~drizzle-trunk/drizzle/development

CSVector *CSS3Protocol::s3_send(CSInputStream *input, const char *bucket, const char *key, off64_t size, const char *content_type, Md5Digest *digest, const char *s3Authorization, time_t s3AuthorizationTime)

1076

{

1077

CSStringBuffer *s3_buffer;

1078

char date[64];

1079

CSString *signed_str;

1080

Md5Digest dummy_digest;

1081

uint32_t retry_count = 0;

1082

S3ProtocolCon *con_data;

1083

CSVector *replyHeaders;

1084

1085

enter_();

1086

push_(input);

1087

1088

new_(s3_buffer, CSStringBuffer());

1089

push_(s3_buffer);

1090

1091

new_(con_data, S3ProtocolCon());

1092

push_(con_data);

1093

1094

if (!digest)

1095

digest = &dummy_digest;

1096

1097

if (!content_type)

1098

content_type = "binary/octet-stream";

1099

1100

retry:

1101

1102

// Clear old settings.

1103

con_data->ms_reset();

1104

1105

if (s3Authorization) {

1106

SET_DATE_FROM_TIME(s3AuthorizationTime, date);

1107

} else {

1108

SET_DATE(date);

1109

}

1110

1111

// Build the URL

1112

s3_buffer->setLength(0);

1113

s3_buffer->append("http://");

1114

s3_buffer->append(bucket);

1115

s3_buffer->append(".");

1116

s3_buffer->append(s3_server->getCString());

1117

s3_buffer->append(key);

1118

1119

con_data->ms_setURL(s3_buffer->getCString());

1120

1121

// Add the 'DATE' header

1122

s3_buffer->setLength(0);

1123

s3_buffer->append("Date: ");

1124

s3_buffer->append(date);

1125

con_data->ms_setHeader(s3_buffer->getCString());

1126

1127

// Add the 'Content-Type' header

1128

s3_buffer->setLength(0);

1129

s3_buffer->append("Content-Type: ");

1130

s3_buffer->append(content_type);

1131

con_data->ms_setHeader(s3_buffer->getCString());

1132

1133

// Create the authentication signature and add the 'Authorization' header

1134

if (!s3Authorization)

1135

signed_str = s3_getSignature("PUT", NULL, content_type, date, bucket, key);

1136

else

1137

signed_str = CSString::newString(s3Authorization);

1138

push_(signed_str);

1139

s3_buffer->setLength(0);

1140

s3_buffer->append("Authorization: AWS ");

1141

s3_buffer->append(s3_public_key->getCString());

1142

s3_buffer->append(":");

1143

s3_buffer->append(signed_str->getCString());

1144

release_(signed_str); signed_str = NULL;

1145

con_data->ms_setHeader(s3_buffer->getCString());

1146

1147

con_data->ms_execute_put_request(RETAIN(input), size, digest);

1148

1149

if (con_data->ms_retry) {

1150

if (retry_count == s3_maxRetrys) {

1151

CSException::throwException(CS_CONTEXT, CS_ERR_GENERIC_ERROR, "S3 operation aborted after max retries.");

1152

}

1153

printf("RETRY: s3_send()\n");

1154

retry_count++;

1155

input->reset();

1156

goto retry;

1157

}

1158

1159

replyHeaders = con_data->ms_reply_headers.takeHeaders();

1160

release_(con_data);

1161

release_(s3_buffer);

1162

release_(input);

1163

return_(replyHeaders);

1164

}

1165

1166

//-------------------------------

1167

CSString *CSS3Protocol::s3_getDataURL(const char *bucket, const char *key, uint32_t keep_alive)

1168

