internal static void Initialize( StatelessServiceInitializationParameters initializationParameters, MonitoringAgentServiceEvent trace) { codePkgActivationCtx = initializationParameters.CodePackageActivationContext; serviceTrace = trace; }
private static void ParseEndPoints(CodePackageActivationContext context, ServiceManifest manifest) { foreach (EndpointResourceDescription description in context.GetEndpoints()) { manifest.Endpoints.Add(description); } }
public static DiagnosticPipeline CreatePipeline(string healthEntityName, string configurationFileName = "eventFlowConfig.json") { // TODO: dynamically re-configure the pipeline when configuration changes, without stopping the service Requires.NotNullOrWhiteSpace(healthEntityName, nameof(healthEntityName)); var healthReporter = new ServiceFabricHealthReporter(healthEntityName); CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext(); ConfigurationPackage configPackage = activationContext.GetConfigurationPackageObject("Config"); string configFilePath = Path.Combine(configPackage.Path, configurationFileName); if (!File.Exists(configFilePath)) { string errorMessage = $"{nameof(ServiceFabricDiagnosticPipelineFactory)}: configuration file '{configFilePath}' is missing or inaccessible"; healthReporter.ReportProblem(errorMessage, EventFlowContextIdentifiers.Configuration); throw new Exception(errorMessage); } ConfigurationBuilder configBuilder = new ConfigurationBuilder(); configBuilder.AddJsonFile(configFilePath); IConfigurationRoot configurationRoot = configBuilder.Build(); return(DiagnosticPipelineFactory.CreatePipeline(configurationRoot, new ServiceFabricHealthReporter(healthEntityName))); }
public FabricHealthReporter(string entityIdentifier, HealthState problemHealthState = HealthState.Warning) { if (string.IsNullOrWhiteSpace(entityIdentifier)) { throw new ArgumentException("entityIdentifier cannot be null or empty", "entityIdentifier"); } this.entityIdentifier = entityIdentifier; this.problemHealthState = problemHealthState; this.fabricClient = new FabricClient( new FabricClientSettings() { HealthReportSendInterval = TimeSpan.FromSeconds(5) } ); CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext(); this.applicatioName = new Uri(activationContext.ApplicationName); this.serviceManifestName = activationContext.GetServiceManifestName(); NodeContext nodeContext = FabricRuntime.GetNodeContext(); this.nodeName = nodeContext.NodeName; }
/// <summary> /// This is used by Kvs and Volatile actor state provider. /// </summary> /// <param name="codePackage"></param> /// <param name="actorImplType"></param> /// <returns></returns> internal static ReplicatorSettings GetActorReplicatorSettings(CodePackageActivationContext codePackage, Type actorImplType) { var settings = ReplicatorSettings.LoadFrom( codePackage, ActorNameFormat.GetConfigPackageName(actorImplType), ActorNameFormat.GetFabricServiceReplicatorConfigSectionName(actorImplType)); settings.SecurityCredentials = SecurityCredentials.LoadFrom( codePackage, ActorNameFormat.GetConfigPackageName(actorImplType), ActorNameFormat.GetFabricServiceReplicatorSecurityConfigSectionName(actorImplType)); var nodeContext = FabricRuntime.GetNodeContext(); var endpoint = codePackage.GetEndpoint(ActorNameFormat.GetFabricServiceReplicatorEndpointName(actorImplType)); settings.ReplicatorAddress = string.Format( CultureInfo.InvariantCulture, "{0}:{1}", nodeContext.IPAddressOrFQDN, endpoint.Port); if (!settings.MaxPrimaryReplicationQueueSize.HasValue) { settings.MaxPrimaryReplicationQueueSize = DefaultMaxPrimaryReplicationQueueSize; } if (!settings.MaxSecondaryReplicationQueueSize.HasValue) { settings.MaxSecondaryReplicationQueueSize = DefaultMaxSecondaryReplicationQueueSize; } return(settings); }
private void ChangeNotificationTestHelper <TPackageInfo, TPackage>( ChangeNotificationTestData <TPackageInfo, TPackage> data, TPackageInfo oldPackage, TPackageInfo newPackage, Action <EventArgs> validator) where TPackageInfo : IPackageInfo where TPackage : class { var stub = new CodePackageActivationContextStub(); // create the context var context = new CodePackageActivationContext(stub); EventArgs packageChangedArgs = null; // create a delegate for handling the event Action <object, EventArgs> eventHandler = (sender, args) => { Assert.AreSame(context, sender); packageChangedArgs = args; }; // hookup the delegate as the event handler data.EventHookupFunction(context, eventHandler); // invoke the event data.EventInvoker(stub, oldPackage, newPackage); // validate that the event was invoked Assert.IsNotNull(packageChangedArgs); validator(packageChangedArgs); }
/// <summary> /// Configure and run a new ServiceHost /// </summary> public static void Run(Action <ServiceHost> configure) { CodePackageActivationContext packageActivationContext = FabricRuntime.GetActivationContext(); try { ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; ServicePointManager.CheckCertificateRevocationList = true; JsonConvert.DefaultSettings = () => new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.None }; var host = new ServiceHost(); configure(host); host.Start(); packageActivationContext.ReportDeployedServicePackageHealth( new HealthInformation("ServiceHost", "ServiceHost.Run", HealthState.Ok)); Thread.Sleep(Timeout.Infinite); } catch (Exception ex) { packageActivationContext.ReportDeployedServicePackageHealth( new HealthInformation("ServiceHost", "ServiceHost.Run", HealthState.Error) { Description = $"Unhandled Exception: {ex}" }, new HealthReportSendOptions { Immediate = true }); Thread.Sleep(5000); Environment.Exit(-1); } }
internal TraceConfig(string eventSourceName, string packageName) { this.traceEventsSectionName = string.Concat(TraceEventsSectionPrefix, eventSourceName); this.packageName = packageName; ConfigurationSettings configurationSettings = null; CodePackageActivationContext context = null; try { context = FabricRuntime.GetActivationContext(); } catch (Exception) { // We want to handle the standalone case } if (context != null) { // Handle scenario for System Servcies as they dont have config package. // System Services like Fault Analysis Service & Update Orchestration Service depends on Microsoft.ServiceFabric.Services.dll which depends on // Microsoft.ServiceFabric.Diagnostics.dll if (context.GetConfigurationPackageNames().Contains(packageName)) { var configPackage = context.GetConfigurationPackageObject(packageName); context.ConfigurationPackageModifiedEvent += this.OnConfigurationPackageModified; if (configPackage != null) { configurationSettings = configPackage.Settings; } } } this.UpdateSettings(configurationSettings, true); }
/// <summary> /// Convenience method to create an instance of this class initialized with property values loaded from the application configuration package. /// </summary> /// <param name="codePackageActivationContext">The activation context under which this code is running. Retrieved from <see cref="System.Fabric.FabricRuntime"/>.</param> /// <param name="configPackageName">The name of the configuration package (specified in the Service Manifest) containing the settings to load.</param> /// <param name="sectionName">The name of the section in Settings.xml within the specified configuration package containing the settings to load.</param> /// <returns>The initialized settings object.</returns> public static LocalEseStoreSettings LoadFrom( CodePackageActivationContext codePackageActivationContext, string configPackageName, string sectionName) { return(Utility.WrapNativeSyncInvokeInMTA <LocalEseStoreSettings>( () => InternalLoadFrom(codePackageActivationContext, configPackageName, sectionName), "LocalEseStoreSettings::LoadFrom")); }
private void OneHandlerRegistrationTestHelper(Func <CodePackageActivationContextStub, int> handlerCountFunc) { var stub = new CodePackageActivationContextStub(); var context = new CodePackageActivationContext(stub); Assert.AreEqual <int>(1, handlerCountFunc(stub)); }
public static string GetConfigValue(string sectionName, string paramName) { CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext(); var configurationPackage = activationContext.GetConfigurationPackageObject("Config"); string configValue = configurationPackage.Settings.Sections[sectionName].Parameters[paramName].Value; return(configValue); }
private static void ParseDataPackages(CodePackageActivationContext context, ServiceManifest manifest) { IList <string> names = context.GetDataPackageNames(); foreach (string name in names) { manifest.DataPackages.Add(context.GetDataPackageObject(name)); } }
public ServiceFabricConfigurationProvider(string packageName) { this.packageName = packageName; this.context = FabricRuntime.GetActivationContext(); this.context.ConfigurationPackageModifiedEvent += (sender, e) => { this.LoadPackage(e.NewPackage, reload: true); this.OnReload(); }; }
public void ServiceInitializationParameters_NonNullActivationContextReturnsObject() { var obj = new CodePackageActivationContext(new Stubs.CodePackageActivationContextStub()); Action <ServiceInitializationParameters> action = (initParams) => Assert.AreSame(obj, initParams.CodePackageActivationContext); action(new StatelessServiceInitializationParameters(obj)); action(new StatefulServiceInitializationParameters(obj)); }
public static string GetCertThumbprint() { CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext(); var configurationPackage = activationContext.GetConfigurationPackageObject("Config"); string policyStorageCertThumbprint = configurationPackage.Settings.Sections["PolicyStorageSecurityConfig"].Parameters["PolicyStorageCertThumbprint"].Value; return(policyStorageCertThumbprint); }
public AppConfigStore(CodePackageActivationContext activationCtx, string configPackageName) { this.activationCtx = activationCtx; this.configPackageName = configPackageName; activationCtx.ConfigurationPackageModifiedEvent += this.OnConfigurationPackageModified; this.RefreshConfigPackage(); }
// internal for test hook internal void ActivateCodePackageInternal( string activationContextId, string codePackageName, CodePackageActivationContext activationContext, NativeRuntime.IFabricRuntime fabricRuntimePointer) { this.ThrowIfDisposed(); CodePackage codePackage; try { codePackage = activationContext.GetCodePackageObject(codePackageName); } catch (KeyNotFoundException) { AppTrace.TraceSource.WriteError("FabricHostEntryPoint.ActivateCodePackageInternal", "The code package {0} to activate was not found", codePackageName); throw new ArgumentException(StringResources.Error_CodePackageNotFound); } DllHostEntryPointDescription description = codePackage.Description.EntryPoint as DllHostEntryPointDescription; if (description == null) { AppTrace.TraceSource.WriteError("FabricHostEntryPoint.ActivateCodePackageInternal", "Code package {0} does not have a FabricHostEntryPoint", codePackageName); throw new ArgumentException(StringResources.Error_FabricHostEntryPoint_No_EntryPoint_Found); } AppTrace.TraceSource.WriteNoise("FabricHostEntryPoint.ActivateCodePackageInternal", "Adding assembly resolver path: {0}", codePackage.Path); this.assemblyResolver.AddApplicationBinariesPath(codePackage.Path); var workerEntryPoints = description.HostedDlls .Where(i => i.Kind == DllHostHostedDllKind.Managed) .Select(FabricWorkerEntryPoint.CreateFromAssemblyDescription) .ToArray(); var fabricRuntime = new FabricRuntime(fabricRuntimePointer, activationContext); ActivatedCodePackage activatedCodePackage = new ActivatedCodePackage(fabricRuntime, workerEntryPoints); bool activateSucceeded = false; try { workerEntryPoints.ForEach(wep => wep.InvokeActivate(fabricRuntime, activationContext)); this.activeCodePackages[activationContextId] = activatedCodePackage; activateSucceeded = true; } finally { if (!activateSucceeded) { activatedCodePackage.Dispose(); } } }
public static string ReadValue(string sectionName, string parameterName) { CodePackageActivationContext context = FabricRuntime.GetActivationContext(); ConfigurationSettings configSettings = context.GetConfigurationPackageObject("Config").Settings; ConfigurationSection configSection = configSettings.Sections.FirstOrDefault(s => (s.Name == sectionName)); ConfigurationProperty configurationProperty = configSection?.Parameters.FirstOrDefault(p => (p.Name == parameterName)); return(configurationProperty?.Value); }
public ServiceFabricHealthReporter(string entityIdentifier) { if (string.IsNullOrWhiteSpace(entityIdentifier)) { throw new ArgumentException("entityIdentifier cannot be null or empty", "entityIdentifier"); } this.entityIdentifier = entityIdentifier; this.activationContext = FabricRuntime.GetActivationContext(); }
private void RegisterSyncTestHelper_DefaultServiceFactory(CodePackageActivationContext context, Type implementationType, bool isStateful) { this.RegisterTestHelper( context, isStateful, 0, true, (s, rt, stub) => rt.RegisterServiceType(s, implementationType), (broker) => this.DefaultServiceFactoryRegistrationValidator(broker, implementationType)); }
private void RegisterSyncTestHelper_CustomServiceFactory(CodePackageActivationContext context, Action <string, FabricRuntime, object> registerFunc, object serviceFactory, bool isStateful) { this.RegisterTestHelper( context, isStateful, 0, true, (s, rt, stub) => registerFunc(s, rt, serviceFactory), (broker) => Assert.AreSame(serviceFactory, broker.ServiceFactory)); }
public StatefulServiceParameters( CodePackageActivationContext codePackageActivationContext, byte[] initializationData, Guid partitionId, Uri serviceName, string serviceTypeName, long replicaId) { this.CodePackageActivationContext = codePackageActivationContext; this.InitializationData = initializationData; this.PartitionId = partitionId; this.ServiceName = serviceName; this.ServiceTypeName = serviceTypeName; this.ReplicaId = replicaId; }
private void ParametersArePassedToServiceFactoryTestHelper( byte[] initializationData, object returnValue, CodePackageActivationContext context, Func <ServiceFactoryBroker, IntPtr, IntPtr, uint, IntPtr, Guid, long, object> factoryFunc, Func <object, ServiceInitializationParameters> initParamGetterFunc, Func <object, long> idGetterFunc) { ParameterSavingStub stub = new ParameterSavingStub { InstanceToReturn = returnValue }; var broker = new ServiceFactoryBroker(stub, context); // the service factory returns byte[0] byte[] initializationDataExpected = initializationData == null ? new byte[0] : initializationData; using (var pin = new PinBlittable(initializationData)) { var instance = factoryFunc( broker, ServiceFactoryBrokerTest.PtrDefaultServiceType, ServiceFactoryBrokerTest.PtrDefaultServiceUri, initializationData == null ? 0 : (uint)initializationData.Length, pin.AddrOfPinnedObject(), ServiceFactoryBrokerTest.DefaultPartitionId, ServiceFactoryBrokerTest.DefaultInstanceId); // the correct values must be passed into the service factory Assert.AreEqual <long>(ServiceFactoryBrokerTest.DefaultInstanceId, stub.InstanceId); Assert.AreEqual(ServiceFactoryBrokerTest.DefaultServiceTypeName, stub.ServiceType); Assert.AreEqual(new Uri(ServiceFactoryBrokerTest.DefaultServiceUri).ToString().ToLower(), stub.ServiceName.ToString().ToLower()); MiscUtility.CompareEnumerables(initializationDataExpected, stub.InitializationData); Assert.AreSame(returnValue, instance); // the values must be set on the initialization parameters (initialize must have been called) ServiceInitializationParameters actualInitParams = initParamGetterFunc(instance); long actualId = idGetterFunc(instance); Assert.AreEqual <long>(ServiceFactoryBrokerTest.DefaultInstanceId, actualId); Assert.AreEqual(ServiceFactoryBrokerTest.DefaultServiceTypeName, actualInitParams.ServiceTypeName); Assert.AreEqual(new Uri(ServiceFactoryBrokerTest.DefaultServiceUri).ToString().ToLower(), actualInitParams.ServiceName.ToString().ToLower()); Assert.AreEqual(ServiceFactoryBrokerTest.DefaultPartitionId, actualInitParams.PartitionId); if (context != null) { Assert.AreSame(context, actualInitParams.CodePackageActivationContext); } MiscUtility.CompareEnumerables(initializationDataExpected, actualInitParams.InitializationData); } }
/// <summary> /// Create and configure a Serilog logger that writes to Elasticsearch, enriching /// with properties about the Service Fabric environment. /// </summary> public static ILogger CreateLogger(NodeContext nodeContext, CodePackageActivationContext activationContext) { var config = new LoggerConfiguration() .Enrich.WithCommonProperties() .Enrich.With(new PropertyEnricher("NodeId", nodeContext.NodeId)) .Enrich.With(new PropertyEnricher("NodeName", nodeContext.NodeName)) .Enrich.With(new PropertyEnricher("ApplicationName", activationContext.ApplicationName)) .Enrich.With(new PropertyEnricher("ApplicationTypeName", activationContext.ApplicationTypeName)) .WriteTo.Elasticsearch(GetElasticsearchOptions()); return(Log.Logger = config.CreateLogger()); }
private MessageBrokerEnvironment GetEnvironment() { CodePackageActivationContext context = FabricRuntime.GetActivationContext(); ConfigurationPackage packageContext = context.GetConfigurationPackageObject("Config"); string environment = packageContext.Settings.Sections["ConfigSection"].Parameters["Environment"].Value; Verify.IsNotEmpty(nameof(environment), environment); ServiceEventSource.Current.ServiceMessage(Context, $"Environment selected: {environment}"); return((MessageBrokerEnvironment)Enum.Parse(typeof(MessageBrokerEnvironment), environment, true)); }
public ServiceFactoryBroker(object serviceFactory, CodePackageActivationContext codePackageActivationContext) { Requires.Argument <object>("serviceFactory", serviceFactory).NotNull(); this.serviceFactory = serviceFactory; this.codePackageActivationContext = codePackageActivationContext; if (!(serviceFactory is IStatelessServiceFactory) && !(serviceFactory is IStatefulServiceFactory)) { AppTrace.TraceSource.WriteError("ServiceFactoryBroker.ServiceFactoryBroker", "Tried to construct a service factory with an invalid type. this indicates a coding error, {0}", serviceFactory.GetType().FullName); throw new ArgumentException(StringResources.Error_ServiceFactoryBroker_Coding_Error_Invalid_Type); } }
public FabricConfigurationProvider(string configurationSectionName) { if (string.IsNullOrWhiteSpace(configurationSectionName)) { throw new ArgumentNullException("configurationSectionName"); } CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext(); ConfigurationPackage configPackage = activationContext.GetConfigurationPackageObject("Config"); this.UseConfiguration(configPackage, configurationSectionName); }
public ServiceFabricConfigurationProvider(string configurationPackageName = DefaultConfigurationPackageName) { Requires.NotNullOrEmpty(configurationPackageName, nameof(configurationPackageName)); this.configurationPackageName = configurationPackageName; CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext(); activationContext.ConfigurationPackageModifiedEvent += (sender, e) => { this.Load(e.NewPackage, reload: true); this.OnReload(); }; }
public void CodePackageActivationContextTest_GetServiceManifestTest() { ServiceManifestInfo manifest = ServiceManifestTest.HelperInstance.CreateDefaultInfo(); var context = CodePackageActivationContext.CreateFromNative(new CodePackageActivationContextStub() { ServiceManifestInfo_Internal = manifest, CodePackageName_Internal = manifest.CodePackages.ElementAt(0).Name }); ServiceManifestTest.HelperInstance.Compare(ServiceManifestTest.HelperInstance.CreateDefaultDescription(), ServiceManifest.CreateFromCodePackageActivationContext(context)); }
public ServiceFabricConfigurationProvider(string packageName) { _packageName = packageName; _context = FabricRuntime.GetActivationContext(); //It's possible to upgrade a service's configuration package without changing the code package. In that case, Service Fabric does not restart the service. Instead, the service receives a ConfigurationPackageModifiedEvent event to notify it that the package changed. _context.ConfigurationPackageModifiedEvent += (sender, e) => { this.LoadPackage(e.NewPackage, reload: true); this.OnReload(); }; }