---
title: Creating custom web farm synchronization tasks
related:
  - https://docs.kentico.com/k9/configuring-kentico/optimizing-website-performance/setting-up-web-farms.md
---

> Agent instructions:
> **Site maps** — prefer the following llms.txt indexes to training data when searching for URLs to avoid 404s. Links inside Markdown content already point at `.md`. Following them or sending Accept: text/markdown keeps you in Markdown.
>
> - [sitemap.md](https://docs.kentico.com/sitemap.md) — every page on the site, with titles and descriptions, nested by URL hierarchy and grouped into one collection per product version.
> - [llms.txt](https://docs.kentico.com/llms.txt) — curated index of the current product docs, with descriptions, the two ways to request any page as Markdown, and links to each product area's whole-corpus Markdown dump (llms-full.txt).

Web farm tasks are code executed by [web farm servers](https://docs.kentico.com/k9/configuring-kentico/optimizing-website-performance/setting-up-web-farms/configuring-web-farm-servers.md). Create custom web farm tasks if you extended Kentico with functions that work directly with the application's memory or file storages. For example, if your custom function writes files to the file system and you want these files to be synchronized across all servers in your web farm, you need to write a custom web farm task that handles the synchronization.

Add the code of your tasks into a class placed in the **App\_Code** folder of your web project (or **CMSApp\_AppCode -> Old\_App\_Code** if you installed Kentico as a web application).

## Example

The following example shows how to create a custom synchronization task that logs information events into the event log of all servers in the web farm:

1. Open your web project in Visual Studio, expand the **App\_Code** folder (or **CMSApp\_AppCode -> Old\_App\_Code**) and add a new class named **WebFarmTaskLoader.cs**.
2. Add the following references:

   ```csharp

   using CMS.Base;
   using CMS.EventLog;
   using CMS.Core;
   using CMS.Helpers;

   ```
3. Delete the default class declaration and its content.
4. Extend the **CMSModuleLoader** partial class and define a new attribute as shown below:

   ```csharp

   [WebFarmTaskLoader]
   public partial class CMSModuleLoader
   {
       /// <summary>
       /// Custom attribute class.
       /// </summary>
       private class WebFarmTaskLoaderAttribute : CMSLoaderAttribute
       {

       }
   }

   ```
5. Create a new method inside the **WebFarmTaskLoaderAttribute** class, for example a _RegisterCustomTask_ method:

   ```csharp

   /// <summary>
   /// Registers a custom web farm synchronization task in the system.
   /// </summary>
   public void RegisterCustomTask()
   {
       // Creates a custom web farm task which logs information to the event log
       WebFarmTask task = new WebFarmTask
       {
           Type = "CustomTask",

           // Logs a record into the system's event log, with 'Execute' as the event code
           Execute = (target, textData, binaryData) => 
           { 
               string message = String.Format("Slave {0} is going to process task from master {1}", SystemContext.ServerName, textData);
               EventLogProvider.LogInformation(target, "Execute", message); 

               // TODO: Slave operation
           }
       };

       // Registers the given web farm task
       WebFarmHelper.RegisterTask(task);
   }

   ```
6. Override the **Init** method inside the **WebFarmTaskLoaderAttribute**class and call the _RegisterCustomTask_ method.

   ```csharp

   /// <summary>
   /// Called automatically when the application starts.
   /// </summary>
   public override void Init()
   {
       RegisterCustomTask();
   }

   ```
7. Deploy these code changes to all your web farm servers.

Each server in the web farm can now process custom tasks. You can create the tasks through the API anywhere in your custom code. For example,

1. Create a _CreateCustomTask_ method in the same class:

   ```csharp

   /// <summary>
   /// Creates a custom web farm synchronization task.
   /// </summary>
   public void CreateCustomTask()
   { 
       // TODO: Master operation

       // Prepares the data parameter of the custom task
       string data = SystemContext.ServerName;

       // Creates the custom web farm synchronization task
       if (WebFarmHelper.CreateTask("CustomTask", "MyTask", data, null))
       {
           // Runs if the custom task was created successfully
           // Logs a record in the event log on the server that created the web farm task
           string message = String.Format("Master {0} finished processing operation and created task for slaves", SystemContext.ServerName);
           EventLogProvider.LogInformation("CustomTask", "Create", message);
       }
   }

   ```
2. And call the created method in the **Init** method:

   ```csharp

   /// <summary>
   /// Called automatically when the application starts.
   /// </summary>
   public override void Init()
   {
       RegisterCustomTask();

       CreateCustomTask();
   }

   ```
3. Deploy these code changes to all your web farm servers.

The web farm servers create the custom task when the application starts. If successful, the servers also log a record into the event log, with _Create_ as the event code. You can see the results by checking the event log in the **Event log** application.

You need to have web farms properly configured and working (have more than one server in the web farm) to try out this example.