// translate MvcRequest/Response into aspnet RequestDelegate
public static RequestDelegate ToWebSocket(this IAlteredPipeline <AlteredApiRequest, AlteredApiResponse> pipeline) =>
async(httpContext) =>
{
var request = httpContext.Request;
if (httpContext.WebSockets.IsWebSocketRequest)
{
var webSocket = await httpContext.WebSockets.AcceptWebSocketAsync();
var buffer = new byte[16384];
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), default(CancellationToken));
while (!webSocket.CloseStatus.HasValue)
{
var message = await webSocket.ReceiveMessage();
var apiRequest = JsonConvert.DeserializeObject <AlteredApiRequest>(message, AlteredJson.DefaultJsonSerializerSettings);
var apiResponse = await pipeline.Execute(apiRequest);
// ignore
}
}
else
{
// fallback
await pipeline.ToAspNet()(httpContext);
}
};
public CloudwatchLogs(IAlteredPipeline <TRequest, TResponse> operation, CloudwatchLogsSink logs, string name) : base(async(request) =>
{
var requestLog = new
{
Time = DateTime.UtcNow,
AlteredEnvironment.App,
AlteredEnvironment.Env,
AlteredEnvironment.Sha,
Name = name,
request.RequestId,
Request = request
};
logs.Log(requestLog);
var response = await operation.Execute(request);
Debug.Assert(request.RequestId == response.RequestId);
var responseLog = new
{
Time = DateTime.UtcNow,
AlteredEnvironment.App,
AlteredEnvironment.Env,
AlteredEnvironment.Sha,
Name = name,
response.RequestId,
Response = response
};
logs.Log(responseLog);
return(response);
})
{ }
public SimpleMvc(IAlteredPipeline <TRequest, TResponse> pipeline) : base(async(request) =>
{
var innerRequest = JsonConvert.DeserializeObject <TRequest>(request.Body, AlteredJson.DefaultJsonSerializerSettings);
var innerResponse = await pipeline.Execute(innerRequest);
var body = AlteredJson.SerializeObject(innerResponse);
return(new AlteredApiResponse
{
StatusCode = 200,
Body = body
});
})
{ }
public AlteredCache(IAlteredPipeline <TRequest, TResponse> f, Func <TRequest, string> getKey, CacheItemPolicy cacheItemPolicy, ObjectCache cache, AsyncLock cacheLock) : base(async(request) =>
{
var key = $"{f.GetType().GUID}:{getKey(request)}";
using (await cacheLock.LockAsync())
{
var response = cache.Get(key) as TResponse;
if (response == null)
{
response = await f.Execute(request);
cache.AddOrGetExisting(key, response, cacheItemPolicy);
}
return(response);
}
})
{
}
public Lambda(IAlteredPipeline <AlteredApiRequest, AlteredApiResponse> pipeline) : base(async(request) =>
{
var body = request.IsBase64Encoded ?
Convert.ToBase64String(Encoding.UTF8.GetBytes(request.Body)) :
request.Body;
var mvcRequest = new AlteredApiRequest
{
Path = request.Path,
HttpMethod = request.HttpMethod,
Headers = request.Headers.ToDictionary(kvp => kvp.Key, kvp => new StringValues(kvp.Value)),
QueryStringParameters = request.QueryStringParameters.ToDictionary(kvp => kvp.Key, kvp => new StringValues(kvp.Value)),
Body = body
};
try
{
var mvcResponse = await pipeline.Execute(mvcRequest);
var response = new ApplicationLoadBalancerResponse
{
StatusCode = mvcResponse.StatusCode,
Headers = mvcResponse.Headers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToString()),
Body = mvcResponse.Body
};
return(response);
}
catch (Exception e)
{
// lambda will write error + request if thrown to
Console.Error.WriteLine(AlteredJson.SerializeObject(new
{
e.Message,
e.Source,
StackTrace = new StackTrace(e).ToString(),
e.Data
}));
Console.Out.WriteLine(AlteredJson.SerializeObject(mvcRequest));
throw e;
}
})
{ }
// translate MvcRequest/Response into aspnet RequestDelegate
public static RequestDelegate ToAlteredAspNet(this IAlteredPipeline <AlteredApiRequest, AlteredApiResponse> pipeline) =>
async(httpContext) =>
{
var request = httpContext.Request;
using (var bodyReader = new StreamReader(request.Body))
{
var mvcRequest = new AlteredApiRequest
{
Path = request.Path,
HttpMethod = request.Method,
Headers = request.Headers,
QueryStringParameters = QueryHelpers.ParseQuery(request.QueryString.Value)
};
if (request.Body?.CanRead == true)
{
mvcRequest.Body = await bodyReader.ReadToEndAsync();
}
var mvcResponse = await pipeline.Execute(mvcRequest);
var response = httpContext.Response;
response.StatusCode = mvcResponse.StatusCode;
foreach (var kvp in mvcResponse.Headers)
{
response.Headers[kvp.Key] = kvp.Value;
}
if (!string.IsNullOrEmpty(mvcResponse.Body))
{
//response.ContentLength = mvcResponse.Body.Length;
response.ContentType = response.Headers[HeaderNames.ContentType];
using (var bodyWriter = new StreamWriter(response.Body))
{
await bodyWriter.WriteAsync(mvcResponse.Body);
}
}
}
};
public LogEcsTaskStateChange(IAlteredPipeline <ECSTaskStateChangeEvent, StringResponse> incomingPipeline) : base(incomingPipeline)
{
}
public AlteredPipelineEx(IAlteredPipeline <TRequest, TResponse> AlteredPipeline) =>
public DescribeTags(IAlteredPipeline <DescribeTagsRequest, DescribeTagsResponse> describeTags) : base(describeTags
// default cache of 5 mins for tags
.WithAlteredCache(getKey: request => AlteredJson.SerializeObject(request.LoadBalancerNames)))
{
}
public static DescribeTags ToDescribeTags(this IAlteredPipeline <DescribeTagsRequest, DescribeTagsResponse> describeTags) => new DescribeTags(describeTags);
public static Task <TResponse> Execute <TRequest, TResponse>(this IAlteredPipeline <IEnumerable <TRequest>, TResponse> p, TRequest single) => p
.Execute(new TRequest[] { single });
public static IAlteredPipeline <TRequest, TResponse> WithCloudwatchLogs <TRequest, TResponse>(this IAlteredPipeline <TRequest, TResponse> operation, CloudwatchLogsSink logs, [CallerMemberName] string name = null)
where TRequest : IRequestId
where TResponse : IRequestId, IStatusCode, IRequestDuration, new() =>
new CloudwatchLogs <TRequest, TResponse>(operation, logs, name);
public static IAlteredPipeline <TRequest, TResponse> WithAlteredLogsApi <TRequest, TResponse>(this IAlteredPipeline <TRequest, TResponse> pipeline)
where TRequest : IRequestId
where TResponse : IRequestId, IRequestDuration, IStatusCode =>
new AlteredLogsPipeline <TRequest, TResponse>(pipeline);
public AlteredSns(IAlteredPipeline <TRequest, TResponse> operation) : base(async(request) =>
{
throw new NotImplementedException();
}) {}
// translate MvcRequest/Response into ApplicationLoadBalancerRequest/Response public static ILambda WithLambda(this IAlteredPipeline <AlteredApiRequest, AlteredApiResponse> pipeline) => new Lambda(pipeline);
public AlteredLogsPipeline(IAlteredPipeline <TRequest, TResponse> incomingPipeline) : base(incomingPipeline
.AsFunc()
.WithCopyRequestId()
.WithMeasureRequestDuration())
{
}
public static Func <TRequest, Task <TResponse> > AsFunc <TRequest, TResponse>(this IAlteredPipeline <TRequest, TResponse> p) => p.Execute;
public static IAlteredPipeline <AlteredApiRequest, AlteredApiResponse> WithSimpleMvc <TRequest, TResponse>(this IAlteredPipeline <TRequest, TResponse> pipeline) => new SimpleMvc <TRequest, TResponse>(pipeline);
public static IAlteredPipeline <TRequest, TResponse> WithCloudwatchMetrics <TRequest, TResponse>(this IAlteredPipeline <TRequest, TResponse> operation, CloudwatchMetricsSink metrics, [CallerMemberName] string name = null)
where TResponse : IStatusCode, IRequestDuration =>
new CloudwatchMetrics <TRequest, TResponse>(operation, metrics, name);
public static IAlteredPipeline <TRequest, TResponse> WithAlteredCache <TRequest, TResponse>(this IAlteredPipeline <TRequest, TResponse> f, Func <TRequest, string> getKey, CacheItemPolicy cacheItemPolicy = null, ObjectCache cache = null, AsyncLock cacheLock = null)
where TResponse : class
{
cache = cache ?? MemoryCache.Default;
cacheItemPolicy = cacheItemPolicy ?? DefaultCacheItemPolicy;
cacheLock = cacheLock ?? new AsyncLock();
return(new AlteredCache <TRequest, TResponse>(f, getKey, cacheItemPolicy, cache, cacheLock));
}
public CloudwatchMetrics(IAlteredPipeline <TRequest, TResponse> operation, CloudwatchMetricsSink metrics, string name) : base(async(request) =>
{
var response = await operation.Execute(request);
var dimensions = new List <Dimension>
{
new Dimension
{
Name = nameof(AlteredEnvironment.App),
Value = AlteredEnvironment.App ?? "-"
},
new Dimension
{
Name = nameof(AlteredEnvironment.Env),
Value = AlteredEnvironment.Env ?? "-"
},
//new Dimension
//{
// Name = nameof(AlteredEnvironment.Sha),
// Value = AlteredEnvironment.Sha ?? "-"
//},
new Dimension
{
Name = "Name",
Value = name ?? "-"
}
};
var metricData = new List <MetricDatum>
{
new MetricDatum
{
MetricName = $"{name} Count",
TimestampUtc = DateTime.UtcNow,
Unit = StandardUnit.None,
Dimensions = dimensions
},
new MetricDatum
{
MetricName = $"{name} {nameof(response.RequestDuration)}",
TimestampUtc = DateTime.UtcNow,
Unit = StandardUnit.Milliseconds,
Dimensions = dimensions,
Value = response.RequestDuration
},
new MetricDatum
{
MetricName = $"{name} {response.StatusCode/100}XX Count",
TimestampUtc = DateTime.UtcNow,
Unit = StandardUnit.None,
Dimensions = dimensions
},
new MetricDatum
{
MetricName = $"{name} {response.StatusCode/100}XX {nameof(response.RequestDuration)}",
TimestampUtc = DateTime.UtcNow,
Unit = StandardUnit.Milliseconds,
Dimensions = dimensions,
Value = response.RequestDuration
}
};
var putMetricDataRequest = new PutMetricDataRequest
{
Namespace = AlteredEnvironment.Name,
MetricData = metricData
};
metrics.PutMetricData(putMetricDataRequest);
return(response);
})
{ }
