id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
144,000 |
libopenstorage/openstorage
|
osdconfig/helper.go
|
newInMemKvdb
|
func newInMemKvdb() (kvdb.Kvdb, error) {
// create in memory kvdb
if kv, err := kvdb.New(mem.Name, "", []string{}, nil, nil); err != nil {
return nil, err
} else {
return kv, nil
}
}
|
go
|
func newInMemKvdb() (kvdb.Kvdb, error) {
// create in memory kvdb
if kv, err := kvdb.New(mem.Name, "", []string{}, nil, nil); err != nil {
return nil, err
} else {
return kv, nil
}
}
|
[
"func",
"newInMemKvdb",
"(",
")",
"(",
"kvdb",
".",
"Kvdb",
",",
"error",
")",
"{",
"// create in memory kvdb",
"if",
"kv",
",",
"err",
":=",
"kvdb",
".",
"New",
"(",
"mem",
".",
"Name",
",",
"\"",
"\"",
",",
"[",
"]",
"string",
"{",
"}",
",",
"nil",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"{",
"return",
"kv",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// helper function go get a new kvdb instance
|
[
"helper",
"function",
"go",
"get",
"a",
"new",
"kvdb",
"instance"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/osdconfig/helper.go#L12-L19
|
144,001 |
libopenstorage/openstorage
|
osdconfig/helper.go
|
getNodeKeyFromNodeID
|
func getNodeKeyFromNodeID(nodeID string) string {
dbg.Assert(len(nodeID) > 0, "%s", "nodeID string can not be empty")
return filepath.Join(baseKey, nodeKey, nodeID)
}
|
go
|
func getNodeKeyFromNodeID(nodeID string) string {
dbg.Assert(len(nodeID) > 0, "%s", "nodeID string can not be empty")
return filepath.Join(baseKey, nodeKey, nodeID)
}
|
[
"func",
"getNodeKeyFromNodeID",
"(",
"nodeID",
"string",
")",
"string",
"{",
"dbg",
".",
"Assert",
"(",
"len",
"(",
"nodeID",
")",
">",
"0",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"baseKey",
",",
"nodeKey",
",",
"nodeID",
")",
"\n",
"}"
] |
// helper function to obtain kvdb key for node based on nodeID
// the check for empty nodeID needs to be done elsewhere
|
[
"helper",
"function",
"to",
"obtain",
"kvdb",
"key",
"for",
"node",
"based",
"on",
"nodeID",
"the",
"check",
"for",
"empty",
"nodeID",
"needs",
"to",
"be",
"done",
"elsewhere"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/osdconfig/helper.go#L23-L26
|
144,002 |
libopenstorage/openstorage
|
osdconfig/helper.go
|
copyData
|
func copyData(wd *data) *data {
wd2 := new(data)
wd2.Key = wd.Key
wd2.Value = make([]byte, len(wd.Value))
copy(wd2.Value, wd.Value)
return wd2
}
|
go
|
func copyData(wd *data) *data {
wd2 := new(data)
wd2.Key = wd.Key
wd2.Value = make([]byte, len(wd.Value))
copy(wd2.Value, wd.Value)
return wd2
}
|
[
"func",
"copyData",
"(",
"wd",
"*",
"data",
")",
"*",
"data",
"{",
"wd2",
":=",
"new",
"(",
"data",
")",
"\n",
"wd2",
".",
"Key",
"=",
"wd",
".",
"Key",
"\n",
"wd2",
".",
"Value",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"wd",
".",
"Value",
")",
")",
"\n",
"copy",
"(",
"wd2",
".",
"Value",
",",
"wd",
".",
"Value",
")",
"\n",
"return",
"wd2",
"\n",
"}"
] |
// copyData is a helper function to copy data to be fed to each callback
|
[
"copyData",
"is",
"a",
"helper",
"function",
"to",
"copy",
"data",
"to",
"be",
"fed",
"to",
"each",
"callback"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/osdconfig/helper.go#L29-L35
|
144,003 |
libopenstorage/openstorage
|
alerts/api.go
|
NewManager
|
func NewManager(kv kvdb.Kvdb, options ...Option) (Manager, error) {
return newManager(kv, options...)
}
|
go
|
func NewManager(kv kvdb.Kvdb, options ...Option) (Manager, error) {
return newManager(kv, options...)
}
|
[
"func",
"NewManager",
"(",
"kv",
"kvdb",
".",
"Kvdb",
",",
"options",
"...",
"Option",
")",
"(",
"Manager",
",",
"error",
")",
"{",
"return",
"newManager",
"(",
"kv",
",",
"options",
"...",
")",
"\n",
"}"
] |
// NewManager obtains instance of Manager for alerts management.
|
[
"NewManager",
"obtains",
"instance",
"of",
"Manager",
"for",
"alerts",
"management",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L11-L13
|
144,004 |
libopenstorage/openstorage
|
alerts/api.go
|
NewFilterDeleter
|
func NewFilterDeleter(kv kvdb.Kvdb, options ...Option) (FilterDeleter, error) {
return newManager(kv, options...)
}
|
go
|
func NewFilterDeleter(kv kvdb.Kvdb, options ...Option) (FilterDeleter, error) {
return newManager(kv, options...)
}
|
[
"func",
"NewFilterDeleter",
"(",
"kv",
"kvdb",
".",
"Kvdb",
",",
"options",
"...",
"Option",
")",
"(",
"FilterDeleter",
",",
"error",
")",
"{",
"return",
"newManager",
"(",
"kv",
",",
"options",
"...",
")",
"\n",
"}"
] |
// NewFilterDeleter obtains instance of FilterDeleter for alerts enumeration and deletion.
|
[
"NewFilterDeleter",
"obtains",
"instance",
"of",
"FilterDeleter",
"for",
"alerts",
"enumeration",
"and",
"deletion",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L16-L18
|
144,005 |
libopenstorage/openstorage
|
alerts/api.go
|
NewTimeSpanOption
|
func NewTimeSpanOption(start, stop time.Time) Option {
return &option{optionType: timeSpanOption, value: NewTimeSpanFilter(start, stop)}
}
|
go
|
func NewTimeSpanOption(start, stop time.Time) Option {
return &option{optionType: timeSpanOption, value: NewTimeSpanFilter(start, stop)}
}
|
[
"func",
"NewTimeSpanOption",
"(",
"start",
",",
"stop",
"time",
".",
"Time",
")",
"Option",
"{",
"return",
"&",
"option",
"{",
"optionType",
":",
"timeSpanOption",
",",
"value",
":",
"NewTimeSpanFilter",
"(",
"start",
",",
"stop",
")",
"}",
"\n",
"}"
] |
// NewTimeSpanOption provides an option to be used in filter definition.
// Filters that take options, apply options only during matching alerts.
|
[
"NewTimeSpanOption",
"provides",
"an",
"option",
"to",
"be",
"used",
"in",
"filter",
"definition",
".",
"Filters",
"that",
"take",
"options",
"apply",
"options",
"only",
"during",
"matching",
"alerts",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L29-L31
|
144,006 |
libopenstorage/openstorage
|
alerts/api.go
|
NewCountSpanOption
|
func NewCountSpanOption(minCount, maxCount int64) Option {
return &option{optionType: countSpanOption, value: NewCountSpanFilter(minCount, maxCount)}
}
|
go
|
func NewCountSpanOption(minCount, maxCount int64) Option {
return &option{optionType: countSpanOption, value: NewCountSpanFilter(minCount, maxCount)}
}
|
[
"func",
"NewCountSpanOption",
"(",
"minCount",
",",
"maxCount",
"int64",
")",
"Option",
"{",
"return",
"&",
"option",
"{",
"optionType",
":",
"countSpanOption",
",",
"value",
":",
"NewCountSpanFilter",
"(",
"minCount",
",",
"maxCount",
")",
"}",
"\n",
"}"
] |
// NewCountSpanOption provides an option to be used in filter definition that
// accept options. Only filters that are efficient in querying kvdb accept options
// and apply these options during matching alerts.
|
[
"NewCountSpanOption",
"provides",
"an",
"option",
"to",
"be",
"used",
"in",
"filter",
"definition",
"that",
"accept",
"options",
".",
"Only",
"filters",
"that",
"are",
"efficient",
"in",
"querying",
"kvdb",
"accept",
"options",
"and",
"apply",
"these",
"options",
"during",
"matching",
"alerts",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L36-L38
|
144,007 |
libopenstorage/openstorage
|
alerts/api.go
|
NewMinSeverityOption
|
func NewMinSeverityOption(minSev api.SeverityType) Option {
return &option{optionType: minSeverityOption, value: NewMinSeverityFilter(minSev)}
}
|
go
|
func NewMinSeverityOption(minSev api.SeverityType) Option {
return &option{optionType: minSeverityOption, value: NewMinSeverityFilter(minSev)}
}
|
[
"func",
"NewMinSeverityOption",
"(",
"minSev",
"api",
".",
"SeverityType",
")",
"Option",
"{",
"return",
"&",
"option",
"{",
"optionType",
":",
"minSeverityOption",
",",
"value",
":",
"NewMinSeverityFilter",
"(",
"minSev",
")",
"}",
"\n",
"}"
] |
// NewMinSeverityOption provides an option to be used during filter creation that
// accept such options. Only filters that are efficient in querying kvdb accept options
// and apply these options during matching alerts.
|
[
"NewMinSeverityOption",
"provides",
"an",
"option",
"to",
"be",
"used",
"during",
"filter",
"creation",
"that",
"accept",
"such",
"options",
".",
"Only",
"filters",
"that",
"are",
"efficient",
"in",
"querying",
"kvdb",
"accept",
"options",
"and",
"apply",
"these",
"options",
"during",
"matching",
"alerts",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L43-L45
|
144,008 |
libopenstorage/openstorage
|
alerts/api.go
|
NewFlagCheckOption
|
func NewFlagCheckOption(flag bool) Option {
return &option{optionType: flagCheckOption, value: NewFlagCheckFilter(flag)}
}
|
go
|
func NewFlagCheckOption(flag bool) Option {
return &option{optionType: flagCheckOption, value: NewFlagCheckFilter(flag)}
}
|
[
"func",
"NewFlagCheckOption",
"(",
"flag",
"bool",
")",
"Option",
"{",
"return",
"&",
"option",
"{",
"optionType",
":",
"flagCheckOption",
",",
"value",
":",
"NewFlagCheckFilter",
"(",
"flag",
")",
"}",
"\n",
"}"
] |
// NewFlagCheckOptions provides an option to be used during filter creation that
// accept such options. Only filters that are efficient in querying kvdb accept options
// and apply these options during matching alerts.
|
[
"NewFlagCheckOptions",
"provides",
"an",
"option",
"to",
"be",
"used",
"during",
"filter",
"creation",
"that",
"accept",
"such",
"options",
".",
"Only",
"filters",
"that",
"are",
"efficient",
"in",
"querying",
"kvdb",
"accept",
"options",
"and",
"apply",
"these",
"options",
"during",
"matching",
"alerts",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L50-L52
|
144,009 |
libopenstorage/openstorage
|
alerts/api.go
|
NewResourceIdOption
|
func NewResourceIdOption(resourceId string) Option {
return &option{optionType: resourceIdOption, value: NewMatchResourceIDFilter(resourceId)}
}
|
go
|
func NewResourceIdOption(resourceId string) Option {
return &option{optionType: resourceIdOption, value: NewMatchResourceIDFilter(resourceId)}
}
|
[
"func",
"NewResourceIdOption",
"(",
"resourceId",
"string",
")",
"Option",
"{",
"return",
"&",
"option",
"{",
"optionType",
":",
"resourceIdOption",
",",
"value",
":",
"NewMatchResourceIDFilter",
"(",
"resourceId",
")",
"}",
"\n",
"}"
] |
// NewResourceIdOption provides an option to be used during filter creation that
// accept such options. Only filters that are efficient in querying kvdb accept options
// and apply these options during matching alerts.
|
[
"NewResourceIdOption",
"provides",
"an",
"option",
"to",
"be",
"used",
"during",
"filter",
"creation",
"that",
"accept",
"such",
"options",
".",
"Only",
"filters",
"that",
"are",
"efficient",
"in",
"querying",
"kvdb",
"accept",
"options",
"and",
"apply",
"these",
"options",
"during",
"matching",
"alerts",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L57-L59
|
144,010 |
libopenstorage/openstorage
|
alerts/api.go
|
NewTimeSpanFilter
|
func NewTimeSpanFilter(start, stop time.Time) Filter {
return &filter{filterType: timeSpanFilter, value: timeZone{start: start, stop: stop}}
}
|
go
|
func NewTimeSpanFilter(start, stop time.Time) Filter {
return &filter{filterType: timeSpanFilter, value: timeZone{start: start, stop: stop}}
}
|
[
"func",
"NewTimeSpanFilter",
"(",
"start",
",",
"stop",
"time",
".",
"Time",
")",
"Filter",
"{",
"return",
"&",
"filter",
"{",
"filterType",
":",
"timeSpanFilter",
",",
"value",
":",
"timeZone",
"{",
"start",
":",
"start",
",",
"stop",
":",
"stop",
"}",
"}",
"\n",
"}"
] |
// NewTimeSpanFilter creates a filter that matches on alert raised in a given time window.
|
[
"NewTimeSpanFilter",
"creates",
"a",
"filter",
"that",
"matches",
"on",
"alert",
"raised",
"in",
"a",
"given",
"time",
"window",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L83-L85
|
144,011 |
libopenstorage/openstorage
|
alerts/api.go
|
NewCountSpanFilter
|
func NewCountSpanFilter(minCount, maxCount int64) Filter {
return &filter{filterType: countSpanFilter, value: []int64{minCount, maxCount}}
}
|
go
|
func NewCountSpanFilter(minCount, maxCount int64) Filter {
return &filter{filterType: countSpanFilter, value: []int64{minCount, maxCount}}
}
|
[
"func",
"NewCountSpanFilter",
"(",
"minCount",
",",
"maxCount",
"int64",
")",
"Filter",
"{",
"return",
"&",
"filter",
"{",
"filterType",
":",
"countSpanFilter",
",",
"value",
":",
"[",
"]",
"int64",
"{",
"minCount",
",",
"maxCount",
"}",
"}",
"\n",
"}"
] |
// NewCountSpanFilter provides a filter that matches on alert count.
|
[
"NewCountSpanFilter",
"provides",
"a",
"filter",
"that",
"matches",
"on",
"alert",
"count",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L100-L102
|
144,012 |
libopenstorage/openstorage
|
alerts/api.go
|
NewMinSeverityFilter
|
func NewMinSeverityFilter(minSev api.SeverityType) Filter {
return &filter{filterType: minSeverityFilter, value: minSev}
}
|
go
|
func NewMinSeverityFilter(minSev api.SeverityType) Filter {
return &filter{filterType: minSeverityFilter, value: minSev}
}
|
[
"func",
"NewMinSeverityFilter",
"(",
"minSev",
"api",
".",
"SeverityType",
")",
"Filter",
"{",
"return",
"&",
"filter",
"{",
"filterType",
":",
"minSeverityFilter",
",",
"value",
":",
"minSev",
"}",
"\n",
"}"
] |
// NewMinSeverityFilter provides a filter that matches on alert when severity is greater than
// or equal to the minSev value.
|
[
"NewMinSeverityFilter",
"provides",
"a",
"filter",
"that",
"matches",
"on",
"alert",
"when",
"severity",
"is",
"greater",
"than",
"or",
"equal",
"to",
"the",
"minSev",
"value",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L106-L108
|
144,013 |
libopenstorage/openstorage
|
alerts/api.go
|
NewDeleteAction
|
func NewDeleteAction(filters ...Filter) Action {
return &action{action: deleteAction, filters: filters, f: deleteActionFunc}
}
|
go
|
func NewDeleteAction(filters ...Filter) Action {
return &action{action: deleteAction, filters: filters, f: deleteActionFunc}
}
|
[
"func",
"NewDeleteAction",
"(",
"filters",
"...",
"Filter",
")",
"Action",
"{",
"return",
"&",
"action",
"{",
"action",
":",
"deleteAction",
",",
"filters",
":",
"filters",
",",
"f",
":",
"deleteActionFunc",
"}",
"\n",
"}"
] |
// Action API
// NewDeleteAction deletes alert entries based on filters.
|
[
"Action",
"API",
"NewDeleteAction",
"deletes",
"alert",
"entries",
"based",
"on",
"filters",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L123-L125
|
144,014 |
libopenstorage/openstorage
|
alerts/api.go
|
NewClearAction
|
func NewClearAction(filters ...Filter) Action {
return &action{action: clearAction, filters: filters, f: clearActionFunc}
}
|
go
|
func NewClearAction(filters ...Filter) Action {
return &action{action: clearAction, filters: filters, f: clearActionFunc}
}
|
[
"func",
"NewClearAction",
"(",
"filters",
"...",
"Filter",
")",
"Action",
"{",
"return",
"&",
"action",
"{",
"action",
":",
"clearAction",
",",
"filters",
":",
"filters",
",",
"f",
":",
"clearActionFunc",
"}",
"\n",
"}"
] |
// NewClearAction marks alert entries as cleared that get deleted after half a day of life in kvdb.
|
[
"NewClearAction",
"marks",
"alert",
"entries",
"as",
"cleared",
"that",
"get",
"deleted",
"after",
"half",
"a",
"day",
"of",
"life",
"in",
"kvdb",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L128-L130
|
144,015 |
libopenstorage/openstorage
|
alerts/api.go
|
NewCustomAction
|
func NewCustomAction(f func(manager Manager, filters ...Filter) error, filters ...Filter) Action {
return &action{action: CustomAction, filters: filters, f: f}
}
|
go
|
func NewCustomAction(f func(manager Manager, filters ...Filter) error, filters ...Filter) Action {
return &action{action: CustomAction, filters: filters, f: f}
}
|
[
"func",
"NewCustomAction",
"(",
"f",
"func",
"(",
"manager",
"Manager",
",",
"filters",
"...",
"Filter",
")",
"error",
",",
"filters",
"...",
"Filter",
")",
"Action",
"{",
"return",
"&",
"action",
"{",
"action",
":",
"CustomAction",
",",
"filters",
":",
"filters",
",",
"f",
":",
"f",
"}",
"\n",
"}"
] |
// NewCustomAction takes custom action using user defined function.
|
[
"NewCustomAction",
"takes",
"custom",
"action",
"using",
"user",
"defined",
"function",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L133-L135
|
144,016 |
libopenstorage/openstorage
|
alerts/api.go
|
NewRaiseRule
|
func NewRaiseRule(name string, filter Filter, action Action) Rule {
return &rule{name: name, event: raiseEvent, filter: filter, action: action}
}
|
go
|
func NewRaiseRule(name string, filter Filter, action Action) Rule {
return &rule{name: name, event: raiseEvent, filter: filter, action: action}
}
|
[
"func",
"NewRaiseRule",
"(",
"name",
"string",
",",
"filter",
"Filter",
",",
"action",
"Action",
")",
"Rule",
"{",
"return",
"&",
"rule",
"{",
"name",
":",
"name",
",",
"event",
":",
"raiseEvent",
",",
"filter",
":",
"filter",
",",
"action",
":",
"action",
"}",
"\n",
"}"
] |
// Rule API
// NewRaiseRule creates a rule that runs action when a raised alerts matche filter.
// Action happens before incoming alert is raised.
|
[
"Rule",
"API",
"NewRaiseRule",
"creates",
"a",
"rule",
"that",
"runs",
"action",
"when",
"a",
"raised",
"alerts",
"matche",
"filter",
".",
"Action",
"happens",
"before",
"incoming",
"alert",
"is",
"raised",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L141-L143
|
144,017 |
libopenstorage/openstorage
|
alerts/api.go
|
NewDeleteRule
|
func NewDeleteRule(name string, filter Filter, action Action) Rule {
return &rule{name: name, event: deleteEvent, filter: filter, action: action}
}
|
go
|
func NewDeleteRule(name string, filter Filter, action Action) Rule {
return &rule{name: name, event: deleteEvent, filter: filter, action: action}
}
|
[
"func",
"NewDeleteRule",
"(",
"name",
"string",
",",
"filter",
"Filter",
",",
"action",
"Action",
")",
"Rule",
"{",
"return",
"&",
"rule",
"{",
"name",
":",
"name",
",",
"event",
":",
"deleteEvent",
",",
"filter",
":",
"filter",
",",
"action",
":",
"action",
"}",
"\n",
"}"
] |
// NewDeleteRule creates a rule that runs action when deleted alerts matche filter.
// Action happens after matching alerts are deleted.
|
[
"NewDeleteRule",
"creates",
"a",
"rule",
"that",
"runs",
"action",
"when",
"deleted",
"alerts",
"matche",
"filter",
".",
"Action",
"happens",
"after",
"matching",
"alerts",
"are",
"deleted",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/api.go#L147-L149
|
144,018 |
libopenstorage/openstorage
|
volume/volume.go
|
NewVolumeDriverRegistry
|
func NewVolumeDriverRegistry(nameToInitFunc map[string]func(map[string]string) (VolumeDriver, error)) VolumeDriverRegistry {
return newVolumeDriverRegistry(nameToInitFunc)
}
|
go
|
func NewVolumeDriverRegistry(nameToInitFunc map[string]func(map[string]string) (VolumeDriver, error)) VolumeDriverRegistry {
return newVolumeDriverRegistry(nameToInitFunc)
}
|
[
"func",
"NewVolumeDriverRegistry",
"(",
"nameToInitFunc",
"map",
"[",
"string",
"]",
"func",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"VolumeDriver",
",",
"error",
")",
")",
"VolumeDriverRegistry",
"{",
"return",
"newVolumeDriverRegistry",
"(",
"nameToInitFunc",
")",
"\n",
"}"
] |
// NewVolumeDriverRegistry constructs a new VolumeDriverRegistry.
|
[
"NewVolumeDriverRegistry",
"constructs",
"a",
"new",
"VolumeDriverRegistry",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/volume.go#L294-L296
|
144,019 |
libopenstorage/openstorage
|
volume/drivers/btrfs/btrfs.go
|
Create
|
func (d *driver) Create(
locator *api.VolumeLocator,
source *api.Source,
spec *api.VolumeSpec,
) (string, error) {
if spec.Format != api.FSType_FS_TYPE_BTRFS && spec.Format != api.FSType_FS_TYPE_NONE {
return "", fmt.Errorf("Filesystem format (%v) must be %v", spec.Format.SimpleString(), api.FSType_FS_TYPE_BTRFS.SimpleString())
}
volume := common.NewVolume(
uuid.New(),
api.FSType_FS_TYPE_BTRFS,
locator,
source,
spec,
)
if err := d.CreateVol(volume); err != nil {
return "", err
}
if err := d.btrfs.Create(volume.Id, "", "", nil); err != nil {
return "", err
}
devicePath, err := d.btrfs.Get(volume.Id, "")
if err != nil {
return volume.Id, err
}
volume.DevicePath = devicePath
return volume.Id, d.UpdateVol(volume)
}
|
go
|
func (d *driver) Create(
locator *api.VolumeLocator,
source *api.Source,
spec *api.VolumeSpec,
) (string, error) {
if spec.Format != api.FSType_FS_TYPE_BTRFS && spec.Format != api.FSType_FS_TYPE_NONE {
return "", fmt.Errorf("Filesystem format (%v) must be %v", spec.Format.SimpleString(), api.FSType_FS_TYPE_BTRFS.SimpleString())
}
volume := common.NewVolume(
uuid.New(),
api.FSType_FS_TYPE_BTRFS,
locator,
source,
spec,
)
if err := d.CreateVol(volume); err != nil {
return "", err
}
if err := d.btrfs.Create(volume.Id, "", "", nil); err != nil {
return "", err
}
devicePath, err := d.btrfs.Get(volume.Id, "")
if err != nil {
return volume.Id, err
}
volume.DevicePath = devicePath
return volume.Id, d.UpdateVol(volume)
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"Create",
"(",
"locator",
"*",
"api",
".",
"VolumeLocator",
",",
"source",
"*",
"api",
".",
"Source",
",",
"spec",
"*",
"api",
".",
"VolumeSpec",
",",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"spec",
".",
"Format",
"!=",
"api",
".",
"FSType_FS_TYPE_BTRFS",
"&&",
"spec",
".",
"Format",
"!=",
"api",
".",
"FSType_FS_TYPE_NONE",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"spec",
".",
"Format",
".",
"SimpleString",
"(",
")",
",",
"api",
".",
"FSType_FS_TYPE_BTRFS",
".",
"SimpleString",
"(",
")",
")",
"\n",
"}",
"\n",
"volume",
":=",
"common",
".",
"NewVolume",
"(",
"uuid",
".",
"New",
"(",
")",
",",
"api",
".",
"FSType_FS_TYPE_BTRFS",
",",
"locator",
",",
"source",
",",
"spec",
",",
")",
"\n",
"if",
"err",
":=",
"d",
".",
"CreateVol",
"(",
"volume",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"d",
".",
"btrfs",
".",
"Create",
"(",
"volume",
".",
"Id",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"devicePath",
",",
"err",
":=",
"d",
".",
"btrfs",
".",
"Get",
"(",
"volume",
".",
"Id",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"volume",
".",
"Id",
",",
"err",
"\n",
"}",
"\n",
"volume",
".",
"DevicePath",
"=",
"devicePath",
"\n",
"return",
"volume",
".",
"Id",
",",
"d",
".",
"UpdateVol",
"(",
"volume",
")",
"\n",
"}"
] |
// Create a new subvolume. The volume spec is not taken into account.
|
[
"Create",
"a",
"new",
"subvolume",
".",
"The",
"volume",
"spec",
"is",
"not",
"taken",
"into",
"account",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/btrfs/btrfs.go#L81-L108
|
144,020 |
libopenstorage/openstorage
|
volume/drivers/btrfs/btrfs.go
|
Snapshot
|
func (d *driver) Snapshot(volumeID string, readonly bool, locator *api.VolumeLocator, noRetry bool) (string, error) {
vols, err := d.Inspect([]string{volumeID})
if err != nil {
return "", err
}
if len(vols) != 1 {
return "", fmt.Errorf("Failed to inspect %v len %v", volumeID, len(vols))
}
snapID := uuid.New()
vols[0].Id = snapID
vols[0].Source = &api.Source{Parent: volumeID}
vols[0].Locator = locator
vols[0].Ctime = prototime.Now()
if err := d.CreateVol(vols[0]); err != nil {
return "", err
}
chaos.Now(koStrayCreate)
err = d.btrfs.Create(snapID, volumeID, "", nil)
if err != nil {
return "", err
}
return vols[0].Id, nil
}
|
go
|
func (d *driver) Snapshot(volumeID string, readonly bool, locator *api.VolumeLocator, noRetry bool) (string, error) {
vols, err := d.Inspect([]string{volumeID})
if err != nil {
return "", err
}
if len(vols) != 1 {
return "", fmt.Errorf("Failed to inspect %v len %v", volumeID, len(vols))
}
snapID := uuid.New()
vols[0].Id = snapID
vols[0].Source = &api.Source{Parent: volumeID}
vols[0].Locator = locator
vols[0].Ctime = prototime.Now()
if err := d.CreateVol(vols[0]); err != nil {
return "", err
}
chaos.Now(koStrayCreate)
err = d.btrfs.Create(snapID, volumeID, "", nil)
if err != nil {
return "", err
}
return vols[0].Id, nil
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"Snapshot",
"(",
"volumeID",
"string",
",",
"readonly",
"bool",
",",
"locator",
"*",
"api",
".",
"VolumeLocator",
",",
"noRetry",
"bool",
")",
"(",
"string",
",",
"error",
")",
"{",
"vols",
",",
"err",
":=",
"d",
".",
"Inspect",
"(",
"[",
"]",
"string",
"{",
"volumeID",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"vols",
")",
"!=",
"1",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"volumeID",
",",
"len",
"(",
"vols",
")",
")",
"\n",
"}",
"\n",
"snapID",
":=",
"uuid",
".",
"New",
"(",
")",
"\n",
"vols",
"[",
"0",
"]",
".",
"Id",
"=",
"snapID",
"\n",
"vols",
"[",
"0",
"]",
".",
"Source",
"=",
"&",
"api",
".",
"Source",
"{",
"Parent",
":",
"volumeID",
"}",
"\n",
"vols",
"[",
"0",
"]",
".",
"Locator",
"=",
"locator",
"\n",
"vols",
"[",
"0",
"]",
".",
"Ctime",
"=",
"prototime",
".",
"Now",
"(",
")",
"\n\n",
"if",
"err",
":=",
"d",
".",
"CreateVol",
"(",
"vols",
"[",
"0",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"chaos",
".",
"Now",
"(",
"koStrayCreate",
")",
"\n",
"err",
"=",
"d",
".",
"btrfs",
".",
"Create",
"(",
"snapID",
",",
"volumeID",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"vols",
"[",
"0",
"]",
".",
"Id",
",",
"nil",
"\n",
"}"
] |
// Snapshot create new subvolume from volume
|
[
"Snapshot",
"create",
"new",
"subvolume",
"from",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/btrfs/btrfs.go#L160-L183
|
144,021 |
libopenstorage/openstorage
|
osdconfig/new.go
|
newCaller
|
func newCaller(kv kvdb.Kvdb) (*configManager, error) {
manager := new(configManager)
manager.cbCluster = make(map[string]CallbackClusterConfigFunc)
manager.cbNode = make(map[string]CallbackNodeConfigFunc)
// kvdb pointer
manager.kv = kv
return manager, nil
}
|
go
|
func newCaller(kv kvdb.Kvdb) (*configManager, error) {
manager := new(configManager)
manager.cbCluster = make(map[string]CallbackClusterConfigFunc)
manager.cbNode = make(map[string]CallbackNodeConfigFunc)
// kvdb pointer
manager.kv = kv
return manager, nil
}
|
[
"func",
"newCaller",
"(",
"kv",
"kvdb",
".",
"Kvdb",
")",
"(",
"*",
"configManager",
",",
"error",
")",
"{",
"manager",
":=",
"new",
"(",
"configManager",
")",
"\n\n",
"manager",
".",
"cbCluster",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"CallbackClusterConfigFunc",
")",
"\n",
"manager",
".",
"cbNode",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"CallbackNodeConfigFunc",
")",
"\n\n",
"// kvdb pointer",
"manager",
".",
"kv",
"=",
"kv",
"\n\n",
"return",
"manager",
",",
"nil",
"\n",
"}"
] |
// newCaller can be used to instantiate configManager,
// however, it is exported as ConfigCaller and avoids
// starting kvdb watches.
// Those not needing kvdb wtches should use this instead of
// config manager.
|
[
"newCaller",
"can",
"be",
"used",
"to",
"instantiate",
"configManager",
"however",
"it",
"is",
"exported",
"as",
"ConfigCaller",
"and",
"avoids",
"starting",
"kvdb",
"watches",
".",
"Those",
"not",
"needing",
"kvdb",
"wtches",
"should",
"use",
"this",
"instead",
"of",
"config",
"manager",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/osdconfig/new.go#L56-L66
|
144,022 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere_util.go
|
IsDevMode
|
func IsDevMode() bool {
_, err := storageops.GetEnvValueStrict("VSPHERE_VM_UUID")
if err != nil {
return false
}
_, err = storageops.GetEnvValueStrict("VSPHERE_TEST_DATASTORE")
return err == nil
}
|
go
|
func IsDevMode() bool {
_, err := storageops.GetEnvValueStrict("VSPHERE_VM_UUID")
if err != nil {
return false
}
_, err = storageops.GetEnvValueStrict("VSPHERE_TEST_DATASTORE")
return err == nil
}
|
[
"func",
"IsDevMode",
"(",
")",
"bool",
"{",
"_",
",",
"err",
":=",
"storageops",
".",
"GetEnvValueStrict",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"storageops",
".",
"GetEnvValueStrict",
"(",
"\"",
"\"",
")",
"\n",
"return",
"err",
"==",
"nil",
"\n",
"}"
] |
// IsDevMode checks if requirement env variables are set to run the pkg outside vsphere in dev mode
|
[
"IsDevMode",
"checks",
"if",
"requirement",
"env",
"variables",
"are",
"set",
"to",
"run",
"the",
"pkg",
"outside",
"vsphere",
"in",
"dev",
"mode"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere_util.go#L94-L102
|
144,023 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere_util.go
|
GetStoragePodMoList
|
func GetStoragePodMoList(
ctx context.Context,
client *vim25.Client,
storagePodRefs []types.ManagedObjectReference,
properties []string) ([]mo.StoragePod, error) {
var storagePodMoList []mo.StoragePod
pc := property.DefaultCollector(client)
err := pc.Retrieve(ctx, storagePodRefs, properties, &storagePodMoList)
if err != nil {
logrus.Errorf("Failed to get Storagepod managed objects from storage pod refs: %+v, properties: %+v, err: %v",
storagePodRefs, properties, err)
return nil, err
}
return storagePodMoList, nil
}
|
go
|
func GetStoragePodMoList(
ctx context.Context,
client *vim25.Client,
storagePodRefs []types.ManagedObjectReference,
properties []string) ([]mo.StoragePod, error) {
var storagePodMoList []mo.StoragePod
pc := property.DefaultCollector(client)
err := pc.Retrieve(ctx, storagePodRefs, properties, &storagePodMoList)
if err != nil {
logrus.Errorf("Failed to get Storagepod managed objects from storage pod refs: %+v, properties: %+v, err: %v",
storagePodRefs, properties, err)
return nil, err
}
return storagePodMoList, nil
}
|
[
"func",
"GetStoragePodMoList",
"(",
"ctx",
"context",
".",
"Context",
",",
"client",
"*",
"vim25",
".",
"Client",
",",
"storagePodRefs",
"[",
"]",
"types",
".",
"ManagedObjectReference",
",",
"properties",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"mo",
".",
"StoragePod",
",",
"error",
")",
"{",
"var",
"storagePodMoList",
"[",
"]",
"mo",
".",
"StoragePod",
"\n",
"pc",
":=",
"property",
".",
"DefaultCollector",
"(",
"client",
")",
"\n",
"err",
":=",
"pc",
".",
"Retrieve",
"(",
"ctx",
",",
"storagePodRefs",
",",
"properties",
",",
"&",
"storagePodMoList",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"storagePodRefs",
",",
"properties",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"storagePodMoList",
",",
"nil",
"\n",
"}"
] |
// GetStoragePodMoList fetches the managed storage pod objects for the given references
// Only the properties is the given property list will be populated in the response
|
[
"GetStoragePodMoList",
"fetches",
"the",
"managed",
"storage",
"pod",
"objects",
"for",
"the",
"given",
"references",
"Only",
"the",
"properties",
"is",
"the",
"given",
"property",
"list",
"will",
"be",
"populated",
"in",
"the",
"response"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere_util.go#L171-L185
|
144,024 |
libopenstorage/openstorage
|
api/server/sdk/volume_migrate.go
|
Start
|
func (s *VolumeServer) Start(
ctx context.Context,
req *api.SdkCloudMigrateStartRequest,
) (*api.SdkCloudMigrateStartResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if volume := req.GetVolume(); volume != nil {
// Check ownership
if err := checkAccessFromDriverForVolumeId(ctx, s.driver(ctx), volume.GetVolumeId(), api.Ownership_Read); err != nil {
return nil, err
}
//migrate volume
return s.volumeMigrate(ctx, req, volume)
} else if volumeGroup := req.GetVolumeGroup(); volumeGroup != nil {
if !s.haveOwnership(ctx, nil, &api.VolumeLocator{
Group: &api.Group{
Id: volumeGroup.GetGroupId(),
},
}) {
return nil, status.Error(codes.PermissionDenied, "Volume Operation not Permitted.")
}
//migrate volume groups
return s.volumeGroupMigrate(ctx, req, volumeGroup)
} else if allVolumes := req.GetAllVolumes(); allVolumes != nil {
// migrate all volumes
if !s.haveOwnership(ctx, nil, nil) {
return nil, status.Error(codes.PermissionDenied, "Volume Operation not Permitted.")
}
return s.allVolumesMigrate(ctx, req, allVolumes)
}
return nil, status.Error(codes.InvalidArgument, "Unknown operation request")
}
|
go
|
func (s *VolumeServer) Start(
ctx context.Context,
req *api.SdkCloudMigrateStartRequest,
) (*api.SdkCloudMigrateStartResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if volume := req.GetVolume(); volume != nil {
// Check ownership
if err := checkAccessFromDriverForVolumeId(ctx, s.driver(ctx), volume.GetVolumeId(), api.Ownership_Read); err != nil {
return nil, err
}
//migrate volume
return s.volumeMigrate(ctx, req, volume)
} else if volumeGroup := req.GetVolumeGroup(); volumeGroup != nil {
if !s.haveOwnership(ctx, nil, &api.VolumeLocator{
Group: &api.Group{
Id: volumeGroup.GetGroupId(),
},
}) {
return nil, status.Error(codes.PermissionDenied, "Volume Operation not Permitted.")
}
//migrate volume groups
return s.volumeGroupMigrate(ctx, req, volumeGroup)
} else if allVolumes := req.GetAllVolumes(); allVolumes != nil {
// migrate all volumes
if !s.haveOwnership(ctx, nil, nil) {
return nil, status.Error(codes.PermissionDenied, "Volume Operation not Permitted.")
}
return s.allVolumesMigrate(ctx, req, allVolumes)
}
return nil, status.Error(codes.InvalidArgument, "Unknown operation request")
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Start",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkCloudMigrateStartRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkCloudMigrateStartResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"volume",
":=",
"req",
".",
"GetVolume",
"(",
")",
";",
"volume",
"!=",
"nil",
"{",
"// Check ownership",
"if",
"err",
":=",
"checkAccessFromDriverForVolumeId",
"(",
"ctx",
",",
"s",
".",
"driver",
"(",
"ctx",
")",
",",
"volume",
".",
"GetVolumeId",
"(",
")",
",",
"api",
".",
"Ownership_Read",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"//migrate volume",
"return",
"s",
".",
"volumeMigrate",
"(",
"ctx",
",",
"req",
",",
"volume",
")",
"\n",
"}",
"else",
"if",
"volumeGroup",
":=",
"req",
".",
"GetVolumeGroup",
"(",
")",
";",
"volumeGroup",
"!=",
"nil",
"{",
"if",
"!",
"s",
".",
"haveOwnership",
"(",
"ctx",
",",
"nil",
",",
"&",
"api",
".",
"VolumeLocator",
"{",
"Group",
":",
"&",
"api",
".",
"Group",
"{",
"Id",
":",
"volumeGroup",
".",
"GetGroupId",
"(",
")",
",",
"}",
",",
"}",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"//migrate volume groups",
"return",
"s",
".",
"volumeGroupMigrate",
"(",
"ctx",
",",
"req",
",",
"volumeGroup",
")",
"\n",
"}",
"else",
"if",
"allVolumes",
":=",
"req",
".",
"GetAllVolumes",
"(",
")",
";",
"allVolumes",
"!=",
"nil",
"{",
"// migrate all volumes",
"if",
"!",
"s",
".",
"haveOwnership",
"(",
"ctx",
",",
"nil",
",",
"nil",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"allVolumesMigrate",
"(",
"ctx",
",",
"req",
",",
"allVolumes",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// Start a volume migration
|
[
"Start",
"a",
"volume",
"migration"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_migrate.go#L29-L63
|
144,025 |
libopenstorage/openstorage
|
api/server/sdk/volume_migrate.go
|
Cancel
|
func (s *VolumeServer) Cancel(
ctx context.Context,
req *api.SdkCloudMigrateCancelRequest,
) (*api.SdkCloudMigrateCancelResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if req.GetRequest() == nil {
return nil, status.Errorf(codes.InvalidArgument, "Must supply valid request")
} else if len(req.GetRequest().GetTaskId()) == 0 {
return nil, status.Errorf(codes.InvalidArgument, "Must supply valid Task ID")
}
err := s.driver(ctx).CloudMigrateCancel(req.GetRequest())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot stop migration for %s : %v",
req.GetRequest().GetTaskId(), err)
}
return &api.SdkCloudMigrateCancelResponse{}, nil
}
|
go
|
func (s *VolumeServer) Cancel(
ctx context.Context,
req *api.SdkCloudMigrateCancelRequest,
) (*api.SdkCloudMigrateCancelResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if req.GetRequest() == nil {
return nil, status.Errorf(codes.InvalidArgument, "Must supply valid request")
} else if len(req.GetRequest().GetTaskId()) == 0 {
return nil, status.Errorf(codes.InvalidArgument, "Must supply valid Task ID")
}
err := s.driver(ctx).CloudMigrateCancel(req.GetRequest())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot stop migration for %s : %v",
req.GetRequest().GetTaskId(), err)
}
return &api.SdkCloudMigrateCancelResponse{}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Cancel",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkCloudMigrateCancelRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkCloudMigrateCancelResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"req",
".",
"GetRequest",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"req",
".",
"GetRequest",
"(",
")",
".",
"GetTaskId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"CloudMigrateCancel",
"(",
"req",
".",
"GetRequest",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetRequest",
"(",
")",
".",
"GetTaskId",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"api",
".",
"SdkCloudMigrateCancelResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// Cancel or stop a ongoing migration
|
[
"Cancel",
"or",
"stop",
"a",
"ongoing",
"migration"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_migrate.go#L166-L185
|
144,026 |
libopenstorage/openstorage
|
api/server/sdk/volume_migrate.go
|
Status
|
func (s *VolumeServer) Status(
ctx context.Context,
req *api.SdkCloudMigrateStatusRequest,
) (*api.SdkCloudMigrateStatusResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
resp, err := s.driver(ctx).CloudMigrateStatus(req.GetRequest())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot get status of migration : %v", err)
}
return &api.SdkCloudMigrateStatusResponse{
Result: resp,
}, nil
}
|
go
|
func (s *VolumeServer) Status(
ctx context.Context,
req *api.SdkCloudMigrateStatusRequest,
) (*api.SdkCloudMigrateStatusResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
resp, err := s.driver(ctx).CloudMigrateStatus(req.GetRequest())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot get status of migration : %v", err)
}
return &api.SdkCloudMigrateStatusResponse{
Result: resp,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Status",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkCloudMigrateStatusRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkCloudMigrateStatusResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"CloudMigrateStatus",
"(",
"req",
".",
"GetRequest",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"api",
".",
"SdkCloudMigrateStatusResponse",
"{",
"Result",
":",
"resp",
",",
"}",
",",
"nil",
"\n\n",
"}"
] |
// Status of ongoing migration
|
[
"Status",
"of",
"ongoing",
"migration"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_migrate.go#L188-L204
|
144,027 |
libopenstorage/openstorage
|
volume/drivers/pwx/pwx.go
|
Init
|
func Init(params map[string]string) (volume.VolumeDriver, error) {
url, ok := params[config.UrlKey]
if !ok {
url = DefaultUrl
}
version, ok := params[config.VersionKey]
if !ok {
version = volume.APIVersion
}
c, err := client.NewClient(url, version, "")
if err != nil {
return nil, err
}
return &driver{VolumeDriver: volumeclient.VolumeDriver(c)}, nil
}
|
go
|
func Init(params map[string]string) (volume.VolumeDriver, error) {
url, ok := params[config.UrlKey]
if !ok {
url = DefaultUrl
}
version, ok := params[config.VersionKey]
if !ok {
version = volume.APIVersion
}
c, err := client.NewClient(url, version, "")
if err != nil {
return nil, err
}
return &driver{VolumeDriver: volumeclient.VolumeDriver(c)}, nil
}
|
[
"func",
"Init",
"(",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"volume",
".",
"VolumeDriver",
",",
"error",
")",
"{",
"url",
",",
"ok",
":=",
"params",
"[",
"config",
".",
"UrlKey",
"]",
"\n",
"if",
"!",
"ok",
"{",
"url",
"=",
"DefaultUrl",
"\n",
"}",
"\n",
"version",
",",
"ok",
":=",
"params",
"[",
"config",
".",
"VersionKey",
"]",
"\n",
"if",
"!",
"ok",
"{",
"version",
"=",
"volume",
".",
"APIVersion",
"\n",
"}",
"\n",
"c",
",",
"err",
":=",
"client",
".",
"NewClient",
"(",
"url",
",",
"version",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"driver",
"{",
"VolumeDriver",
":",
"volumeclient",
".",
"VolumeDriver",
"(",
"c",
")",
"}",
",",
"nil",
"\n",
"}"
] |
// Init initialized the Portworx driver.
// Portworx natively implements the openstorage.org API specification, so
// we can directly point the VolumeDriver to the PWX API server.
|
[
"Init",
"initialized",
"the",
"Portworx",
"driver",
".",
"Portworx",
"natively",
"implements",
"the",
"openstorage",
".",
"org",
"API",
"specification",
"so",
"we",
"can",
"directly",
"point",
"the",
"VolumeDriver",
"to",
"the",
"PWX",
"API",
"server",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/pwx/pwx.go#L27-L42
|
144,028 |
libopenstorage/openstorage
|
cluster/manager/pair.go
|
CreatePair
|
func (c *ClusterManager) CreatePair(
request *api.ClusterPairCreateRequest,
) (*api.ClusterPairCreateResponse, error) {
remoteIp := request.RemoteClusterIp
// Pair with remote server
logrus.Infof("Attempting to pair with cluster at IP %v", remoteIp)
processRequest := &api.ClusterPairProcessRequest{
SourceClusterId: c.Uuid(),
RemoteClusterToken: request.RemoteClusterToken,
Mode: request.Mode,
}
endpoint := "http://" + remoteIp + ":" + strconv.FormatUint(uint64(request.RemoteClusterPort), 10)
clnt, err := clusterclient.NewClusterClient(endpoint, cluster.APIVersion)
if err != nil {
return nil, err
}
remoteCluster := clusterclient.ClusterManager(clnt)
// Issue a remote pair request
resp, err := remoteCluster.ProcessPairRequest(processRequest)
if err != nil {
logrus.Warnf("Unable to pair with %v: %v", remoteIp, err)
return nil, fmt.Errorf("Error from remote cluster: %v", err)
}
// Alert all listeners that we are pairing with a cluster.
for e := c.listeners.Front(); e != nil; e = e.Next() {
err = e.Value.(cluster.ClusterListener).CreatePair(
request,
resp,
)
if err != nil {
logrus.Errorf("Unable to notify %v on a cluster pair event: %v",
e.Value.(cluster.ClusterListener).String(),
err,
)
return nil, err
}
}
pairInfo := &api.ClusterPairInfo{
Id: resp.RemoteClusterId,
Name: resp.RemoteClusterName,
Endpoint: endpoint,
CurrentEndpoints: resp.RemoteClusterEndpoints,
Token: request.RemoteClusterToken,
Options: resp.Options,
Mode: request.Mode,
}
err = pairCreate(pairInfo, request.SetDefault)
if err != nil {
return nil, err
}
logrus.Infof("Successfully paired with cluster ID %v", resp.RemoteClusterId)
response := &api.ClusterPairCreateResponse{
RemoteClusterId: pairInfo.Id,
RemoteClusterName: pairInfo.Name,
}
return response, nil
}
|
go
|
func (c *ClusterManager) CreatePair(
request *api.ClusterPairCreateRequest,
) (*api.ClusterPairCreateResponse, error) {
remoteIp := request.RemoteClusterIp
// Pair with remote server
logrus.Infof("Attempting to pair with cluster at IP %v", remoteIp)
processRequest := &api.ClusterPairProcessRequest{
SourceClusterId: c.Uuid(),
RemoteClusterToken: request.RemoteClusterToken,
Mode: request.Mode,
}
endpoint := "http://" + remoteIp + ":" + strconv.FormatUint(uint64(request.RemoteClusterPort), 10)
clnt, err := clusterclient.NewClusterClient(endpoint, cluster.APIVersion)
if err != nil {
return nil, err
}
remoteCluster := clusterclient.ClusterManager(clnt)
// Issue a remote pair request
resp, err := remoteCluster.ProcessPairRequest(processRequest)
if err != nil {
logrus.Warnf("Unable to pair with %v: %v", remoteIp, err)
return nil, fmt.Errorf("Error from remote cluster: %v", err)
}
// Alert all listeners that we are pairing with a cluster.
for e := c.listeners.Front(); e != nil; e = e.Next() {
err = e.Value.(cluster.ClusterListener).CreatePair(
request,
resp,
)
if err != nil {
logrus.Errorf("Unable to notify %v on a cluster pair event: %v",
e.Value.(cluster.ClusterListener).String(),
err,
)
return nil, err
}
}
pairInfo := &api.ClusterPairInfo{
Id: resp.RemoteClusterId,
Name: resp.RemoteClusterName,
Endpoint: endpoint,
CurrentEndpoints: resp.RemoteClusterEndpoints,
Token: request.RemoteClusterToken,
Options: resp.Options,
Mode: request.Mode,
}
err = pairCreate(pairInfo, request.SetDefault)
if err != nil {
return nil, err
}
logrus.Infof("Successfully paired with cluster ID %v", resp.RemoteClusterId)
response := &api.ClusterPairCreateResponse{
RemoteClusterId: pairInfo.Id,
RemoteClusterName: pairInfo.Name,
}
return response, nil
}
|
[
"func",
"(",
"c",
"*",
"ClusterManager",
")",
"CreatePair",
"(",
"request",
"*",
"api",
".",
"ClusterPairCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"ClusterPairCreateResponse",
",",
"error",
")",
"{",
"remoteIp",
":=",
"request",
".",
"RemoteClusterIp",
"\n\n",
"// Pair with remote server",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"remoteIp",
")",
"\n",
"processRequest",
":=",
"&",
"api",
".",
"ClusterPairProcessRequest",
"{",
"SourceClusterId",
":",
"c",
".",
"Uuid",
"(",
")",
",",
"RemoteClusterToken",
":",
"request",
".",
"RemoteClusterToken",
",",
"Mode",
":",
"request",
".",
"Mode",
",",
"}",
"\n\n",
"endpoint",
":=",
"\"",
"\"",
"+",
"remoteIp",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"FormatUint",
"(",
"uint64",
"(",
"request",
".",
"RemoteClusterPort",
")",
",",
"10",
")",
"\n",
"clnt",
",",
"err",
":=",
"clusterclient",
".",
"NewClusterClient",
"(",
"endpoint",
",",
"cluster",
".",
"APIVersion",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"remoteCluster",
":=",
"clusterclient",
".",
"ClusterManager",
"(",
"clnt",
")",
"\n\n",
"// Issue a remote pair request",
"resp",
",",
"err",
":=",
"remoteCluster",
".",
"ProcessPairRequest",
"(",
"processRequest",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"remoteIp",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Alert all listeners that we are pairing with a cluster.",
"for",
"e",
":=",
"c",
".",
"listeners",
".",
"Front",
"(",
")",
";",
"e",
"!=",
"nil",
";",
"e",
"=",
"e",
".",
"Next",
"(",
")",
"{",
"err",
"=",
"e",
".",
"Value",
".",
"(",
"cluster",
".",
"ClusterListener",
")",
".",
"CreatePair",
"(",
"request",
",",
"resp",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"e",
".",
"Value",
".",
"(",
"cluster",
".",
"ClusterListener",
")",
".",
"String",
"(",
")",
",",
"err",
",",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"pairInfo",
":=",
"&",
"api",
".",
"ClusterPairInfo",
"{",
"Id",
":",
"resp",
".",
"RemoteClusterId",
",",
"Name",
":",
"resp",
".",
"RemoteClusterName",
",",
"Endpoint",
":",
"endpoint",
",",
"CurrentEndpoints",
":",
"resp",
".",
"RemoteClusterEndpoints",
",",
"Token",
":",
"request",
".",
"RemoteClusterToken",
",",
"Options",
":",
"resp",
".",
"Options",
",",
"Mode",
":",
"request",
".",
"Mode",
",",
"}",
"\n\n",
"err",
"=",
"pairCreate",
"(",
"pairInfo",
",",
"request",
".",
"SetDefault",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"resp",
".",
"RemoteClusterId",
")",
"\n\n",
"response",
":=",
"&",
"api",
".",
"ClusterPairCreateResponse",
"{",
"RemoteClusterId",
":",
"pairInfo",
".",
"Id",
",",
"RemoteClusterName",
":",
"pairInfo",
".",
"Name",
",",
"}",
"\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] |
// CreatePair remote pairs this cluster with a remote cluster.
|
[
"CreatePair",
"remote",
"pairs",
"this",
"cluster",
"with",
"a",
"remote",
"cluster",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cluster/manager/pair.go#L27-L90
|
144,029 |
libopenstorage/openstorage
|
cluster/manager/pair.go
|
ProcessPairRequest
|
func (c *ClusterManager) ProcessPairRequest(
request *api.ClusterPairProcessRequest,
) (*api.ClusterPairProcessResponse, error) {
if request.SourceClusterId == c.Uuid() {
return nil, fmt.Errorf("Cannot create cluster pair with self")
}
response := &api.ClusterPairProcessResponse{
RemoteClusterId: c.Uuid(),
RemoteClusterName: c.config.ClusterId,
}
// Get the token without resetting it
tokenResp, err := c.GetPairToken(false)
if err != nil {
return nil, fmt.Errorf("Error getting Cluster Token: %v", err)
}
if tokenResp.Token != request.RemoteClusterToken {
return nil, fmt.Errorf("Token mismatch during pairing")
}
// Alert all listeners that we have received a pair request
for e := c.listeners.Front(); e != nil; e = e.Next() {
err := e.Value.(cluster.ClusterListener).ProcessPairRequest(
request,
response,
)
if err != nil {
logrus.Errorf("Unable to notify %v on a a cluster remote pair request: %v",
e.Value.(cluster.ClusterListener).String(),
err,
)
return nil, err
}
}
logrus.Infof("Successfully paired with remote cluster %v", request.SourceClusterId)
return response, nil
}
|
go
|
func (c *ClusterManager) ProcessPairRequest(
request *api.ClusterPairProcessRequest,
) (*api.ClusterPairProcessResponse, error) {
if request.SourceClusterId == c.Uuid() {
return nil, fmt.Errorf("Cannot create cluster pair with self")
}
response := &api.ClusterPairProcessResponse{
RemoteClusterId: c.Uuid(),
RemoteClusterName: c.config.ClusterId,
}
// Get the token without resetting it
tokenResp, err := c.GetPairToken(false)
if err != nil {
return nil, fmt.Errorf("Error getting Cluster Token: %v", err)
}
if tokenResp.Token != request.RemoteClusterToken {
return nil, fmt.Errorf("Token mismatch during pairing")
}
// Alert all listeners that we have received a pair request
for e := c.listeners.Front(); e != nil; e = e.Next() {
err := e.Value.(cluster.ClusterListener).ProcessPairRequest(
request,
response,
)
if err != nil {
logrus.Errorf("Unable to notify %v on a a cluster remote pair request: %v",
e.Value.(cluster.ClusterListener).String(),
err,
)
return nil, err
}
}
logrus.Infof("Successfully paired with remote cluster %v", request.SourceClusterId)
return response, nil
}
|
[
"func",
"(",
"c",
"*",
"ClusterManager",
")",
"ProcessPairRequest",
"(",
"request",
"*",
"api",
".",
"ClusterPairProcessRequest",
",",
")",
"(",
"*",
"api",
".",
"ClusterPairProcessResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"SourceClusterId",
"==",
"c",
".",
"Uuid",
"(",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"response",
":=",
"&",
"api",
".",
"ClusterPairProcessResponse",
"{",
"RemoteClusterId",
":",
"c",
".",
"Uuid",
"(",
")",
",",
"RemoteClusterName",
":",
"c",
".",
"config",
".",
"ClusterId",
",",
"}",
"\n\n",
"// Get the token without resetting it",
"tokenResp",
",",
"err",
":=",
"c",
".",
"GetPairToken",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"tokenResp",
".",
"Token",
"!=",
"request",
".",
"RemoteClusterToken",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Alert all listeners that we have received a pair request",
"for",
"e",
":=",
"c",
".",
"listeners",
".",
"Front",
"(",
")",
";",
"e",
"!=",
"nil",
";",
"e",
"=",
"e",
".",
"Next",
"(",
")",
"{",
"err",
":=",
"e",
".",
"Value",
".",
"(",
"cluster",
".",
"ClusterListener",
")",
".",
"ProcessPairRequest",
"(",
"request",
",",
"response",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"e",
".",
"Value",
".",
"(",
"cluster",
".",
"ClusterListener",
")",
".",
"String",
"(",
")",
",",
"err",
",",
")",
"\n\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"request",
".",
"SourceClusterId",
")",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] |
// ProcessPairRequest handles a remote cluster's pair request
|
[
"ProcessPairRequest",
"handles",
"a",
"remote",
"cluster",
"s",
"pair",
"request"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cluster/manager/pair.go#L93-L133
|
144,030 |
libopenstorage/openstorage
|
cluster/manager/pair.go
|
getDefaultPairId
|
func getDefaultPairId() (string, error) {
kv := kvdb.Instance()
kvp, err := kv.Get(clusterPairDefaultKey)
if err != nil {
return "", err
}
return string(kvp.Value), nil
}
|
go
|
func getDefaultPairId() (string, error) {
kv := kvdb.Instance()
kvp, err := kv.Get(clusterPairDefaultKey)
if err != nil {
return "", err
}
return string(kvp.Value), nil
}
|
[
"func",
"getDefaultPairId",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"kv",
":=",
"kvdb",
".",
"Instance",
"(",
")",
"\n",
"kvp",
",",
"err",
":=",
"kv",
".",
"Get",
"(",
"clusterPairDefaultKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"string",
"(",
"kvp",
".",
"Value",
")",
",",
"nil",
"\n",
"}"
] |
// Return the default pair id if set, error if none set
|
[
"Return",
"the",
"default",
"pair",
"id",
"if",
"set",
"error",
"if",
"none",
"set"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cluster/manager/pair.go#L424-L431
|
144,031 |
libopenstorage/openstorage
|
pkg/flexvolume/flexvolume.pb.gw.go
|
RegisterAPIHandler
|
func RegisterAPIHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterAPIHandlerClient(ctx, mux, NewAPIClient(conn))
}
|
go
|
func RegisterAPIHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterAPIHandlerClient(ctx, mux, NewAPIClient(conn))
}
|
[
"func",
"RegisterAPIHandler",
"(",
"ctx",
"context",
".",
"Context",
",",
"mux",
"*",
"runtime",
".",
"ServeMux",
",",
"conn",
"*",
"grpc",
".",
"ClientConn",
")",
"error",
"{",
"return",
"RegisterAPIHandlerClient",
"(",
"ctx",
",",
"mux",
",",
"NewAPIClient",
"(",
"conn",
")",
")",
"\n",
"}"
] |
// RegisterAPIHandler registers the http handlers for service API to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
|
[
"RegisterAPIHandler",
"registers",
"the",
"http",
"handlers",
"for",
"service",
"API",
"to",
"mux",
".",
"The",
"handlers",
"forward",
"requests",
"to",
"the",
"grpc",
"endpoint",
"over",
"conn",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/flexvolume/flexvolume.pb.gw.go#L124-L126
|
144,032 |
libopenstorage/openstorage
|
pkg/sanity/sanity.go
|
CloudProviderConfigParse
|
func CloudProviderConfigParse(filePath string) (*CloudBackupConfig, error) {
config := &CloudBackupConfig{}
data, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, fmt.Errorf("Unable to read the Cloud backup configuration file (%s): %s", filePath, err.Error())
}
if err := yaml.Unmarshal(data, config); err != nil {
return nil, fmt.Errorf("Unable to parse Cloud backup configuration: %s", err.Error())
}
return config, nil
}
|
go
|
func CloudProviderConfigParse(filePath string) (*CloudBackupConfig, error) {
config := &CloudBackupConfig{}
data, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, fmt.Errorf("Unable to read the Cloud backup configuration file (%s): %s", filePath, err.Error())
}
if err := yaml.Unmarshal(data, config); err != nil {
return nil, fmt.Errorf("Unable to parse Cloud backup configuration: %s", err.Error())
}
return config, nil
}
|
[
"func",
"CloudProviderConfigParse",
"(",
"filePath",
"string",
")",
"(",
"*",
"CloudBackupConfig",
",",
"error",
")",
"{",
"config",
":=",
"&",
"CloudBackupConfig",
"{",
"}",
"\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"filePath",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"yaml",
".",
"Unmarshal",
"(",
"data",
",",
"config",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"config",
",",
"nil",
"\n\n",
"}"
] |
// CloudProviderConfigParse parses the config file of cloudBackup
|
[
"CloudProviderConfigParse",
"parses",
"the",
"config",
"file",
"of",
"cloudBackup"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/sanity/sanity.go#L65-L77
|
144,033 |
libopenstorage/openstorage
|
volume/drivers/drivers.go
|
Register
|
func Register(name string, params map[string]string) error {
return volumeDriverRegistry.Register(name, params)
}
|
go
|
func Register(name string, params map[string]string) error {
return volumeDriverRegistry.Register(name, params)
}
|
[
"func",
"Register",
"(",
"name",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"error",
"{",
"return",
"volumeDriverRegistry",
".",
"Register",
"(",
"name",
",",
"params",
")",
"\n",
"}"
] |
// Register registers a new driver.
|
[
"Register",
"registers",
"a",
"new",
"driver",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/drivers.go#L62-L64
|
144,034 |
libopenstorage/openstorage
|
volume/drivers/drivers.go
|
Add
|
func Add(name string, init func(map[string]string) (volume.VolumeDriver, error)) error {
return volumeDriverRegistry.Add(name, init)
}
|
go
|
func Add(name string, init func(map[string]string) (volume.VolumeDriver, error)) error {
return volumeDriverRegistry.Add(name, init)
}
|
[
"func",
"Add",
"(",
"name",
"string",
",",
"init",
"func",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"volume",
".",
"VolumeDriver",
",",
"error",
")",
")",
"error",
"{",
"return",
"volumeDriverRegistry",
".",
"Add",
"(",
"name",
",",
"init",
")",
"\n",
"}"
] |
// Add adds a new driver.
|
[
"Add",
"adds",
"a",
"new",
"driver",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/drivers.go#L67-L69
|
144,035 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
Create
|
func (s *VolumeServer) Create(
ctx context.Context,
req *api.SdkVolumeCreateRequest,
) (*api.SdkVolumeCreateResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetName()) == 0 {
return nil, status.Error(
codes.InvalidArgument,
"Must supply a unique name")
} else if req.GetSpec() == nil {
return nil, status.Error(
codes.InvalidArgument,
"Must supply spec object")
}
locator := &api.VolumeLocator{
Name: req.GetName(),
VolumeLabels: req.GetLabels(),
}
source := &api.Source{}
// Validate/Update given spec according to default storage policy set
// In case policy is not set, should fall back to default way
// of creating volume
spec, err := GetDefaultVolSpecs(ctx, req.GetSpec(), false)
if err != nil {
return nil, err
}
// Copy any labels from the spec to the locator
locator = locator.MergeVolumeSpecLabels(spec)
// Convert node IP to ID if necessary for API calls
if err := s.updateReplicaSpecNodeIPstoIds(spec.GetReplicaSet()); err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get replicat set information: %v", err)
}
// Create volume
id, err := s.create(ctx, locator, source, spec)
if err != nil {
return nil, err
}
return &api.SdkVolumeCreateResponse{
VolumeId: id,
}, nil
}
|
go
|
func (s *VolumeServer) Create(
ctx context.Context,
req *api.SdkVolumeCreateRequest,
) (*api.SdkVolumeCreateResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetName()) == 0 {
return nil, status.Error(
codes.InvalidArgument,
"Must supply a unique name")
} else if req.GetSpec() == nil {
return nil, status.Error(
codes.InvalidArgument,
"Must supply spec object")
}
locator := &api.VolumeLocator{
Name: req.GetName(),
VolumeLabels: req.GetLabels(),
}
source := &api.Source{}
// Validate/Update given spec according to default storage policy set
// In case policy is not set, should fall back to default way
// of creating volume
spec, err := GetDefaultVolSpecs(ctx, req.GetSpec(), false)
if err != nil {
return nil, err
}
// Copy any labels from the spec to the locator
locator = locator.MergeVolumeSpecLabels(spec)
// Convert node IP to ID if necessary for API calls
if err := s.updateReplicaSpecNodeIPstoIds(spec.GetReplicaSet()); err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get replicat set information: %v", err)
}
// Create volume
id, err := s.create(ctx, locator, source, spec)
if err != nil {
return nil, err
}
return &api.SdkVolumeCreateResponse{
VolumeId: id,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeCreateResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetName",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"req",
".",
"GetSpec",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"locator",
":=",
"&",
"api",
".",
"VolumeLocator",
"{",
"Name",
":",
"req",
".",
"GetName",
"(",
")",
",",
"VolumeLabels",
":",
"req",
".",
"GetLabels",
"(",
")",
",",
"}",
"\n",
"source",
":=",
"&",
"api",
".",
"Source",
"{",
"}",
"\n\n",
"// Validate/Update given spec according to default storage policy set",
"// In case policy is not set, should fall back to default way",
"// of creating volume",
"spec",
",",
"err",
":=",
"GetDefaultVolSpecs",
"(",
"ctx",
",",
"req",
".",
"GetSpec",
"(",
")",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Copy any labels from the spec to the locator",
"locator",
"=",
"locator",
".",
"MergeVolumeSpecLabels",
"(",
"spec",
")",
"\n\n",
"// Convert node IP to ID if necessary for API calls",
"if",
"err",
":=",
"s",
".",
"updateReplicaSpecNodeIPstoIds",
"(",
"spec",
".",
"GetReplicaSet",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Create volume",
"id",
",",
"err",
":=",
"s",
".",
"create",
"(",
"ctx",
",",
"locator",
",",
"source",
",",
"spec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeCreateResponse",
"{",
"VolumeId",
":",
"id",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Create creates a new volume
|
[
"Create",
"creates",
"a",
"new",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L144-L193
|
144,036 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
Clone
|
func (s *VolumeServer) Clone(
ctx context.Context,
req *api.SdkVolumeCloneRequest,
) (*api.SdkVolumeCloneResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetName()) == 0 {
return nil, status.Error(
codes.InvalidArgument,
"Must supply a uniqe name")
} else if len(req.GetParentId()) == 0 {
return nil, status.Error(
codes.InvalidArgument,
"Must parent volume id")
}
locator := &api.VolumeLocator{
Name: req.GetName(),
}
source := &api.Source{
Parent: req.GetParentId(),
}
// Get spec. This also checks if the parend id exists.
// This will also check for Ownership_Read access.
parentVol, err := s.Inspect(ctx, &api.SdkVolumeInspectRequest{
VolumeId: req.GetParentId(),
})
if err != nil {
return nil, err
}
// Create the clone
id, err := s.create(ctx, locator, source, parentVol.GetVolume().GetSpec())
if err != nil {
return nil, err
}
return &api.SdkVolumeCloneResponse{
VolumeId: id,
}, nil
}
|
go
|
func (s *VolumeServer) Clone(
ctx context.Context,
req *api.SdkVolumeCloneRequest,
) (*api.SdkVolumeCloneResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetName()) == 0 {
return nil, status.Error(
codes.InvalidArgument,
"Must supply a uniqe name")
} else if len(req.GetParentId()) == 0 {
return nil, status.Error(
codes.InvalidArgument,
"Must parent volume id")
}
locator := &api.VolumeLocator{
Name: req.GetName(),
}
source := &api.Source{
Parent: req.GetParentId(),
}
// Get spec. This also checks if the parend id exists.
// This will also check for Ownership_Read access.
parentVol, err := s.Inspect(ctx, &api.SdkVolumeInspectRequest{
VolumeId: req.GetParentId(),
})
if err != nil {
return nil, err
}
// Create the clone
id, err := s.create(ctx, locator, source, parentVol.GetVolume().GetSpec())
if err != nil {
return nil, err
}
return &api.SdkVolumeCloneResponse{
VolumeId: id,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Clone",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeCloneRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeCloneResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetName",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"req",
".",
"GetParentId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"locator",
":=",
"&",
"api",
".",
"VolumeLocator",
"{",
"Name",
":",
"req",
".",
"GetName",
"(",
")",
",",
"}",
"\n",
"source",
":=",
"&",
"api",
".",
"Source",
"{",
"Parent",
":",
"req",
".",
"GetParentId",
"(",
")",
",",
"}",
"\n\n",
"// Get spec. This also checks if the parend id exists.",
"// This will also check for Ownership_Read access.",
"parentVol",
",",
"err",
":=",
"s",
".",
"Inspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkVolumeInspectRequest",
"{",
"VolumeId",
":",
"req",
".",
"GetParentId",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Create the clone",
"id",
",",
"err",
":=",
"s",
".",
"create",
"(",
"ctx",
",",
"locator",
",",
"source",
",",
"parentVol",
".",
"GetVolume",
"(",
")",
".",
"GetSpec",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeCloneResponse",
"{",
"VolumeId",
":",
"id",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Clone creates a new volume from an existing volume
|
[
"Clone",
"creates",
"a",
"new",
"volume",
"from",
"an",
"existing",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L196-L239
|
144,037 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
Delete
|
func (s *VolumeServer) Delete(
ctx context.Context,
req *api.SdkVolumeDeleteRequest,
) (*api.SdkVolumeDeleteResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply volume id")
}
// If the volume is not found, return OK to be idempotent
// This checks access rights also
resp, err := s.Inspect(ctx, &api.SdkVolumeInspectRequest{
VolumeId: req.GetVolumeId(),
})
if err != nil {
if IsErrorNotFound(err) {
return &api.SdkVolumeDeleteResponse{}, nil
}
return nil, err
}
vol := resp.GetVolume()
// Only the owner or the admin can delete
if !vol.IsPermitted(ctx, api.Ownership_Admin) {
return nil, status.Errorf(codes.PermissionDenied, "Cannot delete volume %v", vol.GetId())
}
// Delete the volume
err = s.driver(ctx).Delete(req.GetVolumeId())
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to delete volume %s: %v",
req.GetVolumeId(),
err.Error())
}
return &api.SdkVolumeDeleteResponse{}, nil
}
|
go
|
func (s *VolumeServer) Delete(
ctx context.Context,
req *api.SdkVolumeDeleteRequest,
) (*api.SdkVolumeDeleteResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply volume id")
}
// If the volume is not found, return OK to be idempotent
// This checks access rights also
resp, err := s.Inspect(ctx, &api.SdkVolumeInspectRequest{
VolumeId: req.GetVolumeId(),
})
if err != nil {
if IsErrorNotFound(err) {
return &api.SdkVolumeDeleteResponse{}, nil
}
return nil, err
}
vol := resp.GetVolume()
// Only the owner or the admin can delete
if !vol.IsPermitted(ctx, api.Ownership_Admin) {
return nil, status.Errorf(codes.PermissionDenied, "Cannot delete volume %v", vol.GetId())
}
// Delete the volume
err = s.driver(ctx).Delete(req.GetVolumeId())
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to delete volume %s: %v",
req.GetVolumeId(),
err.Error())
}
return &api.SdkVolumeDeleteResponse{}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Delete",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeDeleteRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeDeleteResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// If the volume is not found, return OK to be idempotent",
"// This checks access rights also",
"resp",
",",
"err",
":=",
"s",
".",
"Inspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkVolumeInspectRequest",
"{",
"VolumeId",
":",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"IsErrorNotFound",
"(",
"err",
")",
"{",
"return",
"&",
"api",
".",
"SdkVolumeDeleteResponse",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"vol",
":=",
"resp",
".",
"GetVolume",
"(",
")",
"\n\n",
"// Only the owner or the admin can delete",
"if",
"!",
"vol",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Admin",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
",",
"vol",
".",
"GetId",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Delete the volume",
"err",
"=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"Delete",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeDeleteResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// Delete deletes a volume
|
[
"Delete",
"deletes",
"a",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L242-L283
|
144,038 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
InspectWithFilters
|
func (s *VolumeServer) InspectWithFilters(
ctx context.Context,
req *api.SdkVolumeInspectWithFiltersRequest,
) (*api.SdkVolumeInspectWithFiltersResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
var locator *api.VolumeLocator
if len(req.GetName()) != 0 ||
len(req.GetLabels()) != 0 ||
req.GetOwnership() != nil {
locator = &api.VolumeLocator{
Name: req.GetName(),
VolumeLabels: req.GetLabels(),
Ownership: req.GetOwnership(),
}
}
enumVols, err := s.driver(ctx).Enumerate(locator, nil)
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to enumerate volumes: %v",
err.Error())
}
vols := make([]*api.SdkVolumeInspectResponse, 0, len(enumVols))
for _, vol := range enumVols {
// Check access
if vol.IsPermitted(ctx, api.Ownership_Read) {
// Check if the caller wants more information
if req.GetOptions().GetDeep() {
resp, err := s.Inspect(ctx, &api.SdkVolumeInspectRequest{
VolumeId: vol.GetId(),
Options: req.GetOptions(),
})
if IsErrorNotFound(err) {
continue
} else if err != nil {
return nil, err
}
vols = append(vols, resp)
} else {
// Caller does not require a deep inspect
// Add the object now
vols = append(vols, &api.SdkVolumeInspectResponse{
Volume: vol,
Name: vol.GetLocator().GetName(),
Labels: vol.GetLocator().GetVolumeLabels(),
})
}
}
}
return &api.SdkVolumeInspectWithFiltersResponse{
Volumes: vols,
}, nil
}
|
go
|
func (s *VolumeServer) InspectWithFilters(
ctx context.Context,
req *api.SdkVolumeInspectWithFiltersRequest,
) (*api.SdkVolumeInspectWithFiltersResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
var locator *api.VolumeLocator
if len(req.GetName()) != 0 ||
len(req.GetLabels()) != 0 ||
req.GetOwnership() != nil {
locator = &api.VolumeLocator{
Name: req.GetName(),
VolumeLabels: req.GetLabels(),
Ownership: req.GetOwnership(),
}
}
enumVols, err := s.driver(ctx).Enumerate(locator, nil)
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to enumerate volumes: %v",
err.Error())
}
vols := make([]*api.SdkVolumeInspectResponse, 0, len(enumVols))
for _, vol := range enumVols {
// Check access
if vol.IsPermitted(ctx, api.Ownership_Read) {
// Check if the caller wants more information
if req.GetOptions().GetDeep() {
resp, err := s.Inspect(ctx, &api.SdkVolumeInspectRequest{
VolumeId: vol.GetId(),
Options: req.GetOptions(),
})
if IsErrorNotFound(err) {
continue
} else if err != nil {
return nil, err
}
vols = append(vols, resp)
} else {
// Caller does not require a deep inspect
// Add the object now
vols = append(vols, &api.SdkVolumeInspectResponse{
Volume: vol,
Name: vol.GetLocator().GetName(),
Labels: vol.GetLocator().GetVolumeLabels(),
})
}
}
}
return &api.SdkVolumeInspectWithFiltersResponse{
Volumes: vols,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"InspectWithFilters",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeInspectWithFiltersRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeInspectWithFiltersResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"locator",
"*",
"api",
".",
"VolumeLocator",
"\n",
"if",
"len",
"(",
"req",
".",
"GetName",
"(",
")",
")",
"!=",
"0",
"||",
"len",
"(",
"req",
".",
"GetLabels",
"(",
")",
")",
"!=",
"0",
"||",
"req",
".",
"GetOwnership",
"(",
")",
"!=",
"nil",
"{",
"locator",
"=",
"&",
"api",
".",
"VolumeLocator",
"{",
"Name",
":",
"req",
".",
"GetName",
"(",
")",
",",
"VolumeLabels",
":",
"req",
".",
"GetLabels",
"(",
")",
",",
"Ownership",
":",
"req",
".",
"GetOwnership",
"(",
")",
",",
"}",
"\n",
"}",
"\n\n",
"enumVols",
",",
"err",
":=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"Enumerate",
"(",
"locator",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"vols",
":=",
"make",
"(",
"[",
"]",
"*",
"api",
".",
"SdkVolumeInspectResponse",
",",
"0",
",",
"len",
"(",
"enumVols",
")",
")",
"\n",
"for",
"_",
",",
"vol",
":=",
"range",
"enumVols",
"{",
"// Check access",
"if",
"vol",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Read",
")",
"{",
"// Check if the caller wants more information",
"if",
"req",
".",
"GetOptions",
"(",
")",
".",
"GetDeep",
"(",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"Inspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkVolumeInspectRequest",
"{",
"VolumeId",
":",
"vol",
".",
"GetId",
"(",
")",
",",
"Options",
":",
"req",
".",
"GetOptions",
"(",
")",
",",
"}",
")",
"\n",
"if",
"IsErrorNotFound",
"(",
"err",
")",
"{",
"continue",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"vols",
"=",
"append",
"(",
"vols",
",",
"resp",
")",
"\n",
"}",
"else",
"{",
"// Caller does not require a deep inspect",
"// Add the object now",
"vols",
"=",
"append",
"(",
"vols",
",",
"&",
"api",
".",
"SdkVolumeInspectResponse",
"{",
"Volume",
":",
"vol",
",",
"Name",
":",
"vol",
".",
"GetLocator",
"(",
")",
".",
"GetName",
"(",
")",
",",
"Labels",
":",
"vol",
".",
"GetLocator",
"(",
")",
".",
"GetVolumeLabels",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeInspectWithFiltersResponse",
"{",
"Volumes",
":",
"vols",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// InspectWithFilters is a helper function returning information about volumes which match a filter
|
[
"InspectWithFilters",
"is",
"a",
"helper",
"function",
"returning",
"information",
"about",
"volumes",
"which",
"match",
"a",
"filter"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L286-L346
|
144,039 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
Inspect
|
func (s *VolumeServer) Inspect(
ctx context.Context,
req *api.SdkVolumeInspectRequest,
) (*api.SdkVolumeInspectResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply volume id")
}
var v *api.Volume
if !req.GetOptions().GetDeep() {
vols, err := s.driver(ctx).Enumerate(&api.VolumeLocator{
VolumeIds: []string{req.GetVolumeId()},
}, nil)
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to inspect volume %s: %v",
req.GetVolumeId(), err)
}
if len(vols) == 0 {
return nil, status.Errorf(
codes.NotFound,
"Volume id %s not found",
req.GetVolumeId())
}
v = vols[0]
} else {
vols, err := s.driver(ctx).Inspect([]string{req.GetVolumeId()})
if err == kvdb.ErrNotFound || (err == nil && len(vols) == 0) {
return nil, status.Errorf(
codes.NotFound,
"Volume id %s not found",
req.GetVolumeId())
} else if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to inspect volume %s: %v",
req.GetVolumeId(), err)
}
v = vols[0]
}
// Check ownership
if !v.IsPermitted(ctx, api.Ownership_Read) {
return nil, status.Errorf(codes.PermissionDenied, "Access denied to volume %s", v.GetId())
}
return &api.SdkVolumeInspectResponse{
Volume: v,
Name: v.GetLocator().GetName(),
Labels: v.GetLocator().GetVolumeLabels(),
}, nil
}
|
go
|
func (s *VolumeServer) Inspect(
ctx context.Context,
req *api.SdkVolumeInspectRequest,
) (*api.SdkVolumeInspectResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply volume id")
}
var v *api.Volume
if !req.GetOptions().GetDeep() {
vols, err := s.driver(ctx).Enumerate(&api.VolumeLocator{
VolumeIds: []string{req.GetVolumeId()},
}, nil)
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to inspect volume %s: %v",
req.GetVolumeId(), err)
}
if len(vols) == 0 {
return nil, status.Errorf(
codes.NotFound,
"Volume id %s not found",
req.GetVolumeId())
}
v = vols[0]
} else {
vols, err := s.driver(ctx).Inspect([]string{req.GetVolumeId()})
if err == kvdb.ErrNotFound || (err == nil && len(vols) == 0) {
return nil, status.Errorf(
codes.NotFound,
"Volume id %s not found",
req.GetVolumeId())
} else if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to inspect volume %s: %v",
req.GetVolumeId(), err)
}
v = vols[0]
}
// Check ownership
if !v.IsPermitted(ctx, api.Ownership_Read) {
return nil, status.Errorf(codes.PermissionDenied, "Access denied to volume %s", v.GetId())
}
return &api.SdkVolumeInspectResponse{
Volume: v,
Name: v.GetLocator().GetName(),
Labels: v.GetLocator().GetVolumeLabels(),
}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Inspect",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeInspectRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeInspectResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"v",
"*",
"api",
".",
"Volume",
"\n",
"if",
"!",
"req",
".",
"GetOptions",
"(",
")",
".",
"GetDeep",
"(",
")",
"{",
"vols",
",",
"err",
":=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"Enumerate",
"(",
"&",
"api",
".",
"VolumeLocator",
"{",
"VolumeIds",
":",
"[",
"]",
"string",
"{",
"req",
".",
"GetVolumeId",
"(",
")",
"}",
",",
"}",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"vols",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n",
"}",
"\n",
"v",
"=",
"vols",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"vols",
",",
"err",
":=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"Inspect",
"(",
"[",
"]",
"string",
"{",
"req",
".",
"GetVolumeId",
"(",
")",
"}",
")",
"\n",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"||",
"(",
"err",
"==",
"nil",
"&&",
"len",
"(",
"vols",
")",
"==",
"0",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"v",
"=",
"vols",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"// Check ownership",
"if",
"!",
"v",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Read",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
",",
"v",
".",
"GetId",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeInspectResponse",
"{",
"Volume",
":",
"v",
",",
"Name",
":",
"v",
".",
"GetLocator",
"(",
")",
".",
"GetName",
"(",
")",
",",
"Labels",
":",
"v",
".",
"GetLocator",
"(",
")",
".",
"GetVolumeLabels",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Inspect returns information about a volume
|
[
"Inspect",
"returns",
"information",
"about",
"a",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L349-L405
|
144,040 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
Enumerate
|
func (s *VolumeServer) Enumerate(
ctx context.Context,
req *api.SdkVolumeEnumerateRequest,
) (*api.SdkVolumeEnumerateResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
resp, err := s.EnumerateWithFilters(
ctx,
&api.SdkVolumeEnumerateWithFiltersRequest{},
)
if err != nil {
return nil, err
}
return &api.SdkVolumeEnumerateResponse{
VolumeIds: resp.GetVolumeIds(),
}, nil
}
|
go
|
func (s *VolumeServer) Enumerate(
ctx context.Context,
req *api.SdkVolumeEnumerateRequest,
) (*api.SdkVolumeEnumerateResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
resp, err := s.EnumerateWithFilters(
ctx,
&api.SdkVolumeEnumerateWithFiltersRequest{},
)
if err != nil {
return nil, err
}
return &api.SdkVolumeEnumerateResponse{
VolumeIds: resp.GetVolumeIds(),
}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Enumerate",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeEnumerateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeEnumerateResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"EnumerateWithFilters",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkVolumeEnumerateWithFiltersRequest",
"{",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeEnumerateResponse",
"{",
"VolumeIds",
":",
"resp",
".",
"GetVolumeIds",
"(",
")",
",",
"}",
",",
"nil",
"\n\n",
"}"
] |
// Enumerate returns a list of volumes
|
[
"Enumerate",
"returns",
"a",
"list",
"of",
"volumes"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L408-L428
|
144,041 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
EnumerateWithFilters
|
func (s *VolumeServer) EnumerateWithFilters(
ctx context.Context,
req *api.SdkVolumeEnumerateWithFiltersRequest,
) (*api.SdkVolumeEnumerateWithFiltersResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
var locator *api.VolumeLocator
if len(req.GetName()) != 0 ||
len(req.GetLabels()) != 0 ||
req.GetOwnership() != nil {
locator = &api.VolumeLocator{
Name: req.GetName(),
VolumeLabels: req.GetLabels(),
Ownership: req.GetOwnership(),
}
}
vols, err := s.driver(ctx).Enumerate(locator, nil)
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to enumerate volumes: %v",
err.Error())
}
ids := make([]string, 0)
for _, vol := range vols {
// Check access
if vol.IsPermitted(ctx, api.Ownership_Read) {
ids = append(ids, vol.GetId())
}
}
return &api.SdkVolumeEnumerateWithFiltersResponse{
VolumeIds: ids,
}, nil
}
|
go
|
func (s *VolumeServer) EnumerateWithFilters(
ctx context.Context,
req *api.SdkVolumeEnumerateWithFiltersRequest,
) (*api.SdkVolumeEnumerateWithFiltersResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
var locator *api.VolumeLocator
if len(req.GetName()) != 0 ||
len(req.GetLabels()) != 0 ||
req.GetOwnership() != nil {
locator = &api.VolumeLocator{
Name: req.GetName(),
VolumeLabels: req.GetLabels(),
Ownership: req.GetOwnership(),
}
}
vols, err := s.driver(ctx).Enumerate(locator, nil)
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to enumerate volumes: %v",
err.Error())
}
ids := make([]string, 0)
for _, vol := range vols {
// Check access
if vol.IsPermitted(ctx, api.Ownership_Read) {
ids = append(ids, vol.GetId())
}
}
return &api.SdkVolumeEnumerateWithFiltersResponse{
VolumeIds: ids,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"EnumerateWithFilters",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeEnumerateWithFiltersRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeEnumerateWithFiltersResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"locator",
"*",
"api",
".",
"VolumeLocator",
"\n",
"if",
"len",
"(",
"req",
".",
"GetName",
"(",
")",
")",
"!=",
"0",
"||",
"len",
"(",
"req",
".",
"GetLabels",
"(",
")",
")",
"!=",
"0",
"||",
"req",
".",
"GetOwnership",
"(",
")",
"!=",
"nil",
"{",
"locator",
"=",
"&",
"api",
".",
"VolumeLocator",
"{",
"Name",
":",
"req",
".",
"GetName",
"(",
")",
",",
"VolumeLabels",
":",
"req",
".",
"GetLabels",
"(",
")",
",",
"Ownership",
":",
"req",
".",
"GetOwnership",
"(",
")",
",",
"}",
"\n",
"}",
"\n\n",
"vols",
",",
"err",
":=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"Enumerate",
"(",
"locator",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"ids",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"_",
",",
"vol",
":=",
"range",
"vols",
"{",
"// Check access",
"if",
"vol",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Read",
")",
"{",
"ids",
"=",
"append",
"(",
"ids",
",",
"vol",
".",
"GetId",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeEnumerateWithFiltersResponse",
"{",
"VolumeIds",
":",
"ids",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// EnumerateWithFilters returns a list of volumes for the provided filters
|
[
"EnumerateWithFilters",
"returns",
"a",
"list",
"of",
"volumes",
"for",
"the",
"provided",
"filters"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L431-L470
|
144,042 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
Update
|
func (s *VolumeServer) Update(
ctx context.Context,
req *api.SdkVolumeUpdateRequest,
) (*api.SdkVolumeUpdateResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply volume id")
}
// Get current state
// This checks for Read access in ownership
resp, err := s.Inspect(ctx, &api.SdkVolumeInspectRequest{
VolumeId: req.GetVolumeId(),
})
if err != nil {
return nil, err
}
// Check if the caller can update the volume
if !resp.GetVolume().IsPermitted(ctx, api.Ownership_Write) {
return nil, status.Errorf(codes.PermissionDenied, "Cannot update volume")
}
// Merge specs
spec := s.mergeVolumeSpecs(resp.GetVolume().GetSpec(), req.GetSpec())
// Update Ownership... carefully
// First point to the original ownership
spec.Ownership = resp.GetVolume().GetSpec().GetOwnership()
// Check if we have been provided an update to the ownership
if req.GetSpec().GetOwnership() != nil {
if spec.Ownership == nil {
spec.Ownership = &api.Ownership{}
}
user, _ := auth.NewUserInfoFromContext(ctx)
if err := spec.Ownership.Update(req.GetSpec().GetOwnership(), user); err != nil {
return nil, err
}
}
// Check if labels have been updated
var locator *api.VolumeLocator
if len(req.GetLabels()) != 0 {
locator = &api.VolumeLocator{VolumeLabels: req.GetLabels()}
}
// Validate/Update given spec according to default storage policy set
// to make sure if update does not violates default policy
updatedSpec, err := GetDefaultVolSpecs(ctx, spec, true)
if err != nil {
return nil, err
}
// Send to driver
if err := s.driver(ctx).Set(req.GetVolumeId(), locator, updatedSpec); err != nil {
return nil, status.Errorf(codes.Internal, "Failed to update volume: %v", err)
}
return &api.SdkVolumeUpdateResponse{}, nil
}
|
go
|
func (s *VolumeServer) Update(
ctx context.Context,
req *api.SdkVolumeUpdateRequest,
) (*api.SdkVolumeUpdateResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply volume id")
}
// Get current state
// This checks for Read access in ownership
resp, err := s.Inspect(ctx, &api.SdkVolumeInspectRequest{
VolumeId: req.GetVolumeId(),
})
if err != nil {
return nil, err
}
// Check if the caller can update the volume
if !resp.GetVolume().IsPermitted(ctx, api.Ownership_Write) {
return nil, status.Errorf(codes.PermissionDenied, "Cannot update volume")
}
// Merge specs
spec := s.mergeVolumeSpecs(resp.GetVolume().GetSpec(), req.GetSpec())
// Update Ownership... carefully
// First point to the original ownership
spec.Ownership = resp.GetVolume().GetSpec().GetOwnership()
// Check if we have been provided an update to the ownership
if req.GetSpec().GetOwnership() != nil {
if spec.Ownership == nil {
spec.Ownership = &api.Ownership{}
}
user, _ := auth.NewUserInfoFromContext(ctx)
if err := spec.Ownership.Update(req.GetSpec().GetOwnership(), user); err != nil {
return nil, err
}
}
// Check if labels have been updated
var locator *api.VolumeLocator
if len(req.GetLabels()) != 0 {
locator = &api.VolumeLocator{VolumeLabels: req.GetLabels()}
}
// Validate/Update given spec according to default storage policy set
// to make sure if update does not violates default policy
updatedSpec, err := GetDefaultVolSpecs(ctx, spec, true)
if err != nil {
return nil, err
}
// Send to driver
if err := s.driver(ctx).Set(req.GetVolumeId(), locator, updatedSpec); err != nil {
return nil, status.Errorf(codes.Internal, "Failed to update volume: %v", err)
}
return &api.SdkVolumeUpdateResponse{}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Update",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeUpdateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeUpdateResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get current state",
"// This checks for Read access in ownership",
"resp",
",",
"err",
":=",
"s",
".",
"Inspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkVolumeInspectRequest",
"{",
"VolumeId",
":",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Check if the caller can update the volume",
"if",
"!",
"resp",
".",
"GetVolume",
"(",
")",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Write",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Merge specs",
"spec",
":=",
"s",
".",
"mergeVolumeSpecs",
"(",
"resp",
".",
"GetVolume",
"(",
")",
".",
"GetSpec",
"(",
")",
",",
"req",
".",
"GetSpec",
"(",
")",
")",
"\n",
"// Update Ownership... carefully",
"// First point to the original ownership",
"spec",
".",
"Ownership",
"=",
"resp",
".",
"GetVolume",
"(",
")",
".",
"GetSpec",
"(",
")",
".",
"GetOwnership",
"(",
")",
"\n\n",
"// Check if we have been provided an update to the ownership",
"if",
"req",
".",
"GetSpec",
"(",
")",
".",
"GetOwnership",
"(",
")",
"!=",
"nil",
"{",
"if",
"spec",
".",
"Ownership",
"==",
"nil",
"{",
"spec",
".",
"Ownership",
"=",
"&",
"api",
".",
"Ownership",
"{",
"}",
"\n",
"}",
"\n\n",
"user",
",",
"_",
":=",
"auth",
".",
"NewUserInfoFromContext",
"(",
"ctx",
")",
"\n",
"if",
"err",
":=",
"spec",
".",
"Ownership",
".",
"Update",
"(",
"req",
".",
"GetSpec",
"(",
")",
".",
"GetOwnership",
"(",
")",
",",
"user",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Check if labels have been updated",
"var",
"locator",
"*",
"api",
".",
"VolumeLocator",
"\n",
"if",
"len",
"(",
"req",
".",
"GetLabels",
"(",
")",
")",
"!=",
"0",
"{",
"locator",
"=",
"&",
"api",
".",
"VolumeLocator",
"{",
"VolumeLabels",
":",
"req",
".",
"GetLabels",
"(",
")",
"}",
"\n",
"}",
"\n\n",
"// Validate/Update given spec according to default storage policy set",
"// to make sure if update does not violates default policy",
"updatedSpec",
",",
"err",
":=",
"GetDefaultVolSpecs",
"(",
"ctx",
",",
"spec",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// Send to driver",
"if",
"err",
":=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"Set",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"locator",
",",
"updatedSpec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeUpdateResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// Update allows the caller to change values in the volume specification
|
[
"Update",
"allows",
"the",
"caller",
"to",
"change",
"values",
"in",
"the",
"volume",
"specification"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L473-L535
|
144,043 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
Stats
|
func (s *VolumeServer) Stats(
ctx context.Context,
req *api.SdkVolumeStatsRequest,
) (*api.SdkVolumeStatsResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply volume id")
}
// Get access rights
if err := s.checkAccessForVolumeId(ctx, req.GetVolumeId(), api.Ownership_Read); err != nil {
return nil, err
}
stats, err := s.driver(ctx).Stats(req.GetVolumeId(), !req.GetNotCumulative())
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to obtain stats for volume %s: %v",
req.GetVolumeId(),
err.Error())
}
return &api.SdkVolumeStatsResponse{
Stats: stats,
}, nil
}
|
go
|
func (s *VolumeServer) Stats(
ctx context.Context,
req *api.SdkVolumeStatsRequest,
) (*api.SdkVolumeStatsResponse, error) {
if s.cluster() == nil || s.driver(ctx) == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply volume id")
}
// Get access rights
if err := s.checkAccessForVolumeId(ctx, req.GetVolumeId(), api.Ownership_Read); err != nil {
return nil, err
}
stats, err := s.driver(ctx).Stats(req.GetVolumeId(), !req.GetNotCumulative())
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to obtain stats for volume %s: %v",
req.GetVolumeId(),
err.Error())
}
return &api.SdkVolumeStatsResponse{
Stats: stats,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeServer",
")",
"Stats",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkVolumeStatsRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkVolumeStatsResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"||",
"s",
".",
"driver",
"(",
"ctx",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get access rights",
"if",
"err",
":=",
"s",
".",
"checkAccessForVolumeId",
"(",
"ctx",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"api",
".",
"Ownership_Read",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"stats",
",",
"err",
":=",
"s",
".",
"driver",
"(",
"ctx",
")",
".",
"Stats",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"!",
"req",
".",
"GetNotCumulative",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkVolumeStatsResponse",
"{",
"Stats",
":",
"stats",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Stats returns volume statistics
|
[
"Stats",
"returns",
"volume",
"statistics"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L538-L567
|
144,044 |
libopenstorage/openstorage
|
api/server/sdk/volume_ops.go
|
GetDefaultVolSpecs
|
func GetDefaultVolSpecs(
ctx context.Context,
spec *api.VolumeSpec,
isUpdate bool,
) (*api.VolumeSpec, error) {
storPolicy, err := policy.Inst()
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to get storage policy instance %v", err)
}
var policy *api.SdkStoragePolicy
// check if custom policy passed with volume
if spec.GetStoragePolicy() != "" {
inspReq := &api.SdkOpenStoragePolicyInspectRequest{
// name of storage policy specified in volSpecs
Name: spec.GetStoragePolicy(),
}
// inspect will make sure user will atleast have read access
customPolicy, customErr := storPolicy.Inspect(ctx, inspReq)
if customErr != nil {
return nil, customErr
}
policy = customPolicy.GetStoragePolicy()
} else {
// check if default storage policy is set
defPolicy, err := storPolicy.DefaultInspect(context.Background(), &api.SdkOpenStoragePolicyDefaultInspectRequest{})
if err != nil {
// err means there is policy stored, but we are not able to retrive it
// hence we are not allowing volume create operation
return nil, status.Errorf(codes.Internal, "Unable to get default policy details %v", err)
} else if defPolicy.GetStoragePolicy() == nil {
// no default storage policy found
return spec, nil
}
policy = defPolicy.GetStoragePolicy()
}
// track volume created using storage policy
spec.StoragePolicy = policy.GetName()
// check if volume update request, if allowupdate is set
// return spec received as it is
if isUpdate && policy.GetAllowUpdate() {
if !policy.IsPermitted(ctx, api.Ownership_Write) {
return nil, status.Errorf(codes.PermissionDenied, "Cannot use storage policy %v", policy.GetName())
}
return spec, nil
}
return mergeVolumeSpecsPolicy(spec, policy.GetPolicy(), policy.GetForce())
}
|
go
|
func GetDefaultVolSpecs(
ctx context.Context,
spec *api.VolumeSpec,
isUpdate bool,
) (*api.VolumeSpec, error) {
storPolicy, err := policy.Inst()
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to get storage policy instance %v", err)
}
var policy *api.SdkStoragePolicy
// check if custom policy passed with volume
if spec.GetStoragePolicy() != "" {
inspReq := &api.SdkOpenStoragePolicyInspectRequest{
// name of storage policy specified in volSpecs
Name: spec.GetStoragePolicy(),
}
// inspect will make sure user will atleast have read access
customPolicy, customErr := storPolicy.Inspect(ctx, inspReq)
if customErr != nil {
return nil, customErr
}
policy = customPolicy.GetStoragePolicy()
} else {
// check if default storage policy is set
defPolicy, err := storPolicy.DefaultInspect(context.Background(), &api.SdkOpenStoragePolicyDefaultInspectRequest{})
if err != nil {
// err means there is policy stored, but we are not able to retrive it
// hence we are not allowing volume create operation
return nil, status.Errorf(codes.Internal, "Unable to get default policy details %v", err)
} else if defPolicy.GetStoragePolicy() == nil {
// no default storage policy found
return spec, nil
}
policy = defPolicy.GetStoragePolicy()
}
// track volume created using storage policy
spec.StoragePolicy = policy.GetName()
// check if volume update request, if allowupdate is set
// return spec received as it is
if isUpdate && policy.GetAllowUpdate() {
if !policy.IsPermitted(ctx, api.Ownership_Write) {
return nil, status.Errorf(codes.PermissionDenied, "Cannot use storage policy %v", policy.GetName())
}
return spec, nil
}
return mergeVolumeSpecsPolicy(spec, policy.GetPolicy(), policy.GetForce())
}
|
[
"func",
"GetDefaultVolSpecs",
"(",
"ctx",
"context",
".",
"Context",
",",
"spec",
"*",
"api",
".",
"VolumeSpec",
",",
"isUpdate",
"bool",
",",
")",
"(",
"*",
"api",
".",
"VolumeSpec",
",",
"error",
")",
"{",
"storPolicy",
",",
"err",
":=",
"policy",
".",
"Inst",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"policy",
"*",
"api",
".",
"SdkStoragePolicy",
"\n",
"// check if custom policy passed with volume",
"if",
"spec",
".",
"GetStoragePolicy",
"(",
")",
"!=",
"\"",
"\"",
"{",
"inspReq",
":=",
"&",
"api",
".",
"SdkOpenStoragePolicyInspectRequest",
"{",
"// name of storage policy specified in volSpecs",
"Name",
":",
"spec",
".",
"GetStoragePolicy",
"(",
")",
",",
"}",
"\n",
"// inspect will make sure user will atleast have read access",
"customPolicy",
",",
"customErr",
":=",
"storPolicy",
".",
"Inspect",
"(",
"ctx",
",",
"inspReq",
")",
"\n",
"if",
"customErr",
"!=",
"nil",
"{",
"return",
"nil",
",",
"customErr",
"\n",
"}",
"\n\n",
"policy",
"=",
"customPolicy",
".",
"GetStoragePolicy",
"(",
")",
"\n",
"}",
"else",
"{",
"// check if default storage policy is set",
"defPolicy",
",",
"err",
":=",
"storPolicy",
".",
"DefaultInspect",
"(",
"context",
".",
"Background",
"(",
")",
",",
"&",
"api",
".",
"SdkOpenStoragePolicyDefaultInspectRequest",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// err means there is policy stored, but we are not able to retrive it",
"// hence we are not allowing volume create operation",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"if",
"defPolicy",
".",
"GetStoragePolicy",
"(",
")",
"==",
"nil",
"{",
"// no default storage policy found",
"return",
"spec",
",",
"nil",
"\n",
"}",
"\n",
"policy",
"=",
"defPolicy",
".",
"GetStoragePolicy",
"(",
")",
"\n",
"}",
"\n\n",
"// track volume created using storage policy",
"spec",
".",
"StoragePolicy",
"=",
"policy",
".",
"GetName",
"(",
")",
"\n",
"// check if volume update request, if allowupdate is set",
"// return spec received as it is",
"if",
"isUpdate",
"&&",
"policy",
".",
"GetAllowUpdate",
"(",
")",
"{",
"if",
"!",
"policy",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Write",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
",",
"policy",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"spec",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"mergeVolumeSpecsPolicy",
"(",
"spec",
",",
"policy",
".",
"GetPolicy",
"(",
")",
",",
"policy",
".",
"GetForce",
"(",
")",
")",
"\n",
"}"
] |
// GetDefaultVolSpecs returns volume spec merged with default storage policy applied if any
|
[
"GetDefaultVolSpecs",
"returns",
"volume",
"spec",
"merged",
"with",
"default",
"storage",
"policy",
"applied",
"if",
"any"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/volume_ops.go#L751-L801
|
144,045 |
libopenstorage/openstorage
|
alerts/alerts.go
|
Tag
|
func (e Error) Tag(tag Error) Error {
return Error(string(tag) + ":" + string(e))
}
|
go
|
func (e Error) Tag(tag Error) Error {
return Error(string(tag) + ":" + string(e))
}
|
[
"func",
"(",
"e",
"Error",
")",
"Tag",
"(",
"tag",
"Error",
")",
"Error",
"{",
"return",
"Error",
"(",
"string",
"(",
"tag",
")",
"+",
"\"",
"\"",
"+",
"string",
"(",
"e",
")",
")",
"\n",
"}"
] |
// Tag tags an error with a tag string.
// Helpful for providing error contexts.
|
[
"Tag",
"tags",
"an",
"error",
"with",
"a",
"tag",
"string",
".",
"Helpful",
"for",
"providing",
"error",
"contexts",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/alerts.go#L27-L29
|
144,046 |
libopenstorage/openstorage
|
alerts/alerts.go
|
Enumerate
|
func (m *manager) Enumerate(filters ...Filter) ([]*api.Alert, error) {
myAlerts := make([]*api.Alert, 0, 0)
keys, err := getUniqueKeysFromFilters(filters...)
if err != nil {
return nil, err
}
// enumerate for unique keys
for key := range keys {
kvps, err := enumerate(m.kv, key)
if err != nil {
return nil, err
}
for _, kvp := range kvps {
alert := new(api.Alert)
if err := json.Unmarshal(kvp.Value, alert); err != nil {
return nil, err
}
if len(filters) == 0 {
myAlerts = append(myAlerts, alert)
continue
}
for _, filter := range filters {
if match, err := filter.Match(alert); err != nil {
return nil, err
} else {
// if alert is matched by at least one filter,
// include it and break out of loop to avoid further checks.
if match {
myAlerts = append(myAlerts, alert)
break
}
}
}
}
}
return myAlerts, nil
}
|
go
|
func (m *manager) Enumerate(filters ...Filter) ([]*api.Alert, error) {
myAlerts := make([]*api.Alert, 0, 0)
keys, err := getUniqueKeysFromFilters(filters...)
if err != nil {
return nil, err
}
// enumerate for unique keys
for key := range keys {
kvps, err := enumerate(m.kv, key)
if err != nil {
return nil, err
}
for _, kvp := range kvps {
alert := new(api.Alert)
if err := json.Unmarshal(kvp.Value, alert); err != nil {
return nil, err
}
if len(filters) == 0 {
myAlerts = append(myAlerts, alert)
continue
}
for _, filter := range filters {
if match, err := filter.Match(alert); err != nil {
return nil, err
} else {
// if alert is matched by at least one filter,
// include it and break out of loop to avoid further checks.
if match {
myAlerts = append(myAlerts, alert)
break
}
}
}
}
}
return myAlerts, nil
}
|
[
"func",
"(",
"m",
"*",
"manager",
")",
"Enumerate",
"(",
"filters",
"...",
"Filter",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Alert",
",",
"error",
")",
"{",
"myAlerts",
":=",
"make",
"(",
"[",
"]",
"*",
"api",
".",
"Alert",
",",
"0",
",",
"0",
")",
"\n",
"keys",
",",
"err",
":=",
"getUniqueKeysFromFilters",
"(",
"filters",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// enumerate for unique keys",
"for",
"key",
":=",
"range",
"keys",
"{",
"kvps",
",",
"err",
":=",
"enumerate",
"(",
"m",
".",
"kv",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"kvp",
":=",
"range",
"kvps",
"{",
"alert",
":=",
"new",
"(",
"api",
".",
"Alert",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"kvp",
".",
"Value",
",",
"alert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"filters",
")",
"==",
"0",
"{",
"myAlerts",
"=",
"append",
"(",
"myAlerts",
",",
"alert",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"filter",
":=",
"range",
"filters",
"{",
"if",
"match",
",",
"err",
":=",
"filter",
".",
"Match",
"(",
"alert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"{",
"// if alert is matched by at least one filter,",
"// include it and break out of loop to avoid further checks.",
"if",
"match",
"{",
"myAlerts",
"=",
"append",
"(",
"myAlerts",
",",
"alert",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"myAlerts",
",",
"nil",
"\n",
"}"
] |
// Enumerate takes a variadic list of filters that are first analyzed to see if one filter
// is inclusive of other. Only the filters that are unique supersets are retained and their contents
// is fetched using kvdb enumerate.
|
[
"Enumerate",
"takes",
"a",
"variadic",
"list",
"of",
"filters",
"that",
"are",
"first",
"analyzed",
"to",
"see",
"if",
"one",
"filter",
"is",
"inclusive",
"of",
"other",
".",
"Only",
"the",
"filters",
"that",
"are",
"unique",
"supersets",
"are",
"retained",
"and",
"their",
"contents",
"is",
"fetched",
"using",
"kvdb",
"enumerate",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/alerts.go#L139-L180
|
144,047 |
libopenstorage/openstorage
|
osdconfig/callback.go
|
execClusterCallbacks
|
func (manager *configManager) execClusterCallbacks(f CallbackClusterConfigFunc, data *data) {
config := new(ClusterConfig)
if err := json.Unmarshal(data.Value, config); err != nil {
logrus.Error(err)
return
}
f(config)
}
|
go
|
func (manager *configManager) execClusterCallbacks(f CallbackClusterConfigFunc, data *data) {
config := new(ClusterConfig)
if err := json.Unmarshal(data.Value, config); err != nil {
logrus.Error(err)
return
}
f(config)
}
|
[
"func",
"(",
"manager",
"*",
"configManager",
")",
"execClusterCallbacks",
"(",
"f",
"CallbackClusterConfigFunc",
",",
"data",
"*",
"data",
")",
"{",
"config",
":=",
"new",
"(",
"ClusterConfig",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
".",
"Value",
",",
"config",
")",
";",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"f",
"(",
"config",
")",
"\n",
"}"
] |
// execClusterCallbacks executes a registered cluster watcher
|
[
"execClusterCallbacks",
"executes",
"a",
"registered",
"cluster",
"watcher"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/osdconfig/callback.go#L12-L20
|
144,048 |
libopenstorage/openstorage
|
osdconfig/callback.go
|
execNodeCallbacks
|
func (manager *configManager) execNodeCallbacks(f CallbackNodeConfigFunc, data *data) {
config := new(NodeConfig)
if err := json.Unmarshal(data.Value, config); err != nil {
logrus.Error(err)
return
}
f(config)
}
|
go
|
func (manager *configManager) execNodeCallbacks(f CallbackNodeConfigFunc, data *data) {
config := new(NodeConfig)
if err := json.Unmarshal(data.Value, config); err != nil {
logrus.Error(err)
return
}
f(config)
}
|
[
"func",
"(",
"manager",
"*",
"configManager",
")",
"execNodeCallbacks",
"(",
"f",
"CallbackNodeConfigFunc",
",",
"data",
"*",
"data",
")",
"{",
"config",
":=",
"new",
"(",
"NodeConfig",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
".",
"Value",
",",
"config",
")",
";",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"f",
"(",
"config",
")",
"\n",
"}"
] |
// execNodeCallbacks executes a registered node watcher
|
[
"execNodeCallbacks",
"executes",
"a",
"registered",
"node",
"watcher"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/osdconfig/callback.go#L23-L31
|
144,049 |
libopenstorage/openstorage
|
osdconfig/callback.go
|
kvdbCallback
|
func (manager *configManager) kvdbCallback(prefix string,
opaque interface{}, kvp *kvdb.KVPair, err error) error {
manager.Lock()
defer manager.Unlock()
c, ok := opaque.(*dataToKvdb)
if !ok {
return fmt.Errorf("opaque value type is incorrect")
}
x := new(data)
if kvp != nil {
x.Key = kvp.Key
x.Value = kvp.Value
}
x.Type = c.Type
switch c.Type {
case clusterWatcher:
for _, f := range manager.cbCluster {
go func(f1 CallbackClusterConfigFunc, wd *data) {
manager.execClusterCallbacks(f1, wd)
}(f, copyData(x))
}
case nodeWatcher:
for _, f := range manager.cbNode {
go func(f1 CallbackNodeConfigFunc, wd *data) {
manager.execNodeCallbacks(f1, wd)
}(f, copyData(x))
}
}
return nil
}
|
go
|
func (manager *configManager) kvdbCallback(prefix string,
opaque interface{}, kvp *kvdb.KVPair, err error) error {
manager.Lock()
defer manager.Unlock()
c, ok := opaque.(*dataToKvdb)
if !ok {
return fmt.Errorf("opaque value type is incorrect")
}
x := new(data)
if kvp != nil {
x.Key = kvp.Key
x.Value = kvp.Value
}
x.Type = c.Type
switch c.Type {
case clusterWatcher:
for _, f := range manager.cbCluster {
go func(f1 CallbackClusterConfigFunc, wd *data) {
manager.execClusterCallbacks(f1, wd)
}(f, copyData(x))
}
case nodeWatcher:
for _, f := range manager.cbNode {
go func(f1 CallbackNodeConfigFunc, wd *data) {
manager.execNodeCallbacks(f1, wd)
}(f, copyData(x))
}
}
return nil
}
|
[
"func",
"(",
"manager",
"*",
"configManager",
")",
"kvdbCallback",
"(",
"prefix",
"string",
",",
"opaque",
"interface",
"{",
"}",
",",
"kvp",
"*",
"kvdb",
".",
"KVPair",
",",
"err",
"error",
")",
"error",
"{",
"manager",
".",
"Lock",
"(",
")",
"\n",
"defer",
"manager",
".",
"Unlock",
"(",
")",
"\n\n",
"c",
",",
"ok",
":=",
"opaque",
".",
"(",
"*",
"dataToKvdb",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"x",
":=",
"new",
"(",
"data",
")",
"\n",
"if",
"kvp",
"!=",
"nil",
"{",
"x",
".",
"Key",
"=",
"kvp",
".",
"Key",
"\n",
"x",
".",
"Value",
"=",
"kvp",
".",
"Value",
"\n",
"}",
"\n",
"x",
".",
"Type",
"=",
"c",
".",
"Type",
"\n",
"switch",
"c",
".",
"Type",
"{",
"case",
"clusterWatcher",
":",
"for",
"_",
",",
"f",
":=",
"range",
"manager",
".",
"cbCluster",
"{",
"go",
"func",
"(",
"f1",
"CallbackClusterConfigFunc",
",",
"wd",
"*",
"data",
")",
"{",
"manager",
".",
"execClusterCallbacks",
"(",
"f1",
",",
"wd",
")",
"\n",
"}",
"(",
"f",
",",
"copyData",
"(",
"x",
")",
")",
"\n",
"}",
"\n",
"case",
"nodeWatcher",
":",
"for",
"_",
",",
"f",
":=",
"range",
"manager",
".",
"cbNode",
"{",
"go",
"func",
"(",
"f1",
"CallbackNodeConfigFunc",
",",
"wd",
"*",
"data",
")",
"{",
"manager",
".",
"execNodeCallbacks",
"(",
"f1",
",",
"wd",
")",
"\n",
"}",
"(",
"f",
",",
"copyData",
"(",
"x",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// kvdbCallback is a callback to be registered with kvdb.
// this callback simply receives data from kvdb and reflects it on a channel it receives in opaque
|
[
"kvdbCallback",
"is",
"a",
"callback",
"to",
"be",
"registered",
"with",
"kvdb",
".",
"this",
"callback",
"simply",
"receives",
"data",
"from",
"kvdb",
"and",
"reflects",
"it",
"on",
"a",
"channel",
"it",
"receives",
"in",
"opaque"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/osdconfig/callback.go#L35-L67
|
144,050 |
libopenstorage/openstorage
|
api/server/volume.go
|
create
|
func (vd *volAPI) create(w http.ResponseWriter, r *http.Request) {
var dcRes api.VolumeCreateResponse
var dcReq api.VolumeCreateRequest
method := "create"
if err := json.NewDecoder(r.Body).Decode(&dcReq); err != nil {
fmt.Println("returning error here")
vd.sendError(vd.name, method, w, err.Error(), http.StatusBadRequest)
return
}
// Get context with auth token
ctx, err := vd.annotateContext(r)
if err != nil {
vd.sendError(vd.name, method, w, err.Error(), http.StatusBadRequest)
return
}
// Get gRPC connection
conn, err := vd.getConn()
if err != nil {
vd.sendError(vd.name, method, w, err.Error(), http.StatusInternalServerError)
return
}
spec := dcReq.GetSpec()
if spec.VolumeLabels == nil {
spec.VolumeLabels = make(map[string]string)
}
for k, v := range dcReq.Locator.GetVolumeLabels() {
spec.VolumeLabels[k] = v
}
volumes := api.NewOpenStorageVolumeClient(conn)
id, err := volumes.Create(ctx, &api.SdkVolumeCreateRequest{
Name: dcReq.Locator.GetName(),
Labels: dcReq.Locator.GetVolumeLabels(),
Spec: dcReq.GetSpec(),
})
dcRes.VolumeResponse = &api.VolumeResponse{Error: responseStatus(err)}
if err == nil {
dcRes.Id = id.GetVolumeId()
}
json.NewEncoder(w).Encode(&dcRes)
}
|
go
|
func (vd *volAPI) create(w http.ResponseWriter, r *http.Request) {
var dcRes api.VolumeCreateResponse
var dcReq api.VolumeCreateRequest
method := "create"
if err := json.NewDecoder(r.Body).Decode(&dcReq); err != nil {
fmt.Println("returning error here")
vd.sendError(vd.name, method, w, err.Error(), http.StatusBadRequest)
return
}
// Get context with auth token
ctx, err := vd.annotateContext(r)
if err != nil {
vd.sendError(vd.name, method, w, err.Error(), http.StatusBadRequest)
return
}
// Get gRPC connection
conn, err := vd.getConn()
if err != nil {
vd.sendError(vd.name, method, w, err.Error(), http.StatusInternalServerError)
return
}
spec := dcReq.GetSpec()
if spec.VolumeLabels == nil {
spec.VolumeLabels = make(map[string]string)
}
for k, v := range dcReq.Locator.GetVolumeLabels() {
spec.VolumeLabels[k] = v
}
volumes := api.NewOpenStorageVolumeClient(conn)
id, err := volumes.Create(ctx, &api.SdkVolumeCreateRequest{
Name: dcReq.Locator.GetName(),
Labels: dcReq.Locator.GetVolumeLabels(),
Spec: dcReq.GetSpec(),
})
dcRes.VolumeResponse = &api.VolumeResponse{Error: responseStatus(err)}
if err == nil {
dcRes.Id = id.GetVolumeId()
}
json.NewEncoder(w).Encode(&dcRes)
}
|
[
"func",
"(",
"vd",
"*",
"volAPI",
")",
"create",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"var",
"dcRes",
"api",
".",
"VolumeCreateResponse",
"\n",
"var",
"dcReq",
"api",
".",
"VolumeCreateRequest",
"\n",
"method",
":=",
"\"",
"\"",
"\n\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"dcReq",
")",
";",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"vd",
".",
"sendError",
"(",
"vd",
".",
"name",
",",
"method",
",",
"w",
",",
"err",
".",
"Error",
"(",
")",
",",
"http",
".",
"StatusBadRequest",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Get context with auth token",
"ctx",
",",
"err",
":=",
"vd",
".",
"annotateContext",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"vd",
".",
"sendError",
"(",
"vd",
".",
"name",
",",
"method",
",",
"w",
",",
"err",
".",
"Error",
"(",
")",
",",
"http",
".",
"StatusBadRequest",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Get gRPC connection",
"conn",
",",
"err",
":=",
"vd",
".",
"getConn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"vd",
".",
"sendError",
"(",
"vd",
".",
"name",
",",
"method",
",",
"w",
",",
"err",
".",
"Error",
"(",
")",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n",
"spec",
":=",
"dcReq",
".",
"GetSpec",
"(",
")",
"\n",
"if",
"spec",
".",
"VolumeLabels",
"==",
"nil",
"{",
"spec",
".",
"VolumeLabels",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"dcReq",
".",
"Locator",
".",
"GetVolumeLabels",
"(",
")",
"{",
"spec",
".",
"VolumeLabels",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"volumes",
":=",
"api",
".",
"NewOpenStorageVolumeClient",
"(",
"conn",
")",
"\n",
"id",
",",
"err",
":=",
"volumes",
".",
"Create",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkVolumeCreateRequest",
"{",
"Name",
":",
"dcReq",
".",
"Locator",
".",
"GetName",
"(",
")",
",",
"Labels",
":",
"dcReq",
".",
"Locator",
".",
"GetVolumeLabels",
"(",
")",
",",
"Spec",
":",
"dcReq",
".",
"GetSpec",
"(",
")",
",",
"}",
")",
"\n\n",
"dcRes",
".",
"VolumeResponse",
"=",
"&",
"api",
".",
"VolumeResponse",
"{",
"Error",
":",
"responseStatus",
"(",
"err",
")",
"}",
"\n",
"if",
"err",
"==",
"nil",
"{",
"dcRes",
".",
"Id",
"=",
"id",
".",
"GetVolumeId",
"(",
")",
"\n",
"}",
"\n\n",
"json",
".",
"NewEncoder",
"(",
"w",
")",
".",
"Encode",
"(",
"&",
"dcRes",
")",
"\n",
"}"
] |
// Creates a single volume with given spec.
|
[
"Creates",
"a",
"single",
"volume",
"with",
"given",
"spec",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/volume.go#L187-L232
|
144,051 |
libopenstorage/openstorage
|
api/server/volume.go
|
GetVolumeAPIRoutes
|
func GetVolumeAPIRoutes(name, sdkUds string) []*Route {
volMgmtApi := newVolumeAPI(name, sdkUds)
return volMgmtApi.Routes()
}
|
go
|
func GetVolumeAPIRoutes(name, sdkUds string) []*Route {
volMgmtApi := newVolumeAPI(name, sdkUds)
return volMgmtApi.Routes()
}
|
[
"func",
"GetVolumeAPIRoutes",
"(",
"name",
",",
"sdkUds",
"string",
")",
"[",
"]",
"*",
"Route",
"{",
"volMgmtApi",
":=",
"newVolumeAPI",
"(",
"name",
",",
"sdkUds",
")",
"\n",
"return",
"volMgmtApi",
".",
"Routes",
"(",
")",
"\n",
"}"
] |
// GetVolumeAPIRoutes returns all the volume routes.
// A driver could use this function if it does not want openstorage
// to setup the REST server but it sets up its own and wants to add
// volume routes
|
[
"GetVolumeAPIRoutes",
"returns",
"all",
"the",
"volume",
"routes",
".",
"A",
"driver",
"could",
"use",
"this",
"function",
"if",
"it",
"does",
"not",
"want",
"openstorage",
"to",
"setup",
"the",
"REST",
"server",
"but",
"it",
"sets",
"up",
"its",
"own",
"and",
"wants",
"to",
"add",
"volume",
"routes"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/volume.go#L1748-L1751
|
144,052 |
libopenstorage/openstorage
|
api/server/volume.go
|
GetVolumeAPIRoutesWithAuth
|
func GetVolumeAPIRoutesWithAuth(
name, sdkUds string,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
router *mux.Router,
serverRegisterRoute ServerRegisterRoute,
preRouteCheckFn func(http.ResponseWriter, *http.Request) bool,
) (*mux.Router, error) {
vd := &volAPI{
restBase: restBase{version: volume.APIVersion, name: name},
sdkUds: sdkUds,
dummyMux: runtime.NewServeMux(),
}
authM, err := NewAuthMiddleware(authProvider, authProviderType)
if err != nil {
return router, err
}
// We setup auth middlewares for all the APIs that get invoked
// from a Container Orchestrator.
// - CREATE
// - ATTACH/MOUNT
// - DETACH/UNMOUNT
// - DELETE
// For all other routes it is expected that the REST client uses an auth token
// Setup middleware for Create
nCreate := negroni.New()
nCreate.Use(negroni.HandlerFunc(authM.createWithAuth))
createRoute := vd.volumeCreateRoute()
nCreate.UseHandlerFunc(serverRegisterRoute(createRoute.fn, preRouteCheckFn))
router.Methods(createRoute.verb).Path(createRoute.path).Handler(nCreate)
// Setup middleware for Delete
nDelete := negroni.New()
nDelete.Use(negroni.HandlerFunc(authM.deleteWithAuth))
deleteRoute := vd.volumeDeleteRoute()
nDelete.UseHandlerFunc(serverRegisterRoute(deleteRoute.fn, preRouteCheckFn))
router.Methods(deleteRoute.verb).Path(deleteRoute.path).Handler(nDelete)
// Setup middleware for Set
nSet := negroni.New()
nSet.Use(negroni.HandlerFunc(authM.setWithAuth))
setRoute := vd.volumeSetRoute()
nSet.UseHandlerFunc(serverRegisterRoute(setRoute.fn, preRouteCheckFn))
router.Methods(setRoute.verb).Path(setRoute.path).Handler(nSet)
// Setup middleware for Inspect
nInspect := negroni.New()
nInspect.Use(negroni.HandlerFunc(authM.inspectWithAuth))
inspectRoute := vd.volumeInspectRoute()
nInspect.UseHandlerFunc(serverRegisterRoute(inspectRoute.fn, preRouteCheckFn))
router.Methods(inspectRoute.verb).Path(inspectRoute.path).Handler(nInspect)
routes := []*Route{vd.versionRoute()}
routes = append(routes, vd.otherVolumeRoutes()...)
routes = append(routes, vd.snapRoutes()...)
routes = append(routes, vd.backupRoutes()...)
routes = append(routes, vd.credsRoutes()...)
routes = append(routes, vd.migrateRoutes()...)
for _, v := range routes {
router.Methods(v.verb).Path(v.path).HandlerFunc(serverRegisterRoute(v.fn, preRouteCheckFn))
}
return router, nil
}
|
go
|
func GetVolumeAPIRoutesWithAuth(
name, sdkUds string,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
router *mux.Router,
serverRegisterRoute ServerRegisterRoute,
preRouteCheckFn func(http.ResponseWriter, *http.Request) bool,
) (*mux.Router, error) {
vd := &volAPI{
restBase: restBase{version: volume.APIVersion, name: name},
sdkUds: sdkUds,
dummyMux: runtime.NewServeMux(),
}
authM, err := NewAuthMiddleware(authProvider, authProviderType)
if err != nil {
return router, err
}
// We setup auth middlewares for all the APIs that get invoked
// from a Container Orchestrator.
// - CREATE
// - ATTACH/MOUNT
// - DETACH/UNMOUNT
// - DELETE
// For all other routes it is expected that the REST client uses an auth token
// Setup middleware for Create
nCreate := negroni.New()
nCreate.Use(negroni.HandlerFunc(authM.createWithAuth))
createRoute := vd.volumeCreateRoute()
nCreate.UseHandlerFunc(serverRegisterRoute(createRoute.fn, preRouteCheckFn))
router.Methods(createRoute.verb).Path(createRoute.path).Handler(nCreate)
// Setup middleware for Delete
nDelete := negroni.New()
nDelete.Use(negroni.HandlerFunc(authM.deleteWithAuth))
deleteRoute := vd.volumeDeleteRoute()
nDelete.UseHandlerFunc(serverRegisterRoute(deleteRoute.fn, preRouteCheckFn))
router.Methods(deleteRoute.verb).Path(deleteRoute.path).Handler(nDelete)
// Setup middleware for Set
nSet := negroni.New()
nSet.Use(negroni.HandlerFunc(authM.setWithAuth))
setRoute := vd.volumeSetRoute()
nSet.UseHandlerFunc(serverRegisterRoute(setRoute.fn, preRouteCheckFn))
router.Methods(setRoute.verb).Path(setRoute.path).Handler(nSet)
// Setup middleware for Inspect
nInspect := negroni.New()
nInspect.Use(negroni.HandlerFunc(authM.inspectWithAuth))
inspectRoute := vd.volumeInspectRoute()
nInspect.UseHandlerFunc(serverRegisterRoute(inspectRoute.fn, preRouteCheckFn))
router.Methods(inspectRoute.verb).Path(inspectRoute.path).Handler(nInspect)
routes := []*Route{vd.versionRoute()}
routes = append(routes, vd.otherVolumeRoutes()...)
routes = append(routes, vd.snapRoutes()...)
routes = append(routes, vd.backupRoutes()...)
routes = append(routes, vd.credsRoutes()...)
routes = append(routes, vd.migrateRoutes()...)
for _, v := range routes {
router.Methods(v.verb).Path(v.path).HandlerFunc(serverRegisterRoute(v.fn, preRouteCheckFn))
}
return router, nil
}
|
[
"func",
"GetVolumeAPIRoutesWithAuth",
"(",
"name",
",",
"sdkUds",
"string",
",",
"authProviderType",
"secrets",
".",
"AuthTokenProviders",
",",
"authProvider",
"osecrets",
".",
"Secrets",
",",
"router",
"*",
"mux",
".",
"Router",
",",
"serverRegisterRoute",
"ServerRegisterRoute",
",",
"preRouteCheckFn",
"func",
"(",
"http",
".",
"ResponseWriter",
",",
"*",
"http",
".",
"Request",
")",
"bool",
",",
")",
"(",
"*",
"mux",
".",
"Router",
",",
"error",
")",
"{",
"vd",
":=",
"&",
"volAPI",
"{",
"restBase",
":",
"restBase",
"{",
"version",
":",
"volume",
".",
"APIVersion",
",",
"name",
":",
"name",
"}",
",",
"sdkUds",
":",
"sdkUds",
",",
"dummyMux",
":",
"runtime",
".",
"NewServeMux",
"(",
")",
",",
"}",
"\n\n",
"authM",
",",
"err",
":=",
"NewAuthMiddleware",
"(",
"authProvider",
",",
"authProviderType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"router",
",",
"err",
"\n",
"}",
"\n\n",
"// We setup auth middlewares for all the APIs that get invoked",
"// from a Container Orchestrator.",
"// - CREATE",
"// - ATTACH/MOUNT",
"// - DETACH/UNMOUNT",
"// - DELETE",
"// For all other routes it is expected that the REST client uses an auth token",
"// Setup middleware for Create",
"nCreate",
":=",
"negroni",
".",
"New",
"(",
")",
"\n",
"nCreate",
".",
"Use",
"(",
"negroni",
".",
"HandlerFunc",
"(",
"authM",
".",
"createWithAuth",
")",
")",
"\n",
"createRoute",
":=",
"vd",
".",
"volumeCreateRoute",
"(",
")",
"\n",
"nCreate",
".",
"UseHandlerFunc",
"(",
"serverRegisterRoute",
"(",
"createRoute",
".",
"fn",
",",
"preRouteCheckFn",
")",
")",
"\n",
"router",
".",
"Methods",
"(",
"createRoute",
".",
"verb",
")",
".",
"Path",
"(",
"createRoute",
".",
"path",
")",
".",
"Handler",
"(",
"nCreate",
")",
"\n\n",
"// Setup middleware for Delete",
"nDelete",
":=",
"negroni",
".",
"New",
"(",
")",
"\n",
"nDelete",
".",
"Use",
"(",
"negroni",
".",
"HandlerFunc",
"(",
"authM",
".",
"deleteWithAuth",
")",
")",
"\n",
"deleteRoute",
":=",
"vd",
".",
"volumeDeleteRoute",
"(",
")",
"\n",
"nDelete",
".",
"UseHandlerFunc",
"(",
"serverRegisterRoute",
"(",
"deleteRoute",
".",
"fn",
",",
"preRouteCheckFn",
")",
")",
"\n",
"router",
".",
"Methods",
"(",
"deleteRoute",
".",
"verb",
")",
".",
"Path",
"(",
"deleteRoute",
".",
"path",
")",
".",
"Handler",
"(",
"nDelete",
")",
"\n\n",
"// Setup middleware for Set",
"nSet",
":=",
"negroni",
".",
"New",
"(",
")",
"\n",
"nSet",
".",
"Use",
"(",
"negroni",
".",
"HandlerFunc",
"(",
"authM",
".",
"setWithAuth",
")",
")",
"\n",
"setRoute",
":=",
"vd",
".",
"volumeSetRoute",
"(",
")",
"\n",
"nSet",
".",
"UseHandlerFunc",
"(",
"serverRegisterRoute",
"(",
"setRoute",
".",
"fn",
",",
"preRouteCheckFn",
")",
")",
"\n",
"router",
".",
"Methods",
"(",
"setRoute",
".",
"verb",
")",
".",
"Path",
"(",
"setRoute",
".",
"path",
")",
".",
"Handler",
"(",
"nSet",
")",
"\n\n",
"// Setup middleware for Inspect",
"nInspect",
":=",
"negroni",
".",
"New",
"(",
")",
"\n",
"nInspect",
".",
"Use",
"(",
"negroni",
".",
"HandlerFunc",
"(",
"authM",
".",
"inspectWithAuth",
")",
")",
"\n",
"inspectRoute",
":=",
"vd",
".",
"volumeInspectRoute",
"(",
")",
"\n",
"nInspect",
".",
"UseHandlerFunc",
"(",
"serverRegisterRoute",
"(",
"inspectRoute",
".",
"fn",
",",
"preRouteCheckFn",
")",
")",
"\n",
"router",
".",
"Methods",
"(",
"inspectRoute",
".",
"verb",
")",
".",
"Path",
"(",
"inspectRoute",
".",
"path",
")",
".",
"Handler",
"(",
"nInspect",
")",
"\n\n",
"routes",
":=",
"[",
"]",
"*",
"Route",
"{",
"vd",
".",
"versionRoute",
"(",
")",
"}",
"\n",
"routes",
"=",
"append",
"(",
"routes",
",",
"vd",
".",
"otherVolumeRoutes",
"(",
")",
"...",
")",
"\n",
"routes",
"=",
"append",
"(",
"routes",
",",
"vd",
".",
"snapRoutes",
"(",
")",
"...",
")",
"\n",
"routes",
"=",
"append",
"(",
"routes",
",",
"vd",
".",
"backupRoutes",
"(",
")",
"...",
")",
"\n",
"routes",
"=",
"append",
"(",
"routes",
",",
"vd",
".",
"credsRoutes",
"(",
")",
"...",
")",
"\n",
"routes",
"=",
"append",
"(",
"routes",
",",
"vd",
".",
"migrateRoutes",
"(",
")",
"...",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"routes",
"{",
"router",
".",
"Methods",
"(",
"v",
".",
"verb",
")",
".",
"Path",
"(",
"v",
".",
"path",
")",
".",
"HandlerFunc",
"(",
"serverRegisterRoute",
"(",
"v",
".",
"fn",
",",
"preRouteCheckFn",
")",
")",
"\n",
"}",
"\n",
"return",
"router",
",",
"nil",
"\n\n",
"}"
] |
// GetVolumeAPIRoutesWithAuth returns a router with all the volume routes
// added to the router along with the auth middleware
// - preRouteCheckFn is a handler that gets executed before the actual volume handler
// is invoked. It is added for legacy support where negroni middleware was not used
|
[
"GetVolumeAPIRoutesWithAuth",
"returns",
"a",
"router",
"with",
"all",
"the",
"volume",
"routes",
"added",
"to",
"the",
"router",
"along",
"with",
"the",
"auth",
"middleware",
"-",
"preRouteCheckFn",
"is",
"a",
"handler",
"that",
"gets",
"executed",
"before",
"the",
"actual",
"volume",
"handler",
"is",
"invoked",
".",
"It",
"is",
"added",
"for",
"legacy",
"support",
"where",
"negroni",
"middleware",
"was",
"not",
"used"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/volume.go#L1765-L1831
|
144,053 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
Create
|
func (v *volumeClient) Create(locator *api.VolumeLocator, source *api.Source,
spec *api.VolumeSpec) (string, error) {
response := &api.VolumeCreateResponse{}
request := &api.VolumeCreateRequest{
Locator: locator,
Source: source,
Spec: spec,
}
if err := v.c.Post().Resource(volumePath).Body(request).Do().Unmarshal(response); err != nil {
return "", err
}
if response.VolumeResponse != nil && response.VolumeResponse.Error != "" {
return "", errors.New(response.VolumeResponse.Error)
}
return response.Id, nil
}
|
go
|
func (v *volumeClient) Create(locator *api.VolumeLocator, source *api.Source,
spec *api.VolumeSpec) (string, error) {
response := &api.VolumeCreateResponse{}
request := &api.VolumeCreateRequest{
Locator: locator,
Source: source,
Spec: spec,
}
if err := v.c.Post().Resource(volumePath).Body(request).Do().Unmarshal(response); err != nil {
return "", err
}
if response.VolumeResponse != nil && response.VolumeResponse.Error != "" {
return "", errors.New(response.VolumeResponse.Error)
}
return response.Id, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"Create",
"(",
"locator",
"*",
"api",
".",
"VolumeLocator",
",",
"source",
"*",
"api",
".",
"Source",
",",
"spec",
"*",
"api",
".",
"VolumeSpec",
")",
"(",
"string",
",",
"error",
")",
"{",
"response",
":=",
"&",
"api",
".",
"VolumeCreateResponse",
"{",
"}",
"\n",
"request",
":=",
"&",
"api",
".",
"VolumeCreateRequest",
"{",
"Locator",
":",
"locator",
",",
"Source",
":",
"source",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"if",
"err",
":=",
"v",
".",
"c",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"volumePath",
")",
".",
"Body",
"(",
"request",
")",
".",
"Do",
"(",
")",
".",
"Unmarshal",
"(",
"response",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"response",
".",
"VolumeResponse",
"!=",
"nil",
"&&",
"response",
".",
"VolumeResponse",
".",
"Error",
"!=",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"response",
".",
"VolumeResponse",
".",
"Error",
")",
"\n",
"}",
"\n",
"return",
"response",
".",
"Id",
",",
"nil",
"\n",
"}"
] |
// Create a new Vol for the specific volume spev.c.
// It returns a system generated VolumeID that uniquely identifies the volume
|
[
"Create",
"a",
"new",
"Vol",
"for",
"the",
"specific",
"volume",
"spev",
".",
"c",
".",
"It",
"returns",
"a",
"system",
"generated",
"VolumeID",
"that",
"uniquely",
"identifies",
"the",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L125-L140
|
144,054 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
Inspect
|
func (v *volumeClient) Inspect(ids []string) ([]*api.Volume, error) {
if len(ids) == 0 {
return nil, nil
}
var volumes []*api.Volume
request := v.c.Get().Resource(volumePath)
for _, id := range ids {
request.QueryOption(api.OptVolumeID, id)
}
if err := request.Do().Unmarshal(&volumes); err != nil {
return nil, err
}
return volumes, nil
}
|
go
|
func (v *volumeClient) Inspect(ids []string) ([]*api.Volume, error) {
if len(ids) == 0 {
return nil, nil
}
var volumes []*api.Volume
request := v.c.Get().Resource(volumePath)
for _, id := range ids {
request.QueryOption(api.OptVolumeID, id)
}
if err := request.Do().Unmarshal(&volumes); err != nil {
return nil, err
}
return volumes, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"Inspect",
"(",
"ids",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"error",
")",
"{",
"if",
"len",
"(",
"ids",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"var",
"volumes",
"[",
"]",
"*",
"api",
".",
"Volume",
"\n",
"request",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"volumePath",
")",
"\n",
"for",
"_",
",",
"id",
":=",
"range",
"ids",
"{",
"request",
".",
"QueryOption",
"(",
"api",
".",
"OptVolumeID",
",",
"id",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"request",
".",
"Do",
"(",
")",
".",
"Unmarshal",
"(",
"&",
"volumes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"volumes",
",",
"nil",
"\n",
"}"
] |
// Inspect specified volumes.
// Errors ErrEnoEnt may be returned.
|
[
"Inspect",
"specified",
"volumes",
".",
"Errors",
"ErrEnoEnt",
"may",
"be",
"returned",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L149-L162
|
144,055 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
Snapshot
|
func (v *volumeClient) Snapshot(volumeID string,
readonly bool,
locator *api.VolumeLocator,
noRetry bool,
) (string, error) {
response := &api.SnapCreateResponse{}
request := &api.SnapCreateRequest{
Id: volumeID,
Readonly: readonly,
Locator: locator,
NoRetry: noRetry,
}
if err := v.c.Post().Resource(snapPath).Body(request).Do().Unmarshal(response); err != nil {
return "", err
}
// TODO(pedge): this probably should not be embedded in this way
if response.VolumeCreateResponse != nil &&
response.VolumeCreateResponse.VolumeResponse != nil &&
response.VolumeCreateResponse.VolumeResponse.Error != "" {
return "", errors.New(
response.VolumeCreateResponse.VolumeResponse.Error)
}
if response.VolumeCreateResponse != nil {
return response.VolumeCreateResponse.Id, nil
}
return "", nil
}
|
go
|
func (v *volumeClient) Snapshot(volumeID string,
readonly bool,
locator *api.VolumeLocator,
noRetry bool,
) (string, error) {
response := &api.SnapCreateResponse{}
request := &api.SnapCreateRequest{
Id: volumeID,
Readonly: readonly,
Locator: locator,
NoRetry: noRetry,
}
if err := v.c.Post().Resource(snapPath).Body(request).Do().Unmarshal(response); err != nil {
return "", err
}
// TODO(pedge): this probably should not be embedded in this way
if response.VolumeCreateResponse != nil &&
response.VolumeCreateResponse.VolumeResponse != nil &&
response.VolumeCreateResponse.VolumeResponse.Error != "" {
return "", errors.New(
response.VolumeCreateResponse.VolumeResponse.Error)
}
if response.VolumeCreateResponse != nil {
return response.VolumeCreateResponse.Id, nil
}
return "", nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"Snapshot",
"(",
"volumeID",
"string",
",",
"readonly",
"bool",
",",
"locator",
"*",
"api",
".",
"VolumeLocator",
",",
"noRetry",
"bool",
",",
")",
"(",
"string",
",",
"error",
")",
"{",
"response",
":=",
"&",
"api",
".",
"SnapCreateResponse",
"{",
"}",
"\n",
"request",
":=",
"&",
"api",
".",
"SnapCreateRequest",
"{",
"Id",
":",
"volumeID",
",",
"Readonly",
":",
"readonly",
",",
"Locator",
":",
"locator",
",",
"NoRetry",
":",
"noRetry",
",",
"}",
"\n",
"if",
"err",
":=",
"v",
".",
"c",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"snapPath",
")",
".",
"Body",
"(",
"request",
")",
".",
"Do",
"(",
")",
".",
"Unmarshal",
"(",
"response",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// TODO(pedge): this probably should not be embedded in this way",
"if",
"response",
".",
"VolumeCreateResponse",
"!=",
"nil",
"&&",
"response",
".",
"VolumeCreateResponse",
".",
"VolumeResponse",
"!=",
"nil",
"&&",
"response",
".",
"VolumeCreateResponse",
".",
"VolumeResponse",
".",
"Error",
"!=",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"response",
".",
"VolumeCreateResponse",
".",
"VolumeResponse",
".",
"Error",
")",
"\n",
"}",
"\n",
"if",
"response",
".",
"VolumeCreateResponse",
"!=",
"nil",
"{",
"return",
"response",
".",
"VolumeCreateResponse",
".",
"Id",
",",
"nil",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}"
] |
// Snap specified volume. IO to the underlying volume should be quiesced before
// calling this function.
// Errors ErrEnoEnt may be returned
|
[
"Snap",
"specified",
"volume",
".",
"IO",
"to",
"the",
"underlying",
"volume",
"should",
"be",
"quiesced",
"before",
"calling",
"this",
"function",
".",
"Errors",
"ErrEnoEnt",
"may",
"be",
"returned"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L180-L207
|
144,056 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
Restore
|
func (v *volumeClient) Restore(volumeID string, snapID string) error {
response := &api.VolumeResponse{}
req := v.c.Post().Resource(snapPath + "/restore").Instance(volumeID)
req.QueryOption(api.OptSnapID, snapID)
if err := req.Do().Unmarshal(response); err != nil {
return err
}
if response.Error != "" {
return errors.New(response.Error)
}
return nil
}
|
go
|
func (v *volumeClient) Restore(volumeID string, snapID string) error {
response := &api.VolumeResponse{}
req := v.c.Post().Resource(snapPath + "/restore").Instance(volumeID)
req.QueryOption(api.OptSnapID, snapID)
if err := req.Do().Unmarshal(response); err != nil {
return err
}
if response.Error != "" {
return errors.New(response.Error)
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"Restore",
"(",
"volumeID",
"string",
",",
"snapID",
"string",
")",
"error",
"{",
"response",
":=",
"&",
"api",
".",
"VolumeResponse",
"{",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"snapPath",
"+",
"\"",
"\"",
")",
".",
"Instance",
"(",
"volumeID",
")",
"\n",
"req",
".",
"QueryOption",
"(",
"api",
".",
"OptSnapID",
",",
"snapID",
")",
"\n\n",
"if",
"err",
":=",
"req",
".",
"Do",
"(",
")",
".",
"Unmarshal",
"(",
"response",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"response",
".",
"Error",
"!=",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"response",
".",
"Error",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Restore specified volume to given snapshot state
|
[
"Restore",
"specified",
"volume",
"to",
"given",
"snapshot",
"state"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L210-L222
|
144,057 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
Stats
|
func (v *volumeClient) Stats(
volumeID string,
cumulative bool,
) (*api.Stats, error) {
stats := &api.Stats{}
req := v.c.Get().Resource(volumePath + "/stats").Instance(volumeID)
req.QueryOption(api.OptCumulative, strconv.FormatBool(cumulative))
err := req.Do().Unmarshal(stats)
return stats, err
}
|
go
|
func (v *volumeClient) Stats(
volumeID string,
cumulative bool,
) (*api.Stats, error) {
stats := &api.Stats{}
req := v.c.Get().Resource(volumePath + "/stats").Instance(volumeID)
req.QueryOption(api.OptCumulative, strconv.FormatBool(cumulative))
err := req.Do().Unmarshal(stats)
return stats, err
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"Stats",
"(",
"volumeID",
"string",
",",
"cumulative",
"bool",
",",
")",
"(",
"*",
"api",
".",
"Stats",
",",
"error",
")",
"{",
"stats",
":=",
"&",
"api",
".",
"Stats",
"{",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"volumePath",
"+",
"\"",
"\"",
")",
".",
"Instance",
"(",
"volumeID",
")",
"\n",
"req",
".",
"QueryOption",
"(",
"api",
".",
"OptCumulative",
",",
"strconv",
".",
"FormatBool",
"(",
"cumulative",
")",
")",
"\n\n",
"err",
":=",
"req",
".",
"Do",
"(",
")",
".",
"Unmarshal",
"(",
"stats",
")",
"\n",
"return",
"stats",
",",
"err",
"\n\n",
"}"
] |
// Stats for specified volume.
// Errors ErrEnoEnt may be returned
|
[
"Stats",
"for",
"specified",
"volume",
".",
"Errors",
"ErrEnoEnt",
"may",
"be",
"returned"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L226-L237
|
144,058 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
UsedSize
|
func (v *volumeClient) UsedSize(
volumeID string,
) (uint64, error) {
var usedSize uint64
req := v.c.Get().Resource(volumePath + "/usedsize").Instance(volumeID)
err := req.Do().Unmarshal(&usedSize)
return usedSize, err
}
|
go
|
func (v *volumeClient) UsedSize(
volumeID string,
) (uint64, error) {
var usedSize uint64
req := v.c.Get().Resource(volumePath + "/usedsize").Instance(volumeID)
err := req.Do().Unmarshal(&usedSize)
return usedSize, err
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"UsedSize",
"(",
"volumeID",
"string",
",",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"var",
"usedSize",
"uint64",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"volumePath",
"+",
"\"",
"\"",
")",
".",
"Instance",
"(",
"volumeID",
")",
"\n",
"err",
":=",
"req",
".",
"Do",
"(",
")",
".",
"Unmarshal",
"(",
"&",
"usedSize",
")",
"\n",
"return",
"usedSize",
",",
"err",
"\n",
"}"
] |
// UsedSize returns allocated volume size.
// Errors ErrEnoEnt may be returned
|
[
"UsedSize",
"returns",
"allocated",
"volume",
"size",
".",
"Errors",
"ErrEnoEnt",
"may",
"be",
"returned"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L241-L248
|
144,059 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
GetActiveRequests
|
func (v *volumeClient) GetActiveRequests() (*api.ActiveRequests, error) {
requests := &api.ActiveRequests{}
resp := v.c.Get().Resource(volumePath + "/requests").Instance("vol_id").Do()
if resp.Error() != nil {
return nil, resp.FormatError()
}
if err := resp.Unmarshal(requests); err != nil {
return nil, err
}
return requests, nil
}
|
go
|
func (v *volumeClient) GetActiveRequests() (*api.ActiveRequests, error) {
requests := &api.ActiveRequests{}
resp := v.c.Get().Resource(volumePath + "/requests").Instance("vol_id").Do()
if resp.Error() != nil {
return nil, resp.FormatError()
}
if err := resp.Unmarshal(requests); err != nil {
return nil, err
}
return requests, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"GetActiveRequests",
"(",
")",
"(",
"*",
"api",
".",
"ActiveRequests",
",",
"error",
")",
"{",
"requests",
":=",
"&",
"api",
".",
"ActiveRequests",
"{",
"}",
"\n",
"resp",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"volumePath",
"+",
"\"",
"\"",
")",
".",
"Instance",
"(",
"\"",
"\"",
")",
".",
"Do",
"(",
")",
"\n\n",
"if",
"resp",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"resp",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"resp",
".",
"Unmarshal",
"(",
"requests",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"requests",
",",
"nil",
"\n",
"}"
] |
// Active Requests on all volume.
|
[
"Active",
"Requests",
"on",
"all",
"volume",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L251-L265
|
144,060 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
Enumerate
|
func (v *volumeClient) Enumerate(locator *api.VolumeLocator,
labels map[string]string) ([]*api.Volume, error) {
var volumes []*api.Volume
req := v.c.Get().Resource(volumePath)
if locator.Name != "" {
req.QueryOption(api.OptName, locator.Name)
}
if len(locator.VolumeLabels) != 0 {
req.QueryOptionLabel(api.OptLabel, locator.VolumeLabels)
}
if len(labels) != 0 {
req.QueryOptionLabel(api.OptConfigLabel, labels)
}
resp := req.Do()
if resp.Error() != nil {
return nil, resp.FormatError()
}
if err := resp.Unmarshal(&volumes); err != nil {
return nil, err
}
return volumes, nil
}
|
go
|
func (v *volumeClient) Enumerate(locator *api.VolumeLocator,
labels map[string]string) ([]*api.Volume, error) {
var volumes []*api.Volume
req := v.c.Get().Resource(volumePath)
if locator.Name != "" {
req.QueryOption(api.OptName, locator.Name)
}
if len(locator.VolumeLabels) != 0 {
req.QueryOptionLabel(api.OptLabel, locator.VolumeLabels)
}
if len(labels) != 0 {
req.QueryOptionLabel(api.OptConfigLabel, labels)
}
resp := req.Do()
if resp.Error() != nil {
return nil, resp.FormatError()
}
if err := resp.Unmarshal(&volumes); err != nil {
return nil, err
}
return volumes, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"Enumerate",
"(",
"locator",
"*",
"api",
".",
"VolumeLocator",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"error",
")",
"{",
"var",
"volumes",
"[",
"]",
"*",
"api",
".",
"Volume",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"volumePath",
")",
"\n",
"if",
"locator",
".",
"Name",
"!=",
"\"",
"\"",
"{",
"req",
".",
"QueryOption",
"(",
"api",
".",
"OptName",
",",
"locator",
".",
"Name",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"locator",
".",
"VolumeLabels",
")",
"!=",
"0",
"{",
"req",
".",
"QueryOptionLabel",
"(",
"api",
".",
"OptLabel",
",",
"locator",
".",
"VolumeLabels",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"labels",
")",
"!=",
"0",
"{",
"req",
".",
"QueryOptionLabel",
"(",
"api",
".",
"OptConfigLabel",
",",
"labels",
")",
"\n",
"}",
"\n",
"resp",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"resp",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"resp",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"resp",
".",
"Unmarshal",
"(",
"&",
"volumes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"volumes",
",",
"nil",
"\n",
"}"
] |
// Enumerate volumes that map to the volumeLocator. Locator fields may be regexp.
// If locator fields are left blank, this will return all volumes.
|
[
"Enumerate",
"volumes",
"that",
"map",
"to",
"the",
"volumeLocator",
".",
"Locator",
"fields",
"may",
"be",
"regexp",
".",
"If",
"locator",
"fields",
"are",
"left",
"blank",
"this",
"will",
"return",
"all",
"volumes",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L291-L313
|
144,061 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
SnapEnumerate
|
func (v *volumeClient) SnapEnumerate(ids []string,
snapLabels map[string]string) ([]*api.Volume, error) {
var volumes []*api.Volume
request := v.c.Get().Resource(snapPath)
for _, id := range ids {
request.QueryOption(api.OptVolumeID, id)
}
if len(snapLabels) != 0 {
request.QueryOptionLabel(api.OptLabel, snapLabels)
}
if err := request.Do().Unmarshal(&volumes); err != nil {
return nil, err
}
return volumes, nil
}
|
go
|
func (v *volumeClient) SnapEnumerate(ids []string,
snapLabels map[string]string) ([]*api.Volume, error) {
var volumes []*api.Volume
request := v.c.Get().Resource(snapPath)
for _, id := range ids {
request.QueryOption(api.OptVolumeID, id)
}
if len(snapLabels) != 0 {
request.QueryOptionLabel(api.OptLabel, snapLabels)
}
if err := request.Do().Unmarshal(&volumes); err != nil {
return nil, err
}
return volumes, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"SnapEnumerate",
"(",
"ids",
"[",
"]",
"string",
",",
"snapLabels",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"error",
")",
"{",
"var",
"volumes",
"[",
"]",
"*",
"api",
".",
"Volume",
"\n",
"request",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"snapPath",
")",
"\n",
"for",
"_",
",",
"id",
":=",
"range",
"ids",
"{",
"request",
".",
"QueryOption",
"(",
"api",
".",
"OptVolumeID",
",",
"id",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"snapLabels",
")",
"!=",
"0",
"{",
"request",
".",
"QueryOptionLabel",
"(",
"api",
".",
"OptLabel",
",",
"snapLabels",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"request",
".",
"Do",
"(",
")",
".",
"Unmarshal",
"(",
"&",
"volumes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"volumes",
",",
"nil",
"\n",
"}"
] |
// Enumerate snaps for specified volume
// Count indicates the number of snaps populated.
|
[
"Enumerate",
"snaps",
"for",
"specified",
"volume",
"Count",
"indicates",
"the",
"number",
"of",
"snaps",
"populated",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L317-L331
|
144,062 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
Attach
|
func (v *volumeClient) Attach(volumeID string, attachOptions map[string]string) (string, error) {
response, err := v.doVolumeSetGetResponse(
volumeID,
&api.VolumeSetRequest{
Action: &api.VolumeStateAction{
Attach: api.VolumeActionParam_VOLUME_ACTION_PARAM_ON,
},
Options: attachOptions,
},
)
if err != nil {
return "", err
}
if response.Volume != nil {
if response.Volume.Spec.Encrypted {
return response.Volume.SecureDevicePath, nil
} else {
return response.Volume.DevicePath, nil
}
}
return "", nil
}
|
go
|
func (v *volumeClient) Attach(volumeID string, attachOptions map[string]string) (string, error) {
response, err := v.doVolumeSetGetResponse(
volumeID,
&api.VolumeSetRequest{
Action: &api.VolumeStateAction{
Attach: api.VolumeActionParam_VOLUME_ACTION_PARAM_ON,
},
Options: attachOptions,
},
)
if err != nil {
return "", err
}
if response.Volume != nil {
if response.Volume.Spec.Encrypted {
return response.Volume.SecureDevicePath, nil
} else {
return response.Volume.DevicePath, nil
}
}
return "", nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"Attach",
"(",
"volumeID",
"string",
",",
"attachOptions",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"response",
",",
"err",
":=",
"v",
".",
"doVolumeSetGetResponse",
"(",
"volumeID",
",",
"&",
"api",
".",
"VolumeSetRequest",
"{",
"Action",
":",
"&",
"api",
".",
"VolumeStateAction",
"{",
"Attach",
":",
"api",
".",
"VolumeActionParam_VOLUME_ACTION_PARAM_ON",
",",
"}",
",",
"Options",
":",
"attachOptions",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"response",
".",
"Volume",
"!=",
"nil",
"{",
"if",
"response",
".",
"Volume",
".",
"Spec",
".",
"Encrypted",
"{",
"return",
"response",
".",
"Volume",
".",
"SecureDevicePath",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"response",
".",
"Volume",
".",
"DevicePath",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}"
] |
// Attach map device to the host.
// On success the devicePath specifies location where the device is exported
// Errors ErrEnoEnt, ErrVolAttached may be returned.
|
[
"Attach",
"map",
"device",
"to",
"the",
"host",
".",
"On",
"success",
"the",
"devicePath",
"specifies",
"location",
"where",
"the",
"device",
"is",
"exported",
"Errors",
"ErrEnoEnt",
"ErrVolAttached",
"may",
"be",
"returned",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L336-L357
|
144,063 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
Detach
|
func (v *volumeClient) Detach(volumeID string, options map[string]string) error {
return v.doVolumeSet(
volumeID,
&api.VolumeSetRequest{
Action: &api.VolumeStateAction{
Attach: api.VolumeActionParam_VOLUME_ACTION_PARAM_OFF,
},
Options: options,
},
)
}
|
go
|
func (v *volumeClient) Detach(volumeID string, options map[string]string) error {
return v.doVolumeSet(
volumeID,
&api.VolumeSetRequest{
Action: &api.VolumeStateAction{
Attach: api.VolumeActionParam_VOLUME_ACTION_PARAM_OFF,
},
Options: options,
},
)
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"Detach",
"(",
"volumeID",
"string",
",",
"options",
"map",
"[",
"string",
"]",
"string",
")",
"error",
"{",
"return",
"v",
".",
"doVolumeSet",
"(",
"volumeID",
",",
"&",
"api",
".",
"VolumeSetRequest",
"{",
"Action",
":",
"&",
"api",
".",
"VolumeStateAction",
"{",
"Attach",
":",
"api",
".",
"VolumeActionParam_VOLUME_ACTION_PARAM_OFF",
",",
"}",
",",
"Options",
":",
"options",
",",
"}",
",",
")",
"\n",
"}"
] |
// Detach device from the host.
// Errors ErrEnoEnt, ErrVolDetached may be returned.
|
[
"Detach",
"device",
"from",
"the",
"host",
".",
"Errors",
"ErrEnoEnt",
"ErrVolDetached",
"may",
"be",
"returned",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L361-L371
|
144,064 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CredsEnumerate
|
func (v *volumeClient) CredsEnumerate() (map[string]interface{}, error) {
creds := make(map[string]interface{}, 0)
err := v.c.Get().Resource(api.OsdCredsPath).Do().Unmarshal(&creds)
return creds, err
}
|
go
|
func (v *volumeClient) CredsEnumerate() (map[string]interface{}, error) {
creds := make(map[string]interface{}, 0)
err := v.c.Get().Resource(api.OsdCredsPath).Do().Unmarshal(&creds)
return creds, err
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CredsEnumerate",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"creds",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"err",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdCredsPath",
")",
".",
"Do",
"(",
")",
".",
"Unmarshal",
"(",
"&",
"creds",
")",
"\n",
"return",
"creds",
",",
"err",
"\n",
"}"
] |
// CredsEnumerate enumerates configured credentials in the cluster
|
[
"CredsEnumerate",
"enumerates",
"configured",
"credentials",
"in",
"the",
"cluster"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L470-L474
|
144,065 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CredsCreate
|
func (v *volumeClient) CredsCreate(params map[string]string) (string, error) {
createResponse := api.CredCreateResponse{}
request := &api.CredCreateRequest{
InputParams: params,
}
req := v.c.Post().Resource(api.OsdCredsPath).Body(request)
response := req.Do()
if response.Error() != nil {
return "", response.FormatError()
}
if err := response.Unmarshal(&createResponse); err != nil {
return "", err
}
return createResponse.UUID, nil
}
|
go
|
func (v *volumeClient) CredsCreate(params map[string]string) (string, error) {
createResponse := api.CredCreateResponse{}
request := &api.CredCreateRequest{
InputParams: params,
}
req := v.c.Post().Resource(api.OsdCredsPath).Body(request)
response := req.Do()
if response.Error() != nil {
return "", response.FormatError()
}
if err := response.Unmarshal(&createResponse); err != nil {
return "", err
}
return createResponse.UUID, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CredsCreate",
"(",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"createResponse",
":=",
"api",
".",
"CredCreateResponse",
"{",
"}",
"\n",
"request",
":=",
"&",
"api",
".",
"CredCreateRequest",
"{",
"InputParams",
":",
"params",
",",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdCredsPath",
")",
".",
"Body",
"(",
"request",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"response",
".",
"Unmarshal",
"(",
"&",
"createResponse",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"createResponse",
".",
"UUID",
",",
"nil",
"\n",
"}"
] |
// CredsCreate creates credentials for a given cloud provider
|
[
"CredsCreate",
"creates",
"credentials",
"for",
"a",
"given",
"cloud",
"provider"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L477-L491
|
144,066 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CredsDelete
|
func (v *volumeClient) CredsDelete(uuid string) error {
req := v.c.Delete().Resource(api.OsdCredsPath).Instance(uuid)
response := req.Do()
if response.Error() != nil {
return response.FormatError()
}
return nil
}
|
go
|
func (v *volumeClient) CredsDelete(uuid string) error {
req := v.c.Delete().Resource(api.OsdCredsPath).Instance(uuid)
response := req.Do()
if response.Error() != nil {
return response.FormatError()
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CredsDelete",
"(",
"uuid",
"string",
")",
"error",
"{",
"req",
":=",
"v",
".",
"c",
".",
"Delete",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdCredsPath",
")",
".",
"Instance",
"(",
"uuid",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CredsDelete deletes the credential with given UUID
|
[
"CredsDelete",
"deletes",
"the",
"credential",
"with",
"given",
"UUID"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L494-L501
|
144,067 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CredsValidate
|
func (v *volumeClient) CredsValidate(uuid string) error {
req := v.c.Put().Resource(api.OsdCredsPath + "/validate").Instance(uuid)
response := req.Do()
if response.Error() != nil {
if response.StatusCode() == http.StatusUnprocessableEntity {
return volume.NewCredentialError(response.Error().Error())
}
return response.FormatError()
}
return nil
}
|
go
|
func (v *volumeClient) CredsValidate(uuid string) error {
req := v.c.Put().Resource(api.OsdCredsPath + "/validate").Instance(uuid)
response := req.Do()
if response.Error() != nil {
if response.StatusCode() == http.StatusUnprocessableEntity {
return volume.NewCredentialError(response.Error().Error())
}
return response.FormatError()
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CredsValidate",
"(",
"uuid",
"string",
")",
"error",
"{",
"req",
":=",
"v",
".",
"c",
".",
"Put",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdCredsPath",
"+",
"\"",
"\"",
")",
".",
"Instance",
"(",
"uuid",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"if",
"response",
".",
"StatusCode",
"(",
")",
"==",
"http",
".",
"StatusUnprocessableEntity",
"{",
"return",
"volume",
".",
"NewCredentialError",
"(",
"response",
".",
"Error",
"(",
")",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CredsValidate validates the credential by accessuing the cloud
// provider with the given credential
|
[
"CredsValidate",
"validates",
"the",
"credential",
"by",
"accessuing",
"the",
"cloud",
"provider",
"with",
"the",
"given",
"credential"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L505-L515
|
144,068 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CloudBackupCreate
|
func (v *volumeClient) CloudBackupCreate(
input *api.CloudBackupCreateRequest,
) (*api.CloudBackupCreateResponse, error) {
createResp := &api.CloudBackupCreateResponse{}
req := v.c.Post().Resource(api.OsdBackupPath).Body(input)
response := req.Do()
if response.Error() != nil {
if response.StatusCode() == http.StatusConflict {
return nil, &ost_errors.ErrExists{
Type: "CloudBackupCreate",
ID: input.Name,
}
}
return nil, response.FormatError()
}
if err := response.Unmarshal(&createResp); err != nil {
return nil, err
}
return createResp, nil
}
|
go
|
func (v *volumeClient) CloudBackupCreate(
input *api.CloudBackupCreateRequest,
) (*api.CloudBackupCreateResponse, error) {
createResp := &api.CloudBackupCreateResponse{}
req := v.c.Post().Resource(api.OsdBackupPath).Body(input)
response := req.Do()
if response.Error() != nil {
if response.StatusCode() == http.StatusConflict {
return nil, &ost_errors.ErrExists{
Type: "CloudBackupCreate",
ID: input.Name,
}
}
return nil, response.FormatError()
}
if err := response.Unmarshal(&createResp); err != nil {
return nil, err
}
return createResp, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CloudBackupCreate",
"(",
"input",
"*",
"api",
".",
"CloudBackupCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"CloudBackupCreateResponse",
",",
"error",
")",
"{",
"createResp",
":=",
"&",
"api",
".",
"CloudBackupCreateResponse",
"{",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdBackupPath",
")",
".",
"Body",
"(",
"input",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"if",
"response",
".",
"StatusCode",
"(",
")",
"==",
"http",
".",
"StatusConflict",
"{",
"return",
"nil",
",",
"&",
"ost_errors",
".",
"ErrExists",
"{",
"Type",
":",
"\"",
"\"",
",",
"ID",
":",
"input",
".",
"Name",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"response",
".",
"Unmarshal",
"(",
"&",
"createResp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"createResp",
",",
"nil",
"\n",
"}"
] |
// CloudBackupCreate uploads snapshot of a volume to cloud
|
[
"CloudBackupCreate",
"uploads",
"snapshot",
"of",
"a",
"volume",
"to",
"cloud"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L518-L537
|
144,069 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CloudBackupGroupCreate
|
func (v *volumeClient) CloudBackupGroupCreate(
input *api.CloudBackupGroupCreateRequest,
) (*api.CloudBackupGroupCreateResponse, error) {
createResp := &api.CloudBackupGroupCreateResponse{}
req := v.c.Post().Resource(api.OsdBackupPath + "/group").Body(input)
response := req.Do()
if response.Error() != nil {
return nil, response.FormatError()
}
if err := response.Unmarshal(&createResp); err != nil {
return nil, err
}
return createResp, nil
}
|
go
|
func (v *volumeClient) CloudBackupGroupCreate(
input *api.CloudBackupGroupCreateRequest,
) (*api.CloudBackupGroupCreateResponse, error) {
createResp := &api.CloudBackupGroupCreateResponse{}
req := v.c.Post().Resource(api.OsdBackupPath + "/group").Body(input)
response := req.Do()
if response.Error() != nil {
return nil, response.FormatError()
}
if err := response.Unmarshal(&createResp); err != nil {
return nil, err
}
return createResp, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CloudBackupGroupCreate",
"(",
"input",
"*",
"api",
".",
"CloudBackupGroupCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"CloudBackupGroupCreateResponse",
",",
"error",
")",
"{",
"createResp",
":=",
"&",
"api",
".",
"CloudBackupGroupCreateResponse",
"{",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdBackupPath",
"+",
"\"",
"\"",
")",
".",
"Body",
"(",
"input",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"response",
".",
"Unmarshal",
"(",
"&",
"createResp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"createResp",
",",
"nil",
"\n",
"}"
] |
// CloudBackupGroupCreate uploads snapshots of a volume group to cloud
|
[
"CloudBackupGroupCreate",
"uploads",
"snapshots",
"of",
"a",
"volume",
"group",
"to",
"cloud"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L540-L556
|
144,070 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CloudBackupRestore
|
func (v *volumeClient) CloudBackupRestore(
input *api.CloudBackupRestoreRequest,
) (*api.CloudBackupRestoreResponse, error) {
restoreResponse := &api.CloudBackupRestoreResponse{}
req := v.c.Post().Resource(api.OsdBackupPath + "/restore").Body(input)
response := req.Do()
if response.Error() != nil {
if response.StatusCode() == http.StatusConflict {
return nil, &ost_errors.ErrExists{
Type: "CloudBackupRestore",
ID: input.Name,
}
}
return nil, response.FormatError()
}
if err := response.Unmarshal(&restoreResponse); err != nil {
return nil, err
}
return restoreResponse, nil
}
|
go
|
func (v *volumeClient) CloudBackupRestore(
input *api.CloudBackupRestoreRequest,
) (*api.CloudBackupRestoreResponse, error) {
restoreResponse := &api.CloudBackupRestoreResponse{}
req := v.c.Post().Resource(api.OsdBackupPath + "/restore").Body(input)
response := req.Do()
if response.Error() != nil {
if response.StatusCode() == http.StatusConflict {
return nil, &ost_errors.ErrExists{
Type: "CloudBackupRestore",
ID: input.Name,
}
}
return nil, response.FormatError()
}
if err := response.Unmarshal(&restoreResponse); err != nil {
return nil, err
}
return restoreResponse, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CloudBackupRestore",
"(",
"input",
"*",
"api",
".",
"CloudBackupRestoreRequest",
",",
")",
"(",
"*",
"api",
".",
"CloudBackupRestoreResponse",
",",
"error",
")",
"{",
"restoreResponse",
":=",
"&",
"api",
".",
"CloudBackupRestoreResponse",
"{",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdBackupPath",
"+",
"\"",
"\"",
")",
".",
"Body",
"(",
"input",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"if",
"response",
".",
"StatusCode",
"(",
")",
"==",
"http",
".",
"StatusConflict",
"{",
"return",
"nil",
",",
"&",
"ost_errors",
".",
"ErrExists",
"{",
"Type",
":",
"\"",
"\"",
",",
"ID",
":",
"input",
".",
"Name",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"response",
".",
"Unmarshal",
"(",
"&",
"restoreResponse",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"restoreResponse",
",",
"nil",
"\n",
"}"
] |
// CloudBackupRestore downloads a cloud backup to a newly created volume
|
[
"CloudBackupRestore",
"downloads",
"a",
"cloud",
"backup",
"to",
"a",
"newly",
"created",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L559-L579
|
144,071 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CloudBackupSchedCreate
|
func (v *volumeClient) CloudBackupSchedCreate(
input *api.CloudBackupSchedCreateRequest,
) (*api.CloudBackupSchedCreateResponse, error) {
createResponse := &api.CloudBackupSchedCreateResponse{}
req := v.c.Post().Resource(api.OsdBackupPath + "/sched").Body(input)
response := req.Do()
if response.Error() != nil {
return nil, response.FormatError()
}
if err := response.Unmarshal(&createResponse); err != nil {
return nil, err
}
return createResponse, nil
}
|
go
|
func (v *volumeClient) CloudBackupSchedCreate(
input *api.CloudBackupSchedCreateRequest,
) (*api.CloudBackupSchedCreateResponse, error) {
createResponse := &api.CloudBackupSchedCreateResponse{}
req := v.c.Post().Resource(api.OsdBackupPath + "/sched").Body(input)
response := req.Do()
if response.Error() != nil {
return nil, response.FormatError()
}
if err := response.Unmarshal(&createResponse); err != nil {
return nil, err
}
return createResponse, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CloudBackupSchedCreate",
"(",
"input",
"*",
"api",
".",
"CloudBackupSchedCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"CloudBackupSchedCreateResponse",
",",
"error",
")",
"{",
"createResponse",
":=",
"&",
"api",
".",
"CloudBackupSchedCreateResponse",
"{",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdBackupPath",
"+",
"\"",
"\"",
")",
".",
"Body",
"(",
"input",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"response",
".",
"Unmarshal",
"(",
"&",
"createResponse",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"createResponse",
",",
"nil",
"\n",
"}"
] |
// CloudBackupSchedCreate for a volume creates a schedule to backup volume to cloud
|
[
"CloudBackupSchedCreate",
"for",
"a",
"volume",
"creates",
"a",
"schedule",
"to",
"backup",
"volume",
"to",
"cloud"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L687-L701
|
144,072 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CloudBackupSchedDelete
|
func (v *volumeClient) CloudBackupSchedDelete(
input *api.CloudBackupSchedDeleteRequest,
) error {
req := v.c.Delete().Resource(api.OsdBackupPath + "/sched").Body(input)
response := req.Do()
if response.Error() != nil {
return response.FormatError()
}
return nil
}
|
go
|
func (v *volumeClient) CloudBackupSchedDelete(
input *api.CloudBackupSchedDeleteRequest,
) error {
req := v.c.Delete().Resource(api.OsdBackupPath + "/sched").Body(input)
response := req.Do()
if response.Error() != nil {
return response.FormatError()
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CloudBackupSchedDelete",
"(",
"input",
"*",
"api",
".",
"CloudBackupSchedDeleteRequest",
",",
")",
"error",
"{",
"req",
":=",
"v",
".",
"c",
".",
"Delete",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdBackupPath",
"+",
"\"",
"\"",
")",
".",
"Body",
"(",
"input",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CloudBackupSchedDelete delete a volume's cloud backup-schedule
|
[
"CloudBackupSchedDelete",
"delete",
"a",
"volume",
"s",
"cloud",
"backup",
"-",
"schedule"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L722-L731
|
144,073 |
libopenstorage/openstorage
|
api/client/volume/client.go
|
CloudBackupSchedEnumerate
|
func (v *volumeClient) CloudBackupSchedEnumerate() (*api.CloudBackupSchedEnumerateResponse, error) {
enumerateResponse := &api.CloudBackupSchedEnumerateResponse{}
req := v.c.Get().Resource(api.OsdBackupPath + "/sched")
response := req.Do()
if response.Error() != nil {
return nil, response.FormatError()
}
if err := response.Unmarshal(enumerateResponse); err != nil {
return nil, err
}
return enumerateResponse, nil
}
|
go
|
func (v *volumeClient) CloudBackupSchedEnumerate() (*api.CloudBackupSchedEnumerateResponse, error) {
enumerateResponse := &api.CloudBackupSchedEnumerateResponse{}
req := v.c.Get().Resource(api.OsdBackupPath + "/sched")
response := req.Do()
if response.Error() != nil {
return nil, response.FormatError()
}
if err := response.Unmarshal(enumerateResponse); err != nil {
return nil, err
}
return enumerateResponse, nil
}
|
[
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CloudBackupSchedEnumerate",
"(",
")",
"(",
"*",
"api",
".",
"CloudBackupSchedEnumerateResponse",
",",
"error",
")",
"{",
"enumerateResponse",
":=",
"&",
"api",
".",
"CloudBackupSchedEnumerateResponse",
"{",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdBackupPath",
"+",
"\"",
"\"",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"response",
".",
"Unmarshal",
"(",
"enumerateResponse",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"enumerateResponse",
",",
"nil",
"\n",
"}"
] |
// CloudBackupSchedEnumerate enumerates the configured backup-schedules in the cluster
|
[
"CloudBackupSchedEnumerate",
"enumerates",
"the",
"configured",
"backup",
"-",
"schedules",
"in",
"the",
"cluster"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L734-L745
|
144,074 |
libopenstorage/openstorage
|
pkg/auth/systemtoken/systemtoken.go
|
NewManager
|
func NewManager(cfg *Config) (auth.TokenGenerator, error) {
if cfg == nil ||
len(cfg.ClusterId) == 0 ||
len(cfg.NodeId) == 0 ||
len(cfg.SharedSecret) == 0 {
return nil, fmt.Errorf("Must supply claims, clusterUuid, nodeId, and system secret")
}
claims := &auth.Claims{
Issuer: cfg.ClusterId,
Subject: cfg.NodeId,
Name: "Internal cluster communication",
Email: "[email protected]",
Roles: []string{"system.admin"},
Groups: []string{"*"},
}
return &manager{
config: cfg,
claims: claims,
}, nil
}
|
go
|
func NewManager(cfg *Config) (auth.TokenGenerator, error) {
if cfg == nil ||
len(cfg.ClusterId) == 0 ||
len(cfg.NodeId) == 0 ||
len(cfg.SharedSecret) == 0 {
return nil, fmt.Errorf("Must supply claims, clusterUuid, nodeId, and system secret")
}
claims := &auth.Claims{
Issuer: cfg.ClusterId,
Subject: cfg.NodeId,
Name: "Internal cluster communication",
Email: "[email protected]",
Roles: []string{"system.admin"},
Groups: []string{"*"},
}
return &manager{
config: cfg,
claims: claims,
}, nil
}
|
[
"func",
"NewManager",
"(",
"cfg",
"*",
"Config",
")",
"(",
"auth",
".",
"TokenGenerator",
",",
"error",
")",
"{",
"if",
"cfg",
"==",
"nil",
"||",
"len",
"(",
"cfg",
".",
"ClusterId",
")",
"==",
"0",
"||",
"len",
"(",
"cfg",
".",
"NodeId",
")",
"==",
"0",
"||",
"len",
"(",
"cfg",
".",
"SharedSecret",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"claims",
":=",
"&",
"auth",
".",
"Claims",
"{",
"Issuer",
":",
"cfg",
".",
"ClusterId",
",",
"Subject",
":",
"cfg",
".",
"NodeId",
",",
"Name",
":",
"\"",
"\"",
",",
"Email",
":",
"\"",
"\"",
",",
"Roles",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"Groups",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"}",
"\n\n",
"return",
"&",
"manager",
"{",
"config",
":",
"cfg",
",",
"claims",
":",
"claims",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewManager initializes the system token generator
|
[
"NewManager",
"initializes",
"the",
"system",
"token",
"generator"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/systemtoken/systemtoken.go#L27-L48
|
144,075 |
libopenstorage/openstorage
|
pkg/auth/systemtoken/systemtoken.go
|
GetAuthenticator
|
func (m *manager) GetAuthenticator() (auth.Authenticator, error) {
return auth.NewJwtAuth(&auth.JwtAuthConfig{
SharedSecret: []byte(m.config.SharedSecret),
})
}
|
go
|
func (m *manager) GetAuthenticator() (auth.Authenticator, error) {
return auth.NewJwtAuth(&auth.JwtAuthConfig{
SharedSecret: []byte(m.config.SharedSecret),
})
}
|
[
"func",
"(",
"m",
"*",
"manager",
")",
"GetAuthenticator",
"(",
")",
"(",
"auth",
".",
"Authenticator",
",",
"error",
")",
"{",
"return",
"auth",
".",
"NewJwtAuth",
"(",
"&",
"auth",
".",
"JwtAuthConfig",
"{",
"SharedSecret",
":",
"[",
"]",
"byte",
"(",
"m",
".",
"config",
".",
"SharedSecret",
")",
",",
"}",
")",
"\n",
"}"
] |
// GetAuthenticator returns an authenticator for this issuer used by the SDK
|
[
"GetAuthenticator",
"returns",
"an",
"authenticator",
"for",
"this",
"issuer",
"used",
"by",
"the",
"SDK"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/systemtoken/systemtoken.go#L57-L61
|
144,076 |
libopenstorage/openstorage
|
pkg/auth/systemtoken/systemtoken.go
|
GetToken
|
func (m *manager) GetToken(opts *auth.Options) (string, error) {
signature, err := auth.NewSignatureSharedSecret(m.config.SharedSecret)
if err != nil {
return "", err
}
return auth.Token(m.claims, signature, opts)
}
|
go
|
func (m *manager) GetToken(opts *auth.Options) (string, error) {
signature, err := auth.NewSignatureSharedSecret(m.config.SharedSecret)
if err != nil {
return "", err
}
return auth.Token(m.claims, signature, opts)
}
|
[
"func",
"(",
"m",
"*",
"manager",
")",
"GetToken",
"(",
"opts",
"*",
"auth",
".",
"Options",
")",
"(",
"string",
",",
"error",
")",
"{",
"signature",
",",
"err",
":=",
"auth",
".",
"NewSignatureSharedSecret",
"(",
"m",
".",
"config",
".",
"SharedSecret",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"auth",
".",
"Token",
"(",
"m",
".",
"claims",
",",
"signature",
",",
"opts",
")",
"\n",
"}"
] |
// GetToken returns a token which can be used for
// authentication and communication from node to node.
|
[
"GetToken",
"returns",
"a",
"token",
"which",
"can",
"be",
"used",
"for",
"authentication",
"and",
"communication",
"from",
"node",
"to",
"node",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/systemtoken/systemtoken.go#L65-L72
|
144,077 |
libopenstorage/openstorage
|
api/server/sdk/rest_gateway.go
|
restServerSetupHandlers
|
func (s *sdkRestGateway) restServerSetupHandlers() (http.Handler, error) {
// Create an HTTP server router
mux := http.NewServeMux()
// Swagger files using packr
swaggerUIBox := packr.NewBox("./swagger-ui")
swaggerJSONBox := packr.NewBox("./api")
mime.AddExtensionType(".svg", "image/svg+xml")
// Handler to return swagger.json
mux.HandleFunc("/swagger.json", func(w http.ResponseWriter, r *http.Request) {
w.Write(swaggerJSONBox.Bytes("api.swagger.json"))
})
// Handler to access the swagger ui. The UI pulls the swagger
// json file from /swagger.json
// The link below MUST have th last '/'. It is really important.
// This link is deprecated
prefix := "/swagger-ui/"
mux.Handle(prefix,
http.StripPrefix(prefix, http.FileServer(swaggerUIBox)))
// This is the new location
prefix = "/sdk/"
mux.Handle(prefix,
http.StripPrefix(prefix, http.FileServer(swaggerUIBox)))
// Create a router just for HTTP REST gRPC Server Gateway
gmux := runtime.NewServeMux()
// Connect to gRPC unix domain socket
conn, err := grpcserver.Connect(
s.grpcServer.Address(),
[]grpc.DialOption{grpc.WithInsecure()})
if err != nil {
return nil, fmt.Errorf("Failed to connect to gRPC handler: %v", err)
}
// REST Gateway Handlers
handlers := []func(context.Context, *runtime.ServeMux, *grpc.ClientConn) (err error){
api.RegisterOpenStorageClusterHandler,
api.RegisterOpenStorageNodeHandler,
api.RegisterOpenStorageVolumeHandler,
api.RegisterOpenStorageObjectstoreHandler,
api.RegisterOpenStorageCredentialsHandler,
api.RegisterOpenStorageSchedulePolicyHandler,
api.RegisterOpenStorageCloudBackupHandler,
api.RegisterOpenStorageIdentityHandler,
api.RegisterOpenStorageMountAttachHandler,
api.RegisterOpenStorageAlertsHandler,
api.RegisterOpenStorageClusterPairHandler,
api.RegisterOpenStorageMigrateHandler,
api.RegisterOpenStorageRoleHandler,
api.RegisterOpenStoragePolicyHandler,
}
// Register the REST Gateway handlers
for _, handler := range handlers {
err := handler(context.Background(), gmux, conn)
if err != nil {
return nil, err
}
}
// Pass all other unhandled paths to the gRPC gateway
mux.Handle("/", gmux)
// Enable cors
c := cors.New(cors.Options{
AllowedOrigins: []string{"*"},
AllowedMethods: []string{"GET", "POST", "DELETE", "HEAD", "PUT", "OPTIONS"},
AllowCredentials: true,
})
cmux := c.Handler(mux)
return cmux, nil
}
|
go
|
func (s *sdkRestGateway) restServerSetupHandlers() (http.Handler, error) {
// Create an HTTP server router
mux := http.NewServeMux()
// Swagger files using packr
swaggerUIBox := packr.NewBox("./swagger-ui")
swaggerJSONBox := packr.NewBox("./api")
mime.AddExtensionType(".svg", "image/svg+xml")
// Handler to return swagger.json
mux.HandleFunc("/swagger.json", func(w http.ResponseWriter, r *http.Request) {
w.Write(swaggerJSONBox.Bytes("api.swagger.json"))
})
// Handler to access the swagger ui. The UI pulls the swagger
// json file from /swagger.json
// The link below MUST have th last '/'. It is really important.
// This link is deprecated
prefix := "/swagger-ui/"
mux.Handle(prefix,
http.StripPrefix(prefix, http.FileServer(swaggerUIBox)))
// This is the new location
prefix = "/sdk/"
mux.Handle(prefix,
http.StripPrefix(prefix, http.FileServer(swaggerUIBox)))
// Create a router just for HTTP REST gRPC Server Gateway
gmux := runtime.NewServeMux()
// Connect to gRPC unix domain socket
conn, err := grpcserver.Connect(
s.grpcServer.Address(),
[]grpc.DialOption{grpc.WithInsecure()})
if err != nil {
return nil, fmt.Errorf("Failed to connect to gRPC handler: %v", err)
}
// REST Gateway Handlers
handlers := []func(context.Context, *runtime.ServeMux, *grpc.ClientConn) (err error){
api.RegisterOpenStorageClusterHandler,
api.RegisterOpenStorageNodeHandler,
api.RegisterOpenStorageVolumeHandler,
api.RegisterOpenStorageObjectstoreHandler,
api.RegisterOpenStorageCredentialsHandler,
api.RegisterOpenStorageSchedulePolicyHandler,
api.RegisterOpenStorageCloudBackupHandler,
api.RegisterOpenStorageIdentityHandler,
api.RegisterOpenStorageMountAttachHandler,
api.RegisterOpenStorageAlertsHandler,
api.RegisterOpenStorageClusterPairHandler,
api.RegisterOpenStorageMigrateHandler,
api.RegisterOpenStorageRoleHandler,
api.RegisterOpenStoragePolicyHandler,
}
// Register the REST Gateway handlers
for _, handler := range handlers {
err := handler(context.Background(), gmux, conn)
if err != nil {
return nil, err
}
}
// Pass all other unhandled paths to the gRPC gateway
mux.Handle("/", gmux)
// Enable cors
c := cors.New(cors.Options{
AllowedOrigins: []string{"*"},
AllowedMethods: []string{"GET", "POST", "DELETE", "HEAD", "PUT", "OPTIONS"},
AllowCredentials: true,
})
cmux := c.Handler(mux)
return cmux, nil
}
|
[
"func",
"(",
"s",
"*",
"sdkRestGateway",
")",
"restServerSetupHandlers",
"(",
")",
"(",
"http",
".",
"Handler",
",",
"error",
")",
"{",
"// Create an HTTP server router",
"mux",
":=",
"http",
".",
"NewServeMux",
"(",
")",
"\n\n",
"// Swagger files using packr",
"swaggerUIBox",
":=",
"packr",
".",
"NewBox",
"(",
"\"",
"\"",
")",
"\n",
"swaggerJSONBox",
":=",
"packr",
".",
"NewBox",
"(",
"\"",
"\"",
")",
"\n",
"mime",
".",
"AddExtensionType",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"// Handler to return swagger.json",
"mux",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"w",
".",
"Write",
"(",
"swaggerJSONBox",
".",
"Bytes",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
")",
"\n\n",
"// Handler to access the swagger ui. The UI pulls the swagger",
"// json file from /swagger.json",
"// The link below MUST have th last '/'. It is really important.",
"// This link is deprecated",
"prefix",
":=",
"\"",
"\"",
"\n",
"mux",
".",
"Handle",
"(",
"prefix",
",",
"http",
".",
"StripPrefix",
"(",
"prefix",
",",
"http",
".",
"FileServer",
"(",
"swaggerUIBox",
")",
")",
")",
"\n",
"// This is the new location",
"prefix",
"=",
"\"",
"\"",
"\n",
"mux",
".",
"Handle",
"(",
"prefix",
",",
"http",
".",
"StripPrefix",
"(",
"prefix",
",",
"http",
".",
"FileServer",
"(",
"swaggerUIBox",
")",
")",
")",
"\n\n",
"// Create a router just for HTTP REST gRPC Server Gateway",
"gmux",
":=",
"runtime",
".",
"NewServeMux",
"(",
")",
"\n\n",
"// Connect to gRPC unix domain socket",
"conn",
",",
"err",
":=",
"grpcserver",
".",
"Connect",
"(",
"s",
".",
"grpcServer",
".",
"Address",
"(",
")",
",",
"[",
"]",
"grpc",
".",
"DialOption",
"{",
"grpc",
".",
"WithInsecure",
"(",
")",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// REST Gateway Handlers",
"handlers",
":=",
"[",
"]",
"func",
"(",
"context",
".",
"Context",
",",
"*",
"runtime",
".",
"ServeMux",
",",
"*",
"grpc",
".",
"ClientConn",
")",
"(",
"err",
"error",
")",
"{",
"api",
".",
"RegisterOpenStorageClusterHandler",
",",
"api",
".",
"RegisterOpenStorageNodeHandler",
",",
"api",
".",
"RegisterOpenStorageVolumeHandler",
",",
"api",
".",
"RegisterOpenStorageObjectstoreHandler",
",",
"api",
".",
"RegisterOpenStorageCredentialsHandler",
",",
"api",
".",
"RegisterOpenStorageSchedulePolicyHandler",
",",
"api",
".",
"RegisterOpenStorageCloudBackupHandler",
",",
"api",
".",
"RegisterOpenStorageIdentityHandler",
",",
"api",
".",
"RegisterOpenStorageMountAttachHandler",
",",
"api",
".",
"RegisterOpenStorageAlertsHandler",
",",
"api",
".",
"RegisterOpenStorageClusterPairHandler",
",",
"api",
".",
"RegisterOpenStorageMigrateHandler",
",",
"api",
".",
"RegisterOpenStorageRoleHandler",
",",
"api",
".",
"RegisterOpenStoragePolicyHandler",
",",
"}",
"\n\n",
"// Register the REST Gateway handlers",
"for",
"_",
",",
"handler",
":=",
"range",
"handlers",
"{",
"err",
":=",
"handler",
"(",
"context",
".",
"Background",
"(",
")",
",",
"gmux",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Pass all other unhandled paths to the gRPC gateway",
"mux",
".",
"Handle",
"(",
"\"",
"\"",
",",
"gmux",
")",
"\n\n",
"// Enable cors",
"c",
":=",
"cors",
".",
"New",
"(",
"cors",
".",
"Options",
"{",
"AllowedOrigins",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"AllowedMethods",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"AllowCredentials",
":",
"true",
",",
"}",
")",
"\n",
"cmux",
":=",
"c",
".",
"Handler",
"(",
"mux",
")",
"\n",
"return",
"cmux",
",",
"nil",
"\n",
"}"
] |
// restServerSetupHandlers sets up the handlers to the swagger ui and
// to the gRPC REST Gateway.
|
[
"restServerSetupHandlers",
"sets",
"up",
"the",
"handlers",
"to",
"the",
"swagger",
"ui",
"and",
"to",
"the",
"gRPC",
"REST",
"Gateway",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/rest_gateway.go#L94-L169
|
144,078 |
libopenstorage/openstorage
|
pkg/seed/git.go
|
Load
|
func (g *Git) Load(dest string) error {
g.ready = false
cmd := exec.Command("git", "clone", g.host, dest)
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("'wd: %s git clone %s': %s: %s", dest, g.host, output, err)
}
if len(g.revision) == 0 {
g.ready = true
return nil
}
cmd = exec.Command("git", "checkout", g.revision)
cmd.Dir = dest
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("wd %v 'git checkout %s': %s: %s", cmd.Dir, g.revision, output, err)
}
cmd = exec.Command("git", "reset", "--hard")
cmd.Dir = dest
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("wd %v 'git reset --hard %s': %s: %s", cmd.Dir, g.revision, output, err)
}
g.ready = true
return nil
}
|
go
|
func (g *Git) Load(dest string) error {
g.ready = false
cmd := exec.Command("git", "clone", g.host, dest)
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("'wd: %s git clone %s': %s: %s", dest, g.host, output, err)
}
if len(g.revision) == 0 {
g.ready = true
return nil
}
cmd = exec.Command("git", "checkout", g.revision)
cmd.Dir = dest
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("wd %v 'git checkout %s': %s: %s", cmd.Dir, g.revision, output, err)
}
cmd = exec.Command("git", "reset", "--hard")
cmd.Dir = dest
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("wd %v 'git reset --hard %s': %s: %s", cmd.Dir, g.revision, output, err)
}
g.ready = true
return nil
}
|
[
"func",
"(",
"g",
"*",
"Git",
")",
"Load",
"(",
"dest",
"string",
")",
"error",
"{",
"g",
".",
"ready",
"=",
"false",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"g",
".",
"host",
",",
"dest",
")",
"\n\n",
"if",
"output",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"dest",
",",
"g",
".",
"host",
",",
"output",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"g",
".",
"revision",
")",
"==",
"0",
"{",
"g",
".",
"ready",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"g",
".",
"revision",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"dest",
"\n",
"if",
"output",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cmd",
".",
"Dir",
",",
"g",
".",
"revision",
",",
"output",
",",
"err",
")",
"\n",
"}",
"\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"dest",
"\n",
"if",
"output",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cmd",
".",
"Dir",
",",
"g",
".",
"revision",
",",
"output",
",",
"err",
")",
"\n",
"}",
"\n\n",
"g",
".",
"ready",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Load from URI into dest.
|
[
"Load",
"from",
"URI",
"into",
"dest",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/seed/git.go#L24-L49
|
144,079 |
libopenstorage/openstorage
|
volume/drivers/buse/nbd.go
|
Create
|
func Create(device Device, id string, size int64) *NBD {
if shuttingDown {
logrus.Warnf("Cannot create NBD device during shutdown")
return nil
}
if size >= 0 {
globalMutex.Lock()
defer globalMutex.Unlock()
dev := &NBD{device: device,
devicePath: "",
size: size,
deviceFile: nil,
socket: 0,
mutex: &sync.Mutex{},
}
nbdDevices[id] = dev
return dev
}
return nil
}
|
go
|
func Create(device Device, id string, size int64) *NBD {
if shuttingDown {
logrus.Warnf("Cannot create NBD device during shutdown")
return nil
}
if size >= 0 {
globalMutex.Lock()
defer globalMutex.Unlock()
dev := &NBD{device: device,
devicePath: "",
size: size,
deviceFile: nil,
socket: 0,
mutex: &sync.Mutex{},
}
nbdDevices[id] = dev
return dev
}
return nil
}
|
[
"func",
"Create",
"(",
"device",
"Device",
",",
"id",
"string",
",",
"size",
"int64",
")",
"*",
"NBD",
"{",
"if",
"shuttingDown",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"size",
">=",
"0",
"{",
"globalMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"dev",
":=",
"&",
"NBD",
"{",
"device",
":",
"device",
",",
"devicePath",
":",
"\"",
"\"",
",",
"size",
":",
"size",
",",
"deviceFile",
":",
"nil",
",",
"socket",
":",
"0",
",",
"mutex",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"}",
"\n\n",
"nbdDevices",
"[",
"id",
"]",
"=",
"dev",
"\n",
"return",
"dev",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Create creates a NBD type interface
|
[
"Create",
"creates",
"a",
"NBD",
"type",
"interface"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/nbd.go#L102-L125
|
144,080 |
libopenstorage/openstorage
|
volume/drivers/buse/nbd.go
|
Size
|
func (nbd *NBD) Size(size int64) (err error) {
if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_BLKSIZE, 4096); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_BLKSIZE",
Err: err,
}
} else if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_SIZE_BLOCKS, uintptr(size/4096)); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_SIZE_BLOCKS",
Err: err,
}
}
return err
}
|
go
|
func (nbd *NBD) Size(size int64) (err error) {
if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_BLKSIZE, 4096); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_BLKSIZE",
Err: err,
}
} else if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_SIZE_BLOCKS, uintptr(size/4096)); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_SIZE_BLOCKS",
Err: err,
}
}
return err
}
|
[
"func",
"(",
"nbd",
"*",
"NBD",
")",
"Size",
"(",
"size",
"int64",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
"=",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_SET_BLKSIZE",
",",
"4096",
")",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"os",
".",
"PathError",
"{",
"Op",
":",
"nbd",
".",
"deviceFile",
".",
"Name",
"(",
")",
",",
"Path",
":",
"\"",
"\"",
",",
"Err",
":",
"err",
",",
"}",
"\n",
"}",
"else",
"if",
"err",
"=",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_SET_SIZE_BLOCKS",
",",
"uintptr",
"(",
"size",
"/",
"4096",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"os",
".",
"PathError",
"{",
"Op",
":",
"nbd",
".",
"deviceFile",
".",
"Name",
"(",
")",
",",
"Path",
":",
"\"",
"\"",
",",
"Err",
":",
"err",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}"
] |
// Size sets the size of the NBD.
|
[
"Size",
"sets",
"the",
"size",
"of",
"the",
"NBD",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/nbd.go#L138-L154
|
144,081 |
libopenstorage/openstorage
|
volume/drivers/buse/nbd.go
|
Connect
|
func (nbd *NBD) Connect() (dev string, err error) {
pair, err := syscall.Socketpair(syscall.SOCK_STREAM, syscall.AF_UNIX, 0)
if err != nil {
return "", err
}
// Find free NBD device.
for i := 0; ; i++ {
dev = fmt.Sprintf("/dev/nbd%d", i)
if _, err = os.Stat(dev); os.IsNotExist(err) {
dev = ""
return "", errors.New("No more NBD devices left.")
}
if _, err = os.Stat(fmt.Sprintf("/sys/block/nbd%d/pid", i)); !os.IsNotExist(err) {
continue // Busy.
}
logrus.Infof("Attempting to open device %v", dev)
if nbd.deviceFile, err = os.Open(dev); err == nil {
// Possible candidate.
ioctl(nbd.deviceFile.Fd(), BLKROSET, 0)
if err := ioctl(nbd.deviceFile.Fd(), NBD_SET_SOCK, uintptr(pair[0])); err == nil {
nbd.socket = pair[1]
break // Success.
}
}
}
// Setup.
if err = nbd.Size(nbd.size); err != nil {
// Already set by nbd.Size().
} else if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_FLAGS, 1); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_FLAGS",
Err: err,
}
} else {
go nbd.connect()
go nbd.handle()
}
nbd.devicePath = dev
return dev, err
}
|
go
|
func (nbd *NBD) Connect() (dev string, err error) {
pair, err := syscall.Socketpair(syscall.SOCK_STREAM, syscall.AF_UNIX, 0)
if err != nil {
return "", err
}
// Find free NBD device.
for i := 0; ; i++ {
dev = fmt.Sprintf("/dev/nbd%d", i)
if _, err = os.Stat(dev); os.IsNotExist(err) {
dev = ""
return "", errors.New("No more NBD devices left.")
}
if _, err = os.Stat(fmt.Sprintf("/sys/block/nbd%d/pid", i)); !os.IsNotExist(err) {
continue // Busy.
}
logrus.Infof("Attempting to open device %v", dev)
if nbd.deviceFile, err = os.Open(dev); err == nil {
// Possible candidate.
ioctl(nbd.deviceFile.Fd(), BLKROSET, 0)
if err := ioctl(nbd.deviceFile.Fd(), NBD_SET_SOCK, uintptr(pair[0])); err == nil {
nbd.socket = pair[1]
break // Success.
}
}
}
// Setup.
if err = nbd.Size(nbd.size); err != nil {
// Already set by nbd.Size().
} else if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_FLAGS, 1); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_FLAGS",
Err: err,
}
} else {
go nbd.connect()
go nbd.handle()
}
nbd.devicePath = dev
return dev, err
}
|
[
"func",
"(",
"nbd",
"*",
"NBD",
")",
"Connect",
"(",
")",
"(",
"dev",
"string",
",",
"err",
"error",
")",
"{",
"pair",
",",
"err",
":=",
"syscall",
".",
"Socketpair",
"(",
"syscall",
".",
"SOCK_STREAM",
",",
"syscall",
".",
"AF_UNIX",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// Find free NBD device.",
"for",
"i",
":=",
"0",
";",
";",
"i",
"++",
"{",
"dev",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"dev",
")",
";",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"dev",
"=",
"\"",
"\"",
"\n",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
")",
")",
";",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"continue",
"// Busy.",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"dev",
")",
"\n",
"if",
"nbd",
".",
"deviceFile",
",",
"err",
"=",
"os",
".",
"Open",
"(",
"dev",
")",
";",
"err",
"==",
"nil",
"{",
"// Possible candidate.",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"BLKROSET",
",",
"0",
")",
"\n",
"if",
"err",
":=",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_SET_SOCK",
",",
"uintptr",
"(",
"pair",
"[",
"0",
"]",
")",
")",
";",
"err",
"==",
"nil",
"{",
"nbd",
".",
"socket",
"=",
"pair",
"[",
"1",
"]",
"\n",
"break",
"// Success.",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Setup.",
"if",
"err",
"=",
"nbd",
".",
"Size",
"(",
"nbd",
".",
"size",
")",
";",
"err",
"!=",
"nil",
"{",
"// Already set by nbd.Size().",
"}",
"else",
"if",
"err",
"=",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_SET_FLAGS",
",",
"1",
")",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"os",
".",
"PathError",
"{",
"Op",
":",
"nbd",
".",
"deviceFile",
".",
"Name",
"(",
")",
",",
"Path",
":",
"\"",
"\"",
",",
"Err",
":",
"err",
",",
"}",
"\n",
"}",
"else",
"{",
"go",
"nbd",
".",
"connect",
"(",
")",
"\n",
"go",
"nbd",
".",
"handle",
"(",
")",
"\n",
"}",
"\n\n",
"nbd",
".",
"devicePath",
"=",
"dev",
"\n\n",
"return",
"dev",
",",
"err",
"\n",
"}"
] |
// Connect the network block device.
|
[
"Connect",
"the",
"network",
"block",
"device",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/nbd.go#L157-L202
|
144,082 |
libopenstorage/openstorage
|
volume/drivers/buse/nbd.go
|
Disconnect
|
func (nbd *NBD) Disconnect() {
nbd.mutex.Lock()
defer nbd.mutex.Unlock()
logrus.Infof("Disconnecting device %v...", nbd.devicePath)
syscall.Unmount(nbd.devicePath, 0)
if nbd.IsConnected() {
logrus.Infof("Issuing a disconnect on %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_DISCONNECT, 0)
logrus.Infof("Clearing NBD queue %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_CLEAR_QUE, 0)
logrus.Infof("Clearing NBD socket %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_CLEAR_SOCK, 0)
logrus.Infof("Closing NBD device file %v", nbd.devicePath)
nbd.deviceFile.Close()
nbd.deviceFile = nil
dummy := make([]byte, 1)
logrus.Infof("Waking up control socket for %v", nbd.devicePath)
syscall.Write(nbd.socket, dummy)
logrus.Infof("Closing control socket for %v", nbd.devicePath)
syscall.Close(nbd.socket)
nbd.socket = 0
}
logrus.Infof("Disconnected device %v", nbd.devicePath)
}
|
go
|
func (nbd *NBD) Disconnect() {
nbd.mutex.Lock()
defer nbd.mutex.Unlock()
logrus.Infof("Disconnecting device %v...", nbd.devicePath)
syscall.Unmount(nbd.devicePath, 0)
if nbd.IsConnected() {
logrus.Infof("Issuing a disconnect on %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_DISCONNECT, 0)
logrus.Infof("Clearing NBD queue %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_CLEAR_QUE, 0)
logrus.Infof("Clearing NBD socket %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_CLEAR_SOCK, 0)
logrus.Infof("Closing NBD device file %v", nbd.devicePath)
nbd.deviceFile.Close()
nbd.deviceFile = nil
dummy := make([]byte, 1)
logrus.Infof("Waking up control socket for %v", nbd.devicePath)
syscall.Write(nbd.socket, dummy)
logrus.Infof("Closing control socket for %v", nbd.devicePath)
syscall.Close(nbd.socket)
nbd.socket = 0
}
logrus.Infof("Disconnected device %v", nbd.devicePath)
}
|
[
"func",
"(",
"nbd",
"*",
"NBD",
")",
"Disconnect",
"(",
")",
"{",
"nbd",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"nbd",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n\n",
"syscall",
".",
"Unmount",
"(",
"nbd",
".",
"devicePath",
",",
"0",
")",
"\n",
"if",
"nbd",
".",
"IsConnected",
"(",
")",
"{",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_DISCONNECT",
",",
"0",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_CLEAR_QUE",
",",
"0",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_CLEAR_SOCK",
",",
"0",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"nbd",
".",
"deviceFile",
".",
"Close",
"(",
")",
"\n",
"nbd",
".",
"deviceFile",
"=",
"nil",
"\n\n",
"dummy",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"syscall",
".",
"Write",
"(",
"nbd",
".",
"socket",
",",
"dummy",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"syscall",
".",
"Close",
"(",
"nbd",
".",
"socket",
")",
"\n",
"nbd",
".",
"socket",
"=",
"0",
"\n",
"}",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"}"
] |
// Disconnect disconnects the network block device
|
[
"Disconnect",
"disconnects",
"the",
"network",
"block",
"device"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/nbd.go#L205-L231
|
144,083 |
libopenstorage/openstorage
|
pkg/auth/oidc.go
|
NewOIDC
|
func NewOIDC(config *OIDCAuthConfig) (*OIDCAuthenticator, error) {
p, err := oidc.NewProvider(context.Background(), config.Issuer)
if err != nil {
return nil, fmt.Errorf("Unable to communicate with OIDC provider %s: %v",
config.Issuer,
err)
}
v := p.Verifier(&oidc.Config{
ClientID: config.ClientID,
SkipClientIDCheck: config.SkipClientIDCheck,
})
return &OIDCAuthenticator{
url: config.Issuer,
usernameClaim: config.UsernameClaim,
namespace: config.Namespace,
provider: p,
verifier: v,
}, nil
}
|
go
|
func NewOIDC(config *OIDCAuthConfig) (*OIDCAuthenticator, error) {
p, err := oidc.NewProvider(context.Background(), config.Issuer)
if err != nil {
return nil, fmt.Errorf("Unable to communicate with OIDC provider %s: %v",
config.Issuer,
err)
}
v := p.Verifier(&oidc.Config{
ClientID: config.ClientID,
SkipClientIDCheck: config.SkipClientIDCheck,
})
return &OIDCAuthenticator{
url: config.Issuer,
usernameClaim: config.UsernameClaim,
namespace: config.Namespace,
provider: p,
verifier: v,
}, nil
}
|
[
"func",
"NewOIDC",
"(",
"config",
"*",
"OIDCAuthConfig",
")",
"(",
"*",
"OIDCAuthenticator",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"oidc",
".",
"NewProvider",
"(",
"context",
".",
"Background",
"(",
")",
",",
"config",
".",
"Issuer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"config",
".",
"Issuer",
",",
"err",
")",
"\n",
"}",
"\n\n",
"v",
":=",
"p",
".",
"Verifier",
"(",
"&",
"oidc",
".",
"Config",
"{",
"ClientID",
":",
"config",
".",
"ClientID",
",",
"SkipClientIDCheck",
":",
"config",
".",
"SkipClientIDCheck",
",",
"}",
")",
"\n",
"return",
"&",
"OIDCAuthenticator",
"{",
"url",
":",
"config",
".",
"Issuer",
",",
"usernameClaim",
":",
"config",
".",
"UsernameClaim",
",",
"namespace",
":",
"config",
".",
"Namespace",
",",
"provider",
":",
"p",
",",
"verifier",
":",
"v",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewOIDC returns a new OIDC authenticator
|
[
"NewOIDC",
"returns",
"a",
"new",
"OIDC",
"authenticator"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/oidc.go#L55-L74
|
144,084 |
libopenstorage/openstorage
|
pkg/auth/oidc.go
|
AuthenticateToken
|
func (o *OIDCAuthenticator) AuthenticateToken(ctx context.Context, rawtoken string) (*Claims, error) {
idToken, err := o.verifier.Verify(ctx, rawtoken)
if err != nil {
return nil, fmt.Errorf("Token failed validation: %v", err)
}
// Check for required claims
var claims map[string]interface{}
if err := idToken.Claims(&claims); err != nil {
return nil, fmt.Errorf("Unable to get claim map from token: %v", err)
}
for _, requiredClaim := range requiredClaims {
if _, ok := claims[requiredClaim]; !ok {
// Claim missing
return nil, fmt.Errorf("Required claim %v missing from token", requiredClaim)
}
}
return o.parseClaims(claims)
}
|
go
|
func (o *OIDCAuthenticator) AuthenticateToken(ctx context.Context, rawtoken string) (*Claims, error) {
idToken, err := o.verifier.Verify(ctx, rawtoken)
if err != nil {
return nil, fmt.Errorf("Token failed validation: %v", err)
}
// Check for required claims
var claims map[string]interface{}
if err := idToken.Claims(&claims); err != nil {
return nil, fmt.Errorf("Unable to get claim map from token: %v", err)
}
for _, requiredClaim := range requiredClaims {
if _, ok := claims[requiredClaim]; !ok {
// Claim missing
return nil, fmt.Errorf("Required claim %v missing from token", requiredClaim)
}
}
return o.parseClaims(claims)
}
|
[
"func",
"(",
"o",
"*",
"OIDCAuthenticator",
")",
"AuthenticateToken",
"(",
"ctx",
"context",
".",
"Context",
",",
"rawtoken",
"string",
")",
"(",
"*",
"Claims",
",",
"error",
")",
"{",
"idToken",
",",
"err",
":=",
"o",
".",
"verifier",
".",
"Verify",
"(",
"ctx",
",",
"rawtoken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Check for required claims",
"var",
"claims",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"idToken",
".",
"Claims",
"(",
"&",
"claims",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"requiredClaim",
":=",
"range",
"requiredClaims",
"{",
"if",
"_",
",",
"ok",
":=",
"claims",
"[",
"requiredClaim",
"]",
";",
"!",
"ok",
"{",
"// Claim missing",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"requiredClaim",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"o",
".",
"parseClaims",
"(",
"claims",
")",
"\n",
"}"
] |
// AuthenticateToken will verify the validity of the provided token with the OIDC
|
[
"AuthenticateToken",
"will",
"verify",
"the",
"validity",
"of",
"the",
"provided",
"token",
"with",
"the",
"OIDC"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/oidc.go#L77-L96
|
144,085 |
libopenstorage/openstorage
|
pkg/auth/oidc.go
|
Username
|
func (o *OIDCAuthenticator) Username(claims *Claims) string {
return getUsername(o.usernameClaim, claims)
}
|
go
|
func (o *OIDCAuthenticator) Username(claims *Claims) string {
return getUsername(o.usernameClaim, claims)
}
|
[
"func",
"(",
"o",
"*",
"OIDCAuthenticator",
")",
"Username",
"(",
"claims",
"*",
"Claims",
")",
"string",
"{",
"return",
"getUsername",
"(",
"o",
".",
"usernameClaim",
",",
"claims",
")",
"\n",
"}"
] |
// Username returns the configured unique id of the user
|
[
"Username",
"returns",
"the",
"configured",
"unique",
"id",
"of",
"the",
"user"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/oidc.go#L99-L101
|
144,086 |
libopenstorage/openstorage
|
pkg/auth/oidc.go
|
parseClaims
|
func (o *OIDCAuthenticator) parseClaims(claims map[string]interface{}) (*Claims, error) {
// If we have namespace set, then use it to get custom claims:
if len(o.namespace) > 0 {
for _, cc := range customClaims {
// Check if there claims needed are under a namespace
if v, ok := claims[o.namespace+cc]; ok {
// Move it to the top of the json tree overwriting anything
// there with the same name.
claims[cc] = v
}
}
}
// Marshal into byte stream so that we can unmarshal into SDK Claims
cbytes, err := json.Marshal(claims)
if err != nil {
return nil, fmt.Errorf("Internal error, unable to re-encode OIDC token claims: %v", err)
}
// Return claims
var sdkClaims Claims
if err := json.Unmarshal(cbytes, &sdkClaims); err != nil {
return nil, fmt.Errorf("Unable to get claims from token: %v", err)
}
if err := validateUsername(o.usernameClaim, &sdkClaims); err != nil {
return nil, err
}
return &sdkClaims, nil
}
|
go
|
func (o *OIDCAuthenticator) parseClaims(claims map[string]interface{}) (*Claims, error) {
// If we have namespace set, then use it to get custom claims:
if len(o.namespace) > 0 {
for _, cc := range customClaims {
// Check if there claims needed are under a namespace
if v, ok := claims[o.namespace+cc]; ok {
// Move it to the top of the json tree overwriting anything
// there with the same name.
claims[cc] = v
}
}
}
// Marshal into byte stream so that we can unmarshal into SDK Claims
cbytes, err := json.Marshal(claims)
if err != nil {
return nil, fmt.Errorf("Internal error, unable to re-encode OIDC token claims: %v", err)
}
// Return claims
var sdkClaims Claims
if err := json.Unmarshal(cbytes, &sdkClaims); err != nil {
return nil, fmt.Errorf("Unable to get claims from token: %v", err)
}
if err := validateUsername(o.usernameClaim, &sdkClaims); err != nil {
return nil, err
}
return &sdkClaims, nil
}
|
[
"func",
"(",
"o",
"*",
"OIDCAuthenticator",
")",
"parseClaims",
"(",
"claims",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"*",
"Claims",
",",
"error",
")",
"{",
"// If we have namespace set, then use it to get custom claims:",
"if",
"len",
"(",
"o",
".",
"namespace",
")",
">",
"0",
"{",
"for",
"_",
",",
"cc",
":=",
"range",
"customClaims",
"{",
"// Check if there claims needed are under a namespace",
"if",
"v",
",",
"ok",
":=",
"claims",
"[",
"o",
".",
"namespace",
"+",
"cc",
"]",
";",
"ok",
"{",
"// Move it to the top of the json tree overwriting anything",
"// there with the same name.",
"claims",
"[",
"cc",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Marshal into byte stream so that we can unmarshal into SDK Claims",
"cbytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"claims",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Return claims",
"var",
"sdkClaims",
"Claims",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"cbytes",
",",
"&",
"sdkClaims",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"validateUsername",
"(",
"o",
".",
"usernameClaim",
",",
"&",
"sdkClaims",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"sdkClaims",
",",
"nil",
"\n",
"}"
] |
// This will let us unit test this function without having a real OIDC
|
[
"This",
"will",
"let",
"us",
"unit",
"test",
"this",
"function",
"without",
"having",
"a",
"real",
"OIDC"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/oidc.go#L104-L135
|
144,087 |
libopenstorage/openstorage
|
pkg/storageops/utils.go
|
AddElementToMap
|
func AddElementToMap(
sets map[string][]interface{},
elem interface{},
key string,
) {
if s, ok := sets[key]; ok {
sets[key] = append(s, elem)
} else {
sets[key] = make([]interface{}, 0)
sets[key] = append(sets[key], elem)
}
}
|
go
|
func AddElementToMap(
sets map[string][]interface{},
elem interface{},
key string,
) {
if s, ok := sets[key]; ok {
sets[key] = append(s, elem)
} else {
sets[key] = make([]interface{}, 0)
sets[key] = append(sets[key], elem)
}
}
|
[
"func",
"AddElementToMap",
"(",
"sets",
"map",
"[",
"string",
"]",
"[",
"]",
"interface",
"{",
"}",
",",
"elem",
"interface",
"{",
"}",
",",
"key",
"string",
",",
")",
"{",
"if",
"s",
",",
"ok",
":=",
"sets",
"[",
"key",
"]",
";",
"ok",
"{",
"sets",
"[",
"key",
"]",
"=",
"append",
"(",
"s",
",",
"elem",
")",
"\n",
"}",
"else",
"{",
"sets",
"[",
"key",
"]",
"=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"sets",
"[",
"key",
"]",
"=",
"append",
"(",
"sets",
"[",
"key",
"]",
",",
"elem",
")",
"\n",
"}",
"\n",
"}"
] |
// AddElementToMap adds to the given 'elem' to the 'sets' map with given 'key'
|
[
"AddElementToMap",
"adds",
"to",
"the",
"given",
"elem",
"to",
"the",
"sets",
"map",
"with",
"given",
"key"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/utils.go#L20-L31
|
144,088 |
libopenstorage/openstorage
|
pkg/storageops/utils.go
|
GetEnvValueStrict
|
func GetEnvValueStrict(key string) (string, error) {
if val := os.Getenv(key); len(val) != 0 {
return strings.TrimSpace(val), nil
}
return "", fmt.Errorf("env variable %s is not set", key)
}
|
go
|
func GetEnvValueStrict(key string) (string, error) {
if val := os.Getenv(key); len(val) != 0 {
return strings.TrimSpace(val), nil
}
return "", fmt.Errorf("env variable %s is not set", key)
}
|
[
"func",
"GetEnvValueStrict",
"(",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"val",
":=",
"os",
".",
"Getenv",
"(",
"key",
")",
";",
"len",
"(",
"val",
")",
"!=",
"0",
"{",
"return",
"strings",
".",
"TrimSpace",
"(",
"val",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"}"
] |
// GetEnvValueStrict fetches value for env variable "key". Returns error if not found or empty
|
[
"GetEnvValueStrict",
"fetches",
"value",
"for",
"env",
"variable",
"key",
".",
"Returns",
"error",
"if",
"not",
"found",
"or",
"empty"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/utils.go#L34-L40
|
144,089 |
libopenstorage/openstorage
|
alerts/action.go
|
clearActionFunc
|
func clearActionFunc(manager Manager, filters ...Filter) error {
myAlerts, err := manager.Enumerate(filters...)
if err != nil {
return err
}
for _, myAlert := range myAlerts {
myAlert.Cleared = true
if err := manager.Raise(myAlert); err != nil {
return err
}
}
return nil
}
|
go
|
func clearActionFunc(manager Manager, filters ...Filter) error {
myAlerts, err := manager.Enumerate(filters...)
if err != nil {
return err
}
for _, myAlert := range myAlerts {
myAlert.Cleared = true
if err := manager.Raise(myAlert); err != nil {
return err
}
}
return nil
}
|
[
"func",
"clearActionFunc",
"(",
"manager",
"Manager",
",",
"filters",
"...",
"Filter",
")",
"error",
"{",
"myAlerts",
",",
"err",
":=",
"manager",
".",
"Enumerate",
"(",
"filters",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"myAlert",
":=",
"range",
"myAlerts",
"{",
"myAlert",
".",
"Cleared",
"=",
"true",
"\n",
"if",
"err",
":=",
"manager",
".",
"Raise",
"(",
"myAlert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// clearActionFunc first enumerates, then changes Cleared flag to true,
// then updates it.
// Raise method determines if ttlOption needs to be applied based on clear flag.
|
[
"clearActionFunc",
"first",
"enumerates",
"then",
"changes",
"Cleared",
"flag",
"to",
"true",
"then",
"updates",
"it",
".",
"Raise",
"method",
"determines",
"if",
"ttlOption",
"needs",
"to",
"be",
"applied",
"based",
"on",
"clear",
"flag",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/action.go#L39-L53
|
144,090 |
libopenstorage/openstorage
|
pkg/auth/selfsigned.go
|
NewJwtAuth
|
func NewJwtAuth(config *JwtAuthConfig) (*JwtAuthenticator, error) {
if config == nil {
return nil, fmt.Errorf("Must provide configuration")
}
// Check at least one is set
if len(config.SharedSecret) == 0 &&
len(config.RsaPublicPem) == 0 &&
len(config.ECDSPublicPem) == 0 {
return nil, fmt.Errorf("Server was passed empty authentication information with no shared secret or pem files set")
}
authenticator := &JwtAuthenticator{
config: *config,
usernameClaim: config.UsernameClaim,
}
var err error
if len(config.SharedSecret) != 0 {
authenticator.sharedSecretKey = config.SharedSecret
}
if len(config.RsaPublicPem) != 0 {
authenticator.rsaKey, err = jwt.ParseRSAPublicKeyFromPEM(config.RsaPublicPem)
if err != nil {
return nil, fmt.Errorf("Unable to parse rsa public key: %v", err)
}
}
if len(config.ECDSPublicPem) != 0 {
authenticator.ecdsKey, err = jwt.ParseECPublicKeyFromPEM(config.ECDSPublicPem)
if err != nil {
return nil, fmt.Errorf("Unable to parse ecds public key: %v", err)
}
}
return authenticator, nil
}
|
go
|
func NewJwtAuth(config *JwtAuthConfig) (*JwtAuthenticator, error) {
if config == nil {
return nil, fmt.Errorf("Must provide configuration")
}
// Check at least one is set
if len(config.SharedSecret) == 0 &&
len(config.RsaPublicPem) == 0 &&
len(config.ECDSPublicPem) == 0 {
return nil, fmt.Errorf("Server was passed empty authentication information with no shared secret or pem files set")
}
authenticator := &JwtAuthenticator{
config: *config,
usernameClaim: config.UsernameClaim,
}
var err error
if len(config.SharedSecret) != 0 {
authenticator.sharedSecretKey = config.SharedSecret
}
if len(config.RsaPublicPem) != 0 {
authenticator.rsaKey, err = jwt.ParseRSAPublicKeyFromPEM(config.RsaPublicPem)
if err != nil {
return nil, fmt.Errorf("Unable to parse rsa public key: %v", err)
}
}
if len(config.ECDSPublicPem) != 0 {
authenticator.ecdsKey, err = jwt.ParseECPublicKeyFromPEM(config.ECDSPublicPem)
if err != nil {
return nil, fmt.Errorf("Unable to parse ecds public key: %v", err)
}
}
return authenticator, nil
}
|
[
"func",
"NewJwtAuth",
"(",
"config",
"*",
"JwtAuthConfig",
")",
"(",
"*",
"JwtAuthenticator",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check at least one is set",
"if",
"len",
"(",
"config",
".",
"SharedSecret",
")",
"==",
"0",
"&&",
"len",
"(",
"config",
".",
"RsaPublicPem",
")",
"==",
"0",
"&&",
"len",
"(",
"config",
".",
"ECDSPublicPem",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"authenticator",
":=",
"&",
"JwtAuthenticator",
"{",
"config",
":",
"*",
"config",
",",
"usernameClaim",
":",
"config",
".",
"UsernameClaim",
",",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"if",
"len",
"(",
"config",
".",
"SharedSecret",
")",
"!=",
"0",
"{",
"authenticator",
".",
"sharedSecretKey",
"=",
"config",
".",
"SharedSecret",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"RsaPublicPem",
")",
"!=",
"0",
"{",
"authenticator",
".",
"rsaKey",
",",
"err",
"=",
"jwt",
".",
"ParseRSAPublicKeyFromPEM",
"(",
"config",
".",
"RsaPublicPem",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"ECDSPublicPem",
")",
"!=",
"0",
"{",
"authenticator",
".",
"ecdsKey",
",",
"err",
"=",
"jwt",
".",
"ParseECPublicKeyFromPEM",
"(",
"config",
".",
"ECDSPublicPem",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"authenticator",
",",
"nil",
"\n",
"}"
] |
// New returns a JwtAuthenticator
|
[
"New",
"returns",
"a",
"JwtAuthenticator"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/selfsigned.go#L51-L87
|
144,091 |
libopenstorage/openstorage
|
pkg/auth/selfsigned.go
|
AuthenticateToken
|
func (j *JwtAuthenticator) AuthenticateToken(ctx context.Context, rawtoken string) (*Claims, error) {
// Parse token
token, err := jwt.Parse(rawtoken, func(token *jwt.Token) (interface{}, error) {
// Verify Method
if strings.HasPrefix(token.Method.Alg(), "RS") {
// RS256, RS384, or RS512
return j.rsaKey, nil
} else if strings.HasPrefix(token.Method.Alg(), "ES") {
// ES256, ES384, or ES512
return j.ecdsKey, nil
} else if strings.HasPrefix(token.Method.Alg(), "HS") {
// HS256, HS384, or HS512
return j.sharedSecretKey, nil
}
return nil, fmt.Errorf("Unknown token algorithm: %s", token.Method.Alg())
})
if err != nil {
return nil, err
}
if !token.Valid {
return nil, fmt.Errorf("Token failed validation")
}
// Get claims
claims, ok := token.Claims.(jwt.MapClaims)
if claims == nil || !ok {
return nil, fmt.Errorf("No claims found in token")
}
// Check for required claims
for _, requiredClaim := range requiredClaims {
if _, ok := claims[requiredClaim]; !ok {
// Claim missing
return nil, fmt.Errorf("Required claim %v missing from token", requiredClaim)
}
}
// Token now has been verified.
// Claims holds all the authorization information.
// Here we need to first decode it then unmarshal it from JSON
parts := strings.Split(token.Raw, ".")
claimBytes, err := jwt.DecodeSegment(parts[1])
if err != nil {
return nil, fmt.Errorf("Failed to decode claims: %v", err)
}
var sdkClaims Claims
err = json.Unmarshal(claimBytes, &sdkClaims)
if err != nil {
return nil, fmt.Errorf("Unable to get sdkclaims: %v", err)
}
if err := validateUsername(j.usernameClaim, &sdkClaims); err != nil {
return nil, err
}
return &sdkClaims, nil
}
|
go
|
func (j *JwtAuthenticator) AuthenticateToken(ctx context.Context, rawtoken string) (*Claims, error) {
// Parse token
token, err := jwt.Parse(rawtoken, func(token *jwt.Token) (interface{}, error) {
// Verify Method
if strings.HasPrefix(token.Method.Alg(), "RS") {
// RS256, RS384, or RS512
return j.rsaKey, nil
} else if strings.HasPrefix(token.Method.Alg(), "ES") {
// ES256, ES384, or ES512
return j.ecdsKey, nil
} else if strings.HasPrefix(token.Method.Alg(), "HS") {
// HS256, HS384, or HS512
return j.sharedSecretKey, nil
}
return nil, fmt.Errorf("Unknown token algorithm: %s", token.Method.Alg())
})
if err != nil {
return nil, err
}
if !token.Valid {
return nil, fmt.Errorf("Token failed validation")
}
// Get claims
claims, ok := token.Claims.(jwt.MapClaims)
if claims == nil || !ok {
return nil, fmt.Errorf("No claims found in token")
}
// Check for required claims
for _, requiredClaim := range requiredClaims {
if _, ok := claims[requiredClaim]; !ok {
// Claim missing
return nil, fmt.Errorf("Required claim %v missing from token", requiredClaim)
}
}
// Token now has been verified.
// Claims holds all the authorization information.
// Here we need to first decode it then unmarshal it from JSON
parts := strings.Split(token.Raw, ".")
claimBytes, err := jwt.DecodeSegment(parts[1])
if err != nil {
return nil, fmt.Errorf("Failed to decode claims: %v", err)
}
var sdkClaims Claims
err = json.Unmarshal(claimBytes, &sdkClaims)
if err != nil {
return nil, fmt.Errorf("Unable to get sdkclaims: %v", err)
}
if err := validateUsername(j.usernameClaim, &sdkClaims); err != nil {
return nil, err
}
return &sdkClaims, nil
}
|
[
"func",
"(",
"j",
"*",
"JwtAuthenticator",
")",
"AuthenticateToken",
"(",
"ctx",
"context",
".",
"Context",
",",
"rawtoken",
"string",
")",
"(",
"*",
"Claims",
",",
"error",
")",
"{",
"// Parse token",
"token",
",",
"err",
":=",
"jwt",
".",
"Parse",
"(",
"rawtoken",
",",
"func",
"(",
"token",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"// Verify Method",
"if",
"strings",
".",
"HasPrefix",
"(",
"token",
".",
"Method",
".",
"Alg",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"// RS256, RS384, or RS512",
"return",
"j",
".",
"rsaKey",
",",
"nil",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasPrefix",
"(",
"token",
".",
"Method",
".",
"Alg",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"// ES256, ES384, or ES512",
"return",
"j",
".",
"ecdsKey",
",",
"nil",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasPrefix",
"(",
"token",
".",
"Method",
".",
"Alg",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"// HS256, HS384, or HS512",
"return",
"j",
".",
"sharedSecretKey",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"token",
".",
"Method",
".",
"Alg",
"(",
")",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"token",
".",
"Valid",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get claims",
"claims",
",",
"ok",
":=",
"token",
".",
"Claims",
".",
"(",
"jwt",
".",
"MapClaims",
")",
"\n",
"if",
"claims",
"==",
"nil",
"||",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check for required claims",
"for",
"_",
",",
"requiredClaim",
":=",
"range",
"requiredClaims",
"{",
"if",
"_",
",",
"ok",
":=",
"claims",
"[",
"requiredClaim",
"]",
";",
"!",
"ok",
"{",
"// Claim missing",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"requiredClaim",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Token now has been verified.",
"// Claims holds all the authorization information.",
"// Here we need to first decode it then unmarshal it from JSON",
"parts",
":=",
"strings",
".",
"Split",
"(",
"token",
".",
"Raw",
",",
"\"",
"\"",
")",
"\n",
"claimBytes",
",",
"err",
":=",
"jwt",
".",
"DecodeSegment",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"sdkClaims",
"Claims",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"claimBytes",
",",
"&",
"sdkClaims",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"validateUsername",
"(",
"j",
".",
"usernameClaim",
",",
"&",
"sdkClaims",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"sdkClaims",
",",
"nil",
"\n",
"}"
] |
// AuthenticateToken determines if a token is valid and if it is, returns
// the information in the claims.
|
[
"AuthenticateToken",
"determines",
"if",
"a",
"token",
"is",
"valid",
"and",
"if",
"it",
"is",
"returns",
"the",
"information",
"in",
"the",
"claims",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/selfsigned.go#L91-L150
|
144,092 |
libopenstorage/openstorage
|
volume/drivers/coprhd/coprhd.go
|
getAuthSession
|
func (d *driver) getAuthSession() (session *napping.Session, err error) {
e := ApiError{}
s := napping.Session{
Userinfo: d.creds,
Client: d.httpClient,
}
url := d.url + loginUri
resp, err := s.Get(url, nil, nil, &e)
if err != nil {
return
}
token := resp.HttpResponse().Header.Get("X-SDS-AUTH-TOKEN")
h := http.Header{}
h.Set("X-SDS-AUTH-TOKEN", token)
session = &napping.Session{
Client: d.httpClient,
Header: &h,
}
return
}
|
go
|
func (d *driver) getAuthSession() (session *napping.Session, err error) {
e := ApiError{}
s := napping.Session{
Userinfo: d.creds,
Client: d.httpClient,
}
url := d.url + loginUri
resp, err := s.Get(url, nil, nil, &e)
if err != nil {
return
}
token := resp.HttpResponse().Header.Get("X-SDS-AUTH-TOKEN")
h := http.Header{}
h.Set("X-SDS-AUTH-TOKEN", token)
session = &napping.Session{
Client: d.httpClient,
Header: &h,
}
return
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"getAuthSession",
"(",
")",
"(",
"session",
"*",
"napping",
".",
"Session",
",",
"err",
"error",
")",
"{",
"e",
":=",
"ApiError",
"{",
"}",
"\n\n",
"s",
":=",
"napping",
".",
"Session",
"{",
"Userinfo",
":",
"d",
".",
"creds",
",",
"Client",
":",
"d",
".",
"httpClient",
",",
"}",
"\n\n",
"url",
":=",
"d",
".",
"url",
"+",
"loginUri",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"url",
",",
"nil",
",",
"nil",
",",
"&",
"e",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"token",
":=",
"resp",
".",
"HttpResponse",
"(",
")",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n\n",
"h",
":=",
"http",
".",
"Header",
"{",
"}",
"\n\n",
"h",
".",
"Set",
"(",
"\"",
"\"",
",",
"token",
")",
"\n\n",
"session",
"=",
"&",
"napping",
".",
"Session",
"{",
"Client",
":",
"d",
".",
"httpClient",
",",
"Header",
":",
"&",
"h",
",",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// getAuthSession returns an authenticated API Session
|
[
"getAuthSession",
"returns",
"an",
"authenticated",
"API",
"Session"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/coprhd/coprhd.go#L253-L281
|
144,093 |
libopenstorage/openstorage
|
pkg/grpcserver/grpcutil.go
|
Connect
|
func Connect(address string, dialOptions []grpc.DialOption) (*grpc.ClientConn, error) {
u, err := url.Parse(address)
if err == nil && (!u.IsAbs() || u.Scheme == "unix") {
dialOptions = append(dialOptions,
grpc.WithDialer(
func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("unix", u.Path, timeout)
}))
}
dialOptions = append(dialOptions, grpc.WithBackoffMaxDelay(time.Second))
conn, err := grpc.Dial(address, dialOptions...)
if err != nil {
return nil, err
}
// We wait for 1 minute until conn.GetState() is READY.
// The interval for this check is 1 second.
if err := util.WaitFor(1*time.Minute, 10*time.Millisecond, func() (bool, error) {
if conn.GetState() == connectivity.Ready {
return false, nil
}
return true, nil
}); err != nil {
return nil, fmt.Errorf("Connection timed out")
}
return conn, nil
}
|
go
|
func Connect(address string, dialOptions []grpc.DialOption) (*grpc.ClientConn, error) {
u, err := url.Parse(address)
if err == nil && (!u.IsAbs() || u.Scheme == "unix") {
dialOptions = append(dialOptions,
grpc.WithDialer(
func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("unix", u.Path, timeout)
}))
}
dialOptions = append(dialOptions, grpc.WithBackoffMaxDelay(time.Second))
conn, err := grpc.Dial(address, dialOptions...)
if err != nil {
return nil, err
}
// We wait for 1 minute until conn.GetState() is READY.
// The interval for this check is 1 second.
if err := util.WaitFor(1*time.Minute, 10*time.Millisecond, func() (bool, error) {
if conn.GetState() == connectivity.Ready {
return false, nil
}
return true, nil
}); err != nil {
return nil, fmt.Errorf("Connection timed out")
}
return conn, nil
}
|
[
"func",
"Connect",
"(",
"address",
"string",
",",
"dialOptions",
"[",
"]",
"grpc",
".",
"DialOption",
")",
"(",
"*",
"grpc",
".",
"ClientConn",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"address",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"(",
"!",
"u",
".",
"IsAbs",
"(",
")",
"||",
"u",
".",
"Scheme",
"==",
"\"",
"\"",
")",
"{",
"dialOptions",
"=",
"append",
"(",
"dialOptions",
",",
"grpc",
".",
"WithDialer",
"(",
"func",
"(",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"net",
".",
"DialTimeout",
"(",
"\"",
"\"",
",",
"u",
".",
"Path",
",",
"timeout",
")",
"\n",
"}",
")",
")",
"\n",
"}",
"\n\n",
"dialOptions",
"=",
"append",
"(",
"dialOptions",
",",
"grpc",
".",
"WithBackoffMaxDelay",
"(",
"time",
".",
"Second",
")",
")",
"\n",
"conn",
",",
"err",
":=",
"grpc",
".",
"Dial",
"(",
"address",
",",
"dialOptions",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// We wait for 1 minute until conn.GetState() is READY.",
"// The interval for this check is 1 second.",
"if",
"err",
":=",
"util",
".",
"WaitFor",
"(",
"1",
"*",
"time",
".",
"Minute",
",",
"10",
"*",
"time",
".",
"Millisecond",
",",
"func",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"conn",
".",
"GetState",
"(",
")",
"==",
"connectivity",
".",
"Ready",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] |
// Connect address by grpc
|
[
"Connect",
"address",
"by",
"grpc"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/grpcserver/grpcutil.go#L33-L61
|
144,094 |
libopenstorage/openstorage
|
csi/v0.3/node.go
|
NodeGetId
|
func (s *OsdCsiServer) NodeGetId(
ctx context.Context,
req *csi.NodeGetIdRequest,
) (*csi.NodeGetIdResponse, error) {
clus, err := s.cluster.Enumerate()
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to Enumerate cluster: %s", err)
}
result := &csi.NodeGetIdResponse{
NodeId: clus.NodeId,
}
logrus.Infof("NodeId is %s", result.NodeId)
return result, nil
}
|
go
|
func (s *OsdCsiServer) NodeGetId(
ctx context.Context,
req *csi.NodeGetIdRequest,
) (*csi.NodeGetIdResponse, error) {
clus, err := s.cluster.Enumerate()
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to Enumerate cluster: %s", err)
}
result := &csi.NodeGetIdResponse{
NodeId: clus.NodeId,
}
logrus.Infof("NodeId is %s", result.NodeId)
return result, nil
}
|
[
"func",
"(",
"s",
"*",
"OsdCsiServer",
")",
"NodeGetId",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"csi",
".",
"NodeGetIdRequest",
",",
")",
"(",
"*",
"csi",
".",
"NodeGetIdResponse",
",",
"error",
")",
"{",
"clus",
",",
"err",
":=",
"s",
".",
"cluster",
".",
"Enumerate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"result",
":=",
"&",
"csi",
".",
"NodeGetIdResponse",
"{",
"NodeId",
":",
"clus",
".",
"NodeId",
",",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"result",
".",
"NodeId",
")",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// NodeGetId is a CSI API which gets the PX NodeId for the local node
|
[
"NodeGetId",
"is",
"a",
"CSI",
"API",
"which",
"gets",
"the",
"PX",
"NodeId",
"for",
"the",
"local",
"node"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/v0.3/node.go#L52-L68
|
144,095 |
libopenstorage/openstorage
|
csi/v0.3/node.go
|
NodeUnpublishVolume
|
func (s *OsdCsiServer) NodeUnpublishVolume(
ctx context.Context,
req *csi.NodeUnpublishVolumeRequest,
) (*csi.NodeUnpublishVolumeResponse, error) {
logrus.Debugf("NodeUnPublishVolume req[%#v]", req)
// Check arguments
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Volume id must be provided")
}
if len(req.GetTargetPath()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Target path must be provided")
}
// Get volume information
_, err := util.VolumeFromName(s.driver, req.GetVolumeId())
if err != nil {
return nil, status.Errorf(codes.NotFound, "Volume id %s not found: %s",
req.GetVolumeId(),
err.Error())
}
// Get information about the target since the request does not
// tell us if it is for block or mount point.
// https://github.com/container-storage-interface/spec/issues/285
fileInfo, err := os.Lstat(req.GetTargetPath())
if err != nil && os.IsNotExist(err) {
// For idempotency, return that there is nothing to unmount
logrus.Infof("NodeUnpublishVolume on target path %s but it does "+
"not exist, returning there is nothing to do", req.GetTargetPath())
return &csi.NodeUnpublishVolumeResponse{}, nil
} else if err != nil {
return nil, status.Errorf(
codes.Internal,
"Unknown error while verifying target location %s: %s",
req.GetTargetPath(),
err.Error())
}
// Check if it is block or not
if fileInfo.Mode()&os.ModeSymlink != 0 {
// If block, we just need to remove the link.
os.Remove(req.GetTargetPath())
} else {
if !fileInfo.IsDir() {
return nil, status.Errorf(
codes.NotFound,
"Target location %s is not a directory", req.GetTargetPath())
}
// Mount volume onto the path
if err = s.driver.Unmount(req.GetVolumeId(), req.GetTargetPath(), nil); err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to unmount volume %s onto %s: %s",
req.GetVolumeId(),
req.GetTargetPath(),
err.Error())
}
}
if s.driver.Type() == api.DriverType_DRIVER_TYPE_BLOCK {
if err = s.driver.Detach(req.GetVolumeId(), nil); err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to detach volume: %s",
err.Error())
}
}
logrus.Infof("Volume %s unmounted", req.GetVolumeId())
return &csi.NodeUnpublishVolumeResponse{}, nil
}
|
go
|
func (s *OsdCsiServer) NodeUnpublishVolume(
ctx context.Context,
req *csi.NodeUnpublishVolumeRequest,
) (*csi.NodeUnpublishVolumeResponse, error) {
logrus.Debugf("NodeUnPublishVolume req[%#v]", req)
// Check arguments
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Volume id must be provided")
}
if len(req.GetTargetPath()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Target path must be provided")
}
// Get volume information
_, err := util.VolumeFromName(s.driver, req.GetVolumeId())
if err != nil {
return nil, status.Errorf(codes.NotFound, "Volume id %s not found: %s",
req.GetVolumeId(),
err.Error())
}
// Get information about the target since the request does not
// tell us if it is for block or mount point.
// https://github.com/container-storage-interface/spec/issues/285
fileInfo, err := os.Lstat(req.GetTargetPath())
if err != nil && os.IsNotExist(err) {
// For idempotency, return that there is nothing to unmount
logrus.Infof("NodeUnpublishVolume on target path %s but it does "+
"not exist, returning there is nothing to do", req.GetTargetPath())
return &csi.NodeUnpublishVolumeResponse{}, nil
} else if err != nil {
return nil, status.Errorf(
codes.Internal,
"Unknown error while verifying target location %s: %s",
req.GetTargetPath(),
err.Error())
}
// Check if it is block or not
if fileInfo.Mode()&os.ModeSymlink != 0 {
// If block, we just need to remove the link.
os.Remove(req.GetTargetPath())
} else {
if !fileInfo.IsDir() {
return nil, status.Errorf(
codes.NotFound,
"Target location %s is not a directory", req.GetTargetPath())
}
// Mount volume onto the path
if err = s.driver.Unmount(req.GetVolumeId(), req.GetTargetPath(), nil); err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to unmount volume %s onto %s: %s",
req.GetVolumeId(),
req.GetTargetPath(),
err.Error())
}
}
if s.driver.Type() == api.DriverType_DRIVER_TYPE_BLOCK {
if err = s.driver.Detach(req.GetVolumeId(), nil); err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to detach volume: %s",
err.Error())
}
}
logrus.Infof("Volume %s unmounted", req.GetVolumeId())
return &csi.NodeUnpublishVolumeResponse{}, nil
}
|
[
"func",
"(",
"s",
"*",
"OsdCsiServer",
")",
"NodeUnpublishVolume",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"csi",
".",
"NodeUnpublishVolumeRequest",
",",
")",
"(",
"*",
"csi",
".",
"NodeUnpublishVolumeResponse",
",",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"req",
")",
"\n\n",
"// Check arguments",
"if",
"len",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get volume information",
"_",
",",
"err",
":=",
"util",
".",
"VolumeFromName",
"(",
"s",
".",
"driver",
",",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Get information about the target since the request does not",
"// tell us if it is for block or mount point.",
"// https://github.com/container-storage-interface/spec/issues/285",
"fileInfo",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"// For idempotency, return that there is nothing to unmount",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"\n",
"return",
"&",
"csi",
".",
"NodeUnpublishVolumeResponse",
"{",
"}",
",",
"nil",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetTargetPath",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Check if it is block or not",
"if",
"fileInfo",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeSymlink",
"!=",
"0",
"{",
"// If block, we just need to remove the link.",
"os",
".",
"Remove",
"(",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"if",
"!",
"fileInfo",
".",
"IsDir",
"(",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Mount volume onto the path",
"if",
"err",
"=",
"s",
".",
"driver",
".",
"Unmount",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"req",
".",
"GetTargetPath",
"(",
")",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"req",
".",
"GetTargetPath",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"driver",
".",
"Type",
"(",
")",
"==",
"api",
".",
"DriverType_DRIVER_TYPE_BLOCK",
"{",
"if",
"err",
"=",
"s",
".",
"driver",
".",
"Detach",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n\n",
"return",
"&",
"csi",
".",
"NodeUnpublishVolumeResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// NodeUnpublishVolume is a CSI API call which unmounts the volume.
|
[
"NodeUnpublishVolume",
"is",
"a",
"CSI",
"API",
"call",
"which",
"unmounts",
"the",
"volume",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/v0.3/node.go#L184-L258
|
144,096 |
libopenstorage/openstorage
|
csi/v0.3/node.go
|
NodeGetCapabilities
|
func (s *OsdCsiServer) NodeGetCapabilities(
ctx context.Context,
req *csi.NodeGetCapabilitiesRequest,
) (*csi.NodeGetCapabilitiesResponse, error) {
logrus.Debugf("NodeGetCapabilities req[%#v]", req)
return &csi.NodeGetCapabilitiesResponse{
Capabilities: []*csi.NodeServiceCapability{
{
Type: &csi.NodeServiceCapability_Rpc{
Rpc: &csi.NodeServiceCapability_RPC{
Type: csi.NodeServiceCapability_RPC_UNKNOWN,
},
},
},
},
}, nil
}
|
go
|
func (s *OsdCsiServer) NodeGetCapabilities(
ctx context.Context,
req *csi.NodeGetCapabilitiesRequest,
) (*csi.NodeGetCapabilitiesResponse, error) {
logrus.Debugf("NodeGetCapabilities req[%#v]", req)
return &csi.NodeGetCapabilitiesResponse{
Capabilities: []*csi.NodeServiceCapability{
{
Type: &csi.NodeServiceCapability_Rpc{
Rpc: &csi.NodeServiceCapability_RPC{
Type: csi.NodeServiceCapability_RPC_UNKNOWN,
},
},
},
},
}, nil
}
|
[
"func",
"(",
"s",
"*",
"OsdCsiServer",
")",
"NodeGetCapabilities",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"csi",
".",
"NodeGetCapabilitiesRequest",
",",
")",
"(",
"*",
"csi",
".",
"NodeGetCapabilitiesResponse",
",",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"req",
")",
"\n\n",
"return",
"&",
"csi",
".",
"NodeGetCapabilitiesResponse",
"{",
"Capabilities",
":",
"[",
"]",
"*",
"csi",
".",
"NodeServiceCapability",
"{",
"{",
"Type",
":",
"&",
"csi",
".",
"NodeServiceCapability_Rpc",
"{",
"Rpc",
":",
"&",
"csi",
".",
"NodeServiceCapability_RPC",
"{",
"Type",
":",
"csi",
".",
"NodeServiceCapability_RPC_UNKNOWN",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NodeGetCapabilities is a CSI API function which seems to be setup for
// future patches
|
[
"NodeGetCapabilities",
"is",
"a",
"CSI",
"API",
"function",
"which",
"seems",
"to",
"be",
"setup",
"for",
"future",
"patches"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/v0.3/node.go#L262-L280
|
144,097 |
libopenstorage/openstorage
|
api/server/server.go
|
StartGraphAPI
|
func StartGraphAPI(name string, restBase string) error {
graphPlugin := newGraphPlugin(name)
if _, _, err := startServer(name, restBase, 0, graphPlugin); err != nil {
return err
}
return nil
}
|
go
|
func StartGraphAPI(name string, restBase string) error {
graphPlugin := newGraphPlugin(name)
if _, _, err := startServer(name, restBase, 0, graphPlugin); err != nil {
return err
}
return nil
}
|
[
"func",
"StartGraphAPI",
"(",
"name",
"string",
",",
"restBase",
"string",
")",
"error",
"{",
"graphPlugin",
":=",
"newGraphPlugin",
"(",
"name",
")",
"\n",
"if",
"_",
",",
"_",
",",
"err",
":=",
"startServer",
"(",
"name",
",",
"restBase",
",",
"0",
",",
"graphPlugin",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// StartGraphAPI starts a REST server to receive GraphDriver commands from
// the Linux container engine.
|
[
"StartGraphAPI",
"starts",
"a",
"REST",
"server",
"to",
"receive",
"GraphDriver",
"commands",
"from",
"the",
"Linux",
"container",
"engine",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/server.go#L54-L61
|
144,098 |
libopenstorage/openstorage
|
api/server/server.go
|
StartVolumeMgmtAPI
|
func StartVolumeMgmtAPI(
name, sdkUds string,
mgmtBase string,
mgmtPort uint16,
auth bool,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
) (*http.Server, *http.Server, error) {
var (
unixServer, portServer *http.Server
err error
)
volMgmtApi := newVolumeAPI(name, sdkUds)
if auth {
unixServer, portServer, err = startServerWithAuth(
name,
mgmtBase,
mgmtPort,
volMgmtApi,
authProviderType,
authProvider,
)
} else {
unixServer, portServer, err = startServer(
name,
mgmtBase,
mgmtPort,
volMgmtApi,
)
}
return unixServer, portServer, err
}
|
go
|
func StartVolumeMgmtAPI(
name, sdkUds string,
mgmtBase string,
mgmtPort uint16,
auth bool,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
) (*http.Server, *http.Server, error) {
var (
unixServer, portServer *http.Server
err error
)
volMgmtApi := newVolumeAPI(name, sdkUds)
if auth {
unixServer, portServer, err = startServerWithAuth(
name,
mgmtBase,
mgmtPort,
volMgmtApi,
authProviderType,
authProvider,
)
} else {
unixServer, portServer, err = startServer(
name,
mgmtBase,
mgmtPort,
volMgmtApi,
)
}
return unixServer, portServer, err
}
|
[
"func",
"StartVolumeMgmtAPI",
"(",
"name",
",",
"sdkUds",
"string",
",",
"mgmtBase",
"string",
",",
"mgmtPort",
"uint16",
",",
"auth",
"bool",
",",
"authProviderType",
"secrets",
".",
"AuthTokenProviders",
",",
"authProvider",
"osecrets",
".",
"Secrets",
",",
")",
"(",
"*",
"http",
".",
"Server",
",",
"*",
"http",
".",
"Server",
",",
"error",
")",
"{",
"var",
"(",
"unixServer",
",",
"portServer",
"*",
"http",
".",
"Server",
"\n",
"err",
"error",
"\n",
")",
"\n",
"volMgmtApi",
":=",
"newVolumeAPI",
"(",
"name",
",",
"sdkUds",
")",
"\n\n",
"if",
"auth",
"{",
"unixServer",
",",
"portServer",
",",
"err",
"=",
"startServerWithAuth",
"(",
"name",
",",
"mgmtBase",
",",
"mgmtPort",
",",
"volMgmtApi",
",",
"authProviderType",
",",
"authProvider",
",",
")",
"\n",
"}",
"else",
"{",
"unixServer",
",",
"portServer",
",",
"err",
"=",
"startServer",
"(",
"name",
",",
"mgmtBase",
",",
"mgmtPort",
",",
"volMgmtApi",
",",
")",
"\n\n",
"}",
"\n",
"return",
"unixServer",
",",
"portServer",
",",
"err",
"\n",
"}"
] |
// StartVolumeMgmtAPI starts a REST server to receive volume management API commands
|
[
"StartVolumeMgmtAPI",
"starts",
"a",
"REST",
"server",
"to",
"receive",
"volume",
"management",
"API",
"commands"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/server.go#L64-L97
|
144,099 |
libopenstorage/openstorage
|
api/server/server.go
|
StartVolumePluginAPI
|
func StartVolumePluginAPI(
name, sdkUds string,
pluginBase string,
pluginPort uint16,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
) error {
var secretsStore secrets.Auth
var err error
// Only initialize secrets store if we have a valid auth provider.
if authProvider != nil && authProviderType != secrets.TypeNone {
secretsStore, err = secrets.NewAuth(authProviderType, authProvider)
if err != nil {
return err
}
}
volPluginApi := newVolumePlugin(name, sdkUds, secretsStore)
if _, _, err := startServer(
name,
pluginBase,
pluginPort,
volPluginApi,
); err != nil {
return err
}
return nil
}
|
go
|
func StartVolumePluginAPI(
name, sdkUds string,
pluginBase string,
pluginPort uint16,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
) error {
var secretsStore secrets.Auth
var err error
// Only initialize secrets store if we have a valid auth provider.
if authProvider != nil && authProviderType != secrets.TypeNone {
secretsStore, err = secrets.NewAuth(authProviderType, authProvider)
if err != nil {
return err
}
}
volPluginApi := newVolumePlugin(name, sdkUds, secretsStore)
if _, _, err := startServer(
name,
pluginBase,
pluginPort,
volPluginApi,
); err != nil {
return err
}
return nil
}
|
[
"func",
"StartVolumePluginAPI",
"(",
"name",
",",
"sdkUds",
"string",
",",
"pluginBase",
"string",
",",
"pluginPort",
"uint16",
",",
"authProviderType",
"secrets",
".",
"AuthTokenProviders",
",",
"authProvider",
"osecrets",
".",
"Secrets",
",",
")",
"error",
"{",
"var",
"secretsStore",
"secrets",
".",
"Auth",
"\n",
"var",
"err",
"error",
"\n\n",
"// Only initialize secrets store if we have a valid auth provider.",
"if",
"authProvider",
"!=",
"nil",
"&&",
"authProviderType",
"!=",
"secrets",
".",
"TypeNone",
"{",
"secretsStore",
",",
"err",
"=",
"secrets",
".",
"NewAuth",
"(",
"authProviderType",
",",
"authProvider",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"volPluginApi",
":=",
"newVolumePlugin",
"(",
"name",
",",
"sdkUds",
",",
"secretsStore",
")",
"\n",
"if",
"_",
",",
"_",
",",
"err",
":=",
"startServer",
"(",
"name",
",",
"pluginBase",
",",
"pluginPort",
",",
"volPluginApi",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// StartVolumePluginAPI starts a REST server to receive volume API commands
// from the linux container engine
|
[
"StartVolumePluginAPI",
"starts",
"a",
"REST",
"server",
"to",
"receive",
"volume",
"API",
"commands",
"from",
"the",
"linux",
"container",
"engine"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/server.go#L101-L129
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.