/// <summary>
/// Create temporary S3 objects to show how object deletion wors in an
/// S3 bucket with versioning enabled.
/// </summary>
/// <param name="client">The initialized S3 client object used to call
/// PutObjectAsync to create temporary objects for the example.</param>
/// <param name="bucketName">A string representing the name of the S3
/// bucket where we will create the temporary objects.</param>
/// <param name="number">The number of temporary objects to create.</param>
/// <returns>A list of the KeyVersion objects.</returns>
static async Task <List <KeyVersion> > PutObjectsAsync(IAmazonS3 client, string bucketName, int number)
{
var keys = new List <KeyVersion>();
for (var i = 0; i < number; i++)
{
string key = "ObjectToDelete-" + new System.Random().Next();
PutObjectRequest request = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = "This is the content body!",
};
var response = await client.PutObjectAsync(request);
KeyVersion keyVersion = new KeyVersion
{
Key = key,
VersionId = response.VersionId,
};
keys.Add(keyVersion);
}
return(keys);
}
static async Task <List <KeyVersion> > PutObjectsAsync(int number)
{
List <KeyVersion> keys = new List <KeyVersion>();
for (int i = 0; i < number; i++)
{
string key = "ExampleObject-" + new System.Random().Next();
PutObjectRequest request = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = "This is the content body!",
};
PutObjectResponse response = await s3Client.PutObjectAsync(request);
KeyVersion keyVersion = new KeyVersion
{
Key = key,
// For non-versioned bucket operations, we only need object key.
// VersionId = response.VersionId
};
keys.Add(keyVersion);
}
return(keys);
}
private async Task <List <KeyVersion> > PutObjectsAsync(IEnumerable <S3Object> objes)
{
var keys = new List <KeyVersion>();
foreach (var obj in objes)
{
PutObjectRequest request = new PutObjectRequest
{
BucketName = BucketName,
Key = obj.Key,
//ContentBody = "This is the content body!",
};
var response = await _client.PutObjectAsync(request);
KeyVersion keyVersion = new KeyVersion
{
Key = obj.Key,
VersionId = response.VersionId
};
keys.Add(keyVersion);
}
return(keys);
}
/// <summary>
/// Deletes the markers left after deleting the temporary objects.
/// </summary>
/// <param name="client">The initialized S3 client object used to call
/// DeleteObjectVersionsAsync, DeleteObjectsAsync, and
/// RemoveDeleteMarkersAsync.</param>
/// <param name="bucketName">The name of the bucket from which to delete
/// objects.</param>
/// <param name="deletedObjects">A list of the objects that were deleted.</param>
private static async Task RemoveDeleteMarkersAsync(IAmazonS3 client, string bucketName, List <DeletedObject> deletedObjects)
{
var keyVersionList = new List <KeyVersion>();
foreach (var deletedObject in deletedObjects)
{
KeyVersion keyVersion = new KeyVersion
{
Key = deletedObject.Key,
VersionId = deletedObject.DeleteMarkerVersionId,
};
keyVersionList.Add(keyVersion);
}
// Create another request to delete the delete markers.
var multiObjectDeleteRequest = new DeleteObjectsRequest
{
BucketName = bucketName,
Objects = keyVersionList,
};
// Now, delete the delete marker to bring your objects back to the bucket.
try
{
Console.WriteLine("Removing the delete markers .....");
var deleteObjectResponse = await client.DeleteObjectsAsync(multiObjectDeleteRequest);
Console.WriteLine($"Successfully deleted the {deleteObjectResponse.DeletedObjects.Count} delete markers");
}
catch (DeleteObjectsException ex)
{
DisplayDeletionErrors(ex);
}
}
private static async Task RemoveDeleteMarkersAsync(List <DeletedObject> deletedObjects)
{
var keyVersionList = new List <KeyVersion>();
foreach (var deletedObject in deletedObjects)
{
KeyVersion keyVersion = new KeyVersion
{
Key = deletedObject.Key,
VersionId = deletedObject.DeleteMarkerVersionId
};
keyVersionList.Add(keyVersion);
}
// Create another request to delete the delete markers.
var multiObjectDeleteRequest = new DeleteObjectsRequest
{
BucketName = bucketName,
Objects = keyVersionList
};
// Now, delete the delete marker to bring your objects back to the bucket.
try
{
Console.WriteLine("Removing the delete markers .....");
var deleteObjectResponse = await s3Client.DeleteObjectsAsync(multiObjectDeleteRequest);
Console.WriteLine("Successfully deleted all the {0} delete markers",
deleteObjectResponse.DeletedObjects.Count);
}
catch (DeleteObjectsException e)
{
PrintDeletionReport(e);
}
}
static void DeleteMultiple()
{
List <KeyVersion> versions = new List <KeyVersion>();
while (true)
{
string key = Common.InputString("Key [null to end]:", null, true);
if (String.IsNullOrEmpty(key))
{
break;
}
int ver = Common.InputInteger("Version:", 1, true, false);
KeyVersion version = new KeyVersion();
version.Key = key;
version.VersionId = ver.ToString();
versions.Add(version);
}
DeleteObjectsRequest request = new DeleteObjectsRequest();
request.BucketName = _Bucket;
request.Objects = versions;
DeleteObjectsResponse response = _S3Client.DeleteObjectsAsync(request).Result;
int statusCode = (int)response.HttpStatusCode;
if (response != null)
{
Console.WriteLine("Deleted objects:");
if (response.DeletedObjects != null && response.DeletedObjects.Count > 0)
{
foreach (DeletedObject curr in response.DeletedObjects)
{
Console.WriteLine(" " + curr.Key + " version " + curr.VersionId);
}
}
else
{
Console.WriteLine(" (none)");
}
Console.WriteLine("Errors:");
if (response.DeleteErrors != null && response.DeleteErrors.Count > 0)
{
foreach (DeleteError curr in response.DeleteErrors)
{
Console.WriteLine(" " + curr.Key + " version " + curr.VersionId);
}
}
else
{
Console.WriteLine(" (none)");
}
Console.WriteLine("Success");
}
else
{
Console.WriteLine("Failed");
}
}
/* 3. Delete an Object */
public static void DeleteFileFromS3(string folderName, string FileName)
{
try
{
ListObjectsRequest request = new ListObjectsRequest();
request.BucketName = "takatanet-test-bucket";
request.Prefix = string.IsNullOrEmpty(FileName) ? folderName + "/" : folderName + "/" + FileName;
ListObjectsResponse response = s3Client.ListObjects(request);
List <KeyVersion> keys = new List <KeyVersion>();
foreach (S3Object obj in response.S3Objects)
{
KeyVersion keyVersion = new KeyVersion()
{
Key = obj.Key
};
keys.Add(keyVersion);
//S3FileInfo s3FileInfo = new Amazon.S3.IO.S3FileInfo(s3Client, request.BucketName, obj.Key);
//s3FileInfo.Delete();
}
MultiObjectDelete(keys);
//DeleteObjectRequest objRequest = new DeleteObjectRequest()
//{
// BucketName = "takatanet-test-bucket",
// Key = string.IsNullOrEmpty(FileName)? folderName + "/" : folderName + "/" + FileName
//};
//DeleteObjectResponse reponse = s3Client.DeleteObject(objRequest);
//S3FileInfo s3FileInfo = new Amazon.S3.IO.S3FileInfo(s3Client, objRequest.BucketName, objRequest.Key);
//s3FileInfo.Delete();
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null &&
(amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId")
||
amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
Console.WriteLine("Check the provided AWS Credentials.");
Console.WriteLine(
"For service sign up go to http://aws.amazon.com/s3");
}
else
{
Console.WriteLine(
"Error occurred. Message:'{0}' when writing an object"
, amazonS3Exception.Message);
}
}
}
public void DeleteObject()
{
this.ResultText.text = $"deleting {this.SampleFileName} from bucket {this.S3BucketName}";
List <KeyVersion> list = new List <KeyVersion>();
KeyVersion item = new KeyVersion();
item.set_Key(this.SampleFileName);
list.Add(item);
DeleteObjectsRequest request2 = new DeleteObjectsRequest();
request2.set_BucketName(this.S3BucketName);
request2.set_Objects(list);
DeleteObjectsRequest request = request2;
this.Client.DeleteObjectsAsync(request, new AmazonServiceCallback <DeleteObjectsRequest, DeleteObjectsResponse>(this, this.< DeleteObject > m__9), null);
}
public static MasterKey Create(KeyVersion version, string fullName, char[] masterPassword)
{
switch (version)
{
case KeyVersion.V0:
return(new MasterKeyV0(fullName).Revalidate(masterPassword));
case KeyVersion.V1:
return(new MasterKeyV1(fullName).Revalidate(masterPassword));
case KeyVersion.V2:
return(new MasterKeyV2(fullName).Revalidate(masterPassword));
case KeyVersion.V3:
return(new MasterKeyV3(fullName).Revalidate(masterPassword));
}
throw new InvalidOperationException($"Unsupported version: {version}");
}
public static string ToBundleVersion(KeyVersion e)
{
switch (e)
{
case KeyVersion.V0:
return("1.0");
case KeyVersion.V1:
return("2.0");
case KeyVersion.V2:
return("2.1");
case KeyVersion.V3:
return("2.2");
}
throw new InvalidOperationException($"Unsupported version: {e}");
}
private void DeletePartFiles(string backet_name, List <string> keys)
{
DeleteObjectsRequest deleteRequest = new DeleteObjectsRequest()
{
BucketName = backet_name
};
foreach (var item in keys)
{
KeyVersion key = new KeyVersion()
{
Key = item
};
deleteRequest.Objects.Add(key);
}
var result = _client.DeleteObjectsAsync(deleteRequest).GetAwaiter().GetResult();
}
/// <summary>
/// 删除搜狐云CDN文件
/// </summary>
/// <param name="key">缓存文件Key</param>
public void ClearSoHuYun(string key)
{
#region 验证密钥
string accessKey = System.Configuration.ConfigurationManager.AppSettings["accessKey"];
string secretKey = System.Configuration.ConfigurationManager.AppSettings["secretKey"];
SHSCSCredentials myCredentials = new BasicSHSCSCredentials(accessKey, secretKey);
#endregion
SohuCSClient client = new SohuCSClient(myCredentials, RegionEndpoint.BJCNC);
try
{
string[] keyArray = key.Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (keyArray != null && keyArray.Length > 0)
{
ListBucketsResponse bucketsResponse = client.ListBuckets();
foreach (SCSBucket bucket in bucketsResponse.Buckets)
{
List <KeyVersion> keyList = new List <KeyVersion>();
foreach (var item in keyArray)
{
KeyVersion kv = new KeyVersion();
kv.Key = item;
//kv.VersionId = "";
keyList.Add(kv);
}
DeleteObjectsRequest request = new DeleteObjectsRequest
{
BucketName = bucket.BucketName, //空间
Objects = keyList
};
DeleteObjectsResponse response = client.DeleteObjects(request);
}
}
}
catch (DeleteObjectsException ex)
{
throw ex;
}
}
public async Task <DeleteObjectsResponse> DeleteObjects(string[] objectPaths, string[] versionIds = null)
{
var keyVersions = new List <KeyVersion>();
for (var i = 0; i < objectPaths.Length; i++)
{
var objectPath = objectPaths[i];
var keyVersion = new KeyVersion()
{
Key = objectPath,
};
if (versionIds != null)
{
var versionId = versionIds.ElementAtOrDefault(i);
if (!string.IsNullOrEmpty(versionId))
{
keyVersion.VersionId = versionId;
}
}
keyVersions.Add(keyVersion);
}
var request = new DeleteObjectsRequest
{
BucketName = BucketName,
Objects = keyVersions,
};
var response = await client.DeleteObjectsAsync(request);
return(response);
}
private static void CollectAllRecursiveKeys(KeyVersion keys)
{
recursiveContentList.Add(keys);
}
/// <summary>
/// Initializes a new instance of the <see cref="Keyczar"/> class.
/// </summary>
/// <param name="keySet">The key set.</param>
protected Keyczar(IKeySet keySet)
{
var metadata = keySet.Metadata;
var versions = metadata
.Versions
.Select(v =>
{
var key = keySet.GetKey(v.VersionNumber);
return Tuple.Create(key.GetKeyHash(), v, key);
})
.ToList();
_primaryVersion = metadata.Versions.SingleOrDefault(it => it.Status == KeyStatus.Primary);
_versions = versions.ToDictionary(k => k.Item2.VersionNumber, v => v.Item3);
_hashedKeys = HashKeys(versions);
_hashedFallbackKeys = HashedFallbackKeys(versions);
}
