Пример #1
0
 public async Task <ChangeStateResponse> ChangeStateAsync(
     string machineName,
     string queueId,
     MachineStateChangeRequest requestInfo,
     CancellationToken cancellationToken = default
     )
 {
     using (var _res = await ChangeStateInternalAsync(
                machineName,
                queueId,
                requestInfo,
                cancellationToken
                ).ConfigureAwait(false))
     {
         return(_res.Body);
     }
 }
Пример #2
0
 public async Task <Newtonsoft.Json.Linq.JToken> ChangeStateAsync(
     MachineStateChangeRequest body,
     string machineName,
     string queueId,
     CancellationToken cancellationToken = default
     )
 {
     using (var _res = await ChangeStateInternalAsync(
                body,
                machineName,
                queueId,
                cancellationToken
                ).ConfigureAwait(false))
     {
         return(_res.Body);
     }
 }
Пример #3
0
        internal async Task <HttpOperationResponse <ChangeStateResponse> > ChangeStateInternalAsync(
            string machineName,
            string queueId,
            MachineStateChangeRequest requestInfo,
            CancellationToken cancellationToken = default
            )
        {
            if (string.IsNullOrEmpty(machineName))
            {
                throw new ArgumentNullException(nameof(machineName));
            }

            if (string.IsNullOrEmpty(queueId))
            {
                throw new ArgumentNullException(nameof(queueId));
            }

            if (requestInfo == default)
            {
                throw new ArgumentNullException(nameof(requestInfo));
            }


            var _path = "/api/2018-03-14/machines/{queueId}/{machineName}/state";

            _path = _path.Replace("{queueId}", Client.Serialize(queueId));
            _path = _path.Replace("{machineName}", Client.Serialize(machineName));

            var _query = new QueryBuilder();

            var _uriBuilder = new UriBuilder(Client.BaseUri);

            _uriBuilder.Path  = _uriBuilder.Path.TrimEnd('/') + _path;
            _uriBuilder.Query = _query.ToString();
            var _url = _uriBuilder.Uri;

            HttpRequestMessage  _req = null;
            HttpResponseMessage _res = null;

            try
            {
                _req = new HttpRequestMessage(HttpMethod.Put, _url);

                string _requestContent = null;
                if (requestInfo != default)
                {
                    _requestContent = Client.Serialize(requestInfo);
                    _req.Content    = new StringContent(_requestContent, Encoding.UTF8)
                    {
                        Headers =
                        {
                            ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"),
                        },
                    };
                }

                if (Client.Credentials != null)
                {
                    await Client.Credentials.ProcessHttpRequestAsync(_req, cancellationToken).ConfigureAwait(false);
                }

                _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false);

                string _responseContent;
                if (!_res.IsSuccessStatusCode)
                {
                    _responseContent = await _res.Content.ReadAsStringAsync().ConfigureAwait(false);

                    var ex = new RestApiException(
                        new HttpRequestMessageWrapper(_req, _requestContent),
                        new HttpResponseMessageWrapper(_res, _responseContent));
                    HandleFailedChangeStateRequest(ex);
                    HandleFailedRequest(ex);
                    Client.OnFailedRequest(ex);
                    throw ex;
                }
                _responseContent = await _res.Content.ReadAsStringAsync().ConfigureAwait(false);

                return(new HttpOperationResponse <ChangeStateResponse>
                {
                    Request = _req,
                    Response = _res,
                    Body = Client.Deserialize <ChangeStateResponse>(_responseContent),
                });
            }
            catch (Exception)
            {
                _req?.Dispose();
                _res?.Dispose();
                throw;
            }
        }
Пример #4
0
        public async Task <Newtonsoft.Json.Linq.JToken> ChangeStateAsync(
            MachineStateChangeRequest body,
            string machineName,
            string queueId,
            CancellationToken cancellationToken = default
            )
        {
            if (body == default(MachineStateChangeRequest))
            {
                throw new ArgumentNullException(nameof(body));
            }

            if (string.IsNullOrEmpty(machineName))
            {
                throw new ArgumentNullException(nameof(machineName));
            }

            if (string.IsNullOrEmpty(queueId))
            {
                throw new ArgumentNullException(nameof(queueId));
            }


            var _baseUri = Client.Options.BaseUri;
            var _url     = new RequestUriBuilder();

            _url.Reset(_baseUri);
            _url.AppendPath(
                "/api/2019-06-17/machines/{queueId}/{machineName}/state".Replace("{queueId}", Uri.EscapeDataString(Client.Serialize(queueId))).Replace("{machineName}", Uri.EscapeDataString(Client.Serialize(machineName))),
                false);



            using (var _req = Client.Pipeline.CreateRequest())
            {
                _req.Uri    = _url;
                _req.Method = RequestMethod.Put;

                if (body != default(MachineStateChangeRequest))
                {
                    _req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));
                    _req.Headers.Add("Content-Type", "application/json; charset=utf-8");
                }

                using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
                {
                    if (_res.Status < 200 || _res.Status >= 300)
                    {
                        await OnChangeStateFailed(_req, _res).ConfigureAwait(false);
                    }

                    if (_res.ContentStream == null)
                    {
                        await OnChangeStateFailed(_req, _res).ConfigureAwait(false);
                    }

                    using (var _reader = new StreamReader(_res.ContentStream))
                    {
                        var _content = await _reader.ReadToEndAsync().ConfigureAwait(false);

                        var _body = Client.Deserialize <Newtonsoft.Json.Linq.JToken>(_content);
                        return(_body);
                    }
                }
            }
        }