AWSError<CoreErrors> AWSErrorMarshaller::Marshall(const Aws::String& exceptionName, const Aws::String& message) const
{
    auto locationOfPound = exceptionName.find_first_of('#');
    auto locationOfColon = exceptionName.find_first_of(':');
    Aws::String formalExceptionName;

    if (locationOfPound != Aws::String::npos)
    {
        formalExceptionName = exceptionName.substr(locationOfPound + 1);       
    }
    else if (locationOfColon != Aws::String::npos)
    {
        formalExceptionName = exceptionName.substr(0, locationOfColon);       
    }
    else
    {
        formalExceptionName = exceptionName;
    }

    AWSError<CoreErrors> error = FindErrorByName(formalExceptionName.c_str());
    if (error.GetErrorType() != CoreErrors::UNKNOWN)
    {
        AWS_LOG_WARN(logTag, "Encountered AWSError\n%s\n%s:", formalExceptionName.c_str(), message.c_str());
        error.SetExceptionName(formalExceptionName);
        error.SetMessage(message);
        return error;
    }    

    AWS_LOG_WARN(logTag, "Encountered Unknown AWSError\n%s\n%s:", exceptionName.c_str(), message.c_str());

    return AWSError<CoreErrors>(CoreErrors::UNKNOWN, exceptionName, "Unable to parse ExceptionName: " + exceptionName + " Message: " + message, false);
}
AWSError<CoreErrors> ElasticTranscoderErrorMarshaller::FindErrorByName(const char* errorName) const
{
  AWSError<CoreErrors> error = ElasticTranscoderErrorMapper::GetErrorForName(errorName);
  if(error.GetErrorType() != CoreErrors::UNKNOWN)
  {
    return error;
  }

  return AWSErrorMarshaller::FindErrorByName(errorName);
}
AWSError<CoreErrors> Route53ErrorMarshaller::FindErrorByName(const char* errorName) const
{
  AWSError<CoreErrors> error = Route53ErrorMapper::GetErrorForName(errorName);
  if(error.GetErrorType() != CoreErrors::UNKNOWN)
  {
    return error;
  }

  return AWSErrorMarshaller::FindErrorByName(errorName);
}
AWSError<CoreErrors> DatabaseMigrationServiceErrorMarshaller::FindErrorByName(const char* errorName) const
{
  AWSError<CoreErrors> error = DatabaseMigrationServiceErrorMapper::GetErrorForName(errorName);
  if(error.GetErrorType() != CoreErrors::UNKNOWN)
  {
    return error;
  }

  return AWSErrorMarshaller::FindErrorByName(errorName);
}
AWSError<CoreErrors> MarketplaceMeteringErrorMarshaller::FindErrorByName(const char* errorName) const
{
  AWSError<CoreErrors> error = MarketplaceMeteringErrorMapper::GetErrorForName(errorName);
  if(error.GetErrorType() != CoreErrors::UNKNOWN)
  {
    return error;
  }

  return AWSErrorMarshaller::FindErrorByName(errorName);
}
AWSError<CoreErrors> ApiGatewayManagementApiErrorMarshaller::FindErrorByName(const char* errorName) const
{
  AWSError<CoreErrors> error = ApiGatewayManagementApiErrorMapper::GetErrorForName(errorName);
  if(error.GetErrorType() != CoreErrors::UNKNOWN)
  {
    return error;
  }

  return AWSErrorMarshaller::FindErrorByName(errorName);
}
AWSError<CoreErrors> ApplicationAutoScalingErrorMarshaller::FindErrorByName(const char* errorName) const
{
  AWSError<CoreErrors> error = ApplicationAutoScalingErrorMapper::GetErrorForName(errorName);
  if(error.GetErrorType() != CoreErrors::UNKNOWN)
  {
    return error;
  }

  return AWSErrorMarshaller::FindErrorByName(errorName);
}
Exemple #8
0
bool DropPlayerDataTable(const std::unique_ptr<DynamoDBClient>& client)
{
    AWS_LOGSTREAM_INFO(SchemaTag, "Dropping old table: " << ExampleTableName);

    DeleteTableRequest deleteTableRequest;
    deleteTableRequest.SetTableName(ExampleTableName);

    DeleteTableOutcome deleteTableOutcome = client->DeleteTable(deleteTableRequest);
    if (!deleteTableOutcome.IsSuccess())
    {
        AWSError<DynamoDBErrors> error = deleteTableOutcome.GetError();
        AWS_LOGSTREAM_ERROR(SchemaTag, "Failed to drop old table: " << ExampleTableName << ": " << error.GetMessage() << "(" << error.GetExceptionName() << ")");
        return false;
    }

    WaitOnTableStatus(client, ExampleTableName, TableStatusWaitUntil::GONE);

    return true;
}
Exemple #9
0
bool CreatePlayerDataTable(const std::unique_ptr<DynamoDBClient>& client)
{
    AWS_LOGSTREAM_INFO(SchemaTag, "Creating " << ExampleTableName << " table");

    // Build the create request
    CreateTableRequest createTableRequest;

    AttributeDefinition identityAttribute;
    identityAttribute.SetAttributeName(IdentityColumnName);
    identityAttribute.SetAttributeType(ScalarAttributeType::S);

    KeySchemaElement identityKeySchemaElement;
    identityKeySchemaElement.WithAttributeName(IdentityColumnName).WithKeyType(KeyType::HASH);

    ProvisionedThroughput provisionedThroughput;
    provisionedThroughput.SetReadCapacityUnits(5);
    provisionedThroughput.SetWriteCapacityUnits(1);

    createTableRequest.AddAttributeDefinitions(identityAttribute);
    createTableRequest.AddKeySchema(identityKeySchemaElement);
    createTableRequest.WithProvisionedThroughput(provisionedThroughput);
    createTableRequest.WithTableName(ExampleTableName);

    CreateTableOutcome createTableOutcome = client->CreateTable(createTableRequest);
    assert(createTableOutcome.IsSuccess() || createTableOutcome.GetError().GetErrorType() == DynamoDBErrors::RESOURCE_IN_USE);

    if(!createTableOutcome.IsSuccess())
    {
        AWSError<DynamoDBErrors> error = createTableOutcome.GetError();
        AWS_LOGSTREAM_ERROR(SchemaTag, "Failed to create table: " << ExampleTableName << ": " << error.GetMessage().c_str() << "(" << error.GetExceptionName() << ")");
        return false;
    }

    // Wait for table to become active
    WaitOnTableStatus(client, ExampleTableName, TableStatusWaitUntil::ACTIVE);

    return true;
}