public static async Task <IActionResult> GetSecrets( [HttpTrigger(AuthorizationLevel.Function, "get", Route = "secrets")] HttpRequest req, ILogger log) { IActionResult result; try { result = await Factory.Create <IGetSecretsFunction, ILogger>(log) .InvokeAsync <HttpRequest, IActionResult>(req) .ConfigureAwait(false); } catch (KeyVaultErrorException ex) { var statusCode = (int)ex.Response.StatusCode; var value = new ErrorModel(statusCode, ex.Body?.Error?.Message); result = new ObjectResult(value) { StatusCode = statusCode }; } catch (Exception ex) { var statusCode = (int)HttpStatusCode.InternalServerError; var value = new ErrorModel(statusCode, ex.Message); result = new ObjectResult(value) { StatusCode = statusCode }; } return(result); }
public static async Task <HttpResponseMessage> GetDummies( [HttpTrigger(AuthorizationLevel.Function, "GET", Route = "dummies")] HttpRequestMessage req, ILogger log) { var result = await Factory.Create <IGetDummiesFunction, ILogger>(log) .InvokeAsync <HttpRequestMessage, HttpResponseMessage>(req) .ConfigureAwait(false); return(result); }
public static async Task <HttpResponseMessage> GetSample( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "samples")] HttpRequestMessage req, ILogger log) { var result = await Factory.Create <ISampleHttpFunction, ILogger>(log) .InvokeAsync <HttpRequestMessage, HttpResponseMessage>(req) .ConfigureAwait(false); return(result); }
public static async Task <IActionResult> RenderSwagger( [HttpTrigger(AuthorizationLevel.Function, "get", Route = "swagger.{extension}")] HttpRequest req, string extension, ILogger log) { IActionResult result; try { var options = new RenderSwaggerFunctionOptions() { Extension = extension }; result = await Factory.Create <IRenderSwaggerFunction, ILogger>(log) .InvokeAsync <HttpRequest, IActionResult>(req, options) .ConfigureAwait(false); } catch (Exception ex) { var statusCode = (int)HttpStatusCode.InternalServerError; var value = new ErrorModel(statusCode, ex.Message); result = new ObjectResult(value) { StatusCode = statusCode }; } return(result); }
public static Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "graphql")] HttpRequest req, ILogger log) { log.LogInformation("GraphQLFunctionHttpTrigger processed a request."); return(Factory.Create <IGraphQLFunction>(log) .InvokeAsync <HttpRequest, IActionResult>(req)); }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", Route = "core/repositories")] HttpRequest req, TraceWriter log) { var options = GetOptions(req); var result = await Factory.Create <IGitHubRepositoriesFunction>(log).InvokeAsync <HttpRequest, object>(req, options).ConfigureAwait(false); return(new OkObjectResult(result)); }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log) { var result = await Factory.Create <ISampleHttpFunction, ILogger>(log) .InvokeAsync <HttpRequest, IActionResult>(req) .ConfigureAwait(false); return(result); }
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", Route = "v1/repositories")] HttpRequestMessage req, TraceWriter log) { var options = GetOptions(req); var result = await Factory.Create <IGitHubRepositoriesFunction>(log).InvokeAsync <HttpRequestMessage, object>(req, options).ConfigureAwait(false); return(req.CreateResponse(HttpStatusCode.OK, result)); }
public static async Task Run([TimerTrigger("0/5 * * * * *")] TimerInfo myTimer, [Queue("output")] IAsyncCollector <string> collector, ILogger log) { var options = new SampleTimerFunctionOptions() { Collector = collector }; var result = await Factory.Create <ISampleTimerFunction, ILogger>(log).InvokeAsync <TimerInfo, bool>(myTimer, options).ConfigureAwait(false); Factory.ResultInvoked = result; }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log ) { var options = new GetSecretFunctionOptions("Sample"); var result = await Factory.Create <IGetOneCustomer, ILogger>(log) .InvokeAsync <HttpRequest, IActionResult>(req, options) .ConfigureAwait(false); return(new OkObjectResult(result)); }
public ICode Transform(ICode code, TryTransformInstructionDelegate transformInstructionDelegate, Func <ICodeInMemoryLayout> codeInLayoutFactoryDelegate = null) { var newInstructionsList = new List <IAssemblyInstructionForTransformation>(); var newFunctionsList = new List <IFunction>(); var instructionListIterator = code.AssemblyInstructions.GetEnumerator(); var lastInstructionInLastBlock = code.Functions.Last().BasicBlocks.Last().AssemblyInstructions.Last(); IAssemblyInstructionForTransformation previousInstruction = null; bool afterInstructionOfLastBlock = false; //move to the first instruction instructionListIterator.MoveNext(); //iterate through all functions foreach (var function in code.Functions) { var basicBlockList = new List <IBasicBlock>(); //iterate through all basic block foreach (var basicBlock in function.BasicBlocks) { var instructionsListOfBlock = new List <IAssemblyInstructionForTransformation>(); foreach (var instructionInBasicBlock in basicBlock.AssemblyInstructions) { bool isInstructionInBasicBlock; bool done = false; //transform instructions from instruction list. //this loop transform: //1. instructions before the basic block which are left to process //2. instructions inside a basic block //3. instructions after the last basic block while (!done) { isInstructionInBasicBlock = instructionListIterator.Current == instructionInBasicBlock; IAssemblyInstructionForTransformation instructionToTransform = instructionListIterator.Current; //perfom the transformation of the instruction List <IAssemblyInstructionForTransformation> transformedInstructionList; var wasTransformed = transformInstructionDelegate(instructionToTransform, isInstructionInBasicBlock ? basicBlock : null, isInstructionInBasicBlock ? function : null, out transformedInstructionList); if (wasTransformed) { if (transformedInstructionList.Count == 0) { throw new ApplicationException("transformation should return at least one instruction"); } if (isInstructionInBasicBlock) { instructionsListOfBlock.AddRange(transformedInstructionList); } newInstructionsList.AddRange(transformedInstructionList); if (previousInstruction != null) { transformedInstructionList[0].PreviousInstruction = previousInstruction; previousInstruction.NextInstruction = transformedInstructionList[0]; } if (transformedInstructionList.Count > 1) { for (int i = 1; i < transformedInstructionList.Count; i++) { transformedInstructionList[i].PreviousInstruction = transformedInstructionList[i - 1]; transformedInstructionList[i - 1].NextInstruction = transformedInstructionList[i]; } } previousInstruction = transformedInstructionList.Last(); } else { if (isInstructionInBasicBlock) { instructionsListOfBlock.Add(instructionToTransform); } newInstructionsList.Add(instructionToTransform); if (previousInstruction != null) { instructionToTransform.PreviousInstruction = previousInstruction; previousInstruction.NextInstruction = instructionToTransform; } previousInstruction = instructionToTransform; } //check weather this is the last instruction in the last basic block if (isInstructionInBasicBlock && !afterInstructionOfLastBlock) { //The transformed instruction is now in the end of program //after the last basic block instruction afterInstructionOfLastBlock = (instructionToTransform == lastInstructionInLastBlock); } instructionListIterator.MoveNext(); //stop transforming intructions in loop when all instruction in scope are processed done = (isInstructionInBasicBlock || instructionListIterator.Current == null); //keep transforming after the last basic block instruction to the end of the program if (afterInstructionOfLastBlock && instructionListIterator.Current != null) { done = false; } } } IBasicBlock newBasicBlock = m_basicBlockFactory.Create(instructionsListOfBlock); basicBlockList.Add(newBasicBlock); } var newFunction = m_functionFactory.Create(basicBlockList.First().AssemblyInstructions.First(), basicBlockList.Last().AssemblyInstructions.Last(), basicBlockList); newFunctionsList.Add(newFunction); } //if there is a factory to create a new code in memory layout structure than use it, otherwise use //the original code layout in memrory instance ICodeInMemoryLayout codeInMemoryLayout = codeInLayoutFactoryDelegate == null ? code.CodeInMemoryLayout:codeInLayoutFactoryDelegate(); //return m_codeFactory.Create(newInstructionsList, newFunctionsList,codeInMemoryLayout); var newcode = m_codeFactory.Create(newInstructionsList, newFunctionsList, codeInMemoryLayout); ValidateNewCode(newcode); return(newcode); }