internal static IRequestSpan DispatchSpan(this IRequestSpan parentSpan, FunctionOptionsBase eventingFunctionOptions)
{
var childSpan = DispatchSpan(parentSpan);
if (childSpan.CanWrite)
{
childSpan.SetAttribute(InnerRequestSpans.DispatchSpan.Attributes.OperationId, eventingFunctionOptions.ClientContextId ?? Guid.NewGuid().ToString());
}
return(childSpan);
}
/// <inheritdoc />
public async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options)
{
var option = options as GitHubRepositoriesHttpTriggerOptions;
string result;
AddRequestHeaders();
string requestUrl = $"{_github.BaseUrl}{string.Format(_github.Endpoints.Repositories, option.Type, option.Name)}";
using (var message = await _httpClient.GetAsync(requestUrl).ConfigureAwait(false))
{
result = await message.Content.ReadAsStringAsync().ConfigureAwait(false);
}
var res = JsonConvert.DeserializeObject <object>(result);
RemoveRequestHeaders();
return((TOutput)res);
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var req = input as HttpRequest;
var opt = options as RenderSwaggerUIFunctionOptions;
var result = await this._ui
.AddMetadata(this._settings.OpenApiInfo)
.AddServer(req, this._settings.HttpSettings.RoutePrefix)
.BuildAsync()
.RenderAsync(opt.Endpoint, this._settings.SwaggerAuthKey)
.ConfigureAwait(false);
var content = new ContentResult()
{
Content = result,
ContentType = "text/html",
StatusCode = (int)HttpStatusCode.OK
};
return((TOutput)(IActionResult)content);
}
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var req = input as HttpRequest;
string name = req.Query["name"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync().ConfigureAwait(false);
dynamic data = JsonConvert.DeserializeObject(requestBody);
name = name ?? data?.name;
this._dependency.Name = name;
this.Log.LogInformation($"input: {this._dependency.Name}");
return(name != null
? (TOutput)(IActionResult) new OkObjectResult($"Hello, {name}")
: (TOutput)(IActionResult) new BadRequestObjectResult("Please pass a name on the query string or in the request body"));
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
var result = (IActionResult)null;
var requestUri = $"{this._settings.BaseUri.TrimEnd('/')}/{this._settings.Endpoints.HealthCheck.TrimStart('/')}";
using (var response = await this._httpClient.GetAsync(requestUri).ConfigureAwait(false))
{
try
{
response.EnsureSuccessStatusCode();
result = new OkResult();
}
catch (Exception ex)
{
var error = new ErrorResponse(ex);
result = new ObjectResult(error)
{
StatusCode = (int)response.StatusCode
};
}
}
return((TOutput)result);
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
#if NET461
var req = input as HttpRequestMessage;
#elif NETSTANDARD2_0
var req = input as HttpRequest;
#endif
var request = (SampleRequestModel)null;
#if NET461
var serialised = await req.Content.ReadAsStringAsync().ConfigureAwait(false);
#elif NETSTANDARD2_0
var serialised = await new StreamReader(req.Body).ReadToEndAsync().ConfigureAwait(false);
#endif
if (!string.IsNullOrWhiteSpace(serialised))
{
request = JsonConvert.DeserializeObject <SampleRequestModel>(serialised);
}
#if NET461
string name = req.GetQueryNameValuePairs()
.SingleOrDefault(p => p.Key.Equals("name", StringComparison.CurrentCultureIgnoreCase))
.Value;
#elif NETSTANDARD2_0
string name = req.Query["name"];
#endif
this._dependency.Name = name;
this.Log.LogInformation($"input: {this._dependency.Name}");
var result = new SampleResponseModel()
{
Id = request == null?Guid.NewGuid() : Guid.Parse(request.Id),
Name = string.IsNullOrWhiteSpace(name) ? "Sample" : name,
Description = "Ignored",
Sub = new SubSampleResponseModel()
{
Value = int.MaxValue
},
Collection = { { "hello", "world" } },
Items1 = { { int.MinValue } },
Items2 = new[] { int.MinValue }.ToArray()
};
#if NET461
var content = new StringContent(JsonConvert.SerializeObject(result), Encoding.UTF8, "application/json");
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = content
};
return((TOutput)Convert.ChangeType(response, typeof(TOutput)));
#elif NETSTANDARD2_0
var content = new ContentResult()
{
Content = JsonConvert.SerializeObject(result),
ContentType = "application/json",
StatusCode = (int)HttpStatusCode.OK
};
return((TOutput)(IActionResult)content);
#endif
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var secrets = await this._kv
.GetSecretsAsync(this._settings.KeyVault.BaseUri)
.MapAsync(this._mapper)
.ConfigureAwait(false);
return((TOutput)(IActionResult) new OkObjectResult(secrets));
}
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var req = input as HttpRequestMessage;
var request = (XmlToXmlMapperRequest)null;
var response = (HttpResponseMessage)null;
try
{
request = await req.Content
.ReadAsAsync <XmlToXmlMapperRequest>()
.ConfigureAwait(false);
}
catch (Exception ex)
{
var statusCode = HttpStatusCode.BadRequest;
var result = new ErrorResponse((int)statusCode, ex.Message, ex.StackTrace);
response = req.CreateResponse(HttpStatusCode.BadRequest, result);
this.Log.LogError($"Request payload was invalid.");
this.Log.LogError(ex.Message);
this.Log.LogError(ex.StackTrace);
return((TOutput)Convert.ChangeType(response, typeof(TOutput)));
}
try
{
var content = await this._helper
.LoadXslAsync(this._settings.Containers.Mappers, request.Mapper.Directory, request.Mapper.Name)
.AddArgumentsAsync(request.ExtensionObjects)
.TransformAsync(request.InputXml)
.ToStringAsync(this._settings.EncodeBase64Output);
var result = new XmlToXmlMapperResponse()
{
Content = content
};
response = req.CreateResponse(HttpStatusCode.OK, result, this._settings.JsonFormatter);
}
catch (CloudStorageNotFoundException ex)
{
var statusCode = HttpStatusCode.InternalServerError;
var err = new ErrorResponse((int)statusCode, ex.Message, ex.StackTrace);
response = req.CreateResponse(statusCode, err);
}
catch (BlobContainerNotFoundException ex)
{
var statusCode = HttpStatusCode.BadRequest;
var err = new ErrorResponse((int)statusCode, ex.Message, ex.StackTrace);
this.Log.LogError($"Request payload was invalid.");
this.Log.LogError($"XSL mapper not found");
response = req.CreateResponse(statusCode, err);
}
catch (BlobNotFoundException ex)
{
var statusCode = HttpStatusCode.BadRequest;
var err = new ErrorResponse((int)statusCode, ex.Message, ex.StackTrace);
this.Log.LogError($"Request payload was invalid.");
this.Log.LogError($"XSL mapper not found");
response = req.CreateResponse(statusCode, err);
}
catch (Exception ex)
{
var statusCode = HttpStatusCode.InternalServerError;
var err = new ErrorResponse((int)statusCode, ex.Message, ex.StackTrace);
response = req.CreateResponse(statusCode, err);
}
return((TOutput)Convert.ChangeType(response, typeof(TOutput)));
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
var request = input as HttpRequest;
var renderSwaggerUIFunctionOptions = options as RenderSwaggerUIFunctionOptions;
var result = await this._ui
.AddMetadata(this._settings.OpenApiInfo)
.AddServer(request, this._settings.HttpSettings.RoutePrefix)
.BuildAsync(typeof(SwaggerUI).Assembly)
.RenderAsync(renderSwaggerUIFunctionOptions.Endpoint, this._settings.SwaggerAuthKey)
.ConfigureAwait(false);
return((TOutput)(IActionResult) new ContentResult()
{
Content = result, ContentType = "text/html", StatusCode = (int)HttpStatusCode.OK
});
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
var req = input as HttpRequest;
var opt = options as RenderOpenApiDocumentFunctionOptions;
var contentType = opt.Format.GetContentType();
var result = await this._document
.InitialiseDocument()
.AddMetadata(this._settings.OpenApiInfo)
.AddServer(req, this._settings.HttpSettings.RoutePrefix)
.Build(opt.Assembly)
.RenderAsync(opt.Version, opt.Format)
.ConfigureAwait(false);
var content = new ContentResult()
{
Content = result,
ContentType = contentType,
StatusCode = (int)HttpStatusCode.OK
};
return((TOutput)(IActionResult)content);
}
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
var collector = (options as SampleTimerFunctionOptions).Collector;
var now = DateTimeOffset.UtcNow;
this.Log.LogInformation($"C# Timer trigger function executed at: {now}");
await collector.AddAsync(now.ToString()).ConfigureAwait(false);
return((TOutput)(object)true);
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var req = input as HttpRequest;
var request = (SampleRequestModel)null;
var serialised = await new StreamReader(req.Body).ReadToEndAsync().ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(serialised))
{
request = JsonConvert.DeserializeObject <SampleRequestModel>(serialised);
}
var name = req.Query["name"].ToString();
var opt = options as GetSamplesFunctionOptions;
var result = new SampleResponseModel()
{
Id = request?.Id,
Name = string.IsNullOrWhiteSpace(name) ? "Sample" : name,
Message = $"Hello {this._settings.Hello} from {opt.Key}"
};
var content = new ContentResult()
{
Content = JsonConvert.SerializeObject(result),
ContentType = "application/json",
StatusCode = (int)HttpStatusCode.OK
};
return((TOutput)(IActionResult)content);
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var result = await this._service.GetUsersAsync().ConfigureAwait(false);
var content = new ContentResult()
{
Content = JsonConvert.SerializeObject(result),
ContentType = "application/json",
StatusCode = (int)HttpStatusCode.OK
};
return((TOutput)(IActionResult)content);
}
async Task <TOutput> IFunction <ILogger> .InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options)
{
Customer newCustomer = new Customer(3, "Klaas", "Vaak");
var mapped = this._mapper.Map <CustomerDTO>(newCustomer);
return((TOutput)(IActionResult) new OkObjectResult(mapped));
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var secrets = await this._kv.GetSecretsAsync(this._settings.KeyVault.BaseUri)
.ConfigureAwait(false);
var items = secrets.OfType <SecretItem>().ToList();
var mapped = this._mapper.Map <List <SecretItemModel> >(items);
return((TOutput)(IActionResult) new OkObjectResult(mapped));
}
/// <inheritdoc />
public async override Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
return(await base.InvokeAsync <TInput, TOutput>(input, options).ConfigureAwait(false));
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var opt = options as GetSecretFunctionOptions ?? throw new ArgumentNullException(nameof(options));
var secret = await this._kv.GetSecretAsync(this._settings.KeyVault.BaseUri, opt.SecretName)
.ConfigureAwait(false);
var mapped = this._mapper.Map <SecretModel>(secret);
return((TOutput)(IActionResult) new OkObjectResult(mapped));
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var content = await this._service.GetDummies().ConfigureAwait(false);
#if NET461
var req = input as HttpRequestMessage;
var result = req.CreateResponse(HttpStatusCode.OK, content);
return((TOutput)Convert.ChangeType(result, typeof(TOutput)));
#elif NETSTANDARD2_0
var result = new OkObjectResult(content);
return((TOutput)(IActionResult)result);
#endif
}
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
var req = input as HttpRequest;
int param1 = Convert.ToInt32(req.Query["param1"]);
int param2 = Convert.ToInt32(req.Query["param2"]);
var content = new ContentResult()
{
Content = $"{param1}+{param2}={param1 + param2}",
ContentType = "application/json",
StatusCode = (int)HttpStatusCode.OK
};
return((TOutput)(IActionResult)content);
}
/// <inheritdoc />
public override async Task<TOutput> InvokeAsync<TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
#if NET461
var req = input as HttpRequestMessage;
#elif NETSTANDARD2_0
var req = input as HttpRequest;
#endif
var opt = options as RenderSwaggerUIFunctionOptions;
var result = await this._ui
.AddMetadata(this._settings.OpenApiInfo)
.AddServer(req, this._settings.HttpSettings.RoutePrefix)
.BuildAsync()
.RenderAsync(opt.Endpoint, this._settings.SwaggerAuthKey)
.ConfigureAwait(false);
#if NET461
var content = new StringContent(result, Encoding.UTF8, "text/html");
var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = content };
return (TOutput)Convert.ChangeType(response, typeof(TOutput));
#elif NETSTANDARD2_0
var content = new ContentResult()
{
Content = result,
ContentType = "text/html",
StatusCode = (int)HttpStatusCode.OK
};
return (TOutput)(IActionResult)content;
#endif
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
#if NET461
var req = input as HttpRequestMessage;
#elif NETSTANDARD2_0
var req = input as HttpRequest;
#endif
var opt = options as RenderOpeApiDocumentFunctionOptions;
var contentType = opt.Format.GetContentType();
var result = await this._document
.InitialiseDocument()
.AddMetadata(this._settings.OpenApiInfo)
.AddServer(req, this._settings.HttpSettings.RoutePrefix)
.Build(opt.Assembly)
.RenderAsync(opt.Version, opt.Format)
.ConfigureAwait(false);
#if NET461
var content = new StringContent(result, Encoding.UTF8, contentType);
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = content
};
return((TOutput)Convert.ChangeType(response, typeof(TOutput)));
#elif NETSTANDARD2_0
var content = new ContentResult()
{
Content = result,
ContentType = contentType,
StatusCode = (int)HttpStatusCode.OK
};
return((TOutput)(IActionResult)content);
#endif
}
/// <inheritdoc />
public override async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input, FunctionOptionsBase options = null)
{
this.Log.LogInformation("C# HTTP trigger function processed a request.");
var opt = options as RenderSwaggerFunctionOptions ?? throw new ArgumentNullException(nameof(options));
if (!IsValidSwaggerExtension(opt.Extension))
{
var statusCode = (int)HttpStatusCode.BadRequest;
var value = new ErrorModel(statusCode, "Extension not supported");
return((TOutput)(IActionResult) new ObjectResult(value)
{
StatusCode = statusCode
});
}
var swagger = await this._http.GetStringAsync(this._settings.Swagger.ImportUrl)
.ConfigureAwait(false);
if (IsYaml(opt.Extension))
{
return((TOutput)(IActionResult) new OkObjectResult(swagger));
}
if (IsJson(opt.Extension))
{
var deserialiser = new DeserializerBuilder().Build();
var deserialised = deserialiser.Deserialize <dynamic>(swagger);
return((TOutput)(IActionResult) new OkObjectResult(deserialised));
}
throw new InvalidOperationException();
}
