// Executes ListTables assuming it were requested with the POST method. func listTables_POST_Handler(w http.ResponseWriter, req *http.Request) { start := time.Now() pathElts := strings.Split(req.URL.Path, "/") if len(pathElts) != 2 { e := "list_tables_route.listTables_POST_Handler:cannot parse path. try /batch-get-item" log.Printf(e) http.Error(w, e, http.StatusBadRequest) return } bodybytes, read_err := ioutil.ReadAll(req.Body) req.Body.Close() if read_err != nil && read_err != io.EOF { e := fmt.Sprintf("list_tables_route.listTables_POST_Handler err reading req body: %s", read_err.Error()) log.Printf(e) http.Error(w, e, http.StatusInternalServerError) return } var l list.List um_err := json.Unmarshal(bodybytes, &l) if um_err != nil { e := fmt.Sprintf("list_tables_route.listTables_POST_Handler unmarshal err on %s to Get %s", string(bodybytes), um_err.Error()) log.Printf(e) http.Error(w, e, http.StatusInternalServerError) return } resp_body, code, resp_err := l.EndpointReq() if resp_err != nil { e := fmt.Sprintf("list_table_route.ListTable_POST_Handler:err %s", resp_err.Error()) log.Printf(e) http.Error(w, e, http.StatusInternalServerError) return } if ep.HttpErr(code) { route_response.WriteError(w, code, "list_table_route.ListTable_POST_Handler", resp_body) return } mr_err := route_response.MakeRouteResponse( w, req, resp_body, code, start, list.ENDPOINT_NAME) if mr_err != nil { e := fmt.Sprintf("list_tables_route.listTables_POST_Handler %s", mr_err.Error()) log.Printf(e) http.Error(w, e, http.StatusInternalServerError) return } }
func main() { // conf file must be read in before anything else, to initialize permissions etc conf_file.Read() if conf.Vals.Initialized == false { panic("the conf.Vals global conf struct has not been initialized") } // deal with iam, or not iam_ready_chan := make(chan bool) go conf_iam.GoIAM(iam_ready_chan) iam_ready := <-iam_ready_chan if iam_ready { fmt.Printf("using iam\n") } else { fmt.Printf("not using iam\n") } tn := "test-godynamo-livetest" tablename1 := tn fmt.Printf("tablename1: %s\n", tablename1) var code int var err error var body string // DELETE THE TABLE var del_table1 delete_table.Request del_table1.TableName = tablename1 _, code, err = del_table1.EndpointReq() if err != nil || code != http.StatusOK { fmt.Printf("fail delete %d %v %s\n", code, err, body) os.Exit(1) } // List TABLES var l list.List l.ExclusiveStartTableName = "" l.Limit = 100 lbody, lcode, lerr := l.EndpointReq() fmt.Printf("%v\n%v\n,%v\n", lbody, lcode, lerr) }
func main() { conf_file.Read() if conf.Vals.Initialized == false { panic("the conf.Vals global conf struct has not been initialized") } iam_ready_chan := make(chan bool) go conf_iam.GoIAM(iam_ready_chan) iam_ready := <-iam_ready_chan if iam_ready { fmt.Printf("using iam\n") } else { fmt.Printf("not using iam\n") } tablename1 := "test-godynamo-livetest" fmt.Printf("tablename: %s\n", tablename1) var code int var err error var body string // CREATE TABLE var create1 create.Create create1.TableName = tablename1 create1.ProvisionedThroughput.ReadCapacityUnits = 100 create1.ProvisionedThroughput.WriteCapacityUnits = 100 create1.AttributeDefinitions = append(create1.AttributeDefinitions, ep.AttributeDefinition{AttributeName: "TheHashKey", AttributeType: ep.S}) create1.AttributeDefinitions = append(create1.AttributeDefinitions, ep.AttributeDefinition{AttributeName: "TheRangeKey", AttributeType: ep.N}) create1.AttributeDefinitions = append(create1.AttributeDefinitions, ep.AttributeDefinition{AttributeName: "AnAttrName", AttributeType: ep.S}) create1.KeySchema = append(create1.KeySchema, ep.KeyDefinition{AttributeName: "TheHashKey", KeyType: ep.HASH}) create1.KeySchema = append(create1.KeySchema, ep.KeyDefinition{AttributeName: "TheRangeKey", KeyType: ep.RANGE}) lsi := ep.NewLocalSecondaryIndex() lsi.IndexName = "AnAttrIndex" lsi.Projection.ProjectionType = ep.KEYS_ONLY lsi.KeySchema = append(lsi.KeySchema, ep.KeyDefinition{AttributeName: "TheHashKey", KeyType: ep.HASH}) lsi.KeySchema = append(lsi.KeySchema, ep.KeyDefinition{AttributeName: "AnAttrName", KeyType: ep.RANGE}) create1.LocalSecondaryIndexes = append(create1.LocalSecondaryIndexes, *lsi) create_json, create_json_err := json.Marshal(create1) if create_json_err != nil { fmt.Printf("%v\n", create_json_err) os.Exit(1) } fmt.Printf("%s\n", string(create_json)) fmt.Printf("%v\n", create1) cbody, ccode, cerr := create1.EndpointReq() fmt.Printf("%v\n%v\n,%v\n", cbody, ccode, cerr) var desc1 desc.Describe desc1.TableName = tablename1 body, code, err = desc1.EndpointReq() fmt.Printf("desc:%v\n%v\n,%v\n", body, code, err) // WAIT FOR IT TO BE ACTIVE fmt.Printf("checking for ACTIVE status for table....\n") active, poll_err := desc.PollTableStatus(tablename1, desc.ACTIVE, 100) if poll_err != nil { fmt.Printf("poll1:%v\n", poll_err) os.Exit(1) } fmt.Printf("ACTIVE:%v\n", active) // List TABLES var l list.List l.ExclusiveStartTableName = "" l.Limit = 100 lbody, lcode, lerr := l.EndpointReq() fmt.Printf("%v\n%v\n,%v\n", lbody, lcode, lerr) }
// Executes ListTables assuming it were requested with the GET method. func listTables_GET_Handler(w http.ResponseWriter, req *http.Request) { start := time.Now() pathElts := strings.Split(req.URL.Path, "/") if len(pathElts) != 2 { e := "list_table_route.ListTablesHandler:cannot parse path." + "try /list?ExclusiveStartTableName=$T&Limit=$L" log.Printf(e) http.Error(w, e, http.StatusBadRequest) return } queryMap := make(map[string]string) for k, v := range req.URL.Query() { queryMap[strings.ToLower(k)] = v[0] } q_estn, estn_exists := queryMap[strings.ToLower(list.EXCLUSIVE_START_TABLE_NAME)] estn := "" if estn_exists { estn = q_estn } q_limit, limit_exists := queryMap[strings.ToLower(list.LIMIT)] limit := uint64(0) if limit_exists { limit_conv, conv_err := strconv.ParseUint(q_limit, 10, 64) if conv_err != nil { e := fmt.Sprintf("list_table_route.listTables_GET_Handler bad limit %s", q_limit) log.Printf(e) } else { limit = limit_conv if limit > DEFAULT_LIMIT { e := fmt.Sprintf("list_table_route.listTables_GET_Handler: high limit %d", limit_conv) log.Printf(e) limit = DEFAULT_LIMIT } } } l := list.List{ Limit: limit, ExclusiveStartTableName: estn} resp_body, code, resp_err := l.EndpointReq() if resp_err != nil { e := fmt.Sprintf("list_table_route.ListTable_GET_Handler:err %s", resp_err.Error()) log.Printf(e) http.Error(w, e, http.StatusInternalServerError) return } if ep.HttpErr(code) { route_response.WriteError(w, code, "list_table_route.ListTable_GET_Handler", resp_body) return } mr_err := route_response.MakeRouteResponse( w, req, resp_body, code, start, list.ENDPOINT_NAME) if mr_err != nil { e := fmt.Sprintf("list_table_route.listTable_GET_Handler %s", mr_err.Error()) log.Printf(e) } }
func main() { // conf file must be read in before anything else, to initialize permissions etc conf_file.Read() if conf.Vals.Initialized == false { panic("the conf.Vals global conf struct has not been initialized") } // deal with iam, or not iam_ready_chan := make(chan bool) go conf_iam.GoIAM(iam_ready_chan) iam_ready := <-iam_ready_chan if iam_ready { fmt.Printf("using iam\n") } else { fmt.Printf("not using iam\n") } tn := "test-godynamo-livetest" tablename1 := tn fmt.Printf("tablename1: %s\n", tablename1) var code int var err error var body string var update_table1 update_table.Request update_table1.TableName = tablename1 update_table1.ProvisionedThroughput.ReadCapacityUnits = 200 update_table1.ProvisionedThroughput.WriteCapacityUnits = 200 body, code, err = update_table1.EndpointReq() if err != nil || code != http.StatusOK { fmt.Printf("update table failed %d %v %s\n", code, err, body) os.Exit(1) } // WAIT FOR THE PROVISIONING TO FINISH fmt.Printf("checking for ACTIVE status for update....\n") active, poll_err := desc.PollTableStatus(tablename1, desc.ACTIVE, 100) if poll_err != nil { fmt.Printf("poll1:%v\n", poll_err) os.Exit(1) } fmt.Printf("ACTIVE:%v\n", active) var desc1 desc.Describe desc1.TableName = tablename1 body, code, err = desc1.EndpointReq() fmt.Printf("desc:%v\n%v\n,%v\n", body, code, err) // WAIT FOR IT TO BE ACTIVE fmt.Printf("checking for ACTIVE status for table....\n") active, poll_err = desc.PollTableStatus(tablename1, desc.ACTIVE, 100) if poll_err != nil { fmt.Printf("poll1:%v\n", poll_err) os.Exit(1) } fmt.Printf("ACTIVE:%v\n", active) // List TABLES var l list.List l.ExclusiveStartTableName = "" l.Limit = 100 lbody, lcode, lerr := l.EndpointReq() fmt.Printf("%v\n%v\n,%v\n", lbody, lcode, lerr) }
func main() { conf_file.Read() conf.Vals.ConfLock.RLock() if conf.Vals.Initialized == false { panic("the conf.Vals global conf struct has not been initialized") } // launch a background poller to keep conns to aws alive if conf.Vals.Network.DynamoDB.KeepAlive { log.Printf("launching background keepalive") go keepalive.KeepAlive([]string{}) } // deal with iam, or not if conf.Vals.UseIAM { iam_ready_chan := make(chan bool) go conf_iam.GoIAM(iam_ready_chan) _ = <-iam_ready_chan } conf.Vals.ConfLock.RUnlock() tn := "test-godynamo-livetest" tablename1 := tn fmt.Printf("tablename1: %s\n", tablename1) var code int var err error var body []byte update_table1 := update_table.NewUpdateTable() update_table1.TableName = tablename1 update_table1.ProvisionedThroughput.ReadCapacityUnits = 200 update_table1.ProvisionedThroughput.WriteCapacityUnits = 200 body, code, err = update_table1.EndpointReq() if err != nil || code != http.StatusOK { fmt.Printf("update table failed %d %v %s\n", code, err, string(body)) os.Exit(1) } // WAIT FOR THE PROVISIONING TO FINISH fmt.Printf("checking for ACTIVE status for update....\n") active, poll_err := desc.PollTableStatus(tablename1, desc.ACTIVE, 100) if poll_err != nil { fmt.Printf("poll1:%v\n", poll_err) os.Exit(1) } fmt.Printf("ACTIVE:%v\n", active) var desc1 desc.DescribeTable desc1.TableName = tablename1 body, code, err = desc1.EndpointReq() if err != nil || code != http.StatusOK { fmt.Printf("desc failed %d %v %s\n", code, err, string(body)) os.Exit(1) } fmt.Printf("desc:%v\n%v\n,%v\n", string(body), code, err) // WAIT FOR IT TO BE ACTIVE fmt.Printf("checking for ACTIVE status for table....\n") active, poll_err = desc.PollTableStatus(tablename1, desc.ACTIVE, 100) if poll_err != nil { fmt.Printf("poll1:%v\n", poll_err) os.Exit(1) } fmt.Printf("ACTIVE:%v\n", active) // List TABLES var l list.List l.ExclusiveStartTableName = "" l.Limit = 100 body, code, err = l.EndpointReq() if err != nil || code != http.StatusOK { fmt.Printf("list failed %d %v %s\n", code, err, string(body)) os.Exit(1) } fmt.Printf("%v\n%v\n,%v\n", string(body), code, err) }
func main() { conf_file.Read() conf.Vals.ConfLock.RLock() if conf.Vals.Initialized == false { panic("the conf.Vals global conf struct has not been initialized") } // launch a background poller to keep conns to aws alive if conf.Vals.Network.DynamoDB.KeepAlive { log.Printf("launching background keepalive") go keepalive.KeepAlive([]string{}) } // deal with iam, or not if conf.Vals.UseIAM { iam_ready_chan := make(chan bool) go conf_iam.GoIAM(iam_ready_chan) _ = <-iam_ready_chan } conf.Vals.ConfLock.RUnlock() tablename1 := "test-godynamo-livetest" fmt.Printf("tablename: %s\n", tablename1) var code int var err error var body []byte // CREATE TABLE create1 := create.NewCreateTable() create1.TableName = tablename1 create1.ProvisionedThroughput.ReadCapacityUnits = 100 create1.ProvisionedThroughput.WriteCapacityUnits = 100 create1.AttributeDefinitions = append(create1.AttributeDefinitions, attributedefinition.AttributeDefinition{AttributeName: "TheHashKey", AttributeType: ep.S}) create1.AttributeDefinitions = append(create1.AttributeDefinitions, attributedefinition.AttributeDefinition{AttributeName: "TheRangeKey", AttributeType: ep.N}) create1.AttributeDefinitions = append(create1.AttributeDefinitions, attributedefinition.AttributeDefinition{AttributeName: "AnAttrName", AttributeType: ep.S}) create1.KeySchema = append(create1.KeySchema, keydefinition.KeyDefinition{AttributeName: "TheHashKey", KeyType: ep.HASH}) create1.KeySchema = append(create1.KeySchema, keydefinition.KeyDefinition{AttributeName: "TheRangeKey", KeyType: ep.RANGE}) lsi := localsecondaryindex.NewLocalSecondaryIndex() lsi.IndexName = "AnAttrIndex" lsi.Projection.ProjectionType = aws_strings.KEYS_ONLY lsi.KeySchema = append(lsi.KeySchema, keydefinition.KeyDefinition{AttributeName: "TheHashKey", KeyType: ep.HASH}) lsi.KeySchema = append(lsi.KeySchema, keydefinition.KeyDefinition{AttributeName: "AnAttrName", KeyType: ep.RANGE}) create1.LocalSecondaryIndexes = append(create1.LocalSecondaryIndexes, *lsi) create_json, create_json_err := json.Marshal(create1) if create_json_err != nil { fmt.Printf("%v\n", create_json_err) os.Exit(1) } fmt.Printf("%s\n", string(create_json)) fmt.Printf("%v\n", create1) body, code, err = create1.EndpointReq() fmt.Printf("%v\n%v\n,%v\n", string(body), code, err) if err != nil || code != http.StatusOK { fmt.Printf("create failed %d %v %s\n", code, err, string(body)) os.Exit(1) } var desc1 desc.Describe desc1.TableName = tablename1 body, code, err = desc1.EndpointReq() fmt.Printf("desc:%v\n%v\n,%v\n", string(body), code, err) if err != nil || code != http.StatusOK { fmt.Printf("desc failed %d %v %s\n", code, err, string(body)) os.Exit(1) } // WAIT FOR IT TO BE ACTIVE fmt.Printf("checking for ACTIVE status for table....\n") active, poll_err := desc.PollTableStatus(tablename1, desc.ACTIVE, 100) if poll_err != nil { fmt.Printf("poll1:%v\n", poll_err) os.Exit(1) } fmt.Printf("ACTIVE:%v\n", active) // List TABLES var l list.List l.ExclusiveStartTableName = "" l.Limit = 100 body, code, err = l.EndpointReq() if err != nil || code != http.StatusOK { fmt.Printf("list failed %d %v %s\n", code, err, string(body)) os.Exit(1) } fmt.Printf("%v\n%v\n,%v\n", string(body), code, err) }