public static string[] Run([ActivityTrigger] DurableActivityContext context, ILogger log,
ExecutionContext executionContext)
{
//config and input
_log = log;
var input = new { Name = context.GetInput <string>() };
var config = executionContext.BuildConfiguration();
var clientId = config["ApplicationId"];
var clientSecret = config["ApplicationSecret"];
var tenantId = config["TenantId"];
string subscriptionId = config["SubscriptionId"];
log.LogInformation($"Get resources activity start {input.Name}");
try
{
// authenticate and return names of VMSSs that start with the prefix
if (!AzureCredentials.Make(tenantId, clientId, clientSecret, subscriptionId)
.TryGetAzure(out IAzure azure, message => _log.LogError(message)))
{
return(Array.Empty <string>());
}
return(azure.GetVmssNames(input.Name).ToArray());
}
catch (Exception e)
{
_log.LogError($"Get resources activity error {e.Message}", e);
}
return(Array.Empty <string>());
}
public static async Task <ChallengeResult> Http01Authorization([ActivityTrigger] DurableActivityContext context, ILogger log)
{
var(site, authzUrl) = context.GetInput <(Site, string)>();
var acme = await CreateAcmeClientAsync();
var authz = await acme.GetAuthorizationDetailsAsync(authzUrl);
// HTTP-01 Challenge の情報を拾う
var challenge = authz.Challenges.First(x => x.Type == "http-01");
var challengeValidationDetails = AuthorizationDecoder.ResolveChallengeForHttp01(authz, challenge, acme.Signer);
var websiteClient = await CreateWebSiteManagementClientAsync();
var credentials = await websiteClient.WebApps.ListPublishingCredentialsAsync(site);
// Kudu API を使い、Answer 用のファイルを作成
var kuduClient = new KuduApiClient(site.ScmSiteUrl(), credentials.PublishingUserName, credentials.PublishingPassword);
await kuduClient.WriteFileAsync(DefaultWebConfigPath, DefaultWebConfig);
await kuduClient.WriteFileAsync(challengeValidationDetails.HttpResourcePath, challengeValidationDetails.HttpResourceValue);
return(new ChallengeResult
{
Url = challenge.Url,
HttpResourceUrl = challengeValidationDetails.HttpResourceUrl,
HttpResourceValue = challengeValidationDetails.HttpResourceValue
});
}
public static async Task <(string, byte[])> FinalizeOrder([ActivityTrigger] DurableActivityContext context, ILogger log)
{
var(hostNames, orderDetails) = context.GetInput <(string[], OrderDetails)>();
// ECC 256bit の証明書に固定
var ec = ECDsa.Create(ECCurve.NamedCurves.nistP256);
var csr = CryptoHelper.Ec.GenerateCsr(hostNames, ec);
var acme = await CreateAcmeClientAsync();
// Order の最終処理を実行し、証明書を作成
var finalize = await acme.FinalizeOrderAsync(orderDetails.Payload.Finalize, csr);
var certificateData = await _httpClient.GetByteArrayAsync(finalize.Payload.Certificate);
// 秘密鍵を含んだ形で X509Certificate2 を作成
var(certificate, chainCertificate) = X509Certificate2Extension.LoadFromPem(certificateData);
var certificateWithPrivateKey = certificate.CopyWithPrivateKey(ec);
var x509Certificates = new X509Certificate2Collection(new[] { certificateWithPrivateKey, chainCertificate });
// PFX 形式としてエクスポート
return(certificateWithPrivateKey.Thumbprint, x509Certificates.Export(X509ContentType.Pfx, "P@ssw0rd"));
}
public static string[] GetFileList([ActivityTrigger] DurableActivityContext ctx)
{
string directory = ctx.GetInput <string>();
string[] files = Directory.GetFiles(directory, "*", SearchOption.TopDirectoryOnly);
return(files);
}
public static async Task <ActivityResponse> SetLeagueEmailAddressCommandHandlerActivity(
[ActivityTrigger] DurableActivityContext context,
ILogger log)
{
ActivityResponse ret = new ActivityResponse()
{
FunctionName = "SetLeagueEmailAddressCommandHandlerActivity"
};
try
{
CommandRequest <Set_Email_Address_Definition> cmdRequest = context.GetInput <CommandRequest <Set_Email_Address_Definition> >();
if (null != cmdRequest)
{
await HandleSetLeagueEmailAddressCommand(cmdRequest.CommandUniqueIdentifier.ToString(), log,
new WriteContext(ret.FunctionName, context.InstanceId ));
ret.Message = $"Command processed {cmdRequest.CommandName} : {cmdRequest.CommandUniqueIdentifier}";
}
else
{
ret.FatalError = true;
ret.Message = $"Unable to read command request from {context.InstanceId }";
}
}
catch (Exception ex)
{
ret.FatalError = true;
ret.Message = ex.Message;
}
return(ret);
}
public static async Task <ActivityResponse> RunWebHookNotificationActivity(
[ActivityTrigger] DurableActivityContext context,
Binder outputBinder,
ILogger log)
{
ActivityResponse response = new ActivityResponse()
{
FunctionName = "RunWebHookNotificationActivity"
};
Command_Notification_Request notifyRequest = context.GetInput <Command_Notification_Request>();
if (null != notifyRequest)
{
var payloadAsJSON = new StringContent(JsonConvert.SerializeObject(notifyRequest));
// Use the binder to bind to an HTTP client to send the results to
using (var client = new HttpClient())
{
HttpResponseMessage msgResp = await client.PostAsync(notifyRequest.HookAddress, payloadAsJSON);
if (null != msgResp)
{
response.Message = $"Output sent - {msgResp.ReasonPhrase}";
}
}
}
else
{
response.StepFailure = true;
response.Message = "Unable to read command notification request from context";
}
return(response);
}
public static async Task FinalizeOrder([ActivityTrigger] DurableActivityContext context, ILogger log)
{
var(hostNames, orderDetails) = context.GetInput <(string[], OrderDetails)>();
var certificateName = hostNames[0].Replace("*", "wildcard").Replace(".", "-");
var keyVaultClient = CreateKeyVaultClient();
// Key Vault を使って CSR を作成
var request = await keyVaultClient.CreateCertificateAsync(Settings.Default.VaultBaseUrl, certificateName, new CertificatePolicy
{
X509CertificateProperties = new X509CertificateProperties
{
SubjectAlternativeNames = new SubjectAlternativeNames(dnsNames: hostNames)
}
}, tags : new Dictionary <string, string>
{
{ "Issuer", "letsencrypt.org" }
});
var acme = await CreateAcmeClientAsync();
// Order の最終処理を実行し、証明書を作成
var finalize = await acme.FinalizeOrderAsync(orderDetails.Payload.Finalize, request.Csr);
var certificateData = await _httpClient.GetByteArrayAsync(finalize.Payload.Certificate);
// X509Certificate2 を作成
var certificate = new X509Certificate2(certificateData);
await keyVaultClient.MergeCertificateAsync(Settings.Default.VaultBaseUrl, certificateName, new X509Certificate2Collection(certificate));
}
public static async Task <string> Worker(
[ActivityTrigger] DurableActivityContext ctx,
TraceWriter log
)
{
return("");
}
public static string Activity([ActivityTrigger] DurableActivityContext context)
{
var payload = context.GetInput <string>();
// This will be serialized and persisted to orchestration history
return($"Hello {payload}!");
}
public static string SayHello(
[ActivityTrigger] DurableActivityContext helloContext)
{
string name = helloContext.GetInput <string>();
return($"Hello {name}!");
}
public static async Task <string> ProcessVideo(
[ActivityTrigger] DurableActivityContext ctx,
TraceWriter log
)
{
var url = ctx.GetInput <string>();
var asm = Assembly.Load("Microsoft.Extensions.Options, Culture=neutral, PublicKeyToken=adb9793829ddae60");
PuppeteerSharp.Browser browser = null;
try
{
browser = await Puppeteer.ConnectAsync(new ConnectOptions { BrowserWSEndpoint = Constants.BrowserWSEndpoint });
var page = await browser.NewPageAsync();
await page.GoToAsync(url, new NavigationOptions { Timeout = 4000 });
}
catch (Exception ex)
{
return(ex.Message);
}
finally
{
if (browser != null)
{
browser.Disconnect();
}
}
return($"Processed {url} shit all.");
}
public static DataTable GetDataTable([ActivityTrigger] DurableActivityContext context, ILogger log)
{
var data = context.GetInput <dynamic>();
DataTable dt = new DataTable((string)data.tableName);
log.LogInformation($"attempting to get datatable {(string)data.tableName}");
using (SqlConnection conn = new SqlConnection((string)data.connectionString))
{
using (SqlCommand cmd = new SqlCommand((string)data.queryString, conn))
{
cmd.CommandTimeout = COMMAND_TIMEOUT;
cmd.CommandType = CommandType.Text;
if (data.parameters != null)
{
cmd.Parameters.AddRange((SqlParameter[])data.parameters);
}
var adapter = new SqlDataAdapter(cmd);
adapter.Fill(dt);
return(dt);
}
}
}
public static int ExecuteQuery([ActivityTrigger] DurableActivityContext context, ILogger log)
{
var data = context.GetInput <dynamic>();
using (SqlConnection conn = new SqlConnection((string)data.connectionString))
{
using (SqlCommand cmd = new SqlCommand((string)data.queryString, conn))
{
cmd.CommandTimeout = COMMAND_TIMEOUT;
cmd.CommandType = CommandType.Text;
if (data.parameters != null)
{
cmd.Parameters.AddRange((SqlParameter[])data.parameters);
}
//var adapter = new SqlDataAdapter(cmd);
//adapter.Fill(dt);
conn.Open();
var ret = cmd.ExecuteNonQuery();
conn.Close();
log.LogInformation($"successfully executed {(string)data.caption}");
return(ret);
}
}
}
public static string GetInventory([ActivityTrigger] DurableActivityContext inputs, TraceWriter log)
{
(string material, string supplyingPlant)materialInfo = inputs.GetInput <(string, string)>();
string baseURL = "https://sandbox.api.sap.com/s4hanacloud/sap/opu/odata/sap/API_PRODUCT_AVAILY_INFO_BASIC/CalculateAvailabilityTimeseries?";
string URL = baseURL + "ATPCheckingRule='A'&Material='" + materialInfo.material + "'&SupplyingPlant='" + materialInfo.supplyingPlant + "'";
var request = new HttpRequestMessage()
{
RequestUri = new Uri(URL),
Method = HttpMethod.Get
};
request.Headers.TryAddWithoutValidation("APIKey", S4HCAPIKey);
request.Headers.TryAddWithoutValidation("Accept", "application/json");
var result = client.SendAsync(request).Result;
string jsonContent = result.Content.ReadAsStringAsync().Result;
var odata = JsonConvert.DeserializeObject <OData>(jsonContent);
log.Info($"Inventory level for {materialInfo.material} in {materialInfo.supplyingPlant} is {odata.d.Results[0].AvailableQuantityInBaseUnit}.");
return(odata.d.Results[0].AvailableQuantityInBaseUnit);
}
public static string Run([ActivityTrigger] DurableActivityContext ctx)
{
var input = ctx.GetInput <string>();
var recordsForYear = DecompressAndDeserialize(input);
return(SerializeAndCompress(GetMedalsPerCountry(recordsForYear)));
}
public static async Task <ActivityResponse> GetLeagueSummaryQueryProjectionRequestActivity(
[ActivityTrigger] DurableActivityContext context,
ILogger log)
{
ActivityResponse ret = new ActivityResponse()
{
FunctionName = "GetLeagueSummaryQueryProjectionRequestActivity"
};
try
{
QueryRequest <Get_League_Summary_Definition> queryRequest = context.GetInput <QueryRequest <Get_League_Summary_Definition> >();
if (null != log)
{
log.LogInformation($"GetLeagueSummaryQueryProjectionRequestActivity called for query : {queryRequest.QueryUniqueIdentifier}");
}
await RequestProjectionsGetLeagueSummaryQuery(queryRequest.QueryName,
queryRequest.QueryUniqueIdentifier.ToString(),
log);
ret.Message = $"Requested projections : { queryRequest.QueryUniqueIdentifier.ToString() } ";
}
catch (Exception ex)
{
ret.Message = ex.Message;
ret.FatalError = true;
}
return(ret);
}
public static async Task BackupDocuments([ActivityTrigger] DurableActivityContext context, ILogger log)
{
var jobDef = context.GetInput <CollectionBackupJob>();
var client = await GetClientAsync(jobDef.ConnectionString);
var name = $"{client.ServiceEndpoint.Host} | {jobDef.CollectionLink}";
log.LogInformation($"Initializing backup for {name}.");
var dir = await GetDirectoryAsync(jobDef);
using (var query = client.CreateDocumentQuery(jobDef.CollectionLink, new FeedOptions()
{
EnableCrossPartitionQuery = true
}).AsDocumentQuery())
{
while (query.HasMoreResults)
{
foreach (var doc in await query.ExecuteNextAsync <Document>())
{
var json = JsonConvert.SerializeObject(doc);
var docRef = dir.GetBlockBlobReference($"{doc.Id}.{doc.ResourceId}.json");
await docRef.UploadTextAsync(json);
log.LogMetric("Document.BackedUp", 1);
}
}
}
log.LogInformation($"Completed backup for {name}.");
}
public static async Task <bool> UpdateInventoryApi(
[ActivityTrigger] DurableActivityContext ctx)
{
var orderDetail = ctx.GetInput <OrderDetail>();
return(await UpdateInventory(orderDetail));
}
public static async Task SendTemplates(
[ActivityTrigger] DurableActivityContext context)
{
var input = context.GetInput <(string, List <string>)>();
// テンプレート作成処理
await lineMessagingClient.ReplyMessageAsync(input.Item1,
new List <ISendMessage>
{
FlexMessage.CreateBubbleMessage("セリフをタップしてね").SetBubbleContainer(
new BubbleContainer()
.SetHeader(BoxLayout.Horizontal)
.AddHeaderContents(new TextComponent
{
Text = "セリフをタップしてね",
Margin = Spacing.Xs,
Size = ComponentSize.Sm,
Align = Align.Center,
Gravity = Gravity.Bottom,
Weight = Weight.Bold
})
.SetFooter(new BoxComponent(BoxLayout.Vertical)
{
Spacing = Spacing.Md, Flex = 0,
Contents = input.Item2.Select(t => new ButtonComponent {
Action = new MessageTemplateAction(t, t)
}).ToList <IFlexComponent>()
}))
});
}
public static async Task <long> CopyFileToBlob(
[ActivityTrigger] DurableActivityContext copyFileContext,
Binder binder,
TraceWriter log)
{
string filePath = copyFileContext.GetInput <string>();
long byteCount = new FileInfo(filePath).Length;
// strip the drive letter prefix and convert to forward slashes
string blobPath = filePath
.Substring(Path.GetPathRoot(filePath).Length)
.Replace('\\', '/');
string outputLocation = $"backups/{blobPath}";
log.Info($"Copying '{filePath}' to '{outputLocation}'. Total bytes = {byteCount}.");
// copy the file contents into a blob
using (Stream source = File.Open(filePath, FileMode.Open))
using (Stream destination = await binder.BindAsync <CloudBlobStream>(
new BlobAttribute(outputLocation)))
{
await source.CopyToAsync(destination);
}
return(byteCount);
}
public static Job CreateJob([ActivityTrigger] DurableActivityContext context)
{
ValueTuple <MediaWorkflowManifest, string, Asset> jobInput = context.GetInput <(MediaWorkflowManifest, string, Asset)>();
MediaWorkflowManifest workflowManifest = jobInput.Item1;
string inputFileUrl = jobInput.Item2;
Asset inputAsset = jobInput.Item3;
Job job = null;
string insightId = null;
MediaClient mediaClient = new MediaClient(workflowManifest);
bool videoIndexer = workflowManifest.TransformPresets.Contains <MediaTransformPreset>(MediaTransformPreset.VideoIndexer);
bool audioIndexer = workflowManifest.TransformPresets.Contains <MediaTransformPreset>(MediaTransformPreset.AudioIndexer);
if (mediaClient.IndexerEnabled() && (videoIndexer || audioIndexer))
{
insightId = mediaClient.IndexerUploadVideo(inputFileUrl, inputAsset, workflowManifest.JobPriority, videoIndexer, audioIndexer);
}
Transform transform = mediaClient.GetTransform(workflowManifest.TransformPresets);
if (transform != null)
{
MediaJobOutputInsight outputInsight = new MediaJobOutputInsight()
{
Id = insightId,
VideoIndexer = videoIndexer,
AudioIndexer = audioIndexer
};
job = mediaClient.CreateJob(transform.Name, workflowManifest.JobName, null, workflowManifest.JobPriority, inputFileUrl, inputAsset, workflowManifest.OutputAssetStorage, workflowManifest.JobOutputPublish, outputInsight, false);
}
return(job);
}
public static async Task <ProjectionResultsRecord <Get_League_Summary_Definition_Return> > RunLeagueSummaryInformationProjectionActivity(
[ActivityTrigger] DurableActivityContext context,
ILogger log)
{
#region Logging
if (null != log)
{
log.LogInformation($"GetLeagueSummaryCreateQueryRequestActivity started - instance {context.InstanceId} ");
}
#endregion
ProjectionRequest projectionRequest = context.GetInput <ProjectionRequest>();
if (null != projectionRequest)
{
return(await ProcessLeagueSummaryInformationProjection(projectionRequest.ProjectionName,
projectionRequest.AggregateInstanceUniqueIdentifier,
log));
}
else
{
#region Logging
if (null != log)
{
log.LogInformation($"Unable to read projection request {context.InstanceId} ");
}
#endregion
}
return(null);
}
public static long GetFileSize([ActivityTrigger] DurableActivityContext ctx)
{
string fileName = ctx.GetInput <string>();
var info = new FileInfo(fileName);
return(info.Length);
}
public static int OrthogonalizeColumnsWorker(
[ActivityTrigger] DurableActivityContext ctx)
{
// Do this little dance since Azure activity functions can only
// take one argument
/*
* var q_j = args.q;
* var M = args.data;
* var idx = args.idx;
* var cols = args.cols;
* var i = args.i;
*
* //var q_j = M.Column(i);
* var end_idx = idx + cols;
*
* for (int k = idx; k < end_idx; k++)
* {
* var v_k = M.Column(k);
* M.SetColumn(k, v_k - ((q_j * v_k) * q_j));
* }
*/
var data = ctx.in
return(1);
}
public static async Task Http01Precondition([ActivityTrigger] DurableActivityContext context, ILogger log)
{
var site = context.GetInput <Site>();
var websiteClient = await CreateWebSiteManagementClientAsync();
var config = await websiteClient.WebApps.GetConfigurationAsync(site);
// 既に .well-known が仮想アプリケーションとして追加されているか確認
var virtualApplication = config.VirtualApplications.FirstOrDefault(x => x.VirtualPath == "/.well-known");
if (virtualApplication == null)
{
// .well-known を仮想アプリケーションとして追加
config.VirtualApplications.Add(new VirtualApplication
{
VirtualPath = "/.well-known",
PhysicalPath = "site\\.well-known",
PreloadEnabled = false
});
}
else
{
// 追加済みの場合は物理パスを変更しているので対処
virtualApplication.PhysicalPath = "site\\.well-known";
}
await websiteClient.WebApps.UpdateConfigurationAsync(site, config);
}
public static async Task <List <Supplier> > GetActiveSuppliers([ActivityTrigger] DurableActivityContext inputs, ILogger log)
{
log.LogInformation("GetActiveSuppliers");
var carService = ServiceProvider.GetCarService();
return(await carService.GetActiveSuppliers());
}
public static async Task CheckIsReady([ActivityTrigger] DurableActivityContext context, ILogger log)
{
var orderDetails = context.GetInput <OrderDetails>();
var acme = await CreateAcmeClientAsync();
orderDetails = await acme.GetOrderDetailsAsync(orderDetails.OrderUrl, orderDetails);
if (orderDetails.Payload.Status == "pending")
{
// pending の場合はリトライする
throw new RetriableActivityException("ACME domain validation is pending.");
}
if (orderDetails.Payload.Status == "invalid")
{
// エラーログ用に Authorization を取得
foreach (var authzUrl in orderDetails.Payload.Authorizations)
{
var authorization = await acme.GetAuthorizationDetailsAsync(authzUrl);
var challenge = authorization.Challenges.FirstOrDefault(x => x.Error != null);
if (challenge != null)
{
log.LogError(JsonConvert.SerializeObject(challenge.Error));
}
}
// invalid の場合は最初から実行が必要なので失敗させる
throw new InvalidOperationException("Invalid order status. Required retry at first.");
}
}
public static async Task <List <CarPrice> > SearchCarSupplier([ActivityTrigger] DurableActivityContext inputs)
{
var r = inputs.GetInput <SupplierSearchRequest>();
var carSearchService = new CarSearchService();
return(await carSearchService.SearchCars(r.CarSearchRequest, r.Supplier));
}
public static void Run([ActivityTrigger] DurableActivityContext context, ILogger log,
ExecutionContext executionContext)
{
// config and input
_log = log;
var input = new
{
ResourceGroupName = context.GetInput <Tuple <string, string> >().Item1,
ResourcesName = context.GetInput <Tuple <string, string> >().Item2
};
var config = executionContext.BuildConfiguration();
var clientId = config["ApplicationId"];
var clientSecret = config["ApplicationSecret"];
var tenantId = config["TenantId"];
string subscriptionId = config["SubscriptionId"];
log.LogInformation($"delete activity group start {input.ResourcesName} ");
try
{
// authenticate and delete resource group
if (!AzureCredentials.Make(tenantId, clientId, clientSecret, subscriptionId)
.TryGetAzure(out IAzure azure, message => _log.LogError(message)))
{
return;
}
azure.DeleteResourcesInGroup(input.ResourceGroupName, input.ResourcesName, s => _log.LogWarning(s));
}
catch (Exception e)
{
_log.LogError($"delete activity group {input.ResourceGroupName} {e.Message}", e);
}
}
public static int Refund2([ActivityTrigger] DurableActivityContext context)
{
(int Amount, Guid Id)payload = context.GetInput <(int, Guid)>();
Account[payload.Id] = Account[payload.Id] + payload.Amount;
return(Account[payload.Id]);
}
