public async System.Threading.Tasks.Task TestCheckGithubAsyncAsync()
{
var logger = new MockLogger();
var timerInfo = new TimerInfo(new MockSchedule(), null);
var context = new Microsoft.Azure.WebJobs.ExecutionContext()
{
InvocationId = Guid.NewGuid(),
FunctionAppDirectory = $@"C:\code\COVID19\COVID19_Azure_DataSync\COVI19_Timer_Function\bin\Debug\netcoreapp2.1"
};
IConfigurationRoot config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
var AzureWebJobsStorage = config.GetValue <string>("Values:AzureWebJobsStorage");
var covidTable = Helper.GetCloudTable("Covid19", AzureWebJobsStorage, logger, context);
var syncTable = Helper.GetCloudTable("SyncStatus", AzureWebJobsStorage, logger, context);
var errorTable = Helper.GetCloudTable("ErrorLogs", AzureWebJobsStorage, logger, context);
ICollector <string> queue = new MockCollector <string>();
var function = new COIVD19_Api(new COVIDService(new System.Net.Http.HttpClient()));
await function.CheckGithubAsync(timerInfo, syncTable, queue, logger);
}
public static async Task <HttpResponseMessage> Run(
Microsoft.Azure.WebJobs.ExecutionContext context,
HttpRequest request,
ILogger log)
{
try
{
var configuration = HostConfiguration <THost> .GetConfiguration(context.FunctionAppDirectory);
var serverRecords = TenantApps <TStartup> .GetServerRecords(context.FunctionAppDirectory, configuration, log);
var path = new PathString(request.Path.Value.ToLower());
log.LogInformation($"C# HTTP trigger:{request.Method} {path}.");
var query = from item in serverRecords
where path.StartsWithSegments(item.PathStringBaseUrl)
select item;
var serverRecord = query.FirstOrDefault();
HttpResponseMessage response = null;
if (serverRecord == null)
{
response = new HttpResponseMessage(HttpStatusCode.NotFound);
return(response);
}
var httpRequestMessageFeature = new TenantHttpRequestMessageFeature(request);
var httpRequestMessage = httpRequestMessageFeature.HttpRequestMessage;
HttpClient client = serverRecord.TestServer.CreateClient();
client.BaseAddress = new Uri($"{request.Scheme}://{request.Host}");
// trim off the front router hints
path = path.Value.Substring(serverRecord.PathStringBaseUrl.Value.Length);
var uriBuilder = new UriBuilder(request.Scheme, request.Host.Host)
{
Path = path,
Query = request.QueryString.Value
};
if (request.Host.Port != null)
{
uriBuilder.Port = (int)request.Host.Port;
}
httpRequestMessage.RequestUri = uriBuilder.Uri;
httpRequestMessage.Headers.Remove("Host");
var responseMessage = await client.SendAsync(httpRequestMessage);
return(responseMessage);
}
catch (Exception e)
{
log.LogError(e, $"MainEntry Exception:{e.Message}");
return(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.InternalServerError
});
}
}
public async Task <IActionResult> ExecuteManuallyAsync(
[HttpTrigger(AuthorizationLevel.Function, "POST", Route = "")] HttpRequestMessage req,
CancellationToken cancellationToken,
ExecutionContext executionContext)
{
var q = req.RequestUri.ParseQueryString();
var body = await req.Content.ReadAsStringAsync();
var overrides = JsonConvert.DeserializeObject <Overrides>(body) ?? Overrides.None;
// keep legacy parameter around until next breaking change is introduced
var value = q.GetValues("NewCertificate")?.FirstOrDefault();
if (!string.IsNullOrEmpty(value))
{
_logger.LogWarning("Detected legacy querystring parameter \"newCertificate\" which will be removed in a future version! " +
"Please provide the \"forceNewCertificates\" parameter in the body instead. " +
"See the changelog for details: https://github.com/MarcStan/lets-encrypt-azure/blob/master/Changelog.md");
overrides.ForceNewCertificates = "true".Equals(value, StringComparison.OrdinalIgnoreCase);
}
try
{
await RenewAsync(overrides, executionContext, cancellationToken);
return(new AcceptedResult());
}
catch (Exception)
{
return(new BadRequestObjectResult(new
{
message = "Certificate renewal failed, check appinsights for details"
}));
}
}
public static async Task <ResponseObject> DeviceSleepCheck(
[OrchestrationTrigger] DurableOrchestrationContext context, Microsoft.Azure.WebJobs.ExecutionContext executionContext, ILogger log)
{
var devAddr = context.GetInput <string>();
var jsonTempaltesPath = Path.Combine(executionContext.FunctionDirectory, @"..\json_templates");
var json = File.ReadAllText(jsonTempaltesPath + @"\enumerate.json");
json = json.Replace("#DEV_ADDR#", $"{devAddr}");
while (true)
{
var resEnum = await context.CallSubOrchestratorAsync <string>("GWSendCommandWithResponse", json);
var errorMessage = Utils.CheckResponse(resEnum, out dynamic resEnumJObject);
if (errorMessage != "" && resEnumJObject.data.statusStr != "info missing")
{
log.LogInformation("Enumerate error: " + errorMessage);
return(new ResponseObject(ResultMessages.ErrorResult, ResultMessages.DiscoveryError, errorMessage));
}
if (resEnumJObject.data.statusStr != "info missing")
{
return(new ResponseObject(ResultMessages.Success, ResultMessages.EnumerateSuccess, resEnum));
}
else
{
// Orchestration sleeps until this time.
var nextCheck = context.CurrentUtcDateTime.AddSeconds(10);
await context.CreateTimer(nextCheck, CancellationToken.None);
}
}
}
public async Task <IActionResult> ExportIssuersZip(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "issuers/export/zip")] ExportIssuersQuery queryArg,
HttpRequest req,
Microsoft.Azure.WebJobs.ExecutionContext context,
ILogger log)
{
return(await ExecuteAsync <ExportIssuersQuery, ExportIssuersResponse>(context,
req,
queryArg,
async (r) => {
var outputStream = new MemoryStream();
using (var zipArchive = new ZipArchive(outputStream, ZipArchiveMode.Create, true))
{
var zipEntry = zipArchive.CreateEntry(r.FileName);
using (var zipStream = zipEntry.Open())
{
using (var ms = new MemoryStream(r.Content))
{
await ms.CopyToAsync(zipStream);
}
}
}
outputStream.Position = 0;
var result = new FileStreamResult(outputStream, "application/octet-stream")
{
FileDownloadName = "export.zip"
};
return result;
}));
}
public static void Run(
[EventHubTrigger("%EventHubName%", Connection = "EventHubConnection", ConsumerGroup = "%ConsumerGroupName%")] EventData[] eventHubMessages,
Microsoft.Azure.WebJobs.ExecutionContext exCtx,
PartitionContext PartitionContext,
TraceWriter log)
{
try
{
log.Info($"Function1 | Run - functionId: {exCtx.InvocationId}");
Schema writerObjectSchema = Schema.Parse(SchemaClass.SCHEMA_OBJECT_ENTITY);
Avro.Specific.SpecificDatumReader <ObjectEntity> r = new Avro.Specific.SpecificDatumReader <ObjectEntity>(writerObjectSchema, writerObjectSchema);
for (int i = 0; i < eventHubMessages.Length; i++)
{
ObjectEntity objectEntityWithSchema = null;
using (MemoryStream memStream = new MemoryStream(eventHubMessages[i].GetBytes()))
{
memStream.Seek(0, SeekOrigin.Begin);
objectEntityWithSchema = r.Read(null, new Avro.IO.BinaryDecoder(memStream));
}
/// Here use the deserialized object for your logic
/// Put your code here
///
}
log.Info($"Function1 | Run - functionId: {exCtx.InvocationId}");
}
catch (Exception ex)
{
log.Error($"Function1 | Run - functionId: {exCtx.InvocationId}. Error StackTrace: {ex.StackTrace}");
throw;
}
}
public static int AddTask(Microsoft.Azure.WebJobs.ExecutionContext execContext, CloudMediaContext context, IJob job, IAsset sourceAsset, string value, string processor, string presetfilename, string stringtoreplace, ref int taskindex, int priority = 10, string specifiedStorageAccountName = null)
{
if (value != null)
{
// Get a media processor reference, and pass to it the name of the
// processor to use for the specific task.
IMediaProcessor mediaProcessor = MediaServicesHelper.GetLatestMediaProcessorByName(context, processor);
string presetPath = Path.Combine(System.IO.Directory.GetParent(execContext.FunctionDirectory).FullName, "presets", presetfilename);
string Configuration = File.ReadAllText(presetPath).Replace(stringtoreplace, value);
// Create a task with the encoding details, using a string preset.
var task = job.Tasks.AddNew(processor + " task",
mediaProcessor,
Configuration,
TaskOptions.None);
task.Priority = priority;
// Specify the input asset to be indexed.
task.InputAssets.Add(sourceAsset);
// Add an output asset to contain the results of the job.
// Use a non default storage account in case this was provided in 'AddTask'
task.OutputAssets.AddNew(sourceAsset.Name + " " + processor + " Output", specifiedStorageAccountName, AssetCreationOptions.None);
return(taskindex++);
}
else
{
return(-1);
}
}
public static async Task <IActionResult> GetTextSentimentAzure(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "text/sentiment/azure")]
HttpRequest request,
TraceWriter traceWriter,
ExecutionContext executionContext
)
{
var appsettings = new AppSettings(executionContext);
var azureCognitiveServicesConfig = appsettings.AzureCognitiveServicesConfig;
_textAnalyticsClient = _textAnalyticsClient ?? GetTextAnalyticsClient(azureCognitiveServicesConfig);
var documentBatch = JsonConvert.DeserializeObject <DocumentBatch>(await GetBodyAsString(request));
var documents = documentBatch.Documents.Select((Models.Document doc) => new MultiLanguageInput
{
Id = doc.Id,
Language = doc.LanguageCode,
Text = doc.Text
}).ToList();
try
{
var sentimentBatchResult = await _textAnalyticsClient.SentimentAsync(new MultiLanguageBatchInput(documents));
var result = DocumentBatchSentimentUtil.FromSentimentBatchResult(sentimentBatchResult);
return(new OkObjectResult(result));
}
catch (Exception ex)
{
string error = ex.ToString() + ex.InnerException?.ToString();
traceWriter.Error(error, ex);
return(new BadRequestObjectResult(error));
}
}
public static async Task <IActionResult> GetTextSentimentGoogle(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "text/sentiment/google")]
HttpRequest request,
TraceWriter traceWriter,
ExecutionContext executionContext
)
{
var appsettings = new AppSettings(executionContext);
string bodyString = await GetBodyAsString(request);
var documentBatch = JsonConvert.DeserializeObject <DocumentBatch>(bodyString.Trim());
//var creds = GoogleCredential.FromJson(File.ReadAllText("CommentQulity-19b70adeab44.json"));
var creds = GoogleCredential.FromJson(JsonConvert.SerializeObject(appsettings.GoogleCredentialsData));
var channelCreds = creds.ToChannelCredentials();
var channel = new Channel(LanguageServiceClient.DefaultEndpoint.ToString(), channelCreds);
var langServiceClient = LanguageServiceClient.Create(channel);
var analyzeSentimentRequest = GetSentimentAnalysisRequest(documentBatch);
var analyzeSentimentResponse = langServiceClient.AnalyzeSentiment(analyzeSentimentRequest);
var result = DocumentBatchSentimentUtil.FromAnnotatedAnalyzeSentimentResponse(analyzeSentimentResponse);
return(new ObjectResult(result));
}
public async Task Run(
Microsoft.Azure.WebJobs.ExecutionContext context,
[ServiceBusTrigger("sbq-queueflow", Connection = "ServiceBusConnection")] string myQueueItem,
ILogger logger)
{
await dotnetcore.azFunction.AppShim.Global.InitializeShimAsync(context, _functionsAppShim, logger);
var job = _serializer.Deserialize <Job>(myQueueItem);
var json = _serializer.Serialize(job);
logger.LogInformation($"C# ServiceBus queue trigger function processed message: {json}");
var httpRequestMessage = new HttpRequestMessage(
HttpMethod.Post,
"http://localhost/api/MyServiceBusTriggerFunction")
{
Content = new StringContent(
json,
Encoding.UTF8, "application/json")
};
var response = await _functionsAppShim.SendAsync(context, httpRequestMessage);
}
public async Task <IActionResult> HttpTrigger(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = null)]
HttpRequest request,
ExecutionContext executionContext,
CancellationToken cancellationToken
)
{
var queryParameter = request.GetQueryParameterDictionary();
var awaitSave = true;
var dateTime = DateTime.UtcNow;
if (!queryParameter.TryGetValue("await", out var awaitSaveString) && !bool.TryParse(awaitSaveString, out awaitSave))
{
awaitSave = true;
}
if (queryParameter.TryGetValue("dtOffsetDays", out var dateTimeOffsetDaysString) && int.TryParse(dateTimeOffsetDaysString, out var offset))
{
dateTime = DateTime.UtcNow.AddDays(offset);
}
return(new ObjectResult(await this.HandleRequest(executionContext, awaitSave, dateTime, cancellationToken))
{
StatusCode = (int)HttpStatusCode.Accepted
});
}
public static void Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log,
ExecutionContext executionContext,
[ServiceBus("testqueue", Connection = "serviceBusConnectionString")] ICollector <Message> collector,
CancellationToken cancellationToken
//[Queue("markerqueue", Connection = "storageConnectionString")]ICollector<SomeResult> collector
)
{
/*
* //string name = req.Query["name"];
* string requestBody = new StreamReader(req.Body).ReadToEnd();
* //dynamic data = JsonConvert.DeserializeObject(requestBody);
* //name = name ?? data?.name;
* using (StreamWriter writer = new StreamWriter(outputBlob))
* {
* await writer.WriteAsync(requestBody);
* }*/
//return $"{Guid.NewGuid()}.json";
CancellationTokenSource tokenSource = CancellationTokenSource.CreateLinkedTokenSource(req.HttpContext.RequestAborted, cancellationToken);
string json = JsonConvert.SerializeObject(new SomeResult
{
Message = "Hello world"
});
Message message = new Message(Encoding.UTF8.GetBytes(json));
collector.Add(message);
//return new OkObjectResult();
}
public static async Task Run([OrchestrationTrigger] IDurableOrchestrationContext context,
Microsoft.Azure.WebJobs.ExecutionContext executionContext, ILogger log)
{
log.LogInformation("Enter orchestration workflow");
using (var timeoutCts = new CancellationTokenSource())
{
DateTime dueTime = context.CurrentUtcDateTime.AddSeconds(15);
Task durableTimeout = context.CreateTimer(dueTime, timeoutCts.Token);
log.LogInformation("Start timer");
Task <bool> startEvent = context.WaitForExternalEvent <bool>("StartEvent");
if (startEvent == await Task.WhenAny(startEvent, durableTimeout))
{
timeoutCts.Cancel();
log.LogInformation("Stop timer");
return;
}
else
{
await Stop(GetAzureContext(executionContext), log);
log.LogInformation("Stop instance");
return;
}
}
}
public static async Task Raise([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[DurableClient] IDurableOrchestrationClient client,
Microsoft.Azure.WebJobs.ExecutionContext executionContext,
ILogger log)
{
string instanceId = InstanceId;
var eventData = req.Query["event"];
var existingInstance = await client.GetStatusAsync(instanceId);
if (eventData == "stop")
{
log.LogInformation("Start orchestration");
await client.StartNewAsync("OrchestrationWorkflow", instanceId);
}
else if (eventData == "start")
{
await Start(GetAzureContext(executionContext), log);
if (existingInstance == null ||
existingInstance.RuntimeStatus == OrchestrationRuntimeStatus.Completed ||
existingInstance.RuntimeStatus == OrchestrationRuntimeStatus.Failed ||
existingInstance.RuntimeStatus == OrchestrationRuntimeStatus.Terminated)
{
log.LogInformation("There is no timers to interrupt");
}
else
{
log.LogInformation("Raise start instance event");
bool isStartEvent = true;
await client.RaiseEventAsync(instanceId, "StartEvent", isStartEvent);
}
}
}
private async Task OnExecutingAsync(HttpRequest request, Microsoft.Azure.WebJobs.ExecutionContext context)
{
// Extract token from header, return 'Unauthorized' error if the token is null.
string token = string.Empty;
if (request.Headers.ContainsKey("Authorization") && request.Headers["Authorization"][0].StartsWith("Bearer "))
{
token = request.Headers["Authorization"][0].Substring("Bearer ".Length);
}
else
{
request.HttpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
throw new HttpRequestException("Unauthorized");
}
// Get Azure AD env settings
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
_instance = config["AzureAd:Instance"];
_tenantId = config["AzureAd:TenantId"];
_clientId = config["AzureAd:ClientId"];
// Validate token (authorization)
string audience = $"api://{_clientId}";
_userClaim = await TokenValidation.VerifyUserHasAnyAcceptedScope(token, _instance, _tenantId, _clientId, audience, _allowedScopes, new CancellationToken());
}
public async Task <IActionResult> ExecuteManuallyAsync(
[HttpTrigger(AuthorizationLevel.Function, "POST", Route = "")] HttpRequestMessage req,
CancellationToken cancellationToken,
ExecutionContext executionContext)
{
var q = req.RequestUri.ParseQueryString();
var overrides = new Overrides
{
NewCertificate = "true".Equals(q.GetValues(nameof(Overrides.NewCertificate))?.FirstOrDefault(), StringComparison.OrdinalIgnoreCase)
};
try
{
await RenewAsync(overrides, executionContext, cancellationToken);
return(new AcceptedResult());
}
catch (Exception)
{
return(new BadRequestObjectResult(new
{
message = "Certificate renewal failed, check appinsights for details"
}));
}
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "graphql")]
HttpRequestMessage reqMessage,
HttpRequest req,
ExecutionContext context,
ILogger log)
{
var httpContextAccessor = FunctionStartup.EstablishHttpContextAccessor(context, reqMessage, req);
FunctionStartup.EstablishContextAccessor(context);
await FunctionStartup.EstablishIdentityAsync(context, httpContextAccessor);
var factory = FunctionStartup.GetFactory(context);
var functionHandler = factory.Create <IGraphQLFunction>();
await functionHandler.InvokeAsync();
return(httpContextAccessor.HttpResponseMessage);
/*
*
* var tokenValidator = factory.ServiceProvider.GetService(typeof(ITokenValidator)) as ITokenValidator;
* httpContextAccessor.HttpContext.User = await tokenValidator.ValidateTokenAsync(reqMessage.Headers.Authorization); ;
*
* if (httpContextAccessor.HttpContext.User == null)
* {
* return reqMessage.CreateResponse(HttpStatusCode.Unauthorized);
* }
* // Authentication boilerplate code end
*
* return reqMessage.CreateResponse(HttpStatusCode.OK, "Hello " + httpContextAccessor.HttpContext.User.Identity.Name);
*/
}
public static async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
TraceWriter log,
Microsoft.Azure.WebJobs.ExecutionContext context)
{
// Function input comes from the request content.
VidUploadProcessRequest requestData = await req.Content.ReadAsAsync <VidUploadProcessRequest>();
//Get the config settings and add them to the requestData object
requestData.config = GetSettings(context);
// Starting a new orchestrator with request data
string instanceId = await starter.StartNewAsync("UploadVideo_Orchestrator", requestData);
log.Info($"Started orchestration with ID = '{instanceId}'.");
var response = starter.CreateCheckStatusResponse(req, instanceId);
// I specify a response interval so the Logic App doesn't check the status
// until after 10 seconds has passed. If work will be longer you can change this
// value as needed.
response.Headers.RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromSeconds(10));
return(response);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "getadwstatus")] HttpRequest req,
ILogger log, Microsoft.Azure.WebJobs.ExecutionContext context)
{
string currentStatus;
dynamic dbInfoObject;
log.LogInformation("autoscaleup of adw initiated");
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var kvClient = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
var kvURL = config["KeyVaultURL"];
try
{
var dwLocation = config["SqlDwLocation"];
//var tableName = config["DwScaleLogsTable"];
var dwuConfigFile = config["DwuConfigFile"];
var resourceIdSecret = config["ResourceId"];
var resourceId = (await kvClient.GetSecretAsync(kvURL, resourceIdSecret)).Value;
//string startupPath = Directory.GetParent(Environment.CurrentDirectory).Parent.Parent.FullName;
//string dwuConfigFilePath = startupPath + "\\" + dwuConfigFile;
//var dwuConfigManager = new DwuConfigManager(dwuConfigFilePath);
//var taskResult = await Task.Factory.StartNew<int>(() =>
//{
// Thread.Sleep(300000);
// return 0;
//});
// Create a DataWarehouseManagementClient
var dwClient = await DwClientFactory.Create(resourceId.ToString(), context);
do
{
// Get database information
var dbInfo = dwClient.GetDatabase();
dbInfoObject = JsonConvert.DeserializeObject(dbInfo);
currentStatus = dbInfoObject.properties.status.ToString();
//logEntity.DwuBefore = currentDwu;
log.LogInformation($"Current DWU is {currentStatus}");
} while (currentStatus != "Online");
return(new OkObjectResult(dbInfoObject));
}
catch (Exception ex)
{
return(new BadRequestObjectResult($"Bad Operation {ex}"));
}
}
public static async Task <HttpResponseMessage> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "analyze")] HttpRequestMessage request,
TraceWriter log,
ExecutionContext context,
CancellationToken cancellationToken)
{
using (IUnityContainer childContainer = Container.CreateChildContainer().WithTracer(log, true))
{
// Create a tracer for this run (that will also log to the specified TraceWriter)
IExtendedTracer tracer = childContainer.Resolve <IExtendedTracer>();
tracer.TraceInformation($"Analyze function request received with invocation Id {context.InvocationId}");
tracer.AddCustomProperty("FunctionName", context.FunctionName);
tracer.AddCustomProperty("InvocationId", context.InvocationId.ToString("N", CultureInfo.InvariantCulture));
try
{
// Trace app counters (before analysis)
tracer.TraceAppCounters();
// Read the request
SmartDetectorExecutionRequest smartDetectorExecutionRequest = await request.Content.ReadAsAsync <SmartDetectorExecutionRequest>(cancellationToken);
tracer.AddCustomProperty("SmartDetectorId", smartDetectorExecutionRequest.SmartDetectorId);
tracer.TraceInformation($"Analyze request received: {JsonConvert.SerializeObject(smartDetectorExecutionRequest)}");
// Process the request
ISmartDetectorRunner runner = childContainer.Resolve <ISmartDetectorRunner>();
bool shouldDetectorTrace = bool.Parse(ConfigurationReader.ReadConfig("ShouldDetectorTrace", required: true));
List <ContractsAlert> alertPresentations = await runner.RunAsync(smartDetectorExecutionRequest, shouldDetectorTrace, cancellationToken);
tracer.TraceInformation($"Analyze completed, returning {alertPresentations.Count} Alerts");
// Create the response with StringContent to prevent Json from serializing to a string
var response = request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(JsonConvert.SerializeObject(alertPresentations), Encoding.UTF8, "application/json");
return(response);
}
catch (AnalysisFailedException afe)
{
// Handle the exception
TopLevelExceptionHandler.TraceUnhandledException(afe, tracer, log);
// Return error status
return(request.CreateResponse(afe.StatusCode, afe.ReasonPhrase));
}
catch (Exception e)
{
// Handle the exception
TopLevelExceptionHandler.TraceUnhandledException(e, tracer, log);
// Return error status
return(request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
finally
{
// Trace app counters (after analysis)
tracer.TraceAppCounters();
}
}
}
public static async Task <IActionResult> LongTimeFunction(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient client,
Microsoft.Azure.WebJobs.ExecutionContext context,
ILogger log)
{
var cekResponse = new CEKResponse();
var clovaClient = new ClovaClient();
var cekRequest = await clovaClient.GetRequest(req.Headers["SignatureCEK"], req.Body);
switch (cekRequest.Request.Type)
{
case RequestType.LaunchRequest:
{
// UserId をインスタンス ID として新しい関数を実行
await client.StartNewAsync(nameof(LongTimeOrchestrationFunction), cekRequest.Session.User.UserId, context.FunctionAppDirectory);
cekResponse.AddText("時間のかかる処理を実行しました。結果はLINEでお知らせします。");
break;
}
case RequestType.IntentRequest:
default:
{
// インテントリクエスト他は特に用意しない
cekResponse.AddText("すみません。よくわかりませんでした。");
break;
}
}
return(new OkObjectResult(cekResponse));
}
public string SayHello([ActivityTrigger] string name, ILogger log, Microsoft.Azure.WebJobs.ExecutionContext context)
{
logger.LogInformation("SayHello beginning " + " " + context.InvocationId);
log.LogInformation($"Saying hello to {name}.");
return($"Hello {name}!");
}
private static IAzure GetAzureContext(Microsoft.Azure.WebJobs.ExecutionContext context)
{
//var azureAuthFile = Path.Combine(context.FunctionAppDirectory, AzureAuthFile);
//var credentials = SdkContext.AzureCredentialsFactory
// .FromFile(Environment.GetEnvironmentVariable(azureAuthFile));
var servicePrinciple = new ServicePrincipalLoginInformation()
{
ClientId = ClientId,
ClientSecret = Secret,
};
var azureCredentials = new AzureCredentials(servicePrinciple, TenantId, AzureEnvironment.AzureGlobalCloud);
try
{
return(Microsoft.Azure.Management.Fluent.Azure
.Configure()
.Authenticate(azureCredentials).WithSubscription(SubscriptionName));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(null);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
Microsoft.Azure.WebJobs.ExecutionContext functionContext,
ILogger log)
{
var init = DateTimeOffset.Now.ToUnixTimeMilliseconds();
log.LogInformation("C# HTTP trigger function START.");
var id = functionContext.InvocationId;
string instanceId = Environment.GetEnvironmentVariable("WEBSITE_INSTANCE_ID");
DoWork();
// DoSleep();
log.LogInformation("C# HTTP trigger function END.");
var end = DateTimeOffset.Now.ToUnixTimeMilliseconds();
var res = new
{
Init = init,
End = end,
InvocationID = id,
InstanceID = instanceId
};
// string responseMessage = $"{init}, {end}, {id}";
string responseMessage = JsonConvert.SerializeObject(res);
return(new OkObjectResult(responseMessage));
}
private static void hae(ExecutionContext context, TraceWriter log, string videoId)
{
// ToDo: kinda slow for 10k comments. Consider using Durable Functions to split up the work
var appSettings = new AppSettings(context);
IYouTubeDataApi youtubeDataApi = new YouTubeDataApi(appSettings.YouTubeApiSettings);
var commentThreadIterator = new CommentThreadIterator(youtubeDataApi);
var commentIterator = new CommentIterator(youtubeDataApi);
var batchedCommentsProvider = new DocumentBatchProvider(
new BatchedCommentsProviderConfig(10, 10000, document => !string.IsNullOrWhiteSpace(document.Text)),
new CommentProvider(commentThreadIterator, commentIterator));
batchedCommentsProvider.Init(videoId);
DocumentBatch docBatch;
while ((docBatch = batchedCommentsProvider.GetNextDocumentBatch()).Documents.Any())
{
foreach (var docBatchDocument in docBatch.Documents)
{
log.Info($"{docBatchDocument.Id} - {docBatchDocument.Text}");
}
}
}
private async Task RenewAsync(
Overrides overrides,
ExecutionContext executionContext,
CancellationToken cancellationToken)
{
var configurations = await _configurationLoader.LoadConfigFilesAsync(executionContext, cancellationToken);
var stopwatch = new Stopwatch();
// with lots of certificate renewals this could run into function timeout (10mins)
// with 30 days to expiry (default setting) this isn't a big problem as next day all unfinished renewals are continued
// user will only get email <= 14 days before expiry so acceptable for now
var errors = new List <Exception>();
foreach ((var name, var config) in configurations)
{
using (_logger.BeginScope($"Working on certificates from {name}"))
{
foreach (var cert in config.Certificates)
{
stopwatch.Restart();
var hostNames = string.Join(";", cert.HostNames);
cert.Overrides = overrides ?? Overrides.None;
try
{
_logger.LogInformation($"await _renewalService.RenewCertificateAsync(config.Acme, cert, cancellationToken) {cert.TargetResource.Name}");
var result = await _renewalService.RenewCertificateAsync(config.Acme, cert, cancellationToken);
switch (result)
{
case RenewalResult.NoChange:
_logger.LogInformation($"Certificate renewal skipped for: {hostNames} (no change required yet)");
break;
case RenewalResult.Success:
_logger.LogInformation($"Certificate renewal succeeded for: {hostNames}");
break;
default:
throw new ArgumentOutOfRangeException(result.ToString());
}
}
catch (Exception e)
{
_logger.LogError(e, $"Certificate renewal failed for: {hostNames}!");
errors.Add(e);
}
_logger.LogInformation($"Renewing certificates for {hostNames} took: {stopwatch.Elapsed}");
}
}
}
if (!configurations.Any())
{
_logger.LogWarning("No configurations where processed, refere to the sample on how to set up configs!");
}
if (errors.Any())
{
throw new AggregateException("Failed to process all certificates", errors);
}
}
public static async Task Run3(
[QueueTrigger("Test3", Connection = "AzureWebJobsStorage")] string myQueueItem
, ExecutionContext context
, [Table("Test3", Connection = "AzureWebJobsStorage")] CloudTable table
, TraceWriter log)
{
await Run(myQueueItem, context, table, log);
}
public static async Task <HttpResponseMessage> RunAllPaths(
CancellationToken ct,
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", "put", "patch", "options", Route = "{*x:regex(^(?!admin|debug|runtime).*$)}")] HttpRequestMessage req,
ILogger log,
ExecutionContext ctx)
{
return(await ServerHttpClient.SendAsync(req, ct));
}
public static async Task <HttpResponseMessage> RunRoot(
CancellationToken ct,
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", "put", "patch", "options", Route = "/")] HttpRequestMessage req,
ILogger log,
ExecutionContext ctx)
{
return(await ServerHttpClient.SendAsync(req, ct));
}
public static async Task Run([BlobTrigger("rawdocuments/{name}", Connection = "Documents")] CloudBlockBlob fileBlob,
[Blob("parseddocuments", Connection = "Documents")] CloudBlobContainer parsedDirectory,
ILogger log, Microsoft.Azure.WebJobs.ExecutionContext context,
CancellationToken cancellationToken)
{
try
{
if (fileBlob.Metadata.ContainsKey("DocumentType"))
{
//skip already processed documents
return;
}
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
string predictionKey = config["PredictionKey"];
string predictionProjectId = config["PredictionProjectId"];
string cognativeKey = config["CognativeKey"];
double minimumPrecision = double.Parse(config["MinimalPrecision"]);
string computerVisionServiceHostName = config["ComputerVisionServiceHostName"];
string customVisionServiceHostName = config["CustomVisionServiceHostName"];
string documentURLWithSAS = GetBlobSasUri(fileBlob);
string tagName = await AnalyseImageAsync(documentURLWithSAS, predictionKey, predictionProjectId, minimumPrecision, customVisionServiceHostName, cancellationToken);
if (!tagName.IsEmpty())
{
MortgageApplicationDocument mortgageApplicationDocument = new MortgageApplicationDocument();
mortgageApplicationDocument.PopuplateFromBlobProperties(fileBlob);
mortgageApplicationDocument.DateParsed = DateTimeOffset.UtcNow;
var parsedResults = await ParseDocumentTextAsync(documentURLWithSAS, cognativeKey, computerVisionServiceHostName, mortgageApplicationDocument.FileName, cancellationToken);
string parsedFileName = $"{tagName}/{fileBlob.Name.Trim('/')}";
CloudBlockBlob blob = parsedDirectory.GetBlockBlobReference(parsedFileName);
mortgageApplicationDocument.SetBlobProperties(blob);
blob.Properties.ContentType = "application/json";
await blob.UploadTextAsync(JsonConvert.SerializeObject(parsedResults));
}
else
{
tagName = "N/A";
}
fileBlob.Metadata.Add("DocumentType", tagName);
await fileBlob.SetMetadataAsync();
}
catch (Exception ex)
{
log.LogError($"Identity Document failed: {ex.ToString()}");
}
}