func NewInventoryRequestResponder(st store.ObjectStore) *InventoryRequestResponder {
x := &InventoryRequestResponder{APIResponder{path: RFPPATH, processorMap: make(map[string]RequestProcessor, 4)}}
x.AddProcessor("POST", &InventoryRequestProcessor{StoreManager{store: st, pathKeys: util.Unmunge(RFPPATH)}})
x.AddProcessor("GET", &GenericGetProcessor{StoreManager{store: st, pathKeys: util.Unmunge(RFPPATH)}})
x.AddProcessor("DELETE", &GenericDeleteProcessor{StoreManager{store: st, pathKeys: util.Unmunge(RFPPATH)}})
return x
}
func NewCallbackReceiver(ts *testing.T) *CallbackReceiver {
x := &CallbackReceiver{APIResponder: APIResponder{path: CB_PATH, processorMap: make(map[string]RequestProcessor, 4)}}
cp := CallbackProcessor{t: ts}
cp.pathKeys = util.Unmunge(CB_PATH)
x.AddProcessor("POST", &cp)
return x
}
func (r APIResponder) Handle(req *http.Request) (int, []byte) {
log.Println("APIResponder.Handle entered")
method := req.Method
u := req.URL
pathTokens := util.Unmunge(u.Path)
queryTokens := strings.Split(u.RawQuery, "&")
// Read the request body
buffer, err := r.ReadBody(req)
if err != nil {
return BAD, nil
}
log.Println("APIResponder.Handle: body read")
pr := r.getProcessor(method)
if &pr == nil {
return BAD, nil
}
obj, err := pr.Unmarshal(buffer)
if err != nil {
return ERROR, nil
}
if obj != nil {
log.Printf("Have object of type %T", obj)
log.Printf("Received message with RequestId %s:\n%s\n", obj.GetKey(), buffer)
} else {
log.Println("Request did not include a body")
}
cerr := pr.ValidateRequest(pathTokens, queryTokens, obj)
if cerr != nil {
log.Printf("Invalid %s request: %s\n", method, cerr.Error())
return cerr.Code(), nil
}
// Process it
responses, cerr := pr.ProcessRequest(pathTokens, queryTokens, obj, &r)
if cerr != nil {
log.Printf("Error processing %s request: %s\n", method, cerr.Error())
return cerr.Code(), nil
}
// Marshal the results into the response body
if len(responses) > 0 {
buffer, err = objects.Marshal(responses)
log.Printf("Marshalling %d objects into response as \n%s", len(responses), buffer)
}
if err != nil {
log.Printf("Error marshalling response: %s\n", err.Error())
return ERROR, nil
}
log.Printf("%s Request handled", method)
return OK, buffer
}
func (s MapStore) EraseAll(keys []string) error {
if len(keys) == 0 {
return errors.New("No keys")
}
for key, _ := range s.store {
toks := util.Unmunge(key)
if s.isMatch(keys, toks) {
s.Erase(toks)
}
}
return nil
}
func (n *Node) FindLeaf(path string) *Node {
sp := util.Unmunge(path)
cnt := len(sp)
currNode := n
for i := 1; i < cnt; i++ {
nn := currNode.FindChild(sp[i])
if nn == nil {
return currNode
}
currNode = nn
}
return currNode
}
func (s MapStore) GetAll(keys []string) ([]objects.Storable, error) {
if len(keys) == 0 {
return nil, errors.New("No keys")
}
ret := make([]objects.Storable, 0, 10)
for key, value := range s.store {
toks := util.Unmunge(key)
if s.isMatch(keys, toks) {
ret = append(ret, value)
}
}
return ret, nil
}
func TestSplit(t *testing.T) {
val := "/Orders/Availability/"
arr := util.Unmunge(val)
t.Logf("Split %s into: ", val)
for _, tok := range arr {
if len(tok) > 0 {
t.Log(tok)
}
}
if len(arr) != 2 {
t.Fatalf("Wrong number, got %d", len(arr))
}
}
func (n *Node) AddPath(path string) (*Node, error) {
// Need to add code to strip any trailing /
sp := util.Unmunge(path)
cnt := len(sp)
currNode := n
for i := 1; i < cnt; i++ {
nn := currNode.FindChild(sp[i])
if nn == nil {
log.Printf("Adding node %s to parent %s", sp[i], currNode.path)
nn = newNode(sp[i])
currNode.Add(nn)
}
currNode = nn
}
return currNode, nil
}