public async Task ResolveMultipleModelsTryFromExpandedPartial(string dtmisExpanded, string dtmisNonExpanded)
{
string[] expandedDtmis = dtmisExpanded.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
string[] nonExpandedDtmis = dtmisNonExpanded.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
string[] totalDtmis = expandedDtmis.Concat(nonExpandedDtmis).ToArray();
ResolverClientOptions options = new ResolverClientOptions(DependencyResolutionOption.TryFromExpanded);
ResolverClient client = TestHelpers.GetTestClient(TestHelpers.ClientType.Local, options);
// Multi-resolve dtmi:com:example:TemperatureController;1 + dtmi:com:example:ColdStorage;1
var result = await client.ResolveAsync(new[] { expandedDtmis[0], nonExpandedDtmis[0] });
Assert.True(result.Keys.Count == totalDtmis.Length);
foreach (string id in totalDtmis)
{
Assert.True(result.ContainsKey(id));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[id]) == id);
}
// TODO: Evaluate using Azure.Core.TestFramework in future iteration.
/*
* string expandedModelPath = DtmiConventions.DtmiToQualifiedPath(expandedDtmis[0], localClient.RepositoryUri.AbsolutePath, fromExpanded: true);
* _logger.ValidateLog(StandardStrings.FetchingContent(expandedModelPath), LogLevel.Trace, Times.Once());
*
* foreach (string dtmi in nonExpandedDtmis)
* {
* string expectedPath = DtmiConventions.DtmiToQualifiedPath(dtmi, localClient.RepositoryUri.AbsolutePath, fromExpanded: true);
* _logger.ValidateLog(StandardStrings.FetchingContent(expectedPath), LogLevel.Trace, Times.Once());
* _logger.ValidateLog(StandardStrings.ErrorAccessLocalRepositoryModel(expectedPath), LogLevel.Warning, Times.Once());
* }
*/
}
public async Task ResolveSingleModelTryFromExpanded(string dtmi, string expectedDeps, TestHelpers.ClientType clientType)
{
var expectedDtmis = $"{dtmi},{expectedDeps}".Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
ResolverClientOptions options = new ResolverClientOptions(DependencyResolutionOption.TryFromExpanded);
ResolverClient client = TestHelpers.GetTestClient(clientType, options);
var result = await client.ResolveAsync(dtmi);
Assert.True(result.Keys.Count == expectedDtmis.Length);
foreach (var id in expectedDtmis)
{
Assert.True(result.ContainsKey(id));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[id]) == id);
}
// TODO: Evaluate using Azure.Core.TestFramework in future iteration.
/*
* string expectedPath = DtmiConventions.DtmiToQualifiedPath(
* dtmi,
* repoType == "local" ? client.RepositoryUri.AbsolutePath : client.RepositoryUri.AbsoluteUri,
* fromExpanded: true);
* _logger.ValidateLog(StandardStrings.FetchingContent(expectedPath), LogLevel.Trace, Times.Once());
*/
}
public void ResolveNoneExistentDtmiFileThrowsException(string dtmi, TestHelpers.ClientType clientType)
{
ResolverClient client = TestHelpers.GetTestClient(clientType);
ResolverException re = Assert.ThrowsAsync <ResolverException>(async() => await client.ResolveAsync(dtmi));
Assert.True(re.Message.StartsWith($"Unable to resolve \"{dtmi}\""));
}
public void Setup()
{
_localClient = new ResolverClient(TestHelpers.TestLocalModelRepository);
// TODO: Needs consistent remote repo
// _remoteClient = ResolverClient.FromRemoteRepository(TestHelpers.GetTestRemoteModelRegistry());
}
public void ResolveInvalidDtmiDepsThrowsException(string dtmi, string invalidDep)
{
ResolverClient client = TestHelpers.GetTestClient(TestHelpers.ClientType.Local);
ResolverException re = Assert.ThrowsAsync <ResolverException>(async() => await client.ResolveAsync(dtmi));
Assert.True(re.Message.StartsWith($"Unable to resolve \"{invalidDep}\""));
}
public async static Task <IEnumerable <string> > ParserDtmiResolver(this ResolverClient client, IReadOnlyCollection <Dtmi> dtmis)
{
IEnumerable <string> dtmiStrings = dtmis.Select(s => s.AbsoluteUri);
IDictionary <string, string> result = await client.ResolveAsync(dtmiStrings);
return(result.Values.ToList());
}
public async Task ResolveSingleModelWithDeps(string dtmi, string expectedDeps, TestHelpers.ClientType clientType)
{
ResolverClient client = TestHelpers.GetTestClient(clientType);
var result = await client.ResolveAsync(dtmi);
var expectedDtmis = $"{dtmi},{expectedDeps}".Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
Assert.True(result.Keys.Count == expectedDtmis.Length);
foreach (var id in expectedDtmis)
{
Assert.True(result.ContainsKey(id));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[id]) == id);
}
// TODO: Evaluate using Azure.Core.TestFramework in future iteration.
/*
* // Verifying log entries for a Process(...) run
* _logger.ValidateLog($"{StandardStrings.ClientInitWithFetcher(localClient.RepositoryUri.Scheme)}", LogLevel.Trace, Times.Once());
*
* _logger.ValidateLog($"{StandardStrings.ProcessingDtmi("dtmi:com:example:TemperatureController;1")}", LogLevel.Trace, Times.Once());
* _logger.ValidateLog($"{StandardStrings.FetchingContent(DtmiConventions.DtmiToQualifiedPath(expectedDtmis[0], localClient.RepositoryUri.AbsolutePath))}", LogLevel.Trace, Times.Once());
*
* _logger.ValidateLog($"{StandardStrings.DiscoveredDependencies(new List<string>() { "dtmi:com:example:Thermostat;1", "dtmi:azure:DeviceManagement:DeviceInformation;1" })}", LogLevel.Trace, Times.Once());
*
* _logger.ValidateLog($"{StandardStrings.ProcessingDtmi("dtmi:com:example:Thermostat;1")}", LogLevel.Trace, Times.Once());
* _logger.ValidateLog($"{StandardStrings.FetchingContent(DtmiConventions.DtmiToQualifiedPath(expectedDtmis[1], localClient.RepositoryUri.AbsolutePath))}", LogLevel.Trace, Times.Once());
*
* _logger.ValidateLog($"{StandardStrings.ProcessingDtmi("dtmi:azure:DeviceManagement:DeviceInformation;1")}", LogLevel.Trace, Times.Once());
* _logger.ValidateLog($"{StandardStrings.FetchingContent(DtmiConventions.DtmiToQualifiedPath(expectedDtmis[2], localClient.RepositoryUri.AbsolutePath))}", LogLevel.Trace, Times.Once());
*/
}
public async Task ParserValidationResolveFromLocalRepository()
{
ModelParser parser = new ModelParser();
string TestRegistryPath = TestHelpers.TestLocalModelRepository;
List <string> parseModelPaths = new List <string>()
{
$"{TestRegistryPath}/dtmi/company/demodevice-2.json",
$"{TestRegistryPath}/dtmi/com/example/temperaturecontroller-1.json",
$"{TestRegistryPath}/dtmi/com/example/camera-3.json",
};
// Shows how to quickly integrate the resolver client with the parser.
ResolverClient client = new ResolverClient(TestRegistryPath);
parser.DtmiResolver = client.ParserDtmiResolver;
foreach (string modelPath in parseModelPaths)
{
// Parser will throw on validation errors
try {
await parser.ParseAsync(new string[] { File.ReadAllText(modelPath) });
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
}
public void ResolveInvalidDtmiFormatThrowsException(string dtmi)
{
ResolverClient client = TestHelpers.GetTestClient(TestHelpers.ClientType.Local);
string expectedExMsg = $"{string.Format(StandardStrings.GenericResolverError, dtmi)}{string.Format(StandardStrings.InvalidDtmiFormat, dtmi)}";
ResolverException re = Assert.ThrowsAsync <ResolverException>(async() => await client.ResolveAsync(dtmi));
Assert.AreEqual(re.Message, expectedExMsg);
}
public async Task ResolveEnsuresNoDupes(string dtmiDupe1, string dtmiDupe2)
{
ResolverClient client = TestHelpers.GetTestClient(TestHelpers.ClientType.Local);
var result = await client.ResolveAsync(new[] { dtmiDupe1, dtmiDupe2 });
Assert.True(result.Keys.Count == 1);
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[dtmiDupe1]) == dtmiDupe1);
}
public async Task ResolveSingleModelNoDeps(string dtmi, TestHelpers.ClientType clientType)
{
ResolverClient client = TestHelpers.GetTestClient(clientType);
var result = await client.ResolveAsync(dtmi);
Assert.True(result.Keys.Count == 1);
Assert.True(result.ContainsKey(dtmi));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[dtmi]) == dtmi);
}
public async Task ResolveSingleModelWithDepsFromExtendsInline(string dtmi)
{
ResolverClient client = TestHelpers.GetTestClient(TestHelpers.ClientType.Local);
var result = await client.ResolveAsync(dtmi);
Assert.True(result.Keys.Count == 1);
Assert.True(result.ContainsKey(dtmi));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[dtmi]) == dtmi);
}
public ModelParser GetParser()
{
ResolverClient client = GetResolver();
ModelParser parser = new ModelParser
{
DtmiResolver = client.ParserDtmiResolver
};
return(parser);
}
public ModelParser GetParser(DependencyResolutionOption resolutionOption = DependencyResolutionOption.Enabled)
{
ResolverClient client = GetResolver(resolutionOption);
ModelParser parser = new ModelParser
{
DtmiResolver = client.ParserDtmiResolver
};
return(parser);
}
public void ResolveWithWrongCasingThrowsException(string dtmi, TestHelpers.ClientType clientType)
{
ResolverClient client = TestHelpers.GetTestClient(clientType);
string expectedExMsg =
string.Format(StandardStrings.GenericResolverError, "dtmi:com:example:thermostat;1") +
string.Format(StandardStrings.IncorrectDtmiCasing, "dtmi:com:example:thermostat;1", "dtmi:com:example:Thermostat;1");
ResolverException re = Assert.ThrowsAsync <ResolverException>(async() => await client.ResolveAsync(dtmi));
Assert.AreEqual(re.Message, expectedExMsg);
}
public async Task ResolveMultipleModelsNoDeps(string dtmi1, string dtmi2, TestHelpers.ClientType clientType)
{
ResolverClient client = TestHelpers.GetTestClient(clientType);
var result = await client.ResolveAsync(new string[] { dtmi1, dtmi2 });
Assert.True(result.Keys.Count == 2);
Assert.True(result.ContainsKey(dtmi1));
Assert.True(result.ContainsKey(dtmi2));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[dtmi1]) == dtmi1);
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[dtmi2]) == dtmi2);
}
public async Task ResolveSingleModelWithDepsDisableDependencyResolution(string dtmi, TestHelpers.ClientType clientType)
{
ResolverClientOptions options = new ResolverClientOptions(DependencyResolutionOption.Disabled);
ResolverClient client = TestHelpers.GetTestClient(clientType, options);
var result = await client.ResolveAsync(dtmi);
Assert.True(result.Keys.Count == 1);
Assert.True(result.ContainsKey(dtmi));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[dtmi]) == dtmi);
}
private static async Task NotFound()
{
string dtmi = "dtmi:com:example:NotFound;1";
ResolverClient rc = new ResolverClient();
var models = await rc.ResolveAsync(dtmi);
ModelParser parser = new ModelParser();
var parseResult = await parser.ParseAsync(models.Values.ToArray());
Console.WriteLine($"{dtmi} resolved in {models.Count} interfaces with {parseResult.Count} entities.");
}
private static async Task ResolveAndParse()
{
string dtmi = "dtmi:com:example:TemperatureController;1";
ILogger logger = LoggerFactory.Create(builder => builder.AddDebug().SetMinimumLevel(LogLevel.Trace)).CreateLogger <Program>();
ResolverClient rc = new ResolverClient(logger);
var models = await rc.ResolveAsync(dtmi);
ModelParser parser = new ModelParser();
var parseResult = await parser.ParseAsync(models.Values.ToArray());
Console.WriteLine($"{dtmi} resolved in {models.Count} interfaces with {parseResult.Count} entities.");
}
private static async Task ParseAndResolve()
{
string dtmi = "dtmi:com:example:TemperatureController;1";
ResolverClient rc = new ResolverClient(new ResolverClientOptions(DependencyResolutionOption.Disabled));
var models = await rc.ResolveAsync(dtmi);
ModelParser parser = new ModelParser();
parser.DtmiResolver = rc.ParserDtmiResolver;
var parseResult = await parser.ParseAsync(models.Values.Take(1).ToArray());
Console.WriteLine($"{dtmi} resolved in {models.Count} interfaces with {parseResult.Count} entities.");
}
public async Task ResolveMultipleModelsWithDeps(string dtmi1, string dtmi2, string expectedDeps)
{
ResolverClient client = TestHelpers.GetTestClient(TestHelpers.ClientType.Local);
var result = await client.ResolveAsync(new[] { dtmi1, dtmi2 });
var expectedDtmis = $"{dtmi1},{dtmi2},{expectedDeps}".Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
Assert.True(result.Keys.Count == expectedDtmis.Length);
foreach (var id in expectedDtmis)
{
Assert.True(result.ContainsKey(id));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[id]) == id);
}
}
public async Task ResolveSingleModelWithDepsFromExtendsInlineVariant(string dtmi, string expected)
{
ResolverClient client = TestHelpers.GetTestClient(TestHelpers.ClientType.Local);
var result = await client.ResolveAsync(dtmi);
var expectedDtmis = $"{dtmi},{expected}".Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
Assert.True(result.Keys.Count == expectedDtmis.Length);
foreach (var id in expectedDtmis)
{
Assert.True(result.ContainsKey(id));
Assert.True(TestHelpers.ParseRootDtmiFromJson(result[id]) == id);
}
}
public async Task ParserValidationResolveFromRemoteRepository()
{
ModelParser parser = new ModelParser();
// TODO: One off model -- need consistent remote model repo for IT's
string TestRepoPath = TestHelpers.TestLocalModelRepository;
string testModelPath = $"{TestRepoPath}/dtmi/company/demodevice-2.json";
// Shows how to quickly integrate the resolver client with the parser.
ResolverClient client = new ResolverClient(TestHelpers.TestRemoteModelRepository);
parser.DtmiResolver = client.ParserDtmiResolver;
// Parser will throw on validation errors
await parser.ParseAsync(new string[] { File.ReadAllText(testModelPath) });
}
public void ClientOptions()
{
DependencyResolutionOption defaultResolutionOption = DependencyResolutionOption.Enabled;
ResolverClientOptions customOptions =
new ResolverClientOptions(DependencyResolutionOption.TryFromExpanded);
int maxRetries = 10;
customOptions.Retry.MaxRetries = maxRetries;
string repositoryUriString = "https://localhost/myregistry/";
Uri repositoryUri = new Uri(repositoryUriString);
ResolverClient defaultClient = new ResolverClient(repositoryUri);
Assert.AreEqual(defaultResolutionOption, defaultClient.ClientOptions.DependencyResolution);
ResolverClient customClient = new ResolverClient(repositoryUriString, customOptions);
Assert.AreEqual(DependencyResolutionOption.TryFromExpanded, customClient.ClientOptions.DependencyResolution);
Assert.AreEqual(maxRetries, customClient.ClientOptions.Retry.MaxRetries);
}
public void ParserValidationResolveFromLocalRepoErrorOnParserCallbackDtmiCasing()
{
ModelParser parser = new ModelParser();
string TestRegistryPath = TestHelpers.TestLocalModelRepository;
// This model references another model with invalid casing.
string modelPath = $"{TestRegistryPath}/dtmi/company/demodevice-1.json";
// Shows how to quickly integrate the resolver client with the parser.
ResolverClient client = new ResolverClient(TestRegistryPath);
parser.DtmiResolver = client.ParserDtmiResolver;
// Parser will throw on validation errors
ResolverException e =
Assert.ThrowsAsync <ResolverException>(async() => await parser.ParseAsync(new string[] { File.ReadAllText(modelPath) }));
Assert.AreEqual(e.Message,
$"{StandardStrings.GenericResolverError("dtmi:azure:deviceManagement:DeviceInformation;1")}" +
$"{StandardStrings.IncorrectDtmiCasing("dtmi:azure:deviceManagement:DeviceInformation;1","dtmi:azure:DeviceManagement:DeviceInformation;1")}");
}
private static FileInfo ImportModel(JsonElement modelItem, string fileName, DirectoryInfo repository, ILogger logger)
{
//Do DTMI verification
var rootId = Validations.GetRootId(modelItem, fileName);
if (!ResolverClient.IsValidDtmi(rootId.GetString()))
{
throw new InvalidDTMIException(rootId);
}
if (!Validations.ValidateDTMIs(modelItem, fileName, logger))
{
throw new InvalidDTMIException(fileName);
}
// write file to repository location
var newPath = DtmiConventions.DtmiToQualifiedPath(rootId.GetString(), repository.FullName);
// TODO: consistent paths. Use global arg formatters.
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
newPath = newPath.Replace("\\", "/");
}
if (!File.Exists(newPath))
{
CheckCreateDirectory(newPath);
logger.LogTrace($"Writing new file to '{newPath}'. ");
File.WriteAllText(newPath, modelItem.ToString(), Encoding.UTF8);
}
else
{
throw new IOException($"File '{newPath}' already exists. Please remove prior to execution.");
}
//return file info
return(new FileInfo(newPath));
}
/// <summary>
/// Execute the policy and returns the info related, the information is then cached
/// </summary>
/// <param name="providerName">Provider name</param>
/// <param name="serviceName">Service name</param>
/// <param name="bindingAccessPoint">Binding access point</param>
/// <param name="bindingUrlType">Binding URL type</param>
/// <param name="messageType">Message type</param>
/// <param name="operationName">Operation name</param>
/// <param name="messageRole">Message role</param>
/// <param name="messageDirection">Direction of the message</param>
/// <param name="policyName">Policy name</param>
/// <param name="policyVersion">Policy version in the format of x.y where x is the major and y is the minor version number</param>
/// <param name="parameters">Parameter items</param>
/// <returns>Return a Directive object with the result</returns>
private static Directives Resolve(
string providerName,
string serviceName,
string bindingAccessPoint,
string bindingUrlType,
string messageType,
string operationName,
string messageRole,
MessageDirectionTypes messageDirection,
string policyName,
string policyVersion,
Parameters parameters)
{
// TraceHelper.TraceMessage("Resolver.Resolve - In");
// Check parameters
if (string.IsNullOrWhiteSpace(policyName))
{
try
{
policyName = ConfigurationManager.AppSettings[Resources.AppSettingEsbDefaultPolicyName];
try
{
policyVersion = ConfigurationManager.AppSettings[Resources.AppSettingEsbDefaultPolicyVersion];
}
catch (Exception)
{
policyVersion = string.Empty;
}
}
catch
{
// TODO: Log the exception
throw new ArgumentException(string.Format(Resources.ExceptionEsbPolicyUndetermined, Resources.AppSettingEsbDefaultPolicyName));
}
}
Version version;
if (!Version.TryParse(policyVersion, out version))
{
version = default(Version);
}
// Build the key
var key = new StringBuilder(512);
if (!string.IsNullOrEmpty(providerName))
{
key.Append("1;");
key.Append(providerName);
key.Append(";");
}
if (!string.IsNullOrEmpty(serviceName))
{
key.Append("2;");
key.Append(serviceName);
key.Append(";");
}
if (!string.IsNullOrEmpty(bindingAccessPoint))
{
key.Append("3;");
key.Append(bindingAccessPoint);
key.Append(";");
}
if (!string.IsNullOrEmpty(bindingUrlType))
{
key.Append("4;");
key.Append(bindingUrlType);
key.Append(";");
}
if (!string.IsNullOrEmpty(messageType))
{
key.Append("5;");
key.Append(messageType);
key.Append(";");
}
if (!string.IsNullOrEmpty(operationName))
{
key.Append("6;");
key.Append(operationName);
key.Append(";");
}
if (!string.IsNullOrEmpty(messageRole))
{
key.Append("7;");
key.Append(messageRole);
key.Append(";");
}
if (!string.IsNullOrEmpty(messageDirection.ToString()))
{
key.Append("8;");
key.Append(messageDirection);
key.Append(";");
}
var keyParams = new StringBuilder(256);
if (parameters != null && parameters.Count > 0)
{
foreach (var paramItem in parameters.Where(paramItem => !string.IsNullOrEmpty(paramItem.Key)))
{
keyParams.Append(paramItem.Key);
keyParams.Append(";");
if (paramItem.Value == null)
{
continue;
}
keyParams.Append(paramItem.Value);
keyParams.Append(";");
}
}
if (keyParams.Length > 0)
{
key.Append("9;");
key.Append(keyParams);
key.Append(";");
}
if (!string.IsNullOrEmpty(policyName))
{
key.Append("10;");
key.Append(policyName);
key.Append(";");
}
if (version != null)
{
key.Append("11;");
key.Append(version.ToString(2));
key.Append(";");
}
// Get from the cache if is there
if (DirectivesCache.Contains(key.ToString()))
{
var resolverResults = DirectivesCache.GetResolverResults(key.ToString());
Debug.Write("[Resolver] Resolve - Returned # elements from the cache: '" + resolverResults.Count + "'");
return(resolverResults);
}
// Call web service
var svc = new ResolverClient();
try
{
svc.Endpoint.Address = new EndpointAddress(ConfigurationManager.AppSettings[Resources.AppSettingEsbServiceEndPoint]);
}
catch
{
// TODO: Log the error
throw new EsbResolutionException(
string.Format(
"No {0} app setting provided for resolution service. Check the config file.",
Resources.AppSettingEsbServiceEndPoint));
}
//////svc.ClientCredentials = System.Net.CredentialCache.DefaultCredentials;
var ver = version == null ? null : version.ToString(2);
var resolverResultFromWs = svc.Resolve(
providerName,
serviceName,
bindingAccessPoint,
bindingUrlType,
messageType,
operationName,
messageRole,
parameters == null || parameters.Count == 0 ? null : parameters,
messageDirection,
policyName,
ver);
var resolverLocalResult = new Directives(resolverResultFromWs);
// Add to the local cache
try
{
DirectivesCache.Add(
key.ToString(),
resolverLocalResult,
new CacheItemPolicy
{
SlidingExpiration =
new TimeSpan(
ConfigurationManager.AppSettings.GetValues(Resources.AppSettingEsbCacheExpiration) == null
? 24
: Convert.ToInt32(
ConfigurationManager.AppSettings[Resources.AppSettingEsbCacheExpiration]),
0,
0)
});
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception)
{
// TODO: Log the exception
}
Debug.Write("[Resolver] Resolve - Returned # elements: " + resolverResultFromWs.Directives == null ? 0 : resolverResultFromWs.Directives.Length);
return(resolverLocalResult);
}
/// <summary>
/// Get a named BAM step.
/// </summary>
/// <param name="activityName">BAM activity name</param>
/// <param name="stepName">The BAM step name.</param>
/// <param name="policyName">Policy name</param>
/// <param name="version">Policy version in the format of x.y where x is the major and y is the minor version number</param>
/// <returns>A BAM activity step.</returns>
private static BamActivityStep DoGetStep(string activityName, string stepName, string policyName, Version version)
{
// Check parameters
if (string.IsNullOrEmpty(activityName))
{
throw new ArgumentException(Resources.ExceptionBamActivityNameInvalid);
}
if (string.IsNullOrEmpty(policyName))
{
try
{
policyName = ConfigurationManager.AppSettings[Resources.AppSettingEsbBamDefaultTrackpointPolicy];
}
catch
{
// TODO: Configuration error - log this.
policyName = string.Empty;
}
if (string.IsNullOrEmpty(policyName))
{
// Assume that the current directive name is being used:
throw new ArgumentException(Resources.ExceptionBamTrackpointPolicyUndetermined);
}
}
var ver = string.Empty;
try
{
ver = version == null
? ConfigurationManager.AppSettings[Resources.AppSettingEsbBamDefaultTrackpointPolicyVersion]
: version.ToString(2);
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
// TODO: Configuration error - log this.
}
BamActivityStep bamActivityStep;
var key = string.Format(Resources.BamActivityKey, activityName, stepName, policyName, string.IsNullOrWhiteSpace(ver) ? string.Empty : "_" + ver);
// Get from the cache if is there
if (Resolver.DirectivesCache.Contains(key))
{
bamActivityStep = Resolver.DirectivesCache.GetBamActivityStep(key);
}
else
{
// Call web service
var svc = new ResolverClient();
try
{
svc.Endpoint.Address = new EndpointAddress(ConfigurationManager.AppSettings[Resources.AppSettingEsbServiceEndPoint]);
}
catch
{
// TODO: Configuration error - log this.
svc.Endpoint.Address = new EndpointAddress(string.Empty);
}
//////svc.Credentials = System.Net.CredentialCache.DefaultCredentials;
bamActivityStep = svc.GetInterceptionPolicy(activityName, stepName, policyName, ver);
if (bamActivityStep.TrackPoints == null)
{
// This was originally treated as an exception, but this was too
// restrictive. It is entirely permissable to have no trackpoint
// configuration for a given BAM step.
bamActivityStep.TrackPoints = new ArrayList(0);
}
}
if (bamActivityStep == null)
{
throw new EsbResolutionException(Resources.ExceptionNoBamActivity);
}
try
{
Resolver.DirectivesCache.Add(
key,
bamActivityStep,
new CacheItemPolicy
{
SlidingExpiration =
new TimeSpan(
ConfigurationManager.AppSettings.GetValues(Resources.AppSettingEsbCacheExpiration) == null
? 24
: Convert.ToInt32(
ConfigurationManager.AppSettings[Resources.AppSettingEsbCacheExpiration]),
0,
0)
});
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
// TODO: Configuration error - log this.
}
return(bamActivityStep);
}
