示例#1
0
// UpdateItemHandler relays the UpdateItem request to Dynamo but first validates it through a local type.
func UpdateItemHandler(w http.ResponseWriter, req *http.Request) {
	if bbpd_runinfo.BBPDAbortIfClosed(w) {
		return
	}
	start := time.Now()
	if req.Method != "POST" {
		e := "update_item_route.UpdateItemHandler: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 := "update_item_route.UpdateItemHandler:cannot parse path. try /update-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("update_item_route.UpdateItemHandler err reading req body: %s", read_err.Error())
		log.Printf(e)
		http.Error(w, e, http.StatusInternalServerError)
		return
	}

	u := update_item.NewUpdateItem()
	um_err := json.Unmarshal(bodybytes, u)

	if um_err != nil {
		e := fmt.Sprintf("update_item_route.UpdateItemHandler unmarshal err on %s to Update: %s", string(bodybytes), um_err.Error())
		log.Printf(e)
		http.Error(w, e, http.StatusInternalServerError)
		return
	}

	resp_body, code, resp_err := u.EndpointReq()

	if resp_err != nil {
		e := fmt.Sprintf("update_item_route.UpdateItemHandler:err %s",
			resp_err.Error())
		log.Printf(e)
		http.Error(w, e, http.StatusInternalServerError)
		return
	}

	if ep.HttpErr(code) {
		route_response.WriteError(w, code, "update_item_route.UpdateItemHandler", resp_body)
		return
	}

	mr_err := route_response.MakeRouteResponse(
		w,
		req,
		resp_body,
		code,
		start,
		update_item.ENDPOINT_NAME)
	if mr_err != nil {
		e := fmt.Sprintf("update_item_route.UpdateItemHandler %s", mr_err.Error())
		log.Printf(e)
	}
}
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")
}