bool deleteAllEntries(S3ConnectionPtr aS3, std::string aBucketName)
{
ListBucketResponsePtr lListBucket;
ListBucketResponse::Object lObject;
std::string lMarker;
std::cout << "Start deleting items from bucket " << aBucketName << std::endl;
try {
uint32_t lCtr = 0;
do
{
lListBucket = aS3->listBucket(aBucketName, "", lMarker);
lListBucket->open();
while (lListBucket->next(lObject)) {
DeleteResponsePtr lDelete = aS3->del(aBucketName, lObject.KeyValue);
if(lCtr < 25){
std::cout << " deleted item with key " << lObject.KeyValue << std::endl;
}else if( lCtr == 25){
std::cout << " deleting more items..." << std::endl;
}else if (lCtr % 50 == 0){
std::cout << " still deleting more items..." << std::endl;
}
++lCtr;
lMarker = lObject.KeyValue;
}
lListBucket->close();
} while (lListBucket->isTruncated());
std::cout << "deleted " << lCtr << " items" << std::endl;
} catch (ListBucketException &e) {
std::cerr << e.what() << std::endl;
return false;
}
return true;
}
bool
del(S3ConnectionPtr aS3, std::string aBucketName, std::string aKey, std::string aPrefix)
{
ListBucketResponsePtr lListBucket;
ListBucketResponse::Object lObject;
std::string lMarker;
try {
if (aKey.size() != 0) {
DeleteResponsePtr lDel = aS3->del(aBucketName, aKey);
} else {
DeleteAllResponsePtr lDel = aS3->deleteAll(aBucketName, aPrefix);
}
} catch (S3Exception &e) {
std::cerr << e.what() << std::endl;
return false;
}
return true;
}
bool deleteBucket ( S3ConnectionPtr aS3, const std::string& aBucketName) {
try {
DeleteBucketResponsePtr lRes = aS3->deleteBucket(aBucketName);
std::cout << "bucket deleted sucessfully" << std::endl;
std::cout << " bucket-name: " << lRes->getBucketName() << std::endl;
} catch (DeleteBucketException &e) {
std::cerr << e.what() << std::endl;
return false;
}
return true;
}
bool
listBucket(S3ConnectionPtr aS3, std::string aBucketName, std::string aPrefix,
std::string aMarker, std::string aDelimiter, int aMaxKeys) {
ListBucketResponsePtr lListBucket;
ListBucketResponse::Object lObject;
std::string lMarker;
try {
do
{
lListBucket = aS3->listBucket(aBucketName, aPrefix, lMarker,
aDelimiter, aMaxKeys);
lListBucket->open();
while (lListBucket->next(lObject)) {
std::cout << " Key: " << lObject.KeyValue << " | Last Modified: " << lObject.LastModified;
std::cout << " | ETag: " << lObject.ETag << " | Size: " << lObject.Size << std::endl;
lMarker = lObject.KeyValue;
HeadResponsePtr lHead = aS3->head(aBucketName, lObject.KeyValue);
std::map<std::string, std::string> lMeta = lHead->getMetaData();
std::map<std::string, std::string>::const_iterator lIter = lMeta.begin();
if (lMeta.size() != 0) {
std::cout << " Custom Metadata:" << std::endl;
for (; lIter != lMeta.end(); ++lIter) {
std::cout << " Key: " << (*lIter).first << "; Value: " << (*lIter).second << std::endl;
}
}
}
lListBucket->close();
std::vector<std::string> lCommonPrefixes = lListBucket->getCommonPrefixes();
for (std::vector<std::string>::const_iterator lIter = lCommonPrefixes.begin();
lIter != lCommonPrefixes.end(); ++lIter) {
std::cout << "CommonPrefix " << *lIter << std::endl;
}
} while (lListBucket->isTruncated());
} catch (S3Exception &e) {
std::cerr << e.what() << std::endl;
return false;
}
return true;
}
bool putbin ( S3ConnectionPtr aS3, const std::string& aBucketName, const std::string& aFileName, const std::string& aKey )
{
try {
std::ifstream lInStream(aFileName.c_str());
if (!lInStream) {
std::cerr << "file not found or accessible: " << aFileName << std::endl;
return false;
}
PutResponsePtr lPut = aS3->put(aBucketName, aKey.length()==0?aFileName:aKey, lInStream, "application/octet-stream");
} catch (PutException &e) {
std::cerr << e.what() << std::endl;
return false;
}
return true;
}
bool get ( S3ConnectionPtr aS3, const std::string& aBucketName, const std::string& aKey )
{
try {
GetResponsePtr lGet = aS3->get(aBucketName, aKey);
char buf[512];
std::istream& lIn = lGet->getInputStream();
while (lIn.good()) {
lIn.read(buf, 512);
std::cout.write(buf, lIn.gcount());
}
} catch (GetException &e) {
std::cerr << e.what() << std::endl;
return false;
}
return true;
}
static void
upload_staged_image(S3ConnectionPtr s3conn, IplImage *image, const std::string& key)
{
assert(image->imageData != NULL);
std::stringstream ins;
ins << PS3M << SERIAL_DELIM
<< image->nChannels << SERIAL_DELIM
<< image->width << SERIAL_DELIM
<< image->height << SERIAL_DELIM
<< image->depth << std::endl;
ins.write(image->imageData, image->imageSize);
// int count = ins.gcount();
// std::cout << count << " " << image->imageData << " " << image->imageSize;
// assert(count == image->imageSize);
PutResponsePtr res = s3conn->put(CVDB::BUCKET, key, ins, "binary/octet-stream");
}
static void
upload_image_eigen(S3ConnectionPtr s3conn, ImageMetadata *meta)
{
assert(meta->features != NULL);
char buf[32];
std::string key(meta->imagetable->prefix);
key += "/";
key += EIGEN_PREFIX;
key += "/";
sprintf(buf, "%d.eigen", meta->id);
key += buf;
std::stringstream ins;
ins.write((char*)(meta->features), sizeof(float)*meta->imagetable->eigenspace->dimension);
PutResponsePtr res = s3conn->put(meta->imagetable->bucket,
key, ins, "binary/octet-stream");
}
bool logging( S3ConnectionPtr aS3, const std::string& aBucketName) {
try {
BucketLoggingStatusResponsePtr lRes = aS3->bucketLoggingStatus(aBucketName);
std::cout << "bucket logging: " << std::endl;
std::cout << " bucket-name: " << lRes->getBucketName() << std::endl;
if (lRes->isLoggingEnabled()) {
std::cout << " logging: enabled" << std::endl;
std::cout << " target bucket: " << lRes->getTargetBucket() << std::endl;
std::cout << " target prefix: " << lRes->getTargetPrefix() << std::endl;
} else {
std::cout << " logging: disabled" << std::endl;
}
} catch (BucketLoggingStatusException &e) {
std::cerr << e.what() << std::endl;
return false;
}
return true;
}
bool
listBuckets ( S3ConnectionPtr aS3 )
{
try {
ListAllBucketsResponsePtr lRes = aS3->listAllBuckets();
std::cout << "buckets listed sucessfully" << std::endl;
ListAllBucketsResponse::Bucket lBucket;
lRes->open();
while (lRes->next(lBucket)) {
std::cout << " Bucket Name: " << lBucket.BucketName
<< " | Creation Date: " << lBucket.CreationDate << "\n";
}
lRes->close();
} catch (CreateBucketException &e) {
std::cerr << e.what() << std::endl;
return false;
}
return true;
}
static void
load_image_eigen(S3ConnectionPtr s3conn, ImageMetadata *meta)
{
char buf[32];
std::string key(meta->imagetable->prefix);
key += "/";
key += EIGEN_PREFIX;
key += "/";
sprintf(buf, "%d.eigen", meta->id);
key += buf;
if (meta->features == NULL) {
meta->features = new float[meta->imagetable->eigenspace->dimension];
}
GetResponsePtr res = s3conn->get(CVDB::BUCKET, key);
std::istream& ins = res->getInputStream();
ins.read((char*)(meta->features), sizeof(float)*meta->imagetable->eigenspace->dimension);
}
