Task <T> ExecuteAsync(Task <T> task, Func <T, Task <T> > continuationTask, ExecuteOptions options)
{
var source = new TaskCompletionSource <Task <T> >();
task.ContinueWith((Task <T> innerTask) =>
{
if (innerTask.IsFaulted)
{
source.TrySetException(innerTask.Exception.InnerExceptions);
}
else if (innerTask.IsCanceled || _cancellationToken.IsCancellationRequested)
{
source.TrySetCanceled();
}
else
{
try
{
source.TrySetResult(continuationTask(innerTask.Result));
}
catch (Exception ex)
{
source.TrySetException(ex);
}
}
}, options.HasFlag(ExecuteOptions.RunSynchronously)
? TaskContinuationOptions.ExecuteSynchronously
: TaskContinuationOptions.None);
return(source.Task.FastUnwrap());
}
Task <T> Execute(Task <T> task, Func <T, Task <T> > continuationTask, ExecuteOptions options)
{
if (task.IsCompleted && options.HasFlag(ExecuteOptions.RunSynchronously))
{
if (task.IsFaulted)
{
return(TaskUtil.Faulted <T>(task.Exception.InnerExceptions));
}
if (task.IsCanceled || _cancellationToken.IsCancellationRequested)
{
return(TaskUtil.Canceled <T>());
}
if (task.Status == TaskStatus.RanToCompletion)
{
try
{
return(continuationTask(task.Result));
}
catch (Exception ex)
{
return(TaskUtil.Faulted <T>(ex));
}
}
}
return(ExecuteAsync(task, continuationTask, options));
}
/// <summary>
/// ExecuteOnChannel method implementation
/// </summary>
private void ExecuteOnSpecificChannel(string operationName, string uri, ExecuteOptions options, CodeToRunOnChannel codeBlock)
{
using (new SPMonitoredScope("ExecuteSpecificChannel:" + operationName))
{
try
{
string ep = FindLoadBalancerEndPoint(uri);
if (!string.IsNullOrEmpty(ep))
{
Uri xu = new Uri(ep);
IChannel channel = (IChannel)GetChannel(xu, options);
try
{
codeBlock((IIdentityServiceContract)channel);
channel.Close();
}
finally
{
if (channel.State != CommunicationState.Closed)
{
channel.Abort();
}
}
}
}
finally
{
}
}
}
/// <summary>
/// GetChannel method implementation
/// </summary>
private IIdentityServiceContract GetChannel(Uri address, ExecuteOptions options)
{
string endpointConfigurationName = GetEndpointConfigurationName(address);
if ((null == m_ChannelFactory) || (endpointConfigurationName != m_EndpointConfigurationName))
{
lock (m_ChannelFactoryLock)
{
if ((null == m_ChannelFactory) || (endpointConfigurationName != m_EndpointConfigurationName))
{
m_ChannelFactory = CreateChannelFactory <IIdentityServiceContract>(endpointConfigurationName);
m_EndpointConfigurationName = endpointConfigurationName;
}
}
}
IIdentityServiceContract channel;
if (ExecuteOptions.AsProcess == (options & ExecuteOptions.AsProcess))
{
channel = m_ChannelFactory.CreateChannelAsProcess <IIdentityServiceContract>(new EndpointAddress(address));
}
else
{
channel = m_ChannelFactory.CreateChannelActingAsLoggedOnUser <IIdentityServiceContract>(new EndpointAddress(address));
}
return(channel);
}
private static int Run(ExecuteOptions options)
{
PopulateMissingConfigValues(ref options);
var app = DependencyRegistry.GetApplication(options);
return(app.Run(options));
}
/// <summary>
/// Invoke method implementation
/// </summary>
private T Invoke <T>(string operationName, string uri, ExecuteOptions options, InvokeDelegate <T> operation)
{
using (new SPMonitoredScope("Invoke :" + operationName + "_" + uri))
{
string ep = FindLoadBalancerEndPoint(uri);
if (!string.IsNullOrEmpty(ep))
{
Uri xu = new Uri(ep);
IIdentityServiceContract identityapplication = GetChannel(xu, options);
IClientChannel clientChannel = identityapplication as IClientChannel;
try
{
operation(identityapplication);
clientChannel.Close();
}
finally
{
if (clientChannel.State != CommunicationState.Closed)
{
clientChannel.Abort();
}
}
}
}
return(default(T));
}
public static Task <TResponse> ExecuteAsync <TRequest, TResponse>(this IClient client, TRequest request,
ExecuteOptions settings)
where TRequest : ClientRequest
where TResponse : IResponse
{
return(client.ExecuteAsync <TRequest, TResponse>(request, settings, CancellationToken.None));
}
/// <summary>
/// ExecuteOnChannel method implementation
/// </summary>
private void ExecuteOnChannel(string operationName, ExecuteOptions options, CodeToRunOnChannel codeBlock)
{
using (new SPMonitoredScope("ExecuteOnChannel:" + operationName))
{
bool mustexit = false;
string firstaddress = "";
do
{
SPServiceLoadBalancerContext loadBalancerContext = m_LoadBalancer.BeginOperation();
try
{
if (firstaddress.Equals(loadBalancerContext.EndpointAddress.ToString()))
{
mustexit = true;
}
if (!mustexit)
{
if ((loadBalancerContext.Status == SPServiceLoadBalancerStatus.Succeeded))
{
if (string.IsNullOrEmpty(firstaddress))
{
firstaddress = loadBalancerContext.EndpointAddress.ToString();
}
IChannel channel = (IChannel)GetChannel(loadBalancerContext.EndpointAddress, options);
try
{
codeBlock((IIdentityServiceContract)channel);
channel.Close();
mustexit = true;
}
catch (TimeoutException)
{
loadBalancerContext.Status = SPServiceLoadBalancerStatus.Failed;
}
catch (EndpointNotFoundException)
{
loadBalancerContext.Status = SPServiceLoadBalancerStatus.Failed;
}
finally
{
if (channel.State != CommunicationState.Closed)
{
channel.Abort();
}
}
}
}
}
finally
{
loadBalancerContext.EndOperation();
}
}while (!mustexit);
}
}
protected static int RunExecuteAndReturnExitCode(ExecuteOptions opts, ITelemetryLogger telemetryLogger, PlatformSpecificServices AddPlatformSpecificServices, EngineEntryPoint StartEngine)
{
telemetryLogger.TrackEvent("ExecuteCommand");
if (opts.ConfigFile == string.Empty)
{
opts.ConfigFile = "configuration.json";
}
if (!File.Exists(opts.ConfigFile))
{
Log.Information("The config file {ConfigFile} does not exist, nor does the default 'configuration.json'. Use '{ExecutableName}.exe init' to create a configuration file first", opts.ConfigFile, System.Reflection.Assembly.GetExecutingAssembly().GetName().Name);
return(1);
}
Log.Information("Config Found, creating engine host");
var config = new EngineConfigurationBuilder().BuildFromFile(opts.ConfigFile);
Console.Title = $"Azure DevOps Migration Tools: {System.IO.Path.GetFileName(opts.ConfigFile)} - {System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(3)} - {config.Source.Project} - {config.Target.Project}";
// Setup Host
var host = Host.CreateDefaultBuilder()
.ConfigureHostConfiguration(configHost =>
{
configHost.SetBasePath(Directory.GetCurrentDirectory());
configHost.AddJsonFile("appsettings.json", optional: true);
configHost.AddEnvironmentVariables();
})
.ConfigureAppConfiguration((hostContext, configApp) =>
{
configApp.SetBasePath(Directory.GetCurrentDirectory());
configApp.AddJsonFile(opts.ConfigFile, optional: false);
configApp.AddJsonFile(
$"{opts.ConfigFile}.{hostContext.HostingEnvironment.EnvironmentName}.json",
optional: true);
})
.ConfigureServices((context, services) =>
{
services.AddOptions();
services.AddSingleton <IDetectOnlineService, DetectOnlineService>();
services.AddSingleton <IDetectVersionService, DetectVersionService>();
services.AddSingleton <ITelemetryLogger>(telemetryLogger);
services.AddSingleton <IEngineConfigurationBuilder, EngineConfigurationBuilder>();
services.AddSingleton <EngineConfiguration>(config);
services.AddSingleton <ProcessorContainer>();
services.AddSingleton <TypeDefinitionMapContainer>();
services.AddSingleton <GitRepoMapContainer>();
services.AddSingleton <ChangeSetMappingContainer>();
AddPlatformSpecificServices(services);
})
.UseConsoleLifetime()
.UseSerilog()
.Build();
StartEngine(host, opts);
Log.Information("Run complete...");
return(0);
}
/// <summary>
/// Execute an taskFactory with the specified payload.
/// </summary>
/// <param name="composer">The source composer</param>
/// <param name="taskFactory">The taskFactory to execute</param>
/// <param name="options">The task execution options</param>
/// <returns></returns>
public static Composer <T> ExecuteAsync <T>(this Composer <T> composer, Func <T, CancellationToken, Task> taskFactory,
ExecuteOptions options = ExecuteOptions.None)
{
return(composer.ExecuteAsync(async(payload, token) =>
{
await taskFactory(payload, token);
return payload;
}, options));
}
Composer Composer.ExecuteAsync(Func <CancellationToken, Task> taskFactory, ExecuteOptions options)
{
_composer.ExecuteAsync(async(x, token) =>
{
await taskFactory(token);
return(x);
}, options);
return(this);
}
Composer <T> Composer <T> .Finally(Action <T, TaskStatus> continuation, ExecuteOptions options)
{
if (_task.IsCompleted && options.HasFlag(ExecuteOptions.RunSynchronously))
{
continuation(_payload, _task.Status);
return(this);
}
_task = FinallyAsync(_task, continuation, options);
return(this);
}
public ExecuteHostedService(
ExecuteOptions exceuteOptions,
IMigrationEngine migrationEngine,
ILogger <ExecuteHostedService> logger,
IHostApplicationLifetime appLifetime)
{
_exceuteOptions = exceuteOptions;
_migrationEngine = migrationEngine;
_logger = logger;
_appLifetime = appLifetime;
}
public ExecuteHostedService(
IServiceProvider services,
ExecuteOptions exceuteOptions,
ILogger <ExecuteHostedService> logger,
IHostApplicationLifetime appLifetime)
{
_exceuteOptions = exceuteOptions;
_services = services;
_logger = logger;
_appLifetime = appLifetime;
}
/// <inheritdoc/>
public async Task <object> ExecuteAsync(object request, ExecuteOptions settings, CancellationToken cancellationToken)
{
if (request is HttpRequest httpRequest)
{
var requestMessage = CreateHttpRequestMessage(httpRequest);
var responseMessage = await HttpClient.SendAsync(requestMessage, cancellationToken);
return(new HttpResponse(responseMessage));
}
throw new ArgumentException($"request type not {typeof(HttpRequest)}.", nameof(request));
}
private static IExecute GetServiceFromOption(ExecuteOptions option) {
var list = new Dictionary<ExecuteOptions, IExecute>
{
{ExecuteOptions.ListVerifiedEmailAddresses,new ExecuteListVerifiedEmailAddresses()},
{ExecuteOptions.VerifyEmailAddress,new ExecuteVerifyEmailAddress()},
{ExecuteOptions.DeleteVerifiedEmailAddress,new ExecuteDeleteVerifiedEmailAddress()},
{ExecuteOptions.SendStatistics,new ExecuteSendStatistics()},
{ExecuteOptions.SendQuota, new ExecuteSendQuota()},
{ExecuteOptions.SendEmail, new ExecuteSendEmail()},
{ExecuteOptions.SendRawEmail, new ExecuteSendRawEmail()}
};
return list.ContainsKey(option) ? list[option] : null;
}
private static (InitOptions init, ExecuteOptions execute) ParseOptions(string[] args)
{
InitOptions initOptions = null;
ExecuteOptions executeOptions = null;
Parser.Default.ParseArguments <InitOptions, ExecuteOptions>(args)
.WithParsed <InitOptions>(opts =>
{
initOptions = opts;
})
.WithParsed <ExecuteOptions>(opts =>
{
executeOptions = opts;
});
return(initOptions, executeOptions);
}
public MigrationEngine(
ExecuteOptions executeOptions,
EngineConfiguration config,
TypeDefinitionMapContainer typeDefinitionMaps,
ProcessorContainer processors,
GitRepoMapContainer gitRepoMaps,
ChangeSetMappingContainer changeSetMapps,
FieldMapContainer fieldMaps,
ITelemetryLogger telemetry)
{
Log.Information("Creating Migration Engine {Guid}", _Guid);
FieldMaps = fieldMaps;
this.executeOptions = executeOptions;
TypeDefinitionMaps = typeDefinitionMaps;
Processors = processors;
GitRepoMaps = gitRepoMaps;
ChangeSetMapps = changeSetMapps;
Telemetry = telemetry;
ProcessConfiguration(config);
}
public static void StartEngine(IHost host, ExecuteOptions opts)
{
var me = host.Services.GetRequiredService <MigrationEngineCore>();
NetworkCredential sourceCredentials = null;
NetworkCredential targetCredentials = null;
if (!string.IsNullOrWhiteSpace(opts.SourceUserName) && !string.IsNullOrWhiteSpace(opts.SourcePassword))
{
sourceCredentials = new NetworkCredential(opts.SourceUserName, opts.SourcePassword, opts.SourceDomain);//new VssCredentials(new Microsoft.VisualStudio.Services.Common.WindowsCredential(new NetworkCredential(opts.SourceUserName, opts.SourcePassword, opts.SourceDomain)));
}
if (!string.IsNullOrWhiteSpace(opts.TargetUserName) && !string.IsNullOrWhiteSpace(opts.TargetPassword))
{
targetCredentials = new NetworkCredential(opts.TargetUserName, opts.TargetPassword, opts.TargetDomain);//new VssCredentials(new Microsoft.VisualStudio.Services.Common.WindowsCredential(new NetworkCredential(opts.TargetUserName, opts.TargetPassword, opts.TargetDomain)));
}
//me.AddNetworkCredentials(sourceCredentials, targetCredentials);
Log.Information("Engine created, running...");
me.Run();
}
/// <summary>
/// 開始処理
/// </summary>
/// <param name="filePath"></param>
public ExcelFormatter(string filePath, ExcelFormatterApp eApp, Config config, ExecuteOptions options, string directory)
{
// アプリケーションの代入
this.ExcelApp = eApp.Application;
// テンプレートワークブックの読み込み
this.TemplateWorkBook = eApp.Template;
// コンフィグファイルの読み込み
this.Config = config;
// 実行オプションの読み込み
this.Options = options;
// 更新時刻の記録
if (!this.Options.OverWriteWriteTime)
{
this.CreationTime = File.GetCreationTime(filePath);
this.LastAccessTime = File.GetLastAccessTime(filePath);
this.LastWriteTime = File.GetLastWriteTime(filePath);
}
this.filePath = filePath;
this.Directory = directory;
}
Task <T> FinallyAsync(Task <T> task, Action <T, TaskStatus> continuation, ExecuteOptions options)
{
var source = new TaskCompletionSource <T>();
task.ContinueWith((Task <T> innerTask) =>
{
try
{
continuation(_payload, innerTask.Status);
source.TrySetFromTask(innerTask);
}
catch (Exception ex)
{
source.TrySetException(ex);
}
}, options.HasFlag(ExecuteOptions.RunSynchronously)
? TaskContinuationOptions.ExecuteSynchronously
: TaskContinuationOptions.None);
return(source.Task);
}
public MigrationEngine(
IServiceProvider services,
ExecuteOptions executeOptions,
EngineConfiguration config,
TypeDefinitionMapContainer typeDefinitionMaps,
ProcessorContainer processors,
GitRepoMapContainer gitRepoMaps,
ChangeSetMappingContainer changeSetMapps,
FieldMapContainer fieldMaps,
ITelemetryLogger telemetry)
{
Log.Information("Creating Migration Engine {SessionId}", telemetry.SessionId);
_services = services;
FieldMaps = fieldMaps;
this.executeOptions = executeOptions;
TypeDefinitionMaps = typeDefinitionMaps;
Processors = processors;
GitRepoMaps = gitRepoMaps;
ChangeSetMapps = changeSetMapps;
Telemetry = telemetry;
Config = config;
}
/// <summary>
/// エクセルファイル群をフォーマットします。
/// </summary>
/// <param name="directoryList"></param>
/// <param name="executeOptions"></param>
/// <param name="excelApp"></param>
private static void FormatExcelFiles(CommandArgument directoryList, ExecuteOptions executeOptions, ExcelFormatterApp excelApp)
{
foreach (string directory in directoryList.Values)
{
// ディレクトリ下のxlsxファイルをすべて取得
DirectoryInfo di = new DirectoryInfo(directory);
// ディレクトリ検索オプション
SearchOption searchOption = executeOptions.SubDirectory ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
try
{
FileInfo[] files = System.Array.FindAll(di.GetFiles("*", searchOption), SearchFile);
Console.WriteLine("----------------------------------------");
LogUtil.Log("ディレクトリ[" + directory + "]内のエクセルファイルに対し処理を開始します。");
foreach (FileInfo file in files)
{
// エクセルファイル一つ一つに対して処理を行う
using (ExcelFormatter formatter = new ExcelFormatter(file.FullName, excelApp, excelApp.Config, executeOptions, directory))
{
try
{
formatter.Open();
formatter.Format();
formatter.SaveAndClose();
}
catch (Exception e)
{
LogUtil.LogWarn("[" + file + "] の処理中にエラーが発生しました。対象への処理を停止します。", e);
}
}
}
}
catch (System.IO.DirectoryNotFoundException e)
{
LogUtil.LogError("[" + directory + "]は存在しないディレクトリです。対象への処理を停止します。", e);
}
}
}
public static void ExecuteEntryPoint(IHost host, ExecuteOptions opts)
{
var me = host.Services.GetRequiredService <Engine.MigrationEngine>();
NetworkCredential sourceCredentials = null;
NetworkCredential targetCredentials = null;
if (!string.IsNullOrWhiteSpace(opts.SourceUserName) && !string.IsNullOrWhiteSpace(opts.SourcePassword))
{
sourceCredentials = new NetworkCredential(opts.SourceUserName, opts.SourcePassword, opts.SourceDomain);//new VssCredentials(new Microsoft.VisualStudio.Services.Common.WindowsCredential(new NetworkCredential(opts.SourceUserName, opts.SourcePassword, opts.SourceDomain)));
}
if (!string.IsNullOrWhiteSpace(opts.TargetUserName) && !string.IsNullOrWhiteSpace(opts.TargetPassword))
{
targetCredentials = new NetworkCredential(opts.TargetUserName, opts.TargetPassword, opts.TargetDomain);//new VssCredentials(new Microsoft.VisualStudio.Services.Common.WindowsCredential(new NetworkCredential(opts.TargetUserName, opts.TargetPassword, opts.TargetDomain)));
}
me.AddNetworkCredentials(sourceCredentials, targetCredentials);
if (!string.IsNullOrWhiteSpace(opts.ChangeSetMappingFile))
{
IChangeSetMappingProvider csmp = new ChangeSetMappingProvider(opts.ChangeSetMappingFile);
csmp.ImportMappings(me.ChangeSetMapping);
}
Log.Information("Engine created, running...");
me.Run();
}
Composer Composer.Execute(Action action, ExecuteOptions options)
{
_composer.Execute(x => action(), options);
return(this);
}
/// <summary>
/// ExecuteOnChannel method implementation
/// </summary>
private T Execute <T>(string operationName, ExecuteOptions options, ExecuteDelegate <T> operation)
{
T result;
object obj = null;
using (new SPMonitoredScope("Execute :" + operationName))
{
bool mustexit = false;
string firstaddress = "";
do
{
SPServiceLoadBalancerContext loadBalancerContext = m_LoadBalancer.BeginOperation();
try
{
if (firstaddress.Equals(loadBalancerContext.EndpointAddress.ToString()))
{
mustexit = true;
}
if (!mustexit)
{
if ((loadBalancerContext.Status == SPServiceLoadBalancerStatus.Succeeded))
{
if (string.IsNullOrEmpty(firstaddress))
{
firstaddress = loadBalancerContext.EndpointAddress.ToString();
}
IIdentityServiceContract identityapplication = GetChannel(loadBalancerContext.EndpointAddress, options);
IClientChannel clientChannel = identityapplication as IClientChannel;
try
{
obj = operation(identityapplication);
clientChannel.Close();
mustexit = true;
}
catch (TimeoutException)
{
loadBalancerContext.Status = SPServiceLoadBalancerStatus.Failed;
}
catch (EndpointNotFoundException)
{
loadBalancerContext.Status = SPServiceLoadBalancerStatus.Failed;
}
finally
{
if (clientChannel.State != CommunicationState.Closed)
{
clientChannel.Abort();
}
}
}
}
}
finally
{
loadBalancerContext.EndOperation();
}
}while (!mustexit);
result = (T)((object)obj);
}
return(result);
}
private static int Run(ExecuteOptions options) => GetApplication(options).Run(options);
public EngineConfigurationWrapper(IEngineConfigurationBuilder engineConfigurationBuilder, ExecuteOptions opts, ILogger <EngineConfigurationWrapper> logger)
{
if (opts == null) //means that we are in init command and not execute
{
_engineConfiguration = engineConfigurationBuilder.BuildDefault();
return;
}
if (opts.ConfigFile == string.Empty)
{
opts.ConfigFile = "configuration.json";
}
if (!File.Exists(opts.ConfigFile))
{
logger.LogInformation("The config file {ConfigFile} does not exist, nor does the default 'configuration.json'. Use '{ExecutableName}.exe init' to create a configuration file first", opts.ConfigFile, Assembly.GetEntryAssembly().GetName().Name);
throw new ArgumentException("missing configfile");
}
logger.LogInformation("Config Found, creating engine host");
_engineConfiguration = engineConfigurationBuilder.BuildFromFile(opts.ConfigFile);
}
Composer <T> Composer <T> .ExecuteAsync(Func <T, CancellationToken, Task <T> > taskFactory, ExecuteOptions options)
{
_task = Execute(_task, payload => taskFactory(payload, _cancellationToken), options);
return(this);
}
Composer <T> Composer <T> .Execute(Action <T> action, ExecuteOptions options)
{
_task = Execute(_task, payload => TaskUtil.RunSynchronously(payload, action, _cancellationToken), options);
return(this);
}
/// <summary>
/// Constructor
/// </summary>
public CSExecutor()
{
rethrow = false;
options = new ExecuteOptions();
}
Composer Composer.Finally(Action <TaskStatus> continuation, ExecuteOptions options)
{
_composer.Finally((x, status) => continuation(status), options);
return(this);
}
