public StaticContentImportService(ILogger <StaticContentImportService> logger,
IOptions <DirectoryOptions> dirOptions, SiteRenderingContext siteContext)
{
_logger = logger;
_siteContext = siteContext;
_dirOptions = dirOptions.Value;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
}
app.UseMiddleware <SetGuidMiddleware>();
app.UseStaticFiles();
var directoryOptions = new DirectoryOptions();
Configuration.GetSection("Directories")
.Bind(directoryOptions);
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(directoryOptions.MediaAbsoluteDirectory),
RequestPath = directoryOptions.MediaRelativeDirectory
});
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapBlazorHub();
endpoints.MapFallbackToPage("/_Host");
});
}
public FragmentDiscoveryService(IOptions <DirectoryOptions> options,
RawFragmentImporterService importerService, ILogger <FragmentDiscoveryService> logger)
{
_importerService = importerService;
_logger = logger;
_options = options.Value;
}
static async Task Main(string[] args)
{
List <Person> list;
ConnectionOptions connectionOptions = new ConnectionOptions();
ServiceLayer.ServiceLayer serviceLayer =
new ServiceLayer.ServiceLayer(connectionOptions);
//list = serviceLayer.GetPersonList();
DirectoryOptions dirOptions = new DirectoryOptions();
XmlGenerator xmlGenerator = new XmlGenerator(dirOptions);
//xmlGenerator.ListToXml(list, dirOptions);
//Monitoring.Update();
list = await serviceLayer.GetPersonListAsync();
xmlGenerator.ListToXml(list, dirOptions);
Monitoring.Update();
//Console.WriteLine("Hello World!");
}
public ScienceExportController(IConfiguration config, ApplicationDbContext context, IMapper mapper, DirectoryOptions directoryOptions)
{
_context = context;
_mapper = mapper;
_backend = config.GetSection("Global").GetRequiredSetting("Backend");
_directoryOptions = directoryOptions;
}
public DirectoryCommand(string path, DirectoryOptions options = default, IEnumerable <DirectoryAttributeFilter> attributeFilter = null, IEnumerable <DirectorySort> sortBy = null)
{
this.Path = path;
this.Options = options;
this.attributeFilter = attributeFilter?.ToArray() ?? Array.Empty <DirectoryAttributeFilter>();
this.sortBy = sortBy?.ToArray() ?? Array.Empty <DirectorySort>();
}
public TemplateImportService(IOptions <DirectoryOptions> options, ILogger <TemplateImportService> logger,
SiteRenderingContext siteContext)
{
_logger = logger;
_siteRenderingContext = siteContext;
_options = options.Value;
}
public WorkerHostService(IConfiguration config, ILogger <WorkerHostService> logger, DirectoryOptions directoryOptions)
{
_logger = logger;
_directoryOptions = directoryOptions;
_hosts = InstantiateWorkerHostsFromConfig(config.GetSection("WorkerHosts")).ToList();
_logger.LogInformation($"Instantiated {_hosts.Count} worker hosts.");
}
public ExperimentController(ApplicationDbContext context, IMapper mapper, WorkerHostService hostService, ScalingService scalingService, IMemoryCache memoryCache, DirectoryOptions directoryOptions)
{
_context = context;
_mapper = mapper;
_hostService = hostService;
_scalingService = scalingService;
_cache = memoryCache;
_directoryOptions = directoryOptions;
}
public ExperimentFileController(ApplicationDbContext context, IMapper mapper,
DirectoryOptions directoryOptions, IOptions <GitRemoteOptions> gitRemoteOptions)
{
_context = context;
_mapper = mapper;
_directoryOptions = directoryOptions;
_gitRemoteOptions = gitRemoteOptions.Value;
relativeFolder = _directoryOptions.DataLocation + "/ExperimentTemplates";
}
public ExperimentFrameworkController(DirectoryOptions directoyOptions, ILogger <ExperimentFrameworkController> logger,
IOptions <GitRemoteOptions> gitRemoteOptions)
{
_directoyOptions = directoyOptions;
_logger = logger;
_gitRemoteOptions = gitRemoteOptions.Value;
globalpath = directoyOptions.DataLocation + "/ExperimentFramework";
projectpath = directoyOptions.DataLocation + "/ExperimentTemplates";
datalocation = directoyOptions.DataLocation;
}
public StaticContentExportService(ILogger <StaticContentExportService> logger,
PublishDirectoryWriter outputWriter,
SiteRenderingContext siteContext, StaticContentImportService importService,
IOptions <DirectoryOptions> dirOptions)
{
_logger = logger;
_outputWriter = outputWriter;
_siteContext = siteContext;
_importService = importService;
_dirOptions = dirOptions.Value;
}
private void EnsureDataLocationAvailable(string location, DirectoryOptions directoryOptions)
{
var di = new DirectoryInfo(location);
if (!di.Exists)
{
di.Create();
/* Copy existing examples to this location */
directoryOptions.CopyDirectoryRecursively(new DirectoryInfo("AppData/ExperimentTemplates"), location + "/ExperimentTemplates");
directoryOptions.CopyDirectoryRecursively(new DirectoryInfo("AppData/ExperimentFramework"), location + "/ExperimentFramework");
}
}
public async void ListToXml(List <Person> list, DirectoryOptions options)
{
XmlSerializer xml = new XmlSerializer(list.GetType());
await Task.Run(() =>
{
using (FileStream fs = new FileStream(Path.Combine(options.SoursceDirectory,
"list.xml"), FileMode.Create))
{
xml.Serialize(fs, list);
}
log.AddToLog("ListToXml: OK\n");
});
}
internal static void Validate(ETLOptions options, Logger logger)
{
DirectoryOptions directoryOptions = options.DirectoryOptions;
if (!MakeValidDir(directoryOptions.SourceDirectory))
{
directoryOptions.SourceDirectory = @"C:\FileWatcher\SourceDirectory";
MakeValidDir(directoryOptions.SourceDirectory);
logger.Log("Using default directory. Error in creating sourseDirectory ", true);
}
if (!MakeValidDir(directoryOptions.TargetDirectory))
{
directoryOptions.TargetDirectory = @"C:\FileWatcher\TargetDirectory";
MakeValidDir(directoryOptions.TargetDirectory);
logger.Log("Using default directory. Error in creating targetDirectory", true);
}
if (!MakeValidDir(directoryOptions.ArchiveDirectory))
{
directoryOptions.ArchiveDirectory = @"C:\FileWatcher\TargetDirectory\archive";
MakeValidDir(directoryOptions.ArchiveDirectory);
logger.Log("The access to archive directory is denied, using default directory.", true);
}
if (!MakeValidFile(directoryOptions.LogFile))
{
directoryOptions.LogFile = @"C:\FileWtcher\TargetDirectory\Logfile.txt";
MakeValidFile(directoryOptions.LogFile);
logger.Log("The access to log file is denied, using default log file.", true);
}
ArchiveOptions archivationOptions = options.ArchiveOptions;
if ((int)archivationOptions.CompressionLevel < 0 || (int)archivationOptions.CompressionLevel > 2)
{
archivationOptions.CompressionLevel = System.IO.Compression.CompressionLevel.Optimal;
logger.Log("Incorrect value of compression level. Default value is set.", true);
}
}
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(
options =>
{
options.AddPolicy("AllowAll",
p => p.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader().AllowCredentials());
});
if (Configuration.GetValue <string>("Backend:Server", "sqlite") == "sqlite")
{
var sqliteFileName = "maci_data.db";
services.AddDbContext <ApplicationDbContext>(options => options.UseSqlite("Data Source=./" + sqliteFileName));
}
else if (Configuration.GetValue <string>("Backend:Server", "sqlite") == "postgres")
{
// services.AddDbContext<ApplicationDbContext>(options => options.UseNpgsql(Configuration.GetConnectionString("DefaultConnection")));
services.AddDbContext <ApplicationDbContext>(options => options.UseNpgsql(Configuration.GetValue <string>("Backend:DefaultConnection")));
}
services.AddMvc().AddJsonOptions(options =>
{
// Use PascalCase for serializing JSON objects.
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
});
services.AddSingleton <IConfiguration>(Configuration); // Probably not the cleanest solution...
services.AddSingleton(sp => MapperConfiguration.CreateMapper());
services.AddSingleton <WorkerHostService>();
services.AddSingleton <ScalingService>();
services.AddMemoryCache();
services.Configure <ExportOptions>(Configuration.GetSection("Export"));
services.Configure <GitRemoteOptions>(Configuration.GetSection("Git:RemoteCredentials"));
var DataLocation = Configuration.GetValue <string>("Backend:DataLocation");
var directoryOptions = new DirectoryOptions()
{
DataLocation = DataLocation
};
EnsureDataLocationAvailable(DataLocation, directoryOptions);
services.AddSingleton <DirectoryOptions>(directoryOptions);
}
private void TestSASTokenOfEachVersion(string targetSASVersion, bool isDirectoryTransfer)
{
Test.Info("Testing version of {0}", targetSASVersion);
DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty);
DMLibDataHelper.AddOneFileInBytes(sourceDataInfo.RootNode, DMLibTestBase.FileName, 1024);
var options = new TestExecutionOptions <DMLibDataInfo>();
options.IsDirectoryTransfer = isDirectoryTransfer;
options.TransferItemModifier = (fileNode, transferItem) =>
{
dynamic transferOptions = isDirectoryTransfer ? DefaultTransferDirectoryOptions : DefaultTransferOptions;
transferItem.Options = transferOptions;
if (isDirectoryTransfer)
{
transferItem.TransferContext = new DirectoryTransferContext();
transferItem.TransferContext.FileFailed += (source, e) =>
{
Test.Error(e.Exception.ToString());
};
DirectoryOptions dirOptions = transferItem.Options as DirectoryOptions;
dirOptions.Recursive = true;
}
else
{
transferItem.TransferContext = new SingleTransferContext();
}
transferItem.TransferContext.ShouldOverwriteCallbackAsync = TransferContext.ForceOverwrite;
};
string sourceSAS = null;
string destSAS = null;
switch (DMLibTestContext.SourceType)
{
case DMLibDataType.CloudBlob:
case DMLibDataType.AppendBlob:
case DMLibDataType.BlockBlob:
case DMLibDataType.PageBlob:
if ((DMLibTestContext.SourceType == DMLibDataType.AppendBlob) &&
(string.CompareOrdinal(targetSASVersion, "2015-04-05") < 0))
{
break;
}
SourceAdaptor.CreateIfNotExists();
CloudBlobDataAdaptor blobAdaptor = SourceAdaptor as CloudBlobDataAdaptor;
sourceSAS = Util.SASGenerator.GetSharedAccessSignature(blobAdaptor.GetBaseContainer(),
new SharedAccessBlobPolicy
{
Permissions = isDirectoryTransfer ? SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.List : SharedAccessBlobPermissions.Read,
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddHours(1)
},
null,
null,
null,
targetSASVersion);
break;
case DMLibDataType.CloudFile:
if (string.CompareOrdinal(targetSASVersion, "2015-02-21") < 0)
{
break;
}
SourceAdaptor.CreateIfNotExists();
CloudFileDataAdaptor fileAdaptor = SourceAdaptor as CloudFileDataAdaptor;
sourceSAS = Util.SASGenerator.GetSharedAccessSignature(
fileAdaptor.GetBaseShare(),
new SharedAccessFilePolicy
{
Permissions = isDirectoryTransfer ? SharedAccessFilePermissions.List | SharedAccessFilePermissions.Read : SharedAccessFilePermissions.Read,
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddHours(1)
},
null,
null,
null,
targetSASVersion);
break;
default:
break;
}
if (!DMLibTestContext.IsAsync ||
(string.CompareOrdinal(targetSASVersion, "2014-02-14") >= 0))
{
switch (DMLibTestContext.DestType)
{
case DMLibDataType.CloudBlob:
case DMLibDataType.AppendBlob:
case DMLibDataType.BlockBlob:
case DMLibDataType.PageBlob:
if ((DMLibTestContext.DestType == DMLibDataType.AppendBlob) &&
(string.CompareOrdinal(targetSASVersion, "2015-04-05") < 0))
{
break;
}
DestAdaptor.CreateIfNotExists();
CloudBlobDataAdaptor blobAdaptor = DestAdaptor as CloudBlobDataAdaptor;
destSAS = Util.SASGenerator.GetSharedAccessSignature(blobAdaptor.GetBaseContainer(),
new SharedAccessBlobPolicy
{
Permissions = DMLibTestContext.IsAsync ? SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.Read : SharedAccessBlobPermissions.Write,
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddHours(1)
},
null,
null,
null,
targetSASVersion);
break;
case DMLibDataType.CloudFile:
if (string.CompareOrdinal(targetSASVersion, "2015-02-21") < 0)
{
break;
}
DestAdaptor.CreateIfNotExists();
CloudFileDataAdaptor fileAdaptor = DestAdaptor as CloudFileDataAdaptor;
destSAS = Util.SASGenerator.GetSharedAccessSignature(
fileAdaptor.GetBaseShare(),
new SharedAccessFilePolicy
{
Permissions = DMLibTestContext.IsAsync ? SharedAccessFilePermissions.Write | SharedAccessFilePermissions.Read : SharedAccessFilePermissions.Write,
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddHours(1)
},
null,
null,
null,
targetSASVersion);
break;
default:
break;
}
}
if (null != sourceSAS)
{
options.SourceCredentials = new StorageCredentials(sourceSAS);
}
if (null != destSAS)
{
options.DestCredentials = new StorageCredentials(destSAS);
}
var result = this.ExecuteTestCase(sourceDataInfo, options);
VerificationHelper.VerifyTransferSucceed(result, sourceDataInfo);
}
public PublishDirectoryCleanupService(ILogger <PublishDirectoryCleanupService> logger, IOptions <DirectoryOptions> dirOptions)
{
_logger = logger;
_dirOptions = dirOptions.Value;
}
public XmlGenerator(DirectoryOptions options)
{
Directory.CreateDirectory(options.SoursceDirectory);
}
public WorkerController(IConfiguration config, ApplicationDbContext context, IMapper mapper, IHostingEnvironment env, DirectoryOptions directoryOptions)
{
_context = context;
_mapper = mapper;
_directoryOptions = directoryOptions;
}
public ExperimentInstanceController(ApplicationDbContext context, IMapper mapper, DirectoryOptions directoryOptions)
{
_context = context;
_mapper = mapper;
_directoryOptions = directoryOptions;
}
public PublishDirectoryWriter(IOptions <DirectoryOptions> dirOptions,
ILogger <PublishDirectoryWriter> logger)
{
_logger = logger;
_dirOptions = dirOptions.Value;
}
