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()
get1 := get.NewGetItem()
get1.TableName = "test-godynamo-livetest"
// make sure this item has actually been inserted previously
get1.Key["TheHashKey"] = &attributevalue.AttributeValue{S: "AHashKey264"}
get1.Key["TheRangeKey"] = &attributevalue.AttributeValue{N: "264"}
body, code, err := get1.EndpointReq()
if err != nil || code != http.StatusOK {
fmt.Printf("get failed %d %v %s\n", code, err, body)
}
fmt.Printf("%v\n%v\n,%v\n", string(body), code, err)
resp := get.NewResponse()
um_err := json.Unmarshal([]byte(body), resp)
if um_err != nil {
log.Fatal(um_err)
}
j, jerr := json.Marshal(resp)
if jerr != nil {
log.Fatal(jerr)
}
fmt.Printf("RESP:%s\n", string(j))
// Try converting the Response to a ResponseItemJSON
c, cerr := resp.ToResponseItemJSON()
if cerr != nil {
log.Fatal(cerr)
}
jc, jcerr := json.Marshal(c)
if jcerr != nil {
log.Fatal(jcerr)
}
fmt.Printf("JSON:%s\n", string(jc))
}
func main() {
// this is the same as item-operations-livetest except here we demonstrate using a parameterized conf
home := os.Getenv("HOME")
home_conf_file := home + string(os.PathSeparator) + "." + conf.CONF_NAME
home_conf, home_conf_err := conf_file.ReadConfFile(home_conf_file)
if home_conf_err != nil {
panic("cannot read conf from " + home_conf_file)
}
home_conf.ConfLock.RLock()
if home_conf.Initialized == false {
panic("conf struct has not been initialized")
}
// launch a background poller to keep conns to aws alive
if home_conf.Network.DynamoDB.KeepAlive {
log.Printf("launching background keepalive")
go keepalive.KeepAlive([]string{})
}
// deal with iam, or not
if home_conf.UseIAM {
iam_ready_chan := make(chan bool)
go conf_iam.GoIAM(iam_ready_chan)
_ = <-iam_ready_chan
}
home_conf.ConfLock.RUnlock()
tn := "test-godynamo-livetest"
tablename1 := tn
fmt.Printf("tablename1: %s\n", tablename1)
var code int
var err error
var body []byte
// INSERT SINGLE ITEM
hk := "a-hash-key"
rk := "1"
put1 := put_item.NewPutItem()
put1.TableName = tablename1
av1 := attributevalue.NewAttributeValue()
av2 := attributevalue.NewAttributeValue()
av3 := attributevalue.NewAttributeValue()
av4 := attributevalue.NewAttributeValue()
av5 := attributevalue.NewAttributeValue()
av6 := attributevalue.NewAttributeValue()
av7 := attributevalue.NewAttributeValue()
av1.S = hk
av2.N = rk
av3.InsertSS("pk1_a")
av3.InsertSS("pk1_c")
av4.InsertNS("1")
av4.InsertNS_float64(2)
av4.InsertNS("3")
av4.InsertNS("-7.2432342")
av5.N = "1"
av6.B = base64.StdEncoding.EncodeToString([]byte("hello"))
av7.InsertBS(base64.StdEncoding.EncodeToString([]byte("hello")))
av7.InsertBS(base64.StdEncoding.EncodeToString([]byte("there")))
put1.Item["TheHashKey"] = av1
put1.Item["TheRangeKey"] = av2
put1.Item["stringlist"] = av3
put1.Item["numlist"] = av4
put1.Item["num"] = av5
put1.Item["byte"] = av6
put1.Item["bytelist"] = av7
body, code, err = put1.EndpointReqWithConf(home_conf)
if err != nil || code != http.StatusOK {
fmt.Printf("put1 failed %d %v %s\n", code, err, string(body))
os.Exit(1)
}
fmt.Printf("%v\n%v\n,%v\n", string(body), code, err)
// GET THAT ITEM
get1 := get_item.NewGetItem()
get1.TableName = tablename1
get1.Key["TheHashKey"] = av1
get1.Key["TheRangeKey"] = av2
get_json, get_json_err := json.Marshal(get1)
if get_json_err != nil {
fmt.Printf("%v\n", get_json_err)
os.Exit(1)
}
fmt.Printf("%s\n", string(get_json))
body, code, err = get1.EndpointReqWithConf(home_conf)
if err != nil || code != http.StatusOK {
fmt.Printf("get failed %d %v %s\n", code, err, string(body))
os.Exit(1)
}
fmt.Printf("%v\n%v\n,%v\n", string(body), code, err)
var gr get_item.Response
um_err := json.Unmarshal([]byte(body), &gr)
if um_err != nil {
fmt.Printf("get resp unmarshal failed %s\n", um_err.Error())
os.Exit(1)
}
fmt.Printf("%v\n", string(body))
// UPDATE THAT ITEM
up1 := update_item.NewUpdateItem()
new_attr_val := "new string here"
up1.TableName = tablename1
up1.Key["TheHashKey"] = av1
up1.Key["TheRangeKey"] = av2
up1.AttributeUpdates = attributevalue.NewAttributeValueUpdateMap()
up_avu := attributevalue.NewAttributeValueUpdate()
up_avu.Action = update_item.ACTION_PUT
up_avu.Value = &attributevalue.AttributeValue{S: new_attr_val}
up1.AttributeUpdates["new_string"] = up_avu
del_avu := attributevalue.NewAttributeValueUpdate()
del_avu.Action = update_item.ACTION_DEL
del_avu.Value = attributevalue.NewAttributeValue()
del_avu.Value.InsertSS("pk1_a")
up1.AttributeUpdates["stringlist"] = del_avu
del2_avu := attributevalue.NewAttributeValueUpdate()
del2_avu.Action = update_item.ACTION_DEL
del2_avu.Value = &attributevalue.AttributeValue{}
up1.AttributeUpdates["byte"] = del2_avu
add_avu := attributevalue.NewAttributeValueUpdate()
add_avu.Action = update_item.ACTION_ADD
add_avu.Value = &attributevalue.AttributeValue{N: "4"}
up1.AttributeUpdates["num"] = add_avu
up1.ReturnValues = update_item.RETVAL_ALL_NEW
update_item_json, update_item_json_err := json.Marshal(up1)
if update_item_json_err != nil {
fmt.Printf("%v\n", update_item_json_err)
os.Exit(1)
}
fmt.Printf("%s\n", string(update_item_json))
body, code, err = up1.EndpointReqWithConf(home_conf)
if err != nil || code != http.StatusOK {
fmt.Printf("update item failed %d %v %s\n", code, err, string(body))
os.Exit(1)
}
fmt.Printf("%v\n%v\n,%v\n", string(body), code, err)
var ur update_item.Response
um_err = json.Unmarshal([]byte(body), &ur)
if um_err != nil {
fmt.Printf("update resp unmarshal failed %s\n", um_err.Error())
os.Exit(1)
}
// GET IT AGAIN
body, code, err = get1.EndpointReqWithConf(home_conf)
if err != nil || code != http.StatusOK {
fmt.Printf("get failed %d %v %s\n", code, err, string(body))
os.Exit(1)
}
fmt.Printf("%v\n%v\n,%v\n", string(body), code, err)
// DELETE THE ITEM
del1 := delete_item.NewDeleteItem()
del1.TableName = tablename1
del1.Key["TheHashKey"] = av1
del1.Key["TheRangeKey"] = av2
del1.ReturnValues = delete_item.RETVAL_ALL_OLD
body, code, err = del1.EndpointReqWithConf(home_conf)
if err != nil || code != http.StatusOK {
fmt.Printf("delete item failed %d %v %s\n", code, err, string(body))
os.Exit(1)
}
fmt.Printf("%v\n%v\n,%v\n", string(body), code, err)
fmt.Printf("PASSED\n")
}
// GetItemHandler relays the GetItem request to Dynamo but first validates it through a local type.
func GetItemHandler(w http.ResponseWriter, req *http.Request) {
if bbpd_runinfo.BBPDAbortIfClosed(w) {
return
}
start := time.Now()
if req.Method != "POST" {
e := "get_item_route.GetItemHandler:method only supports POST"
log.Printf(e)
http.Error(w, e, http.StatusBadRequest)
return
}
pathElts := strings.Split(req.URL.Path, "/")
if len(pathElts) != 2 {
e := "get_item_route.GetItemHandler:cannot parse path."
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("get_item_route.GetItemHandler err reading req body: %s", read_err.Error())
log.Printf(e)
http.Error(w, e, http.StatusInternalServerError)
return
}
g := get.NewGetItem()
um_err := json.Unmarshal(bodybytes, g)
if um_err != nil {
e := fmt.Sprintf("get_item_route.GetItemHandler 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 := g.EndpointReq()
if resp_err != nil {
e := fmt.Sprintf("get_item_route.GetItemHandler:err %s",
resp_err.Error())
log.Printf(e)
http.Error(w, e, http.StatusInternalServerError)
return
}
if ep.HttpErr(code) {
route_response.WriteError(w, code, "get_item_route.GetItemHandler", resp_body)
return
}
mr_err := route_response.MakeRouteResponse(
w,
req,
resp_body,
code,
start,
get.ENDPOINT_NAME)
if mr_err != nil {
e := fmt.Sprintf("get_item_route.GetItemHandler %s",
mr_err.Error())
log.Printf(e)
http.Error(w, e, http.StatusInternalServerError)
return
}
}
func main() {
// this is the same as get-item-livetest except here we demonstrate using a parameterized conf
home := os.Getenv("HOME")
home_conf_file := home + string(os.PathSeparator) + "." + conf.CONF_NAME
home_conf, home_conf_err := conf_file.ReadConfFile(home_conf_file)
if home_conf_err != nil {
panic("cannot read conf from " + home_conf_file)
}
home_conf.ConfLock.RLock()
if home_conf.Initialized == false {
panic("conf struct has not been initialized")
}
// launch a background poller to keep conns to aws alive
if home_conf.Network.DynamoDB.KeepAlive {
log.Printf("launching background keepalive")
go keepalive.KeepAlive([]string{})
}
// deal with iam, or not
if home_conf.UseIAM {
iam_ready_chan := make(chan bool)
go conf_iam.GoIAM(iam_ready_chan)
_ = <-iam_ready_chan
}
home_conf.ConfLock.RUnlock()
get1 := get.NewGetItem()
get1.TableName = "test-godynamo-livetest"
// make sure this item has actually been inserted previously
get1.Key["TheHashKey"] = &attributevalue.AttributeValue{S: "AHashKey264"}
get1.Key["TheRangeKey"] = &attributevalue.AttributeValue{N: "264"}
body, code, err := get1.EndpointReqWithConf(home_conf)
if err != nil || code != http.StatusOK {
fmt.Printf("get failed %d %v %s\n", code, err, body)
}
fmt.Printf("%v\n%v\n,%v\n", string(body), code, err)
resp := get.NewResponse()
um_err := json.Unmarshal([]byte(body), resp)
if um_err != nil {
log.Fatal(um_err)
}
j, jerr := json.Marshal(resp)
if jerr != nil {
log.Fatal(jerr)
}
fmt.Printf("RESP:%s\n", string(j))
// Try converting the Response to a ResponseItemJSON
c, cerr := resp.ToResponseItemJSON()
if cerr != nil {
log.Fatal(cerr)
}
jc, jcerr := json.Marshal(c)
if jcerr != nil {
log.Fatal(jcerr)
}
fmt.Printf("JSON:%s\n", string(jc))
}