// IsTableStatusWithConf will test the equality status of a table. func IsTableStatusWithConf(tablename string, status string, c *conf.AWS_Conf) (bool, error) { if !conf.IsValid(c) { return false, errors.New("describe_table.IsTableStatusWithConf: c is not valid") } d := ep.Endpoint(&DescribeTable{TableName: tablename}) s_resp, s_code, s_err := authreq.RetryReq_V4WithConf(d, DESCTABLE_ENDPOINT, c) if s_err != nil { e := fmt.Sprintf("describe_table.IsTableStatus: "+ "check on %s err %s", tablename, s_err.Error()) // if not a 500 problem, don't retry if !ep.ServerErr(s_code) { return false, errors.New(e) } } if s_resp != nil && s_code == http.StatusOK { var resp_json Response um_err := json.Unmarshal([]byte(s_resp), &resp_json) if um_err != nil { um_msg := fmt.Sprintf("describe_table.IsTableStatus:"+ "cannot unmarshal %s, err: %s\ncheck "+ "table creation of %s manually", s_resp, um_err.Error(), tablename) return false, errors.New(um_msg) } return (resp_json.Table.TableStatus == status), nil } e := fmt.Sprintf("describe_table.IsTableStatus:does %s exist?", tablename) return false, errors.New(e) }
// TableExistsWithconf test for table exists: exploit the fact that aws reports 4xx for tables that don't exist. func (desc DescribeTable) TableExistsWithConf(c *conf.AWS_Conf) (bool, error) { if !conf.IsValid(c) { return false, errors.New("describe_table.TableExistsWithConf: c is not valid") } _, code, err := desc.EndpointReqWithConf(c) if err != nil { e := fmt.Sprintf("describe_table.TableExistsWithConf "+ "%s", err.Error()) return false, errors.New(e) } return (code == http.StatusOK), nil }
func (delete_item *DeleteItem) EndpointReqWithConf(c *conf.AWS_Conf) ([]byte, int, error) { if delete_item == nil { return nil, 0, errors.New("delete_item.(DeleteItem)EndpointReqWithConf: receiver is nil") } if !conf.IsValid(c) { return nil, 0, errors.New("delete_item.EndpointReqWithConf: c is not valid") } // returns resp_body,code,err reqJSON, json_err := json.Marshal(delete_item) if json_err != nil { return nil, 0, json_err } return authreq.RetryReqJSON_V4WithConf(reqJSON, DELETEITEM_ENDPOINT, c) }
func (query *Query) EndpointReqWithConf(c *conf.AWS_Conf) ([]byte, int, error) { if query == nil { return nil, 0, errors.New("query.(Query)EndpointReqWithConf: receiver is nil") } if !conf.IsValid(c) { return nil, 0, errors.New("query.EndpointReqWithConf: c is not valid") } // returns resp_body,code,err reqJSON, json_err := json.Marshal(query) if json_err != nil { return nil, 0, json_err } return authreq.RetryReqJSON_V4WithConf(reqJSON, QUERY_ENDPOINT, c) }
func (list_tables *ListTables) EndpointReqWithConf(c *conf.AWS_Conf) ([]byte, int, error) { if list_tables == nil { return nil, 0, errors.New("list_tables.(ListTables)EndpointReqWithConf: receiver is nil") } if !conf.IsValid(c) { return nil, 0, errors.New("list_tables.EndpointReqWithConf: c is not valid") } // returns resp_body,code,err reqJSON, json_err := json.Marshal(list_tables) if json_err != nil { return nil, 0, json_err } return authreq.RetryReqJSON_V4WithConf(reqJSON, LISTTABLE_ENDPOINT, c) }
func (describe_table *DescribeTable) EndpointReqWithConf(c *conf.AWS_Conf) ([]byte, int, error) { if describe_table == nil { return nil, 0, errors.New("describe_table.(DescribeTable)EndpointReqWithConf: receiver is nil") } if !conf.IsValid(c) { return nil, 0, errors.New("describe_table.EndpointReqWithConf: c is not valid") } // returns resp_body,code,err reqJSON, json_err := json.Marshal(describe_table) if json_err != nil { return nil, 0, json_err } return authreq.RetryReqJSON_V4WithConf(reqJSON, DESCTABLE_ENDPOINT, c) }
func (batch_write_item *BatchWriteItem) EndpointReqWithConf(c *conf.AWS_Conf) ([]byte, int, error) { if batch_write_item == nil { return nil, 0, errors.New("batch_write_item.(BatchWriteItem)EndpointReqWithConf: receiver is nil") } if !conf.IsValid(c) { return nil, 0, errors.New("batch_write_item.EndpointReqWithConf: c is not valid") } // returns resp_body,code,err reqJSON, json_err := json.Marshal(batch_write_item) if json_err != nil { return nil, 0, json_err } return authreq.RetryReqJSON_V4WithConf(reqJSON, BATCHWRITE_ENDPOINT, c) }
func (scan *Scan) EndpointReqWithConf(c *conf.AWS_Conf) ([]byte, int, error) { if scan == nil { return nil, 0, errors.New("scan.(Scan)EndpointReqWithConf: receiver is nil") } if !conf.IsValid(c) { return nil, 0, errors.New("scan.EndpointReqWithConf: c is not valid") } // returns resp_body,code,err reqJSON, json_err := json.Marshal(scan) if json_err != nil { return nil, 0, json_err } return authreq.RetryReqJSON_V4WithConf(reqJSON, SCAN_ENDPOINT, c) }
// DoBatchGet is an endpoint request handler for BatchGetItem that supports arbitrarily-sized // BatchGetItem struct instances. // These are split in a list of conforming BatchGetItem instances // via `Split` and the concurrently dispatched to DynamoDB, // with the resulting responses stitched together. May break your provisioning. func (b *BatchGetItem) DoBatchGetWithConf(c *conf.AWS_Conf) ([]byte, int, error) { if b == nil { return nil, 0, errors.New("batch_get_item.DoBatchGetWithConf: receiver is nil") } if !conf.IsValid(c) { return nil, 0, errors.New("batch_get_item.DoBatchGetWithConf: c is not valid") } bs, split_err := Split(b) if split_err != nil { e := fmt.Sprintf("batch_get_item.DoBatchGet: split failed: %s", split_err.Error()) return nil, 0, errors.New(e) } resps := make(chan ep.Endpoint_Response, len(bs)) for _, bi := range bs { go func(bi_ BatchGetItem) { body, code, err := bi_.RetryBatchGetWithConf(0, c) resps <- ep.Endpoint_Response{Body: body, Code: code, Err: err} }(bi) } combined_resp := NewResponse() for i := 0; i < len(bs); i++ { resp := <-resps if resp.Err != nil { return nil, 0, resp.Err } else if resp.Code != http.StatusOK { e := fmt.Sprintf("batch_get_item.DoBatchGetWithConf (%d): code %d", i, resp.Code) return nil, resp.Code, errors.New(e) } else { var r Response um_err := json.Unmarshal(resp.Body, &r) if um_err != nil { e := fmt.Sprintf("batch_get_item.DoBatchGetWithConf (%d): %s on \n%s", i, um_err.Error(), string(resp.Body)) return nil, 0, errors.New(e) } // merge the responses from this call and the recursive one _ = combineResponseMetadata(combined_resp, &r) _ = combineResponses(combined_resp, &r) } } body, marshal_err := json.Marshal(*combined_resp) if marshal_err != nil { return nil, 0, marshal_err } return body, http.StatusOK, nil }
// PollTableStatusWithConf allows the caller to poll a table for a specific status. func PollTableStatusWithConf(tablename string, status string, tries int, c *conf.AWS_Conf) (bool, error) { if !conf.IsValid(c) { return false, errors.New("describe_table.PollTableStatusWithConf: c is not valid") } // aws docs informs us to poll the describe endpoint until the table // "status" is status for this tablename wait := time.Duration(2 * time.Second) for i := 0; i < tries; i++ { active, err := IsTableStatusWithConf(tablename, status, c) if err != nil { e := fmt.Sprintf("describe_table.PollStatus:%s", err.Error()) return false, errors.New(e) } if active { return active, nil } time.Sleep(wait) // wait for table to become ACTIVE } return false, nil }
// RawReqWithConf will sign and transmit the request to the AWS DynamoDB endpoint. // reqJSON is the json request // amzTarget is the dynamoDB endpoint // c is the configuration struct // returns []byte respBody, string aws reqID, int http code, error func RawReqWithConf(reqJSON []byte, amzTarget string, c *conf.AWS_Conf) ([]byte, string, int, error) { if !conf.IsValid(c) { return nil, "", 0, errors.New("auth_v4.RawReqWithConf: conf not valid") } // shadow conf vars in a read lock to minimize contention var our_c conf.AWS_Conf cp_err := our_c.Copy(c) if cp_err != nil { return nil, "", 0, cp_err } return rawReqAll( reqJSON, amzTarget, our_c.UseIAM, our_c.Network.DynamoDB.URL, our_c.Network.DynamoDB.Host, our_c.Network.DynamoDB.Port, our_c.Network.DynamoDB.Zone, our_c.IAM.Credentials.Secret, our_c.IAM.Credentials.AccessKey, our_c.IAM.Credentials.Token, our_c.Auth.Secret, our_c.Auth.AccessKey) }