// Handle is the type's Handler function.
func (h *postArgsHandler) Handle(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
reqObj := ctx.Value("reqObj")
if reqObj == nil {
return fmt.Errorf("missing request object")
}
v := reflect.ValueOf(reqObj).Elem()
t := v.Type()
for i := 0; i < v.NumField(); i++ {
ft := t.Field(i)
fv := v.Field(i).Interface()
switch tfv := fv.(type) {
case nil:
// do nothing
case map[string]interface{}:
store.Set(getFieldName(ft), utils.NewStoreWithData(tfv))
default:
// add it to the store
store.Set(getFieldName(ft), fv)
}
}
return h.handler(ctx, w, req, store)
}
func (r *router) volumesForService(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
filter, err := parseFilter(store)
if err != nil {
return err
}
if filter != nil {
store.Set("filter", filter)
}
service := context.MustService(ctx)
opts := &types.VolumesOpts{
Attachments: store.GetAttachments(),
Opts: store,
}
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
return getFilteredVolumes(ctx, req, store, svc, opts, filter)
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeMapSchema),
http.StatusOK)
}
// Handle is the type's Handler function.
func (h *queryParamsHandler) Handle(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
for k, v := range req.URL.Query() {
ctx.WithFields(log.Fields{
"key": k,
"value": v,
"len(value)": len(v),
}).Debug("query param")
switch len(v) {
case 0:
store.Set(k, true)
case 1:
if len(v[0]) == 0 {
store.Set(k, true)
} else {
if i, err := strconv.ParseInt(v[0], 10, 64); err == nil {
store.Set(k, i)
} else if b, err := strconv.ParseBool(v[0]); err == nil {
store.Set(k, b)
} else {
store.Set(k, v[0])
}
}
default:
store.Set(k, v)
}
}
return h.handler(ctx, w, req, store)
}
func (r *router) volumes(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
filter, err := parseFilter(store)
if err != nil {
return err
}
if filter != nil {
store.Set("filter", filter)
}
var (
tasks = map[string]*types.Task{}
taskIDs []int
opts = &types.VolumesOpts{
Attachments: store.GetAttachments(),
Opts: store,
}
reply = types.ServiceVolumeMap{}
)
for service := range services.StorageServices(ctx) {
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
ctx = context.WithStorageService(ctx, svc)
var err error
if ctx, err = context.WithStorageSession(ctx); err != nil {
return nil, err
}
return getFilteredVolumes(ctx, req, store, svc, opts, filter)
}
task := service.TaskExecute(ctx, run, schema.VolumeMapSchema)
taskIDs = append(taskIDs, task.ID)
tasks[service.Name()] = task
}
run := func(ctx types.Context) (interface{}, error) {
services.TaskWaitAll(ctx, taskIDs...)
for k, v := range tasks {
if v.Error != nil {
return nil, utils.NewBatchProcessErr(reply, v.Error)
}
objMap, ok := v.Result.(types.VolumeMap)
if !ok {
return nil, utils.NewBatchProcessErr(
reply, goof.New("error casting to types.VolumeMap"))
}
reply[k] = objMap
}
return reply, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
services.TaskExecute(ctx, run, schema.ServiceVolumeMapSchema),
http.StatusOK)
}
