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)); }