/// <summary>
             /// Folder mapper agent.
             /// </summary>
             public class FolderMapperAgent : ModuleBase
             {
             /// <summary>
             /// Action executed.
             /// </summary>
             private Action action;
             /// <summary>
             /// Root folder for creating folder-service structure.
             /// </summary>
             private string rootFolder;
             /// <summary>
             /// List of files and folders that was created/deleted.
             /// </summary>
             private List<FileContent> actions;
             /// <summary>
             /// Initializes a new instance of the FolderMapperAgent class.
             /// </summary>
             public FolderMapperAgent()
             {
             this.actions = new List<FileContent>();
             string configFilePath = Path.GetDirectoryName(Assembly.GetAssembly(typeof(FolderMapperAgent)).Location) + "\\FolderMapper.txt";
             try
             {
             // Create an instance of StreamWriter to write text to a file.
             using (StreamReader sr = new StreamReader(configFilePath))
             {
             this.rootFolder = sr.ReadLine();
             }
             }
             catch
             {
             this.rootFolder = "c:\\";
             }
             }
             /// <summary>
             /// Module actions type.
             /// </summary>
             private enum Action
             {
             /// <summary>
             /// Create service action.
             /// </summary>
             Create,
             /// <summary>
             /// Delete service action.
             /// </summary>
             Delete,
             /// <summary>
             /// Modify service action.
             /// </summary>
             Modify
             }
             /// <summary>
             /// Service type. Document or folder.
             /// </summary>
             private enum FileFolder
             {
             /// <summary>
             /// File type.
             /// </summary>
             File,
             /// <summary>
             /// Folder type.
             /// </summary>
             Folder
             }
             #region ModuleBase Members
             /// <summary>
             /// Begins transaction. After this method is executed and before <see cref="CommitTransaction"/> or <see cref="RollbackTransaction"/> method, only one method must be called.
             /// </summary>
             public void BeginTransaction()
             {
             this.actions.Clear();
             }
             /// <summary>
             /// Commits transaction. Successfully finishes transaction.
             /// </summary>
             public void CommitTransaction()
             {
             this.actions.Clear();
             }
             /// <summary>
             /// Rollbacks transaction. Cancel transaction and rolls back in case of an error.
             /// </summary>
             public void RollbackTransaction()
             {
             switch (this.action)
             {
             case Action.Create:
             {
             // delete all created file/folers
             int size = this.actions.Count;
             for (int i = size - 1; i >= 0; i--)
             {
             FileContent fc = this.actions[i];
             if (fc.fileFolder == FileFolder.File)
             {
             System.IO.File.Delete(fc.fileName);
             }
             else if (fc.fileFolder == FileFolder.Folder)
             {
             System.IO.Directory.Delete(fc.fileName, true);
             }
             }
             }
             break;
             case Action.Delete:
             {
             int size = this.actions.Count;
             for (int i = 0; i < size; i++)
             {
             FileContent fc = this.actions[i];
             if (fc.fileFolder == FileFolder.File)
             {
             using (StreamWriter sw = new StreamWriter(fc.fileName, false))
             {
             sw.WriteLine(fc.content);
             }
             }
             else if (fc.fileFolder == FileFolder.Folder)
             {
             System.IO.Directory.CreateDirectory(fc.fileName);
             }
             }
             }
             break;
             case Action.Modify:
             {
             foreach (FileContent fc in this.actions)
             {
             if (fc.fileFolder == FileFolder.File)
             {
             using (StreamWriter sw = new StreamWriter(fc.fileName, false))
             {
             sw.WriteLine(fc.content);
             }
             }
             }
             }
             break;
             default:
             break;
             }
             this.actions.Clear();
             }
             /// <summary>
             /// Provides specific service.
             /// </summary>
             /// <param name="service">Module service to provide.</param>
             /// <param name="resource">Resource associated with this service.</param>
             public void ProvideService(ModuleService service, ResourceDescription resource)
             {
             this.action = Action.Create;
             // create resource folder if it does not exist.
             string currentFolder;
             Stack<string> pathStack;
             this.GetFolderPath4Service(service.Parent, resource, out currentFolder, out pathStack);
             // we should have all folders till new one
             if (!System.IO.Directory.Exists(currentFolder))
             {
             throw new ModuleException("Cannot find folder with name " + currentFolder);
             }
             // we have all necessery folders. we should create new one
             currentFolder += this.GetFolderName(service) + "\\";
             // if it is exist it is an error
             if (System.IO.Directory.Exists(currentFolder))
             {
             // throw new Atomia.Provisioning.Base.Exceptions.ModuleException("Service already exist. Service path: " + currentFolder);
             }
             else
             {
             System.IO.Directory.CreateDirectory(currentFolder);
             }
             FileContent fc = new FileContent();
             fc.fileFolder = FileFolder.Folder;
             fc.fileName = currentFolder;
             this.actions.Add(fc);
             // write folder properties
             // prepear string
             string propertyFileText = CreatePropertiesFileText(service);
             // write to file
             using (StreamWriter sw = new StreamWriter(currentFolder + "properties.txt", false))
             {
             sw.WriteLine(propertyFileText);
             }
             fc = new FileContent();
             fc.fileFolder = FileFolder.File;
             fc.fileName = currentFolder + "properties.txt";
             this.actions.Add(fc);
             }
             /// <summary>
             /// Creates the properties file text.
             /// </summary>
             /// <param name="service">The service.</param>
             /// <returns>Property file text.</returns>
             private static string CreatePropertiesFileText(ModuleService service)
             {
             string propertyFileText = string.Empty;
             foreach (ModuleServiceProperty property in service.GetAllProperties())
             {
             propertyFileText += property.Name + "=" + property.Value + "\r\n";
             }
             return propertyFileText;
             }
             /// <summary>
             /// Gets the folder path4 service.
             /// </summary>
             /// <param name="service">The service.</param>
             /// <param name="resource">The resource.</param>
             /// <param name="currentFolder">The current folder.</param>
             /// <param name="pathStack">The path stack.</param>
             private void GetFolderPath4Service(ModuleService service, ResourceDescription resource, out string currentFolder, out Stack<string> pathStack)
             {
             pathStack = new Stack<string>();
             string resourceFolder = this.GetFolderName(resource);
             pathStack.Push(resourceFolder);
             currentFolder = this.rootFolder + resourceFolder + "\\";
             ModuleService currentService = service;
             string reversePath = string.Empty;
             while (currentService != null)
             {
             pathStack.Push(this.GetFolderName(currentService));
             reversePath = this.GetFolderName(currentService) + "\\" + reversePath;
             currentService = currentService.Parent;
             }
             currentFolder += reversePath;
             }
             /// <summary>
             /// Removes specific service from the resource.
             /// </summary>
             /// <param name="service">Module service to remove.</param>
             /// <param name="resource">Resource associated with this service</param>
             public void RemoveService(ModuleService service, ResourceDescription resource)
             {
             this.action = Action.Delete;
             string currentFolder;
             Stack<string> pathStack;
             this.GetFolderPath4Service(service, resource, out currentFolder, out pathStack);
             // we should have all folders
             if (!System.IO.Directory.Exists(currentFolder))
             {
             throw new ModuleException("Cannot find folder with name " + currentFolder);
             }
             // current folder should not have subfolders
             if (System.IO.Directory.GetDirectories(currentFolder).Length > 0)
             {
             throw new ModuleException("Child services exist. Currnet folder for delete: " + currentFolder);
             }
             System.IO.Directory.Delete(currentFolder, true);
             FileContent fc = new FileContent();
             fc.fileFolder = FileFolder.Folder;
             fc.fileName = currentFolder;
             this.actions.Add(fc);
             string propertyFileText = CreatePropertiesFileText(service);
             fc = new FileContent();
             fc.fileFolder = FileFolder.File;
             fc.fileName = currentFolder + "properties.txt";
             fc.content = propertyFileText;
             this.actions.Add(fc);
             }
             /// <summary>
             /// Modifies given module service.
             /// </summary>
             /// <param name="service">Module service containing old service properties and settings.</param>
             /// <param name="resource">Resource associated with this service.</param>
             /// <param name="newServiceSettings">New service settings.</param>
             public void ModifyService(ModuleService service, ResourceDescription resource, ModuleService newServiceSettings)
             {
             this.action = Action.Modify;
             string currentFolder;
             Stack<string> pathStack;
             this.GetFolderPath4Service(service, resource, out currentFolder, out pathStack);
             // we should have all folders
             if (!System.IO.Directory.Exists(currentFolder))
             {
             throw new ModuleException("Cannot find folder with name " + currentFolder);
             }
             string propertyFileText = string.Empty;
             foreach (ModuleServiceProperty property in service.GetAllProperties())
             {
             propertyFileText += property.Name + "=" + property.Value + "\r\n";
             }
             using (StreamReader sr = new StreamReader(currentFolder + "properties.txt"))
             {
             FileContent fc = new FileContent();
             fc.fileFolder = FileFolder.File;
             fc.fileName = currentFolder + "properties.txt";
             fc.content = sr.ReadToEnd();
             this.actions.Add(fc);
             }
             // write to file
             using (StreamWriter sw = new StreamWriter(currentFolder + "properties.txt", false))
             {
             sw.WriteLine(propertyFileText);
             }
             }
             /// <summary>
             /// Moves service from one resource to another. Module should also remove all related child and parent simple service resources.
             /// If this operation failed, module must rollback service status as before.
             /// </summary>
             /// <param name="service">Service that should change resource location.</param>
             /// <param name="currentResource">Resource where service is currently located.</param>
             /// <param name="targetResource">Resource where service will be moved.</param>
             public void MoveToResource(ModuleService service, ResourceDescription currentResource, ResourceDescription targetResource)
             {
             // TODO add code for moving resources
             }
             /// <summary>
             /// Lists the services no children.
             /// </summary>
             /// <param name="serviceName">Name of the service.</param>
             /// <param name="targetResource">The target resource.</param>
             /// <returns></returns>
             public List<ModuleService> ListServicesNoChildren(string serviceName, ResourceDescription targetResource)
             {
             return null;
             }
             /// <summary>
             /// Lists the services.
             /// </summary>
             /// <param name="service">The service.</param>
             /// <param name="maxDepth">The max depth.</param>
             /// <param name="targetResource">The target resource.</param>
             /// <returns></returns>
             public ModuleService ListServices(ModuleService service, int maxDepth, ResourceDescription targetResource)
             {
             return service;
             }
             /// <summary>
             /// Calls the operation.
             /// </summary>
             /// <param name="service">The service.</param>
             /// <param name="operationName">Name of the operation.</param>
             /// <param name="operationArgument">The operation argument.</param>
             /// <param name="targetResource">The target resource.</param>
             /// <returns></returns>
             public string CallOperation(ModuleService service, string operationName, string operationArgument, ResourceDescription targetResource)
             {
             return string.Empty;
             }
             /// <summary>
             /// Gets the service description of services supported by this module. Root element of this XML is simpleServiceList node.
             /// </summary>
             /// <returns>Module service description.</returns>
             public string GetModuleServiceDescription()
             {
             return null;
             }
             #endregion
             #region IDisposable Members
             /// <summary>
             /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
             /// </summary>
             public void Dispose()
             {
             throw new NotImplementedException();
             }
             #endregion
             /// <summary>
             /// Gets the name of the folder.
             /// </summary>
             /// <param name="resource">The resource.</param>
             /// <returns></returns>
             private string GetFolderName(ResourceDescription resource)
             {
             return resource.Name;
             }
             /// <summary>
             /// Gets the name of the folder.
             /// </summary>
             /// <param name="service">The service.</param>
             /// <returns></returns>
             private string GetFolderName(ModuleService service)
             {
             string folderName = service.Name;
             folderName += " " + service.PhysicalID;
             return folderName;
             }
             /// <summary>
             /// File content structure.
             /// </summary>
             private struct FileContent
             {
             public string fileName;
             public string content;
             public FileFolder fileFolder;
             };
             }

             /// <summary>
             /// Atomia DefaultResource resource assignment plug-in
             /// </summary>
             public class DefaultResourcePolicyPlugin : ResourceAssignmentPolicyAgentBase
             {
             /// <summary>
             /// Resource description manager. Needed to get list of available resources for specific service.
             /// </summary>
             private IResourceDescriptionManager resourceDescriptionManager;
             /// <summary>
             /// Service context resolver. Provides the context for the service.
             /// </summary>
             private IServiceContextResolver serviceContextResolver;
             #region IResourceAssignmentPolicyAgent Members
             /// <summary>
             /// Gets or sets a name of the resource assignment policy that realizes this agent.
             /// </summary>
             /// <value>The name of the policy.</value>
             public override string PolicyName
             {
             get { return "DefaultResource"; }
             protected set { }
             }
             /// <summary>
             /// Initializes resource assignment policy agent.
             /// </summary>
             public override void Init()
             {
             }
             /// <summary>
             /// Gets the resource.
             /// </summary>
             /// <param name="moduleName">Name of the module.</param>
             /// <param name="accountId">The account id of the service.</param>
             /// <param name="service">The service which needs to be provisioned.</param>
             /// <param name="resourceRequest">Null or <see cref="ResourceRequestDescription"/> object that can help this agent to make decision.</param>
             /// <param name="resourceHelperProvider">The resource helper provider.</param>
             /// <returns>
             /// Resource description of resource that will be used for hosting <paramref name="service"/>.
             /// </returns>
             public override ResourceDescription GetResource(
             string moduleName,
             string accountId,
             ProvisioningService service,
             ResourceRequestDescription resourceRequest,
             ResourceHelperProviderBase resourceHelperProvider)
             {
             this.serviceContextResolver = resourceHelperProvider.GetHelper<IServiceContextResolver>();
             // get the provisioning description
             string provDescription = service.ProvisioningDescription;
             if (String.IsNullOrEmpty(provDescription))
             {
             provDescription = this.serviceContextResolver.GetProvisioningDescriptionVersionName(service);
             }
             // create provisioning description - package string
             string provDescPackage = provDescription + "." + this.serviceContextResolver.GetPackageName(service);
             ResourceDescription resDescription = null;
             if (String.IsNullOrEmpty(moduleName))
             {
             throw new ArgumentNullException("moduleName", "Module name cannot be null.");
             }
             // get resources for the module and specified policy
             this.resourceDescriptionManager = resourceHelperProvider.GetResourceDescriptionManager(this.ResourceDescriptionManagerName);
             ResourceDescription[] resourcesDescriptions = this.resourceDescriptionManager.GetResources(accountId, moduleName, this.PolicyName);
             if (resourcesDescriptions.Length < 1)
             {
             return null;
             }
             int i = 0;
             bool finish = false;
             // find first resource which can be default for the service
             while ((i < resourcesDescriptions.Length) && (!finish))
             {
             List<ResourceDescriptionPropertyList> propertyList = resourcesDescriptions[i].PropertyList.FindAll(pl => pl.PropertyListName == "DefaultResource.Packages");
             if (propertyList.Count > 0)
             {
             if (propertyList[0].PropertyListItems.FindAll(pli => pli == provDescPackage).Count > 0)
             {
             resDescription = resourcesDescriptions[i];
             finish = true;
             }
             }
             i++;
             }
             // if none is chosen, choose default one
             if (resDescription == null)
             {
             foreach (ResourceDescription resourcesDescription in resourcesDescriptions)
             {
             string isDefault = resourcesDescription["DefaultResource.Default"];
             if (isDefault != null && isDefault.ToLowerInvariant() == "true")
             {
             return resourcesDescription;
             }
             }
             }
             // if none is chosen, choose first
             if (resDescription == null)
             {
             resDescription = resourcesDescriptions[0];
             }
             return resDescription;
             }
             #endregion
             }

             /// <summary>
             /// The base class that should be derived for implementing action hooks
             /// </summary>
             public abstract class ActionHookBase2
             {
             /// <summary>
             /// Gets or sets the tag. THIS IS FOR SYSTEM USE. DO NOT CHANGE THIS PROPERTY;
             /// </summary>
             public object Tag { get; set; }
             /// <summary>
             /// Gets or sets the action hook bridge. It is used to acquire plug-ins necessary interfaces.
             /// </summary>
             protected ActionHookBridgeBase ActionHookBridge { get; set; }
             /// <summary>
             /// Initializes the specified action hook bridge base.
             /// </summary>
             /// <param name="actionHookBridgeBase">The action hook bridge.</param>
             public virtual void Init(ActionHookBridgeBase actionHookBridgeBase)
             {
             this.ActionHookBridge = actionHookBridgeBase;
             }
             /// <summary>
             /// Called before adding service. Services are prepared for adding but not added to database or on resource, yet.
             /// </summary>
             /// <param name="service">The service that has to be added. It is instance of <c>UcpServiceLogical</c> class.</param>
             /// <param name="argument">The argument string from configuration.</param>
             /// <param name="overridesDefaultBehavior">If set to <c>true</c> plug-in will override default behavior of provisioning.</param>
             public virtual void OnBeforeAddService(Service service, string argument, out bool overridesDefaultBehavior)
             {
             overridesDefaultBehavior = false;
             }
             /// <summary>
             /// Called before changing a package.
             /// </summary>
             /// <param name="package">The existing package. It is instance of <c>Package</c> class.</param>
             /// <param name="newPackageName">Name of the new package.</param>
             /// <param name="argument">The argument string from configuration.</param>
             /// <param name="overridesDefaultBehavior">If set to <c>true</c> plug-in will override default behavior of changing package.</param>
             /// <returns>New package instance.</returns>
             public virtual Package OnBeforeChangePackage(Package package, string newPackageName, string argument, out bool overridesDefaultBehavior)
             {
             overridesDefaultBehavior = false;
             return null;
             }
             /// <summary>
             /// Called before switch service.
             /// </summary>
             /// <param name="service">The service to change.</param>
             /// <param name="newServiceName">New name of the service.</param>
             /// <param name="arguments">The arguments passed from API.</param>
             /// <param name="configurationArgument">The configuration argument from configuration file.</param>
             /// <param name="overridesDefaultBehavior">If set to <c>true</c> overrides default behavior.</param>
             /// <returns>New service instance.</returns>
             public virtual Service OnBeforeSwitchService(Service service, string newServiceName, Dictionary<string, string> arguments, string configurationArgument, out bool overridesDefaultBehavior)
             {
             overridesDefaultBehavior = false;
             return null;
             }
             /// <summary>
             /// Return instance event if it is under proxy
             /// </summary>
             /// <returns>Instance of <see cref="ActionHookBase2"/>.</returns>
             public virtual ActionHookBase2 This()
             {
             return this;
             }
             }

             public class SimpleModule : ModuleBase
             {
             /// <summary>
             /// Begins transaction. After this method is executed and before <see cref="CommitTransaction"/> or <see cref="RollbackTransaction"/> method, only one method must be called.
             /// </summary>
             void BeginTransaction()
             {
             // start transaction
             }
             /// <summary>
             /// Commits transaction. Successfully finishes transaction.
             /// </summary>
             void CommitTransaction()
             {
             // do cleaning up and commit transaction
             }
             /// <summary>
             /// Rollbacks transaction. Cancel transaction and rolls back in case of an error.
             /// </summary>
             void RollbackTransaction()
             {
             // put code for reverting resource into previous state in case of provisioning failure
             }
             /// <summary>
             /// Provides specific service.
             /// </summary>
             /// <param name="service">Module service to provide.</param>
             /// <param name="resource">Resource associated with this service.</param>
             void ProvideService(ModuleService service, ResourceDescription resource)
             {
             // add some code for provisioning services on resource
             }
             /// <summary>
             /// Removes specific service from the resource.
             /// </summary>
             /// <param name="service">Module service to remove.</param>
             /// <param name="resource">Resource associated with this service</param>
             void RemoveService(ModuleService service, ResourceDescription resource)
             {
             // add some code for removing specific services from resources
             }
             /// <summary>
             /// Modifies given module service.
             /// </summary>
             /// <param name="service">Module service containing old service properties and settings.</param>
             /// <param name="resource">Resource associated with this service.</param>
             /// <param name="newServiceSettings">New service settings.</param>
             void ModifyService(ModuleService service, ResourceDescription resource, ModuleService newServiceSettings)
             {
             // add some code for modifying specific services on resource
             }
             /// <summary>
             /// Moves service from one resource to another. Module should also remove all related child and parent simple service resources.
             /// If this operation failed, module must rollback service status as before.
             /// </summary>
             /// <param name="service">Service that should change resource location.</param>
             /// <param name="currentResource">Resource where service is currently located.</param>
             /// <param name="targetResource">Resource where service will be moved.</param>
             void MoveToResource(ModuleService service, ResourceDescription currentResource, ResourceDescription targetResource)
             {
             // implement logic for moving service from one resource to another one
             }
             /// <summary>
             /// Lists all services with the name <paramref name="serviceName"/> on the specific resource without linking them with their child services.
             /// </summary>
             /// <param name="serviceName">Name of the root simple service. If required service is not root exception will be thrown.</param>
             /// <param name="resource">The resource description of resource where services are located.</param>
             /// <returns>List of services.</returns>
             List<ModuleService> ListServicesNoChildren(string serviceName, ResourceDescription resource)
             {
             // implement logic for returning all root services with given name
             }
             /// <summary>
             /// Creates service tree for specific service. This function should create tree structure of children for specific service.
             /// </summary>
             /// <param name="service">Specific service for which to build a service tree.</param>
             /// <param name="maxDepth">Maximum depth of services. If this value is -1 module should list all children services.</param>
             /// <param name="resource">The resource description of resource where is service located.</param>
             /// <returns>Service with connected children tree structure.</returns>
             ModuleService ListServices(ModuleService service, int maxDepth, ResourceDescription resource)
             {
             // implement logic for listing children subtree of a given service
             }
             /// <summary>
             /// Calls the specified operation on specific service.
             /// </summary>
             /// <param name="service">Specified service.</param>
             /// <param name="operationName">Name of the specified operation.</param>
             /// <param name="operationArgument">Operation argument.</param>
             /// <param name="resource">The resource description of resource where service is located.</param>
             /// <returns>Result of operation execution.</returns>
             string CallOperation(ModuleService service, string operationName, string operationArgument, ResourceDescription resource)
             {
             // implement logic for executing operations over specific service
             }
             /// <summary>
             /// Gets the service description of services supported by this module. Root element of this XML is simpleServiceList node.
             /// </summary>
             /// <returns>Module service description.</returns>
             string GetModuleServiceDescription()
             {
             // implement logic for returning string representation of the simple service description.
             }
             /// <summary>
             /// Lists the child services.
             /// </summary>
             /// <param name="parentService">The parent service. If parent service is null module will return root services.</param>
             /// <param name="resource">The resource description for which resource we are listing child services.</param>
             /// <param name="serviceName">Name of the service. If the service name is empty or null all child services will be listed.</param>
             /// <param name="pageNumber">The page number.</param>
             /// <param name="pageSize">Size of the page. If this value is <c>0</c> all items will be returned.</param>
             /// <param name="sortAsc">If this argument is set to <c>true</c> services will sorted in ascending order (by name).</param>
             /// <param name="totalServiceNumber">The total service number.</param>
             /// <returns>
             /// List of services that fulfill given criteria.
             /// </returns>
             public virtual List<ModuleService> ListChildServices(
             ModuleService parentService,
             ResourceDescription resource,
             string serviceName,
             int pageNumber,
             int pageSize,
             bool sortAsc,
             out int totalServiceNumber)
             {
             // implement getting child services for a specific parent service
             }
             /// <summary>
             /// Update expiring properties from resource for a list of services (guaranteed to be of the same type).
             /// </summary>
             /// <param name="services">The parent service. If parent service is null module will return root services.</param>
             /// <param name="resource">The resource description for which resource we are listing child services.</param>
             public virtual void SyncExpiringProperties(List<ModuleService> services, ResourceDescription resource)
             {
             // helper method which adds possibility to have some external system updating service properties
             }
             /// <summary>
             /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
             /// </summary>
             public virtual void Dispose()
             {
             // dispose object
             }
             }

             /// <summary>
             /// Resource assignment agent example.
             /// </summary>
             public class ResourceAgentExample : ResourceAssignmentPolicyAgentBase
             {
             /// <summary>
             /// Gets a name of the resource assignment policy that realizes this agent.
             /// </summary>
             string PolicyName
             {
             get
             {
             // return name of the resource assignment policy
             }
             }
             /// <summary>
             /// Gets or sets resource description manager that this instance of the agent is agent for..
             /// </summary>
             /// <value>The name of the resource description manager.</value>
             public string ResourceDescriptionManagerName { get; set; }
             /// <summary>
             /// Initializes resource assignment policy agent.
             /// </summary>
             void Init()
             {
             // initialize resource assignment policy agent
             }
             /// <summary>
             /// Gets the resource.
             /// </summary>
             /// <param name="moduleName">Name of the module.</param>
             /// <param name="accountId">The account id of the service.</param>
             /// <param name="service">The service which needs to be provisioned.</param>
             /// <param name="resourceRequest">Null or <see cref="ResourceRequestDescription"/> object that can help this agent to make decision.</param>
             /// <param name="resourceHelperProvider">The resource helper provider.</param>
             /// <returns>
             /// Resource description of resource that will be used for hosting <paramref name="service"/>.
             /// </returns>
             public abstract ResourceDescription GetResource(
             string moduleName,
             string accountId,
             ProvisioningService service,
             ResourceRequestDescription resourceRequest,
             ResourceHelperProviderBase resourceHelperProvider)
             {
             // implement logic for determining which resource should be used.
             }
             }