Esempio n. 1
0
        public async Task <StoredHttpSession> StoreRequestAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            Guard.ArgumentNotNull(request, "request");

            var session = new StoredHttpSession {
                Timestamp = DateTimeOffset.UtcNow, Id = Guid.NewGuid()
            };

            string partitionKey = GetPartitionKey(session);
            string rowKey       = GetRequestRowKey(session);

            request.Content = await StoreContentAsync(rowKey, request.Content, cancellationToken);

            var entity = new HttpRequestMessageEntity
            {
                PartitionKey   = partitionKey,
                RowKey         = rowKey,
                Method         = request.Method.Method,
                RequestUri     = request.RequestUri.ToString(),
                Version        = request.Version.ToString(),
                Headers        = SerializeHeaders(request.Headers),
                ContentHeaders = request.Content != null?SerializeHeaders(request.Content.Headers) : null,
                                     HasContent          = request.Content != null,
                                     IsContentCompressed = _useCompression
            };
            await _table.ExecuteAsync(TableOperation.Insert(entity), cancellationToken);

            return(session);
        }
Esempio n. 2
0
        public async Task <HttpRequestMessage> GetRequestAsync(StoredHttpSession session, CancellationToken cancellationToken)
        {
            Guard.ArgumentNotNull(session, "session");

            string partitionKey = GetPartitionKey(session);
            string rowKey       = GetRequestRowKey(session);

            TableResult result = await _table.ExecuteAsync(TableOperation.Retrieve <HttpRequestMessageEntity>(partitionKey, rowKey), cancellationToken);

            if (result.Result == null)
            {
                return(null);
            }

            var entity  = (HttpRequestMessageEntity)result.Result;
            var request = new HttpRequestMessage
            {
                Method     = new HttpMethod(entity.Method),
                RequestUri = new Uri(entity.RequestUri),
                Version    = new Version(entity.Version)
            };

            request.Headers.AddRange(DeserializeHeaders(entity.Headers));
            if (entity.HasContent)
            {
                request.Content = await GetStoredHttpContentAsync(rowKey, DeserializeHeaders(entity.ContentHeaders), entity.IsContentCompressed, cancellationToken);
            }

            return(request);
        }
Esempio n. 3
0
        public async Task <HttpResponseMessage> GetResponseAsync(StoredHttpSession session, CancellationToken cancellationToken)
        {
            Guard.ArgumentNotNull(session, "session");

            string partitionKey = GetPartitionKey(session);
            string rowKey       = GetResponseRowKey(session);

            TableResult result = await _table.ExecuteAsync(TableOperation.Retrieve <HttpResponseMessageEntity>(partitionKey, rowKey), cancellationToken);

            if (result.Result == null)
            {
                return(null);
            }

            var entity   = (HttpResponseMessageEntity)result.Result;
            var response = new HttpResponseMessage
            {
                Version      = new Version(entity.Version),
                StatusCode   = (HttpStatusCode)entity.StatusCode,
                ReasonPhrase = entity.ReasonPhrase,
            };

            response.Headers.AddRange(DeserializeHeaders(entity.Headers));
            if (entity.HasContent)
            {
                response.Content = await GetStoredHttpContentAsync(rowKey, DeserializeHeaders(entity.ContentHeaders), entity.IsContentCompressed, cancellationToken);
            }

            return(response);
        }
Esempio n. 4
0
        public async Task StoreResponseAsync(StoredHttpSession session, HttpResponseMessage response, CancellationToken cancellationToken)
        {
            Guard.ArgumentNotNull(session, "session");
            Guard.ArgumentNotNull(response, "response");

            string partitionKey = GetPartitionKey(session);
            string rowKey       = GetResponseRowKey(session);

            response.Content = await StoreContentAsync(rowKey, response.Content, cancellationToken);

            var entity = new HttpResponseMessageEntity
            {
                PartitionKey   = partitionKey,
                RowKey         = rowKey,
                Version        = response.Version.ToString(),
                StatusCode     = (int)response.StatusCode,
                ReasonPhrase   = response.ReasonPhrase,
                Headers        = SerializeHeaders(response.Headers),
                ContentHeaders = response.Content != null?SerializeHeaders(response.Content.Headers) : null,
                                     HasContent          = response.Content != null,
                                     IsContentCompressed = _useCompression
            };
            await _table.ExecuteAsync(TableOperation.Insert(entity), cancellationToken);
        }
Esempio n. 5
0
 private static string GetPartitionKey(StoredHttpSession session)
 {
     return(DateTimeOffset.MinValue.GetDescendingOrderString());
 }
Esempio n. 6
0
 private static string GetRowKey(StoredHttpSession session, string suffix)
 {
     return(string.Join("-", new[] { session.Timestamp.GetDescendingOrderString(), Base64Url.Encode(session.Id.ToByteArray()), suffix }));
 }
Esempio n. 7
0
 private static string GetResponseRowKey(StoredHttpSession session)
 {
     return(GetRowKey(session, ResponseRowKeySuffix));
 }