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));
}
