private IRemoteMessage[] InvokeRemoteAnalyzer(IEnumerable <string> sourceFilePaths, IEnumerable <string> referencedAssemblyPaths)
{
TraceMessageHandler?.Invoke("Calling analyzer service.");
var proxy = (IRemoteDependencyAnalyzer)Activator.GetObject(typeof(IRemoteDependencyAnalyzer), _serviceAddress);
var result = proxy.AnalyzeProject(ConfigProvider.Config, sourceFilePaths.ToArray(), referencedAssemblyPaths.ToArray());
TraceMessageHandler?.Invoke("Calling analyzer service succeeded.");
return(result);
}
private void ActivateServerAndWaitBeforeRetry(Exception e, int retryCount, TimeSpan[] retryTimeSpans)
{
TraceMessageHandler?.Invoke($"{CommunicationErrorMessage} Exception: {e.Message}");
TraceMessageHandler?.Invoke($"Trying to activate analyzer service (attempt #{retryCount + 1}).");
AnalyzerServiceActivator.Activate(TraceMessageHandler);
var sleepTimeSpan = retryTimeSpans[retryCount];
TraceMessageHandler?.Invoke($"Retrying service call after: {sleepTimeSpan}.");
Thread.Sleep(sleepTimeSpan);
}
private IEnumerable <TypeDependency> GetIllegalTypeDependencies(Func <IEnumerable <TypeDependency> > typeDependencyEnumerator)
{
var illegalDependencies = typeDependencyEnumerator()
.Where(i => !_typeDependencyValidator.IsAllowedDependency(i))
.Take(_config.MaxIssueCount + 1);
foreach (var illegalDependency in illegalDependencies)
{
yield return(illegalDependency);
}
TraceMessageHandler?.Invoke(GetCacheStatisticsMessage(_typeDependencyValidator));
}
private IEnumerable <TypeDependency> UnwrapTraceMessages(IRemoteMessage[] remoteMessages)
{
foreach (var remoteMessage in remoteMessages)
{
switch (remoteMessage)
{
case RemoteIllegalDependencyMessage illegalDependencyMessage:
yield return(illegalDependencyMessage.IllegalDependency);
break;
case RemoteTraceMessage traceMessage:
TraceMessageHandler?.Invoke(traceMessage.Text);
break;
default:
throw new Exception($"Unexpected IRemoteMessage type {remoteMessage?.GetType().Name}");
}
}
}
private void LogTraceMessage(string message) => TraceMessageHandler?.Invoke(message);
public override async Task Run(IList <string> args)
{
if (args.Count != 1)
{
ShowUsage(exit: true);
}
if (!Uri.TryCreate(args[0], UriKind.Absolute, out Uri uri))
{
ShowError($"Invalid url: {args[0]}");
}
if (uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
{
if (string.IsNullOrWhiteSpace(_cert))
{
ShowError($"Client Certificate (--cert) is required when using https");
}
if (!File.Exists(_cert))
{
ShowError($"Not Found: {_cert}");
}
}
if (string.IsNullOrWhiteSpace(_org))
{
ShowError($"Originator is required (--from)");
}
var hostUri = new Uri(uri.GetLeftPart(UriPartial.Authority));
var handler = new HttpClientHandler
{
ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true
};
if (_cert != null)
{
var certificate = AosUtils.LoadCertificate(_cert);
handler.ClientCertificates.Add(certificate);
}
HttpClient client;
#if true //DEBUG
var loggingHandler = new TraceMessageHandler(handler);
client = new HttpClient(loggingHandler);
#else
client = new HttpClient(handler);
#endif
client.DefaultRequestHeaders.Add("Accept", Connection <Aetheros.Schema.OneM2M.PrimitiveContent> .OneM2MResponseContentType);
var tasks = Enumerable.Range(0, _parallel).Select(i => {
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, uri);
httpRequestMessage.Headers.Add("X-M2M-RI", _rqi ?? Guid.NewGuid().ToString("N"));
httpRequestMessage.Headers.Add("X-M2M-Origin", _org);
return(client.SendAsync(httpRequestMessage));
});
//var responses = await tasks.WhenAll();
//var response = await client.SendAsync(httpRequestMessage);
//response.EnsureSuccessStatusCode();
foreach (var task in tasks)
{
var response = await task;
Console.WriteLine("===========");
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}
