func main() {
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")
}
tn := "test-godynamo-livetest"
q := query.NewQuery()
q.TableName = tn
q.Select = ep.SELECT_ALL
k_v1 := fmt.Sprintf("AHashKey%d", 100)
kc := condition.NewCondition()
kc.AttributeValueList = make([]*attributevalue.AttributeValue, 1)
kc.AttributeValueList[0] = &attributevalue.AttributeValue{S: k_v1}
kc.ComparisonOperator = query.OP_EQ
q.Limit = 10000
q.KeyConditions["TheHashKey"] = kc
json, _ := json.Marshal(q)
fmt.Printf("JSON:%s\n", string(json))
body, code, err := q.EndpointReqWithConf(home_conf)
if err != nil || code != http.StatusOK {
fmt.Printf("query failed %d %v %s\n", code, err, body)
}
fmt.Printf("%v\n%v\n%v\n", string(body), code, err)
}
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"
q := query.NewQuery()
q.TableName = tn
q.Select = ep.SELECT_ALL
k_v1 := fmt.Sprintf("AHashKey%d", 100)
var kc query.KeyCondition
kc.AttributeValueList = make([]ep.AttributeValue, 1)
kc.AttributeValueList[0] = ep.AttributeValue{S: k_v1}
kc.ComparisonOperator = query.OP_EQ
q.Limit = 10000
q.KeyConditions["TheHashKey"] = kc
json, _ := json.Marshal(q)
fmt.Printf("JSON:%s\n", string(json))
body, code, err := q.EndpointReq()
fmt.Printf("%v\n%v\n%v\n", 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()
tn := "test-godynamo-livetest"
q := query.NewQuery()
q.TableName = tn
q.Select = ep.SELECT_ALL
k_v1 := fmt.Sprintf("AHashKey%d", 100)
kc := condition.NewCondition()
kc.AttributeValueList = make([]*attributevalue.AttributeValue, 1)
kc.AttributeValueList[0] = &attributevalue.AttributeValue{S: k_v1}
kc.ComparisonOperator = query.OP_EQ
q.Limit = 10000
q.KeyConditions["TheHashKey"] = kc
json, _ := json.Marshal(q)
fmt.Printf("JSON:%s\n", string(json))
body, code, err := q.EndpointReq()
if err != nil || code != http.StatusOK {
fmt.Printf("query failed %d %v %s\n", code, err, body)
}
fmt.Printf("%v\n%v\n%v\n", string(body), code, err)
}
// QueryHandler relays the Query request to Dynamo but first validates it through a local type.
func QueryHandler(w http.ResponseWriter, req *http.Request) {
if bbpd_runinfo.BBPDAbortIfClosed(w) {
return
}
start := time.Now()
if req.Method != "POST" {
e := "query_route.QueryHandler: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 := "query_route.QueryHandler:cannot parse path. try /create, call as POST"
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("query_route.QueryHandler err reading req body: %s", read_err.Error())
log.Printf(e)
http.Error(w, e, http.StatusInternalServerError)
return
}
q := query.NewQuery()
um_err := json.Unmarshal(bodybytes, q)
if um_err != nil {
e := fmt.Sprintf("query_route.QueryHandler unmarshal err on %s to Create: %s", string(bodybytes), um_err.Error())
log.Printf(e)
http.Error(w, e, http.StatusInternalServerError)
return
}
resp_body, code, resp_err := q.EndpointReq()
if resp_err != nil {
e := fmt.Sprintf("query_route.QueryHandler:err %s",
resp_err.Error())
log.Printf(e)
http.Error(w, e, http.StatusInternalServerError)
return
}
if ep.HttpErr(code) {
route_response.WriteError(w, code, "query_route.QueryHandler", resp_body)
return
}
mr_err := route_response.MakeRouteResponse(
w,
req,
resp_body,
code,
start,
query.ENDPOINT_NAME)
if mr_err != nil {
e := fmt.Sprintf("query_route.QueryHandler %s", mr_err.Error())
log.Printf(e)
}
}
