Exemple #1
0
        internal RpcServerContext(RpcServerTransaction trans)
        {
            _request     = trans.Request;
            _trans       = trans;
            _hasReturned = 0;

            _observer = RpcObserverManager.GetServerItem(_request.Service, _request.Method, _request.FromService, _request.FromComputer);
            _watch    = new Stopwatch();
            _watch.Start();
        }
Exemple #2
0
        public RpcServerContext(IRpcServerTransaction trans)
        {
            _request     = trans.ReceiveRequestHeader();
            _trans       = trans;
            _hasReturned = 0;

            _observer = RpcObserverManager.GetServerItem(_request.Service, _request.Method, _request.FromService, _request.FromComputer);
            _watch    = new Stopwatch();
            _watch.Start();
            // _perfCounters.ConcurrentContext.Increment();
        }
Exemple #3
0
        public void SendRequest(Action <long, RpcClientContext, bool> callback, int timeout)
        {
            RpcRequest request = _trans.Request;
            Stopwatch  watch   = new Stopwatch();

            _callback = callback;
            _observer = RpcObserverManager.GetClientItem(_trans.ServerUri.ToString(), request.Service, request.Method, _trans.ServiceRole);

            watch.Start();

            try {
                _trans.SendRequest(
                    delegate {
                    var response     = _trans.Response;
                    long elapseTicks = watch.ElapsedTicks;
                    bool successed   = response.ErrorCode == RpcErrorCode.OK;
                    _observer.Track(successed, response.Error, elapseTicks);
                    _callback(elapseTicks, this, successed);
                },
                    timeout
                    );

                TracingManager.Info(
                    delegate() {
                    _observer.RequestTracer.InfoFmt2(
                        request.ServiceAtComputer,
                        request.ContextUri,
                        "Args = {0}",
                        ObjectHelper.DumpObject(request.BodyValue)
                        );
                }
                    );
            } catch (Exception ex) {
                _observer.RequestTracer.ErrorFmt2(
                    ex,
                    request.FromService,
                    request.ContextUri.ToString(),
                    "Args = {0}",
                    ObjectHelper.DumpObject(request.BodyValue)
                    );

                var  response    = RpcResponse.Create(RpcErrorCode.SendFailed, ex);
                long elapseTicks = watch.ElapsedTicks;
                _observer.Track(false, response.Error, elapseTicks);
                _callback(elapseTicks, this, false);
            }
        }
        internal void SendRequest <TArgs>(TArgs args, int timeout)
        {
            _observer = RpcObserverManager.GetClientItem(_request.ServerUri, _request.Service, _request.Method, _serviceRole);

            Stopwatch watch = new Stopwatch();

            watch.Start();

            try {
                _args = args;
                _trans.SendRequest <TArgs>(
                    _request,
                    args,
                    response => ProcessResponse(response, watch.ElapsedTicks),
                    timeout
                    );

                TracingManager.Info(
                    delegate() {
                    _observer.RequestTracer.InfoFmt2(
                        _request.FromService,
                        _request.ToUri,
                        "Args = {0}",
                        ObjectHelper.DumpObject(_args)
                        );
                }
                    );
            } catch (Exception ex) {
                _observer.RequestTracer.ErrorFmt2(
                    ex,
                    _request.FromService,
                    _request.ToUri.ToString(),
                    "Args = {0}",
                    ObjectHelper.DumpObject(_args)
                    );
                throw;
            }
        }