public async Task <ISingleResponse <ServiceEnvironmentStatus> > GetServiceStatusAsync(ServiceEnvironmentStatus entity) { Logger?.LogDebug("'{0}' has been invoked", nameof(GetServiceStatusAsync)); var response = new SingleResponse <ServiceEnvironmentStatus>(); try { response.Model = await Repository .GetServiceEnvironmentStatusAsync(entity); } catch (Exception ex) { response.SetError(Logger, ex); } return(response); }
public async Task <ISingleResponse <OrderHeader> > GetOrderAsync(long id) { Logger?.LogDebug("{0} has been invoked", nameof(GetOrderAsync)); var response = new SingleResponse <OrderHeader>(); try { // Retrieve order by id response.Model = await DbContext.GetOrderAsync(new OrderHeader(id)); } catch (Exception ex) { response.SetError(Logger, nameof(GetOrderAsync), ex); } return(response); }
private void UnsubscribeAll() { lock (Sync) { if (!Subscribers.Any()) { return; } AbortStreaming(); Logger?.LogDebug($"{GetType().Name}.{nameof(UnsubscribeAll)}: Removing all streams. [thread: {Thread.CurrentThread.ManagedThreadId}]"); Subscribers.Clear(); StreamNames.Clear(); OnProvidedStreamsChanged(); } }
protected internal void HandleStopEvent(Activity current, IOwinContext arg) { if (ShouldIgnoreRequest(arg.Request.Path.Value)) { Logger?.LogDebug("HandleStopEvent: Ignoring path: {path}", arg.Request.Path.Value); return; } if (current.Duration.TotalMilliseconds > 0) { ITagContext tagContext = GetTagContext(arg); StatsRecorder .NewMeasureMap() .Put(responseTimeMeasure, current.Duration.TotalMilliseconds) .Put(serverCountMeasure, 1) .Record(tagContext); } }
private async Task EnsureClientsCollectionCreated() { _clientUri = UriFactory.CreateDocumentCollectionUri(Database.Id, Constants.CollectionNames.Client); Logger?.LogDebug($"Clients URI: {_clientUri}"); var partitionKeyDefinition = new PartitionKeyDefinition { Paths = { Constants.CollectionPartitionKeys.Client } }; Logger?.LogDebug($"Client Partition Key: {partitionKeyDefinition}"); var indexingPolicy = new IndexingPolicy { Automatic = true, IndexingMode = IndexingMode.Consistent }; Logger?.LogDebug($"Clients Indexing Policy: {indexingPolicy}"); _clients = new DocumentCollection { Id = Constants.CollectionNames.Client, PartitionKey = partitionKeyDefinition, IndexingPolicy = indexingPolicy }; Logger?.LogDebug($"Clients Collection: {_clients}"); Logger?.LogDebug($"Ensure Clients (ID:{_clients.Id}) collection exists..."); var clientsRequestOptions = new RequestOptions { OfferThroughput = GetRUsFor(CollectionName.Clients) }; Logger?.LogDebug($"Clients Request Options: {clientsRequestOptions}"); var clientResults = await DocumentClient.CreateDocumentCollectionIfNotExistsAsync(DatabaseUri, _clients, clientsRequestOptions); Logger?.LogDebug($"{_clients.Id} Creation Results: {clientResults.StatusCode}"); if (clientResults.StatusCode.EqualsOne(HttpStatusCode.Created, HttpStatusCode.OK)) { _clients = clientResults.Resource; } }
private void HandleMessage(Event message) { if (message == null) { Logger?.LogWarning($"下载器代理 {_options.AgentId} 接收到空消息"); return; } #if DEBUG Logger?.LogDebug($"下载器代理 {_options.AgentId} 接收到消息: {message}"); #endif try { switch (message.Type) { case Framework.DownloadCommand: { if (message.IsTimeout(60)) { break; } DownloadAsync(message.Data).ConfigureAwait(false).GetAwaiter(); break; } case Framework.ExitCommand: { if (message.IsTimeout(6)) { break; } if (message.Data == _options.AgentId) { StopAsync(default).ConfigureAwait(true).GetAwaiter(); } else { Logger?.LogWarning($"下载器代理 {_options.AgentId} 收到错误的退出消息: {message}"); } break; }
protected internal void HandleStartEvent(HttpContext context) { if (ShouldIgnoreRequest(context.Request.Path)) { Logger?.LogDebug("HandleStartEvent: Ignoring path: {path}", context.Request.Path.ToString()); return; } if (active.Value != null) { Logger?.LogDebug("HandleStartEvent: Continuing existing span!"); return; } ISpanContext traceContext = ExtractTraceContext(context); string spanName = ExtractSpanName(context); ISpan span; if (traceContext != null) { Logger?.LogDebug("HandleStartEvent: Found parent span {parent}", traceContext.ToString()); span = Tracer.SpanBuilderWithRemoteParent(spanName, traceContext) .StartSpan(); } else { span = Tracer.SpanBuilder(spanName) .StartSpan(); } span.PutServerSpanKindAttribute() .PutHttpUrlAttribute(context.Request.GetDisplayUrl()) .PutHttpMethodAttribute(context.Request.Method.ToString()) .PutHttpPathAttribute(context.Request.Path.ToString()) .PutHttpHostAttribute(context.Request.Host.ToString()); if (context.Request.Headers != null) { span.PutHttpRequestHeadersAttribute(AsList(context.Request.Headers)); } active.Value = new SpanContext(span, AsyncLocalContext.CurrentSpan); AsyncLocalContext.CurrentSpan = span; }
/// <summary> /// Starts the service listener if it is in a stopped state. /// </summary> /// <param name="servicePort">The port used to listen on.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentOutOfRangeException">servicePort - Port must be less then " + IPEndPoint.MaxPort + " and more then " + IPEndPoint.MinPort</exception> /// <exception cref="InvalidOperationException">Tcp listener is already active and must be stopped before starting</exception> public bool Start(int servicePort) { if (servicePort > IPEndPoint.MaxPort || servicePort < IPEndPoint.MinPort) { throw new ArgumentOutOfRangeException(nameof(servicePort), "Port must be less then " + IPEndPoint.MaxPort + " and more then " + IPEndPoint.MinPort); } if (IsActive) { throw new InvalidOperationException( "Tcp listener is already active and must be stopped before starting"); } if (InterfaceAddress == null) { var ex = new InvalidOperationException("Unable to set interface address"); Logger?.LogDebug(ex, "Unable to set interface address for TCP {Port}", servicePort); throw ex; } try { Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1); Socket.Bind(new IPEndPoint(InterfaceAddress, servicePort)); Socket.ReceiveTimeout = ReceiveTimeout; Socket.SendTimeout = SendTimeout; Socket.Listen(ListenBacklog); IsActive = true; Thread = new Thread(StartTcpListening); Thread.Start(); Logger?.LogInformation("Listener started for TCP requests on {LocalEndPoint}", Socket.LocalEndPoint); } catch (Exception ex) { Logger?.LogError(ex, "Listener failed to to start on TCP {ServicePort}", servicePort); return(false); } return(true); }
public override void Post(SpeechIdentifier.PostCallback callback) { if (IsSessionOpen && !IsSessionClosing) { IdentifyResults.Clear(); Uri uri = Configuration.Server.BuildEndpoint(URI_PATH_PROCESS); Logger?.LogDebug("SpeechIdentifier_HttpClient_Version1.Post(callback): URI: " + uri.ToString()); using (var request = BuildRequest(CallMode.Process, uri)) { var task = mHttpClient.SendAsync(request).ContinueWith((requestTask) => { if (requestTask.IsFaulted) { IdentifyResult = SpeechIdentifier.Result.Timeout; Logger?.LogError(requestTask.Exception); callback?.Invoke(IdentifyResult); return; } HandleResponse(CallMode.Process, request, requestTask.Result).ContinueWith((responseTask) => { if (responseTask.IsFaulted) { IdentifyResult = SpeechIdentifier.Result.Timeout; Logger?.LogError(responseTask.Exception); callback?.Invoke(IdentifyResult); return; } callback?.Invoke(IdentifyResult); }); }); if (task.IsFaulted) { IdentifyResult = SpeechIdentifier.Result.Timeout; Logger?.LogError(task.Exception); callback?.Invoke(IdentifyResult); } return; } } callback?.Invoke(IdentifyResult = SpeechIdentifier.Result.Invalid); }
public override bool Cancel(string reason) { if (IsSessionOpen && !IsSessionClosing) { IsSessionClosing = true; IdentifyResults.Clear(); Content.Clear(); if (string.IsNullOrEmpty(reason)) { reason = "Unknown"; } else { reason = reason.Replace(' ', '-').Substring(0, System.Math.Min(reason.Length, 64)); } Uri uri = Configuration.Server.BuildEndpoint(URI_PATH_CANCEL, reason); Logger?.LogDebug("SpeechIdentifier_HttpClient_Version1.Cancel(): URI: " + uri.ToString()); using (var request = BuildRequest(CallMode.Cancel, uri)) { try { var responseTask = mHttpClient.SendAsync(request); responseTask.RunSynchronously(); var resultTask = HandleResponse(CallMode.Cancel, request, responseTask.Result); resultTask.RunSynchronously(); return(resultTask.Result); } catch (HttpRequestException ex) { IdentifyResult = SpeechIdentifier.Result.Timeout; Logger?.LogError(ex); } } } return(false); }
/// <summary> /// Determines the file size of the given file /// </summary> /// <param name="fileName"></param> /// <returns></returns> public async Task <long> GetFileSizeAsync(string fileName) { EnsureLoggedIn(); Logger?.LogDebug($"[FtpClient] Getting file size for {fileName}"); var sizeResponse = await SendCommandAsync(new FtpCommandEnvelope { FtpCommand = FtpCommand.SIZE, Data = fileName }); if (sizeResponse.FtpStatusCode != FtpStatusCode.FileStatus) { throw new FtpException(sizeResponse.ResponseMessage); } long fileSize = long.Parse(sizeResponse.ResponseMessage.Substring(4)); return(fileSize); }
/// <summary> /// Initializes a new UnitOfWork instance /// </summary> /// <returns>The new UnitOfWork instance</returns> public IUnitOfWorkBase InitNewUnitOfWork() { ThrowIfDisposingOrDisposed(); int newUowID = GetNextFreeUowID(); var uow = InitNewUnitOfWork(newUowID); if (uow == null) { Logger?.LogError("InitNewUnitOfWork from {type} returned null.", this.GetType()); } else { Logger?.LogDebug("New UnitOfWork ({uow.id}, {uow.type}) initialized by {dbCtx.type}.", uow.UowId, uow.GetType(), this.GetType()); } RegisterUnitOfWork(uow); return(uow); }
public override Task TakeMeasurementAsync() { if (CurrentState == SensorStateEnum.Initialized) { _lastTemperatureCelsius = _cpuTemperature.Temperature.Celsius; if (double.IsNaN(_lastTemperatureCelsius)) { CurrentState = SensorStateEnum.Error; _lastTemperatureCelsius = double.NaN; } else { _lastTemperatureCelsius = Math.Round(_lastTemperatureCelsius, 2); } } Logger?.LogDebug($"{DateTimeOffset.Now}:HealthSensor: reading"); Logger?.LogInformation($"CPU Temperature {_lastTemperatureCelsius}"); return(Task.FromResult(_lastTemperatureCelsius)); }
public Task HandleAsync(Message message) { Logger?.LogDebug("Handing {MessageType} with ordered shell handler.", message.Header.MessageType); currentTask = new Task <TResult?>((state) => { taskDepth++; var previousTask = (Task <TResult?>?)state; var previousResult = previousTask?.Result; var currentResult = HandleAsync(message, previousResult).Result; taskDepth--; if (taskDepth == 0) { currentTask = null; } return(currentResult); }, currentTask); currentTask.Start(); return(currentTask); }
protected internal void HandleStopEvent(HttpWebRequest request, HttpStatusCode statusCode, WebHeaderCollection headers) { if (!Pending.TryRemove(request, out var span)) { Logger?.LogDebug("HandleStopEvent: Missing span context"); return; } if (span != null) { span.PutHttpStatusCodeAttribute((int)statusCode); if (headers != null) { span.PutHttpResponseHeadersAttribute(headers); } span.End(); } }
/// <summary> /// Produces a data socket using Extended Passive mode /// </summary> /// <returns></returns> internal async Task <Socket> ConnectDataSocketAsync() { Logger?.LogDebug("[FtpClient] Connecting to a data socket"); var epsvResult = await SendCommandAsync(FtpCommand.EPSV); if (epsvResult.FtpStatusCode != FtpStatusCode.EnteringExtendedPassive) { throw new FtpException(epsvResult.ResponseMessage); } var passivePortNumber = epsvResult.ResponseMessage.ExtractEpsvPortNumber(); if (!passivePortNumber.HasValue) { throw new FtpException("Could not detmine EPSV data port"); } Socket socket = null; try { Logger?.LogDebug($"Connecting data socket, {Configuration.Host}:{passivePortNumber.Value}"); var ipEndpoint = await dnsResolver.ResolveAsync(Configuration.Host, passivePortNumber.Value, Configuration.IpVersion); socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) { ReceiveTimeout = Configuration.TimeoutSeconds * 1000 }; socket.Connect(ipEndpoint); return(socket); } catch (Exception ex) { if (socket != null && socket.Connected) { socket.Shutdown(SocketShutdown.Both); } throw new FtpException("Can't connect to remote server", ex); } }
public async Task <IListResponse <ServiceWatcherItemDto> > GetActiveServiceWatcherItemsAsync() { Logger?.LogDebug("'{0}' has been invoked", nameof(GetActiveServiceWatcherItemsAsync)); var response = new ListResponse <ServiceWatcherItemDto>(); try { response.Model = await DbContext.GetActiveServiceWatcherItems().ToListAsync(); Logger?.LogInformation("The service watch items were loaded successfully"); } catch (Exception ex) { response.SetError(Logger, nameof(GetActiveServiceWatcherItemsAsync), ex); } return(response); }
private void EnableReloading() { if (Settings.ReloadSettings.ConfigMaps && !Polling) { switch (Settings.ReloadSettings.Mode) { case ReloadMethods.Event: ConfigMapWatcher = K8sClient.WatchNamespacedConfigMapAsync( Settings.Name, Settings.Namespace, onEvent: (eventType, item) => { Logger?.LogInformation("Recieved {eventType} event for ConfigMap {configMapName} with {entries} values", eventType.ToString(), Settings.Name, item?.Data?.Count); switch (eventType) { case WatchEventType.Added: case WatchEventType.Modified: case WatchEventType.Deleted: ProcessData(item); break; default: Logger?.LogDebug("Event type {eventType} is not supported, no action has been taken", eventType); break; } }, onError: (exception) => { Logger?.LogCritical(exception, "ConfigMap watcher on {namespace}.{name} encountered an error!", Settings.Namespace, Settings.Name); }, onClosed: () => { Logger?.LogInformation("ConfigMap watcher on {namespace}.{name} connection has closed", Settings.Namespace, Settings.Name); }).GetAwaiter().GetResult(); break; case ReloadMethods.Polling: StartPolling(Settings.ReloadSettings.Period); break; default: Logger?.LogError("Unsupported reload method!"); break; } } }
/// <summary> /// Sends a command to the FTP server, and returns the response /// </summary> /// <param name="envelope"></param> /// <returns></returns> public async Task <FtpResponse> SendCommandAsync(FtpCommandEnvelope envelope) { await commandSemaphore.WaitAsync(); if (HasResponsePending()) { await GetResponseAsync(); } string commandString = envelope.GetCommandString(); Logger?.LogDebug($"[FtpClient] Sending command: {commandString}"); commandSocket.Send(commandString.ToAsciiBytes()); var response = await GetResponseAsync(); commandSemaphore.Release(); return(response); }
protected virtual IMessage DoReceive(CancellationToken cancellationToken = default) { var interceptorList = Interceptors; Stack <IChannelInterceptor> interceptorStack = null; try { Logger?.LogTrace("PreReceive on channel '" + this + "'"); if (interceptorList.Count > 0) { interceptorStack = new Stack <IChannelInterceptor>(); if (!interceptorList.PreReceive(this, interceptorStack)) { return(null); } } var message = DoReceiveInternal(cancellationToken); if (message == null) { Logger?.LogTrace("PostReceive on channel '" + ServiceName + "', message is null"); } else { Logger?.LogDebug("PostReceive on channel '" + ServiceName + "', message: " + message); } if (interceptorStack != null && message != null) { message = interceptorList.PostReceive(message, this); } interceptorList.AfterReceiveCompletion(message, this, null, interceptorStack); return(message); } catch (Exception ex) { interceptorList.AfterReceiveCompletion(null, this, ex, interceptorStack); throw; } }
protected internal virtual void HandleAfterActionEvent() { var spanContext = active.Value; if (spanContext == null) { Logger?.LogDebug("HandleAfterActionEvent: Missing span context"); return; } IScope scope = spanContext.ActiveScope; if (scope != null) { scope.Dispose(); } active.Value = null; }
public async Task <ISingleResponse <Customer> > GetCustomer(string CustomerCode) { //throw new NotImplementedException(); Logger?.LogDebug("{0} has been invoked", nameof(GetCustomer)); var response = new SingleResponse <Customer>(); try { // Retrieve order by id response.Model = await customerRepository.GetCustomer(CustomerCode); } catch (Exception ex) { response.SetError(ex, Logger); } return(response); }
public async Task <ISingleResponse <Branch> > GetBranchByBranchCodeAsync(string branchCode) { //throw new NotImplementedException(); Logger?.LogDebug("{0} has been invoked", nameof(GetBranchByBranchCodeAsync)); var response = new SingleResponse <Branch>(); try { // Retrieve order by id response.Model = await branchRepository.GetBranchByBranchCodeAsync(branchCode); } catch (Exception ex) { response.SetError(ex, Logger); } return(response); }
public async Task <ISingleResponse <Order> > GetOrderAsync(Int64 id) { Logger?.LogDebug("{0} has been invoked", nameof(GetOrderAsync)); var response = new SingleResponse <Order>(); try { // Retrieve order by id response.Model = await SalesRepository .GetOrderAsync(new Order(id)); } catch (Exception ex) { response.SetError(ex, Logger); } return(response); }
protected internal void HandleStartEvent(HttpRequestMessage request) { if (ShouldIgnoreRequest(request.RequestUri.AbsolutePath)) { Logger?.LogDebug("HandleStartEvent: Ignoring path: {path}", request.RequestUri.AbsolutePath); return; } if (request.Properties.TryGetValue(SPANCONTEXT_KEY, out object context)) { Logger?.LogDebug("HandleStartEvent: Continuing existing span!"); return; } string spanName = ExtractSpanName(request); var parentSpan = GetCurrentSpan(); ISpan started; IScope scope; if (parentSpan != null) { scope = Tracer.SpanBuilderWithExplicitParent(spanName, parentSpan) .StartScopedSpan(out started); } else { scope = Tracer.SpanBuilder(spanName) .StartScopedSpan(out started); } request.Properties.Add(SPANCONTEXT_KEY, new SpanContext(started, scope)); started.PutClientSpanKindAttribute() .PutHttpRawUrlAttribute(request.RequestUri.ToString()) .PutHttpMethodAttribute(request.Method.ToString()) .PutHttpHostAttribute(request.RequestUri.Host, request.RequestUri.Port) .PutHttpPathAttribute(request.RequestUri.AbsolutePath) .PutHttpRequestHeadersAttribute(request.Headers.ToList()); InjectTraceContext(request, parentSpan); }
public virtual IUserDataClient Unsubscribe <TEventArgs>(string listenKey, Action <TEventArgs> callback) where TEventArgs : UserDataEventArgs { Logger?.LogDebug($"{nameof(UserDataClient)}.{nameof(Unsubscribe)}: \"{listenKey}\" (callback: {(callback == null ? "no" : "yes")}). [thread: {Thread.CurrentThread.ManagedThreadId}]"); var type = typeof(TEventArgs); if (callback != null) { if (type == typeof(AccountUpdateEventArgs)) { // ReSharper disable once InconsistentlySynchronizedField Unsubscribe(listenKey, callback as Action <AccountUpdateEventArgs>, _accountUpdateSubscribers); } else if (type == typeof(OrderUpdateEventArgs)) { // ReSharper disable once InconsistentlySynchronizedField Unsubscribe(listenKey, callback as Action <OrderUpdateEventArgs>, _orderUpdateSubscribers); } else if (type == typeof(AccountTradeUpdateEventArgs)) { // ReSharper disable once InconsistentlySynchronizedField Unsubscribe(listenKey, callback as Action <AccountTradeUpdateEventArgs>, _accountTradeUpdateSubscribers); } else { Unsubscribe(listenKey, callback as Action <UserDataEventArgs>, null); } } else { // ReSharper disable once InconsistentlySynchronizedField Unsubscribe(listenKey, null, _accountUpdateSubscribers); // ReSharper disable once InconsistentlySynchronizedField Unsubscribe(listenKey, null, _orderUpdateSubscribers); // ReSharper disable once InconsistentlySynchronizedField Unsubscribe(listenKey, null, _accountTradeUpdateSubscribers); Unsubscribe <UserDataEventArgs>(listenKey, null, null); } return(this); }
private void HandleMessage(string message) { if (string.IsNullOrWhiteSpace(message)) { Logger?.LogWarning($"下载器代理 {_options.AgentId} 接收到空消息"); return; } #if DEBUG Logger?.LogDebug($"下载器代理 {_options.AgentId} 接收到消息: {message}"); #endif try { var commandMessage = message.ToCommandMessage(); if (commandMessage == null) { Logger?.LogWarning($"下载器代理 {_options.AgentId} 接收到非法消息: {message}"); return; } switch (commandMessage.Command) { case Framework.DownloadCommand: { Download(commandMessage.Message).ConfigureAwait(false).GetAwaiter(); break; } case Framework.ExitCommand: { if (commandMessage.Message == _options.AgentId) { StopAsync(default).ConfigureAwait(true).GetAwaiter(); } else { Logger?.LogWarning($"下载器代理 {_options.AgentId} 收到错误的退出消息: {message}"); } break; }
public async Task <IActionResult> GetTransactions() { Logger?.LogDebug("'{0}' has been invoked", nameof(GetTransactions)); var response = new ListResponse <Transaction>(); try { var data = await GetAllTransactions(); response.Model = data; response.Message = $"Total of Transactions: {data.Count()}"; } catch (Exception ex) { ResponseError(response, ex, nameof(GetTransactions)); } return(response.ToHttpResponse()); }
public override async Task PublishAsync(CancellationToken cancellationToken) { var data = GetTelemetry(); var messageString = JsonConvert.SerializeObject(data); Logger?.LogDebug($"Telemetry message: {messageString}"); var encodedText = Encoding.UTF8.GetBytes($"{messageString}{_separator}"); try { await _fileStream.WriteAsync(encodedText, 0, encodedText.Length, cancellationToken); await _fileStream.FlushAsync(cancellationToken); } catch (ObjectDisposedException e) { Logger.LogCritical(e.Message); } }
/// <summary> /// Removes cached item by cachekey's prefix async. /// </summary> /// <remarks> /// Before using the method , you should follow this link /// https://github.com/memcached/memcached/wiki/ProgrammingTricks#namespacing /// and confirm that you use the namespacing when you set and get the cache. /// </remarks> /// <param name="prefix">Prefix of CacheKey.</param> /// <returns></returns> public override async Task BaseRemoveByPrefixAsync(string prefix) { ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix)); var oldPrefixKey = _memcachedClient.Get(prefix)?.ToString(); var newValue = DateTime.UtcNow.Ticks.ToString(); Logger?.LogDebug("RemoveByPrefixAsync : prefix = {0}", prefix); if (oldPrefixKey.Equals(newValue)) { newValue = string.Concat(newValue, new Random().Next(9).ToString()); } await _memcachedClient.StoreAsync( Enyim.Caching.Memcached.StoreMode.Set, this.HandleCacheKey(prefix), newValue, new TimeSpan(0, 0, 0)); }