{

1169

CSStringBuffer *s3_buffer;

1170

char timeout[32];

1171

CSString *signed_str;

1172

enter_();

1173

1174

new_(s3_buffer, CSStringBuffer());

1175

push_(s3_buffer);

1176

1177

snprintf(timeout, 32, "%"PRId32"", ((uint32_t)time(NULL)) + keep_alive);

1178

1179

signed_str = s3_getSignature("GET", NULL, NULL, timeout, bucket, key);

1180

//printf("Unsafe: \"%s\"\n", signed_str->getCString());

1181

signed_str = urlEncode(signed_str); // Because the signature is in the URL it must be URL encoded.

1182

//printf(" Safe: \"%s\"\n", signed_str->getCString());

1183

push_(signed_str);

1184

1185

s3_buffer->setLength(0);

1186

s3_buffer->append("http://");

1187

s3_buffer->append(bucket);

1188

s3_buffer->append(".");

1189

s3_buffer->append(s3_server->getCString());

1190

s3_buffer->append(key);

1191

1192

s3_buffer->append("?AWSAccessKeyId=");

1193

s3_buffer->append(s3_public_key->getCString());

1194

s3_buffer->append("&Expires=");

1195

s3_buffer->append(timeout);

1196

s3_buffer->append("&Signature=");

1197

s3_buffer->append(signed_str->getCString());

1198

1199

release_(signed_str);

1200

1201

pop_(s3_buffer);

1202

CSString *str = CSString::newString(s3_buffer);

1203

return_(str);

1204

}

1205

1206

//#define S3_UNIT_TEST

1207

#ifdef S3_UNIT_TEST

1208

static void show_help_info(const char *cmd)

1209

{

1210

printf("Get authenticated query string:\n\t%s q <bucket> <object_key> <timeout>\n", cmd);

1211

printf("Delete object:\n\t%s d <bucket> <object_key>\n", cmd);

1212

printf("Delete all object with a given prefix:\n\t%s D <bucket> <object_prefix>\n", cmd);

1213

printf("Get object, data will be written to 'prottest.out':\n\t%s g <bucket> <object_key> <timeout>\n", cmd);

1214

printf("Put (Upload) an object:\n\t%s p <bucket> <object_key> <file>\n", cmd);

1215

printf("List objects in the bucket:\n\t%s l <bucket> [<object_prefix> [max_list_size]]\n", cmd);

1216

printf("Copy object:\n\t%s c <src_bucket> <src_object_key> <dst_bucket> <dst_object_key> \n", cmd);

1217

printf("Copy all object with a given prefix:\n\t%s C <src_bucket> <object_key_prefix> <dst_bucket> \n", cmd);

1218

}

1219

1220

void dump_headers(CSVector *header_array)

1221

{

1222

CSHTTPHeaders headers;

1223

1224

headers.setHeaders(header_array);

1225

printf("Reply Headers:\n");

1226

printf("--------------\n");

1227

1228

for (uint32_t i = 0; i < headers.numHeaders(); i++) {

1229

CSHeader *h = headers.getHeader(i);

1230

1231

printf("%s : %s\n", h->getNameCString(), h->getValueCString());

1232

h->release();

1233

}

1234

printf("--------------\n");

1235

headers.clearHeaders();

1236

}

1237

1238

int main(int argc, char **argv)

1239

