public override ElasticsearchResponse <TReturn> Request <TReturn>(RequestData requestData)
        {
            this.Calls.Should().ContainKey(requestData.Uri.Port);

            var state = this.Calls[requestData.Uri.Port];

            if (IsSniffRequest(requestData))
            {
                var sniffed = Interlocked.Increment(ref state.Sniffed);
                return(HandleRules <TReturn, ISniffRule>(
                           requestData,
                           this._cluster.SniffingRules,
                           (r) => this.UpdateCluster(r.NewClusterState),
                           () => SniffResponse.Create(this._cluster.Nodes)
                           ));
            }
            if (IsPingRequest(requestData))
            {
                var pinged = Interlocked.Increment(ref state.Pinged);
                return(HandleRules <TReturn, IRule>(
                           requestData,
                           this._cluster.PingingRules,
                           (r) => { },
                           () => null              //HEAD request
                           ));
            }
            var called = Interlocked.Increment(ref state.Called);

            return(HandleRules <TReturn, IClientCallRule>(
                       requestData,
                       this._cluster.ClientCallRules,
                       (r) => { },
                       () => CallResponse()          //TODO search response
                       ));
        }
Beispiel #2
0
        public override ElasticsearchResponse <TReturn> Request <TReturn>(RequestData requestData)
        {
            this.Calls.Should().ContainKey(requestData.Uri.Port);
            try
            {
                var state = this.Calls[requestData.Uri.Port];
                if (IsSniffRequest(requestData))
                {
                    var sniffed = Interlocked.Increment(ref state.Sniffed);
                    return(HandleRules <TReturn, ISniffRule>(
                               requestData,
                               this._cluster.SniffingRules,
                               requestData.RequestTimeout,
                               (r) => this.UpdateCluster(r.NewClusterState),
                               (r) => SniffResponse.Create(this._cluster.Nodes, this._cluster.PublishAddressOverride, this._cluster.SniffShouldReturnFqnd)
                               ));
                }
                if (IsPingRequest(requestData))
                {
                    var pinged = Interlocked.Increment(ref state.Pinged);
                    return(HandleRules <TReturn, IRule>(
                               requestData,
                               this._cluster.PingingRules,
                               requestData.PingTimeout,
                               (r) => { },
                               (r) => null                  //HEAD request
                               ));
                }
                var called = Interlocked.Increment(ref state.Called);
                return(HandleRules <TReturn, IClientCallRule>(
                           requestData,
                           this._cluster.ClientCallRules,
                           requestData.RequestTimeout,
                           (r) => { },
                           CallResponse
                           ));
            }
#if DOTNETCORE
            catch (System.Net.Http.HttpRequestException e)
#else
            catch (WebException e)
#endif
            {
                var builder = new ResponseBuilder <TReturn>(requestData);
                builder.Exception = e;
                return(builder.ToResponse());
            }
        }