package agent import ( "net/http" "strconv" "strings" "github.com/hashicorp/nomad/api" "github.com/hashicorp/nomad/nomad/structs" ) func (s *HTTPServer) CSIVolumesRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) { switch req.Method { case http.MethodPut, http.MethodPost: return s.csiVolumeRegister(resp, req) case http.MethodGet: default: return nil, CodedError(405, ErrInvalidMethod) } // Type filters volume lists to a specific type. When support for non-CSI volumes is // introduced, we'll need to dispatch here query := req.URL.Query() qtype, ok := query["type"] if !ok { return []*structs.CSIVolListStub{}, nil } if qtype[0] != "csi" { return nil, nil } args := structs.CSIVolumeListRequest{} if s.parse(resp, req, &args.Region, &args.QueryOptions) { return nil, nil } args.Prefix = query.Get("prefix") args.PluginID = query.Get("plugin_id") args.NodeID = query.Get("node_id") var out structs.CSIVolumeListResponse if err := s.agent.RPC("CSIVolume.List", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return out.Volumes, nil } func (s *HTTPServer) CSIExternalVolumesRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) { if req.Method != http.MethodGet { return nil, CodedError(405, ErrInvalidMethod) } args := structs.CSIVolumeExternalListRequest{} if s.parse(resp, req, &args.Region, &args.QueryOptions) { return nil, nil } query := req.URL.Query() args.PluginID = query.Get("plugin_id") var out structs.CSIVolumeExternalListResponse if err := s.agent.RPC("CSIVolume.ListExternal", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return out, nil } // CSIVolumeSpecificRequest dispatches GET and PUT func (s *HTTPServer) CSIVolumeSpecificRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) { // Tokenize the suffix of the path to get the volume id reqSuffix := strings.TrimPrefix(req.URL.Path, "/v1/volume/csi/") tokens := strings.Split(reqSuffix, "/") if len(tokens) < 1 { return nil, CodedError(404, resourceNotFoundErr) } id := tokens[0] if len(tokens) == 1 { switch req.Method { case http.MethodGet: return s.csiVolumeGet(id, resp, req) case http.MethodPut: return s.csiVolumeRegister(resp, req) case http.MethodDelete: return s.csiVolumeDeregister(id, resp, req) default: return nil, CodedError(405, ErrInvalidMethod) } } if len(tokens) == 2 { switch req.Method { case http.MethodPut: if tokens[1] == "create" { return s.csiVolumeCreate(resp, req) } case http.MethodDelete: if tokens[1] == "detach" { return s.csiVolumeDetach(id, resp, req) } if tokens[1] == "delete" { return s.csiVolumeDelete(id, resp, req) } default: return nil, CodedError(405, ErrInvalidMethod) } } return nil, CodedError(404, resourceNotFoundErr) } func (s *HTTPServer) csiVolumeGet(id string, resp http.ResponseWriter, req *http.Request) (interface{}, error) { args := structs.CSIVolumeGetRequest{ ID: id, } if s.parse(resp, req, &args.Region, &args.QueryOptions) { return nil, nil } var out structs.CSIVolumeGetResponse if err := s.agent.RPC("CSIVolume.Get", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) if out.Volume == nil { return nil, CodedError(404, "volume not found") } vol := structsCSIVolumeToApi(out.Volume) // remove sensitive fields, as our redaction mechanism doesn't // help serializing here vol.Secrets = nil vol.MountOptions = nil return vol, nil } func (s *HTTPServer) csiVolumeRegister(resp http.ResponseWriter, req *http.Request) (interface{}, error) { switch req.Method { case http.MethodPost, http.MethodPut: default: return nil, CodedError(405, ErrInvalidMethod) } args := structs.CSIVolumeRegisterRequest{} if err := decodeBody(req, &args); err != nil { return err, CodedError(400, err.Error()) } s.parseWriteRequest(req, &args.WriteRequest) var out structs.CSIVolumeRegisterResponse if err := s.agent.RPC("CSIVolume.Register", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return nil, nil } func (s *HTTPServer) csiVolumeCreate(resp http.ResponseWriter, req *http.Request) (interface{}, error) { switch req.Method { case http.MethodPost, http.MethodPut: default: return nil, CodedError(405, ErrInvalidMethod) } args := structs.CSIVolumeCreateRequest{} if err := decodeBody(req, &args); err != nil { return err, CodedError(400, err.Error()) } s.parseWriteRequest(req, &args.WriteRequest) var out structs.CSIVolumeCreateResponse if err := s.agent.RPC("CSIVolume.Create", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return out, nil } func (s *HTTPServer) csiVolumeDeregister(id string, resp http.ResponseWriter, req *http.Request) (interface{}, error) { if req.Method != http.MethodDelete { return nil, CodedError(405, ErrInvalidMethod) } raw := req.URL.Query().Get("force") var force bool if raw != "" { var err error force, err = strconv.ParseBool(raw) if err != nil { return nil, CodedError(400, "invalid force value") } } args := structs.CSIVolumeDeregisterRequest{ VolumeIDs: []string{id}, Force: force, } s.parseWriteRequest(req, &args.WriteRequest) var out structs.CSIVolumeDeregisterResponse if err := s.agent.RPC("CSIVolume.Deregister", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return nil, nil } func (s *HTTPServer) csiVolumeDelete(id string, resp http.ResponseWriter, req *http.Request) (interface{}, error) { if req.Method != http.MethodDelete { return nil, CodedError(405, ErrInvalidMethod) } args := structs.CSIVolumeDeleteRequest{ VolumeIDs: []string{id}, } s.parseWriteRequest(req, &args.WriteRequest) var out structs.CSIVolumeDeleteResponse if err := s.agent.RPC("CSIVolume.Delete", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return nil, nil } func (s *HTTPServer) csiVolumeDetach(id string, resp http.ResponseWriter, req *http.Request) (interface{}, error) { if req.Method != http.MethodDelete { return nil, CodedError(405, ErrInvalidMethod) } nodeID := req.URL.Query().Get("node") if nodeID == "" { return nil, CodedError(400, "detach requires node ID") } args := structs.CSIVolumeUnpublishRequest{ VolumeID: id, Claim: &structs.CSIVolumeClaim{ NodeID: nodeID, Mode: structs.CSIVolumeClaimGC, }, } s.parseWriteRequest(req, &args.WriteRequest) var out structs.CSIVolumeUnpublishResponse if err := s.agent.RPC("CSIVolume.Unpublish", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return nil, nil } func (s *HTTPServer) CSISnapshotsRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) { switch req.Method { case http.MethodPut, http.MethodPost: return s.csiSnapshotCreate(resp, req) case http.MethodDelete: return s.csiSnapshotDelete(resp, req) case http.MethodGet: return s.csiSnapshotList(resp, req) } return nil, CodedError(405, ErrInvalidMethod) } func (s *HTTPServer) csiSnapshotCreate(resp http.ResponseWriter, req *http.Request) (interface{}, error) { args := structs.CSISnapshotCreateRequest{} if err := decodeBody(req, &args); err != nil { return err, CodedError(400, err.Error()) } s.parseWriteRequest(req, &args.WriteRequest) var out structs.CSISnapshotCreateResponse if err := s.agent.RPC("CSIVolume.CreateSnapshot", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return out, nil } func (s *HTTPServer) csiSnapshotDelete(resp http.ResponseWriter, req *http.Request) (interface{}, error) { args := structs.CSISnapshotDeleteRequest{} s.parseWriteRequest(req, &args.WriteRequest) snap := &structs.CSISnapshot{Secrets: structs.CSISecrets{}} query := req.URL.Query() snap.PluginID = query.Get("plugin_id") snap.ID = query.Get("snapshot_id") secrets := query["secret"] for _, raw := range secrets { secret := strings.Split(raw, "=") if len(secret) == 2 { snap.Secrets[secret[0]] = secret[1] } } args.Snapshots = []*structs.CSISnapshot{snap} var out structs.CSISnapshotDeleteResponse if err := s.agent.RPC("CSIVolume.DeleteSnapshot", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return nil, nil } func (s *HTTPServer) csiSnapshotList(resp http.ResponseWriter, req *http.Request) (interface{}, error) { args := structs.CSISnapshotListRequest{} if s.parse(resp, req, &args.Region, &args.QueryOptions) { return nil, nil } query := req.URL.Query() args.PluginID = query.Get("plugin_id") var out structs.CSISnapshotListResponse if err := s.agent.RPC("CSIVolume.ListSnapshots", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return out, nil } // CSIPluginsRequest lists CSI plugins func (s *HTTPServer) CSIPluginsRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) { if req.Method != http.MethodGet { return nil, CodedError(405, ErrInvalidMethod) } // Type filters plugin lists to a specific type. When support for non-CSI plugins is // introduced, we'll need to dispatch here query := req.URL.Query() qtype, ok := query["type"] if !ok { return []*structs.CSIPluginListStub{}, nil } if qtype[0] != "csi" { return nil, nil } args := structs.CSIPluginListRequest{} if s.parse(resp, req, &args.Region, &args.QueryOptions) { return nil, nil } var out structs.CSIPluginListResponse if err := s.agent.RPC("CSIPlugin.List", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) return out.Plugins, nil } // CSIPluginSpecificRequest list the job with CSIInfo func (s *HTTPServer) CSIPluginSpecificRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) { if req.Method != http.MethodGet { return nil, CodedError(405, ErrInvalidMethod) } // Tokenize the suffix of the path to get the plugin id reqSuffix := strings.TrimPrefix(req.URL.Path, "/v1/plugin/csi/") tokens := strings.Split(reqSuffix, "/") if len(tokens) > 2 || len(tokens) < 1 { return nil, CodedError(404, resourceNotFoundErr) } id := tokens[0] args := structs.CSIPluginGetRequest{ID: id} if s.parse(resp, req, &args.Region, &args.QueryOptions) { return nil, nil } var out structs.CSIPluginGetResponse if err := s.agent.RPC("CSIPlugin.Get", &args, &out); err != nil { return nil, err } setMeta(resp, &out.QueryMeta) if out.Plugin == nil { return nil, CodedError(404, "plugin not found") } return structsCSIPluginToApi(out.Plugin), nil } // structsCSIPluginToApi converts CSIPlugin, setting Expected the count of known plugin // instances func structsCSIPluginToApi(plug *structs.CSIPlugin) *api.CSIPlugin { if plug == nil { return nil } out := &api.CSIPlugin{ ID: plug.ID, Provider: plug.Provider, Version: plug.Version, Allocations: make([]*api.AllocationListStub, 0, len(plug.Allocations)), ControllerRequired: plug.ControllerRequired, ControllersHealthy: plug.ControllersHealthy, ControllersExpected: plug.ControllersExpected, Controllers: make(map[string]*api.CSIInfo, len(plug.Controllers)), NodesHealthy: plug.NodesHealthy, NodesExpected: plug.NodesExpected, Nodes: make(map[string]*api.CSIInfo, len(plug.Nodes)), CreateIndex: plug.CreateIndex, ModifyIndex: plug.ModifyIndex, } for k, v := range plug.Controllers { out.Controllers[k] = structsCSIInfoToApi(v) } for k, v := range plug.Nodes { out.Nodes[k] = structsCSIInfoToApi(v) } for _, a := range plug.Allocations { if a != nil { out.Allocations = append(out.Allocations, structsAllocListStubToApi(a)) } } return out } // structsCSIVolumeToApi converts CSIVolume, creating the allocation array func structsCSIVolumeToApi(vol *structs.CSIVolume) *api.CSIVolume { if vol == nil { return nil } allocCount := len(vol.ReadAllocs) + len(vol.WriteAllocs) out := &api.CSIVolume{ ID: vol.ID, Name: vol.Name, ExternalID: vol.ExternalID, Namespace: vol.Namespace, Topologies: structsCSITopolgiesToApi(vol.Topologies), AccessMode: structsCSIAccessModeToApi(vol.AccessMode), AttachmentMode: structsCSIAttachmentModeToApi(vol.AttachmentMode), MountOptions: structsCSIMountOptionsToApi(vol.MountOptions), Secrets: structsCSISecretsToApi(vol.Secrets), Parameters: vol.Parameters, Context: vol.Context, // Allocations is the collapsed list of both read and write allocs Allocations: make([]*api.AllocationListStub, 0, allocCount), // tracking of volume claims ReadAllocs: map[string]*api.Allocation{}, WriteAllocs: map[string]*api.Allocation{}, Schedulable: vol.Schedulable, PluginID: vol.PluginID, Provider: vol.Provider, ProviderVersion: vol.ProviderVersion, ControllerRequired: vol.ControllerRequired, ControllersHealthy: vol.ControllersHealthy, ControllersExpected: vol.ControllersExpected, NodesHealthy: vol.NodesHealthy, NodesExpected: vol.NodesExpected, ResourceExhausted: vol.ResourceExhausted, CreateIndex: vol.CreateIndex, ModifyIndex: vol.ModifyIndex, } // WriteAllocs and ReadAllocs will only ever contain the Allocation ID, // with a null value for the Allocation; these IDs are mapped to // allocation stubs in the Allocations field. This indirection is so the // API can support both the UI and CLI consumer in a safely backwards // compatible way for _, a := range vol.WriteAllocs { if a != nil { alloc := structsAllocListStubToApi(a.Stub(nil)) if alloc != nil { out.WriteAllocs[alloc.ID] = nil out.Allocations = append(out.Allocations, alloc) } } } for _, a := range vol.ReadAllocs { if a != nil { alloc := structsAllocListStubToApi(a.Stub(nil)) if alloc != nil { out.ReadAllocs[alloc.ID] = nil out.Allocations = append(out.Allocations, alloc) } } } return out } // structsCSIInfoToApi converts CSIInfo, part of CSIPlugin func structsCSIInfoToApi(info *structs.CSIInfo) *api.CSIInfo { if info == nil { return nil } out := &api.CSIInfo{ PluginID: info.PluginID, AllocID: info.AllocID, Healthy: info.Healthy, HealthDescription: info.HealthDescription, UpdateTime: info.UpdateTime, RequiresControllerPlugin: info.RequiresControllerPlugin, RequiresTopologies: info.RequiresTopologies, } if info.ControllerInfo != nil { out.ControllerInfo = &api.CSIControllerInfo{ SupportsReadOnlyAttach: info.ControllerInfo.SupportsReadOnlyAttach, SupportsAttachDetach: info.ControllerInfo.SupportsAttachDetach, SupportsListVolumes: info.ControllerInfo.SupportsListVolumes, SupportsListVolumesAttachedNodes: info.ControllerInfo.SupportsListVolumesAttachedNodes, } } if info.NodeInfo != nil { out.NodeInfo = &api.CSINodeInfo{ ID: info.NodeInfo.ID, MaxVolumes: info.NodeInfo.MaxVolumes, RequiresNodeStageVolume: info.NodeInfo.RequiresNodeStageVolume, } if info.NodeInfo.AccessibleTopology != nil { out.NodeInfo.AccessibleTopology = &api.CSITopology{} out.NodeInfo.AccessibleTopology.Segments = info.NodeInfo.AccessibleTopology.Segments } } return out } // structsAllocListStubToApi converts AllocListStub, for CSIPlugin func structsAllocListStubToApi(alloc *structs.AllocListStub) *api.AllocationListStub { if alloc == nil { return nil } out := &api.AllocationListStub{ ID: alloc.ID, EvalID: alloc.EvalID, Name: alloc.Name, Namespace: alloc.Namespace, NodeID: alloc.NodeID, NodeName: alloc.NodeName, JobID: alloc.JobID, JobType: alloc.JobType, JobVersion: alloc.JobVersion, TaskGroup: alloc.TaskGroup, DesiredStatus: alloc.DesiredStatus, DesiredDescription: alloc.DesiredDescription, ClientStatus: alloc.ClientStatus, ClientDescription: alloc.ClientDescription, TaskStates: make(map[string]*api.TaskState, len(alloc.TaskStates)), FollowupEvalID: alloc.FollowupEvalID, PreemptedAllocations: alloc.PreemptedAllocations, PreemptedByAllocation: alloc.PreemptedByAllocation, CreateIndex: alloc.CreateIndex, ModifyIndex: alloc.ModifyIndex, CreateTime: alloc.CreateTime, ModifyTime: alloc.ModifyTime, } out.DeploymentStatus = structsAllocDeploymentStatusToApi(alloc.DeploymentStatus) out.RescheduleTracker = structsRescheduleTrackerToApi(alloc.RescheduleTracker) for k, v := range alloc.TaskStates { out.TaskStates[k] = structsTaskStateToApi(v) } return out } // structsAllocDeploymentStatusToApi converts RescheduleTracker, part of AllocListStub func structsAllocDeploymentStatusToApi(ads *structs.AllocDeploymentStatus) *api.AllocDeploymentStatus { if ads == nil { return nil } out := &api.AllocDeploymentStatus{ Healthy: ads.Healthy, Timestamp: ads.Timestamp, Canary: ads.Canary, ModifyIndex: ads.ModifyIndex, } return out } // structsRescheduleTrackerToApi converts RescheduleTracker, part of AllocListStub func structsRescheduleTrackerToApi(rt *structs.RescheduleTracker) *api.RescheduleTracker { if rt == nil { return nil } out := &api.RescheduleTracker{ Events: make([]*api.RescheduleEvent, 0, len(rt.Events)), } for _, e := range rt.Events { out.Events = append(out.Events, &api.RescheduleEvent{ RescheduleTime: e.RescheduleTime, PrevAllocID: e.PrevAllocID, PrevNodeID: e.PrevNodeID, }) } return out } // structsTaskStateToApi converts TaskState, part of AllocListStub func structsTaskStateToApi(ts *structs.TaskState) *api.TaskState { if ts == nil { return nil } out := &api.TaskState{ State: ts.State, Failed: ts.Failed, Restarts: ts.Restarts, LastRestart: ts.LastRestart, StartedAt: ts.StartedAt, FinishedAt: ts.FinishedAt, Events: make([]*api.TaskEvent, 0, len(ts.Events)), } for _, te := range ts.Events { out.Events = append(out.Events, structsTaskEventToApi(te)) } return out } // structsTaskEventToApi converts TaskEvents, part of AllocListStub func structsTaskEventToApi(te *structs.TaskEvent) *api.TaskEvent { if te == nil { return nil } out := &api.TaskEvent{ Type: te.Type, Time: te.Time, DisplayMessage: te.DisplayMessage, Details: te.Details, // DEPRECATION NOTICE: The following fields are all deprecated. see TaskEvent struct in structs.go for details. FailsTask: te.FailsTask, RestartReason: te.RestartReason, SetupError: te.SetupError, DriverError: te.DriverError, DriverMessage: te.DriverMessage, ExitCode: te.ExitCode, Signal: te.Signal, Message: te.Message, KillReason: te.KillReason, KillTimeout: te.KillTimeout, KillError: te.KillError, StartDelay: te.StartDelay, DownloadError: te.DownloadError, ValidationError: te.ValidationError, DiskLimit: te.DiskLimit, FailedSibling: te.FailedSibling, VaultError: te.VaultError, TaskSignalReason: te.TaskSignalReason, TaskSignal: te.TaskSignal, GenericSource: te.GenericSource, } return out } // structsCSITopolgiesToApi converts topologies, part of structsCSIVolumeToApi func structsCSITopolgiesToApi(tops []*structs.CSITopology) []*api.CSITopology { out := make([]*api.CSITopology, 0, len(tops)) for _, t := range tops { out = append(out, &api.CSITopology{ Segments: t.Segments, }) } return out } // structsCSIAccessModeToApi converts access mode, part of structsCSIVolumeToApi func structsCSIAccessModeToApi(mode structs.CSIVolumeAccessMode) api.CSIVolumeAccessMode { switch mode { case structs.CSIVolumeAccessModeSingleNodeReader: return api.CSIVolumeAccessModeSingleNodeReader case structs.CSIVolumeAccessModeSingleNodeWriter: return api.CSIVolumeAccessModeSingleNodeWriter case structs.CSIVolumeAccessModeMultiNodeReader: return api.CSIVolumeAccessModeMultiNodeReader case structs.CSIVolumeAccessModeMultiNodeSingleWriter: return api.CSIVolumeAccessModeMultiNodeSingleWriter case structs.CSIVolumeAccessModeMultiNodeMultiWriter: return api.CSIVolumeAccessModeMultiNodeMultiWriter default: } return api.CSIVolumeAccessModeUnknown } // structsCSIAttachmentModeToApiModeToApi converts attachment mode, part of structsCSIVolumeToApi func structsCSIAttachmentModeToApi(mode structs.CSIVolumeAttachmentMode) api.CSIVolumeAttachmentMode { switch mode { case structs.CSIVolumeAttachmentModeBlockDevice: return api.CSIVolumeAttachmentModeBlockDevice case structs.CSIVolumeAttachmentModeFilesystem: return api.CSIVolumeAttachmentModeFilesystem default: } return api.CSIVolumeAttachmentModeUnknown } // structsCSIMountOptionsToApi converts mount options, part of structsCSIVolumeToApi func structsCSIMountOptionsToApi(opts *structs.CSIMountOptions) *api.CSIMountOptions { if opts == nil { return nil } return &api.CSIMountOptions{ FSType: opts.FSType, MountFlags: opts.MountFlags, } } func structsCSISecretsToApi(secrets structs.CSISecrets) api.CSISecrets { out := make(api.CSISecrets, len(secrets)) for k, v := range secrets { out[k] = v } return out }