public void uploadStreamTest()
{
try
{
Mac mac = new Mac(Settings.AccessKey, Settings.SecretKey);
UploadManager target = new UploadManager();
string key = "s" + SmartHeatStationParaInfo.TimeHelper.GetUpLoadTime() + ".txt";
string filePath = "stations.txt";
FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
PutPolicy putPolicy = new PutPolicy();
putPolicy.Scope = Settings.Bucket + ":" + key;
putPolicy.SetExpires(3600);
putPolicy.DeleteAfterDays = 1;
string token = Auth.createUploadToken(putPolicy, mac);
UploadOptions uploadOptions = null;
UpCompletionHandler upCompletionHandler = new UpCompletionHandler(delegate(string fileKey, ResponseInfo respInfo, string response)
{
});
target.uploadStream(fs, key, token, uploadOptions, upCompletionHandler);
}
catch
{
}
}
public void UploadFile(QiNiuConfig qiNiuConfig)
{
// 上传策略
PutPolicy putPolicy = new PutPolicy();
// 设置要上传的目标空间
putPolicy.Scope = qiNiuConfig.Bucket;
// 上传策略的过期时间(单位:秒)
putPolicy.SetExpires(3600);
// 文件上传完毕后，在多少天后自动被删除
//putPolicy.DeleteAfterDays = 1;
// 请注意这里的Zone设置(如果不设置，就默认为华东机房)
// var zoneId = Qiniu.Common.AutoZone.Query(AK,BUCKET);
// Qiniu.Common.Config.ConfigZone(zoneId);
Mac mac = new Mac(qiNiuConfig.AK, qiNiuConfig.SK); // Use AK & SK here
// 生成上传凭证
string uploadToken = Auth.createUploadToken(putPolicy, mac);
UploadOptions uploadOptions = null;
// 上传完毕事件处理
UpCompletionHandler uploadCompleted = new UpCompletionHandler(OnUploadCompleted);
// 方式1：使用UploadManager
//默认设置 Qiniu.Common.Config.PUT_THRESHOLD = 512*1024;
//可以适当修改,UploadManager会根据这个阈值自动选择是否使用分片(Resumable)上传
UploadManager um = new UploadManager();
um.uploadFile(qiNiuConfig.LocalFile, qiNiuConfig.SaveKey, uploadToken, uploadOptions, qiNiuConfig.UpHandler);
// 方式2：使用FormManager
//FormUploader fm = new FormUploader();
//fm.uploadFile(localFile, saveKey, token, uploadOptions, uploadCompleted);
}
private static int Upload(IServiceProvider provider, UploadOptions options, CancellationToken token)
{
if (options.Interactive)
{
ConsoleHelpers.WriteLine("Enter the numeric file ID or workshop item URL to update, followed by <enter>: ");
ConsoleHelpers.WriteLine();
var input = Console.ReadLine().Trim();
if (ulong.TryParse(input, out var rawFileId))
{
options.ExistingItem = rawFileId;
}
else if (ulong.TryParse(Regex.Match(input, @"\?id=(?<fileId>[0-9]*)").Groups["fileId"].Value, out var urlFileId))
{
options.ExistingItem = urlFileId;
}
else
{
ConsoleHelpers.FatalError($"Unable to find workshop item ID in '{input}'");
}
}
provider.GetRequiredService <WorkshopUploader>()
.Upload(options.UploadDirectory, options.ExistingItem, token)
.GetAwaiter()
.GetResult();
ConsoleHelpers.WaitBeforeExiting(TimeSpan.FromSeconds(10), PrimaryCancellationSource.Token)
.GetAwaiter()
.GetResult();
return(0);
}
public void uploadoptions_with_different_chunksize()
{
var opts = new UploadOptions
{
ChunkSizeBytes = 1024
};
var data = TestBytes.Generate(1024 * 2);
var fileId = bucket.Upload(testfile, data, opts);
fileId.Should().NotBeEmpty();
var info = bucket.GetFileInfoByNameAsync(testfile, -1).WaitSync();
info.ChunkSizeBytes.Should().Be(1024);
//verify chunks
var chunks = GridUtility.EnumerateChunks(bucket, info.Id).ToList();
chunks.Count.Should().Be(2);
foreach (var chunk in chunks)
{
chunk.Data.Length.Should().Be(1024);
}
}
private void UploadSingleFile(IAmazonGlacier client,
string vaultName,
string accountId,
string filePath,
string description)
{
using (var transferManager = new ArchiveTransferManager(client))
{
var runner = new ProgressRunner(this);
var uploadOptions = new UploadOptions
{
AccountId = accountId
};
var tracker = new UploadProgressTracker(runner, handler => uploadOptions.StreamTransferProgress += handler, filePath);
var output = new CmdletOutput();
runner.SafeRun(() =>
{
#if DESKTOP
var result = transferManager.Upload(vaultName, description, filePath, uploadOptions);
#else
var result = transferManager.UploadAsync(vaultName, description, filePath, uploadOptions).GetAwaiter().GetResult();
#endif
output.PipelineOutput = new FileUploadResult(filePath, result);
}, tracker, output);
// write as we go so that any subsequent error doesn't cause the user to lose
// the ids of archives we have successfully uploaded so far
ProcessOutput(output);
}
}
private void UploadSingleFile(IAmazonGlacier client,
string vaultName,
string accountId,
string startingFolder,
string filePath,
int thisFileIndex,
int allFilesCount)
{
using (var transferManager = new ArchiveTransferManager(client))
{
var runner = new ProgressRunner(this);
var uploadOptions = new UploadOptions
{
AccountId = accountId
};
var tracker = new UploadFolderProgressTracker(runner, handler => uploadOptions.StreamTransferProgress += handler, startingFolder, filePath, thisFileIndex, allFilesCount);
var output = new CmdletOutput();
runner.SafeRun(() =>
{
#if DESKTOP
var result = transferManager.Upload(vaultName, "", filePath, uploadOptions);
#else
var result = transferManager.UploadAsync(vaultName, "", filePath, uploadOptions).GetAwaiter().GetResult();
#endif
output.PipelineOutput = new FileUploadResult(filePath, result);
}, tracker, output);
ProcessOutput(output);
}
}
public void uploadoptions_with_different_chunksize()
{
var opts = new UploadOptions
{
ChunkSizeBytes = 1024
};
var data = TestBytes.Generate(1024 * 2);
var fileId = bucket.Upload(testfile, data, opts);
fileId.Should().NotBeEmpty();
var info = bucket.GetFileInfoByNameAsync(testfile, -1).WaitSync();
info.ChunkSizeBytes.Should().Be(1024);
//verify chunks
var chunks = GridUtility.EnumerateChunks(bucket, info.Id).ToList();
chunks.Count.Should().Be(2);
foreach( var chunk in chunks )
{
chunk.Data.Length.Should().Be(1024);
}
}
/// <summary>
/// Upload a local picture to azure storage.
/// 1. Upload a local picture as a block blob.
/// 2. Set its content type to "image/png".
/// </summary>
private static async Task BlobUploadSample()
{
// When transfer large file to block blob, set TransferManager.Configurations.BlockSize to specify the size of the blocks.
// It must be between 4MB and 100MB and be multiple of 4MB. Default value is 4MB.
//
// Currently, the max block count of a block blob is limited to 50000.
// When transfering a big file and the BlockSize provided is smaller than the minimum value - (size/50000),
// it'll be reset to a value which is greater than the minimum value and multiple of 4MB for this file.
TransferManager.Configurations.BlockSize = 4 * 1024 * 1024; //4MB
string sourceFileName = "azure.png";
string destinationBlobName = "azure_blockblob.png";
// Create the destination CloudBlob instance
CloudBlob destinationBlob = await Util.GetCloudBlobAsync(ContainerName, destinationBlobName, BlobType.BlockBlob);
// Use UploadOptions to set ContentType of destination CloudBlob
UploadOptions options = new UploadOptions();
SingleTransferContext context = new SingleTransferContext();
context.SetAttributesCallbackAsync = async(destination) =>
{
CloudBlob destBlob = destination as CloudBlob;
destBlob.Properties.ContentType = "image/png";
};
// Start the upload
await TransferManager.UploadAsync(sourceFileName, destinationBlob, options, context);
Console.WriteLine("File {0} is uploaded to {1} successfully.", sourceFileName, destinationBlob.Uri.ToString());
}
/// <summary>
/// sends a file to a server
/// </summary>
/// <param name="options">Upload options</param>
public void upload(string options)
{
try
{
try
{
uploadOptions = JSON.JsonHelper.Deserialize <UploadOptions>(options);
}
catch (Exception)
{
DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
return;
}
Uri serverUri;
try
{
serverUri = new Uri(uploadOptions.Server);
}
catch (Exception)
{
DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new FileTransferError(InvalidUrlError)));
return;
}
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(serverUri);
webRequest.ContentType = "multipart/form-data;boundary=" + Boundary;
webRequest.Method = "POST";
webRequest.BeginGetRequestStream(WriteCallback, webRequest);
}
catch (Exception)
{
DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new FileTransferError(ConnectionError)));
}
}
/// <summary>
/// sends a file to a server
/// </summary>
/// <param name="options">Upload options</param>
public void upload(string options)
{
try
{
try
{
uploadOptions = JSON.JsonHelper.Deserialize<UploadOptions>(options);
}
catch (Exception)
{
DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
return;
}
Uri serverUri;
try
{
serverUri = new Uri(uploadOptions.Server);
}
catch (Exception)
{
DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR,new FileTransferError(InvalidUrlError)));
return;
}
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(serverUri);
webRequest.ContentType = "multipart/form-data;boundary=" + Boundary;
webRequest.Method = "POST";
webRequest.BeginGetRequestStream(WriteCallback, webRequest);
}
catch (Exception)
{
DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new FileTransferError(ConnectionError)));
}
}
public void TestSetContentType()
{
string contentType = "contenttype";
DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty);
DMLibDataHelper.AddOneFile(sourceDataInfo.RootNode, DMLibTestBase.FileName, 1024);
var options = new TestExecutionOptions <DMLibDataInfo>();
options.TransferItemModifier = (fileNode, transferItem) =>
{
UploadOptions uploadOptions = new UploadOptions();
uploadOptions.ContentType = "contenttype";
transferItem.Options = uploadOptions;
};
var result = this.ExecuteTestCase(sourceDataInfo, options);
Test.Assert(result.Exceptions.Count == 0, "Verify no exception is thrown.");
Test.Assert(DMLibDataHelper.Equals(sourceDataInfo, result.DataInfo), "Verify transfer result.");
FileNode destFileNode = result.DataInfo.RootNode.GetFileNode(DMLibTestBase.FileName);
Test.Assert(contentType.Equals(destFileNode.ContentType), "Verify content type: {0}, expected {1}", destFileNode.ContentType, contentType);
}
public void DoUpLoad()
{
//string AK = "ACCESS_KEY";
//string SK = "SECRET_KEY";
// 目标空间名
//string bucket = "TARGET_BUCKET";
// 目标文件名
string saveKey = "stations" + TimeHelper.GetUpLoadTime() + ".txt";
// 本地文件
string localFile = Path.Combine(Application.StartupPath, "stations.txt");
// 上传策略
PutPolicy putPolicy = new PutPolicy();
// 设置要上传的目标空间
putPolicy.Scope = Bucket;
// 上传策略的过期时间(单位:秒)
putPolicy.SetExpires(3600);
// 文件上传完毕后，在多少天后自动被删除
putPolicy.DeleteAfterDays = 1;
// 请注意这里的Zone设置(如果不设置，就默认为华东机房)
// var zoneId = Qiniu.Common.AutoZone.Query(AK,BUCKET);
// Qiniu.Common.Config.ConfigZone(zoneId);
Mac mac = new Mac(AccessKey, SecretKey); // Use AK & SK here
// 生成上传凭证
string token = Auth.createUploadToken(putPolicy, mac);
UploadOptions uploadOptions = null;
// 上传完毕事件处理
UpCompletionHandler uploadCompleted = new UpCompletionHandler(OnUploadCompleted);
// 方式1：使用UploadManager
//默认设置 Qiniu.Common.Config.PUT_THRESHOLD = 512*1024;
//可以适当修改,UploadManager会根据这个阈值自动选择是否使用分片(Resumable)上传
UploadManager um = new UploadManager();
um.uploadFile(localFile, saveKey, token, uploadOptions, uploadCompleted);
}
private async Task <CreateTransferResult> UpdateFileTransferAsync(PictureparkAsset asset)
{
var transferIdentifier = $"Smint.io Update Import {Guid.NewGuid().ToString()}";
var localFile = await asset.GetDownloadedFileAsync();
var filePaths = new FileLocations[]
{
new FileLocations(localFile.FullName, asset.RecommendedFileName, asset.RecommendedFileName)
};
var request = new CreateTransferRequest
{
Name = transferIdentifier,
TransferType = TransferType.FileUpload,
Files = new TransferUploadFile[] {
new TransferUploadFile()
{
FileName = asset.RecommendedFileName
}
}
};
var uploadOptions = new UploadOptions
{
ChunkSize = 1024 * 1024,
ConcurrentUploads = 4,
SuccessDelegate = Console.WriteLine,
ErrorDelegate = ErrorDelegate,
WaitForTransferCompletion = true
};
return(await _client.Transfer.UploadFilesAsync(transferIdentifier, filePaths, uploadOptions));
}
public Task <Guid> AddFileAsync(string fileName, Stream fileStream, object metadata)
{
var uploadOptions = new UploadOptions();
uploadOptions.SetMetadata(metadata);
return(_bucket.UploadAsync(fileName, fileStream, uploadOptions));
}
public void uploadStreamTest()
{
//Settings.load();
Settings.LoadFromFile();
UploadManager target = new UploadManager();
Mac mac = new Mac(Settings.AccessKey, Settings.SecretKey);
string key = "test_UploadManagerUploadStream.png";
string filePath = "F:\\test.png";
FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
PutPolicy putPolicy = new PutPolicy();
putPolicy.Scope = Settings.Bucket;
putPolicy.SetExpires(3600);
putPolicy.DeleteAfterDays = 1;
string token = Auth.createUploadToken(putPolicy, mac);
UploadOptions uploadOptions = null;
UpCompletionHandler upCompletionHandler = new UpCompletionHandler(delegate(string fileKey, ResponseInfo respInfo, string response)
{
Assert.AreEqual(200, respInfo.StatusCode);
});
target.uploadStream(fs, key, token, uploadOptions, upCompletionHandler);
}
public void uploadStreamTest(string _key, string _filePath)
{
Mac mac = new Mac(Settings.AccessKey, Settings.SecretKey);
UploadManager target = new UploadManager();
string key = _key;
string filePath = _filePath;
FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
PutPolicy putPolicy = new PutPolicy();
putPolicy.Scope = Settings.Bucket + ":" + key;
putPolicy.SetExpires(3600);
putPolicy.DeleteAfterDays = 1;
string token = Auth.createUploadToken(putPolicy, mac);
UploadOptions uploadOptions = null;
UpCompletionHandler upCompletionHandler = new UpCompletionHandler(delegate(string fileKey, ResponseInfo respInfo, string response)
{
});
target.uploadStream(fs, key, token, uploadOptions, upCompletionHandler);
}
public void can_store_metadata_with_upload()
{
var meta = new AppMeta()
{
User = "******",
LastAccess = DateTime.Now,
Roles = new[] { "admin", "office" },
ContentType = "application/pdf"
};
var opts = new UploadOptions();
opts.SetMetadata(meta);
var id = bucket.Upload(testfile, TestBytes.HalfChunk, opts);
var fileInfo = bucket.GetFileInfo(id);
fileInfo.Metadata.Should().NotBeNull();
var otherMeta = fileInfo.Metadata.ToObject <AppMeta>(Converter.Serializer);
otherMeta.User.Should().Be(meta.User);
otherMeta.LastAccess.Should().BeCloseTo(meta.LastAccess.Value, 2000);
otherMeta.Roles.Should().Equal(meta.Roles);
otherMeta.ContentType.Should().Be(meta.ContentType);
}
private void upload(string filePath, string fileName, string qetag, string uploadToken)
{
//set button state
toggleButtonState(UploadButton, false);
toggleButtonState(HaltButton, true);
string recordKey = StringUtils.urlSafeBase64Encode(qetag + ":" + fileName);
ResumeRecorder recorder = new ResumeRecorder("record");
UploadManager uploadManager = new UploadManager(recorder, new KeyGenerator(delegate() { return(recordKey); }));
UploadOptions uploadOptions = UploadOptions.defaultOptions();
uploadOptions.ProgressHandler = new UpProgressHandler(delegate(string key, double percent)
{
updateProgress(percent);
});
uploadOptions.CancellationSignal = new UpCancellationSignal(delegate() { return(this.cancelSignal); });
UpCompletionHandler upCompletionHandler = new UpCompletionHandler(delegate(string key, ResponseInfo respInfo, string response)
{
if (respInfo.isOk())
{
appendLog("文件上传成功!");
}
else
{
appendLog("文件上传失败,原因如下:");
appendLog(respInfo.ToString());
}
toggleButtonState(UploadButton, true);
toggleButtonState(HaltButton, false);
});
appendLog("正在上传...");
uploadManager.uploadFile(filePath, fileName, uploadToken, uploadOptions, upCompletionHandler);
}
public static void uploadFile()
{
Mac mac = new Mac(Settings.AccessKey, Settings.SecretKey);
string bucket = "BUCKET";
string saveKey = "SAVE_KEY";
string localFile = "LOCAL_FILE";
PutPolicy putPolicy = new PutPolicy();
putPolicy.Scope = bucket;
putPolicy.SetExpires(3600);
putPolicy.DeleteAfterDays = 1;
string token = Auth.createUploadToken(putPolicy, mac);
UploadOptions uploadOptions = null;
// 上传完毕事件处理
UpCompletionHandler uploadCompleted = new UpCompletionHandler(OnUploadCompleted);
// 方式1：使用UploadManager
//默认设置 Qiniu.Common.Config.PUT_THRESHOLD = 512*1024;
//可以适当修改,UploadManager会根据这个阈值自动选择是否使用分片(Resumable)上传
UploadManager um = new UploadManager();
um.uploadFile(localFile, saveKey, token, uploadOptions, uploadCompleted);
// 方式2：使用FormManager
//FormUploader fm = new FormUploader();
//fm.uploadFile(localFile, saveKey, token, uploadOptions, uploadCompleted);
}
protected async Task <bool> UploadSignature()
{
UploadOptions options = new UploadOptions();
SingleTransferContext context = new SingleTransferContext();
bool transferred = false;
context.LogLevel = LogLevel.Informational;
context.ProgressHandler = new SingleFileTransferProgressReporter(SignatureFile);
context.SetAttributesCallback = (destination) =>
{
SignatureBlob = destination as CloudBlockBlob;
SignatureBlob.Properties.ContentType = "application/octet-stream";
};
context.ShouldOverwriteCallback = (source, destination) =>
{
return(true);
};
context.FileTransferred += (sender, e) =>
{
Context_FileTransferred(sender, e);
transferred = true;
};
context.FileFailed += (sender, e) =>
{
Context_FileFailed(sender, e);
transferred = false;
};
context.FileSkipped += (sender, e) =>
{
Context_FileSkipped(sender, e);
transferred = false;
};
try
{
SignatureBlob = await DestinationStorage.GetorCreateCloudBlobAsync(DestinationContainerName, DestinationBlob.Name + ".sig", BlobType.BlockBlob) as CloudBlockBlob;
if (await SignatureBlob.ExistsAsync())
{
L.Warn("The existing signature blob {blob} will be overwritten.", SignatureBlob.Name);
}
await TransferManager.UploadAsync(SignatureFile.FullName, SignatureBlob, options, context, CT);
transferred = true;
}
catch (Exception e)
{
LogTransferException(e, $"upload signature to cloud blob {SignatureBlob.Name}");
if (e is OperationCanceledException || e is TaskCanceledException || (e is TransferException && CT.IsCancellationRequested))
{
transferred = true;
}
else
{
transferred = false;
}
}
return(transferred);
}
public FloorManager(ILocationRepository locationRepository, IFloorRepository floorRepository, IFileStorageService fileStorageService, AccountManager accountManager, IOptionsMonitor <UploadOptions> uploadOptions, ILogger <FloorManager> logger)
{
_locationRepository = locationRepository;
_floorRepository = floorRepository;
_fileStorageService = fileStorageService;
_accountManager = accountManager;
_uploadOptions = uploadOptions.CurrentValue;
_logger = logger;
}
public async Task <Models.UploadStatus> UploadAsync(System.IO.Stream source, UploadOptions options)
{
var dataFormat = StravaExtensions.GetStravaDataType(options.FileName);
var stravaOptions = (StravaUploadOptions)options;
var result = await _client.Activities.Upload(options.Sport.ToStravaActivityType(), dataFormat, source, options.FileName,
stravaOptions.Name, stravaOptions.Description, stravaOptions.IsPrivate, stravaOptions.IsCommute);
return(CreateUploadStatus(result));
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
public ServiceStarter(IAgentClient agentClient,
ProjectInstance instance, UploadOptions uploadOptions,
ITransferControl transferControl, ProgressTracker progressTracker)
{
this.agentClient = agentClient ?? throw new ArgumentNullException(nameof(agentClient));
this.instance = instance ?? throw new ArgumentNullException(nameof(instance));
this.uploadOptions = uploadOptions ?? throw new ArgumentNullException(nameof(uploadOptions));
this.transferControl = transferControl ?? throw new ArgumentNullException(nameof(transferControl));
this.progressTracker = progressTracker ?? throw new ArgumentNullException(nameof(progressTracker));
ProcessTimeout = 0;
}
private static int Upload(UploadOptions options)
{
var client = CreateClient(options);
var statusMap = client.Upload(SevenZipArchive.ZipFormat, File.ReadAllBytes(options.Source));
foreach (var keyValuePair in statusMap)
{
Console.WriteLine($"Key: {keyValuePair.Key}; value: {keyValuePair.Value}");
}
return(0);
}
public GetAdminOverViewQueryHandler(
IMediator mediator,
IUnitOfWork unitOfWork,
IOptionsMonitor <UploadOptions> uploadsOpts,
ILogger <GetAdminOverViewQueryHandler> logger)
{
_logger = logger;
_mediator = mediator;
_unitOfWork = unitOfWork;
_uploadOpts = uploadsOpts.CurrentValue;
}
public GetUploadSettingQueryHandler(
IUnitOfWork unitOfWork,
IOptionsMonitor <UploadOptions> uploadOpt,
IHttpContextAccessor httpContextAccessor,
ILogger <GetUploadSettingQueryHandler> logger)
{
_logger = logger;
_unitOfWork = unitOfWork;
_uploadOpt = uploadOpt.CurrentValue;
_caller = httpContextAccessor.HttpContext.User;
}
public StartDownloadCommandHandler(
gFileManager.gFileManagerClient fileMngClient,
IHttpContextAccessor httpContextAccessor,
IOptionsMonitor <UploadOptions> uploadOpt,
ILogger <StartDownloadCommandHandler> logger)
{
_logger = logger;
_fileMngClient = fileMngClient;
_uploadOpt = uploadOpt.CurrentValue;
_httpContext = httpContextAccessor.HttpContext;
}
internal BaseUploadCommand(ArchiveTransferManager manager, string vaultName, string archiveDescription, string filePath, UploadOptions options)
{
this.manager = manager;
this.vaultName = vaultName;
this.archiveDescription = archiveDescription;
this.filePath = filePath;
this.options = options;
if (this.options == null)
this.options = new UploadOptions();
}
static async Task Run(UploadOptions uploadOptions)
{
var services = new ServiceCollection();
services.AddLogging(builder =>
{
builder.SetMinimumLevel(uploadOptions.LogLevel);
builder.AddConsole();
});
if (uploadOptions.UsePlate2Format)
{
services.AddTransient <IWorkItemGenerator, PlateFile2WorkItemGenerator>();
}
else
{
services.AddTransient <IWorkItemGenerator, PlateFileWorkItemGenerator>();
}
services.AddSingleton <AzurePlateTilePyramid>();
services.AddSingleton <Processor>();
services.AddSingleton(new AzurePlateTilePyramidOptions
{
CreateContainer = true,
SkipIfExists = uploadOptions.SkipExisting,
});
services.AddAzureClients(builder =>
{
builder.AddBlobServiceClient(uploadOptions.Storage);
if (uploadOptions.Interactive)
{
builder.UseCredential(new InteractiveBrowserCredential());
}
else
{
builder.UseCredential(new DefaultAzureCredential());
}
});
var options = new ProcessorOptions
{
BaseUrl = uploadOptions.BaseUrl,
Files = uploadOptions.File.Select(p => p.FullName)
};
using var container = services.BuildServiceProvider();
await container.GetRequiredService <Processor>().ProcessAsync(options, default);
}
internal BaseUploadCommand(ArchiveTransferManager manager, string vaultName, string archiveDescription, string filePath, UploadOptions options)
{
this.manager = manager;
this.vaultName = vaultName;
this.archiveDescription = archiveDescription;
this.filePath = filePath;
this.options = options;
if (this.options == null)
{
this.options = new UploadOptions();
}
}
public void ToQueryString_DryRunIsFalse_DoesNotAppearInQueryString()
{
// Arrange
var options = new UploadOptions {
DryRun = false
};
// Act
var queryString = options.ToQueryString();
// Assert
Assert.That(!queryString.Contains("dryrun", StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
public Uploader(ScadaProject project, ProjectInstance instance, DeploymentProfile profile,
ITransferControl transferControl)
{
this.project = project ?? throw new ArgumentNullException(nameof(project));
this.instance = instance ?? throw new ArgumentNullException(nameof(instance));
this.profile = profile ?? throw new ArgumentNullException(nameof(profile));
this.transferControl = transferControl ?? throw new ArgumentNullException(nameof(transferControl));
uploadOptions = profile.UploadOptions;
progressTracker = new ProgressTracker(transferControl)
{
TaskCount = TaskCount
};
conn = null;
}
/// <summary>
/// Sets the upload options for a given server
/// </summary>
public void SetUploadOptions(UploadOptions options, string callerAddress)
{
if (_serversConfig.TryGetValue(callerAddress, out UploadOptions opts))
{
// update entry
_serversConfig[callerAddress] = options;
}
else
{
// create new entry
_serversConfig.TryAdd(callerAddress, options);
}
_signal.Release();
}
internal SinglepartUploadCommand(ArchiveTransferManager mananger, string vaultName, string archiveDescription, string filePath, UploadOptions options)
: base(mananger, vaultName, archiveDescription, filePath, options)
{
}
public void can_store_simple_meta_with_upload()
{
var opts = new UploadOptions();
opts.SetMetadata(new
{
UserId = "123",
LastAccess = R.Now(),
Roles = R.Array("admin", "office"),
ContentType = "application/pdf"
});
var id = bucket.Upload(testfile, TestBytes.HalfChunk, opts);
var fileInfo = bucket.GetFileInfo(id);
fileInfo.Metadata["UserId"].Value<string>().Should().Be("123");
fileInfo.Dump();
}
public void can_store_metadata_with_upload()
{
var meta = new AppMeta()
{
User = "******",
LastAccess = DateTime.Now,
Roles = new[] {"admin", "office"},
ContentType = "application/pdf"
};
var opts = new UploadOptions();
opts.SetMetadata(meta);
var id = bucket.Upload(testfile, TestBytes.HalfChunk, opts);
var fileInfo = bucket.GetFileInfo(id);
fileInfo.Metadata.Should().NotBeNull();
var otherMeta = fileInfo.Metadata.ToObject<AppMeta>(Converter.Serializer);
otherMeta.User.Should().Be(meta.User);
otherMeta.LastAccess.Should().BeCloseTo(meta.LastAccess.Value, 2000);
otherMeta.Roles.Should().Equal(meta.Roles);
otherMeta.ContentType.Should().Be(meta.ContentType);
}
