public void GetConfigurationValuesTest()
{
var config = ConfigurationSectionFactory.GetSimpleJsonLoggerConfigurationSection();
Assert.AreEqual(DetailLevel.High, (DetailLevel)config.DetailLevelToLog);
Assert.AreEqual("Log Test", config.LogName);
Assert.AreEqual("This is just a typical description.", config.LogDescription);
}
public void ValidateConfigurationSectionFactory()
{
ConfigurationSection configSection = ConfigurationSectionFactory.GetSection(StorageAccountConfigurationSettings.SectionName);
Assert.IsNotNull(configSection, "Config section is null");
Assert.AreEqual <Type>(typeof(StorageAccountConfigurationSettings), configSection.GetType(), "Config section is of a wrong type");
configSection = ConfigurationSectionFactory.GetSection(typeof(RetryPolicyConfigurationSettings).FullName);
Assert.IsNotNull(configSection, "Config section is null");
Assert.AreEqual <Type>(typeof(RetryPolicyConfigurationSettings), configSection.GetType(), "Config section is of a wrong type");
configSection = ConfigurationSectionFactory.GetSection(typeof(ApplicationDiagnosticSettings).AssemblyQualifiedName);
Assert.IsNotNull(configSection, "Config section is null");
Assert.AreEqual <Type>(typeof(ApplicationDiagnosticSettings), configSection.GetType(), "Config section is of a wrong type");
}
/// <summary>
/// Retrieves the specified <see cref="System.Configuration.ConfigurationSection"/> for a given application running of the specified machine.
/// </summary>
/// <param name="sectionName">The name of the section to be retrieved.</param>
/// <param name="applicationName">The name of the application for which a configuration section is being requested.</param>
/// <param name="machineName">The name of the machine on which the requesting application is running.</param>
/// <returns>The specified <see cref="System.Configuration.ConfigurationSection"/>, or a null reference if a section by that name is not found.</returns>
public ConfigurationSection GetSection(string sectionName, string applicationName, string machineName)
{
var callToken = TraceManager.RulesComponent.TraceIn(sectionName, this.configPolicy, this.configVersion);
try
{
PolicyExecutionInfo policyExecInfo = new PolicyExecutionInfo(PolicyName, PolicyVersion);
policyExecInfo.AddParameter(WellKnownContractMember.MessageParameters.SectionName, sectionName);
policyExecInfo.AddParameter(WellKnownContractMember.MessageParameters.ApplicationName, applicationName);
policyExecInfo.AddParameter(WellKnownContractMember.MessageParameters.MachineName, machineName);
ConfigurationSection configSection = ConfigurationSectionFactory.GetSection(sectionName);
if (configSection != null)
{
PolicyExecutionResult execResult = PolicyHelper.Execute(policyExecInfo, RulesEngineFactFactory.GetFacts(configSection));
if (execResult.Success)
{
// If policy invocation was successful, we need to update the policy version number of reflect the true version of the policy.
this.actualConfigVersion = new Version(execResult.PolicyVersion.Major, execResult.PolicyVersion.Minor);
if (SourceChanged != null)
{
SourceChanged(this, new ConfigurationSourceChangedEventArgs(this, new string[] { sectionName }));
}
return(configSection);
}
else
{
throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, ExceptionMessages.ConfigPolicyExecutionFailed, execResult.PolicyName), execResult.Errors.Count > 0 ? execResult.Errors[0] : null);
}
}
else
{
throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, ExceptionMessages.ConfigurationSectionNotSupported, sectionName, Resources.RulesEngineConfigurationSourceElementDisplayName));
}
}
finally
{
TraceManager.RulesComponent.TraceOut(callToken);
}
}
public Log GetLogEntries()
{
var config = ConfigurationSectionFactory.GetSimpleJsonLoggerConfigurationSection();
string logName = config.LogName;
var service = Unity.Instance.Resolve <ILogBusinessService>();
var log = service.GetLog(logName);
if (log == null)
{
log = new Log()
{
LogDescription = config.LogDescription,
Name = logName,
CreatedOn = DateTimeOffset.UtcNow
};
}
return(log);
}
public void Log(string message, DetailLevel level)
{
if (level != DetailLevel.None)
{
var config = ConfigurationSectionFactory.GetSimpleJsonLoggerConfigurationSection();
string logDescription = config.LogDescription;
string logName = config.LogName;
int configurationLevel = config.DetailLevelToLog;
var service = Unity.Instance.Resolve <ILogBusinessService>();
if (configurationLevel >= (int)level)
{
var timestamp = DateTimeOffset.UtcNow;
var log = GetLogEntries();
if (log.Messages != null)
{
var tempList = new List <Log.LogMessage>(log.Messages)
{
new Log.LogMessage {
Data = message, TimeStamp = timestamp, DetailLevel = (int)level
}
};
log.Messages = tempList.ToArray();
}
else
{
log.Messages = new Log.LogMessage[] {
new Log.LogMessage {
Data = message, TimeStamp = timestamp, DetailLevel = (int)level
}
};
}
service.SaveLog(log);
}
}
}
private ConfigurationSection RetrieveSection(string sectionName)
{
var callToken = TraceManager.DebugComponent.TraceIn(sectionName);
try
{
using (ReliableServiceBusClient <IOnPremiseConfigurationServiceChannel> configServiceClient = new ReliableServiceBusClient <IOnPremiseConfigurationServiceChannel>(this.sbEndpointInfo, this.retryPolicy))
{
var startScopeInvokeService = TraceManager.DebugComponent.TraceStartScope(Resources.ScopeOnPremiseConfigurationSourceInvokeService, callToken);
try
{
// Invoke the WCF service in a reliable fashion and retrieve the specified configuration section.
XmlElement configSectionXml = configServiceClient.RetryPolicy.ExecuteAction <XmlElement>(() =>
{
return(configServiceClient.Client.GetConfigurationSection(sectionName, CloudEnvironment.CurrentRoleName, CloudEnvironment.CurrentRoleMachineName));
});
if (configSectionXml != null)
{
// Instantiate a configuration object that correspond to the specified section.
ConfigurationSection configSection = ConfigurationSectionFactory.GetSection(sectionName);
// Gotcha: configuration section deserializer requires a well-formed XML document including processing instruction.
XmlDocument configXml = FrameworkUtility.CreateXmlDocument();
configXml.AppendChild(configXml.ImportNode(configSectionXml, true));
// Configure XML reader settings to disable validation and ignore certain XML entities.
XmlReaderSettings settings = new XmlReaderSettings
{
CloseInput = true,
IgnoreWhitespace = true,
IgnoreComments = true,
ValidationType = ValidationType.None,
IgnoreProcessingInstructions = true
};
// Create a reader to consume the XML data.
using (XmlReader reader = XmlReader.Create(new StringReader(configXml.OuterXml), settings))
{
// Attempt to cast the configuration section object into SerializableConfigurationSection for further check.
SerializableConfigurationSection serializableSection = configSection as SerializableConfigurationSection;
// Check if the the configuration section natively supports serialization/de-serialization.
if (serializableSection != null)
{
// Yes, it's supported. Invoke the ReadXml method to consume XML and turn it into object model.
serializableSection.ReadXml(reader);
}
else
{
// No, it's unsupported. Need to do something different, starting with positioning the XML reader to the first available node.
reader.Read();
// Invoke the DeserializeSection method via reflection. This is the only way as the method is internal.
MethodInfo info = configSection.GetType().GetMethod(WellKnownContractMember.MethodNames.DeserializeSection, BindingFlags.NonPublic | BindingFlags.Instance);
info.Invoke(configSection, new object[] { reader });
}
reader.Close();
}
if (SourceChanged != null)
{
SourceChanged(this, new ConfigurationSourceChangedEventArgs(this, new string[] { sectionName }));
}
return(configSection);
}
else
{
// The specified section is not supported by the remote configuration source. We should not throw an exception and rely on the caller to handle an empty section.
return(null);
}
}
finally
{
TraceManager.DebugComponent.TraceEndScope(Resources.ScopeOnPremiseConfigurationSourceInvokeService, startScopeInvokeService, callToken);
}
}
}
catch (Exception ex)
{
TraceManager.DebugComponent.TraceError(ex, callToken);
throw;
}
finally
{
TraceManager.DebugComponent.TraceOut(callToken);
}
}