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)));
}
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);
}
public static string GetCertThumbprint()
{
CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext();
var configurationPackage = activationContext.GetConfigurationPackageObject("Config");
string policyStorageCertThumbprint = configurationPackage.Settings.Sections["PolicyStorageSecurityConfig"].Parameters["PolicyStorageCertThumbprint"].Value;
return(policyStorageCertThumbprint);
}
private static void ParseConfigurationPackages(CodePackageActivationContext context, ServiceManifest manifest)
{
IList <string> names = context.GetConfigurationPackageNames();
foreach (string name in names)
{
manifest.ConfigurationPackages.Add(context.GetConfigurationPackageObject(name));
}
}
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);
}
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 FabricConfigurationProvider(string configurationSectionName)
{
if (string.IsNullOrWhiteSpace(configurationSectionName))
{
throw new ArgumentNullException("configurationSectionName");
}
CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext();
ConfigurationPackage configPackage = activationContext.GetConfigurationPackageObject("Config");
this.UseConfiguration(configPackage, configurationSectionName);
}
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 ConfigHandler(CodePackageActivationContext activationcontext, string sectionName)
{
this.SectionName = sectionName;
if (activationcontext.GetConfigurationPackageNames().Contains("Config"))
{
var configPackage = activationcontext.GetConfigurationPackageObject("Config");
this.UpdateConfigSettings(configPackage.Settings);
activationcontext.ConfigurationPackageModifiedEvent
+= this.CodePackageActivationContext_ConfigurationPackageModifiedEvent;
}
}
private LoggingConfiguration()
{
CodePackageActivationContext codeContext = FabricRuntime.GetActivationContext();
if (codeContext == null) // sanity check
{
throw new ApplicationException("CodePackageActivationContext is null");
}
// let exceptions flow out, they will be traced downstream and the service won't start
ConfigurationPackage configurationPackage = codeContext.GetConfigurationPackageObject(ConfigurationPackageName);
// Read settings from configuration package
this.InitializeSettingsFromConfigurationPackage(configurationPackage);
}
private static void UpdateEventFlowConfiguration()
{
string appInsightsKey = Environment.GetEnvironmentVariable("EventFlow:ApplicationInsightsKey");
string logFilter = Environment.GetEnvironmentVariable("EventFlow:LogFilter");
CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext();
ConfigurationPackage configPackage = activationContext.GetConfigurationPackageObject("Config");
string configFilePath = Path.Combine(configPackage.Path, "eventFlowConfig.json");
string content = File.ReadAllText(configFilePath);
EventFlowOptions options = JsonConvert.DeserializeObject <EventFlowOptions>(content);
options.Outputs[0].InstrumentationKey = appInsightsKey;
options.Filters[0].Include = logFilter;
File.WriteAllText(configFilePath, JsonConvert.SerializeObject(options));
}
public override void Load()
{
// TODO: react to configuration changes by listening to ConfiugrationPackageActivationContext.ConfigurationPackageModifiedEvent
CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext();
ConfigurationPackage configPackage = activationContext.GetConfigurationPackageObject(this.configurationPackageName);
foreach (var configurationSection in configPackage.Settings.Sections)
{
foreach (var property in configurationSection.Parameters)
{
// We omit encrypted values due to security concerns--if you need them, use Service Fabric APIs to access them
if (!property.IsEncrypted)
{
Data[ConfigurationPath.Combine(configurationSection.Name, property.Name)] = property.Value;
}
}
}
}
public FabricConfigProvider(string configurationSectionName)
{
CodePackageActivationContext activationContext = FabricRuntime.GetActivationContext();
ConfigurationPackage configPackage = activationContext.GetConfigurationPackageObject("Config");
if (!configPackage.Settings.Sections.Contains(configurationSectionName))
{
throw new ApplicationException($"Configuration section {configurationSectionName} not found");
}
var section = configPackage.Settings.Sections[configurationSectionName];
var obj = new JObject();
foreach (var setting in section.Parameters)
{
obj.Add(setting.Name, setting.Value);
}
Config = obj.ToObject <TConfig>();
}
public override void Load()
{
var config = _context.GetConfigurationPackageObject(_packageName);
LoadPackage(config);
}
public NextGenCapture_RabbitMQService(StatelessServiceContext context)
: base(context)
{
activationContext = FabricRuntime.GetActivationContext();
configurationPackage = activationContext.GetConfigurationPackageObject("Config");
}
