Example #1
0
        private async Task <ServiceInfo> CreateNewWorkerServiceAsync()
        {
            var count = await this.GetWorkerCountAsync() + 1;

            var appName         = this.Context.CodePackageActivationContext.ApplicationName;
            var serviceBaseName = "Worker";
            var serviceName     = $"{serviceBaseName}{count}";
            var serviceAddress  = $"{appName}/{serviceName}";
            var serviceType     = $"{serviceBaseName}Type";

            using (var client = new FabricClient())
            {
                var serviceDescriptor = new StatelessServiceDescription()
                {
                    ApplicationName            = new Uri(appName),
                    ServiceName                = new Uri(serviceAddress),
                    ServiceTypeName            = serviceType,
                    PartitionSchemeDescription = new SingletonPartitionSchemeDescription()
                };
                await client.ServiceManager.CreateServiceAsync(serviceDescriptor);
            }

            return(new ServiceInfo
            {
                ServiceAddress = serviceAddress,
                ServiceName = serviceName
            });
        }
Example #2
0
        internal StatelessServiceDescription GetStatelessDescription(Job j)
        {
            var ser = JsonSerializer.Create();

            var sw = new StringWriter();

            ser.Serialize(sw, j);

            var desc = new StatelessServiceDescription()
            {
                ApplicationName            = new Uri("fabric:/Compute2"),
                DefaultMoveCost            = MoveCost.High,
                ServiceName                = new Uri(string.Format("fabric:/Compute2/ComputeInstance{0}", System.DateTime.Now.Ticks)),
                ServiceTypeName            = "StatelessComputeServiceType",
                PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                InstanceCount              = 1,
                InitializationData         = Encoding.UTF8.GetBytes(sw.ToString())
            };

            var metric = new StatelessServiceLoadMetricDescription()
            {
                DefaultLoad = 1,
                Name        = "TCU",
                Weight      = ServiceLoadMetricWeight.Medium
            };

            desc.Metrics.Add(metric);

            return(desc);
        }
        protected override void ProcessRecord()
        {
            PartitionSchemeDescription partitionSchemeDescription;
            ServiceDescription         serviceDescription;
            var client = new ServiceFabricClientBuilder().ConnectAsync(ClusterEndPoint, ThumbPrint).Result;

            if (PartitionSchemeUniformInt64)
            {
                partitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription(PartitionCount, LowKey.ToString(), HighKey.ToString());
            }
            else if (PartitionSchemeNamed)
            {
                partitionSchemeDescription = new NamedPartitionSchemeDescription(PartitionCount, PartitionNames);
            }
            else
            {
                partitionSchemeDescription = new SingletonPartitionSchemeDescription();
            }

            if (Stateless.IsPresent)
            {
                serviceDescription = new StatelessServiceDescription(new ServiceName(ServiceName), ServiceType, partitionSchemeDescription, InstanceCount, initializationData: InitializationData);
            }
            else
            {
                serviceDescription = new StatefulServiceDescription(new ServiceName(ServiceName), ServiceType, partitionSchemeDescription, TargetReplicaSetSize, MinReplicaSetSize, PersistedState, initializationData: InitializationData);
            }

            client.Services.CreateServiceAsync(ApplicationId, serviceDescription).Wait();
        }
