public Response <GetSegmentAndDetailResponse> GetSegmentAndDetail(SegmentRequest request) { Response <GetSegmentAndDetailResponse> response = new Response <GetSegmentAndDetailResponse>() { Result = new GetSegmentAndDetailResponse() }; if (request == null || request.ID == 0) { ArgumentNullException ex = new ArgumentNullException("GetSegmentAndDetail request"); LogError(ex); response.ErrorCode = ErrorCode.Argument; response.Exception = ex; return(response); } try { SegmentAccessor accessor = new SegmentAccessor(); Segment segment; IEnumerable <SegmentDetail> segmentDetailCollection; accessor.GetSegmentAndDetail(request.ID, out segment, out segmentDetailCollection); response.Result.Segment = segment; response.Result.SegmentDetailCollection = segmentDetailCollection; response.IsSuccess = true; } catch (Exception ex) { LogError(ex); response.IsSuccess = false; response.ErrorCode = ErrorCode.Technical; } return(response); }
public Task Flush(CancellationToken token = default(CancellationToken)) { // todo performance optimization for ConcurrentQueue //var queued = _segmentQueue.Count; //var limit = queued <= _config.PendingSegmentLimit ? queued : _config.PendingSegmentLimit; var limit = _config.BatchSize; var index = 0; var segments = new List <SegmentRequest>(limit); SegmentRequest request = null; while (index++ < limit && _segmentQueue.TryDequeue(out request)) { segments.Add(request); Interlocked.Decrement(ref _offset); } // send async if (segments.Count > 0) { _segmentReporter.ReportAsync(segments, token); } Interlocked.Exchange(ref _offset, _segmentQueue.Count); return(Task.CompletedTask); }
public async Task <SegmentResponse> PutSegment(int id, SegmentRequest model) { var Segment = await _unitOfWork.Repository <Segment>().GetAll().Where(x => x.Id == id).FirstOrDefaultAsync(); if (Segment != null) { try { Segment.Name = model.Name; await _unitOfWork.Repository <Segment>().Update(Segment, id); await _unitOfWork.CommitAsync(); return(new SegmentResponse { Id = Segment.Id, Name = Segment.Name }); } catch (Exception e) { throw new CrudException(HttpStatusCode.BadRequest, "Update Segment Error!!!", e.InnerException?.Message); } } else { return(null); } }
/// <summary> /// Initializes a new instance of the <see cref="PathingEngineBase"/> class. /// </summary> /// <param name="moveCostProvider">The move cost provider.</param> /// <param name="cellCostStrategy">The cell cost provider.</param> /// <param name="smoother">The path smoother to use</param> protected PathingEngineBase(IMoveCost moveCostProvider, ICellCostStrategy cellCostStrategy, ISmoothPaths smoother) { Ensure.ArgumentNotNull(moveCostProvider, "moveCostProvider"); Ensure.ArgumentNotNull(cellCostStrategy, "cellCostStrategy"); Ensure.ArgumentNotNull(smoother, "smoother"); _costProvider = moveCostProvider; _smoother = smoother; _cellCostStrategy = cellCostStrategy; _coroutineIter = new SafeIterator(this); _segmentRequest = new SegmentRequest(); _segments = new DynamicArray<Path>(10); }
/// <summary> /// Initializes a new instance of the <see cref="PathingEngineBase"/> class. /// </summary> /// <param name="moveCostProvider">The move cost provider.</param> /// <param name="cellCostStrategy">The cell cost provider.</param> /// <param name="smoother">The path smoother to use</param> protected PathingEngineBase(IMoveCost moveCostProvider, ICellCostStrategy cellCostStrategy, ISmoothPaths smoother) { Ensure.ArgumentNotNull(moveCostProvider, "moveCostProvider"); Ensure.ArgumentNotNull(cellCostStrategy, "cellCostStrategy"); Ensure.ArgumentNotNull(smoother, "smoother"); _costProvider = moveCostProvider; _smoother = smoother; _cellCostStrategy = cellCostStrategy; _coroutineIter = new SafeIterator(this); _segmentRequest = new SegmentRequest(); _segments = new DynamicArray <Path>(10); }
public static SegmentObject Map(SegmentRequest request) { var traceSegment = new SegmentObject { TraceId = request.TraceId, //todo: is there chances request.UniqueIds.Count > 1 ? TraceSegmentId = request.Segment.SegmentId, Service = request.Segment.ServiceId, ServiceInstance = request.Segment.ServiceInstanceId, IsSizeLimited = false }; traceSegment.Spans.Add(request.Segment.Spans.Select(MapToSpan).ToArray()); return(traceSegment); }
public SegmentRequest Transform() { var upstreamSegment = new SegmentRequest { UniqueIds = _relatedGlobalTraces.GetRelatedGlobalTraces() .Select(x => x.ToUniqueId()).ToArray() }; upstreamSegment.Segment = new SegmentObjectRequest { SegmentId = TraceSegmentId.Transform(), Spans = _spans.Select(x => x.Transform()).ToArray(), ServiceId = ApplicationId, ServiceInstanceId = ApplicationInstanceId }; return(upstreamSegment); }
public static UpstreamSegment Map(SegmentRequest request) { var upstreamSegment = new UpstreamSegment(); upstreamSegment.GlobalTraceIds.AddRange(request.UniqueIds.Select(MapToUniqueId).ToArray()); var traceSegment = new TraceSegmentObject { TraceSegmentId = MapToUniqueId(request.Segment.SegmentId), ApplicationId = request.Segment.ServiceId, ApplicationInstanceId = request.Segment.ServiceInstanceId, IsSizeLimited = false }; traceSegment.Spans.Add(request.Segment.Spans.Select(MapToSpan).ToArray()); upstreamSegment.Segment = traceSegment.ToByteString(); return(upstreamSegment); }
private void trace(Channel channel, int serviceId, int serviceInstanceId) { var client = new TraceSegmentReportService.TraceSegmentReportServiceClient(channel); using (var asyncClientStreamingCall = client.collect()) { SegmentContextMapper context = new SegmentContextMapper(); SegmentRequest segment = context.Map(serviceId, serviceInstanceId, this.txtInputValue.Text); asyncClientStreamingCall.RequestStream.WriteAsync(SegmentV6Helpers.Map(segment)); asyncClientStreamingCall.RequestStream.CompleteAsync(); //cli //CommandLineApplication var var2 = Task.Run(async() => { return(await asyncClientStreamingCall.ResponseAsync); }).Result; } }
public Response <long> DeleteSegmentDetail(SegmentRequest request) { Response <long> response = new Response <long>(); if (request == null || request.ID == 0) { ArgumentNullException ex = new ArgumentNullException("GetSegmentAndDetail request"); LogError(ex); response.ErrorCode = ErrorCode.Argument; response.Exception = ex; return(response); } try { SegmentAccessor accessor = new SegmentAccessor(); int returnVal = 0; long segmentID = accessor.DeleteSegmentDetail(request.ID, out returnVal); if (returnVal == 1) { response.IsSuccess = true; response.Result = segmentID; } else { response.IsSuccess = false; response.Result = returnVal; } } catch (Exception ex) { LogError(ex); response.IsSuccess = false; response.ErrorCode = ErrorCode.Technical; } return(response); }
public async Task <SegmentResponse> PostSegment(SegmentRequest model) { Segment Segment = new Segment { Name = model.Name, }; try { await _unitOfWork.Repository <Segment>().InsertAsync(Segment); await _unitOfWork.CommitAsync(); return(new SegmentResponse { Id = Segment.Id, Name = Segment.Name }); } catch (Exception e) { throw new CrudException(HttpStatusCode.BadRequest, "Insert Segment Error!!!", e.InnerException?.Message); } }
public SegmentRequest Map(SegmentContext segmentContext) { var segmentRequest = new SegmentRequest { UniqueIds = new[] { MapUniqueId(segmentContext.TraceId) } }; var segmentObjectRequest = new SegmentObjectRequest { SegmentId = MapUniqueId(segmentContext.SegmentId), ServiceId = segmentContext.ServiceId, ServiceInstanceId = segmentContext.ServiceInstanceId }; segmentRequest.Segment = segmentObjectRequest; var span = new SpanRequest { SpanId = segmentContext.Span.SpanId, ParentSpanId = segmentContext.Span.ParentSpanId, OperationName = segmentContext.Span.OperationName, StartTime = segmentContext.Span.StartTime, EndTime = segmentContext.Span.EndTime, SpanType = (int)segmentContext.Span.SpanType, SpanLayer = (int)segmentContext.Span.SpanLayer, IsError = segmentContext.Span.IsError, Peer = segmentContext.Span.Peer, Component = segmentContext.Span.Component }; foreach (var reference in segmentContext.References) { span.References.Add(new SegmentReferenceRequest { ParentSegmentId = MapUniqueId(reference.ParentSegmentId), ParentServiceInstanceId = reference.ParentServiceInstanceId, ParentSpanId = reference.ParentSpanId, ParentEndpointName = reference.ParentEndpoint, EntryServiceInstanceId = reference.EntryServiceInstanceId, EntryEndpointName = reference.EntryEndpoint, NetworkAddress = reference.NetworkAddress, RefType = (int)reference.Reference }); } foreach (var tag in segmentContext.Span.Tags) { span.Tags.Add(new KeyValuePair <string, string>(tag.Key, tag.Value)); } foreach (var log in segmentContext.Span.Logs) { var logData = new LogDataRequest { Timestamp = log.Timestamp }; foreach (var data in log.Data) { logData.Data.Add(new KeyValuePair <string, string>(data.Key, data.Value)); } span.Logs.Add(logData); } segmentObjectRequest.Spans.Add(span); return(segmentRequest); }
public async Task <ActionResult <SegmentResponse> > PutSegment(int id, [FromBody] SegmentRequest model) { var rs = await _SegmentService.PutSegment(id, model); return(Ok(rs)); }
public ActionResult GetProductSegments([FromBody] SegmentRequest request) { return(new ProductPromotionManager().QueryProductSegment(request.Value)); }
public List <KeyWord> Segment(SegmentRequest request) { return(this.ServiceImpl.Segment(request.Sentence, request.Option)); }