protected internal virtual bool DeploymentsDiffer(IDeploymentEntity deployment, IDeploymentEntity saved)
{
if (deployment.GetResources() == null || saved.GetResources() == null)
{
return(true);
}
IDictionary <string, IResourceEntity> resources = deployment.GetResources();
IDictionary <string, IResourceEntity> savedResources = saved.GetResources();
foreach (string resourceName in resources.Keys)
{
IResourceEntity savedResource = savedResources[resourceName];
if (savedResource == null)
{
return(true);
}
if (!savedResource.Generated)
{
IResourceEntity resource = resources[resourceName];
byte[] bytes = resource.Bytes;
byte[] savedBytes = savedResource.Bytes;
if (!StructuralComparisons.StructuralEqualityComparer.Equals(bytes, savedBytes))
{
return(true);
}
}
}
return(false);
}
public virtual Stream Execute(ICommandContext commandContext)
{
if (ReferenceEquals(deploymentId, null))
{
throw new ActivitiIllegalArgumentException("deploymentId is null");
}
if (ReferenceEquals(resourceName, null))
{
throw new ActivitiIllegalArgumentException("resourceName is null");
}
IResourceEntity resource = commandContext.ResourceEntityManager.FindResourceByDeploymentIdAndResourceName(deploymentId, resourceName);
if (resource == null)
{
if (commandContext.DeploymentEntityManager.FindById <IDeployment>(new KeyValuePair <string, object>("id", deploymentId)) == null)
{
throw new ActivitiObjectNotFoundException("deployment does not exist: " + deploymentId, typeof(IDeployment));
}
else
{
throw new ActivitiObjectNotFoundException("no resource found with name '" + resourceName + "' in deployment '" + deploymentId + "'", typeof(System.IO.Stream));
}
}
return(new MemoryStream(resource.Bytes));
}
public void Add(string key, IResourceEntity r)
{
if (!_d.ContainsKey(key))
{
_d.Add(key, r);
}
}
/// <inheritdoc />
public void Deploy(IDictionary <string, IResourceEntity> resources)
{
foreach (string key in resources.Keys)
{
IResourceEntity resource = resources[key];
MemoryStream ms = new MemoryStream(resource.Bytes);
XDocument doc = XDocument.Load(ms, LoadOptions.PreserveWhitespace);
var userTasks = doc.Descendants(XName.Get(BpmnXMLConstants.ELEMENT_TASK_USER, BpmnXMLConstants.BPMN2_NAMESPACE));
XmlNameTable nameTable = doc.CreateReader(ReaderOptions.OmitDuplicateNamespaces).NameTable;
namespaceManager = new XmlNamespaceManager(nameTable);
namespaceManager.AddNamespace(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
var serviceTasks = doc.Descendants(XName.Get(BpmnXMLConstants.ELEMENT_TASK_SERVICE, BpmnXMLConstants.BPMN2_NAMESPACE));
bool changed = deployUserTaskToParallel.ConvertUserTaskToParallel(userTasks)
| deployMultilInstanceExecutionListener.AddMultilinstanceExcutionListener(userTasks)
| deployRuntimeAssigneeExecutionListener.AddRuntimeAssigneeExcutionListener(userTasks)
| deployUserTaskAssigneeListener.AddUserTaskAssignmentListener(userTasks)
| deployServiceTask.AddDefaultImplementation(serviceTasks);
if (changed)
{
MemoryStream saved = new MemoryStream();
doc.Save(saved);
saved.Flush();
saved.Seek(0, SeekOrigin.Begin);
resource.Bytes = saved.ToArray();
saved.Close();
}
ms.Close();
}
}
public virtual void AddResource(IResourceEntity resource)
{
if (resources == null)
{
resources = new Dictionary <string, IResourceEntity>();
}
resources[resource.Name] = resource;
}
/// <summary>
/// 新增资源对象
/// </summary>
/// <param name="token">生命周期token</param>
/// <param name="e">资源实例</param>
public void AddEntity(TransactionToken token, IResourceEntity e)
{
if (!_transd.ContainsKey(token.UniqueID))
{
ResourceCollection rc = new ResourceCollection();
_transd.Add(token.UniqueID, rc);
}
_transd[token.UniqueID].Add(e.ID, e);
}
public virtual IDeploymentBuilder AddBytes(string resourceName, byte[] bytes)
{
IResourceEntity resource = resourceEntityManager.Create();
resource.Name = resourceName;
resource.Bytes = bytes ?? throw new ActivitiIllegalArgumentException("bytes is null");
deployment.AddResource(resource);
return(this);
}
private static void Runable(IResourceEntity resource, bool runable)
{
using (MemoryStream ms = new MemoryStream(resource.Bytes))
{
XDocument doc = XDocument.Load(ms);
XElement process = doc.Descendants(XName.Get(BpmnXMLConstants.ELEMENT_PROCESS, BpmnXMLConstants.BPMN2_NAMESPACE)).First();
process.Attribute(BpmnXMLConstants.ATTRIBUTE_PROCESS_EXECUTABLE).SetValue(runable);
resource.Bytes = Encoding.UTF8.GetBytes(doc.ToString());
}
}
private static TResource Map <TResource>(this IResourceEntity entity)
where TResource : Resource, new()
{
return(new TResource
{
Id = entity.id,
SubcategoryId = entity.resourceSubcategoryId,
Title = entity.title,
Text = entity.text,
CreatedTime = entity.createdTime,
ShortUrl = entity.shortUrl,
});
}
/// <summary>
/// 新增资源对象
/// </summary>
/// <param name="lifeCycleToken">生命周期token</param>
/// <param name="e">资源实例</param>
public void AddEntity(string lifeCycleToken, IResourceEntity e)
{
string key = GenerateKey(e.ID, lifeCycleToken);
if (!_d.ContainsKey(key))
{
_d.Add(key, e);
}
else
{
_d[key] = e;
}
}
public virtual void Runable()
{
foreach (string key in (resources ?? new Dictionary <string, IResourceEntity>()).Keys)
{
IResourceEntity resource = resources[key];
if ((resource.Bytes?.Length).GetValueOrDefault() == 0)
{
continue;
}
Runable(resource, true);
}
}
public virtual IDeploymentBuilder AddInputStream(string resourceName, Stream inputStream)
{
if (inputStream == null)
{
throw new ActivitiIllegalArgumentException("inputStream for resource '" + resourceName + "' is null");
}
byte[] bytes = IoUtil.ReadInputStream(inputStream, resourceName);
IResourceEntity resource = resourceEntityManager.Create();
resource.Name = resourceName;
resource.Bytes = bytes;
deployment.AddResource(resource);
return(this);
}
/// <summary>
/// Called before a resource is updated in the storage layer.
/// </summary>
/// <remarks>
/// Use requestContext.ApiVersion to get the API version of the request.
/// </remarks>
/// <param name="requestContext">The request context.</param>
/// <param name="subscription">The subscription.</param>
/// <param name="existingResource">The existing resource.</param>
/// <param name="updatedResourceDefinition">The updated resource definition.</param>
Task <ResourceOperationStatus> IManagedResourceGroupWideResourceTypeRequestHandler.OnUpdateResource(
RequestContext requestContext,
SubscriptionNotificationDefinition subscription,
IResourceEntity existingResource,
ResourceDefinition updatedResourceDefinition)
{
ArgumentValidator.ValidateNotNull("requestContext", requestContext);
ArgumentValidator.ValidateNotNull("subscription", subscription);
ArgumentValidator.ValidateNotNull("existingResource", existingResource);
ArgumentValidator.ValidateNotNull("updatedResourceDefinition", updatedResourceDefinition);
// TODO: Implement custom logic to update the resource.
return(Task.FromResult(ResourceOperationStatus.CompleteSynchronously(existingResource)));
}
/// <summary>
/// Called after a resource is created in the storage layer.
/// </summary>
/// <remarks>
/// Use requestContext.ApiVersion to get the API version of the request.
/// </remarks>
/// <param name="requestContext">The request context.</param>
/// <param name="subscription">The subscription.</param>
/// <param name="createdResource">The created resource.</param>
async Task <ResourceOperationStatus> IManagedResourceGroupWideResourceTypeRequestHandler.OnAfterInsertResource(
RequestContext requestContext,
SubscriptionNotificationDefinition subscription,
IResourceEntity createdResource)
{
ArgumentValidator.ValidateNotNull("requestContext", requestContext);
ArgumentValidator.ValidateNotNull("subscription", subscription);
ArgumentValidator.ValidateNotNull("createdResource", createdResource);
// Enforce quotas for nested resources.
ServiceQuota[] quotas = ServiceQuota.CreateSubscriptionQuotaFromSubscriptionNotification(
createdResource.SubscriptionId,
subscription);
// Count aggregated quota for nested resources for the entire subscription.
int nestedResourceCountLimit = 0;
quotas.ToList().ForEach(quota => nestedResourceCountLimit += quota.NestedResourceCountLimit);
int resourceCount = 0;
DataContinuationToken continuationToken = null;
do
{
var result = await this.resourceProviderStorage
.ResourceDataProvider
.FindResources(
createdResource.SubscriptionId,
createdResource.QualifiedTypeName,
continuationToken : continuationToken);
resourceCount += result.Entities.Length;
continuationToken = result.ContinuationToken;
} while (continuationToken != null);
// TODO: Apply custom quota enforcement logic here.
// Check that there is sufficient quota to create additional resources (enforce the resource count)
if (nestedResourceCountLimit < resourceCount)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, ResponseErrorMessages.InsufficientResourceQuota, createdResource.Name);
throw new ResourceProviderException(errorMessage, ResponseErrorCode.InsufficientQuota.ToString(), HttpStatusCode.BadRequest);
}
// TODO: Add custom nested resource creation logic here.
return(ResourceOperationStatus.CompleteSynchronously(createdResource));
}
private BpmnParse CreateBpmnParseFromResource(BpmnDeploymentHelper helper, IResourceEntity resource)
{
string resourceName = resource.Name;
MemoryStream inputStream = new MemoryStream(resource.Bytes);
var changed = helper.AddCamundaNamespace(inputStream);
if (changed.Item1)
{
resource.Bytes = changed.Item2.ToArray();
inputStream = changed.Item2;
}
;
inputStream.Seek(0, SeekOrigin.Begin);
BpmnParse bpmnParse = bpmnParser.CreateParse().SourceInputStream(inputStream).SetSourceSystemId(resourceName).SetName(resourceName);
bpmnParse.Deployment = deployment;
if (deploymentSettings != null)
{
// Schema validation if needed
if (deploymentSettings.ContainsKey(Cmd.DeploymentSettingsFields.IS_BPMN20_XSD_VALIDATION_ENABLED))
{
bpmnParse.ValidateSchema = Convert.ToBoolean(deploymentSettings[Cmd.DeploymentSettingsFields.IS_BPMN20_XSD_VALIDATION_ENABLED]);
}
// Process validation if needed
if (deploymentSettings.ContainsKey(Cmd.DeploymentSettingsFields.IS_PROCESS_VALIDATION_ENABLED))
{
bpmnParse.ValidateProcess = Convert.ToBoolean(deploymentSettings[Cmd.DeploymentSettingsFields.IS_PROCESS_VALIDATION_ENABLED]);
}
}
else
{
// On redeploy, we assume it is validated at the first deploy
bpmnParse.ValidateSchema = false;
bpmnParse.ValidateProcess = false;
}
bpmnParse.Execute();
return(bpmnParse);
}
public virtual IDeploymentBuilder AddString(string resourceName, string text)
{
if (text is null)
{
throw new ActivitiIllegalArgumentException("text is null");
}
IResourceEntity resource = resourceEntityManager.Create();
resource.Name = resourceName;
try
{
resource.Bytes = text.GetBytes(DEFAULT_ENCODING);
}
catch (Exception e)
{
throw new ActivitiException("Unable to get process bytes.", e);
}
deployment.AddResource(resource);
return(this);
}
/// <summary>
/// Called when a proxy request is made on a managed resource.
/// </summary>
/// <param name="requestContext">The request context.</param>
/// <param name="subscription">The subscription notification.</param>
/// <param name="resourceEntity">The resource entity.</param>
/// <param name="proxySuffix">The proxy suffix containing the request URI segments that up to the last segment of the resource identifier.</param>
/// <returns>
/// An <see cref="OperationStatus" /> indicating the status of the operation and the update
/// state of the <see cref="IResourceEntity" /> instance.
/// </returns>
/// <remarks>
/// Use requestContext.ApiVersion to get the API version of the request.
/// </remarks>
public Task <ProxyOperationStatus> OnProxyRequest(RequestContext requestContext, SubscriptionNotificationDefinition subscription, IResourceEntity resourceEntity, string proxySuffix)
{
throw new NotImplementedException();
}
/// <summary>
/// Called before the resource is inserted in the storage layer.
/// </summary>
/// <param name="requestContext">The request context.</param>
/// <param name="subscription">The subscription.</param>
/// <param name="requestResourceEntity">The request resource entity.</param>
/// <returns>
/// A <see cref="ResourceDefinition" /> that has been validated and projected to the desired
/// state so that it may be safely inserted in the storage layer.
/// </returns>
/// <remarks>
/// Use requestContext.ApiVersion to get the API version of the request.
/// If the requestResourceEntity is invalid, throw a <see cref="ResourceProviderException" /> to fail the request.
/// </remarks>
public Task OnBeforeInsertResource(RequestContext requestContext, SubscriptionNotificationDefinition subscription, IResourceEntity requestResourceEntity)
{
// TODO: (florbe) Validate the resource definition.
// TODO: (florbe) Project the resource definition Properties section to the desired internal format.
return(Task.FromResult(false));
}
/// <summary>
/// Called for each resource that is returned to the client.
/// </summary>
/// <param name="requestContext">The request context.</param>
/// <param name="resource">The resource to project.</param>
/// <remarks>
/// Use requestContext.ApiVersion to get the API version of the request.
/// Return the unmodified input resource parameter if no projection is necessary.
/// </remarks>
Task IManagedResourceGroupWideResourceTypeRequestHandler.OnProjectResource(RequestContext requestContext, IResourceEntity resource)
{
// TODO: Customize resource.Properties or resource.InternalState before returning the resource to the caller.
return(Task.FromResult(false));
}
/// <summary>
/// Called when resource is deleted.
/// </summary>
/// <remarks>
/// A request context is not necessary to delete a resource.
/// </remarks>
/// <param name="deletedResource">The deleted resource.</param>
Task <ResourceOperationStatus> IManagedResourceGroupWideResourceTypeRequestHandler.OnDeleteResource(IResourceEntity deletedResource)
{
ArgumentValidator.ValidateNotNull("deletedResource", deletedResource);
// TODO: Add custom nested resource deletion logic here.
return(Task.FromResult(ResourceOperationStatus.CompleteSynchronously(deletedResource)));
}
/// <summary>
/// Called when a proxy request is made on a managed resource.
/// </summary>
/// <param name="requestContext">The request context.</param>
/// <param name="subscription">The subscription notification.</param>
/// <param name="resourceEntity">The resource entity.</param>
/// <param name="proxySuffix">The proxy suffix containing the request URI segments that up to the last segment of the resource identifier.</param>
/// <returns>
/// An <see cref="OperationStatus" /> indicating the status of the operation and the update
/// state of the <see cref="IResourceEntity" /> instance.
/// </returns>
/// <remarks>
/// Use requestContext.ApiVersion to get the API version of the request.
/// </remarks>
public Task <ProxyOperationStatus> OnProxyRequest(RequestContext requestContext, SubscriptionNotificationDefinition subscription, IResourceEntity resourceEntity, string proxySuffix)
{
// TODO: We need to return an appropriate RPE!!!
throw new NotImplementedException();
}
/// <summary>
/// Called when resource is suspended.
/// </summary>
/// <remarks>
/// A request context is not necessary to suspend a resource.
/// </remarks>
/// <param name="suspendedResource">The suspended resource.</param>
Task <IResourceEntity> IManagedResourceGroupWideResourceTypeRequestHandler.OnSuspendResource(IResourceEntity suspendedResource)
{
ArgumentValidator.ValidateNotNull("suspendedResource", suspendedResource);
// TODO: Implement custom logic to suspend resource operation.
return(Task.FromResult(suspendedResource));
}
/// <summary>
/// Called for each resource that is returned to the client.
/// </summary>
/// <param name="requestContext">The request context.</param>
/// <param name="resource">The resource to project.</param>
/// <remarks>
/// Use requestContext.ApiVersion to get the API version of the request.
/// Return the unmodified input resource parameter if no projection is necessary.
/// </remarks>
Task IManagedResourceGroupWideResourceTypeRequestHandler.OnProjectResource(RequestContext requestContext, IResourceEntity resource)
{
// TODO: Customize any properties before returning the resource to the caller.
// In case no customization is needed just return the received resource.
return(Task.FromResult(false));
}