Example #4
0
        /// <summary>
        /// Provisions a new backend and name it uniquely according to the name in param
        /// </summary>
        /// <param name="backendName"></param>
        /// <returns></returns>
        public async Task ProvisionNewBackend(string backendName)
        {
            Uri serviceName     = new Uri($"{m_appName}/{backendName}");
            var applicationName = new Uri(m_appName);
            var payload         = backendName;
            StatelessServiceDescription serviceDescription = new StatelessServiceDescription()
            {
                ApplicationName            = applicationName,
                ServiceTypeName            = "BackgroundStatelessWorkerType",
                ServiceName                = serviceName,
                PartitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription(100, 0, 99),
                // to change the number of instaces of this service please change
                //100 to your desired number and similartly change 99
                ServicePackageActivationMode = ServicePackageActivationMode.ExclusiveProcess,
                InitializationData           = Encoding.UTF8.GetBytes($" Backend name is : {payload}")
            };

            //launch service
            try
            {
                using (var fabricClient = new FabricClient())
                {
                    await fabricClient.ServiceManager.CreateServiceAsync(serviceDescription);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// Serializes the object to JSON.
        /// </summary>
        /// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
        /// <param name="obj">The object to serialize to JSON.</param>
        internal static void Serialize(JsonWriter writer, StatelessServiceDescription obj)
        {
            // Required properties are always serialized, optional properties are serialized when not null.
            writer.WriteStartObject();
            writer.WriteProperty(obj.ServiceKind.ToString(), "ServiceKind", JsonWriterExtensions.WriteStringValue);
            writer.WriteProperty(obj.ServiceName, "ServiceName", ServiceNameConverter.Serialize);
            writer.WriteProperty(obj.ServiceTypeName, "ServiceTypeName", JsonWriterExtensions.WriteStringValue);
            writer.WriteProperty(obj.PartitionDescription, "PartitionDescription", PartitionSchemeDescriptionConverter.Serialize);
            writer.WriteProperty(obj.InstanceCount, "InstanceCount", JsonWriterExtensions.WriteIntValue);
            writer.WriteProperty(obj.DefaultMoveCost, "DefaultMoveCost", MoveCostConverter.Serialize);
            writer.WriteProperty(obj.ServicePackageActivationMode, "ServicePackageActivationMode", ServicePackageActivationModeConverter.Serialize);
            if (obj.ApplicationName != null)
            {
                writer.WriteProperty(obj.ApplicationName, "ApplicationName", ApplicationNameConverter.Serialize);
            }

            if (obj.InitializationData != null)
            {
                writer.WriteProperty(obj.InitializationData, "InitializationData", ByteArrayConverter.Serialize);
            }

            if (obj.PlacementConstraints != null)
            {
                writer.WriteProperty(obj.PlacementConstraints, "PlacementConstraints", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.CorrelationScheme != null)
            {
                writer.WriteEnumerableProperty(obj.CorrelationScheme, "CorrelationScheme", ServiceCorrelationDescriptionConverter.Serialize);
            }

            if (obj.ServiceLoadMetrics != null)
            {
                writer.WriteEnumerableProperty(obj.ServiceLoadMetrics, "ServiceLoadMetrics", ServiceLoadMetricDescriptionConverter.Serialize);
            }

            if (obj.ServicePlacementPolicies != null)
            {
                writer.WriteEnumerableProperty(obj.ServicePlacementPolicies, "ServicePlacementPolicies", ServicePlacementPolicyDescriptionConverter.Serialize);
            }

            if (obj.IsDefaultMoveCostSpecified != null)
            {
                writer.WriteProperty(obj.IsDefaultMoveCostSpecified, "IsDefaultMoveCostSpecified", JsonWriterExtensions.WriteBoolValue);
            }

            if (obj.ServiceDnsName != null)
            {
                writer.WriteProperty(obj.ServiceDnsName, "ServiceDnsName", JsonWriterExtensions.WriteStringValue);
            }

            if (obj.ScalingPolicies != null)
            {
                writer.WriteEnumerableProperty(obj.ScalingPolicies, "ScalingPolicies", ScalingPolicyDescriptionConverter.Serialize);
            }

            writer.WriteEndObject();
        }
        public async Task IncreaseDecreaseServiceInstances(bool increase, string appName, string serviceName, string serviceType)
        {
            //string appName = "fabric:/MyApplication";
            //string serviceName = "fabric:/MyApplication/Stateless1";
            //string serviceType = "Stateless1Type";

            using (var fabricClient = new FabricClient())
            {
                if (increase)
                {
                    // Create the stateless service description.  For stateful services, use a StatefulServiceDescription object.
                    StatelessServiceDescription serviceDescription = new StatelessServiceDescription
                    {
                        ApplicationName            = new Uri(appName),
                        InstanceCount              = 1,
                        PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                        ServiceName     = new Uri(serviceName),
                        ServiceTypeName = serviceType
                    };

                    // Create the service instance.
                    try
                    {
                        fabricClient.ServiceManager.CreateServiceAsync(serviceDescription).Wait();
                        ServiceEventSource.Current.ServiceMessage(_serviceContext, "Created service instance {0}", serviceName);
                    }
                    catch (AggregateException ae)
                    {
                        ServiceEventSource.Current.ServiceMessage(_serviceContext, "CreateService failed.");
                        foreach (Exception ex in ae.InnerExceptions)
                        {
                            ServiceEventSource.Current.ServiceMessage(_serviceContext, "HResult: {0} Message: {1}", ex.HResult, ex.Message);
                        }
                    }
                }
                else
                {
                    // Delete a service instance.
                    try
                    {
                        DeleteServiceDescription deleteServiceDescription = new DeleteServiceDescription(new Uri(serviceName));

                        await fabricClient.ServiceManager.DeleteServiceAsync(deleteServiceDescription);

                        ServiceEventSource.Current.ServiceMessage(_serviceContext, "Deleted service instance {0}", serviceName);
                    }
                    catch (AggregateException ae)
                    {
                        ServiceEventSource.Current.ServiceMessage(_serviceContext, "DeleteService failed.");
                        foreach (Exception ex in ae.InnerExceptions)
                        {
                            ServiceEventSource.Current.ServiceMessage(_serviceContext, "HResult: {0} Message: {1}", ex.HResult, ex.Message);
                        }
                    }
                }
            }
        }
        public async Task <IActionResult> Post([FromRoute] string name, [FromBody] EventsProcessorApplicationParams parameters)
        {
            // Determine the number of IoT Hub partitions.
            // The events processing service will be created with the same number of partitions.
            EventHubClient             eventHubClient = EventHubClient.CreateFromConnectionString(parameters.IotHubConnectionString, "messages/events");
            EventHubRuntimeInformation eventHubInfo   = await eventHubClient.GetRuntimeInformationAsync();

            // Application parameters are passed to the Events Processing application instance.
            NameValueCollection appInstanceParameters = new NameValueCollection();

            appInstanceParameters["IotHubConnectionString"]        = parameters.IotHubConnectionString;
            appInstanceParameters["IotHubProcessOnlyFutureEvents"] = parameters.IotHubProcessOnlyFutureEvents;
            appInstanceParameters["PublishDataServiceURLs"]        = parameters.PublishDataServiceURLs;

            ApplicationDescription application = new ApplicationDescription(
                new Uri($"{Names.EventsProcessorApplicationPrefix}/{name}"),
                Names.EventsProcessorApplicationTypeName,
                parameters.Version,
                appInstanceParameters);

            // Create a named application instance
            await this.fabricClient.ApplicationManager.CreateApplicationAsync(application, this.operationTimeout, this.appLifetime.ApplicationStopping);

            // Next, create named instances of the services that run in the application.
            ServiceUriBuilder serviceNameUriBuilder = new ServiceUriBuilder(application.ApplicationName.ToString(), Names.EventsProcessorRouterServiceName);

            StatefulServiceDescription service = new StatefulServiceDescription()
            {
                ApplicationName            = application.ApplicationName,
                HasPersistedState          = true,
                MinReplicaSetSize          = 3,
                TargetReplicaSetSize       = 3,
                PartitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription(eventHubInfo.PartitionCount, 0, eventHubInfo.PartitionCount - 1),
                ServiceName     = serviceNameUriBuilder.Build(),
                ServiceTypeName = Names.EventsProcessorRouterServiceTypeName
            };

            await this.fabricClient.ServiceManager.CreateServiceAsync(service, this.operationTimeout, this.appLifetime.ApplicationStopping);

            if (parameters.PublishDataServiceURLs != null && parameters.PublishDataServiceURLs.Length > 0)
            {
                // Next, create named instances of the services that run in the application.
                serviceNameUriBuilder = new ServiceUriBuilder(application.ApplicationName.ToString(), Names.EventsProcessorExtenderServiceName);

                StatelessServiceDescription extenderService = new StatelessServiceDescription()
                {
                    ApplicationName            = application.ApplicationName,
                    InstanceCount              = 1,
                    PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                    ServiceName     = serviceNameUriBuilder.Build(),
                    ServiceTypeName = Names.EventsProcessorExtenderServiceTypeName
                };

                await this.fabricClient.ServiceManager.CreateServiceAsync(extenderService, this.operationTimeout, this.appLifetime.ApplicationStopping);
            }
            return(this.Ok());
        }
            public override ServiceDescription Build()
            {
                var statelessDescription = new StatelessServiceDescription
                {
                    InstanceCount = this.InstanceCount
                };

                statelessDescription.ApplicationName            = this.ApplicationName;
                statelessDescription.PartitionSchemeDescription = this.PartitionSchemeDescriptionBuilder.Build();
                statelessDescription.ServiceName          = this.ServiceName;
                statelessDescription.ServiceTypeName      = this.ServiceTypeName;
                statelessDescription.PlacementConstraints = this.PlacementConstraints;
                statelessDescription.ServiceDnsName       = this.ServiceDnsName;

                if (this.Correlations != null)
                {
                    foreach (var str in this.Correlations)
                    {
                        statelessDescription.Correlations.Add(ServiceCmdletBase.ParseCorrelation(str));
                    }
                }

                if (this.PlacementPolicies != null)
                {
                    foreach (var str in this.PlacementPolicies)
                    {
                        statelessDescription.PlacementPolicies.Add(ServiceCmdletBase.ParsePlacementPolicy(str));
                    }
                }

                if (this.DefaultMoveCost != null)
                {
                    statelessDescription.DefaultMoveCost = ServiceCmdletBase.ParseMoveCost(this.DefaultMoveCost);
                }

                statelessDescription.ServicePackageActivationMode = this.ServicePackageActivationMode;

                if (this.Metrics != null)
                {
                    foreach (var str in this.Metrics)
                    {
                        statelessDescription.Metrics.Add(ServiceCmdletBase.ParseStatelessMetric(str));
                    }
                }

                if (this.ScalingPolicies != null)
                {
                    foreach (var scale in this.ScalingPolicies)
                    {
                        statelessDescription.ScalingPolicies.Add(scale);
                    }
                }

                return(statelessDescription);
            }
Example #9
0
        public static StatelessServiceDescription GetCloneStateless(this StatelessServiceDescription other)
        {
            StatelessServiceDescription clone = new StatelessServiceDescription()
            {
                InstanceCount = other.InstanceCount
            };

            clone.Metrics.AddRangeNullSafe(other.Metrics.Select(m => (m as StatelessServiceLoadMetricDescription).GetClone()));
            // Copy properties
            clone.CopyFrom(other);
            return(clone);
        }
Example #10
0
        private Task CreateService(string appName)
        {
            StatelessServiceDescription serviceDescription = new StatelessServiceDescription()
            {
                ApplicationName            = new Uri(appName),
                PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                InstanceCount   = 1,
                ServiceTypeName = "MailboxType",
                ServiceName     = new Uri($"{appName}/Mailbox" + new Random().Next(100).ToString())
            };

            return(_fabricClient.ServiceManager.CreateServiceAsync(serviceDescription));
        }
Example #11
0
        public string Get(int instances)
        {
            var    fc      = new FabricClient();
            string appName = this.context.CodePackageActivationContext.ApplicationName;

            StatelessServiceDescription serviceDescription = new StatelessServiceDescription()
            {
                ApplicationName            = new Uri(appName),
                PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                InstanceCount   = 1,
                ServiceTypeName = "MailboxType",
                ServiceName     = new Uri($"{appName}/test1")
            };

            return(fc.ServiceManager.CreateServiceAsync(serviceDescription).ToString());
        }
Example #12
0
        private bool TryCreateStatelessServiceDescription(out StatelessServiceDescription sd)
        {
            sd = null;

            try
            {
                sd = new StatelessServiceDescription();
                sd.ApplicationName = new Uri(this.control.Package.ApplicationAddress, UriKind.Absolute);
                sd.ServiceName     = new Uri(this.control.Package.ServiceAddress, UriKind.Absolute);
                sd.ServiceTypeName = this.control.Package.ServiceType;

                int count;
                if (!this.TryGetData("ServiceStatelessCount", out count))
                {
                    return(false);
                }

                sd.InstanceCount = count;
                // add special case for -1 when running in dev one-box, only start 1 instance
                if (sd.InstanceCount == -1)
                {
                    if (this.control.Cluster.ClusterType == ClusterType.OneBox)
                    {
                        log.Info("special case override of -1 for onebox environment");
                        if (Environment.UserInteractive)
                        {
                            log.Warn("CreateService: special case override of instanceCount==-1 for onebox environment");
                        }
                        sd.InstanceCount = 1;
                    }
                }

                PartitionSchemeDescription psd;
                if (!this.TryCreatePartitionDescription(out psd))
                {
                    return(false);
                }

                sd.PartitionSchemeDescription = psd;
                return(true);
            }
            catch (Exception e)
            {
                log.Error("failed to create StatelessServiceDescription, exception={0}", e.Message);
                return(false);
            }
        }
        public async Task Handle(PeriodEndStoppedEvent message, IMessageHandlerContext context)
        {
            logger.LogDebug($"Received period end stopped event. Details: {message.ToJson()}");

            var fabricClient       = new FabricClient();
            var serviceDescription = new StatelessServiceDescription
            {
                ApplicationName            = new Uri("fabric:/SFA.DAS.Payments.DataLocks.ServiceFabric"),
                PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                ServiceName     = new Uri(ServiceNames.DatalockApprovalsService),
                ServiceTypeName = "SFA.DAS.Payments.DataLocks.ApprovalsServiceType",
                InstanceCount   = instanceCount,
            };

            await fabricClient.ServiceManager.CreateServiceAsync(serviceDescription);

            logger.LogInfo($"Finished period end stopped handler. Details: {message.ToJson()}");
        }
        public async Task <IActionResult> Post([FromRoute] string tenantName, [FromBody] InsightApplicationParams parameters)
        {
            // First create the application instance.
            // This won't actually create the services yet.
            ApplicationDescription application = new ApplicationDescription(
                new Uri($"{Names.InsightApplicationNamePrefix}/{tenantName}"),
                Names.InsightApplicationTypeName,
                parameters.Version);

            await this.fabricClient.ApplicationManager.CreateApplicationAsync(application, this.operationTimeout, this.appLifetime.ApplicationStopping);

            // Now create the data service in the new application instance.
            ServiceUriBuilder          dataServiceNameUriBuilder = new ServiceUriBuilder(application.ApplicationName.ToString(), Names.InsightDataServiceName);
            StatefulServiceDescription dataServiceDescription    = new StatefulServiceDescription()
            {
                ApplicationName            = application.ApplicationName,
                HasPersistedState          = true,
                MinReplicaSetSize          = 3,
                TargetReplicaSetSize       = 3,
                PartitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription(parameters.DataPartitionCount, Int64.MinValue, Int64.MaxValue),
                ServiceName     = dataServiceNameUriBuilder.Build(),
                ServiceTypeName = Names.InsightDataServiceTypeName
            };

            await this.fabricClient.ServiceManager.CreateServiceAsync(dataServiceDescription, this.operationTimeout, this.appLifetime.ApplicationStopping);

            // And finally, create the web service in the new application instance.
            ServiceUriBuilder           webServiceNameUriBuilder = new ServiceUriBuilder(application.ApplicationName.ToString(), Names.InsightWebServiceName);
            StatelessServiceDescription webServiceDescription    = new StatelessServiceDescription()
            {
                ApplicationName            = application.ApplicationName,
                InstanceCount              = parameters.WebInstanceCount,
                PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                ServiceName     = webServiceNameUriBuilder.Build(),
                ServiceTypeName = Names.InsightWebServiceTypeName
            };

            await this.fabricClient.ServiceManager.CreateServiceAsync(webServiceDescription, this.operationTimeout, this.appLifetime.ApplicationStopping);


            return(this.Ok());
        }
        private void TestHelper(Action <StatelessServiceDescription> setup)
        {
            var expected = HelperInstance.CreateDefaultDescription();

            if (setup != null)
            {
                setup(expected);
            }

            using (var pc = new PinCollection())
            {
                NativeTypes.FABRIC_SERVICE_DESCRIPTION_KIND kind;
                IntPtr native = expected.ToNative(pc, out kind);


                var actual = StatelessServiceDescription.CreateFromNative(native);

                Assert.AreEqual(NativeTypes.FABRIC_SERVICE_DESCRIPTION_KIND.FABRIC_SERVICE_DESCRIPTION_KIND_STATELESS, kind);
                HelperInstance.Compare(expected, actual);
            }
        }
        public Task PostStateless(string jobName, int?workload = null)
        {
            string applicationName = this.context.CodePackageActivationContext.ApplicationName;

            StatelessServiceDescription serviceDescription = new StatelessServiceDescription()
            {
                ApplicationName            = new Uri(applicationName),
                InstanceCount              = 1,
                PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                ServiceTypeName            = "StatelessJobServiceType",
                ServiceName = new Uri($"{applicationName}/jobs/{jobName}")
            };

            if (workload.HasValue)
            {
                serviceDescription.Metrics.Add(new StatelessServiceLoadMetricDescription()
                {
                    Name        = "WorkUnits",
                    DefaultLoad = workload.Value,
                    Weight      = ServiceLoadMetricWeight.High
                });
            }
            return(fabricClient.ServiceManager.CreateServiceAsync(serviceDescription));
        }
Example #17
0
        public DeviceGenerator(StatelessServiceContext context)
            : base(context)
        {
            applicationPath = new Uri($"fabric:/DeviceSimulation/Devices");

            var simulations = new List <SimulationItem>()
            {
                new SimulationItem()
                {
                    Id             = Guid.NewGuid(),
                    DeviceName     = "SimulatedTruck-001",
                    DeviceType     = "Truck",
                    DefinitionPath = "Truck.json",
                    Interval       = 1
                }
            };

            serviceDescriptions = new Dictionary <string, StatelessServiceDescription>();
            foreach (var simulation in simulations)
            {
                var json = JsonConvert.SerializeObject(simulation);
                var statelessServiceDescription = new StatelessServiceDescription()
                {
                    ApplicationName            = new Uri($"fabric:/DeviceSimulation/Devices"),
                    ServiceName                = new Uri($"fabric:/DeviceSimulation/Devices/{simulation.DeviceName}"),
                    ServiceTypeName            = "DeviceSimulatorType",
                    PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                    InitializationData         = Encoding.ASCII.GetBytes(json),
                    InstanceCount              = 1,
                };

                serviceDescriptions.Add("Truck", statelessServiceDescription);
            }

            fabricClient = new FabricClient();
        }
        protected override object FormatOutput(object output)
        {
            var result = new PSObject(output);

            if (output is ServiceGroupDescription)
            {
                var serviceGroupDescription = output as ServiceGroupDescription;

                // Adding a helper toString method for printing IList<MemberDescription>
                var memberDescriptionsPSObj = new PSObject(serviceGroupDescription.MemberDescriptions);
                memberDescriptionsPSObj.Members.Add(
                    new PSCodeMethod(
                        Constants.ToStringMethodName,
                        typeof(OutputFormatter).GetMethod(Constants.FormatObjectMethodName)));
                result.Properties.Add(new PSNoteProperty(Constants.MemberDescriptionsPropertyName, memberDescriptionsPSObj));

                result.Properties.Add(new PSNoteProperty(
                                          Constants.ApplicationNamePropertyName,
                                          serviceGroupDescription.ServiceDescription.ApplicationName));
                result.Properties.Add(new PSNoteProperty(
                                          Constants.ServiceNamePropertyName,
                                          serviceGroupDescription.ServiceDescription.ServiceName));
                result.Properties.Add(new PSNoteProperty(
                                          Constants.ServiceTypeNamePropertyName,
                                          serviceGroupDescription.ServiceDescription.ServiceTypeName));
                result.Properties.Add(new PSNoteProperty(
                                          Constants.ServiceKindPropertyName,
                                          serviceGroupDescription.ServiceDescription.Kind));
                if (serviceGroupDescription.ServiceDescription is StatefulServiceDescription)
                {
                    StatefulServiceDescription statefulServiceDescription = serviceGroupDescription.ServiceDescription as StatefulServiceDescription;
                    result.Properties.Add(new PSNoteProperty(
                                              Constants.HasPersistedStatePropertyName,
                                              statefulServiceDescription.HasPersistedState));
                    result.Properties.Add(new PSNoteProperty(
                                              Constants.MinReplicaSetSizePropertyName,
                                              statefulServiceDescription.MinReplicaSetSize));
                    result.Properties.Add(new PSNoteProperty(
                                              Constants.TargetReplicaSetSizePropertyName,
                                              statefulServiceDescription.TargetReplicaSetSize));

                    if (statefulServiceDescription.HasPersistedState)
                    {
                        result.Properties.Add(new PSNoteProperty(
                                                  Constants.ReplicaRestartWaitDurationPropertyName,
                                                  statefulServiceDescription.ReplicaRestartWaitDuration));
                        result.Properties.Add(new PSNoteProperty(
                                                  Constants.QuorumLossWaitDurationPropertyName,
                                                  statefulServiceDescription.QuorumLossWaitDuration));
                        result.Properties.Add(new PSNoteProperty(
                                                  Constants.StandByReplicaKeepDurationPropertyName,
                                                  statefulServiceDescription.StandByReplicaKeepDuration));
                    }
                }
                else if (serviceGroupDescription.ServiceDescription is StatelessServiceDescription)
                {
                    StatelessServiceDescription statelessServiceDescription = serviceGroupDescription.ServiceDescription as StatelessServiceDescription;
                    result.Properties.Add(new PSNoteProperty(
                                              Constants.InstanceCountPropertyName,
                                              statelessServiceDescription.InstanceCount));
                }

                result.Properties.Add(
                    new PSNoteProperty(
                        Constants.PartitionSchemePropertyName,
                        serviceGroupDescription.ServiceDescription.PartitionSchemeDescription.Scheme));
                result.Properties.Add(
                    new PSNoteProperty(
                        Constants.PlacementConstraintsPropertyName,
                        string.IsNullOrEmpty(serviceGroupDescription.ServiceDescription.PlacementConstraints) ? Constants.NoneResultOutput : serviceGroupDescription.ServiceDescription.PlacementConstraints));

                if (serviceGroupDescription.ServiceDescription.PartitionSchemeDescription.Scheme == PartitionScheme.UniformInt64Range)
                {
                    var info = serviceGroupDescription.ServiceDescription.PartitionSchemeDescription as UniformInt64RangePartitionSchemeDescription;
                    if (info != null)
                    {
                        result.Properties.Add(new PSNoteProperty(Constants.PartitionLowKeyPropertyName, info.LowKey));
                        result.Properties.Add(new PSNoteProperty(Constants.PartitionHighKeyPropertyName, info.HighKey));
                        result.Properties.Add(new PSNoteProperty(Constants.PartitionCountPropertyName, info.PartitionCount));
                    }
                }
                else if (serviceGroupDescription.ServiceDescription.PartitionSchemeDescription.Scheme == PartitionScheme.Named)
                {
                    var info = serviceGroupDescription.ServiceDescription.PartitionSchemeDescription as NamedPartitionSchemeDescription;
                    if (info != null)
                    {
                        var partitionNamesPropertyPSObj = new PSObject(info.PartitionNames);
                        partitionNamesPropertyPSObj.Members.Add(
                            new PSCodeMethod(
                                Constants.ToStringMethodName,
                                typeof(OutputFormatter).GetMethod(Constants.FormatObjectMethodName)));

                        result.Properties.Add(new PSNoteProperty(Constants.PartitionNamesPropertyName, partitionNamesPropertyPSObj));
                    }
                }

                return(result);
            }

            return(base.FormatOutput(output));
        }
Example #19
0
        private async Task <SprocAddressStruct> GetOrCreateSproServiceInstanceAsync(string messageSessionType, string messageUserName)
        {
            var urlPath = $"SPROC_{messageSessionType}_{messageUserName}";

            var url          = new ServiceUriBuilder(urlPath).ToUri();
            var fabricClient = new FabricClient();

            ServiceDescription service = null;

            try
            {
                service = await fabricClient.ServiceManager.GetServiceDescriptionAsync(url);
            }
            catch (Exception ex)
            {
                // nothing to do -> exception mean no service with the requested namename
                service = null;
            }
            if (service == null)
            {
                StatelessServiceDescription newGeneratorDescription = new StatelessServiceDescription()
                {
                    ApplicationName            = new Uri(this.Context.CodePackageActivationContext.ApplicationName),
                    ServiceName                = url,
                    InstanceCount              = 1,
                    ServiceTypeName            = "com.mega.SproGuestExeType",
                    PartitionSchemeDescription = new SingletonPartitionSchemeDescription()
                };

                await fabricClient.ServiceManager.CreateServiceAsync(newGeneratorDescription).ConfigureAwait(false);

                service = await fabricClient.ServiceManager.GetServiceDescriptionAsync(url);


                var healthState = HealthState.Unknown;
                var count       = 0;
                while (healthState != HealthState.Ok)
                {
                    if (count++ >= 10)
                    {
                        throw new TimeoutException("Time out waiting for " + url);
                    }

                    var serviceList = await fabricClient.QueryManager.GetServiceListAsync(new Uri(this.Context.CodePackageActivationContext.ApplicationName));

                    healthState = serviceList.Single(services => services.ServiceName == url).HealthState;

                    if (healthState != HealthState.Ok)
                    {
                        await Task.Delay(TimeSpan.FromSeconds(2));
                    }
                }
            }

            ServicePartitionResolver resolver  = ServicePartitionResolver.GetDefault();
            ResolvedServicePartition partition = await resolver.ResolveAsync(service.ServiceName,
                                                                             new ServicePartitionKey(), CancellationToken.None);

            var s = partition.Endpoints.First();
            // s.Address == {"Endpoints":{"com.mega.SproGuestExeTypeEndpoint":"localhost:33039"}}

            // HACK : exytraction fqdn : should using json deserialization instead of this bad hack
            int start = s.Address.IndexOf(":\"") + 2;
            int stop  = s.Address.IndexOf("\"", start);
            var fqdn  = s.Address.Substring(start, stop - start);

            var parts = fqdn.Split(':');

            return(new SprocAddressStruct {
                ServiceName = service.ServiceName, Ip = parts[0], Port = Convert.ToInt32(parts[1])
            });
        }
Example #20
0
        private ServiceDescription CreateServiceDescription(ServiceOperationDescription serviceOperationDescription)
        {
            string             errorMessage;
            ServiceDescription serviceDescription;

            switch (serviceOperationDescription.ServiceKind)
            {
            case ArmServiceKind.Stateful:
                if (!this.ValidObjectType <StatefulServiceOperationDescription>(serviceOperationDescription, out errorMessage))
                {
                    throw new InvalidCastException(errorMessage);
                }

                var statefulOperation = (StatefulServiceOperationDescription)serviceOperationDescription;
                serviceDescription = new StatefulServiceDescription()
                {
                    HasPersistedState          = statefulOperation.HasPersistedState,
                    MinReplicaSetSize          = statefulOperation.MinReplicaSetSize,
                    TargetReplicaSetSize       = statefulOperation.TargetReplicaSetSize,
                    QuorumLossWaitDuration     = statefulOperation.QuorumLossWaitDuration,
                    ReplicaRestartWaitDuration = statefulOperation.ReplicaRestartWaitDuration,
                    StandByReplicaKeepDuration = statefulOperation.StandByReplicaKeepDuration
                };

                break;

            case ArmServiceKind.Stateless:
                if (!this.ValidObjectType <StatelessServiceOperationDescription>(serviceOperationDescription, out errorMessage))
                {
                    throw new InvalidCastException(errorMessage);
                }

                var statelessOperation = (StatelessServiceOperationDescription)serviceOperationDescription;
                serviceDescription = new StatelessServiceDescription()
                {
                    InstanceCount = statelessOperation.InstanceCount
                };

                break;

            default:
                throw new ArgumentOutOfRangeException(
                          nameof(serviceOperationDescription.ServiceKind),
                          serviceOperationDescription.ServiceKind,
                          $"{this.TraceType}: Unexpected ArmServiceKind");
            }

            serviceDescription.ApplicationName = serviceOperationDescription.ApplicationName;
            serviceDescription.ServiceName     = serviceOperationDescription.ServiceName;

            if (serviceOperationDescription.DefaultMoveCost.HasValue)
            {
                serviceDescription.DefaultMoveCost =
                    (MoveCost)Enum.Parse(
                        typeof(MoveCost),
                        serviceOperationDescription.DefaultMoveCost.Value.ToString());
            }

            serviceDescription.PlacementConstraints = serviceOperationDescription.PlacementConstraints;
            serviceDescription.ServiceTypeName      = serviceOperationDescription.ServiceTypeName;

            if (serviceOperationDescription.CorrelationScheme != null)
            {
                foreach (var scheme in serviceOperationDescription.CorrelationScheme)
                {
                    serviceDescription.Correlations.Add(this.GetServiceCorrelationDescription(scheme));
                }
            }

            if (serviceOperationDescription.ServiceLoadMetrics != null)
            {
                foreach (var metric in serviceOperationDescription.ServiceLoadMetrics)
                {
                    serviceDescription.Metrics.Add(this.GetServiceLoadMetricDescription(metric));
                }
            }

            if (serviceOperationDescription.ServicePlacementPolicies != null)
            {
                foreach (var policy in serviceOperationDescription.ServicePlacementPolicies)
                {
                    serviceDescription.PlacementPolicies.Add(this.GetServicePlacementPolicyDescription(policy));
                }
            }

            PartitionSchemeDescription partitionSchemeDescription;

            switch (serviceOperationDescription.PartitionDescription.PartitionScheme)
            {
            case ArmPartitionScheme.Named:
                if (!this.ValidObjectType <ArmNamedPartitionDescription>(serviceOperationDescription.PartitionDescription, out errorMessage))
                {
                    throw new InvalidCastException(errorMessage);
                }

                var namedOperation = (ArmNamedPartitionDescription)serviceOperationDescription.PartitionDescription;
                partitionSchemeDescription = new NamedPartitionSchemeDescription(namedOperation.Names);
                break;

            case ArmPartitionScheme.Singleton:
                partitionSchemeDescription = new SingletonPartitionSchemeDescription();
                break;

            case ArmPartitionScheme.UniformInt64Range:
                if (!this.ValidObjectType <ArmUniformInt64PartitionDescription>(serviceOperationDescription.PartitionDescription, out errorMessage))
                {
                    throw new InvalidCastException(errorMessage);
                }

                var uniformOperation = (ArmUniformInt64PartitionDescription)serviceOperationDescription.PartitionDescription;
                partitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription()
                {
                    HighKey        = uniformOperation.HighKey,
                    LowKey         = uniformOperation.LowKey,
                    PartitionCount = uniformOperation.Count
                };

                break;

            default:
                throw new ArgumentOutOfRangeException(
                          nameof(serviceOperationDescription.PartitionDescription.PartitionScheme),
                          serviceOperationDescription.PartitionDescription.PartitionScheme,
                          $"{this.TraceType}: Unexpected ArmPartitionScheme");
            }

            serviceDescription.PartitionSchemeDescription = partitionSchemeDescription;

            return(serviceDescription);
        }
        /// <inheritdoc/>
        protected override void ProcessRecordInternal()
        {
            PartitionSchemeDescription partitionSchemeDescription = null;

            if (this.Named.IsPresent)
            {
                partitionSchemeDescription = new NamedPartitionSchemeDescription(
                    count: this.Count,
                    names: this.Names);
            }
            else if (this.Singleton.IsPresent)
            {
                partitionSchemeDescription = new SingletonPartitionSchemeDescription();
            }
            else if (this.UniformInt64Range.IsPresent)
            {
                partitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription(
                    count: this.Count,
                    lowKey: this.LowKey,
                    highKey: this.HighKey);
            }

            ServiceDescription serviceDescription = null;

            if (this.Stateful.IsPresent)
            {
                serviceDescription = new StatefulServiceDescription(
                    serviceName: this.ServiceName,
                    serviceTypeName: this.ServiceTypeName,
                    partitionDescription: partitionSchemeDescription,
                    targetReplicaSetSize: this.TargetReplicaSetSize,
                    minReplicaSetSize: this.MinReplicaSetSize,
                    hasPersistedState: this.HasPersistedState,
                    applicationName: this.ApplicationName,
                    initializationData: this.InitializationData,
                    placementConstraints: this.PlacementConstraints,
                    correlationScheme: this.CorrelationScheme,
                    serviceLoadMetrics: this.ServiceLoadMetrics,
                    servicePlacementPolicies: this.ServicePlacementPolicies,
                    defaultMoveCost: this.DefaultMoveCost,
                    isDefaultMoveCostSpecified: this.IsDefaultMoveCostSpecified,
                    servicePackageActivationMode: this.ServicePackageActivationMode,
                    serviceDnsName: this.ServiceDnsName,
                    scalingPolicies: this.ScalingPolicies,
                    tagsRequiredToPlace: this.TagsRequiredToPlace,
                    tagsRequiredToRun: this.TagsRequiredToRun,
                    flags: this.Flags,
                    replicaRestartWaitDurationSeconds: this.ReplicaRestartWaitDurationSeconds,
                    quorumLossWaitDurationSeconds: this.QuorumLossWaitDurationSeconds,
                    standByReplicaKeepDurationSeconds: this.StandByReplicaKeepDurationSeconds,
                    servicePlacementTimeLimitSeconds: this.ServicePlacementTimeLimitSeconds,
                    dropSourceReplicaOnMove: this.DropSourceReplicaOnMove,
                    replicaLifecycleDescription: this.ReplicaLifecycleDescription,
                    auxiliaryReplicaCount: this.AuxiliaryReplicaCount);
            }
            else if (this.Stateless.IsPresent)
            {
                serviceDescription = new StatelessServiceDescription(
                    serviceName: this.ServiceName,
                    serviceTypeName: this.ServiceTypeName,
                    partitionDescription: partitionSchemeDescription,
                    instanceCount: this.InstanceCount,
                    applicationName: this.ApplicationName,
                    initializationData: this.InitializationData,
                    placementConstraints: this.PlacementConstraints,
                    correlationScheme: this.CorrelationScheme,
                    serviceLoadMetrics: this.ServiceLoadMetrics,
                    servicePlacementPolicies: this.ServicePlacementPolicies,
                    defaultMoveCost: this.DefaultMoveCost,
                    isDefaultMoveCostSpecified: this.IsDefaultMoveCostSpecified,
                    servicePackageActivationMode: this.ServicePackageActivationMode,
                    serviceDnsName: this.ServiceDnsName,
                    scalingPolicies: this.ScalingPolicies,
                    tagsRequiredToPlace: this.TagsRequiredToPlace,
                    tagsRequiredToRun: this.TagsRequiredToRun,
                    minInstanceCount: this.MinInstanceCount,
                    minInstancePercentage: this.MinInstancePercentage,
                    flags: this.Flags,
                    instanceCloseDelayDurationSeconds: this.InstanceCloseDelayDurationSeconds,
                    instanceLifecycleDescription: this.InstanceLifecycleDescription,
                    instanceRestartWaitDurationSeconds: this.InstanceRestartWaitDurationSeconds);
            }

            this.ServiceFabricClient.Services.CreateServiceAsync(
                applicationId: this.ApplicationId,
                serviceDescription: serviceDescription,
                serverTimeout: this.ServerTimeout,
                cancellationToken: this.CancellationToken).GetAwaiter().GetResult();

            Console.WriteLine("Success!");
        }
Example #22
0
        private bool TryCreateStatelessServiceDescription(out StatelessServiceDescription sd)
        {
            sd = null;

            try
            {
                sd = new StatelessServiceDescription();
                sd.ApplicationName = new Uri(this.control.Package.ApplicationAddress, UriKind.Absolute);
                sd.ServiceName = new Uri(this.control.Package.ServiceAddress, UriKind.Absolute);
                sd.ServiceTypeName = this.control.Package.ServiceType;

                int count;
                if (!this.TryGetData("ServiceStatelessCount", out count))
                {
                    return false;
                }

                sd.InstanceCount = count;
                // add special case for -1 when running in dev one-box, only start 1 instance
                if (sd.InstanceCount == -1)
                {
                    if (this.control.Cluster.ClusterType == ClusterType.OneBox)
                    {
                        log.Info("special case override of -1 for onebox environment");
                        if (Environment.UserInteractive)
                        {
                            log.Warn("CreateService: special case override of instanceCount==-1 for onebox environment");
                        }
                        sd.InstanceCount = 1;
                    }
                }

                PartitionSchemeDescription psd;
                if (!this.TryCreatePartitionDescription(out psd))
                {
                    return false;
                }

                sd.PartitionSchemeDescription = psd;
                return true;
            }
            catch (Exception e)
            {
                log.Error("failed to create StatelessServiceDescription, exception={0}", e.Message);
                return false;
            }
        }
        public void ServiceDescriptionSerializationTest()
        {
            StatelessServiceDescription svc = this.random.CreateRandom <StatelessServiceDescription>();

            TestUsingSerializer(this.Serializer, svc);
        }
Example #24
0
        /// <summary>
        /// This is the main entry point for your service instance.
        /// </summary>
        /// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service instance.</param>
        protected override async Task RunAsync(CancellationToken cancellationToken)
        {
            // TODO: Replace the following sample code with your own logic
            //       or remove this RunAsync override if it's not needed in your service.

            var simulationJson = await storageService.FetchFileAsync("run", "main-simulation.json");

            var simulations = JsonConvert.DeserializeObject <IEnumerable <SimulationItem> >(simulationJson);

            var ramp      = 1;
            var rampDelay = 1;

            serviceDescriptions = new Dictionary <string, StatelessServiceDescription>();
            foreach (var simulation in simulations)
            {
                simulation.ScriptFile = await storageService.FetchFileAsync("scripts", $"{simulation.DeviceType}.cscript");

                simulation.ScriptLanguage = ScriptLanguage.CSharp;
                simulation.InitialState   = await storageService.FetchFileAsync("state", $"{simulation.DeviceType}.json");

                var batchStart = 1;
                var batchSize  = 10;

                batchSize = simulation.BatchSize ?? batchSize;
                var batches = Enumerable.Range(simulation.DeviceOffset ?? 1, (simulation.NumberOfDevices + (simulation.DeviceOffset ?? 1)) / batchSize);

                var serviceName = $"{simulation.DeviceStartRange}-{simulation.DeviceEndRange}";
                var json        = JsonConvert.SerializeObject(simulation);
                var statelessServiceDescription = new StatelessServiceDescription()
                {
                    ApplicationName            = new Uri($"fabric:/DeviceSimulation/Devices"),
                    ServiceName                = new Uri($"fabric:/DeviceSimulation/Devices/{serviceName}"),
                    ServiceTypeName            = "DeviceSimulatorType",
                    PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                    InitializationData         = Encoding.ASCII.GetBytes(json),
                    InstanceCount              = 1,
                };

                serviceDescriptions.Add(serviceName, statelessServiceDescription);
                batchStart += batchSize;
            }

            fabricClient = new FabricClient();
            var applicationDescription = new ApplicationDescription(applicationPath, "DeviceSimulationType", "1.0.0", new NameValueCollection());
            await fabricClient.ApplicationManager.CreateApplicationAsync(applicationDescription);

            int i = 1;

            foreach (var kvp in serviceDescriptions)
            {
                await fabricClient.ServiceManager.CreateServiceAsync(kvp.Value);

                // Stagger Service Start Times
                if (i % ramp == 0 || i == serviceDescriptions.Count())
                {
                    System.Diagnostics.Trace.WriteLine($"Waiting {rampDelay * 1000} s to start up next batch of applications.");
                    Thread.Sleep(rampDelay * 1000);
                }

                i++;
            }
        }
        public async Task<IActionResult> Post([FromRoute] string tenantName, [FromBody] TenantApplicationParams parameters)
        {
            // First create the application instance.
            // This won't actually create the services yet.
            ApplicationDescription application = new ApplicationDescription(
                new Uri($"{Names.TenantApplicationNamePrefix}/{tenantName}"),
                Names.TenantApplicationTypeName,
                parameters.Version);

            await this.fabricClient.ApplicationManager.CreateApplicationAsync(application, this.operationTimeout, this.serviceCancellationToken);

            // Now create the data service in the new application instance.
            ServiceUriBuilder dataServiceNameUriBuilder = new ServiceUriBuilder(application.ApplicationName.ToString(), Names.TenantDataServiceName);
            StatefulServiceDescription dataServiceDescription = new StatefulServiceDescription()
            {
                ApplicationName = application.ApplicationName,
                HasPersistedState = true,
                MinReplicaSetSize = 3,
                TargetReplicaSetSize = 3,
                PartitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription(parameters.DataPartitionCount, Int64.MinValue, Int64.MaxValue),
                ServiceName = dataServiceNameUriBuilder.Build(),
                ServiceTypeName = Names.TenantDataServiceTypeName
            };

            await this.fabricClient.ServiceManager.CreateServiceAsync(dataServiceDescription, this.operationTimeout, this.serviceCancellationToken);

            // And finally, create the web service in the new application instance.
            ServiceUriBuilder webServiceNameUriBuilder = new ServiceUriBuilder(application.ApplicationName.ToString(), Names.TenantWebServiceName);
            StatelessServiceDescription webServiceDescription = new StatelessServiceDescription()
            {
                ApplicationName = application.ApplicationName,
                InstanceCount = parameters.WebInstanceCount,
                PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
                ServiceName = webServiceNameUriBuilder.Build(),
                ServiceTypeName = Names.TenantWebServiceTypeName
            };

            await this.fabricClient.ServiceManager.CreateServiceAsync(webServiceDescription, this.operationTimeout, this.serviceCancellationToken);


            return this.Ok();
        }
Example #26
0
        /// <summary>
        /// Creates an instance of an application.
        /// </summary>
        /// <param name="applicationName"></param>
        /// <param name="applicationTypeName"></param>
        /// <param name="applicationTypeVersion"></param>
        /// <param name="token"></param>
        /// <param name="cluster"></param>
        /// <param name="applicationInstanceName"></param>
        /// <returns></returns>
        public async Task <ApplicationDescription> CreateApplicationAsync(ApplicationDefinition applicationDefinition, CancellationToken token)
        {
            var app = new ApplicationDescription()
            {
                ApplicationName        = new Uri(applicationDefinition.ApplicationName),
                ApplicationTypeName    = applicationDefinition.Type,
                ApplicationTypeVersion = applicationDefinition.Version
            };

            //maybe move this some where else as seperate step?
            var accountName = Environment.GetEnvironmentVariable("STORAGE_ACCOUNT_NAME");
            var accountKey  = Environment.GetEnvironmentVariable("STORAGE_ACCOUNT_KEY");

            var connectionstring = $"DefaultEndpointsProtocol=https;AccountName={accountName};AccountKey={accountKey};EndpointSuffix=core.windows.net";

            var name = applicationDefinition.ApplicationName.GetName();

            await CreateAzureFileStorage(name, connectionstring);

            // set up env varaialbes for save world files to azure storage
            app.ApplicationParameters.Add("worldtolink_env", $@"\\{accountName}.file.core.windows.net\{name}");
            app.ApplicationParameters.Add("passcode_env", accountKey);
            app.ApplicationParameters.Add("MOTD_env", $"service fabric minecraft: {applicationDefinition.ApplicationName}");

            // set up the ports.
            var serviceDefinition = applicationDefinition.Services.First();

            var mcPort   = serviceDefinition.Ports["MCPORT"];
            var rconPort = serviceDefinition.Ports["RCONPORT"];

            app.ApplicationParameters.Add("MCPORT", mcPort.ToString());
            app.ApplicationParameters.Add("RCONPORT", rconPort.ToString());

            try
            {
                await fabricClient.ApplicationManager.CreateApplicationAsync(app, writeOperationTimeout, token);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                throw;
            }

            // Create the stateless service description.  For stateful services, use a StatefulServiceDescription object.
            StatelessServiceDescription serviceDescription = new StatelessServiceDescription();

            serviceDescription.ApplicationName            = app.ApplicationName;
            serviceDescription.InstanceCount              = 1;
            serviceDescription.PartitionSchemeDescription = new SingletonPartitionSchemeDescription();
            serviceDescription.ServiceName     = new Uri($"{app.ApplicationName}/{serviceDefinition.ServiceName}");
            serviceDescription.ServiceTypeName = serviceDefinition.Type;


            try
            {
                await fabricClient.ServiceManager.CreateServiceAsync(serviceDescription, this.writeOperationTimeout, token);

                return(app);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }