/// <summary>
/// The method to create the controller object from the requested routing information
/// This methods loads the xml file where the Controller information
/// with its full qualify path stored. The XLinq is used to load the xml file.
/// The xml file is queried using xlinq based upon the controllerName.
/// The information received from the cml file is stored into the Dictionary<string,string> object.
/// From this dictionary object the controller object is created and using the Activator object
/// the controller instance is created to whcih the Logger object is passed.
/// </summary>
/// <param name="requestContext"></param>
/// <param name="controllerName"></param>
/// <returns></returns>
public IController CreateController(System.Web.Routing.RequestContext requestContext, string controllerName)
{
IController controllerType = null;
Type typeData = null;
XDocument xdoc = XDocument.Load(HostingEnvironment.MapPath(@"~/Controllers.xml"));
var controllerData = (from controller in xdoc.Descendants("ControllerName")
select new ControllerInfo()
{
ControllerKey = controller.Descendants("Class").First().Value,
ControllerPath = controller.Descendants("FullPath").First().Value
}).ToList();
Dictionary <string, string> controllersDictionary = new Dictionary <string, string>();
foreach (var item in controllerData)
{
controllersDictionary.Add(item.ControllerKey, item.ControllerPath);
}
string controllerTypeName = null;
if (controllersDictionary.TryGetValue(controllerName, out controllerTypeName))
{
typeData = Type.GetType(controllerTypeName);
}
IRequestLogger logger = new RequestLogger();
controllerType = (IController)Activator.CreateInstance(typeData, logger);
return(controllerType);
}
private void Context_BeginRequest(object sender, EventArgs e)
{
_log.Debug("开始执行 BeginRequest");
HttpApplication context = sender as HttpApplication;
requestLog = RequestLogger.CreateRequestLog(context.Request);
if (!RequestLoggerEventHandler.BeginRequestLoggerHandler(context.Request, requestLog))
{
return;
}
try
{
using (var requestLoggerRepository = GetConnection())
{
requestLoggerRepository.AddRequestLogger(requestLog);
requestLoggerRepository.SaveChange();
}
}catch (Exception ex)
{
_log.Error(ex);
throw ex;
}
RequestLoggerEventHandler.AlfterBeginRequestLoggerHandler(context.Request, requestLog);
_log.Debug("结束执行 BeginRequest");
}
public async Task Invoke(HttpContext httpContext, RequestLogger requestLogger)
{
var log = new RequestLogModel();
try
{
log = await requestLogger.RequestIndiactor(httpContext);
using (var memStream = new MemoryStream())
{
var originalResponseBody = httpContext.Response.Body;
httpContext.Response.Body = memStream;
httpContext.Items.Add("RequestLog", log);
await _next(httpContext);
memStream.Position = 0;
log.Response = new StreamReader(memStream).ReadToEnd();
memStream.Position = 0;
await memStream.CopyToAsync(originalResponseBody);
httpContext.Response.Body = originalResponseBody;
}
await requestLogger.ResponseIndiactor(httpContext, log);
}
catch (Exception ex)
{
await requestLogger.ExceptionIndiactor(httpContext, log, ex);
throw;
}
}
public async Task ChecksHttpGetVerb(WebhookConfig config, HttpMethod httpMethod, string payload, HttpStatusCode expectedResponseCode, string expectedResponseBody)
{
var mockHttp = new MockHttpMessageHandler();
var request = mockHttp.When(httpMethod, config.Uri)
.Respond(expectedResponseCode, "application/json", expectedResponseBody);
var mockBigBrother = new Mock <IBigBrother>();
var httpClients = new Dictionary <string, HttpClient> {
{ new Uri(config.Uri).Host, mockHttp.ToHttpClient() }
};
var httpClientBuilder = new HttpClientFactory(httpClients);
var requestBuilder = new RequestBuilder();
var requestLogger = new RequestLogger(mockBigBrother.Object);
var genericWebhookHandler = new GenericWebhookHandler(
httpClientBuilder,
new Mock <IAuthenticationHandlerFactory>().Object,
requestBuilder,
requestLogger,
mockBigBrother.Object,
config);
await genericWebhookHandler.CallAsync(new MessageData(payload, "TestType", "subA", "service") { CorrelationId = Guid.NewGuid().ToString() }, new Dictionary <string, object>(), _cancellationToken);
Assert.Equal(1, mockHttp.GetMatchCount(request));
}
public void Initialize()
{
_dateTimeMock
.Setup(m => m.UtcNow)
.Returns(_utcNow);
_logger = new RequestLogger(_dateTimeMock.Object);
}
public ActionResult Get(string loc1, string loc2, string profile = "", bool instructions = false,
string lang = "en")
{
try
{
var from = Utility.ParseCoordinate(loc1);
var to = Utility.ParseCoordinate(loc2);
var route = RouterInstance.Calculate(profile, from, to);
route.PruneColours();
GeoJsonFeatureCollection instr = null;
if (instructions)
{
instr = RouterInstance.GenerateInstructions(route, lang);
}
RequestLogger.LogRequest(from, to);
return(Json(new RouteResponse(route, instr)));
}
catch (ResolveException e)
{
Log.Error(e, "Getting a route failed (not found)");
return(NotFound(e.Message));
}
catch (Exception e)
{
Log.Error(e, "Getting a route failed (other error)");
return(BadRequest(e.Message));
}
}
protected async Task <GatewayResponse> SendRequestAsync(string endpoint, MultipartFormDataContent content)
{
HttpClient httpClient = new HttpClient {
Timeout = TimeSpan.FromMilliseconds(Timeout)
};
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, ServiceUrl + endpoint);
HttpResponseMessage response = null;
try {
RequestLogger?.RequestSent(content.ToString());
request.Content = content;
response = await httpClient.SendAsync(request);
string rawResponse = response.Content.ReadAsStringAsync().Result;
RequestLogger?.ResponseReceived(rawResponse);
return(new GatewayResponse {
StatusCode = response.StatusCode,
RequestUrl = response.RequestMessage.RequestUri.ToString(),
RawResponse = rawResponse
});
}
catch (Exception exc) {
throw new GatewayException("Error occurred while communicating with gateway.", exc);
}
finally { }
}
public async Task<FileContentResult> GetLoRes(int id)
{
using (SAEONLogs.MethodCall(GetType(), new MethodCallParameters { { nameof(id), id } }))
{
try
{
var image = await dbContext.Images.FirstOrDefaultAsync(i => i.Id == id);
//Guard.IsNotNull(image, nameof(image));
if (image == null)
{
throw new ArgumentOutOfRangeException(nameof(id));
}
var fileName = Path.Combine(environment.ContentRootPath, image.Link.RemoveStartingBackSlash().RemoveStartingForwardSlash());
using (MemoryStream outStream = new MemoryStream())
using (var jpgImage = await SixLabors.ImageSharp.Image.LoadAsync(fileName))
{
await jpgImage.SaveAsJpegAsync(outStream);
var imageBytes = outStream.ToArray();
var result = new FileContentResult(imageBytes, MediaTypeNames.Image.Jpeg);
var contentDisposition = new ContentDispositionHeaderValue("inline");
contentDisposition.FileName = Path.GetFileName(fileName);
Response.Headers[HeaderNames.ContentDisposition] = contentDisposition.ToString();
await RequestLogger.LogAsync(dbContext, Request, $"{image.Name}|{image.Link}");
return result;
}
}
catch (Exception ex)
{
SAEONLogs.Exception(ex);
throw;
}
}
}
internal void CheckForRoutingUpdates(HttpContextBase context)
{
HttpResponseBase response = context.Response;
string routingUpdatesHeaderValue = response.Headers["X-RoutingEntryUpdate"];
if (string.IsNullOrEmpty(routingUpdatesHeaderValue))
{
return;
}
response.Headers.Remove("X-RoutingEntryUpdate");
if (this.diagnostics == null)
{
RequestLogger logger = RequestLogger.GetLogger(context);
this.diagnostics = new RouteRefresherDiagnostics(logger);
}
if (this.routeRefresher == null)
{
this.routeRefresher = new RouteRefresher(this.diagnostics);
}
this.diagnostics.LogRouteRefresherLatency(delegate
{
this.routeRefresher.ProcessRoutingUpdates(routingUpdatesHeaderValue);
});
this.routeRefresher = null;
this.diagnostics = null;
}
public async Task ShouldNotCallGetUserNameAsyncOnceIfUnauthenticated()
{
var requestLogger = new RequestLogger <CreateTodoItemCommand>(_logger.Object, _currentUserService.Object, _identityService.Object);
await requestLogger.Process(new CreateTodoItemCommand { ListId = 1, Title = "title" }, new CancellationToken());
_identityService.Verify(i => i.GetUserNameAsync(null), Times.Never);
}
protected GatewayResponse SendRequest(HttpMethod verb, string endpoint, string data = null, Dictionary <string, string> queryStringParams = null, string contentType = null)
{
HttpClient httpClient = new HttpClient {
Timeout = TimeSpan.FromMilliseconds(Timeout)
};
var queryString = BuildQueryString(queryStringParams);
HttpRequestMessage request = new HttpRequestMessage(verb, ServiceUrl + endpoint + queryString);
foreach (var item in Headers)
{
request.Headers.Add(item.Key, item.Value);
}
HttpResponseMessage response = null;
try {
if (verb != HttpMethod.Get && data != null)
{
request.Content = new StringContent(data, Encoding.UTF8, contentType ?? _contentType);
RequestLogger?.RequestSent(data);
}
response = httpClient.SendAsync(request).Result;
string rawResponse = string.Empty;
if (response.Content.Headers.ContentEncoding.Contains("gzip"))
{
var result = response.Content.ReadAsByteArrayAsync().Result;
using (GZipStream gzipStream = new GZipStream(new MemoryStream(result), CompressionMode.Decompress)) {
using (var stream = new MemoryStream()) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = gzipStream.Read(buffer, 0, buffer.Length)) > 0)
{
stream.Write(buffer, 0, bytesRead);
}
rawResponse = new UTF8Encoding().GetString(stream.ToArray());
}
}
}
else
{
rawResponse = response.Content.ReadAsStringAsync().Result;
}
RequestLogger?.ResponseReceived(rawResponse);
return(new GatewayResponse {
StatusCode = response.StatusCode,
RequestUrl = response.RequestMessage.RequestUri.ToString(),
RawResponse = rawResponse
});
}
catch (Exception exc) {
throw new GatewayException("Error occurred while communicating with gateway.", exc);
}
finally { }
}
public void NoLogger_PassThrough()
{
RequestLogger middleware = new RequestLogger(env =>
{
return(TaskHelpers.Completed());
});
middleware.Invoke(Request.Create().Environment).Wait();
}
public RouteSelectorDiagnostics(RequestLogger baseLogger)
{
this.baseLogger = baseLogger;
this.accountForestLatencies = new List <long>(2);
this.globalLocatorLatencies = new List <long>(2);
this.resourceForestLatencies = new List <long>(2);
this.serverLocatorLatencies = new List <long>(2);
this.sharedCacheLatencies = new List <long>(2);
}
private void LastChanceExceptionHandler(Exception unhandledException)
{
RequestLogger logger = RequestLogger.GetLogger(new HttpContextWrapper(HttpContext.Current));
if (logger != null)
{
logger.LastChanceExceptionHandler(unhandledException);
}
}
public void NoLogger_PassThrough()
{
RequestLogger middleware = new RequestLogger(env =>
{
return TaskHelpers.Completed();
});
middleware.Invoke(Request.Create().Environment).Wait();
}
public async Task ShouldCallGetUserNameAsyncOnceIfAuthenticated()
{
_currentUserService.Setup(x => x.UserId).Returns("Administrator");
var requestLogger = new RequestLogger <CreateTodoItemCommand>(_logger.Object, _currentUserService.Object, _identityService.Object);
await requestLogger.Process(new CreateTodoItemCommand { ListId = 1, Title = "title" }, new CancellationToken());
_identityService.Verify(i => i.GetUserNameAsync(It.IsAny <string>()), Times.Once);
}
public void TestRequestLogger_None()
{
RequestLogger logger = new RequestLogger(".\\log", RequestLogLevel.None);
Assert.IsTrue(!Directory.Exists(".\\log\\deadletter"), "deadletter directory is created while log level is set to none");
Assert.IsTrue(!Directory.Exists(".\\log\\successful"), "successful directory is created while log level is set to none");
// These calls should do nothing, shouldn't fail either.
logger.LogSuccess("body");
logger.LogFailure("body");
}
public async Task CheckWebhookCall(SubscriberConfiguration config, MessageData messageData, string expectedUri, string expectedContent)
{
var mockHttpHandler = new MockHttpMessageHandler();
var mockWebHookRequestWithCallback = mockHttpHandler.When(HttpMethod.Post, expectedUri)
.WithContentType("application/json", expectedContent)
.Respond(HttpStatusCode.OK, "application/json", "{\"msg\":\"Hello World\"}");
var mockBigBrother = new Mock <IBigBrother>();
var httpClients = new Dictionary <string, HttpClient>
{
{ new Uri(config.Uri).Host, mockHttpHandler.ToHttpClient() },
{ new Uri(config.Callback.Uri).Host, mockHttpHandler.ToHttpClient() }
};
var mockTokenHandler = new Mock <IAuthenticationHandler>();
mockTokenHandler.Setup(s => s.GetTokenAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(Guid.NewGuid().ToString);
var mockAuthHandlerFactory = new Mock <IAuthenticationHandlerFactory>();
mockAuthHandlerFactory.Setup(s => s.GetAsync(It.IsAny <WebhookConfig>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => mockTokenHandler.Object);
var httpClientBuilder = new HttpClientFactory(httpClients);
var requestBuilder = new RequestBuilder();
var requestLogger = new RequestLogger(mockBigBrother.Object);
var mockHandlerFactory = new Mock <IEventHandlerFactory>();
mockHandlerFactory.Setup(s => s.CreateWebhookHandler(config.Callback.Name)).Returns(
new GenericWebhookHandler(
httpClientBuilder,
mockAuthHandlerFactory.Object,
requestBuilder,
requestLogger,
mockBigBrother.Object,
config.Callback));
var webhookResponseHandler = new WebhookResponseHandler(
mockHandlerFactory.Object,
httpClientBuilder,
requestBuilder,
mockAuthHandlerFactory.Object,
requestLogger,
mockBigBrother.Object,
config);
await webhookResponseHandler.CallAsync(messageData, new Dictionary <string, object>(), _cancellationToken);
mockAuthHandlerFactory.Verify(e => e.GetAsync(It.IsAny <WebhookConfig>(), _cancellationToken), Times.Once);
Assert.Equal(1, mockHttpHandler.GetMatchCount(mockWebHookRequestWithCallback));
}
public async Task ExecuteHappyPathRawContract()
{
var(messageData, metaData) = EventHandlerTestHelper.CreateMessageDataPayload();
var config = new WebhookConfig
{
Uri = "http://localhost/webhook",
HttpMethod = HttpMethod.Put,
EventType = "Event1",
AuthenticationConfig = new AuthenticationConfig(),
WebhookRequestRules = new List <WebhookRequestRule>
{
new WebhookRequestRule
{
Source = new ParserLocation
{
Path = "OrderCode"
},
Destination = new ParserLocation
{
Location = Location.Uri
}
}
}
};
var mockHttp = new MockHttpMessageHandler();
var webhookRequest = mockHttp.When(HttpMethod.Put, $"{config.Uri}/{metaData["OrderCode"]}")
.WithContentType("application/json", messageData.Payload)
.Respond(HttpStatusCode.OK, "application/json", string.Empty);
var mockBigBrother = new Mock <IBigBrother>();
var httpClients = new Dictionary <string, HttpClient> {
{ new Uri(config.Uri).Host, mockHttp.ToHttpClient() }
};
var httpClientBuilder = new HttpClientFactory(httpClients);
var requestBuilder = new RequestBuilder();
var requestLogger = new RequestLogger(mockBigBrother.Object);
var genericWebhookHandler = new GenericWebhookHandler(
httpClientBuilder,
new Mock <IAuthenticationHandlerFactory>().Object,
requestBuilder,
requestLogger,
mockBigBrother.Object,
config);
await genericWebhookHandler.CallAsync(messageData, new Dictionary <string, object>(), _cancellationToken);
Assert.Equal(1, mockHttp.GetMatchCount(webhookRequest));
}
public void Logger_Logged()
{
RequestLogger middleware = new RequestLogger(env =>
{
return TaskHelpers.Completed();
});
StringWriter writer = new StringWriter();
Request request = Request.Create();
request.TraceOutput = writer;
middleware.Invoke(request.Environment).Wait();
Assert.That(writer.GetStringBuilder().ToString(), Is.Not.EqualTo(string.Empty));
}
public void リクエストからログ文字列に変換ができる()
{
var expected = @"POST http://hoge/piyo HTTP /1.1
Host: hoge
Connection: Keep-Alive
<request></request>";
var headers = new NameValueCollection();
headers.Add("Host", "hoge");
headers.Add("Connection", "Keep-Alive");
Assert.That(RequestLogger.ToString("POST", new Uri("http://hoge/piyo"), headers, @"<request></request>"), Is.EqualTo(expected));
}
public void UpdateRequestLogger(RequestLogger requestLogger)
{
var model = requestLoggers.FirstOrDefault(p => p.Id.Equals(requestLogger.Id));
if (model != null)
{
model.EndRequest();
}
else
{
requestLogger.EndRequest();
AddRequestLogger(requestLogger);
}
}
protected GatewayResponse SendRequest(HttpMethod verb, string endpoint, string data = null, Dictionary <string, string> queryStringParams = null, string contentType = null)
{
HttpClient httpClient = new HttpClient(HttpClientHandlerBuilder.Build(WebProxy))
{
Timeout = TimeSpan.FromMilliseconds(Timeout)
};
var queryString = BuildQueryString(queryStringParams);
HttpRequestMessage request = new HttpRequestMessage(verb, ServiceUrl + endpoint + queryString);
foreach (var item in Headers)
{
request.Headers.Add(item.Key, item.Value);
}
if (DynamicHeaders != null)
{
foreach (var item in DynamicHeaders)
{
request.Headers.Add(item.Key, item.Value);
}
}
HttpResponseMessage response = null;
try {
if (verb != HttpMethod.Get && data != null)
{
request.Content = new StringContent(data, Encoding.UTF8, contentType ?? _contentType);
}
RequestLogger?.RequestSent(GenerateRequestLog(request));
response = httpClient.SendAsync(request).Result;
string rawResponse = response.Content.ReadAsStringAsync().Result;
RequestLogger?.ResponseReceived(rawResponse);
return(new GatewayResponse {
StatusCode = response.StatusCode,
RequestUrl = response.RequestMessage.RequestUri.ToString(),
RawResponse = rawResponse
});
}
catch (Exception exc) {
throw new GatewayException("Error occurred while communicating with gateway.", exc);
}
finally { }
}
public void Logger_Logged()
{
RequestLogger middleware = new RequestLogger(env =>
{
return(TaskHelpers.Completed());
});
StringWriter writer = new StringWriter();
Request request = Request.Create();
request.TraceOutput = writer;
middleware.Invoke(request.Environment).Wait();
Assert.That(writer.GetStringBuilder().ToString(), Is.Not.EqualTo(string.Empty));
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleBingCommercePusher"/> class.
/// </summary>
/// <param name="config">The pusher configurations object</param>
/// <param name="checkpoint">The checkpoint to poll the data since if it's valid.</param>
/// <param name="serializer">(Optional): Explicit serialier to be used.</param>
public SimpleBingCommercePusher(BingCommerceConfig config, IDataCheckpoint checkpoint, IPushSerializer <IDictionary <string, object> > serializer = null)
{
var sdkClient = new BingCommerceIngestion(new TokenCredentials(config.AccessToken));
var logger = new RequestLogger(config.RequestLogLocation, config.RequestLog);
this.config = config;
this.client = new IngestionClient(sdkClient, config.TenantId, config.IndexId, config.RetryCount, logger);
this.tracker = new StatusTracker(this.client, config.TrackingInterval, logger);
this.taskManager = new TaskManager(config.MaxConcurrentRequests);
this.checkpointAcceptor = new CheckpointAcceptor(checkpoint);
this.Serializer = serializer ?? new FormatSerializer(config.PushFormat);
log.Debug("Successfully created the Simple Bing Commerce Pusher with the provided access token.");
}
/// <inheritdoc/>
public IRequestLogger GetRequestLogger()
{
const string requestLoggerKey = "requestLogger";
var requestLogger = _httpContextService.GetItem <IRequestLogger>(requestLoggerKey);
if (requestLogger != null)
{
return(requestLogger);
}
requestLogger = new RequestLogger(_dateTime);
_httpContextService.SetItem(requestLoggerKey, requestLogger);
return(requestLogger);
}
protected override void OnEndRequest(HttpContext context, EventArgs e)
{
var requestLogger = context.Items[RequestLogger.ItemKey] as IRequestLogger;
if (requestLogger == null)
{
return;
}
requestLogger.MvcLogRecord.DateResponded = DateTime.UtcNow;
requestLogger.MvcLogRecord.HttpStatus = context.Response.StatusCode;
requestLogger.MvcLogRecord.Error = GetExceptionMessage(context);
requestLogger.WriteLog();
RequestLogger.RemoveRequestLogger(requestLogger);
}
/// <summary>
/// Configure the services for the web api. Adds a CORS policy and initializes
/// the router and languages.
/// </summary>
/// <param name="services">The services of the application.</param>
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
services.AddCors(options => {
options.AddPolicy("AllowAnyOrigin",
builder => builder.AllowAnyOrigin().AllowAnyHeader().WithMethods("GET"));
});
services.AddDirectoryBrowser();
services.AddSingleton <IConfiguration> (Configuration);
RouterInstance.Initialize(Configuration);
Languages.initialize(Configuration);
RequestLogger.initialize(Configuration);
}
public void RequestLogger_Should_Not_Call_GetUserNameAsync_Once_If_Unauthenticated()
{
var logger = new Mock <ILogger <CreateTodoItemCommand> >();
var currentUserService = new Mock <ICurrentUserService>();
var identityService = new Mock <IIdentityService>();
currentUserService.Setup(x => x.UserId).Returns((string)null);
IRequestPreProcessor <CreateTodoItemCommand> requestLogger = new RequestLogger <CreateTodoItemCommand>(logger.Object, currentUserService.Object, identityService.Object);
requestLogger.Process(new CreateTodoItemCommand {
ListId = 1, Title = "title"
}, new CancellationToken());
identityService.Verify(i => i.GetUserNameAsync(null), Times.Never);
}
public void RequestLogger_Should_Call_GetUserNameAsync_Once_If_Authenticated()
{
var logger = new Mock <ILogger <CreateProductCommand> >();
var currentUserService = new Mock <ICurrentUserService>();
var identityService = new Mock <IIdentityService>();
currentUserService.Setup(x => x.UserId).Returns(UserId);
IRequestPreProcessor <CreateProductCommand> requestLogger = new RequestLogger <CreateProductCommand>(logger.Object, currentUserService.Object, identityService.Object);
requestLogger.Process(new CreateProductCommand {
CategoryId = 1, Title = "title"
}, new CancellationToken());
identityService.Verify(i => i.GetUserNameAsync(UserId), Times.Once);
}
public void RequestLogger_Should_Call_GetUserNameAsync_Once_If_Authenticated()
{
var logger = new Mock <ILogger <CreateSaleItemCommand> >();
var currentUserService = new Mock <ICurrentUserService>();
var identityService = new Mock <IIdentityService>();
currentUserService.Setup(x => x.UserId).Returns(UserId);
IRequestPreProcessor <CreateSaleItemCommand> requestLogger = new RequestLogger <CreateSaleItemCommand>(logger.Object, currentUserService.Object, identityService.Object);
requestLogger.Process(new CreateSaleItemCommand {
ArticleNumber = ArticleNumber, SalesPriceInEuro = SalesPriceInEuro, DateTimeOffset = DateTimeOffset.Now.AddDays(-2)
}, new CancellationToken());
identityService.Verify(i => i.GetUserNameAsync(UserId), Times.Once);
}
public async Task Invoke(HttpContext context)
{
try
{
await _next(context);
}
finally
{
var request = new RequestLog {
Method = context.Request.Method, Path = context.Request.Path.Value,
StatusCode = context.Response.StatusCode.ToString(),
Host = context.Request.Host.ToString(), Headers = context.Request.Headers.ToString()
};
await RequestLogger.Log(request);
}
}
