Status FirehoseLogForwarder::setUp() { // Set up client Status s = makeAWSClient<Aws::Firehose::FirehoseClient>(client_); if (!s.ok()) { return s; } if (FLAGS_aws_firehose_stream.empty()) { return Status(1, "Stream name must be specified with --aws_firehose_stream"); } // Make sure we can connect to designated stream Aws::Firehose::Model::DescribeDeliveryStreamRequest r; r.SetDeliveryStreamName(FLAGS_aws_firehose_stream); auto outcome = client_->DescribeDeliveryStream(r); if (!outcome.IsSuccess()) { return Status( 1, "Could not find Firehose stream: " + FLAGS_aws_firehose_stream); } VLOG(1) << "Firehose logging initialized with stream: " << FLAGS_aws_firehose_stream; return Status(0); }
/** * Creates an alias for an AWS account, based on command line input */ int main(int argc, char** argv) { if(argc != 2) { std::cout << "Usage: iam_create_account_alias <alias_name>" << std::endl; return 1; } Aws::String alias_name(argv[1]); Aws::SDKOptions options; Aws::InitAPI(options); { Aws::IAM::IAMClient iam; Aws::IAM::Model::CreateAccountAliasRequest request; request.SetAccountAlias(alias_name); auto outcome = iam.CreateAccountAlias(request); if (!outcome.IsSuccess()) { std::cout << "Error creating account alias " << alias_name << ": " << outcome.GetError().GetMessage() << std::endl; } else { std::cout << "Successfully created account alias " << alias_name << std::endl; } } Aws::ShutdownAPI(options); return 0; }
void CreateAlarmAndEnableActions( const Aws::String& alarm_name, const Aws::String& instanceId, const Aws::String& actionArn) { Aws::CloudWatch::CloudWatchClient cw; Aws::CloudWatch::Model::PutMetricAlarmRequest request; request.SetAlarmName(alarm_name); request.SetComparisonOperator( Aws::CloudWatch::Model::ComparisonOperator::GreaterThanThreshold); request.SetEvaluationPeriods(1); request.SetMetricName("CPUUtilization"); request.SetNamespace("AWS/EC2"); request.SetPeriod(60); request.SetStatistic(Aws::CloudWatch::Model::Statistic::Average); request.SetThreshold(70.0); request.SetActionsEnabled(false); request.SetAlarmDescription("Alarm when server CPU exceeds 70%"); request.SetUnit(Aws::CloudWatch::Model::StandardUnit::Seconds); request.AddAlarmActions(actionArn); Aws::CloudWatch::Model::Dimension dimension; dimension.SetName("InstanceId"); dimension.SetValue(instanceId); request.AddDimensions(dimension); auto outcome = cw.PutMetricAlarm(request); if (!outcome.IsSuccess()) { std::cout << "Failed to create cloudwatch alarm:" << outcome.GetError().GetMessage() << std::endl; return; } Aws::CloudWatch::Model::EnableAlarmActionsRequest enable_request; enable_request.AddAlarmNames(alarm_name); auto enable_outcome = cw.EnableAlarmActions(enable_request); if (!enable_outcome.IsSuccess()) { std::cout << "Failed to enable alarm actions:" << enable_outcome.GetError().GetMessage() << std::endl; return; } std::cout << "Successfully created alarm " << alarm_name << " and enabled actions on it." << std::endl; }
ReplicationTransportSPtr ReplicaManagerWrapper::CreateTransport(REConfigSPtr const & config) { auto transport = ReplicationTransport::Create(config->ReplicatorListenAddress); auto errorCode = transport->Start(L"localhost:0"); ASSERT_IFNOT(errorCode.IsSuccess(), "Failed to start: {0}", errorCode); return transport; }
/* * Load snapshot data */ void Engine::LoadFromSnapshot() { if (!current_snapshot_.Valid()) { LOGI("Snapshot is not valid!"); EnableUI(true); return; } LOGI("Opening file"); service_->Snapshots() .Open(current_snapshot_.FileName(), gpg::SnapshotConflictPolicy::MANUAL, [this](gpg::SnapshotManager::OpenResponse const & response) { LOGI("Opened file"); if (IsSuccess(response.status)) { //Do need conflict resolution? if (response.data.Valid() == false) { if (response.conflict_id != "") { LOGI("Need conflict resolution"); bool b = ResolveConflicts(response, 0); if (!b) { LOGI("Failed resolving conflicts"); EnableUI(true); return; } } else { EnableUI(true); return; } } LOGI("Reading file"); gpg::SnapshotManager::ReadResponse responseRead = service_->Snapshots().ReadBlocking(response.data); if (IsSuccess(responseRead.status)) { LOGI("Parsing data"); ParseSnapshotData(responseRead.data); ndk_helper::JNIHelper::GetInstance()->RunOnUiThread([this]() { UpdateGameUI(); }); } } EnableUI(true); }); }
ICCItem *CMission::GetProperty (const CString &sName) // GetProperty // // Returns a property { CCodeChain &CC = g_pUniverse->GetCC(); if (strEquals(sName, PROPERTY_IS_ACTIVE)) return CC.CreateBool(IsActive()); else if (strEquals(sName, PROPERTY_IS_COMPLETED)) return CC.CreateBool(IsCompleted()); else if (strEquals(sName, PROPERTY_IS_DEBRIEFED)) return CC.CreateBool(m_fDebriefed); else if (strEquals(sName, PROPERTY_IS_DECLINED)) return CC.CreateBool(m_fDeclined); else if (strEquals(sName, PROPERTY_IS_FAILURE)) return CC.CreateBool(IsFailure()); else if (strEquals(sName, PROPERTY_IS_INTRO_SHOWN)) return CC.CreateBool(m_fIntroShown); else if (strEquals(sName, PROPERTY_IS_OPEN)) return CC.CreateBool(m_iStatus == statusOpen); else if (strEquals(sName, PROPERTY_IS_RECORDED)) return CC.CreateBool(IsRecorded()); else if (strEquals(sName, PROPERTY_IS_SUCCESS)) return CC.CreateBool(IsSuccess()); else if (strEquals(sName, PROPERTY_IS_UNAVAILABLE)) return CC.CreateBool(IsUnavailable()); else if (strEquals(sName, PROPERTY_NODE_ID)) return (m_sNodeID.IsBlank() ? CC.CreateNil() : CC.CreateString(m_sNodeID)); else if (strEquals(sName, PROPERTY_OWNER_ID)) { if (m_pOwner.GetID() == OBJID_NULL) return CC.CreateNil(); else return CC.CreateInteger(m_pOwner.GetID()); } else if (strEquals(sName, PROPERTY_UNID)) return CC.CreateInteger(m_pType->GetUNID()); else return CSpaceObject::GetProperty(sName); }
bool doesBucketExists(ClientPtrType client, String bucketName) { auto objectReq = Aws::S3::Model::HeadBucketRequest(); auto objectRes = client->HeadBucket(objectReq.WithBucket(bucketName)); if (objectRes.IsSuccess()) { return true; } return false; }
std::tuple<bool, Map> doesObjectExists(ClientPtrType client, String bucketName, String key) { auto objectReq = Aws::S3::Model::HeadObjectRequest(); objectReq.WithBucket(bucketName).WithKey(key); auto objectRes = client->HeadObject(objectReq); if (objectRes.IsSuccess()) { return std::make_tuple(true, objectRes.GetResult().GetMetadata()); } return std::make_tuple(false, Map()); }
void CreateSecurityGroup( const Aws::String& group_name, const Aws::String& description, const Aws::String& vpc_id) { Aws::EC2::EC2Client ec2; Aws::EC2::Model::CreateSecurityGroupRequest request; request.SetGroupName(group_name); request.SetDescription(description); request.SetVpcId(vpc_id); auto outcome = ec2.CreateSecurityGroup(request); if (!outcome.IsSuccess()) { std::cout << "Failed to create security group:" << outcome.GetError().GetMessage() << std::endl; return; } std::cout << "Successfully created security group named " << group_name << std::endl; Aws::EC2::Model::AuthorizeSecurityGroupIngressRequest authorize_request; authorize_request.SetGroupName(group_name); BuildSampleIngressRule(authorize_request); auto ingress_request = ec2.AuthorizeSecurityGroupIngress( authorize_request); if(!ingress_request.IsSuccess()) { std::cout << "Failed to set ingress policy for security group " << group_name << ":" << ingress_request.GetError().GetMessage() << std::endl; return; } std::cout << "Successfully added ingress policy to security group " << group_name << std::endl; }
/** * Lists all iam policies */ int main(int argc, char** argv) { Aws::SDKOptions options; Aws::InitAPI(options); { Aws::IAM::IAMClient iam; Aws::IAM::Model::ListPoliciesRequest request; bool done = false; bool header = false; while (!done) { auto outcome = iam.ListPolicies(request); if (!outcome.IsSuccess()) { std::cout << "Failed to list iam policies: " << outcome.GetError().GetMessage() << std::endl; break; } if (!header) { std::cout << std::left << std::setw(55) << "Name" << std::setw(30) << "ID" << std::setw(80) << "Arn" << std::setw(64) << "Description" << std::setw(12) << "CreateDate" << std::endl; header = true; } const auto &policies = outcome.GetResult().GetPolicies(); for (const auto &policy : policies) { std::cout << std::left << std::setw(55) << policy.GetPolicyName() << std::setw(30) << policy.GetPolicyId() << std::setw(80) << policy.GetArn() << std::setw(64) << policy.GetDescription() << std::setw(12) << policy.GetCreateDate().ToGmtString(DATE_FORMAT) << std::endl; } if (outcome.GetResult().GetIsTruncated()) { request.SetMarker(outcome.GetResult().GetMarker()); } else { done = true; } } } Aws::ShutdownAPI(options); return 0; }
void ReplicaManagerWrapper::UpdateConfiguration( ReplicaInformationVector const & previousActiveReplicas, ULONG previousQuorum, ReplicaInformationVector const & currentActiveReplicas, ULONG currentQuorum) { auto error = replicaManagerSPtr_->UpdateConfiguration( previousActiveReplicas, previousQuorum, currentActiveReplicas, currentQuorum, true, true); VERIFY_IS_TRUE(error.IsSuccess(), L"UpdateConfiguration (catchup replicas set) should succeed"); }
void getFakeObject(ClientPtrType client, String bucketName, String key) { String base = "=== Get Fake Object [" + bucketName + "/" + key; std::cout << base << "]: Start ===\n"; std::cout << "Reading from " << key << "\n"; auto inpData = Aws::MakeShared<Aws::FStream>("GetObjectInputStream", key.c_str(), std::ios_base::in | std::ios_base::binary); auto objReq = Aws::S3::Model::GetObjectRequest(); objReq.WithBucket(bucketName).WithKey(key); auto objRes = client->GetObject(objReq); if (objRes.IsSuccess()) { std::cout << base << "]: Failed ===\n"; } std::cout << base << "]: End ===\n\n"; }
void copyObject(ClientPtrType client, String bucketName, String src, String dst) { String base = "=== Copy Object [" + bucketName + "/" + src + "->" + dst; std::cout << base << "]: Start ===\n"; auto objReq = Aws::S3::Model::CopyObjectRequest(); objReq.WithBucket(bucketName).WithCopySource(bucketName + "/" + src); auto objRes = client->CopyObject(objReq.WithKey(dst)); if (!objRes.IsSuccess()) { std::cout << base << "]: Client Side failure ===\n"; } if (!std::get<0>(doesObjectExists(client, bucketName, dst))) { std::cout << base << "]: Failed ===\n"; } std::cout << base << "]: End ===\n\n"; }
void deleteObject(ClientPtrType client, String bucketName, String key) { String base = "=== Delete Object [" + bucketName + "/" + key; std::cout << base << "]: Start ===\n"; auto objReq = Aws::S3::Model::DeleteObjectRequest(); objReq.WithBucket(bucketName); auto objRes = client->DeleteObject(objReq.WithKey(key)); if (!objRes.IsSuccess()) { std::cout << base << "]: Client Side failure ===\n"; } if (std::get<0>(doesObjectExists(client, bucketName, key))) { std::cout << base << "]: Deletion of " << key << " Failed ===\n"; } std::cout << base << "]: End ===\n\n"; }
/** * Connects an sqs queue to an associated dead letter queue based on command * line input */ int main(int argc, char** argv) { if (argc != 4) { std::cout << "Usage: dead_letter_queue <source_queue_url> " << "<dead_letter_queue_arn> <max_messages>" << std::endl; return 1; } Aws::SDKOptions options; Aws::InitAPI(options); { Aws::String src_queue_url = argv[1]; Aws::String queue_arn = argv[2]; Aws::StringStream ss(argv[3]); int max_msg = 1; ss >> max_msg; Aws::SQS::SQSClient sqs; Aws::String redrivePolicy = MakeRedrivePolicy(queue_arn, max_msg); Aws::SQS::Model::SetQueueAttributesRequest request; request.SetQueueUrl(src_queue_url); request.AddAttributes( Aws::SQS::Model::QueueAttributeName::RedrivePolicy, redrivePolicy); auto outcome = sqs.SetQueueAttributes(request); if (outcome.IsSuccess()) { std::cout << "Successfully set dead letter queue for queue " << src_queue_url << " to " << queue_arn << std::endl; } else { std::cout << "Error setting dead letter queue for queue " << src_queue_url << ": " << outcome.GetError().GetMessage() << std::endl; } } Aws::ShutdownAPI(options); return 0; }
void deleteBucket(ClientPtrType client, String bucketName) { String base = "=== Delete Bucket [" + bucketName; std::cout << base << "]: Start ===\n"; auto bucketReq = Aws::S3::Model::DeleteBucketRequest(); auto bucketRes = client->DeleteBucket(bucketReq.WithBucket(bucketName)); if (!bucketRes.IsSuccess()) { std::cout << base << "]: Client Side failure ===\n"; std::cout << bucketRes.GetError().GetExceptionName() << "\t" << bucketRes.GetError().GetMessage() << "\n"; } if (doesBucketExists(client, bucketName)) { std::cout << base << "]: Failed ===\n"; } std::cout << base << "]: End ===\n\n"; }
/** * Posts a sample cloudwatch event, based on command line input */ int main(int argc, char** argv) { if (argc != 4) { std::cout << "Usage:" << std::endl << " put_events " << "<resource_arn> <sample_key> <sample_value>" << std::endl; return 1; } Aws::SDKOptions options; Aws::InitAPI(options); { Aws::String resource_arn(argv[1]); Aws::String event_key(argv[2]); Aws::String event_value(argv[3]); Aws::CloudWatchEvents::CloudWatchEventsClient cwe; Aws::CloudWatchEvents::Model::PutEventsRequestEntry event_entry; event_entry.SetDetail(MakeDetails(event_key, event_value)); event_entry.SetDetailType("sampleSubmitted"); event_entry.AddResources(resource_arn); event_entry.SetSource("aws-sdk-cpp-cloudwatch-example"); Aws::CloudWatchEvents::Model::PutEventsRequest request; request.AddEntries(event_entry); auto outcome = cwe.PutEvents(request); if (!outcome.IsSuccess()) { std::cout << "Failed to post cloudwatch event: " << outcome.GetError().GetMessage() << std::endl; } else { std::cout << "Successfully posted cloudwatch event" << std::endl; } } Aws::ShutdownAPI(options); return 0; }
// Updates local player achievements with values from the server: void GPGManager::FetchAchievements() { if (!LoggedIn() || achievement_data_state_ == kPending) return; achievement_data_state_ = kPending; game_services_->Achievements().FetchAll( [this](const gpg::AchievementManager::FetchAllResponse &far) mutable { pthread_mutex_lock(&achievements_mutex_); if (IsSuccess(far.status)) { achievement_data_state_ = kComplete; achievement_data_initialized_ = true; } else { achievement_data_state_ = kFailed; } achievement_data_ = far.data; pthread_mutex_unlock(&achievements_mutex_); }); }
void GPGManager::FetchPlayer() { game_services_->Players().FetchSelf([this]( const gpg::PlayerManager::FetchSelfResponse &fsr) mutable { pthread_mutex_lock(&players_mutex_); if (IsSuccess(fsr.status)) { gpg::Player *player_data = new gpg::Player(fsr.data); SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "GPG: got player info. ID = %s, name = %s, avatar=%s", player_data->Id().c_str(), player_data->Name().c_str(), player_data->AvatarUrl(gpg::ImageResolution::HI_RES).c_str()); player_data_.reset(player_data); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "GPG: failed to get player info"); player_data_.reset(nullptr); } pthread_mutex_unlock(&players_mutex_); }); }
/** * Updates the status (active/inactive) of an iam user's access key, based on * command line input */ int main(int argc, char** argv) { if(argc != 4) { PrintUsage(); return 1; } Aws::String user_name(argv[1]); Aws::String accessKeyId(argv[2]); auto status = Aws::IAM::Model::StatusTypeMapper::GetStatusTypeForName(argv[3]); if (status == Aws::IAM::Model::StatusType::NOT_SET) { PrintUsage(); return 1; } Aws::SDKOptions options; Aws::InitAPI(options); { Aws::IAM::IAMClient iam; Aws::IAM::Model::UpdateAccessKeyRequest request; request.SetUserName(user_name); request.SetAccessKeyId(accessKeyId); request.SetStatus(status); auto outcome = iam.UpdateAccessKey(request); if (outcome.IsSuccess()) { std::cout << "Successfully updated status of access key " << accessKeyId << " for user " << user_name << std::endl; } else { std::cout << "Error updated status of access key " << accessKeyId << " for user " << user_name << ": " << outcome.GetError().GetMessage() << std::endl; } } Aws::ShutdownAPI(options); return 0; }
/* * Show quest UI */ void Engine::ShowQuestUI() { EnableUI(false); service_->Quests().ShowAllUI([this]( gpg::QuestManager::QuestUIResponse const & response) { if (IsSuccess(response.status)) { if (response.accepted_quest.Valid()) { LOGI("Accepted a quest"); EnableUI(true); } if (response.milestone_to_claim.Valid()) { LOGI("Claimed a milestone"); ClaimMilestone(response.milestone_to_claim); } } else { LOGI("Invalid response status"); EnableUI(true); } }); }
/** * Creates a cloud watch logs subscription filter, based on command line input */ int main(int argc, char** argv) { if (argc != 5) { std::cout << "Usage: " << std::endl << " put_subscription_filter " << "<filter_name> <filter_pattern> <log_group_name> " << "<lambda_function_arn>" << std::endl; return 1; } Aws::SDKOptions options; Aws::InitAPI(options); { Aws::String filter_name(argv[1]); Aws::String filter_pattern(argv[2]); Aws::String log_group(argv[3]); Aws::String dest_arn(argv[4]); Aws::CloudWatchLogs::CloudWatchLogsClient cwl; Aws::CloudWatchLogs::Model::PutSubscriptionFilterRequest request; request.SetFilterName(filter_name); request.SetFilterPattern(filter_pattern); request.SetLogGroupName(log_group); request.SetDestinationArn(dest_arn); auto outcome = cwl.PutSubscriptionFilter(request); if (!outcome.IsSuccess()) { std::cout << "Failed to create cloudwatch logs subscription filter " << filter_name << ": " << outcome.GetError().GetMessage() << std::endl; } else { std::cout << "Successfully created cloudwatch logs subscription " << "filter " << filter_name << std::endl; } } Aws::ShutdownAPI(options); return 0; }
void OnTryInvalidateCompleted(AsyncOperationSPtr const & operation, bool expectedCompletedSynchronously) { if (operation->CompletedSynchronously != expectedCompletedSynchronously) { return; } auto const & thisSPtr = operation->Parent; bool isFirstWaiter = false; TestCacheEntrySPtr entry; auto error = cache_.EndTryInvalidate(operation, isFirstWaiter, entry); Trace.WriteInfo( TraceComponent, "EndTryInvalidate(key={0} worker={1}): error={2} isFirst={3}", key_, workerId_, error, isFirstWaiter); if (error.IsSuccess()) { if (isFirstWaiter) { this->ProcessFirstWaiterOnInvalidate(thisSPtr); } else { this->ProcessEntryOnInvalidate(thisSPtr, entry); } } else if (error.IsError(ErrorCodeValue::Timeout)) { this->StartTryGet(thisSPtr); } else { this->TryComplete(thisSPtr, error); } }
/** * Creates a long-polled sqs queue based on command line input */ int main(int argc, char** argv) { if (argc != 3) { std::cout << "Usage: long_polling_on_create_queue <queue_name> " << "<poll_time_in_seconds>" << std::endl; return 1; } Aws::SDKOptions options; Aws::InitAPI(options); { Aws::String queue_name = argv[1]; Aws::String poll_time = argv[2]; Aws::SQS::SQSClient sqs; Aws::SQS::Model::CreateQueueRequest request; request.SetQueueName(queue_name); request.AddAttributes( Aws::SQS::Model::QueueAttributeName::ReceiveMessageWaitTimeSeconds, poll_time); auto outcome = sqs.CreateQueue(request); if (outcome.IsSuccess()) { std::cout << "Successfully created queue " << queue_name << std::endl; } else { std::cout << "Error creating queue " << queue_name << ": " << outcome.GetError().GetMessage() << std::endl; } } Aws::ShutdownAPI(options); return 0; }
/** * Deletes an access key from an IAM user, based on command line input */ int main(int argc, char** argv) { if (argc != 3) { std::cout << "Usage: delete_access_key <user_name> <access_key_id>" << std::endl; return 1; } Aws::SDKOptions options; Aws::InitAPI(options); { Aws::String user_name(argv[1]); Aws::String key_id(argv[2]); Aws::IAM::IAMClient iam; Aws::IAM::Model::DeleteAccessKeyRequest request; request.SetUserName(user_name); request.SetAccessKeyId(key_id); auto outcome = iam.DeleteAccessKey(request); if (!outcome.IsSuccess()) { std::cout << "Error deleting access key " << key_id << " from user " << user_name << ": " << outcome.GetError().GetMessage() << std::endl; } else { std::cout << "Successfully deleted access key " << key_id << " for IAM user " << user_name << std::endl; } } Aws::ShutdownAPI(options); return 0; }
void deleteObjects(ClientPtrType client, String bucketName, String prefix, size_t num) { String base = "=== Delete Objects [" + bucketName + "/" + prefix; std::cout << base << "]: Start ===\n"; Aws::Vector<Aws::S3::Model::ObjectIdentifier> objects; for (size_t i = 0; i < num; ++i) { objects.push_back(Aws::S3::Model::ObjectIdentifier().WithKey(prefix + std::to_string(i).c_str())); } auto objReq = Aws::S3::Model::DeleteObjectsRequest(); objReq.WithBucket(bucketName).WithDelete(Aws::S3::Model::Delete().WithObjects(objects)); auto objRes = client->DeleteObjects(objReq); if (!objRes.IsSuccess()) { std::cout << base << "]: Client Side failure ===\n"; }/* if (std::get<0>(doesObjectExists(client, bucketName, key))) { std::cout << base << "]: Deletion of " << key << " Failed ===\n"; }*/ std::cout << base << "]: End ===\n\n"; }
void getObject(ClientPtrType client, String bucketName, String key, String path, Map metadata) { String base = "=== Get Object [" + bucketName + "/" + key; std::cout << base << "]: Start ===\n"; std::cout << "Reading from " << path << "\n"; auto inpData = Aws::MakeShared<Aws::FStream>("GetObjectInputStream", path.c_str(), std::ios_base::in | std::ios_base::binary); auto objReq = Aws::S3::Model::GetObjectRequest(); objReq.WithBucket(bucketName).WithKey(key); auto objRes = client->GetObject(objReq); if (!objRes.IsSuccess()) { std::cout << base << "]: Client Side failure ===\n"; std::cout << objRes.GetError().GetExceptionName() << "\t" << objRes.GetError().GetMessage() << "\n"; std::cout << base << "]: Failed ===\n"; } else { if (!metadata.empty()) { if (metadata != objRes.GetResult().GetMetadata()) { std::cout << objRes.GetResult().GetMissingMeta() << "\n"; print(metadata); print(objRes.GetResult().GetMetadata()); std::cout << base << "]: Metadata not equal ===\n"; } } Aws::IOStream& file = objRes.GetResult().GetBody(); if (!doFilesMatch(inpData.get(), file)) { std::cout << base << "]: Content not equal ===\n"; } } std::cout << base << "]: End ===\n\n"; }
/** * Creates a fixed policy with name based on command line input */ int main(int argc, char** argv) { if (argc != 3) { std::cout << "Usage: create_policy <policy_name> <resource_arn>" << std::endl; return 1; } Aws::SDKOptions options; Aws::InitAPI(options); { Aws::String policy_name(argv[1]); Aws::String rsrc_arn(argv[2]); Aws::IAM::IAMClient iam; Aws::IAM::Model::CreatePolicyRequest request; request.SetPolicyName(policy_name); request.SetPolicyDocument(BuildSamplePolicyDocument(rsrc_arn)); auto outcome = iam.CreatePolicy(request); if (!outcome.IsSuccess()) { std::cout << "Error creating policy " << policy_name << ": " << outcome.GetError().GetMessage() << std::endl; } else { std::cout << "Successfully created policy " << policy_name << std::endl; } } Aws::ShutdownAPI(options); return 0; }
/* * Show current event status */ void Engine::ShowEventStatus() { EnableUI(false); service_->Events().FetchAll([this](gpg::EventManager::FetchAllResponse const &response) { if (IsSuccess(response.status)) { ndk_helper::JNIHelper::GetInstance()->RunOnUiThread([this,response]() { LOGI("Showing event status"); if (dialog_) delete dialog_; dialog_ = new jui_helper::JUIDialog(app_->activity); std::ostringstream str; auto begin = response.data.begin(); auto end = response.data.end(); while( begin != end) { str <<begin->second.Name() << ": " << begin->second.Count() << "\n"; begin++; } // Setting up message jui_helper::JUITextView* text = new jui_helper::JUITextView( str.str().c_str()); text->AddRule(jui_helper::LAYOUT_PARAMETER_ALIGN_PARENT_TOP, jui_helper::LAYOUT_PARAMETER_TRUE); text->AddRule(jui_helper::LAYOUT_PARAMETER_CENTER_IN_PARENT, jui_helper::LAYOUT_PARAMETER_TRUE); text->SetAttribute("TextSize", jui_helper::ATTRIBUTE_UNIT_SP, 18.f); // OK Button jui_helper::JUIButton *button = new jui_helper::JUIButton("OK"); button->SetCallback( [this](jui_helper::JUIView * view, const int32_t message) { switch (message) { case jui_helper::JUICALLBACK_BUTTON_UP: { dialog_->Close(); } } }); button->AddRule(jui_helper::LAYOUT_PARAMETER_CENTER_IN_PARENT, jui_helper::LAYOUT_PARAMETER_TRUE); button->AddRule(jui_helper::LAYOUT_PARAMETER_BELOW, text); dialog_->SetCallback( jui_helper::JUICALLBACK_DIALOG_CANCELLED, [this](jui_helper::JUIDialog * dialog, const int32_t message) { LOGI("Dialog cancelled"); dialog_->Close(); EnableUI(true); }); dialog_->SetCallback( jui_helper::JUICALLBACK_DIALOG_DISMISSED, [this](jui_helper::JUIDialog * dialog, const int32_t message) { LOGI("Dialog dismissed"); dialog_->Close(); EnableUI(true); }); dialog_->SetAttribute("Title", "Event status"); dialog_->AddView(text); dialog_->AddView(button); dialog_->Show(); LOGI("Showing dialog"); }); } else EnableUI(true); }); }
status_t AbstractSingleFileServerProcess::RunInternal() { if (Logger::IsInfoEnabled()) printf("[%s] will fetch data\n", Name()); BPath localPath; status_t result = GetLocalPath(localPath); if (result != B_OK) return result; BString urlPathComponent = UrlPathComponent(); if (IsSuccess(result) && HasOption(SERVER_PROCESS_DROP_CACHE)) result = DeleteLocalFile(localPath); bool hasData = false; off_t size; if (IsSuccess(result)) result = StorageUtils::ExistsObject(localPath, &hasData, NULL, &size); hasData = hasData && size > 0; if (IsSuccess(result) && ShouldAttemptNetworkDownload(hasData)) { result = DownloadToLocalFileAtomically( localPath, ServerSettings::CreateFullUrl(urlPathComponent)); if (!IsSuccess(result)) { if (hasData) { printf("[%s] failed to update data, but have old data " "anyway so carry on with that\n", Name()); result = B_OK; } else { printf("[%s] failed to obtain data\n", Name()); } } else { if (Logger::IsInfoEnabled()) printf("[%s] did fetch data\n", Name()); } } if (IsSuccess(result)) { status_t hasDataResult = StorageUtils::ExistsObject( localPath, &hasData, NULL, &size); hasData = hasData && size > 0; if (hasDataResult == B_OK && !hasData) result = HD_ERR_NO_DATA; } if (IsSuccess(result)) { printf("[%s] will process data\n", Name()); result = ProcessLocalData(); switch (result) { case B_OK: printf("[%s] did process data\n", Name()); break; default: MoveDamagedFileAside(localPath); break; } } return result; }