internal UploadManager(IUploaderFactory uploaderFactory, UploadOperation uploadOperation)
{
var uploader = uploaderFactory.GetUploader(uploadOperation);
//run different set of async tasks based on OperationType,
//using nested class Uploader
uploader.DoStuff();
}
/// <summary>
/// Upload a file to the server.
/// </summary>
/// <param name="path">relative or absolute uri to the location where the file should be uploaded to.</param>
/// <param name="fileName">name for the uploaded file.</param>
/// <param name="inputStream">Stream that contains the file content.</param>
/// <param name="option">
/// a enum to specify the overwrite behavior if a file with the same name already exists.
/// Default is DoNotOverwrite.
/// </param>
/// <param name="ct">a cancellation token</param>
/// <param name="progress">a progress event callback handler</param>
public Task <LiveOperationResult> UploadAsync(
string path,
string fileName,
Stream inputStream,
OverwriteOption option,
CancellationToken ct,
IProgress <LiveOperationProgress> progress)
{
LiveUtility.ValidateNotNullOrWhiteSpaceString(path, "path");
LiveUtility.ValidateNotNullParameter(inputStream, "inputStream");
if (string.IsNullOrEmpty(fileName))
{
string message = String.Format(CultureInfo.CurrentUICulture,
ResourceHelper.GetString("InvalidNullOrEmptyParameter"),
"fileName");
throw new ArgumentException(message, "fileName");
}
if (!inputStream.CanRead)
{
string message = String.Format(CultureInfo.CurrentUICulture,
ResourceHelper.GetString("StreamNotReadable"),
"inputStream");
throw new ArgumentException(message, "inputStream");
}
var tcs = new TaskCompletionSource <LiveOperationResult>();
var op = new UploadOperation(
this,
this.GetResourceUri(path, ApiMethod.Upload),
fileName,
inputStream,
option,
progress,
null);
op.OperationCompletedCallback = (LiveOperationResult result) =>
{
if (result.IsCancelled)
{
tcs.TrySetCanceled();
}
else if (result.Error != null)
{
tcs.TrySetException(result.Error);
}
else
{
tcs.TrySetResult(result);
}
};
ct.Register(op.Cancel);
op.Execute();
return(tcs.Task);
}
private async void StartMultipartUpload_Click(object sender, RoutedEventArgs e)
{
// By default 'serverAddressField' is disabled and URI validation is not required. When enabling the text
// box validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling Uri.TryCreate() that will return 'false' for strings that are not valid URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet that require
// the "Home or Work Networking" capability.
Uri uri;
if (!Uri.TryCreate(serverAddressField.Text.Trim(), UriKind.Absolute, out uri))
{
rootPage.NotifyUser("Invalid URI.", NotifyType.ErrorMessage);
return;
}
// Verify that we are currently not snapped, or that we can unsnap to open the picker.
if (ApplicationView.Value == ApplicationViewState.Snapped && !ApplicationView.TryUnsnap())
{
rootPage.NotifyUser("File picker cannot be opened in snapped mode. Please unsnap first.", NotifyType.ErrorMessage);
return;
}
FileOpenPicker picker = new FileOpenPicker();
picker.FileTypeFilter.Add("*");
IReadOnlyList <StorageFile> files = await picker.PickMultipleFilesAsync();
if (files.Count == 0)
{
rootPage.NotifyUser("No file selected.", NotifyType.ErrorMessage);
return;
}
List <BackgroundTransferContentPart> parts = new List <BackgroundTransferContentPart>();
for (int i = 0; i < files.Count; i++)
{
BackgroundTransferContentPart part = new BackgroundTransferContentPart("File" + i, files[i].Name);
part.SetFile(files[i]);
parts.Add(part);
}
BackgroundUploader uploader = new BackgroundUploader();
UploadOperation upload = await uploader.CreateUploadAsync(uri, parts);
String fileNames = files[0].Name;
for (int i = 1; i < files.Count; i++)
{
fileNames += ", " + files[i].Name;
}
Log(String.Format("Uploading {0} to {1}, {2}", fileNames, uri.AbsoluteUri, upload.Guid));
// Attach progress and completion handlers.
await HandleUploadAsync(upload, true);
}
public void AddUploadOperation(UploadOperation uploadOperation)
{
var entry = new BucketEntryViewModel(this, _bucketService, _objectService);
entry.IsUploadOperation = true;
entry.UploadOperation = uploadOperation;
entry.InitUploadOperation();
Entries.Add(entry);
}
public static HttpTransfer FromNative(this UploadOperation x) => new HttpTransfer(
x.Guid.ToString(),
x.RequestedUri.ToString(),
x.SourceFile.Path,
true,
x.CostPolicy == BackgroundTransferCostPolicy.Always,
null,
(long)x.Progress.TotalBytesToSend,
(long)x.Progress.BytesSent,
x.Progress.Status.FromNative()
);
private async Task OnUploadProgressChanged(UploadOperation obj)
{
if (Windows.ApplicationModel.Core.CoreApplication.Views.Count > 0)
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ExecutionContext.Instance.BackgroundTransferOperation = obj;
ExecutionContext.Instance.Status = ExecutionStatus.Sending;
});
}
}
private void OnUploadProgressChanged(UploadOperation e, ICompletedUpload upload)
{
ProgressChanged?.Invoke(this, new TransferItem
{
OperationGuid = e.Guid,
Name = upload.Name,
ContentType = upload.ContentType,
Status = e.Progress.Status,
TotalSize = FileSize.FromBytes(e.Progress.TotalBytesToSend),
ProcessedSize = FileSize.FromBytes(e.Progress.BytesSent)
});
}
public void NapackUploadOperationFailsWhenUserNotRegistered()
{
UploadOperation uploadOperation = new UploadOperation()
{
Operation = "Upload",
ForceMajorUpversioning = false,
ForceMinorUpversioning = false,
PackageFile = NapackOperationTests.PackageJsonFileLocation,
NapackSettingsFile = NapackOperationTests.SettingsFileLocation
};
uploadOperation.PerformOperation();
}
/// <summary>
/// Upload a file to the server.
/// </summary>
/// <param name="path">relative or absolute uri to the location where the file should be uploaded to.</param>
/// <param name="fileName">name for the uploaded file.</param>
/// <param name="inputStream">Stream that contains the file content.</param>
/// <param name="option">an enum to specify the overwrite behavior if a file with the same name already exists.</param>
/// <param name="ct">a token that is used to cancel the upload operation.</param>
/// <param name="progress">an object that is called to report the upload's progress.</param>
/// <returns>A Task object representing the asynchronous operation.</returns>
public Task <LiveOperationResult> UploadAsync(
string path,
string fileName,
Stream inputStream,
OverwriteOption option,
CancellationToken ct,
IProgress <LiveOperationProgress> progress)
{
if (string.IsNullOrEmpty(path))
{
string message = String.Format(CultureInfo.CurrentUICulture,
ResourceHelper.GetString("UrlInvalid"),
"path");
throw new ArgumentException(message, "path");
}
if (string.IsNullOrEmpty(fileName))
{
string message = String.Format(CultureInfo.CurrentUICulture,
ResourceHelper.GetString("InvalidNullOrEmptyParameter"),
"fileName");
throw new ArgumentException(message, "fileName");
}
if (inputStream == null)
{
string message = String.Format(CultureInfo.CurrentUICulture,
ResourceHelper.GetString("InvalidNullParameter"),
"inputStream");
throw new ArgumentNullException("inputStream", message);
}
if (!inputStream.CanRead)
{
string message = String.Format(CultureInfo.CurrentUICulture,
ResourceHelper.GetString("StreamNotReadable"),
"inputStream");
throw new ArgumentException(message, "inputStream");
}
var operation = new UploadOperation(
this,
this.GetResourceUri(path, ApiMethod.Upload),
fileName,
inputStream,
option,
progress != null ? new Action <LiveOperationProgress>(progress.Report) : null,
SynchronizationContextWrapper.Current);
return(this.ExecuteApiOperation(operation, ct));
}
public async Task <UploadOperation> UploadObjectAsync(Bucket bucket, string targetPath, UploadOptions uploadOptions, byte[] bytesToUpload, CustomMetadata customMetadata, bool immediateStart = true)
{
var uploadOptionsSWIG = uploadOptions.ToSWIG();
SWIG.UploadResult uploadResult = await Task.Run(() => SWIG.storj_uplink.upload_object(_access._project, bucket.Name, targetPath, uploadOptionsSWIG));
UploadOperation upload = new UploadOperation(bytesToUpload, uploadResult, targetPath, customMetadata);
if (immediateStart)
{
upload.StartUploadAsync(); //Don't await it, otherwise it would "block" UploadObjectAsync
}
return(upload);
}
public async Task <string> CreateVideoAsync(IStorageFile file, Video v)
{
VideoSubmition videoSubmition = new VideoSubmition
{
Tags = v.Tags,
Title = v.Title,
Synopse = v.Synopse
};
Video createdVideo = null;
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.AccessKey, _client.InnerChannel))
{
createdVideo = await this._client.AddVideoPostAsync(videoSubmition, null);
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
string token = createdVideo.Token;
BackgroundUploader uploader = new BackgroundUploader();
UploadOperation uploadOperation =
await VideosServiceClient.CreateUploadOperationForCreateVideo(file, token, uploader);
await uploadOperation.StartAsync();
return(await GetResponseMessage(uploadOperation));
}
private async void UploadMultipleFiles(Uri uri, IReadOnlyList <StorageFile> files)
{
if (files.Count == 0)
{
rootPage.NotifyUser("No file selected.", NotifyType.ErrorMessage);
return;
}
ulong totalFileSize = 0;
for (int i = 0; i < files.Count; i++)
{
BasicProperties properties = await files[i].GetBasicPropertiesAsync();
totalFileSize += properties.Size;
if (totalFileSize > maxUploadFileSize)
{
rootPage.NotifyUser(String.Format(CultureInfo.CurrentCulture,
"Size of selected files exceeds max. upload file size ({0} MB).",
maxUploadFileSize / (1024 * 1024)), NotifyType.ErrorMessage);
return;
}
}
List <BackgroundTransferContentPart> parts = new List <BackgroundTransferContentPart>();
for (int i = 0; i < files.Count; i++)
{
BackgroundTransferContentPart part = new BackgroundTransferContentPart("File" + i, files[i].Name);
part.SetFile(files[i]);
parts.Add(part);
}
BackgroundUploader uploader = new BackgroundUploader();
UploadOperation upload = await uploader.CreateUploadAsync(uri, parts);
String fileNames = files[0].Name;
for (int i = 1; i < files.Count; i++)
{
fileNames += ", " + files[i].Name;
}
Log(String.Format(CultureInfo.CurrentCulture, "Uploading {0} to {1}, {2}", fileNames, uri.AbsoluteUri,
upload.Guid));
// Attach progress and completion handlers.
await HandleUploadAsync(upload, true);
}
/// <summary>
/// Invoked when image add button is clicked and choose the image.
/// </summary>
/// <param name="sender">The image add button clicked.</param>
/// <param name="e">Event data that describes how the click was initiated.</param>
private async void ImageUploadButton_Click(object sender, RoutedEventArgs e)
{
FileOpenPicker picker = FileTypePicker(imagesFilterTypeList);
if (picker == null)
{
return;
}
images = await picker.PickMultipleFilesAsync();
if (images == null || images.Count == 0)
{
return;
}
Image imgImg = new Image
{
Source = new BitmapImage(new Uri("ms-appx:///Images/Upload/image.png")),
Margin = new Thickness(5, 0, 5, 0)
};
ToolTip toolTip = new ToolTip();
toolTip.Content = images[0].Name;
ToolTipService.SetToolTip(imgImg, toolTip);
totalImagePanel.Children.RemoveAt(totalImagePanel.Children.Count - 1);
imagePanel.Children.Add(imgImg);
List <BackgroundTransferContentPart> imageParts = CreateBackgroundTransferContentPartList(images);
Uri uploadUri = new Uri(Constants.DataCenterURI + "Upload.aspx?username="******"Image uplaod error3. Please check your network.");
}
}
public async Task UploadAsync(StorageFile file, int travelerId, Progress <UploadOperation> progressCallback, int reservationId, bool isPrivate)
{
var address = isPrivate ? Addresses.UploadPrivateFileUri : Addresses.UploadPublicFileUri;
Uri destination = new Uri(string.Format(address, reservationId));
BackgroundUploader uploader = new BackgroundUploader();
uploader.SetRequestHeader("Filename", file.Name);
UploadOperation upload = uploader.CreateUpload(destination, file);
UploadOperation result = await upload.StartAsync().AsTask();
string fileUri = result.GetResponseInformation().Headers["Location"];
await _data.CreateAzureStorageFileMetadata(fileUri, file.Name, reservationId, isPrivate, UserAuth.Instance.Traveler.TravelerId);
}
public async Task UploadAsync(StorageFile sourceFile, int travelerId, int reservationId, bool isPrivate, int locationId)
{
var address = isPrivate ? Addresses.UploadPrivateFileUri : Addresses.UploadPublicFileUri;
Uri destinationUri = new Uri(string.Format(address, reservationId));
BackgroundUploader uploader = new BackgroundUploader();
uploader.SetRequestHeader("Filename", sourceFile.Name);
UploadOperation upload = uploader.CreateUpload(destinationUri, sourceFile);
await upload.StartAsync();
var fileAddress = upload.GetResponseInformation().Headers["Location"];
await _data.CreateAzureStorageFileMetadata(new Uri(fileAddress), sourceFile.Name, reservationId, isPrivate, travelerId, locationId);
}
/// <summary>
/// This is the upload handler.
/// </summary>
/// <param name="upload"></param>
/// <param name="start"></param>
private static async void HandleUploadAsync(UploadOperation upload, bool start)
{
try
{
Progress <UploadOperation> progressCallback = new Progress <UploadOperation>(UploadProgress);
if (start)
{
await upload.StartAsync().AsTask(cancellationToken.Token, progressCallback);
}
ResponseInformation response = upload.GetResponseInformation();
}
catch (Exception ex)
{
}
}
private const int maxUploadFileSize = 100 * 1024 * 1024; // 100 MB
/// <summary>
/// StartUploadFiles
/// </summary>
/// <param name="url"></param>
/// <param name="files"></param>
public async void StartUploadFiles(string url, IReadOnlyList <StorageFile> files)
{
Uri uri = null;
if (!Uri.TryCreate(url, UriKind.Absolute, out uri))
{
if (this.ErrorException != null)
{
this.ErrorException(this, "Please Invalid UploadURl");
}
return;
}
if (files == null || files.Count == 0)
{
if (this.ErrorException != null)
{
this.ErrorException(this, "Please Invalid files");
}
return;
}
ulong totalFileSize = 0;
for (int i = 0; i < files.Count; i++)
{
BasicProperties properties = await files[i].GetBasicPropertiesAsync();
totalFileSize += properties.Size;
if (totalFileSize > maxUploadFileSize)
{
if (this.ErrorException != null)
{
this.ErrorException(this, "Please Invalid maxUploadFileSize");
}
return;
}
}
List <BackgroundTransferContentPart> parts = new List <BackgroundTransferContentPart>();
for (int i = 0; i < files.Count; i++)
{
BackgroundTransferContentPart part = new BackgroundTransferContentPart("File" + i, files[i].Name);
part.SetFile(files[i]);
parts.Add(part);
}
BackgroundUploader uploader = new BackgroundUploader();
UploadOperation upload = await uploader.CreateUploadAsync(uri, parts);
await HandleUploadAsync(upload, true);
}
private async void StartUpload_Click(object sender, RoutedEventArgs e)
{
// By default 'serverAddressField' is disabled and URI validation is not required. When enabling the text
// box validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling Uri.TryCreate() that will return 'false' for strings that are not valid URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet that require
// the "Home or Work Networking" capability.
Uri uri;
if (!Uri.TryCreate(serverAddressField.Text.Trim(), UriKind.Absolute, out uri))
{
rootPage.NotifyUser("Invalid URI.", NotifyType.ErrorMessage);
return;
}
FileOpenPicker picker = new FileOpenPicker();
picker.FileTypeFilter.Add("*");
StorageFile file = await picker.PickSingleFileAsync();
if (file == null)
{
rootPage.NotifyUser("No file selected.", NotifyType.ErrorMessage);
return;
}
BasicProperties properties = await file.GetBasicPropertiesAsync();
if (properties.Size > maxUploadFileSize)
{
rootPage.NotifyUser(String.Format(CultureInfo.CurrentCulture,
"Selected file exceeds max. upload file size ({0} MB).", maxUploadFileSize / (1024 * 1024)),
NotifyType.ErrorMessage);
return;
}
BackgroundUploader uploader = new BackgroundUploader();
uploader.SetRequestHeader("Filename", file.Name);
UploadOperation upload = uploader.CreateUpload(uri, file);
Log(String.Format(CultureInfo.CurrentCulture, "Uploading {0} to {1}, {2}", file.Name, uri.AbsoluteUri,
upload.Guid));
// Attach progress and completion handlers.
await HandleUploadAsync(upload, true);
}
public async Task <UploadOperation> UploadObjectAsync(Bucket bucket, string targetPath, UploadOptions uploadOptions, Stream stream, CustomMetadata customMetadata, bool immediateStart)
{
var uploadOptionsSWIG = uploadOptions.ToSWIG();
_uploadOptions.Add(uploadOptionsSWIG);
using (SWIG.UplinkUploadResult uploadResult = await Task.Run(() => SWIG.storj_uplink.uplink_upload_object(_access._project, bucket.Name, targetPath, uploadOptionsSWIG)).ConfigureAwait(false))
{
UploadOperation upload = new UploadOperation(stream, uploadResult, targetPath, customMetadata);
if (immediateStart)
{
upload.StartUploadAsync(); //Don't await it, otherwise it would "block" UploadObjectAsync
}
return(upload);
}
}
async void UploadProgress(UploadOperation upload)
{
LogStatus(string.Format("Progress: {0}, Status: {1}", upload.Guid, upload.Progress.Status));
BackgroundUploadProgress progress = upload.Progress;
double percentSent = 100;
if (progress.TotalBytesToSend > 0)
{
var bs = progress.BytesSent;
percentSent = bs * 100 / progress.TotalBytesToSend;
}
SendNotify(percentSent);
//MarshalLog(String.Format(" - Sent bytes: {0} of {1} ({2}%)",
// progress.BytesSent, progress.TotalBytesToSend, percentSent));
LogStatus(string.Format(" - Sent bytes: {0} of {1} ({2}%), Received bytes: {3} of {4}",
progress.BytesSent, progress.TotalBytesToSend, percentSent,
progress.BytesReceived, progress.TotalBytesToReceive));
if (progress.HasRestarted)
{
LogStatus(" - Upload restarted");
}
if (progress.HasResponseChanged)
{
var resp = upload.GetResponseInformation();
// We've received new response headers from the server.
LogStatus(" - Response updated; Header count: " + resp.Headers.Count);
var response = upload.GetResultStreamAt(0);
StreamReader stream = new StreamReader(response.AsStreamForRead());
Debug.WriteLine("----------------------------------------Response from upload----------------------------------");
var st = stream.ReadToEnd();
Debug.WriteLine(st);
//var res = JsonConvert.DeserializeObject<APIResponseOverride>(st);
//await ConfigureMediaPhotoAsync(res.upload_id, Caption, null, null);
await FinishVoiceAsync();
//UploadCompleted?.Invoke(null, Convert.ToInt64(res.upload_id));
// If you want to stream the response data this is a good time to start.
// upload.GetResultStreamAt(0);
}
}
/// <summary>
/// 处理并监视指定的后台上传任务
/// </summary>
/// <param name="upload">后台上传任务</param>
/// <param name="isNew">是否是新增的任务</param>
private async Task HandleUploadAsync(UploadOperation upload, bool isNew)
{
try
{
// 将 UploadOperation 附加到 TransferModel，以便上传进度可通知
TransferModel transfer = new TransferModel();
transfer.UploadOperation = upload;
transfer.Source = "多个文件";
transfer.Destination = upload.RequestedUri.ToString();
transfer.Progress = upload.Progress.Status.ToString() + "0 / 0";
_transfers.Add(transfer);
WriteLine("Task Count: " + _transfers.Count.ToString());
// 当上传进度发生变化时的回调函数
Progress <UploadOperation> progressCallback = new Progress <UploadOperation>(UploadProgress);
if (isNew)
{
await upload.StartAsync().AsTask(_cancelToken.Token, progressCallback); // 启动一个后台上传任务
}
else
{
await upload.AttachAsync().AsTask(_cancelToken.Token, progressCallback); // 监视已存在的后台上传任务
}
// 上传完成后获取服务端的响应信息
ResponseInformation response = upload.GetResponseInformation();
WriteLine("Completed: " + response.ActualUri + ", HttpStatusCode: " + response.StatusCode.ToString());
}
catch (TaskCanceledException) // 调用 CancellationTokenSource.Cancel() 后会抛出此异常
{
WriteLine("Canceled: " + upload.Guid);
}
catch (Exception ex)
{
// 将异常转换为 WebErrorStatus 枚举，如果获取到的是 WebErrorStatus.Unknown 则说明此次异常不是涉及 web 的异常
WebErrorStatus error = BackgroundTransferError.GetStatus(ex.HResult);
WriteLine(ex.ToString());
}
finally
{
_transfers.Remove(_transfers.First(p => p.UploadOperation == upload));
}
}
/// <summary>
/// Start uplaod and create handler.
/// </summary>
/// <param name="upload">UploadOperation handled.</param>
/// <param name="start">Whether uplaod is started.</param>
/// <returns>
/// Represent the asynchronous operation.
/// </returns>
private async Task HandleUploadAsync(UploadOperation upload, bool start)
{
try
{
try
{
Progress <UploadOperation> progressCallback = new Progress <UploadOperation>(UploadProgress);
if (start)
{
// Start the upload and attach a progress handler.
await upload.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The upload was already running when the application started, re-attach the progress handler.
await upload.AttachAsync().AsTask(cts.Token, progressCallback);
}
}
catch
{
ShowMessageDialog("Error90! Upload canceled.");
}
ResponseInformation response = upload.GetResponseInformation();
foreach (var c in response.Headers)
{
System.Diagnostics.Debug.WriteLine("{0}, {1}. markkkkkkkk", c.Key, c.Value);
}
if (images != null && images.Count != 0 && hasImage == false)
{
toBeUploadCourse.ImageUri = response.Headers[images.FirstOrDefault().Name];
hasImage = true;
}
SaveUploadLessonToListAsync(response);
}
catch (TaskCanceledException)
{
ShowMessageDialog("Error9! Upload canceled.");
}
catch
{
ShowMessageDialog("Error10! Upload canceled.");
//throw;
}
}
private async void FinishUpload(UploadOperation operation, ICompletedUpload upload)
{
if (operation.Progress.Status == BackgroundTransferStatus.Completed)
{
try
{
string serverResponse = await(new StreamReader(
operation.GetResultStreamAt(0).AsStreamForRead())).ReadToEndAsync();
var newUpload = new CompletedUpload
{
Id = upload.Id,
Name = upload.Name,
ContentType = upload.ContentType,
ServerResponse = serverResponse
};
await _database.InsertOrReplaceAsync(newUpload);
var result = await _uploadsPostprocessor.ProcessUploadAsync(newUpload);
if (result != UploadsPostprocessorResultType.ConnectionError)
{
await _database.RemoveAsync(operation.Guid);
}
}
catch (Exception ex)
{
_logService.LogException(ex);
}
}
else
{
await _database.RemoveAsync(operation.Guid);
}
OnUploadProgressChanged(operation, upload);
_cts.Remove(operation.Guid);
_uploads.Remove(operation);
if (_uploads.Count == 0)
{
UploadsCompleted?.Invoke(this, EventArgs.Empty);
}
}
private async Task HandleUploadAsync(UploadOperation upload, bool start)
{
var progressCallback = new Progress <UploadOperation>(UploadProgress);
if (start)
{
// Start the upload and attach a progress handler.
await upload.StartAsync().AsTask(_cts.Token, progressCallback);
}
else
{
// The upload was already running when the application started, re-attach the progress handler.
await upload.AttachAsync().AsTask(_cts.Token, progressCallback);
}
var response = upload.GetResponseInformation();
}
private async void UploadOperation_UploadOperationEnded(UploadOperation uploadOperation)
{
UploadOperation.UploadOperationProgressChanged -= UploadOperation_UploadOperationProgressChanged;
UploadOperation.UploadOperationEnded -= UploadOperation_UploadOperationEnded;
if (uploadOperation.Completed)
{
BucketContentViewModel.ActiveUploadOperations[_bucketContentViewModel.BucketName].Remove(uploadOperation);
await _bucketContentViewModel.RefreshAsync();
}
else
{
RaiseChanged(nameof(UploadOperation));
RaiseChanged(nameof(UploadPercentage));
RaiseChanged(nameof(UploadFailed));
RaiseChanged(nameof(UploadRunning));
}
}
/// <summary>
/// This is the progress changed event which will return progress.
/// </summary>
/// <param name="upload"></param>
private static void UploadProgress(UploadOperation upload)
{
BackgroundUploadProgress progress = upload.Progress;
double percentSent = 100;
if (progress.TotalBytesToSend > 0)
{
percentSent = progress.BytesSent * 100 / progress.TotalBytesToSend;
if (OnUploadProgressChanged != null)
{
OnUploadProgressChanged(percentSent, (double)progress.BytesSent, (double)progress.TotalBytesToSend);
}
}
//pbProgress.Value = percentSent;
//tblockPercentageDownloaded.Text = percentSent + "%";
}
public UploadHttpTask(TaskConfiguration config, UploadOperation operation, bool restart) : base(config, true)
{
this.operation = operation;
this.Identifier = operation.Guid.ToString();
this.LocalFilePath = operation.SourceFile.ToString();
var task = restart ? this.operation.AttachAsync() : this.operation.StartAsync();
task.AsTask(
CancellationToken.None,
new Progress <UploadOperation>(x => this.SetData(
x.Progress.Status,
x.Progress.BytesSent,
x.Progress.TotalBytesToSend,
x.Progress.HasRestarted
)
));
}
private async void StartUpload_Click(object sender, RoutedEventArgs e)
{
// By default 'serverAddressField' is disabled and URI validation is not required. When enabling the text
// box validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling Uri.TryCreate() that will return 'false' for strings that are not valid URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet that require
// the "Home or Work Networking" capability.
Uri uri;
if (!Uri.TryCreate(serverAddressField.Text.Trim(), UriKind.Absolute, out uri))
{
rootPage.NotifyUser("Invalid URI.", NotifyType.ErrorMessage);
return;
}
// Verify that we are currently not snapped, or that we can unsnap to open the picker.
if (ApplicationView.Value == ApplicationViewState.Snapped && !ApplicationView.TryUnsnap())
{
rootPage.NotifyUser("File picker cannot be opened in snapped mode. Please unsnap first.", NotifyType.ErrorMessage);
return;
}
FileOpenPicker picker = new FileOpenPicker();
picker.FileTypeFilter.Add("*");
StorageFile file = await picker.PickSingleFileAsync();
if (file == null)
{
rootPage.NotifyUser("No file selected.", NotifyType.ErrorMessage);
return;
}
BackgroundUploader uploader = new BackgroundUploader();
uploader.SetRequestHeader("Filename", file.Name);
UploadOperation upload = uploader.CreateUpload(uri, file);
Log(String.Format("Uploading {0} to {1}, {2}", file.Name, uri.AbsoluteUri, upload.Guid));
// Attach progress and completion handlers.
await HandleUploadAsync(upload, true);
}
// Note that this event is invoked on a background thread, so we cannot access the UI directly.
private void UploadProgress(UploadOperation upload)
{
var progress = upload.Progress;
double percentSent = 100;
if (progress.TotalBytesToSend > 0)
{
percentSent = progress.BytesSent * 100 / progress.TotalBytesToSend;
}
_currentProgressBar.Value = percentSent;
if (progress.HasResponseChanged)
{
// If you want to stream the response data this is a good time to start.
// upload.GetResultStreamAt(0);
}
}
async Task <ResponseInfo> GetUploadResponse(UploadOperation operation)
{
await Task.Delay(1000);
ResponseInfo ret = new ResponseInfo();
await operation.StartAsync();
IInputStream stream = operation.GetResultStreamAt(0);
StreamReader sr = new StreamReader(stream.AsStreamForRead());
ret.Response = await sr.ReadToEndAsync();
var info = operation.GetResponseInformation();
ret.StatusCode = info.StatusCode;
ret.Headers = info.Headers;
ret.RequestUri = info.ActualUri;
return(ret);
}
static void Main(string[] args)
{
string login = string.Empty;
string pass = string.Empty;
string host = string.Empty;
var correctParameters = args.Length == 1;
if (correctParameters)
{
try
{
var connectString = args[0];
var passDelimiter = connectString.IndexOf(":");
var hostDelimiter = connectString.IndexOf("@");
login = connectString.Substring(0, passDelimiter);
pass = connectString.Substring(passDelimiter + 1, hostDelimiter - passDelimiter - 1);
host = connectString.Substring(hostDelimiter + 1, connectString.Length - hostDelimiter - 1);
correctParameters = !string.IsNullOrWhiteSpace(login) && !string.IsNullOrWhiteSpace(pass) && !string.IsNullOrWhiteSpace(host);
}
catch
{
correctParameters = false;
}
}
if (!correctParameters)
{
Console.WriteLine("Incorrect parameter. Usage: ftpClient <login>:<password>@<host>");
return;
}
Console.WriteLine($"Connecting to: {host} using LOGIN: {login} & PASSWORD: {pass}");
var mode = TransferMode.Active;
var controlChannel = new ControlChannel();
if (!controlChannel.Init(host, login, pass))
{
return;
}
OperationBase currentOperation = null;
string cmd = null;
do
{
Console.Write("ftpClient> ");
var cmdLine = Console.ReadLine();
var cmdParams = cmdLine.Split(' ');
cmd = cmdParams.Length > 0 ? cmdParams[0].ToLower() : string.Empty;
currentOperation = null;
switch (cmd)
{
case "ls":
case "dir":
{
currentOperation = new DirectoryListingOperation(cmdParams.Length > 1 ? cmdParams[1] : null);
break;
}
case "recv":
case "get":
{
if (cmdParams.Length < 2 || cmdParams.Length > 3)
{
Console.WriteLine($"Incorrect command usage! Type: {cmdParams[0].ToUpper()} remote_file_name [local_file_name]");
continue;
}
currentOperation =
new DownloadOperation(
new DirectoryInfo(Environment.CurrentDirectory),
cmdParams[1],
cmdParams.Length > 2 ? cmdParams[2] : null);
break;
}
case "send":
case "put":
{
if (cmdParams.Length < 2 || cmdParams.Length > 3)
{
Console.WriteLine($"Incorrect command usage! Type: {cmdParams[0].ToUpper()} local_file_name [remote_file_name]");
continue;
}
currentOperation =
new UploadOperation(
new DirectoryInfo(Environment.CurrentDirectory),
cmdParams[1],
cmdParams.Length > 2 ? cmdParams[2] : null);
break;
}
case "delete":
{
if (cmdParams.Length != 2)
{
Console.WriteLine($"Incorrect command usage! Type: DELETE remote_file_name");
continue;
}
string response;
controlChannel.SendCommand($"DELE {cmdParams[1]}", out response);
break;
}
case "mode":
{
if (cmdParams.Length != 2 || (cmdParams[1].ToLower() != "a" && cmdParams[1].ToLower() != "p"))
{
Console.WriteLine("Incorrect command usage! Type: MODE [a|p]");
continue;
}
mode = cmdParams[1].ToLower() == "a" ? TransferMode.Active : TransferMode.Passive;
Console.WriteLine($"{mode.ToString().ToUpper()} data transfer mode set.");
break;
}
case "mkdir":
{
if (cmdParams.Length != 2)
{
Console.WriteLine("Incorrect command usage! Type: MKDIR directory_name");
continue;
}
string response;
controlChannel.SendCommand($"MKD {cmdParams[1]}", out response);
break;
}
case "rmdir":
{
if (cmdParams.Length != 2)
{
Console.WriteLine("Incorrect command usage! Type: RMDIR directory_name");
continue;
}
string response;
controlChannel.SendCommand($"RMD {cmdParams[1]}", out response);
break;
}
case "cd":
{
if (cmdParams.Length != 2)
{
Console.WriteLine("Incorrect command usage! Type: CD directory_name");
continue;
}
string response;
controlChannel.SendCommand($"CWD {cmdParams[1]}", out response);
break;
}
case "cdup":
{
string response;
controlChannel.SendCommand($"CDUP", out response);
break;
}
case "site":
{
if (cmdParams.Length > 2)
{
Console.WriteLine($"Incorrect command usage! Type: SITE [site_specific_command]");
continue;
}
string response;
controlChannel.SendCommand($"SITE {(cmdParams.Length > 1 ? cmdParams[1] : string.Empty)}", out response);
currentOperation = null;
break;
}
case "quit":
{
string response;
controlChannel.SendCommand("QUIT", out response);
currentOperation = null;
break;
}
case "help":
{
Console.WriteLine("List of supported commands:");
Console.WriteLine("DIR(LS) [directory_name] - list content of the specified directory.");
Console.WriteLine("RECV(GET) <server_file_name> [local_file_name] - download file from the server.");
Console.WriteLine("SEND(PUT) <local_file_name> [server_file_name] - upload file to the server.");
Console.WriteLine("DELETE <server_file_name> - delete file on the server.");
Console.WriteLine("MODE <a|p> - set active or passive mode for the data channel.");
Console.WriteLine("MKDIR <directory_name> - create directory on the server.");
Console.WriteLine("RMDIR <directory_name> - remove directory on the server.");
Console.WriteLine("CD <directory_name> - change current server directory.");
Console.WriteLine("CDUP - change current server directory one level up.");
Console.WriteLine("SITE [custom_parameter] - site specific command.");
Console.WriteLine("QUIT - close ftpClient");
break;
}
default:
{
Console.WriteLine("Unknown command! Type HELP for the list of supported commands.");
break;
}
}
if (currentOperation != null && currentOperation.Init(controlChannel, mode))
{
try
{
currentOperation.Process(controlChannel).Wait();
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
currentOperation.Finish();
}
}
} while (cmd != "quit" && controlChannel.IsConnected);
controlChannel.Close();
}
