public bool Commit()
{
if (_customMetadata != null)
{
if (UploadOperation.customMetadataMutex.WaitOne(1000))
{
try
{
_customMetadata.ToSWIG(); //Appends the customMetadata in the go-layer to a global field
using (SWIG.UplinkError customMetadataError = SWIG.storj_uplink.upload_set_custom_metadata2(_upload))
{
if (customMetadataError != null && !string.IsNullOrEmpty(customMetadataError.message))
{
_errorMessage = customMetadataError.message;
return(false);
}
}
}
finally
{
UploadOperation.customMetadataMutex.ReleaseMutex();
}
}
}
using (SWIG.UplinkError commitError = SWIG.storj_uplink.uplink_upload_commit(_upload))
{
if (commitError != null && !string.IsNullOrEmpty(commitError.message))
{
_errorMessage = commitError.message;
return(false);
}
}
return(true);
}
public async Task <UploadsList> ListUploadsAsync(string bucketName, ListUploadOptions listUploadOptions)
{
var listUploadsOptionsSWIG = listUploadOptions.ToSWIG();
_listUploadsOptions.Add(listUploadsOptionsSWIG);
using (SWIG.UplinkUploadIterator uploadIterator = await Task.Run(() => SWIG.storj_uplink.uplink_list_uploads(_access._project, bucketName, listUploadsOptionsSWIG)).ConfigureAwait(false))
{
using (SWIG.UplinkError error = SWIG.storj_uplink.uplink_upload_iterator_err(uploadIterator))
{
if (error != null && !string.IsNullOrEmpty(error.message))
{
throw new UploadsListException(error.message);
}
}
UploadsList uploadsList = new UploadsList();
while (SWIG.storj_uplink.uplink_upload_iterator_next(uploadIterator))
{
using (var uploadInfo = SWIG.storj_uplink.uplink_upload_iterator_item(uploadIterator))
{
uploadsList.Items.Add(uplink.NET.Models.UploadInfo.FromSWIG(uploadInfo));
}
}
return(uploadsList);
}
}
public async Task <BucketList> ListBucketsAsync(ListBucketsOptions listBucketsOptions)
{
var listBucketsOptionsSWIG = listBucketsOptions.ToSWIG();
_listOptions.Add(listBucketsOptionsSWIG);
using (SWIG.UplinkBucketIterator bucketIterator = await Task.Run(() => SWIG.storj_uplink.uplink_list_buckets(_access._project, listBucketsOptionsSWIG)).ConfigureAwait(false))
{
using (SWIG.UplinkError error = SWIG.storj_uplink.uplink_bucket_iterator_err(bucketIterator))
{
if (error != null && !string.IsNullOrEmpty(error.message))
{
throw new BucketListException(error.message);
}
}
BucketList bucketList = new BucketList();
while (SWIG.storj_uplink.uplink_bucket_iterator_next(bucketIterator))
{
var bucket = SWIG.storj_uplink.uplink_bucket_iterator_item(bucketIterator);
bucketList.Items.Add(Bucket.FromSWIG(bucket, _access._project));
}
return(bucketList);
}
}
public async Task <ObjectList> ListObjectsAsync(Bucket bucket, ListObjectsOptions listObjectsOptions)
{
var listObjectsOptionsSWIG = listObjectsOptions.ToSWIG();
_listOptions.Add(listObjectsOptionsSWIG);
using (SWIG.UplinkObjectIterator objectIterator = await Task.Run(() => SWIG.storj_uplink.uplink_list_objects(_access._project, bucket.Name, listObjectsOptionsSWIG)))
{
using (SWIG.UplinkError error = SWIG.storj_uplink.uplink_object_iterator_err(objectIterator))
{
if (error != null && !string.IsNullOrEmpty(error.message))
{
throw new BucketListException(error.message);
}
}
ObjectList objectList = new ObjectList();
while (SWIG.storj_uplink.uplink_object_iterator_next(objectIterator))
{
using (var objectResult = SWIG.storj_uplink.uplink_object_iterator_item(objectIterator))
{
objectList.Items.Add(uplink.NET.Models.Object.FromSWIG(objectResult, true));
}
}
return(objectList);
}
}
public async Task <UploadPartsList> ListUploadPartsAsync(string bucketName, string objectKey, string uploadId, ListUploadPartsOptions listUploadPartOptions)
{
var listUploadPartsOptionsSWIG = listUploadPartOptions.ToSWIG();
_listUploadPartsOptions.Add(listUploadPartsOptionsSWIG);
using (SWIG.UplinkPartIterator partIterator = await Task.Run(() => SWIG.storj_uplink.uplink_list_upload_parts(_access._project, bucketName, objectKey, uploadId, listUploadPartsOptionsSWIG)).ConfigureAwait(false))
{
using (SWIG.UplinkError error = SWIG.storj_uplink.uplink_part_iterator_err(partIterator))
{
if (error != null && !string.IsNullOrEmpty(error.message))
{
throw new UploadPartsListException(error.message);
}
}
UploadPartsList uploadPartList = new UploadPartsList();
while (SWIG.storj_uplink.uplink_part_iterator_next(partIterator))
{
using (var partUploadResult = SWIG.storj_uplink.uplink_part_iterator_item(partIterator))
{
uploadPartList.Items.Add(uplink.NET.Models.Part.FromSWIG(partUploadResult));
}
}
return(uploadPartList);
}
}
public void Dispose()
{
if (_project != null)
{
using (SWIG.UplinkError closeError = SWIG.storj_uplink.uplink_close_project(_project))
{
_project.Dispose();
_project = null;
}
}
}
public async Task MoveObjectAsync(Bucket oldBucket, string oldKey, Bucket newBucket, string newKey)
{
using (var options = new SWIG.UplinkMoveObjectOptions())
using (SWIG.UplinkError error = await Task.Run(() => SWIG.storj_uplink.uplink_move_object(_access._project, oldBucket.Name, oldKey, newBucket.Name, newKey, options)))
{
if (error != null && !string.IsNullOrEmpty(error.message))
{
throw new ObjectNotFoundException(error.message);
}
}
}
public async Task UpdateObjectMetadataAsync(Bucket bucket, string targetPath, CustomMetadata metadata)
{
await UploadOperation.customMetadataSemaphore.WaitAsync();
try
{
metadata.ToSWIG(); //Appends the customMetadata in the go-layer to a global field
using (var options = new SWIG.UplinkUploadObjectMetadataOptions())
using (SWIG.UplinkError error = await Task.Run(() => SWIG.storj_uplink.uplink_update_object_metadata2(_access._project, bucket.Name, targetPath, options)).ConfigureAwait(false))
{
if (error != null && !string.IsNullOrEmpty(error.message))
{
throw new CouldNotUpdateObjectMetadataException(error.message);
}
}
}
finally
{
UploadOperation.customMetadataSemaphore.Release();
}
}
public void Dispose()
{
if (_project != null)
{
SWIG.UplinkError closeError = SWIG.storj_uplink.uplink_close_project(_project);
SWIG.storj_uplink.uplink_free_error(closeError);
_project.Dispose();
_project = null;
}
if (_accessResult != null)
{
SWIG.storj_uplink.uplink_free_access_result(_accessResult);
_accessResult.Dispose();
_accessResult = null;
}
if (_projectResult != null)
{
SWIG.storj_uplink.uplink_free_project_result(_projectResult);
_projectResult.Dispose();
_projectResult = null;
}
}
internal void ToSWIG(SWIG.UplinkUpload upload)
{
if (CustomMetadata != null)
{
UploadOperation.customMetadataSemaphore.Wait();
try
{
CustomMetadata.ToSWIG(); //Appends the customMetadata in the go-layer to a global field
using (SWIG.UplinkError customMetadataError = SWIG.storj_uplink.upload_set_custom_metadata2(upload))
{
if (customMetadataError != null && !string.IsNullOrEmpty(customMetadataError.message))
{
throw new SetCustomMetadataFailedException(customMetadataError.message);
}
}
}
finally
{
UploadOperation.customMetadataSemaphore.Release();
}
}
}
private void DoUpload()
{
try
{
if (_byteStreamToUpload != null)
{
Running = true;
int bytesToUploadCount = 0;
do
{
byte[] bytesToUpload = new byte[262144];
bytesToUploadCount = _byteStreamToUpload.Read(bytesToUpload, 0, 262144);
if (bytesToUploadCount > 0)
{
byte[] targetArray = bytesToUpload.Take((int)bytesToUploadCount).ToArray();
fixed(byte *arrayPtr = targetArray)
{
using (SWIG.UplinkWriteResult sentResult = SWIG.storj_uplink.uplink_upload_write(_upload, new SWIG.SWIGTYPE_p_void(new IntPtr(arrayPtr), true), (uint)bytesToUploadCount))
{
if (sentResult.error != null && !string.IsNullOrEmpty(sentResult.error.message))
{
_errorMessage = sentResult.error.message;
Failed = true;
Running = false;
UploadOperationEnded?.Invoke(this);
return;
}
else
{
BytesSent += sentResult.bytes_written;
}
}
if (_cancelled)
{
using (SWIG.UplinkError abortError = SWIG.storj_uplink.uplink_upload_abort(_upload))
{
if (abortError != null && !string.IsNullOrEmpty(abortError.message))
{
Failed = true;
_errorMessage = abortError.message;
}
else
{
Cancelled = true;
}
}
Running = false;
UploadOperationEnded?.Invoke(this);
return;
}
UploadOperationProgressChanged?.Invoke(this);
if (!string.IsNullOrEmpty(_errorMessage))
{
Failed = true;
UploadOperationEnded?.Invoke(this);
return;
}
}
}
} while (bytesToUploadCount > 0);
if (_customMetadata != null)
{
if (customMetadataMutex.WaitOne(1000))
{
try
{
_customMetadata.ToSWIG(); //Appends the customMetadata in the go-layer to a global field
using (SWIG.UplinkError customMetadataError = SWIG.storj_uplink.upload_set_custom_metadata2(_upload))
{
if (customMetadataError != null && !string.IsNullOrEmpty(customMetadataError.message))
{
_errorMessage = customMetadataError.message;
Failed = true;
UploadOperationEnded?.Invoke(this);
return;
}
}
}
finally
{
customMetadataMutex.ReleaseMutex();
}
}
}
using (SWIG.UplinkError commitError = SWIG.storj_uplink.uplink_upload_commit(_upload))
{
if (commitError != null && !string.IsNullOrEmpty(commitError.message))
{
_errorMessage = commitError.message;
Failed = true;
UploadOperationEnded?.Invoke(this);
return;
}
}
}
if (!string.IsNullOrEmpty(_errorMessage))
{
Failed = true;
UploadOperationEnded?.Invoke(this);
return;
}
Completed = true;
UploadOperationEnded?.Invoke(this);
}
catch (Exception ex)
{
Failed = true;
_errorMessage = ex.Message;
return;
}
finally
{
Running = false;
UploadOperationEnded?.Invoke(this);
}
}
private void DoDownload()
{
Running = true;
while (BytesReceived < TotalBytes)
{
var tenth = _bytesToDownload.Length / 10;
if (TotalBytes - BytesReceived > tenth)
{
//Fetch next bytes in batch
byte[] part = new byte[tenth];
fixed(byte *arrayPtr = part)
{
using (SWIG.UplinkReadResult readResult = SWIG.storj_uplink.uplink_download_read(_download, new SWIG.SWIGTYPE_p_void(new IntPtr(arrayPtr), true), (uint)tenth))
{
if (readResult.error != null && !string.IsNullOrEmpty(readResult.error.message))
{
_errorMessage = readResult.error.message;
Failed = true;
Running = false;
DownloadOperationEnded?.Invoke(this);
return;
}
if (readResult.bytes_read != 0)
{
Array.Copy(part, 0, _bytesToDownload, (long)BytesReceived, readResult.bytes_read);
BytesReceived += readResult.bytes_read;
}
}
}
}
else
{
//Fetch only the remaining bytes
var remaining = TotalBytes - BytesReceived;
byte[] part = new byte[remaining];
fixed(byte *arrayPtr = part)
{
using (SWIG.UplinkReadResult readResult = SWIG.storj_uplink.uplink_download_read(_download, new SWIG.SWIGTYPE_p_void(new IntPtr(arrayPtr), true), (uint)remaining))
{
if (readResult.error != null && !string.IsNullOrEmpty(readResult.error.message))
{
_errorMessage = readResult.error.message;
Failed = true;
Running = false;
DownloadOperationEnded?.Invoke(this);
return;
}
if (readResult.bytes_read != 0)
{
Array.Copy(part, 0, _bytesToDownload, (long)BytesReceived, readResult.bytes_read);
BytesReceived += readResult.bytes_read;
}
}
}
}
if (_cancelled)
{
using (SWIG.UplinkError cancelError = SWIG.storj_uplink.uplink_close_download(_download))
{
if (cancelError != null && !string.IsNullOrEmpty(cancelError.message))
{
_errorMessage = cancelError.message;
Failed = true;
}
else
{
Cancelled = true;
}
}
Running = false;
DownloadOperationEnded?.Invoke(this);
return;
}
DownloadOperationProgressChanged?.Invoke(this);
if (!string.IsNullOrEmpty(_errorMessage))
{
Failed = true;
Running = false;
DownloadOperationEnded?.Invoke(this);
return;
}
}
using (SWIG.UplinkError closeError = SWIG.storj_uplink.uplink_close_download(_download))
{
if (closeError != null && !string.IsNullOrEmpty(closeError.message))
{
_errorMessage = closeError.message;
Failed = true;
Running = false;
DownloadOperationEnded?.Invoke(this);
return;
}
}
Completed = true;
Running = false;
DownloadOperationEnded?.Invoke(this);
}
