bool LSD_Reader::Save(const std::string& filename, const RPG::Save& save, const std::string &encoding) {
LcfWriter writer(filename, encoding);
if (!writer.IsOk()) {
LcfReader::SetError("Couldn't find %s save file.\n", filename.c_str());
return false;
}
const std::string header("LcfSaveData");
writer.WriteInt(header.size());
writer.Write(header);
const_cast<RPG::Save&>(save).title.timestamp = GenerateTimestamp();
Struct<RPG::Save>::WriteLcf(save, writer);
return true;
}
//--------------------------------------------------------------------------------------------------
void OAuthSignRequest
(
const Credentials_t& keys, ///< [IN] The application's keys.
Request_t type, ///< [IN] The type of request to be performed.
const std::string& url, ///< [IN] The address and path of the request.
ParamMap_t& params, ///< [IN/OUT] The parameter list will be updated with the required
///< OAuth additions.
bool excludeConsumer ///< [IN] Should the consumer key be excluded from the params?
)
//--------------------------------------------------------------------------------------------------
{
std::string timeStamp = GenerateTimestamp();
params.insert({ "oauth_nonce", GenerateNonce(timeStamp) });
params.insert({ "oauth_signature_method", "HMAC-SHA1" });
params.insert({ "oauth_timestamp", timeStamp });
params.insert({ "oauth_version", "1.0" });
if (excludeConsumer == false)
{
params.insert({ "oauth_consumer_key", keys.consumer.publicKey });
}
if (keys.oAuthAccess.publicKey.size() > 0)
{
params.insert({ "oauth_token", keys.oAuthAccess.publicKey });
}
std::stringstream requestString;
std::stringstream paramString;
switch (type)
{
case Request_t::Get:
requestString << "GET&";
break;
case Request_t::Post:
requestString << "POST&";
break;
default:
throw std::runtime_error("Unexpected HTTP request type.");
}
requestString << UrlEncode(url) << "&";
bool first = true;
for (auto iter : params)
{
if (first) { first = false; } else { paramString << "&"; }
paramString << UrlEncode(iter.first) << "=" << UrlEncode(iter.second);
}
requestString << UrlEncode(paramString.str());
for (size_t i = 0; i < requestString.str().size(); i += 20)
{
std::string section = requestString.str().substr(i, 20);
}
CHMAC_SHA1 sha1;
std::string signingKey = UrlEncode(keys.consumer.secretKey) + "&";
if (keys.oAuthAccess.secretKey.size() > 0)
{
signingKey += UrlEncode(keys.oAuthAccess.secretKey);
}
BYTE digest[CHMAC_SHA1::SHA1_DIGEST_LENGTH] = "";
sha1.HMAC_SHA1((unsigned char*)requestString.str().c_str(),
requestString.str().size(),
(unsigned char*)signingKey.c_str(),
signingKey.size(),
digest);
params.insert({ "oauth_signature", base64_encode(digest, sizeof(digest)) });
}
bool TransactionManager::CommitTransaction(TxnContext *context, EventTuple *param, CharArray &ret_str){
BEGIN_PHASE_MEASURE(thread_id_, COMMIT_PHASE);
// step 1: acquire lock and validate
uint64_t max_rw_ts = 0;
size_t lock_count = 0;
bool is_success = true;
access_list_.Sort();
for (size_t i = 0; i < access_list_.access_count_; ++i) {
++lock_count;
Access *access_ptr = access_list_.GetAccess(i);
if (access_ptr->access_type_ == READ_ONLY) {
// acquire read lock
access_ptr->access_record_->content_.AcquireReadLock();
#if !defined(NOVALID)
// whether someone has changed the tuple after my read
if (access_ptr->access_record_->content_.GetTimestamp() != access_ptr->timestamp_) {
UPDATE_CC_ABORT_COUNT(thread_id_, context->txn_type_, access_ptr->access_record_->GetTableId());
is_success = false;
break;
}
#endif
if (access_ptr->timestamp_ > max_rw_ts){
max_rw_ts = access_ptr->timestamp_;
}
}
else if (access_ptr->access_type_ == READ_WRITE) {
// acquire write lock
access_ptr->access_record_->content_.AcquireWriteLock();
#if !defined(NOVALID)
// whether someone has changed the tuple after my read
if (access_ptr->access_record_->content_.GetTimestamp() != access_ptr->timestamp_) {
UPDATE_CC_ABORT_COUNT(thread_id_, context->txn_type_, access_ptr->access_record_->GetTableId());
is_success = false;
break;
}
#endif
if (access_ptr->timestamp_ > max_rw_ts){
max_rw_ts = access_ptr->timestamp_;
}
}
else {
assert(access_ptr->access_type_ == DELETE_ONLY);
access_ptr->access_record_->content_.AcquireWriteLock();
}
}
// step 2: if success, then overwrite and commit
if (is_success == true) {
BEGIN_CC_TS_ALLOC_TIME_MEASURE(thread_id_);
uint64_t curr_ts = ScalableTimestamp::GetTimestamp();
END_CC_TS_ALLOC_TIME_MEASURE(thread_id_);
uint64_t commit_ts = GenerateTimestamp(curr_ts, max_rw_ts);
for (size_t i = 0; i < access_list_.access_count_; ++i) {
Access *access_ptr = access_list_.GetAccess(i);
TableRecord *access_record = access_ptr->access_record_;
if (access_ptr->access_type_ == READ_WRITE) {
assert(commit_ts > access_ptr->timestamp_);
access_record->record_->CopyFrom(access_ptr->local_record_);
COMPILER_MEMORY_FENCE;
access_record->content_.SetTimestamp(commit_ts);
#if defined(VALUE_LOGGING)
log_buffer_.UpdateRecord(access_record->schema_ptr_->GetTableId(), access_ptr->local_record_->data_ptr_, access_record->schema_ptr_->GetSchemaSize());
#endif
}
else if (access_ptr->access_type_ == DELETE_ONLY) {
assert(max_rw_ts >= access_ptr->timestamp_);
assert(commit_ts > access_ptr->timestamp_);
access_record->record_->is_visible_ = false;
COMPILER_MEMORY_FENCE;
access_record->content_.SetTimestamp(commit_ts);
#if defined(VALUE_LOGGING)
log_buffer_.DeleteRecord(access_record->schema_ptr_->GetTableId(), access_record->GetPrimaryKey());
#endif
}
}
for (size_t i = 0; i < insertion_list_.insertion_count_; ++i) {
Insertion *insertion_ptr = insertion_list_.GetInsertion(i);
TableRecord *tb_record = new TableRecord(insertion_ptr->local_record_);
tb_record->content_.AcquireWriteLock();
tb_record->content_.SetTimestamp(commit_ts);
insertion_ptr->insertion_record_ = tb_record;
//storage_manager_->tables_[insertion_ptr->table_id_]->InsertRecord(insertion_ptr->primary_key_, insertion_ptr->insertion_record_);
#if defined(VALUE_LOGGING)
log_buffer_.InsertRecord(insertion_ptr->table_id_, insertion_record->data_ptr_, insertion_record->schema_ptr_->GetSchemaSize());
#endif
}
// commit.
#if defined(VALUE_LOGGING)
CharArray *log_str = log_buffer_.Commit();
logger_->CommitTransaction(this->thread_id_, commit_ts, log_str);
#elif defined(COMMAND_LOGGING)
CharArray *log_str = log_buffer_.Commit(context->txn_type_, param);
logger_->CommitTransaction(this->thread_id_, commit_ts, log_str);
#endif
// step 3: release locks and clean up.
for (size_t i = 0; i < access_list_.access_count_; ++i) {
Access *access_ptr = access_list_.GetAccess(i);
if (access_ptr->access_type_ == READ_ONLY) {
access_ptr->access_record_->content_.ReleaseReadLock();
}
else if (access_ptr->access_type_ == READ_WRITE) {
access_ptr->access_record_->content_.ReleaseWriteLock();
BEGIN_CC_MEM_ALLOC_TIME_MEASURE(thread_id_);
allocator_->Free(access_ptr->local_record_->data_ptr_);
access_ptr->local_record_->~SchemaRecord();
allocator_->Free((char*)access_ptr->local_record_);
END_CC_MEM_ALLOC_TIME_MEASURE(thread_id_);
}
else if (access_ptr->access_type_ == DELETE_ONLY) {
access_ptr->access_record_->content_.ReleaseWriteLock();
}
}
for (size_t i = 0; i < insertion_list_.insertion_count_; ++i) {
Insertion *insertion_ptr = insertion_list_.GetInsertion(i);
insertion_ptr->insertion_record_->content_.ReleaseWriteLock();
}
}
// if failed.
else {
// step 3: release locks and clean up.
for (size_t i = 0; i < access_list_.access_count_; ++i) {
Access *access_ptr = access_list_.GetAccess(i);
if (access_ptr->access_type_ == READ_ONLY) {
access_ptr->access_record_->content_.ReleaseReadLock();
}
else if (access_ptr->access_type_ == READ_WRITE) {
access_ptr->access_record_->content_.ReleaseWriteLock();
BEGIN_CC_MEM_ALLOC_TIME_MEASURE(thread_id_);
allocator_->Free(access_ptr->local_record_->data_ptr_);
access_ptr->local_record_->~SchemaRecord();
allocator_->Free((char*)access_ptr->local_record_);
END_CC_MEM_ALLOC_TIME_MEASURE(thread_id_);
}
else {
assert(access_ptr->access_type_ == DELETE_ONLY);
access_ptr->access_record_->content_.ReleaseWriteLock();
}
--lock_count;
if (lock_count == 0) {
break;
}
}
for (size_t i = 0; i < insertion_list_.insertion_count_; ++i) {
Insertion *insertion_ptr = insertion_list_.GetInsertion(i);
BEGIN_CC_MEM_ALLOC_TIME_MEASURE(thread_id_);
allocator_->Free(insertion_ptr->local_record_->data_ptr_);
insertion_ptr->local_record_->~SchemaRecord();
allocator_->Free((char*)insertion_ptr->local_record_);
END_CC_MEM_ALLOC_TIME_MEASURE(thread_id_);
}
}
assert(insertion_list_.insertion_count_ <= kMaxAccessNum);
assert(access_list_.access_count_ <= kMaxAccessNum);
insertion_list_.Clear();
access_list_.Clear();
END_PHASE_MEASURE(thread_id_, COMMIT_PHASE);
return is_success;
}