{

1240

CSThread *main_thread;

1241

const char *pub_key;

1242

const char *priv_key;

1243

CSS3Protocol *prot = NULL;

1244

1245

if (argc < 3) {

1246

show_help_info(argv[0]);

1247

return 0;

1248

}

1249

1250

if (! CSThread::startUp()) {

1251

CSException::throwException(CS_CONTEXT, ENOMEM, "CSThread::startUp() failed.");

1252

return 1;

1253

}

1254

1255

cs_init_memory();

1256

1257

main_thread = new CSThread( NULL);

1258

CSThread::setSelf(main_thread);

1259

1260

enter_();

1261

try_(a) {

1262

1263

pub_key = getenv("S3_ACCESS_KEY_ID");

1264

priv_key = getenv("S3_SECRET_ACCESS_KEY");

1265

new_(prot, CSS3Protocol());

1266

push_(prot);

1267

1268

prot->s3_setServer("s3.amazonaws.com/");

1269

prot->s3_setPublicKey(pub_key);

1270

prot->s3_setPrivateKey(priv_key);

1271

1272

switch (argv[1][0]) {

1273

case 'q': // Get the query string

1274

if (argc == 5) {

1275

CSString *qstr = prot->s3_getDataURL(argv[2], argv[3], atoi(argv[4]));

1276

printf("To test call:\ncurl -L -D - \"%s\"\n", qstr->getCString());

1277

qstr->release();

1278

} else

1279

printf("Bad command: q <bucket> <object_key> <timeout>\n");

1280

1281

break;

1282

case 'd': // Delete the object

1283

if (argc == 4) {

1284

printf("delete %s %s\n", argv[2], argv[3]);

1285

if (!prot->s3_delete(argv[2], argv[3]))

1286

printf("%s/%s could not be found.\n", argv[2], argv[3]);

1287

1288

} else

1289

printf("Bad command: d <bucket> <object_key>\n");

1290

1291

break;

1292

case 'D': // Delete objects like

1293

if (argc == 4) {

1294

CSVector *list;

1295

CSString *key;

1296

1297

list = prot->s3_list(argv[2], argv[3]);

1298

push_(list);

1299

while (key = (CSString*) list->take(0)) {

1300

printf("Deleting %s\n", key->getCString());

1301

prot->s3_delete(argv[2], key->getCString());

1302

key->release();

1303

}

1304

release_(list);

1305

1306

} else

1307

printf("Bad command: D <bucket> <object_key_prefix>\n");

1308

1309

break;

1310

case 'g': // Get the object

1311

if (argc == 4) {

1312

CSFile *output;

1313

CSVector *headers;

1314

bool found;

1315

1316

output = CSFile::newFile("prottest.out");

1317

push_(output);

1318

output->open(CSFile::CREATE | CSFile::TRUNCATE);

1319

headers = prot->s3_receive(output->getOutputStream(), argv[2], argv[3], &found);

1320

if (!found)

1321

printf("%s/%s could not be found.\n", argv[2], argv[3]);

1322

1323

dump_headers(headers);

1324

1325

release_(output);

1326

} else

1327

printf("Bad command: g <bucket> <object_key>\n");

1328

1329

break;

1330

1331

case 'p': // Put (Upload) the object

1332

if (argc == 5) {

1333

CSFile *input;

1334

CSVector *headers;

1335

1336

input = CSFile::newFile(argv[4]);

1337

push_(input);

1338

input->open(CSFile::READONLY);

1339

headers = prot->s3_send(input->getInputStream(), argv[2], argv[3], input->myFilePath->getSize());

1340

dump_headers(headers);

1341

release_(input);

1342

} else

1343

printf("Bad command: p <bucket> <object_key> <file> \n");

1344

1345

break;

1346

1347

case 'c': // Copy the object

1348

if (argc == 6) {

1349

prot->s3_copy(NULL, argv[4], argv[5], argv[2], argv[3]);

1350

} else

1351

printf("Bad command: c <src_bucket> <src_object_key> <dst_bucket> <dst_object_key>\n");

1352

1353

break;

1354

1355

case 'C': // Copy objects like

1356

if (argc == 5) {

1357

CSVector *list;

1358

CSString *key;

1359

1360

list = prot->s3_list(argv[2], argv[3]);

1361

push_(list);

1362

while (key = (CSString*) list->take(0)) {

1363

printf("Copying %s\n", key->getCString());

1364

prot->s3_copy(NULL, argv[4], key->getCString(), argv[2], key->getCString());

1365

key->release();

1366

}

1367

release_(list);

1368

1369

} else

1370

printf("Bad command: C <src_bucket> <object_key_prefix> <dst_bucket>\n");

1371

1372

break;

1373

case 'l': // List the object

1374

if ((argc == 3) || (argc == 4) || (argc == 5)) {

1375

uint32_t max = 0;

1376

char *prefix = NULL;

1377

CSVector *list;

1378

CSString *key;

1379

1380

if (argc > 3) {

1381

prefix = argv[3];

1382

if (!strlen(prefix))

1383

prefix = NULL;

1384

}

1385

1386

if (argc == 5)

1387

max = atol(argv[4]);

1388

1389

list = prot->s3_list(argv[2], prefix, max);

1390

push_(list);

1391

while (key = (CSString*) list->take(0)) {

1392

printf("%s\n", key->getCString());

1393

key->release();

1394

}

1395

release_(list);

1396

1397

} else

1398

printf("Bad command: l <bucket> [<object_prefix> [max_list_size]] \n");

1399

1400

break;

1401

default:

1402

printf("Unknown command.\n");

1403

show_help_info(argv[0]);

1404

}

1405

1406

release_(prot);

1407

}

1408

1409

catch_(a);

1410

self->logException();

1411

1412

cont_(a);

1413

1414

outer_()

1415

main_thread->release();

1416

cs_exit_memory();

1417

CSThread::shutDown();

1418

return 0;

1419

}

1420

1421

#endif

1422

1423

Older »