// WriteTask writes a task to a ResponseWriter.
func WriteTask(
ctx types.Context,
config gofig.Config,
w http.ResponseWriter,
store types.Store,
task *types.Task,
okStatus int) error {
if store.GetBool("async") {
WriteJSON(w, http.StatusAccepted, task)
return nil
}
exeTimeoutDur, err := time.ParseDuration(
config.GetString(types.ConfigServerTasksExeTimeout))
if err != nil {
exeTimeoutDur = time.Duration(time.Second * 60)
}
exeTimeout := time.NewTimer(exeTimeoutDur)
select {
case <-services.TaskWaitC(ctx, task.ID):
if task.Error != nil {
return task.Error
}
WriteJSON(w, okStatus, task.Result)
case <-exeTimeout.C:
WriteJSON(w, http.StatusRequestTimeout, task)
}
return nil
}
func (r *router) volumeDetach(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
if _, ok := context.InstanceID(ctx); !ok {
return utils.NewMissingInstanceIDError(service.Name())
}
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
v, err := svc.Driver().VolumeDetach(
ctx,
store.GetString("volumeID"),
&types.VolumeDetachOpts{
Force: store.GetBool("force"),
Opts: store,
})
if err != nil {
return nil, err
}
if v == nil {
return nil, nil
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAvailable
}
return v, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, nil),
http.StatusResetContent)
}
func (r *router) volumeAttach(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
if _, ok := context.InstanceID(ctx); !ok {
return utils.NewMissingInstanceIDError(service.Name())
}
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
v, attTokn, err := svc.Driver().VolumeAttach(
ctx,
store.GetString("volumeID"),
&types.VolumeAttachOpts{
NextDevice: store.GetStringPtr("nextDeviceName"),
Force: store.GetBool("force"),
Opts: store,
})
if err != nil {
return nil, err
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAttached
}
return &types.VolumeAttachResponse{
Volume: v,
AttachToken: attTokn,
}, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeAttachResponseSchema),
http.StatusOK)
}
func toServiceInfo(
ctx types.Context,
service types.StorageService,
store types.Store) (*types.ServiceInfo, error) {
d := service.Driver()
var instance *types.Instance
if store.GetBool("instance") {
if _, ok := context.InstanceID(ctx); !ok {
return nil, utils.NewMissingInstanceIDError(service.Name())
}
var err error
instance, err = d.InstanceInspect(ctx, store)
if err != nil {
return nil, err
}
}
st, err := d.Type(ctx)
if err != nil {
return nil, err
}
nd, err := d.NextDeviceInfo(ctx)
if err != nil {
return nil, err
}
return &types.ServiceInfo{
Name: service.Name(),
Instance: instance,
Driver: &types.DriverInfo{
Name: d.Name(),
Type: st,
NextDevice: nd,
},
}, nil
}
// Unmount will unmount the specified volume by volumeName or volumeID.
func (d *driver) Unmount(
ctx types.Context,
volumeID, volumeName string,
opts types.Store) (*types.Volume, error) {
ctx.WithFields(log.Fields{
"volumeName": volumeName,
"volumeID": volumeID,
"opts": opts}).Info("unmounting volume")
if volumeName == "" && volumeID == "" {
return nil, goof.New("missing volume name or ID")
}
vol, err := d.volumeInspectByIDOrName(
ctx, volumeID, volumeName,
types.VolAttReqWithDevMapOnlyVolsAttachedToInstance, opts)
if err != nil {
return nil, err
}
if len(vol.Attachments) == 0 {
return nil, nil
}
client := context.MustClient(ctx)
inst, err := client.Storage().InstanceInspect(ctx, utils.NewStore())
if err != nil {
return nil, goof.New("problem getting instance ID")
}
var ma *types.VolumeAttachment
for _, att := range vol.Attachments {
if att.InstanceID.ID == inst.InstanceID.ID {
ma = att
break
}
}
if ma == nil {
return nil, goof.New("no attachment found for instance")
}
if ma.DeviceName == "" {
return nil, goof.New("no device name found for attachment")
}
mounts, err := client.OS().Mounts(
ctx, ma.DeviceName, "", opts)
if err != nil {
return nil, err
}
for _, mount := range mounts {
ctx.WithField("mount", mount).Debug("retrieved mount")
}
if len(mounts) > 0 {
for _, mount := range mounts {
ctx.WithField("mount", mount).Debug("unmounting mount point")
err = client.OS().Unmount(ctx, mount.MountPoint, opts)
if err != nil {
return nil, err
}
}
}
vol, err = client.Storage().VolumeDetach(ctx, vol.ID,
&types.VolumeDetachOpts{
Force: opts.GetBool("force"),
Opts: utils.NewStore(),
})
if err != nil {
return nil, err
}
ctx.WithFields(log.Fields{
"vol": vol}).Info("unmounted and detached volume")
return vol, nil
}
func (r *router) volumeDetachAllForService(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
if _, ok := context.InstanceID(ctx); !ok {
return utils.NewMissingInstanceIDError(service.Name())
}
var reply types.VolumeMap = map[string]*types.Volume{}
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
driver := svc.Driver()
volumes, err := driver.Volumes(ctx, &types.VolumesOpts{Opts: store})
if err != nil {
return nil, err
}
for _, volume := range volumes {
v, err := driver.VolumeDetach(
ctx,
volume.ID,
&types.VolumeDetachOpts{
Force: store.GetBool("force"),
Opts: store,
})
if err != nil {
return nil, utils.NewBatchProcessErr(reply, err)
}
if err != nil {
return nil, err
}
if v == nil {
continue
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAvailable
}
reply[v.ID] = v
}
return reply, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeMapSchema),
http.StatusResetContent)
}
func (r *router) volumeDetachAll(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
var (
taskIDs []int
tasks = map[string]*types.Task{}
opts = &types.VolumesOpts{Opts: store}
reply types.ServiceVolumeMap = map[string]types.VolumeMap{}
replyRWL = &sync.Mutex{}
)
for service := range services.StorageServices(ctx) {
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
ctx = context.WithStorageService(ctx, svc)
if _, ok := context.InstanceID(ctx); !ok {
return nil, utils.NewMissingInstanceIDError(service.Name())
}
var err error
if ctx, err = context.WithStorageSession(ctx); err != nil {
return nil, err
}
driver := svc.Driver()
volumes, err := driver.Volumes(ctx, opts)
if err != nil {
return nil, err
}
// check here
var volumeMap types.VolumeMap = map[string]*types.Volume{}
defer func() {
if len(volumeMap) > 0 {
replyRWL.Lock()
defer replyRWL.Unlock()
reply[service.Name()] = volumeMap
}
}()
for _, volume := range volumes {
v, err := driver.VolumeDetach(
ctx,
volume.ID,
&types.VolumeDetachOpts{
Force: store.GetBool("force"),
Opts: store,
})
if err != nil {
return nil, err
}
if err != nil {
return nil, err
}
if v == nil {
continue
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAvailable
}
volumeMap[v.ID] = v
}
return nil, nil
}
task := service.TaskExecute(ctx, run, nil)
taskIDs = append(taskIDs, task.ID)
tasks[service.Name()] = task
}
run := func(ctx types.Context) (interface{}, error) {
services.TaskWaitAll(ctx, taskIDs...)
for _, v := range tasks {
if v.Error != nil {
return nil, utils.NewBatchProcessErr(reply, v.Error)
}
}
return reply, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
services.TaskExecute(ctx, run, schema.ServiceVolumeMapSchema),
http.StatusResetContent)
}