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,100 |
libopenstorage/openstorage
|
pkg/role/sdkserviceapi.go
|
NewSdkRoleManager
|
func NewSdkRoleManager(kv kvdb.Kvdb) (*SdkRoleManager, error) {
s := &SdkRoleManager{
kv: kv,
}
// Load all default roles
for k, v := range defaultRoles {
role := &api.SdkRole{
Name: k,
Rules: v,
}
if _, err := kv.Put(prefixWithName(k), role, 0); err != nil {
return nil, err
}
}
return s, nil
}
|
go
|
func NewSdkRoleManager(kv kvdb.Kvdb) (*SdkRoleManager, error) {
s := &SdkRoleManager{
kv: kv,
}
// Load all default roles
for k, v := range defaultRoles {
role := &api.SdkRole{
Name: k,
Rules: v,
}
if _, err := kv.Put(prefixWithName(k), role, 0); err != nil {
return nil, err
}
}
return s, nil
}
|
[
"func",
"NewSdkRoleManager",
"(",
"kv",
"kvdb",
".",
"Kvdb",
")",
"(",
"*",
"SdkRoleManager",
",",
"error",
")",
"{",
"s",
":=",
"&",
"SdkRoleManager",
"{",
"kv",
":",
"kv",
",",
"}",
"\n\n",
"// Load all default roles",
"for",
"k",
",",
"v",
":=",
"range",
"defaultRoles",
"{",
"role",
":=",
"&",
"api",
".",
"SdkRole",
"{",
"Name",
":",
"k",
",",
"Rules",
":",
"v",
",",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"kv",
".",
"Put",
"(",
"prefixWithName",
"(",
"k",
")",
",",
"role",
",",
"0",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] |
// NewSdkRoleManager returns a new SDK role manager
|
[
"NewSdkRoleManager",
"returns",
"a",
"new",
"SDK",
"role",
"manager"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/role/sdkserviceapi.go#L152-L169
|
144,101 |
libopenstorage/openstorage
|
pkg/role/sdkserviceapi.go
|
Create
|
func (r *SdkRoleManager) Create(
ctx context.Context,
req *api.SdkRoleCreateRequest,
) (*api.SdkRoleCreateResponse, error) {
if req.GetRole() == nil {
return nil, status.Error(codes.InvalidArgument, "Must supply a role")
} else if len(req.GetRole().GetName()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply a name for the role")
} else if err := r.validateRole(req.GetRole()); err != nil {
return nil, err
}
// Determine if there is collision with default roles
if _, ok := defaultRoles[req.GetRole().GetName()]; ok {
return nil, status.Errorf(
codes.InvalidArgument,
"Name %s already used by system role", req.GetRole().GetName())
}
// Save value in kvdb
_, err := r.kv.Create(prefixWithName(req.GetRole().GetName()), req.GetRole(), 0)
if err == kvdb.ErrExist {
// Idempotency check.
// Check that the new rules are the same.
oldrole, err := r.Inspect(ctx, &api.SdkRoleInspectRequest{
Name: req.GetRole().GetName(),
})
if err != nil {
return nil, err
}
if !reflect.DeepEqual(oldrole.GetRole(), req.GetRole()) {
return nil, status.Error(
codes.AlreadyExists,
"Existing role differs from requested role")
}
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to save role: %v", err)
}
return &api.SdkRoleCreateResponse{
Role: req.GetRole(),
}, nil
}
|
go
|
func (r *SdkRoleManager) Create(
ctx context.Context,
req *api.SdkRoleCreateRequest,
) (*api.SdkRoleCreateResponse, error) {
if req.GetRole() == nil {
return nil, status.Error(codes.InvalidArgument, "Must supply a role")
} else if len(req.GetRole().GetName()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply a name for the role")
} else if err := r.validateRole(req.GetRole()); err != nil {
return nil, err
}
// Determine if there is collision with default roles
if _, ok := defaultRoles[req.GetRole().GetName()]; ok {
return nil, status.Errorf(
codes.InvalidArgument,
"Name %s already used by system role", req.GetRole().GetName())
}
// Save value in kvdb
_, err := r.kv.Create(prefixWithName(req.GetRole().GetName()), req.GetRole(), 0)
if err == kvdb.ErrExist {
// Idempotency check.
// Check that the new rules are the same.
oldrole, err := r.Inspect(ctx, &api.SdkRoleInspectRequest{
Name: req.GetRole().GetName(),
})
if err != nil {
return nil, err
}
if !reflect.DeepEqual(oldrole.GetRole(), req.GetRole()) {
return nil, status.Error(
codes.AlreadyExists,
"Existing role differs from requested role")
}
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to save role: %v", err)
}
return &api.SdkRoleCreateResponse{
Role: req.GetRole(),
}, nil
}
|
[
"func",
"(",
"r",
"*",
"SdkRoleManager",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkRoleCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkRoleCreateResponse",
",",
"error",
")",
"{",
"if",
"req",
".",
"GetRole",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"err",
":=",
"r",
".",
"validateRole",
"(",
"req",
".",
"GetRole",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Determine if there is collision with default roles",
"if",
"_",
",",
"ok",
":=",
"defaultRoles",
"[",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
"]",
";",
"ok",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
",",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Save value in kvdb",
"_",
",",
"err",
":=",
"r",
".",
"kv",
".",
"Create",
"(",
"prefixWithName",
"(",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
")",
",",
"req",
".",
"GetRole",
"(",
")",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"kvdb",
".",
"ErrExist",
"{",
"// Idempotency check.",
"// Check that the new rules are the same.",
"oldrole",
",",
"err",
":=",
"r",
".",
"Inspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkRoleInspectRequest",
"{",
"Name",
":",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"reflect",
".",
"DeepEqual",
"(",
"oldrole",
".",
"GetRole",
"(",
")",
",",
"req",
".",
"GetRole",
"(",
")",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"AlreadyExists",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkRoleCreateResponse",
"{",
"Role",
":",
"req",
".",
"GetRole",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Create saves a role in Kvdb
|
[
"Create",
"saves",
"a",
"role",
"in",
"Kvdb"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/role/sdkserviceapi.go#L172-L214
|
144,102 |
libopenstorage/openstorage
|
pkg/role/sdkserviceapi.go
|
Enumerate
|
func (r *SdkRoleManager) Enumerate(
ctx context.Context,
req *api.SdkRoleEnumerateRequest,
) (*api.SdkRoleEnumerateResponse, error) {
keys, err := r.kv.Keys(rolePrefix, "/")
if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to access roles from database: %v", err)
}
names := make([]string, len(keys))
for i, key := range keys {
names[i] = strings.TrimPrefix(key, rolePrefix+"/")
}
return &api.SdkRoleEnumerateResponse{
Names: names,
}, nil
}
|
go
|
func (r *SdkRoleManager) Enumerate(
ctx context.Context,
req *api.SdkRoleEnumerateRequest,
) (*api.SdkRoleEnumerateResponse, error) {
keys, err := r.kv.Keys(rolePrefix, "/")
if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to access roles from database: %v", err)
}
names := make([]string, len(keys))
for i, key := range keys {
names[i] = strings.TrimPrefix(key, rolePrefix+"/")
}
return &api.SdkRoleEnumerateResponse{
Names: names,
}, nil
}
|
[
"func",
"(",
"r",
"*",
"SdkRoleManager",
")",
"Enumerate",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkRoleEnumerateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkRoleEnumerateResponse",
",",
"error",
")",
"{",
"keys",
",",
"err",
":=",
"r",
".",
"kv",
".",
"Keys",
"(",
"rolePrefix",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"names",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"keys",
")",
")",
"\n",
"for",
"i",
",",
"key",
":=",
"range",
"keys",
"{",
"names",
"[",
"i",
"]",
"=",
"strings",
".",
"TrimPrefix",
"(",
"key",
",",
"rolePrefix",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkRoleEnumerateResponse",
"{",
"Names",
":",
"names",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Enumerate returns a list of role names
|
[
"Enumerate",
"returns",
"a",
"list",
"of",
"role",
"names"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/role/sdkserviceapi.go#L217-L234
|
144,103 |
libopenstorage/openstorage
|
pkg/role/sdkserviceapi.go
|
Inspect
|
func (r *SdkRoleManager) Inspect(
ctx context.Context,
req *api.SdkRoleInspectRequest,
) (*api.SdkRoleInspectResponse, error) {
if len(req.GetName()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply a name for role")
}
elem := &api.SdkRole{}
_, err := r.kv.GetVal(prefixWithName(req.GetName()), elem)
if err == kvdb.ErrNotFound {
return nil, status.Errorf(codes.NotFound, "Role %s not found", req.GetName())
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get role %s information: %v", req.GetName(), err)
}
return &api.SdkRoleInspectResponse{
Role: elem,
}, nil
}
|
go
|
func (r *SdkRoleManager) Inspect(
ctx context.Context,
req *api.SdkRoleInspectRequest,
) (*api.SdkRoleInspectResponse, error) {
if len(req.GetName()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply a name for role")
}
elem := &api.SdkRole{}
_, err := r.kv.GetVal(prefixWithName(req.GetName()), elem)
if err == kvdb.ErrNotFound {
return nil, status.Errorf(codes.NotFound, "Role %s not found", req.GetName())
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get role %s information: %v", req.GetName(), err)
}
return &api.SdkRoleInspectResponse{
Role: elem,
}, nil
}
|
[
"func",
"(",
"r",
"*",
"SdkRoleManager",
")",
"Inspect",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkRoleInspectRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkRoleInspectResponse",
",",
"error",
")",
"{",
"if",
"len",
"(",
"req",
".",
"GetName",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"elem",
":=",
"&",
"api",
".",
"SdkRole",
"{",
"}",
"\n",
"_",
",",
"err",
":=",
"r",
".",
"kv",
".",
"GetVal",
"(",
"prefixWithName",
"(",
"req",
".",
"GetName",
"(",
")",
")",
",",
"elem",
")",
"\n",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkRoleInspectResponse",
"{",
"Role",
":",
"elem",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Inspect returns a role object
|
[
"Inspect",
"returns",
"a",
"role",
"object"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/role/sdkserviceapi.go#L237-L256
|
144,104 |
libopenstorage/openstorage
|
pkg/role/sdkserviceapi.go
|
Delete
|
func (r *SdkRoleManager) Delete(
ctx context.Context,
req *api.SdkRoleDeleteRequest,
) (*api.SdkRoleDeleteResponse, error) {
if len(req.GetName()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply a name for role")
}
// Determine if there is collision with default roles
if _, ok := defaultRoles[req.GetName()]; ok {
return nil, status.Errorf(
codes.InvalidArgument,
"Cannot delete system role %s", req.GetName())
}
_, err := r.kv.Delete(prefixWithName(req.GetName()))
if err != kvdb.ErrNotFound && err != nil {
return nil, status.Errorf(codes.Internal, "Failed to delete role %s: %v", req.GetName(), err)
}
return &api.SdkRoleDeleteResponse{}, nil
}
|
go
|
func (r *SdkRoleManager) Delete(
ctx context.Context,
req *api.SdkRoleDeleteRequest,
) (*api.SdkRoleDeleteResponse, error) {
if len(req.GetName()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply a name for role")
}
// Determine if there is collision with default roles
if _, ok := defaultRoles[req.GetName()]; ok {
return nil, status.Errorf(
codes.InvalidArgument,
"Cannot delete system role %s", req.GetName())
}
_, err := r.kv.Delete(prefixWithName(req.GetName()))
if err != kvdb.ErrNotFound && err != nil {
return nil, status.Errorf(codes.Internal, "Failed to delete role %s: %v", req.GetName(), err)
}
return &api.SdkRoleDeleteResponse{}, nil
}
|
[
"func",
"(",
"r",
"*",
"SdkRoleManager",
")",
"Delete",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkRoleDeleteRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkRoleDeleteResponse",
",",
"error",
")",
"{",
"if",
"len",
"(",
"req",
".",
"GetName",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Determine if there is collision with default roles",
"if",
"_",
",",
"ok",
":=",
"defaultRoles",
"[",
"req",
".",
"GetName",
"(",
")",
"]",
";",
"ok",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"r",
".",
"kv",
".",
"Delete",
"(",
"prefixWithName",
"(",
"req",
".",
"GetName",
"(",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"kvdb",
".",
"ErrNotFound",
"&&",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkRoleDeleteResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// Delete removes a role from Kvdb
|
[
"Delete",
"removes",
"a",
"role",
"from",
"Kvdb"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/role/sdkserviceapi.go#L259-L280
|
144,105 |
libopenstorage/openstorage
|
pkg/role/sdkserviceapi.go
|
Update
|
func (r *SdkRoleManager) Update(
ctx context.Context,
req *api.SdkRoleUpdateRequest,
) (*api.SdkRoleUpdateResponse, error) {
if req.GetRole() == nil {
return nil, status.Error(codes.InvalidArgument, "Must supply a role")
}
if err := r.validateRole(req.GetRole()); err != nil {
return nil, err
}
// Determine if there is collision with default roles
if _, ok := defaultRoles[req.GetRole().GetName()]; ok {
return nil, status.Errorf(
codes.InvalidArgument,
"System role %s cannot be updated", req.GetRole().GetName())
}
_, err := r.kv.Update(prefixWithName(req.GetRole().GetName()), req.GetRole(), 0)
if err == kvdb.ErrNotFound {
return nil, status.Errorf(codes.NotFound, "Role %s not found", req.GetRole())
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get role %s information: %v", req.GetRole().GetName(), err)
}
return &api.SdkRoleUpdateResponse{
Role: req.GetRole(),
}, nil
}
|
go
|
func (r *SdkRoleManager) Update(
ctx context.Context,
req *api.SdkRoleUpdateRequest,
) (*api.SdkRoleUpdateResponse, error) {
if req.GetRole() == nil {
return nil, status.Error(codes.InvalidArgument, "Must supply a role")
}
if err := r.validateRole(req.GetRole()); err != nil {
return nil, err
}
// Determine if there is collision with default roles
if _, ok := defaultRoles[req.GetRole().GetName()]; ok {
return nil, status.Errorf(
codes.InvalidArgument,
"System role %s cannot be updated", req.GetRole().GetName())
}
_, err := r.kv.Update(prefixWithName(req.GetRole().GetName()), req.GetRole(), 0)
if err == kvdb.ErrNotFound {
return nil, status.Errorf(codes.NotFound, "Role %s not found", req.GetRole())
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get role %s information: %v", req.GetRole().GetName(), err)
}
return &api.SdkRoleUpdateResponse{
Role: req.GetRole(),
}, nil
}
|
[
"func",
"(",
"r",
"*",
"SdkRoleManager",
")",
"Update",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkRoleUpdateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkRoleUpdateResponse",
",",
"error",
")",
"{",
"if",
"req",
".",
"GetRole",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"r",
".",
"validateRole",
"(",
"req",
".",
"GetRole",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Determine if there is collision with default roles",
"if",
"_",
",",
"ok",
":=",
"defaultRoles",
"[",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
"]",
";",
"ok",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
",",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"r",
".",
"kv",
".",
"Update",
"(",
"prefixWithName",
"(",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
")",
",",
"req",
".",
"GetRole",
"(",
")",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetRole",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetRole",
"(",
")",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkRoleUpdateResponse",
"{",
"Role",
":",
"req",
".",
"GetRole",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Update replaces an existing role.
|
[
"Update",
"replaces",
"an",
"existing",
"role",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/role/sdkserviceapi.go#L283-L311
|
144,106 |
libopenstorage/openstorage
|
pkg/role/sdkserviceapi.go
|
Verify
|
func (r *SdkRoleManager) Verify(ctx context.Context, roles []string, fullmethod string) error {
// Check all roles
for _, role := range roles {
// Get the role rules
resp, err := r.Inspect(ctx, &api.SdkRoleInspectRequest{
Name: role,
})
if err != nil || resp == nil || resp.GetRole() == nil {
continue
}
if err := r.verifyRules(resp.GetRole().GetRules(), fullmethod); err == nil {
return nil
}
}
return status.Errorf(codes.PermissionDenied, "Access denied to roles: %+s", roles)
}
|
go
|
func (r *SdkRoleManager) Verify(ctx context.Context, roles []string, fullmethod string) error {
// Check all roles
for _, role := range roles {
// Get the role rules
resp, err := r.Inspect(ctx, &api.SdkRoleInspectRequest{
Name: role,
})
if err != nil || resp == nil || resp.GetRole() == nil {
continue
}
if err := r.verifyRules(resp.GetRole().GetRules(), fullmethod); err == nil {
return nil
}
}
return status.Errorf(codes.PermissionDenied, "Access denied to roles: %+s", roles)
}
|
[
"func",
"(",
"r",
"*",
"SdkRoleManager",
")",
"Verify",
"(",
"ctx",
"context",
".",
"Context",
",",
"roles",
"[",
"]",
"string",
",",
"fullmethod",
"string",
")",
"error",
"{",
"// Check all roles",
"for",
"_",
",",
"role",
":=",
"range",
"roles",
"{",
"// Get the role rules",
"resp",
",",
"err",
":=",
"r",
".",
"Inspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkRoleInspectRequest",
"{",
"Name",
":",
"role",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"resp",
"==",
"nil",
"||",
"resp",
".",
"GetRole",
"(",
")",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"r",
".",
"verifyRules",
"(",
"resp",
".",
"GetRole",
"(",
")",
".",
"GetRules",
"(",
")",
",",
"fullmethod",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
",",
"roles",
")",
"\n",
"}"
] |
// Verify determines if the role has access to `fullmethod`
|
[
"Verify",
"determines",
"if",
"the",
"role",
"has",
"access",
"to",
"fullmethod"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/role/sdkserviceapi.go#L314-L332
|
144,107 |
libopenstorage/openstorage
|
pkg/role/sdkserviceapi.go
|
verifyRules
|
func (r *SdkRoleManager) verifyRules(rules []*api.SdkRule, fullmethod string) error {
var reqService, reqApi string
// String: "/openstorage.api.OpenStorage<service>/<method>"
parts := strings.Split(fullmethod, "/")
if len(parts) > 1 {
reqService = strings.TrimPrefix(strings.ToLower(parts[1]), "openstorage.api.openstorage")
}
if len(parts) > 2 {
reqApi = strings.ToLower(parts[2])
}
// Go through each rule until a match is found
for _, rule := range rules {
for _, service := range rule.Services {
if matchRule(service, reqService) {
for _, api := range rule.Apis {
if matchRule(api, reqApi) {
return nil
}
}
}
}
}
return fmt.Errorf("no accessable rule to authorize access found")
}
|
go
|
func (r *SdkRoleManager) verifyRules(rules []*api.SdkRule, fullmethod string) error {
var reqService, reqApi string
// String: "/openstorage.api.OpenStorage<service>/<method>"
parts := strings.Split(fullmethod, "/")
if len(parts) > 1 {
reqService = strings.TrimPrefix(strings.ToLower(parts[1]), "openstorage.api.openstorage")
}
if len(parts) > 2 {
reqApi = strings.ToLower(parts[2])
}
// Go through each rule until a match is found
for _, rule := range rules {
for _, service := range rule.Services {
if matchRule(service, reqService) {
for _, api := range rule.Apis {
if matchRule(api, reqApi) {
return nil
}
}
}
}
}
return fmt.Errorf("no accessable rule to authorize access found")
}
|
[
"func",
"(",
"r",
"*",
"SdkRoleManager",
")",
"verifyRules",
"(",
"rules",
"[",
"]",
"*",
"api",
".",
"SdkRule",
",",
"fullmethod",
"string",
")",
"error",
"{",
"var",
"reqService",
",",
"reqApi",
"string",
"\n\n",
"// String: \"/openstorage.api.OpenStorage<service>/<method>\"",
"parts",
":=",
"strings",
".",
"Split",
"(",
"fullmethod",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"len",
"(",
"parts",
")",
">",
"1",
"{",
"reqService",
"=",
"strings",
".",
"TrimPrefix",
"(",
"strings",
".",
"ToLower",
"(",
"parts",
"[",
"1",
"]",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"parts",
")",
">",
"2",
"{",
"reqApi",
"=",
"strings",
".",
"ToLower",
"(",
"parts",
"[",
"2",
"]",
")",
"\n",
"}",
"\n\n",
"// Go through each rule until a match is found",
"for",
"_",
",",
"rule",
":=",
"range",
"rules",
"{",
"for",
"_",
",",
"service",
":=",
"range",
"rule",
".",
"Services",
"{",
"if",
"matchRule",
"(",
"service",
",",
"reqService",
")",
"{",
"for",
"_",
",",
"api",
":=",
"range",
"rule",
".",
"Apis",
"{",
"if",
"matchRule",
"(",
"api",
",",
"reqApi",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// verifyRules checks if the rules authorize use of the API called `fullmethod`
|
[
"verifyRules",
"checks",
"if",
"the",
"rules",
"authorize",
"use",
"of",
"the",
"API",
"called",
"fullmethod"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/role/sdkserviceapi.go#L335-L363
|
144,108 |
libopenstorage/openstorage
|
pkg/seed/seed.go
|
New
|
func New(uri string, options map[string]string) (Source, error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
switch u.Scheme {
case "github":
return NewGitSource(uri, options)
}
return nil, ErrUnsupported
}
|
go
|
func New(uri string, options map[string]string) (Source, error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
switch u.Scheme {
case "github":
return NewGitSource(uri, options)
}
return nil, ErrUnsupported
}
|
[
"func",
"New",
"(",
"uri",
"string",
",",
"options",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"Source",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"switch",
"u",
".",
"Scheme",
"{",
"case",
"\"",
"\"",
":",
"return",
"NewGitSource",
"(",
"uri",
",",
"options",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"ErrUnsupported",
"\n",
"}"
] |
// New returns a new instance of Source
|
[
"New",
"returns",
"a",
"new",
"instance",
"of",
"Source"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/seed/seed.go#L26-L36
|
144,109 |
libopenstorage/openstorage
|
api/server/sdk/objectstore.go
|
Inspect
|
func (s *ObjectstoreServer) Inspect(
ctx context.Context,
req *api.SdkObjectstoreInspectRequest,
) (*api.SdkObjectstoreInspectResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
objResp, err := s.cluster().ObjectStoreInspect(req.GetObjectstoreId())
if err != nil {
if err == kvdb.ErrNotFound {
return nil, status.Errorf(
codes.NotFound,
"Id %s not found",
req.GetObjectstoreId())
}
return nil, status.Errorf(
codes.Internal,
"Failed to inspect objectstore: %v",
err.Error())
}
return &api.SdkObjectstoreInspectResponse{ObjectstoreStatus: objResp}, nil
}
|
go
|
func (s *ObjectstoreServer) Inspect(
ctx context.Context,
req *api.SdkObjectstoreInspectRequest,
) (*api.SdkObjectstoreInspectResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
objResp, err := s.cluster().ObjectStoreInspect(req.GetObjectstoreId())
if err != nil {
if err == kvdb.ErrNotFound {
return nil, status.Errorf(
codes.NotFound,
"Id %s not found",
req.GetObjectstoreId())
}
return nil, status.Errorf(
codes.Internal,
"Failed to inspect objectstore: %v",
err.Error())
}
return &api.SdkObjectstoreInspectResponse{ObjectstoreStatus: objResp}, nil
}
|
[
"func",
"(",
"s",
"*",
"ObjectstoreServer",
")",
"Inspect",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkObjectstoreInspectRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkObjectstoreInspectResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"objResp",
",",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"ObjectStoreInspect",
"(",
"req",
".",
"GetObjectstoreId",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetObjectstoreId",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkObjectstoreInspectResponse",
"{",
"ObjectstoreStatus",
":",
"objResp",
"}",
",",
"nil",
"\n",
"}"
] |
// Inspect Objectstore return status of provided objectstore
|
[
"Inspect",
"Objectstore",
"return",
"status",
"of",
"provided",
"objectstore"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/objectstore.go#L40-L63
|
144,110 |
libopenstorage/openstorage
|
api/server/sdk/objectstore.go
|
Create
|
func (s *ObjectstoreServer) Create(
ctx context.Context,
req *api.SdkObjectstoreCreateRequest,
) (*api.SdkObjectstoreCreateResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must provide volume ID")
}
objResp, err := s.cluster().ObjectStoreCreate(req.GetVolumeId())
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to create objectstore: %v",
err.Error())
}
return &api.SdkObjectstoreCreateResponse{ObjectstoreStatus: objResp}, nil
}
|
go
|
func (s *ObjectstoreServer) Create(
ctx context.Context,
req *api.SdkObjectstoreCreateRequest,
) (*api.SdkObjectstoreCreateResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must provide volume ID")
}
objResp, err := s.cluster().ObjectStoreCreate(req.GetVolumeId())
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Failed to create objectstore: %v",
err.Error())
}
return &api.SdkObjectstoreCreateResponse{ObjectstoreStatus: objResp}, nil
}
|
[
"func",
"(",
"s",
"*",
"ObjectstoreServer",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkObjectstoreCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkObjectstoreCreateResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"objResp",
",",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"ObjectStoreCreate",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkObjectstoreCreateResponse",
"{",
"ObjectstoreStatus",
":",
"objResp",
"}",
",",
"nil",
"\n",
"}"
] |
// CreateObjectstore creates objectstore for given volume
|
[
"CreateObjectstore",
"creates",
"objectstore",
"for",
"given",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/objectstore.go#L66-L86
|
144,111 |
libopenstorage/openstorage
|
api/server/sdk/objectstore.go
|
Update
|
func (s *ObjectstoreServer) Update(
ctx context.Context,
req *api.SdkObjectstoreUpdateRequest,
) (*api.SdkObjectstoreUpdateResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
err := s.cluster().ObjectStoreUpdate(req.GetObjectstoreId(), req.GetEnable())
if err != nil {
if err == kvdb.ErrNotFound {
return nil, status.Errorf(
codes.NotFound,
"Id %s not found",
req.GetObjectstoreId())
}
return nil, status.Errorf(
codes.Internal,
"Failed to update objectstore: %v",
err.Error())
}
return &api.SdkObjectstoreUpdateResponse{}, nil
}
|
go
|
func (s *ObjectstoreServer) Update(
ctx context.Context,
req *api.SdkObjectstoreUpdateRequest,
) (*api.SdkObjectstoreUpdateResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
err := s.cluster().ObjectStoreUpdate(req.GetObjectstoreId(), req.GetEnable())
if err != nil {
if err == kvdb.ErrNotFound {
return nil, status.Errorf(
codes.NotFound,
"Id %s not found",
req.GetObjectstoreId())
}
return nil, status.Errorf(
codes.Internal,
"Failed to update objectstore: %v",
err.Error())
}
return &api.SdkObjectstoreUpdateResponse{}, nil
}
|
[
"func",
"(",
"s",
"*",
"ObjectstoreServer",
")",
"Update",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkObjectstoreUpdateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkObjectstoreUpdateResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"ObjectStoreUpdate",
"(",
"req",
".",
"GetObjectstoreId",
"(",
")",
",",
"req",
".",
"GetEnable",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetObjectstoreId",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkObjectstoreUpdateResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// UpdateObjectstore updates given objectstore state
|
[
"UpdateObjectstore",
"updates",
"given",
"objectstore",
"state"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/objectstore.go#L89-L112
|
144,112 |
libopenstorage/openstorage
|
api/server/sdk/objectstore.go
|
Delete
|
func (s *ObjectstoreServer) Delete(
ctx context.Context,
req *api.SdkObjectstoreDeleteRequest,
) (*api.SdkObjectstoreDeleteResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
err := s.cluster().ObjectStoreDelete(req.GetObjectstoreId())
if err != nil && err != kvdb.ErrNotFound {
return nil, status.Errorf(
codes.Internal,
"Failed to delete objectstore: %v",
err.Error())
}
return &api.SdkObjectstoreDeleteResponse{}, nil
}
|
go
|
func (s *ObjectstoreServer) Delete(
ctx context.Context,
req *api.SdkObjectstoreDeleteRequest,
) (*api.SdkObjectstoreDeleteResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
err := s.cluster().ObjectStoreDelete(req.GetObjectstoreId())
if err != nil && err != kvdb.ErrNotFound {
return nil, status.Errorf(
codes.Internal,
"Failed to delete objectstore: %v",
err.Error())
}
return &api.SdkObjectstoreDeleteResponse{}, nil
}
|
[
"func",
"(",
"s",
"*",
"ObjectstoreServer",
")",
"Delete",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkObjectstoreDeleteRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkObjectstoreDeleteResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"ObjectStoreDelete",
"(",
"req",
".",
"GetObjectstoreId",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"kvdb",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkObjectstoreDeleteResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// DeleteObjectstore delete objectstore from cluster
|
[
"DeleteObjectstore",
"delete",
"objectstore",
"from",
"cluster"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/objectstore.go#L115-L132
|
144,113 |
libopenstorage/openstorage
|
csi/csi.go
|
NewOsdCsiServer
|
func NewOsdCsiServer(config *OsdCsiServerConfig) (grpcserver.Server, error) {
if nil == config {
return nil, fmt.Errorf("Must supply configuration")
}
if len(config.SdkUds) == 0 {
return nil, fmt.Errorf("SdkUds must be provided")
}
if len(config.DriverName) == 0 {
return nil, fmt.Errorf("OSD Driver name must be provided")
}
// Save the driver for future calls
d, err := volumedrivers.Get(config.DriverName)
if err != nil {
return nil, fmt.Errorf("Unable to get driver %s info: %s", config.DriverName, err.Error())
}
// Create server
gServer, err := grpcserver.New(&grpcserver.GrpcServerConfig{
Name: "CSI 1.1",
Net: config.Net,
Address: config.Address,
})
if err != nil {
return nil, fmt.Errorf("Failed to create CSI server: %v", err)
}
return &OsdCsiServer{
specHandler: spec.NewSpecHandler(),
GrpcServer: gServer,
driver: d,
cluster: config.Cluster,
sdkUds: config.SdkUds,
}, nil
}
|
go
|
func NewOsdCsiServer(config *OsdCsiServerConfig) (grpcserver.Server, error) {
if nil == config {
return nil, fmt.Errorf("Must supply configuration")
}
if len(config.SdkUds) == 0 {
return nil, fmt.Errorf("SdkUds must be provided")
}
if len(config.DriverName) == 0 {
return nil, fmt.Errorf("OSD Driver name must be provided")
}
// Save the driver for future calls
d, err := volumedrivers.Get(config.DriverName)
if err != nil {
return nil, fmt.Errorf("Unable to get driver %s info: %s", config.DriverName, err.Error())
}
// Create server
gServer, err := grpcserver.New(&grpcserver.GrpcServerConfig{
Name: "CSI 1.1",
Net: config.Net,
Address: config.Address,
})
if err != nil {
return nil, fmt.Errorf("Failed to create CSI server: %v", err)
}
return &OsdCsiServer{
specHandler: spec.NewSpecHandler(),
GrpcServer: gServer,
driver: d,
cluster: config.Cluster,
sdkUds: config.SdkUds,
}, nil
}
|
[
"func",
"NewOsdCsiServer",
"(",
"config",
"*",
"OsdCsiServerConfig",
")",
"(",
"grpcserver",
".",
"Server",
",",
"error",
")",
"{",
"if",
"nil",
"==",
"config",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"SdkUds",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"DriverName",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// Save the driver for future calls",
"d",
",",
"err",
":=",
"volumedrivers",
".",
"Get",
"(",
"config",
".",
"DriverName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"config",
".",
"DriverName",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Create server",
"gServer",
",",
"err",
":=",
"grpcserver",
".",
"New",
"(",
"&",
"grpcserver",
".",
"GrpcServerConfig",
"{",
"Name",
":",
"\"",
"\"",
",",
"Net",
":",
"config",
".",
"Net",
",",
"Address",
":",
"config",
".",
"Address",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"OsdCsiServer",
"{",
"specHandler",
":",
"spec",
".",
"NewSpecHandler",
"(",
")",
",",
"GrpcServer",
":",
"gServer",
",",
"driver",
":",
"d",
",",
"cluster",
":",
"config",
".",
"Cluster",
",",
"sdkUds",
":",
"config",
".",
"SdkUds",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewOsdCsiServer creates a gRPC CSI complient server on the
// specified port and transport.
|
[
"NewOsdCsiServer",
"creates",
"a",
"gRPC",
"CSI",
"complient",
"server",
"on",
"the",
"specified",
"port",
"and",
"transport",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/csi.go#L64-L97
|
144,114 |
libopenstorage/openstorage
|
csi/csi.go
|
setupContextWithToken
|
func (s *OsdCsiServer) setupContextWithToken(ctx context.Context, csiSecrets map[string]string) context.Context {
if token, ok := csiSecrets[authsecrets.SecretTokenKey]; ok {
md := metadata.New(map[string]string{
"authorization": "bearer " + token,
})
return metadata.NewOutgoingContext(ctx, md)
}
return ctx
}
|
go
|
func (s *OsdCsiServer) setupContextWithToken(ctx context.Context, csiSecrets map[string]string) context.Context {
if token, ok := csiSecrets[authsecrets.SecretTokenKey]; ok {
md := metadata.New(map[string]string{
"authorization": "bearer " + token,
})
return metadata.NewOutgoingContext(ctx, md)
}
return ctx
}
|
[
"func",
"(",
"s",
"*",
"OsdCsiServer",
")",
"setupContextWithToken",
"(",
"ctx",
"context",
".",
"Context",
",",
"csiSecrets",
"map",
"[",
"string",
"]",
"string",
")",
"context",
".",
"Context",
"{",
"if",
"token",
",",
"ok",
":=",
"csiSecrets",
"[",
"authsecrets",
".",
"SecretTokenKey",
"]",
";",
"ok",
"{",
"md",
":=",
"metadata",
".",
"New",
"(",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"+",
"token",
",",
"}",
")",
"\n",
"return",
"metadata",
".",
"NewOutgoingContext",
"(",
"ctx",
",",
"md",
")",
"\n",
"}",
"\n",
"return",
"ctx",
"\n",
"}"
] |
// Gets token from the secrets. In Kubernetes, the side car containers copy
// the contents of a K8S Secret map into the Secrets section of the CSI call.
|
[
"Gets",
"token",
"from",
"the",
"secrets",
".",
"In",
"Kubernetes",
"the",
"side",
"car",
"containers",
"copy",
"the",
"contents",
"of",
"a",
"K8S",
"Secret",
"map",
"into",
"the",
"Secrets",
"section",
"of",
"the",
"CSI",
"call",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/csi.go#L117-L125
|
144,115 |
libopenstorage/openstorage
|
pkg/storageops/storageops.go
|
NewStorageError
|
func NewStorageError(code int, msg string, instance string) error {
return &StorageError{Code: code, Msg: msg, Instance: instance}
}
|
go
|
func NewStorageError(code int, msg string, instance string) error {
return &StorageError{Code: code, Msg: msg, Instance: instance}
}
|
[
"func",
"NewStorageError",
"(",
"code",
"int",
",",
"msg",
"string",
",",
"instance",
"string",
")",
"error",
"{",
"return",
"&",
"StorageError",
"{",
"Code",
":",
"code",
",",
"Msg",
":",
"msg",
",",
"Instance",
":",
"instance",
"}",
"\n",
"}"
] |
// NewStorageError creates a new custom storage error instance
|
[
"NewStorageError",
"creates",
"a",
"new",
"custom",
"storage",
"error",
"instance"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/storageops.go#L93-L95
|
144,116 |
libopenstorage/openstorage
|
api/api.go
|
DriverTypeSimpleValueOf
|
func DriverTypeSimpleValueOf(s string) (DriverType, error) {
obj, err := simpleValueOf("driver_type", DriverType_value, s)
return DriverType(obj), err
}
|
go
|
func DriverTypeSimpleValueOf(s string) (DriverType, error) {
obj, err := simpleValueOf("driver_type", DriverType_value, s)
return DriverType(obj), err
}
|
[
"func",
"DriverTypeSimpleValueOf",
"(",
"s",
"string",
")",
"(",
"DriverType",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"simpleValueOf",
"(",
"\"",
"\"",
",",
"DriverType_value",
",",
"s",
")",
"\n",
"return",
"DriverType",
"(",
"obj",
")",
",",
"err",
"\n",
"}"
] |
//
// DriverTypeSimpleValueOf returns the string format of DriverType
|
[
"DriverTypeSimpleValueOf",
"returns",
"the",
"string",
"format",
"of",
"DriverType"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L580-L583
|
144,117 |
libopenstorage/openstorage
|
api/api.go
|
FSTypeSimpleValueOf
|
func FSTypeSimpleValueOf(s string) (FSType, error) {
obj, err := simpleValueOf("fs_type", FSType_value, s)
return FSType(obj), err
}
|
go
|
func FSTypeSimpleValueOf(s string) (FSType, error) {
obj, err := simpleValueOf("fs_type", FSType_value, s)
return FSType(obj), err
}
|
[
"func",
"FSTypeSimpleValueOf",
"(",
"s",
"string",
")",
"(",
"FSType",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"simpleValueOf",
"(",
"\"",
"\"",
",",
"FSType_value",
",",
"s",
")",
"\n",
"return",
"FSType",
"(",
"obj",
")",
",",
"err",
"\n",
"}"
] |
// FSTypeSimpleValueOf returns the string format of FSType
|
[
"FSTypeSimpleValueOf",
"returns",
"the",
"string",
"format",
"of",
"FSType"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L591-L594
|
144,118 |
libopenstorage/openstorage
|
api/api.go
|
CosTypeSimpleValueOf
|
func CosTypeSimpleValueOf(s string) (CosType, error) {
obj, exists := CosType_value[strings.ToUpper(s)]
if !exists {
return -1, fmt.Errorf("Invalid cos value: %s", s)
}
return CosType(obj), nil
}
|
go
|
func CosTypeSimpleValueOf(s string) (CosType, error) {
obj, exists := CosType_value[strings.ToUpper(s)]
if !exists {
return -1, fmt.Errorf("Invalid cos value: %s", s)
}
return CosType(obj), nil
}
|
[
"func",
"CosTypeSimpleValueOf",
"(",
"s",
"string",
")",
"(",
"CosType",
",",
"error",
")",
"{",
"obj",
",",
"exists",
":=",
"CosType_value",
"[",
"strings",
".",
"ToUpper",
"(",
"s",
")",
"]",
"\n",
"if",
"!",
"exists",
"{",
"return",
"-",
"1",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
")",
"\n",
"}",
"\n",
"return",
"CosType",
"(",
"obj",
")",
",",
"nil",
"\n",
"}"
] |
// CosTypeSimpleValueOf returns the string format of CosType
|
[
"CosTypeSimpleValueOf",
"returns",
"the",
"string",
"format",
"of",
"CosType"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L602-L608
|
144,119 |
libopenstorage/openstorage
|
api/api.go
|
GraphDriverChangeTypeSimpleValueOf
|
func GraphDriverChangeTypeSimpleValueOf(s string) (GraphDriverChangeType, error) {
obj, err := simpleValueOf("graph_driver_change_type", GraphDriverChangeType_value, s)
return GraphDriverChangeType(obj), err
}
|
go
|
func GraphDriverChangeTypeSimpleValueOf(s string) (GraphDriverChangeType, error) {
obj, err := simpleValueOf("graph_driver_change_type", GraphDriverChangeType_value, s)
return GraphDriverChangeType(obj), err
}
|
[
"func",
"GraphDriverChangeTypeSimpleValueOf",
"(",
"s",
"string",
")",
"(",
"GraphDriverChangeType",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"simpleValueOf",
"(",
"\"",
"\"",
",",
"GraphDriverChangeType_value",
",",
"s",
")",
"\n",
"return",
"GraphDriverChangeType",
"(",
"obj",
")",
",",
"err",
"\n",
"}"
] |
// GraphDriverChangeTypeSimpleValueOf returns the string format of GraphDriverChangeType
|
[
"GraphDriverChangeTypeSimpleValueOf",
"returns",
"the",
"string",
"format",
"of",
"GraphDriverChangeType"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L616-L619
|
144,120 |
libopenstorage/openstorage
|
api/api.go
|
VolumeActionParamSimpleValueOf
|
func VolumeActionParamSimpleValueOf(s string) (VolumeActionParam, error) {
obj, err := simpleValueOf("volume_action_param", VolumeActionParam_value, s)
return VolumeActionParam(obj), err
}
|
go
|
func VolumeActionParamSimpleValueOf(s string) (VolumeActionParam, error) {
obj, err := simpleValueOf("volume_action_param", VolumeActionParam_value, s)
return VolumeActionParam(obj), err
}
|
[
"func",
"VolumeActionParamSimpleValueOf",
"(",
"s",
"string",
")",
"(",
"VolumeActionParam",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"simpleValueOf",
"(",
"\"",
"\"",
",",
"VolumeActionParam_value",
",",
"s",
")",
"\n",
"return",
"VolumeActionParam",
"(",
"obj",
")",
",",
"err",
"\n",
"}"
] |
// VolumeActionParamSimpleValueOf returns the string format of VolumeAction
|
[
"VolumeActionParamSimpleValueOf",
"returns",
"the",
"string",
"format",
"of",
"VolumeAction"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L627-L630
|
144,121 |
libopenstorage/openstorage
|
api/api.go
|
VolumeStateSimpleValueOf
|
func VolumeStateSimpleValueOf(s string) (VolumeState, error) {
obj, err := simpleValueOf("volume_state", VolumeState_value, s)
return VolumeState(obj), err
}
|
go
|
func VolumeStateSimpleValueOf(s string) (VolumeState, error) {
obj, err := simpleValueOf("volume_state", VolumeState_value, s)
return VolumeState(obj), err
}
|
[
"func",
"VolumeStateSimpleValueOf",
"(",
"s",
"string",
")",
"(",
"VolumeState",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"simpleValueOf",
"(",
"\"",
"\"",
",",
"VolumeState_value",
",",
"s",
")",
"\n",
"return",
"VolumeState",
"(",
"obj",
")",
",",
"err",
"\n",
"}"
] |
// VolumeStateSimpleValueOf returns the string format of VolumeState
|
[
"VolumeStateSimpleValueOf",
"returns",
"the",
"string",
"format",
"of",
"VolumeState"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L638-L641
|
144,122 |
libopenstorage/openstorage
|
api/api.go
|
VolumeStatusSimpleValueOf
|
func VolumeStatusSimpleValueOf(s string) (VolumeStatus, error) {
obj, err := simpleValueOf("volume_status", VolumeStatus_value, s)
return VolumeStatus(obj), err
}
|
go
|
func VolumeStatusSimpleValueOf(s string) (VolumeStatus, error) {
obj, err := simpleValueOf("volume_status", VolumeStatus_value, s)
return VolumeStatus(obj), err
}
|
[
"func",
"VolumeStatusSimpleValueOf",
"(",
"s",
"string",
")",
"(",
"VolumeStatus",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"simpleValueOf",
"(",
"\"",
"\"",
",",
"VolumeStatus_value",
",",
"s",
")",
"\n",
"return",
"VolumeStatus",
"(",
"obj",
")",
",",
"err",
"\n",
"}"
] |
// VolumeStatusSimpleValueOf returns the string format of VolumeStatus
|
[
"VolumeStatusSimpleValueOf",
"returns",
"the",
"string",
"format",
"of",
"VolumeStatus"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L649-L652
|
144,123 |
libopenstorage/openstorage
|
api/api.go
|
IoProfileSimpleValueOf
|
func IoProfileSimpleValueOf(s string) (IoProfile, error) {
obj, err := simpleValueOf("io_profile", IoProfile_value, s)
return IoProfile(obj), err
}
|
go
|
func IoProfileSimpleValueOf(s string) (IoProfile, error) {
obj, err := simpleValueOf("io_profile", IoProfile_value, s)
return IoProfile(obj), err
}
|
[
"func",
"IoProfileSimpleValueOf",
"(",
"s",
"string",
")",
"(",
"IoProfile",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"simpleValueOf",
"(",
"\"",
"\"",
",",
"IoProfile_value",
",",
"s",
")",
"\n",
"return",
"IoProfile",
"(",
"obj",
")",
",",
"err",
"\n",
"}"
] |
// IoProfileSimpleValueOf returns the string format of IoProfile
|
[
"IoProfileSimpleValueOf",
"returns",
"the",
"string",
"format",
"of",
"IoProfile"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L660-L663
|
144,124 |
libopenstorage/openstorage
|
api/api.go
|
WriteThroughput
|
func (v *Stats) WriteThroughput() uint64 {
intv := toSec(v.IntervalMs)
if intv == 0 {
return 0
}
return (v.WriteBytes) / intv
}
|
go
|
func (v *Stats) WriteThroughput() uint64 {
intv := toSec(v.IntervalMs)
if intv == 0 {
return 0
}
return (v.WriteBytes) / intv
}
|
[
"func",
"(",
"v",
"*",
"Stats",
")",
"WriteThroughput",
"(",
")",
"uint64",
"{",
"intv",
":=",
"toSec",
"(",
"v",
".",
"IntervalMs",
")",
"\n",
"if",
"intv",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"(",
"v",
".",
"WriteBytes",
")",
"/",
"intv",
"\n",
"}"
] |
// WriteThroughput returns the write throughput
|
[
"WriteThroughput",
"returns",
"the",
"write",
"throughput"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L691-L697
|
144,125 |
libopenstorage/openstorage
|
api/api.go
|
ReadThroughput
|
func (v *Stats) ReadThroughput() uint64 {
intv := toSec(v.IntervalMs)
if intv == 0 {
return 0
}
return (v.ReadBytes) / intv
}
|
go
|
func (v *Stats) ReadThroughput() uint64 {
intv := toSec(v.IntervalMs)
if intv == 0 {
return 0
}
return (v.ReadBytes) / intv
}
|
[
"func",
"(",
"v",
"*",
"Stats",
")",
"ReadThroughput",
"(",
")",
"uint64",
"{",
"intv",
":=",
"toSec",
"(",
"v",
".",
"IntervalMs",
")",
"\n",
"if",
"intv",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"(",
"v",
".",
"ReadBytes",
")",
"/",
"intv",
"\n",
"}"
] |
// ReadThroughput returns the read throughput
|
[
"ReadThroughput",
"returns",
"the",
"read",
"throughput"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L700-L706
|
144,126 |
libopenstorage/openstorage
|
api/api.go
|
Latency
|
func (v *Stats) Latency() uint64 {
ops := v.Writes + v.Reads
if ops == 0 {
return 0
}
return (uint64)((v.IoMs * 1000) / ops)
}
|
go
|
func (v *Stats) Latency() uint64 {
ops := v.Writes + v.Reads
if ops == 0 {
return 0
}
return (uint64)((v.IoMs * 1000) / ops)
}
|
[
"func",
"(",
"v",
"*",
"Stats",
")",
"Latency",
"(",
")",
"uint64",
"{",
"ops",
":=",
"v",
".",
"Writes",
"+",
"v",
".",
"Reads",
"\n",
"if",
"ops",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"(",
"uint64",
")",
"(",
"(",
"v",
".",
"IoMs",
"*",
"1000",
")",
"/",
"ops",
")",
"\n",
"}"
] |
// Latency returns latency
|
[
"Latency",
"returns",
"latency"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L709-L715
|
144,127 |
libopenstorage/openstorage
|
api/api.go
|
ReadLatency
|
func (v *Stats) ReadLatency() uint64 {
if v.Reads == 0 {
return 0
}
return (uint64)((v.ReadMs * 1000) / v.Reads)
}
|
go
|
func (v *Stats) ReadLatency() uint64 {
if v.Reads == 0 {
return 0
}
return (uint64)((v.ReadMs * 1000) / v.Reads)
}
|
[
"func",
"(",
"v",
"*",
"Stats",
")",
"ReadLatency",
"(",
")",
"uint64",
"{",
"if",
"v",
".",
"Reads",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"(",
"uint64",
")",
"(",
"(",
"v",
".",
"ReadMs",
"*",
"1000",
")",
"/",
"v",
".",
"Reads",
")",
"\n",
"}"
] |
// Read latency returns avg. time required for read operation to complete
|
[
"Read",
"latency",
"returns",
"avg",
".",
"time",
"required",
"for",
"read",
"operation",
"to",
"complete"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L718-L723
|
144,128 |
libopenstorage/openstorage
|
api/api.go
|
WriteLatency
|
func (v *Stats) WriteLatency() uint64 {
if v.Writes == 0 {
return 0
}
return (uint64)((v.WriteMs * 1000) / v.Writes)
}
|
go
|
func (v *Stats) WriteLatency() uint64 {
if v.Writes == 0 {
return 0
}
return (uint64)((v.WriteMs * 1000) / v.Writes)
}
|
[
"func",
"(",
"v",
"*",
"Stats",
")",
"WriteLatency",
"(",
")",
"uint64",
"{",
"if",
"v",
".",
"Writes",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"(",
"uint64",
")",
"(",
"(",
"v",
".",
"WriteMs",
"*",
"1000",
")",
"/",
"v",
".",
"Writes",
")",
"\n",
"}"
] |
// Write latency returns avg. time required for write operation to complete
|
[
"Write",
"latency",
"returns",
"avg",
".",
"time",
"required",
"for",
"write",
"operation",
"to",
"complete"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L726-L731
|
144,129 |
libopenstorage/openstorage
|
api/api.go
|
Iops
|
func (v *Stats) Iops() uint64 {
intv := toSec(v.IntervalMs)
if intv == 0 {
return 0
}
return (v.Writes + v.Reads) / intv
}
|
go
|
func (v *Stats) Iops() uint64 {
intv := toSec(v.IntervalMs)
if intv == 0 {
return 0
}
return (v.Writes + v.Reads) / intv
}
|
[
"func",
"(",
"v",
"*",
"Stats",
")",
"Iops",
"(",
")",
"uint64",
"{",
"intv",
":=",
"toSec",
"(",
"v",
".",
"IntervalMs",
")",
"\n",
"if",
"intv",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"(",
"v",
".",
"Writes",
"+",
"v",
".",
"Reads",
")",
"/",
"intv",
"\n",
"}"
] |
// Iops returns iops
|
[
"Iops",
"returns",
"iops"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L734-L740
|
144,130 |
libopenstorage/openstorage
|
api/api.go
|
Contains
|
func (m *Volume) Contains(mid string) bool {
rsets := m.GetReplicaSets()
for _, rset := range rsets {
for _, node := range rset.Nodes {
if node == mid {
return true
}
}
}
return false
}
|
go
|
func (m *Volume) Contains(mid string) bool {
rsets := m.GetReplicaSets()
for _, rset := range rsets {
for _, node := range rset.Nodes {
if node == mid {
return true
}
}
}
return false
}
|
[
"func",
"(",
"m",
"*",
"Volume",
")",
"Contains",
"(",
"mid",
"string",
")",
"bool",
"{",
"rsets",
":=",
"m",
".",
"GetReplicaSets",
"(",
")",
"\n",
"for",
"_",
",",
"rset",
":=",
"range",
"rsets",
"{",
"for",
"_",
",",
"node",
":=",
"range",
"rset",
".",
"Nodes",
"{",
"if",
"node",
"==",
"mid",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// Contains returns true if mid is a member of volume's replication set.
|
[
"Contains",
"returns",
"true",
"if",
"mid",
"is",
"a",
"member",
"of",
"volume",
"s",
"replication",
"set",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L748-L758
|
144,131 |
libopenstorage/openstorage
|
api/api.go
|
Copy
|
func (s *VolumeSpec) Copy() *VolumeSpec {
spec := *s
if s.ReplicaSet != nil {
spec.ReplicaSet = &ReplicaSet{Nodes: make([]string, len(s.ReplicaSet.Nodes))}
copy(spec.ReplicaSet.Nodes, s.ReplicaSet.Nodes)
}
return &spec
}
|
go
|
func (s *VolumeSpec) Copy() *VolumeSpec {
spec := *s
if s.ReplicaSet != nil {
spec.ReplicaSet = &ReplicaSet{Nodes: make([]string, len(s.ReplicaSet.Nodes))}
copy(spec.ReplicaSet.Nodes, s.ReplicaSet.Nodes)
}
return &spec
}
|
[
"func",
"(",
"s",
"*",
"VolumeSpec",
")",
"Copy",
"(",
")",
"*",
"VolumeSpec",
"{",
"spec",
":=",
"*",
"s",
"\n",
"if",
"s",
".",
"ReplicaSet",
"!=",
"nil",
"{",
"spec",
".",
"ReplicaSet",
"=",
"&",
"ReplicaSet",
"{",
"Nodes",
":",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"s",
".",
"ReplicaSet",
".",
"Nodes",
")",
")",
"}",
"\n",
"copy",
"(",
"spec",
".",
"ReplicaSet",
".",
"Nodes",
",",
"s",
".",
"ReplicaSet",
".",
"Nodes",
")",
"\n",
"}",
"\n",
"return",
"&",
"spec",
"\n",
"}"
] |
// Copy makes a deep copy of VolumeSpec
|
[
"Copy",
"makes",
"a",
"deep",
"copy",
"of",
"VolumeSpec"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L761-L768
|
144,132 |
libopenstorage/openstorage
|
api/api.go
|
Copy
|
func (s *Node) Copy() *Node {
localCopy := deepcopy.Copy(*s)
nodeCopy := localCopy.(Node)
return &nodeCopy
}
|
go
|
func (s *Node) Copy() *Node {
localCopy := deepcopy.Copy(*s)
nodeCopy := localCopy.(Node)
return &nodeCopy
}
|
[
"func",
"(",
"s",
"*",
"Node",
")",
"Copy",
"(",
")",
"*",
"Node",
"{",
"localCopy",
":=",
"deepcopy",
".",
"Copy",
"(",
"*",
"s",
")",
"\n",
"nodeCopy",
":=",
"localCopy",
".",
"(",
"Node",
")",
"\n",
"return",
"&",
"nodeCopy",
"\n",
"}"
] |
// Copy makes a deep copy of Node
|
[
"Copy",
"makes",
"a",
"deep",
"copy",
"of",
"Node"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L771-L775
|
144,133 |
libopenstorage/openstorage
|
api/api.go
|
ToStorageNode
|
func (s *Node) ToStorageNode() *StorageNode {
node := &StorageNode{
Id: s.Id,
SchedulerNodeName: s.SchedulerNodeName,
Cpu: s.Cpu,
MemTotal: s.MemTotal,
MemUsed: s.MemUsed,
MemFree: s.MemFree,
AvgLoad: int64(s.Avgload),
Status: s.Status,
MgmtIp: s.MgmtIp,
DataIp: s.DataIp,
Hostname: s.Hostname,
}
node.Disks = make(map[string]*StorageResource)
for k, v := range s.Disks {
node.Disks[k] = &v
}
node.NodeLabels = make(map[string]string)
for k, v := range s.NodeLabels {
node.NodeLabels[k] = v
}
node.Pools = make([]*StoragePool, len(s.Pools))
for i, v := range s.Pools {
node.Pools[i] = &v
}
return node
}
|
go
|
func (s *Node) ToStorageNode() *StorageNode {
node := &StorageNode{
Id: s.Id,
SchedulerNodeName: s.SchedulerNodeName,
Cpu: s.Cpu,
MemTotal: s.MemTotal,
MemUsed: s.MemUsed,
MemFree: s.MemFree,
AvgLoad: int64(s.Avgload),
Status: s.Status,
MgmtIp: s.MgmtIp,
DataIp: s.DataIp,
Hostname: s.Hostname,
}
node.Disks = make(map[string]*StorageResource)
for k, v := range s.Disks {
node.Disks[k] = &v
}
node.NodeLabels = make(map[string]string)
for k, v := range s.NodeLabels {
node.NodeLabels[k] = v
}
node.Pools = make([]*StoragePool, len(s.Pools))
for i, v := range s.Pools {
node.Pools[i] = &v
}
return node
}
|
[
"func",
"(",
"s",
"*",
"Node",
")",
"ToStorageNode",
"(",
")",
"*",
"StorageNode",
"{",
"node",
":=",
"&",
"StorageNode",
"{",
"Id",
":",
"s",
".",
"Id",
",",
"SchedulerNodeName",
":",
"s",
".",
"SchedulerNodeName",
",",
"Cpu",
":",
"s",
".",
"Cpu",
",",
"MemTotal",
":",
"s",
".",
"MemTotal",
",",
"MemUsed",
":",
"s",
".",
"MemUsed",
",",
"MemFree",
":",
"s",
".",
"MemFree",
",",
"AvgLoad",
":",
"int64",
"(",
"s",
".",
"Avgload",
")",
",",
"Status",
":",
"s",
".",
"Status",
",",
"MgmtIp",
":",
"s",
".",
"MgmtIp",
",",
"DataIp",
":",
"s",
".",
"DataIp",
",",
"Hostname",
":",
"s",
".",
"Hostname",
",",
"}",
"\n\n",
"node",
".",
"Disks",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"StorageResource",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"s",
".",
"Disks",
"{",
"node",
".",
"Disks",
"[",
"k",
"]",
"=",
"&",
"v",
"\n",
"}",
"\n\n",
"node",
".",
"NodeLabels",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"s",
".",
"NodeLabels",
"{",
"node",
".",
"NodeLabels",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"node",
".",
"Pools",
"=",
"make",
"(",
"[",
"]",
"*",
"StoragePool",
",",
"len",
"(",
"s",
".",
"Pools",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"s",
".",
"Pools",
"{",
"node",
".",
"Pools",
"[",
"i",
"]",
"=",
"&",
"v",
"\n",
"}",
"\n\n",
"return",
"node",
"\n",
"}"
] |
// ToStorageNode converts a Node structure to an exported gRPC StorageNode struct
|
[
"ToStorageNode",
"converts",
"a",
"Node",
"structure",
"to",
"an",
"exported",
"gRPC",
"StorageNode",
"struct"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L794-L825
|
144,134 |
libopenstorage/openstorage
|
api/api.go
|
ToStorageCluster
|
func (c *Cluster) ToStorageCluster() *StorageCluster {
cluster := &StorageCluster{
Status: c.Status,
// Due to history, the cluster ID is normally the name of the cluster, not the
// unique identifier
Name: c.Id,
}
return cluster
}
|
go
|
func (c *Cluster) ToStorageCluster() *StorageCluster {
cluster := &StorageCluster{
Status: c.Status,
// Due to history, the cluster ID is normally the name of the cluster, not the
// unique identifier
Name: c.Id,
}
return cluster
}
|
[
"func",
"(",
"c",
"*",
"Cluster",
")",
"ToStorageCluster",
"(",
")",
"*",
"StorageCluster",
"{",
"cluster",
":=",
"&",
"StorageCluster",
"{",
"Status",
":",
"c",
".",
"Status",
",",
"// Due to history, the cluster ID is normally the name of the cluster, not the",
"// unique identifier",
"Name",
":",
"c",
".",
"Id",
",",
"}",
"\n\n",
"return",
"cluster",
"\n",
"}"
] |
// ToStorageCluster converts a Cluster structure to an exported gRPC StorageCluster struct
|
[
"ToStorageCluster",
"converts",
"a",
"Cluster",
"structure",
"to",
"an",
"exported",
"gRPC",
"StorageCluster",
"struct"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L828-L838
|
144,135 |
libopenstorage/openstorage
|
api/api.go
|
GetCloneCreatorOwnership
|
func (v *VolumeSpec) GetCloneCreatorOwnership(ctx context.Context) (*Ownership, bool) {
o := v.GetOwnership()
// If there is user information, then auth is enabled
if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {
// Check if the owner is the one who cloned it
if o != nil && o.IsOwner(userinfo) {
return o, false
}
// Not the same owner, we now need new ownership.
// This works for public volumes also.
return OwnershipSetUsernameFromContext(ctx, nil), true
}
return o, false
}
|
go
|
func (v *VolumeSpec) GetCloneCreatorOwnership(ctx context.Context) (*Ownership, bool) {
o := v.GetOwnership()
// If there is user information, then auth is enabled
if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {
// Check if the owner is the one who cloned it
if o != nil && o.IsOwner(userinfo) {
return o, false
}
// Not the same owner, we now need new ownership.
// This works for public volumes also.
return OwnershipSetUsernameFromContext(ctx, nil), true
}
return o, false
}
|
[
"func",
"(",
"v",
"*",
"VolumeSpec",
")",
"GetCloneCreatorOwnership",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"Ownership",
",",
"bool",
")",
"{",
"o",
":=",
"v",
".",
"GetOwnership",
"(",
")",
"\n\n",
"// If there is user information, then auth is enabled",
"if",
"userinfo",
",",
"ok",
":=",
"auth",
".",
"NewUserInfoFromContext",
"(",
"ctx",
")",
";",
"ok",
"{",
"// Check if the owner is the one who cloned it",
"if",
"o",
"!=",
"nil",
"&&",
"o",
".",
"IsOwner",
"(",
"userinfo",
")",
"{",
"return",
"o",
",",
"false",
"\n",
"}",
"\n\n",
"// Not the same owner, we now need new ownership.",
"// This works for public volumes also.",
"return",
"OwnershipSetUsernameFromContext",
"(",
"ctx",
",",
"nil",
")",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"o",
",",
"false",
"\n",
"}"
] |
// GetCloneCreatorOwnership returns the appropriate ownership for the
// new snapshot and if an update is required
|
[
"GetCloneCreatorOwnership",
"returns",
"the",
"appropriate",
"ownership",
"for",
"the",
"new",
"snapshot",
"and",
"if",
"an",
"update",
"is",
"required"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L1033-L1050
|
144,136 |
libopenstorage/openstorage
|
api/api.go
|
IsPermitted
|
func (s *SdkStoragePolicy) IsPermitted(ctx context.Context, accessType Ownership_AccessType) bool {
if s.IsPublic() {
return true
}
// Storage Policy is not public, check permission
if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {
// Check Access
return s.IsPermittedFromUserInfo(userinfo, accessType)
} else {
// There is no user information in the context so
// authorization is not running
return true
}
}
|
go
|
func (s *SdkStoragePolicy) IsPermitted(ctx context.Context, accessType Ownership_AccessType) bool {
if s.IsPublic() {
return true
}
// Storage Policy is not public, check permission
if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {
// Check Access
return s.IsPermittedFromUserInfo(userinfo, accessType)
} else {
// There is no user information in the context so
// authorization is not running
return true
}
}
|
[
"func",
"(",
"s",
"*",
"SdkStoragePolicy",
")",
"IsPermitted",
"(",
"ctx",
"context",
".",
"Context",
",",
"accessType",
"Ownership_AccessType",
")",
"bool",
"{",
"if",
"s",
".",
"IsPublic",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"// Storage Policy is not public, check permission",
"if",
"userinfo",
",",
"ok",
":=",
"auth",
".",
"NewUserInfoFromContext",
"(",
"ctx",
")",
";",
"ok",
"{",
"// Check Access",
"return",
"s",
".",
"IsPermittedFromUserInfo",
"(",
"userinfo",
",",
"accessType",
")",
"\n",
"}",
"else",
"{",
"// There is no user information in the context so",
"// authorization is not running",
"return",
"true",
"\n",
"}",
"\n",
"}"
] |
// Check access permission of SdkStoragePolicy Objects
|
[
"Check",
"access",
"permission",
"of",
"SdkStoragePolicy",
"Objects"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/api.go#L1054-L1068
|
144,137 |
libopenstorage/openstorage
|
pkg/auth/secrets/secrets.go
|
NewAuth
|
func NewAuth(
authProviderType AuthTokenProviders,
s osecrets.Secrets,
) (Auth, error) {
if s == nil {
return nil, ErrSecretsNotInitialized
}
switch authProviderType {
case TypeK8s:
return &k8sAuth{s}, nil
case TypeDCOS:
return &dcosAuth{s}, nil
}
return nil, fmt.Errorf("secrets type %v not supported", authProviderType)
}
|
go
|
func NewAuth(
authProviderType AuthTokenProviders,
s osecrets.Secrets,
) (Auth, error) {
if s == nil {
return nil, ErrSecretsNotInitialized
}
switch authProviderType {
case TypeK8s:
return &k8sAuth{s}, nil
case TypeDCOS:
return &dcosAuth{s}, nil
}
return nil, fmt.Errorf("secrets type %v not supported", authProviderType)
}
|
[
"func",
"NewAuth",
"(",
"authProviderType",
"AuthTokenProviders",
",",
"s",
"osecrets",
".",
"Secrets",
",",
")",
"(",
"Auth",
",",
"error",
")",
"{",
"if",
"s",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrSecretsNotInitialized",
"\n",
"}",
"\n",
"switch",
"authProviderType",
"{",
"case",
"TypeK8s",
":",
"return",
"&",
"k8sAuth",
"{",
"s",
"}",
",",
"nil",
"\n",
"case",
"TypeDCOS",
":",
"return",
"&",
"dcosAuth",
"{",
"s",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"authProviderType",
")",
"\n",
"}"
] |
// NewAuth returns a new instance of Auth implementation
|
[
"NewAuth",
"returns",
"a",
"new",
"instance",
"of",
"Auth",
"implementation"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/secrets/secrets.go#L55-L69
|
144,138 |
libopenstorage/openstorage
|
pkg/mount/custom_mount.go
|
NewCustomMounter
|
func NewCustomMounter(
devPrefixes []string,
mountImpl MountImpl,
customMounter CustomMounter,
allowedDirs []string,
) (*CustomMounterHandler, error) {
m := &CustomMounterHandler{
Mounter: Mounter{
mountImpl: mountImpl,
mounts: make(DeviceMap),
paths: make(PathMap),
allowedDirs: allowedDirs,
kl: keylock.New(),
},
}
cl, cr := customMounter()
m.cl = cl
m.cr = cr
err := m.Load(devPrefixes)
if err != nil {
return nil, err
}
return m, nil
}
|
go
|
func NewCustomMounter(
devPrefixes []string,
mountImpl MountImpl,
customMounter CustomMounter,
allowedDirs []string,
) (*CustomMounterHandler, error) {
m := &CustomMounterHandler{
Mounter: Mounter{
mountImpl: mountImpl,
mounts: make(DeviceMap),
paths: make(PathMap),
allowedDirs: allowedDirs,
kl: keylock.New(),
},
}
cl, cr := customMounter()
m.cl = cl
m.cr = cr
err := m.Load(devPrefixes)
if err != nil {
return nil, err
}
return m, nil
}
|
[
"func",
"NewCustomMounter",
"(",
"devPrefixes",
"[",
"]",
"string",
",",
"mountImpl",
"MountImpl",
",",
"customMounter",
"CustomMounter",
",",
"allowedDirs",
"[",
"]",
"string",
",",
")",
"(",
"*",
"CustomMounterHandler",
",",
"error",
")",
"{",
"m",
":=",
"&",
"CustomMounterHandler",
"{",
"Mounter",
":",
"Mounter",
"{",
"mountImpl",
":",
"mountImpl",
",",
"mounts",
":",
"make",
"(",
"DeviceMap",
")",
",",
"paths",
":",
"make",
"(",
"PathMap",
")",
",",
"allowedDirs",
":",
"allowedDirs",
",",
"kl",
":",
"keylock",
".",
"New",
"(",
")",
",",
"}",
",",
"}",
"\n",
"cl",
",",
"cr",
":=",
"customMounter",
"(",
")",
"\n",
"m",
".",
"cl",
"=",
"cl",
"\n",
"m",
".",
"cr",
"=",
"cr",
"\n",
"err",
":=",
"m",
".",
"Load",
"(",
"devPrefixes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// NewCustomMounter returns a new CustomMounter
|
[
"NewCustomMounter",
"returns",
"a",
"new",
"CustomMounter"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/mount/custom_mount.go#L22-L46
|
144,139 |
libopenstorage/openstorage
|
pkg/mount/custom_mount.go
|
Reload
|
func (c *CustomMounterHandler) Reload(device string) error {
return c.cr(device, c.mounts, c.paths)
}
|
go
|
func (c *CustomMounterHandler) Reload(device string) error {
return c.cr(device, c.mounts, c.paths)
}
|
[
"func",
"(",
"c",
"*",
"CustomMounterHandler",
")",
"Reload",
"(",
"device",
"string",
")",
"error",
"{",
"return",
"c",
".",
"cr",
"(",
"device",
",",
"c",
".",
"mounts",
",",
"c",
".",
"paths",
")",
"\n",
"}"
] |
// Reload mount table for a device
|
[
"Reload",
"mount",
"table",
"for",
"a",
"device"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/mount/custom_mount.go#L54-L56
|
144,140 |
libopenstorage/openstorage
|
cli/volumes.go
|
BlockVolumeCommands
|
func BlockVolumeCommands(name string) []cli.Command {
v := &volDriver{name: name}
blockCommands := []cli.Command{
{
Name: "attach",
Aliases: []string{"a"},
Usage: "Attach volume to specified path",
Action: v.volumeAttach,
Flags: []cli.Flag{
cli.StringFlag{
Name: "path,p",
Usage: "Path on local filesystem",
},
},
},
{
Name: "detach",
Aliases: []string{"d"},
Usage: "Detach specified volume",
Action: v.volumeDetach,
},
}
baseCommands := baseVolumeCommand(v)
return append(baseCommands, blockCommands...)
}
|
go
|
func BlockVolumeCommands(name string) []cli.Command {
v := &volDriver{name: name}
blockCommands := []cli.Command{
{
Name: "attach",
Aliases: []string{"a"},
Usage: "Attach volume to specified path",
Action: v.volumeAttach,
Flags: []cli.Flag{
cli.StringFlag{
Name: "path,p",
Usage: "Path on local filesystem",
},
},
},
{
Name: "detach",
Aliases: []string{"d"},
Usage: "Detach specified volume",
Action: v.volumeDetach,
},
}
baseCommands := baseVolumeCommand(v)
return append(baseCommands, blockCommands...)
}
|
[
"func",
"BlockVolumeCommands",
"(",
"name",
"string",
")",
"[",
"]",
"cli",
".",
"Command",
"{",
"v",
":=",
"&",
"volDriver",
"{",
"name",
":",
"name",
"}",
"\n\n",
"blockCommands",
":=",
"[",
"]",
"cli",
".",
"Command",
"{",
"{",
"Name",
":",
"\"",
"\"",
",",
"Aliases",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"Usage",
":",
"\"",
"\"",
",",
"Action",
":",
"v",
".",
"volumeAttach",
",",
"Flags",
":",
"[",
"]",
"cli",
".",
"Flag",
"{",
"cli",
".",
"StringFlag",
"{",
"Name",
":",
"\"",
"\"",
",",
"Usage",
":",
"\"",
"\"",
",",
"}",
",",
"}",
",",
"}",
",",
"{",
"Name",
":",
"\"",
"\"",
",",
"Aliases",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"Usage",
":",
"\"",
"\"",
",",
"Action",
":",
"v",
".",
"volumeDetach",
",",
"}",
",",
"}",
"\n\n",
"baseCommands",
":=",
"baseVolumeCommand",
"(",
"v",
")",
"\n\n",
"return",
"append",
"(",
"baseCommands",
",",
"blockCommands",
"...",
")",
"\n",
"}"
] |
// BlockVolumeCommands exports CLI comamnds for a Block VolumeDriver.
|
[
"BlockVolumeCommands",
"exports",
"CLI",
"comamnds",
"for",
"a",
"Block",
"VolumeDriver",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cli/volumes.go#L513-L540
|
144,141 |
libopenstorage/openstorage
|
cli/volumes.go
|
FileVolumeCommands
|
func FileVolumeCommands(name string) []cli.Command {
v := &volDriver{name: name}
return baseVolumeCommand(v)
}
|
go
|
func FileVolumeCommands(name string) []cli.Command {
v := &volDriver{name: name}
return baseVolumeCommand(v)
}
|
[
"func",
"FileVolumeCommands",
"(",
"name",
"string",
")",
"[",
"]",
"cli",
".",
"Command",
"{",
"v",
":=",
"&",
"volDriver",
"{",
"name",
":",
"name",
"}",
"\n\n",
"return",
"baseVolumeCommand",
"(",
"v",
")",
"\n",
"}"
] |
// FileVolumeCommands exports CLI comamnds for File VolumeDriver
|
[
"FileVolumeCommands",
"exports",
"CLI",
"comamnds",
"for",
"File",
"VolumeDriver"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cli/volumes.go#L543-L547
|
144,142 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
Lock
|
func (e *defaultStoreEnumerator) Lock(volumeID string) (interface{}, error) {
return e.kvdb.Lock(e.lockKey(volumeID))
}
|
go
|
func (e *defaultStoreEnumerator) Lock(volumeID string) (interface{}, error) {
return e.kvdb.Lock(e.lockKey(volumeID))
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"Lock",
"(",
"volumeID",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"e",
".",
"kvdb",
".",
"Lock",
"(",
"e",
".",
"lockKey",
"(",
"volumeID",
")",
")",
"\n",
"}"
] |
// Lock volume specified by volumeID.
|
[
"Lock",
"volume",
"specified",
"by",
"volumeID",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L31-L33
|
144,143 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
Unlock
|
func (e *defaultStoreEnumerator) Unlock(token interface{}) error {
v, ok := token.(*kvdb.KVPair)
if !ok {
return fmt.Errorf("Invalid token of type %T", token)
}
return e.kvdb.Unlock(v)
}
|
go
|
func (e *defaultStoreEnumerator) Unlock(token interface{}) error {
v, ok := token.(*kvdb.KVPair)
if !ok {
return fmt.Errorf("Invalid token of type %T", token)
}
return e.kvdb.Unlock(v)
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"Unlock",
"(",
"token",
"interface",
"{",
"}",
")",
"error",
"{",
"v",
",",
"ok",
":=",
"token",
".",
"(",
"*",
"kvdb",
".",
"KVPair",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"token",
")",
"\n",
"}",
"\n",
"return",
"e",
".",
"kvdb",
".",
"Unlock",
"(",
"v",
")",
"\n",
"}"
] |
// Lock volume with token obtained from call to Lock.
|
[
"Lock",
"volume",
"with",
"token",
"obtained",
"from",
"call",
"to",
"Lock",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L36-L42
|
144,144 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
CreateVol
|
func (e *defaultStoreEnumerator) CreateVol(vol *api.Volume) error {
_, err := e.kvdb.Create(e.volKey(vol.Id), vol, 0)
return err
}
|
go
|
func (e *defaultStoreEnumerator) CreateVol(vol *api.Volume) error {
_, err := e.kvdb.Create(e.volKey(vol.Id), vol, 0)
return err
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"CreateVol",
"(",
"vol",
"*",
"api",
".",
"Volume",
")",
"error",
"{",
"_",
",",
"err",
":=",
"e",
".",
"kvdb",
".",
"Create",
"(",
"e",
".",
"volKey",
"(",
"vol",
".",
"Id",
")",
",",
"vol",
",",
"0",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// CreateVol returns error if volume with the same ID already existe.
|
[
"CreateVol",
"returns",
"error",
"if",
"volume",
"with",
"the",
"same",
"ID",
"already",
"existe",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L45-L48
|
144,145 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
GetVol
|
func (e *defaultStoreEnumerator) GetVol(volumeID string) (*api.Volume, error) {
var v api.Volume
_, err := e.kvdb.GetVal(e.volKey(volumeID), &v)
return &v, err
}
|
go
|
func (e *defaultStoreEnumerator) GetVol(volumeID string) (*api.Volume, error) {
var v api.Volume
_, err := e.kvdb.GetVal(e.volKey(volumeID), &v)
return &v, err
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"GetVol",
"(",
"volumeID",
"string",
")",
"(",
"*",
"api",
".",
"Volume",
",",
"error",
")",
"{",
"var",
"v",
"api",
".",
"Volume",
"\n",
"_",
",",
"err",
":=",
"e",
".",
"kvdb",
".",
"GetVal",
"(",
"e",
".",
"volKey",
"(",
"volumeID",
")",
",",
"&",
"v",
")",
"\n",
"return",
"&",
"v",
",",
"err",
"\n",
"}"
] |
// GetVol from volumeID.
|
[
"GetVol",
"from",
"volumeID",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L51-L55
|
144,146 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
UpdateVol
|
func (e *defaultStoreEnumerator) UpdateVol(vol *api.Volume) error {
_, err := e.kvdb.Put(e.volKey(vol.Id), vol, 0)
return err
}
|
go
|
func (e *defaultStoreEnumerator) UpdateVol(vol *api.Volume) error {
_, err := e.kvdb.Put(e.volKey(vol.Id), vol, 0)
return err
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"UpdateVol",
"(",
"vol",
"*",
"api",
".",
"Volume",
")",
"error",
"{",
"_",
",",
"err",
":=",
"e",
".",
"kvdb",
".",
"Put",
"(",
"e",
".",
"volKey",
"(",
"vol",
".",
"Id",
")",
",",
"vol",
",",
"0",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// UpdateVol with vol
|
[
"UpdateVol",
"with",
"vol"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L58-L61
|
144,147 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
DeleteVol
|
func (e *defaultStoreEnumerator) DeleteVol(volumeID string) error {
_, err := e.kvdb.Delete(e.volKey(volumeID))
return err
}
|
go
|
func (e *defaultStoreEnumerator) DeleteVol(volumeID string) error {
_, err := e.kvdb.Delete(e.volKey(volumeID))
return err
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"DeleteVol",
"(",
"volumeID",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"e",
".",
"kvdb",
".",
"Delete",
"(",
"e",
".",
"volKey",
"(",
"volumeID",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// DeleteVol. Returns error if volume does not exist.
|
[
"DeleteVol",
".",
"Returns",
"error",
"if",
"volume",
"does",
"not",
"exist",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L64-L67
|
144,148 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
Inspect
|
func (e *defaultStoreEnumerator) Inspect(ids []string) ([]*api.Volume, error) {
volumes := make([]*api.Volume, 0, len(ids))
for _, id := range ids {
volume, err := e.GetVol(id)
// XXX Distinguish between ENOENT and an internal error from KVDB
if err != nil {
continue
}
volumes = append(volumes, volume)
}
return volumes, nil
}
|
go
|
func (e *defaultStoreEnumerator) Inspect(ids []string) ([]*api.Volume, error) {
volumes := make([]*api.Volume, 0, len(ids))
for _, id := range ids {
volume, err := e.GetVol(id)
// XXX Distinguish between ENOENT and an internal error from KVDB
if err != nil {
continue
}
volumes = append(volumes, volume)
}
return volumes, nil
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"Inspect",
"(",
"ids",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"error",
")",
"{",
"volumes",
":=",
"make",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"0",
",",
"len",
"(",
"ids",
")",
")",
"\n",
"for",
"_",
",",
"id",
":=",
"range",
"ids",
"{",
"volume",
",",
"err",
":=",
"e",
".",
"GetVol",
"(",
"id",
")",
"\n",
"// XXX Distinguish between ENOENT and an internal error from KVDB",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"volumes",
"=",
"append",
"(",
"volumes",
",",
"volume",
")",
"\n",
"}",
"\n",
"return",
"volumes",
",",
"nil",
"\n",
"}"
] |
// Inspect specified volumes.
// Returns slice of volumes that were found.
|
[
"Inspect",
"specified",
"volumes",
".",
"Returns",
"slice",
"of",
"volumes",
"that",
"were",
"found",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L71-L82
|
144,149 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
Enumerate
|
func (e *defaultStoreEnumerator) Enumerate(
locator *api.VolumeLocator,
labels map[string]string,
) ([]*api.Volume, error) {
kvp, err := e.kvdb.Enumerate(e.volKeyPrefix())
if err != nil {
return nil, err
}
volumes := make([]*api.Volume, 0, len(kvp))
for _, v := range kvp {
elem := &api.Volume{}
if err := json.Unmarshal(v.Value, elem); err != nil {
return nil, err
}
if match(elem, locator, labels) {
volumes = append(volumes, elem)
}
}
return volumes, nil
}
|
go
|
func (e *defaultStoreEnumerator) Enumerate(
locator *api.VolumeLocator,
labels map[string]string,
) ([]*api.Volume, error) {
kvp, err := e.kvdb.Enumerate(e.volKeyPrefix())
if err != nil {
return nil, err
}
volumes := make([]*api.Volume, 0, len(kvp))
for _, v := range kvp {
elem := &api.Volume{}
if err := json.Unmarshal(v.Value, elem); err != nil {
return nil, err
}
if match(elem, locator, labels) {
volumes = append(volumes, elem)
}
}
return volumes, nil
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"Enumerate",
"(",
"locator",
"*",
"api",
".",
"VolumeLocator",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"error",
")",
"{",
"kvp",
",",
"err",
":=",
"e",
".",
"kvdb",
".",
"Enumerate",
"(",
"e",
".",
"volKeyPrefix",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"volumes",
":=",
"make",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"0",
",",
"len",
"(",
"kvp",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"kvp",
"{",
"elem",
":=",
"&",
"api",
".",
"Volume",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"v",
".",
"Value",
",",
"elem",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"match",
"(",
"elem",
",",
"locator",
",",
"labels",
")",
"{",
"volumes",
"=",
"append",
"(",
"volumes",
",",
"elem",
")",
"\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 volumee.
|
[
"Enumerate",
"volumes",
"that",
"map",
"to",
"the",
"volumeLocator",
".",
"Locator",
"fields",
"may",
"be",
"regexp",
".",
"If",
"locator",
"fields",
"are",
"left",
"blank",
"this",
"will",
"return",
"all",
"volumee",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L86-L106
|
144,150 |
libopenstorage/openstorage
|
volume/drivers/common/default_store_enumerator.go
|
SnapEnumerate
|
func (e *defaultStoreEnumerator) SnapEnumerate(
volumeIDs []string,
labels map[string]string,
) ([]*api.Volume, error) {
kvp, err := e.kvdb.Enumerate(e.volKeyPrefix())
if err != nil {
return nil, err
}
volumes := make([]*api.Volume, 0, len(kvp))
for _, v := range kvp {
elem := &api.Volume{}
if err := json.Unmarshal(v.Value, elem); err != nil {
return nil, err
}
if elem.Source == nil ||
elem.Source.Parent == "" ||
(volumeIDs != nil && !contains(elem.Source.Parent, volumeIDs)) {
continue
}
if hasSubset(elem.Locator.VolumeLabels, labels) {
volumes = append(volumes, elem)
}
}
return volumes, nil
}
|
go
|
func (e *defaultStoreEnumerator) SnapEnumerate(
volumeIDs []string,
labels map[string]string,
) ([]*api.Volume, error) {
kvp, err := e.kvdb.Enumerate(e.volKeyPrefix())
if err != nil {
return nil, err
}
volumes := make([]*api.Volume, 0, len(kvp))
for _, v := range kvp {
elem := &api.Volume{}
if err := json.Unmarshal(v.Value, elem); err != nil {
return nil, err
}
if elem.Source == nil ||
elem.Source.Parent == "" ||
(volumeIDs != nil && !contains(elem.Source.Parent, volumeIDs)) {
continue
}
if hasSubset(elem.Locator.VolumeLabels, labels) {
volumes = append(volumes, elem)
}
}
return volumes, nil
}
|
[
"func",
"(",
"e",
"*",
"defaultStoreEnumerator",
")",
"SnapEnumerate",
"(",
"volumeIDs",
"[",
"]",
"string",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"error",
")",
"{",
"kvp",
",",
"err",
":=",
"e",
".",
"kvdb",
".",
"Enumerate",
"(",
"e",
".",
"volKeyPrefix",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"volumes",
":=",
"make",
"(",
"[",
"]",
"*",
"api",
".",
"Volume",
",",
"0",
",",
"len",
"(",
"kvp",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"kvp",
"{",
"elem",
":=",
"&",
"api",
".",
"Volume",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"v",
".",
"Value",
",",
"elem",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"elem",
".",
"Source",
"==",
"nil",
"||",
"elem",
".",
"Source",
".",
"Parent",
"==",
"\"",
"\"",
"||",
"(",
"volumeIDs",
"!=",
"nil",
"&&",
"!",
"contains",
"(",
"elem",
".",
"Source",
".",
"Parent",
",",
"volumeIDs",
")",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"hasSubset",
"(",
"elem",
".",
"Locator",
".",
"VolumeLabels",
",",
"labels",
")",
"{",
"volumes",
"=",
"append",
"(",
"volumes",
",",
"elem",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"volumes",
",",
"nil",
"\n",
"}"
] |
// SnapEnumerate for specified volume
|
[
"SnapEnumerate",
"for",
"specified",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/common/default_store_enumerator.go#L109-L133
|
144,151 |
libopenstorage/openstorage
|
api/server/middleware_auth.go
|
NewAuthMiddleware
|
func NewAuthMiddleware(
s osecrets.Secrets,
authType secrets.AuthTokenProviders,
) (*authMiddleware, error) {
provider, err := secrets.NewAuth(
authType,
s,
)
if err != nil {
return nil, err
}
return &authMiddleware{provider}, nil
}
|
go
|
func NewAuthMiddleware(
s osecrets.Secrets,
authType secrets.AuthTokenProviders,
) (*authMiddleware, error) {
provider, err := secrets.NewAuth(
authType,
s,
)
if err != nil {
return nil, err
}
return &authMiddleware{provider}, nil
}
|
[
"func",
"NewAuthMiddleware",
"(",
"s",
"osecrets",
".",
"Secrets",
",",
"authType",
"secrets",
".",
"AuthTokenProviders",
",",
")",
"(",
"*",
"authMiddleware",
",",
"error",
")",
"{",
"provider",
",",
"err",
":=",
"secrets",
".",
"NewAuth",
"(",
"authType",
",",
"s",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"authMiddleware",
"{",
"provider",
"}",
",",
"nil",
"\n",
"}"
] |
// NewAuthMiddleware returns a negroni implementation of an http middleware
// which will intercept the management APIs
|
[
"NewAuthMiddleware",
"returns",
"a",
"negroni",
"implementation",
"of",
"an",
"http",
"middleware",
"which",
"will",
"intercept",
"the",
"management",
"APIs"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/middleware_auth.go#L34-L46
|
144,152 |
libopenstorage/openstorage
|
api/ownership.go
|
OwnershipSetUsernameFromContext
|
func OwnershipSetUsernameFromContext(ctx context.Context, srcOwnership *Ownership) *Ownership {
// Check if the context has information about the user. If not,
// then security is not enabled.
if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {
// Merge the previous acls which may have been set by the user
var acls *Ownership_AccessControl
if srcOwnership != nil {
acls = srcOwnership.GetAcls()
}
return &Ownership{
Owner: userinfo.Username,
Acls: acls,
}
}
return srcOwnership
}
|
go
|
func OwnershipSetUsernameFromContext(ctx context.Context, srcOwnership *Ownership) *Ownership {
// Check if the context has information about the user. If not,
// then security is not enabled.
if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {
// Merge the previous acls which may have been set by the user
var acls *Ownership_AccessControl
if srcOwnership != nil {
acls = srcOwnership.GetAcls()
}
return &Ownership{
Owner: userinfo.Username,
Acls: acls,
}
}
return srcOwnership
}
|
[
"func",
"OwnershipSetUsernameFromContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"srcOwnership",
"*",
"Ownership",
")",
"*",
"Ownership",
"{",
"// Check if the context has information about the user. If not,",
"// then security is not enabled.",
"if",
"userinfo",
",",
"ok",
":=",
"auth",
".",
"NewUserInfoFromContext",
"(",
"ctx",
")",
";",
"ok",
"{",
"// Merge the previous acls which may have been set by the user",
"var",
"acls",
"*",
"Ownership_AccessControl",
"\n",
"if",
"srcOwnership",
"!=",
"nil",
"{",
"acls",
"=",
"srcOwnership",
".",
"GetAcls",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"Ownership",
"{",
"Owner",
":",
"userinfo",
".",
"Username",
",",
"Acls",
":",
"acls",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"srcOwnership",
"\n",
"}"
] |
// OwnershipSetUsernameFromContext is used to create a new ownership object for
// a volume. It takes an ownership value if passed in by the user, then
// sets the `owner` value to the user name referred to in the user context
|
[
"OwnershipSetUsernameFromContext",
"is",
"used",
"to",
"create",
"a",
"new",
"ownership",
"object",
"for",
"a",
"volume",
".",
"It",
"takes",
"an",
"ownership",
"value",
"if",
"passed",
"in",
"by",
"the",
"user",
"then",
"sets",
"the",
"owner",
"value",
"to",
"the",
"user",
"name",
"referred",
"to",
"in",
"the",
"user",
"context"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L36-L54
|
144,153 |
libopenstorage/openstorage
|
api/ownership.go
|
IsPermittedByContext
|
func (o *Ownership) IsPermittedByContext(
ctx context.Context,
accessType Ownership_AccessType) bool {
// If no ownership is there then it is public
if o == nil {
return true
}
// Volume is not public, check permission
if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {
// Check Access
return o.IsPermitted(userinfo, accessType)
} else {
// There is no user information in the context so
// authorization is not running
return true
}
}
|
go
|
func (o *Ownership) IsPermittedByContext(
ctx context.Context,
accessType Ownership_AccessType) bool {
// If no ownership is there then it is public
if o == nil {
return true
}
// Volume is not public, check permission
if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {
// Check Access
return o.IsPermitted(userinfo, accessType)
} else {
// There is no user information in the context so
// authorization is not running
return true
}
}
|
[
"func",
"(",
"o",
"*",
"Ownership",
")",
"IsPermittedByContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"accessType",
"Ownership_AccessType",
")",
"bool",
"{",
"// If no ownership is there then it is public",
"if",
"o",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"// Volume is not public, check permission",
"if",
"userinfo",
",",
"ok",
":=",
"auth",
".",
"NewUserInfoFromContext",
"(",
"ctx",
")",
";",
"ok",
"{",
"// Check Access",
"return",
"o",
".",
"IsPermitted",
"(",
"userinfo",
",",
"accessType",
")",
"\n",
"}",
"else",
"{",
"// There is no user information in the context so",
"// authorization is not running",
"return",
"true",
"\n",
"}",
"\n",
"}"
] |
// IsPermittedByContext returns true if the user captured in
// the context has permission to access the resource
|
[
"IsPermittedByContext",
"returns",
"true",
"if",
"the",
"user",
"captured",
"in",
"the",
"context",
"has",
"permission",
"to",
"access",
"the",
"resource"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L58-L76
|
144,154 |
libopenstorage/openstorage
|
api/ownership.go
|
IsPermitted
|
func (o *Ownership) IsPermitted(
user *auth.UserInfo,
accessType Ownership_AccessType,
) bool {
// There is no owner, so it is a public resource
if o.IsPublic() {
return true
}
// If we are missing user information then do not allow.
// It is ok for the the user claims to have an empty Groups setting
if user == nil ||
len(user.Username) == 0 {
return false
}
if o.IsOwner(user) ||
o.IsUserAllowedByGroup(user, accessType) ||
o.IsUserAllowedByCollaborators(user, accessType) {
return true
}
return false
}
|
go
|
func (o *Ownership) IsPermitted(
user *auth.UserInfo,
accessType Ownership_AccessType,
) bool {
// There is no owner, so it is a public resource
if o.IsPublic() {
return true
}
// If we are missing user information then do not allow.
// It is ok for the the user claims to have an empty Groups setting
if user == nil ||
len(user.Username) == 0 {
return false
}
if o.IsOwner(user) ||
o.IsUserAllowedByGroup(user, accessType) ||
o.IsUserAllowedByCollaborators(user, accessType) {
return true
}
return false
}
|
[
"func",
"(",
"o",
"*",
"Ownership",
")",
"IsPermitted",
"(",
"user",
"*",
"auth",
".",
"UserInfo",
",",
"accessType",
"Ownership_AccessType",
",",
")",
"bool",
"{",
"// There is no owner, so it is a public resource",
"if",
"o",
".",
"IsPublic",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"// If we are missing user information then do not allow.",
"// It is ok for the the user claims to have an empty Groups setting",
"if",
"user",
"==",
"nil",
"||",
"len",
"(",
"user",
".",
"Username",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"o",
".",
"IsOwner",
"(",
"user",
")",
"||",
"o",
".",
"IsUserAllowedByGroup",
"(",
"user",
",",
"accessType",
")",
"||",
"o",
".",
"IsUserAllowedByCollaborators",
"(",
"user",
",",
"accessType",
")",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// IsPermitted returns true if the user has access to the resource
// according to the ownership. If there is no owner, then it is public
|
[
"IsPermitted",
"returns",
"true",
"if",
"the",
"user",
"has",
"access",
"to",
"the",
"resource",
"according",
"to",
"the",
"ownership",
".",
"If",
"there",
"is",
"no",
"owner",
"then",
"it",
"is",
"public"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L80-L103
|
144,155 |
libopenstorage/openstorage
|
api/ownership.go
|
GetGroups
|
func (o *Ownership) GetGroups() map[string]Ownership_AccessType {
if o.GetAcls() == nil {
return nil
}
return o.GetAcls().GetGroups()
}
|
go
|
func (o *Ownership) GetGroups() map[string]Ownership_AccessType {
if o.GetAcls() == nil {
return nil
}
return o.GetAcls().GetGroups()
}
|
[
"func",
"(",
"o",
"*",
"Ownership",
")",
"GetGroups",
"(",
")",
"map",
"[",
"string",
"]",
"Ownership_AccessType",
"{",
"if",
"o",
".",
"GetAcls",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"o",
".",
"GetAcls",
"(",
")",
".",
"GetGroups",
"(",
")",
"\n",
"}"
] |
// GetGroups returns the groups in the ownership
|
[
"GetGroups",
"returns",
"the",
"groups",
"in",
"the",
"ownership"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L106-L111
|
144,156 |
libopenstorage/openstorage
|
api/ownership.go
|
GetCollaborators
|
func (o *Ownership) GetCollaborators() map[string]Ownership_AccessType {
if o.GetAcls() == nil {
return nil
}
return o.GetAcls().GetCollaborators()
}
|
go
|
func (o *Ownership) GetCollaborators() map[string]Ownership_AccessType {
if o.GetAcls() == nil {
return nil
}
return o.GetAcls().GetCollaborators()
}
|
[
"func",
"(",
"o",
"*",
"Ownership",
")",
"GetCollaborators",
"(",
")",
"map",
"[",
"string",
"]",
"Ownership_AccessType",
"{",
"if",
"o",
".",
"GetAcls",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"o",
".",
"GetAcls",
"(",
")",
".",
"GetCollaborators",
"(",
")",
"\n",
"}"
] |
// GetCollaborators returns the collaborators in the ownership
|
[
"GetCollaborators",
"returns",
"the",
"collaborators",
"in",
"the",
"ownership"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L114-L119
|
144,157 |
libopenstorage/openstorage
|
api/ownership.go
|
IsUserAllowedByGroup
|
func (o *Ownership) IsUserAllowedByGroup(
user *auth.UserInfo,
accessType Ownership_AccessType,
) bool {
// Allow if it is the admin user for any group
if o.IsAdminByUser(user) {
return true
}
ownergroups := o.GetGroups()
if len(ownergroups) == 0 {
return false
}
// Check each of the groups from the user
for _, group := range user.Claims.Groups {
// Check if the user group has permission
if a, ok := ownergroups[group]; ok {
return a.isAccessPermitted(accessType)
}
}
// Check if any group is allowed
if a, ok := ownergroups["*"]; ok {
return a.isAccessPermitted(accessType)
}
return false
}
|
go
|
func (o *Ownership) IsUserAllowedByGroup(
user *auth.UserInfo,
accessType Ownership_AccessType,
) bool {
// Allow if it is the admin user for any group
if o.IsAdminByUser(user) {
return true
}
ownergroups := o.GetGroups()
if len(ownergroups) == 0 {
return false
}
// Check each of the groups from the user
for _, group := range user.Claims.Groups {
// Check if the user group has permission
if a, ok := ownergroups[group]; ok {
return a.isAccessPermitted(accessType)
}
}
// Check if any group is allowed
if a, ok := ownergroups["*"]; ok {
return a.isAccessPermitted(accessType)
}
return false
}
|
[
"func",
"(",
"o",
"*",
"Ownership",
")",
"IsUserAllowedByGroup",
"(",
"user",
"*",
"auth",
".",
"UserInfo",
",",
"accessType",
"Ownership_AccessType",
",",
")",
"bool",
"{",
"// Allow if it is the admin user for any group",
"if",
"o",
".",
"IsAdminByUser",
"(",
"user",
")",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"ownergroups",
":=",
"o",
".",
"GetGroups",
"(",
")",
"\n",
"if",
"len",
"(",
"ownergroups",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// Check each of the groups from the user",
"for",
"_",
",",
"group",
":=",
"range",
"user",
".",
"Claims",
".",
"Groups",
"{",
"// Check if the user group has permission",
"if",
"a",
",",
"ok",
":=",
"ownergroups",
"[",
"group",
"]",
";",
"ok",
"{",
"return",
"a",
".",
"isAccessPermitted",
"(",
"accessType",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Check if any group is allowed",
"if",
"a",
",",
"ok",
":=",
"ownergroups",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"return",
"a",
".",
"isAccessPermitted",
"(",
"accessType",
")",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// IsUserAllowedByGroup returns true if the user is allowed access
// by belonging to the appropriate group
|
[
"IsUserAllowedByGroup",
"returns",
"true",
"if",
"the",
"user",
"is",
"allowed",
"access",
"by",
"belonging",
"to",
"the",
"appropriate",
"group"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L123-L152
|
144,158 |
libopenstorage/openstorage
|
api/ownership.go
|
IsUserAllowedByCollaborators
|
func (o *Ownership) IsUserAllowedByCollaborators(
user *auth.UserInfo,
accessType Ownership_AccessType,
) bool {
collaborators := o.GetCollaborators()
if len(collaborators) == 0 {
return false
}
// Check each of the groups from the user
if a, ok := collaborators[user.Username]; ok {
return a.isAccessPermitted(accessType)
}
// Check any user is allowed
if a, ok := collaborators["*"]; ok {
return a.isAccessPermitted(accessType)
}
return false
}
|
go
|
func (o *Ownership) IsUserAllowedByCollaborators(
user *auth.UserInfo,
accessType Ownership_AccessType,
) bool {
collaborators := o.GetCollaborators()
if len(collaborators) == 0 {
return false
}
// Check each of the groups from the user
if a, ok := collaborators[user.Username]; ok {
return a.isAccessPermitted(accessType)
}
// Check any user is allowed
if a, ok := collaborators["*"]; ok {
return a.isAccessPermitted(accessType)
}
return false
}
|
[
"func",
"(",
"o",
"*",
"Ownership",
")",
"IsUserAllowedByCollaborators",
"(",
"user",
"*",
"auth",
".",
"UserInfo",
",",
"accessType",
"Ownership_AccessType",
",",
")",
"bool",
"{",
"collaborators",
":=",
"o",
".",
"GetCollaborators",
"(",
")",
"\n",
"if",
"len",
"(",
"collaborators",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// Check each of the groups from the user",
"if",
"a",
",",
"ok",
":=",
"collaborators",
"[",
"user",
".",
"Username",
"]",
";",
"ok",
"{",
"return",
"a",
".",
"isAccessPermitted",
"(",
"accessType",
")",
"\n",
"}",
"\n\n",
"// Check any user is allowed",
"if",
"a",
",",
"ok",
":=",
"collaborators",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"return",
"a",
".",
"isAccessPermitted",
"(",
"accessType",
")",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// IsUserAllowedByCollaborators returns true if the user is allowed access
// because they are part of the collaborators list
|
[
"IsUserAllowedByCollaborators",
"returns",
"true",
"if",
"the",
"user",
"is",
"allowed",
"access",
"because",
"they",
"are",
"part",
"of",
"the",
"collaborators",
"list"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L156-L176
|
144,159 |
libopenstorage/openstorage
|
api/ownership.go
|
IsOwner
|
func (o *Ownership) IsOwner(user *auth.UserInfo) bool {
return o.Owner == user.Username
}
|
go
|
func (o *Ownership) IsOwner(user *auth.UserInfo) bool {
return o.Owner == user.Username
}
|
[
"func",
"(",
"o",
"*",
"Ownership",
")",
"IsOwner",
"(",
"user",
"*",
"auth",
".",
"UserInfo",
")",
"bool",
"{",
"return",
"o",
".",
"Owner",
"==",
"user",
".",
"Username",
"\n",
"}"
] |
// IsOwner returns if the user is the owner of the resource
|
[
"IsOwner",
"returns",
"if",
"the",
"user",
"is",
"the",
"owner",
"of",
"the",
"resource"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L189-L191
|
144,160 |
libopenstorage/openstorage
|
api/ownership.go
|
Update
|
func (o *Ownership) Update(newownerInfo *Ownership, user *auth.UserInfo) error {
if user == nil {
// There is no auth, just copy the whole thing
*o = *newownerInfo
} else {
// Auth is enabled
// Only the owner, user with access type admin,
// or admin can change the group
if user.Username != o.Owner &&
!o.IsAdminByUser(user) &&
!o.IsPermitted(user, Ownership_Admin) {
return status.Error(codes.PermissionDenied,
"Only owner or those with admin access type can update volume acls")
}
// Only the admin can change the owner
if newownerInfo.HasAnOwner() {
if o.IsAdminByUser(user) {
o.Owner = newownerInfo.Owner
} else {
return status.Error(codes.PermissionDenied,
"Only the administrator can change the owner of the resource")
}
}
o.Acls = newownerInfo.GetAcls()
}
return nil
}
|
go
|
func (o *Ownership) Update(newownerInfo *Ownership, user *auth.UserInfo) error {
if user == nil {
// There is no auth, just copy the whole thing
*o = *newownerInfo
} else {
// Auth is enabled
// Only the owner, user with access type admin,
// or admin can change the group
if user.Username != o.Owner &&
!o.IsAdminByUser(user) &&
!o.IsPermitted(user, Ownership_Admin) {
return status.Error(codes.PermissionDenied,
"Only owner or those with admin access type can update volume acls")
}
// Only the admin can change the owner
if newownerInfo.HasAnOwner() {
if o.IsAdminByUser(user) {
o.Owner = newownerInfo.Owner
} else {
return status.Error(codes.PermissionDenied,
"Only the administrator can change the owner of the resource")
}
}
o.Acls = newownerInfo.GetAcls()
}
return nil
}
|
[
"func",
"(",
"o",
"*",
"Ownership",
")",
"Update",
"(",
"newownerInfo",
"*",
"Ownership",
",",
"user",
"*",
"auth",
".",
"UserInfo",
")",
"error",
"{",
"if",
"user",
"==",
"nil",
"{",
"// There is no auth, just copy the whole thing",
"*",
"o",
"=",
"*",
"newownerInfo",
"\n",
"}",
"else",
"{",
"// Auth is enabled",
"// Only the owner, user with access type admin,",
"// or admin can change the group",
"if",
"user",
".",
"Username",
"!=",
"o",
".",
"Owner",
"&&",
"!",
"o",
".",
"IsAdminByUser",
"(",
"user",
")",
"&&",
"!",
"o",
".",
"IsPermitted",
"(",
"user",
",",
"Ownership_Admin",
")",
"{",
"return",
"status",
".",
"Error",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Only the admin can change the owner",
"if",
"newownerInfo",
".",
"HasAnOwner",
"(",
")",
"{",
"if",
"o",
".",
"IsAdminByUser",
"(",
"user",
")",
"{",
"o",
".",
"Owner",
"=",
"newownerInfo",
".",
"Owner",
"\n",
"}",
"else",
"{",
"return",
"status",
".",
"Error",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"o",
".",
"Acls",
"=",
"newownerInfo",
".",
"GetAcls",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Update can be used to update an ownership with new ownership information. It
// takes into account who is trying to change the ownership values
|
[
"Update",
"can",
"be",
"used",
"to",
"update",
"an",
"ownership",
"with",
"new",
"ownership",
"information",
".",
"It",
"takes",
"into",
"account",
"who",
"is",
"trying",
"to",
"change",
"the",
"ownership",
"values"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L201-L229
|
144,161 |
libopenstorage/openstorage
|
api/ownership.go
|
IsAdminByUser
|
func IsAdminByUser(user *auth.UserInfo) bool {
// If there is a user, then auth is enabled
if user != nil {
return listContains(user.Claims.Groups, AdminGroup)
}
// No auth enabled, so everyone is an admin
return true
}
|
go
|
func IsAdminByUser(user *auth.UserInfo) bool {
// If there is a user, then auth is enabled
if user != nil {
return listContains(user.Claims.Groups, AdminGroup)
}
// No auth enabled, so everyone is an admin
return true
}
|
[
"func",
"IsAdminByUser",
"(",
"user",
"*",
"auth",
".",
"UserInfo",
")",
"bool",
"{",
"// If there is a user, then auth is enabled",
"if",
"user",
"!=",
"nil",
"{",
"return",
"listContains",
"(",
"user",
".",
"Claims",
".",
"Groups",
",",
"AdminGroup",
")",
"\n",
"}",
"\n\n",
"// No auth enabled, so everyone is an admin",
"return",
"true",
"\n",
"}"
] |
// IsAdminByUser returns true if the user is an ownership admin, meaning,
// that they belong to any group
|
[
"IsAdminByUser",
"returns",
"true",
"if",
"the",
"user",
"is",
"an",
"ownership",
"admin",
"meaning",
"that",
"they",
"belong",
"to",
"any",
"group"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/ownership.go#L278-L286
|
144,162 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere.go
|
NewClient
|
func NewClient(cfg *VSphereConfig) (storageops.Ops, error) {
vSphereConn := &vclib.VSphereConnection{
Username: cfg.User,
Password: cfg.Password,
Hostname: cfg.VCenterIP,
Insecure: cfg.InsecureFlag,
RoundTripperCount: cfg.RoundTripperCount,
Port: cfg.VCenterPort,
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
vmObj, err := GetVMObject(ctx, vSphereConn, cfg.VMUUID)
if err != nil {
return nil, err
}
logrus.Debugf("Using following configuration for vsphere:")
logrus.Debugf(" vCenter: %s:%s", cfg.VCenterIP, cfg.VCenterPort)
logrus.Debugf(" Datacenter: %s", vmObj.Datacenter.Name())
logrus.Debugf(" VMUUID: %s", cfg.VMUUID)
return &vsphereOps{
cfg: cfg,
vm: vmObj,
conn: vSphereConn,
}, nil
}
|
go
|
func NewClient(cfg *VSphereConfig) (storageops.Ops, error) {
vSphereConn := &vclib.VSphereConnection{
Username: cfg.User,
Password: cfg.Password,
Hostname: cfg.VCenterIP,
Insecure: cfg.InsecureFlag,
RoundTripperCount: cfg.RoundTripperCount,
Port: cfg.VCenterPort,
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
vmObj, err := GetVMObject(ctx, vSphereConn, cfg.VMUUID)
if err != nil {
return nil, err
}
logrus.Debugf("Using following configuration for vsphere:")
logrus.Debugf(" vCenter: %s:%s", cfg.VCenterIP, cfg.VCenterPort)
logrus.Debugf(" Datacenter: %s", vmObj.Datacenter.Name())
logrus.Debugf(" VMUUID: %s", cfg.VMUUID)
return &vsphereOps{
cfg: cfg,
vm: vmObj,
conn: vSphereConn,
}, nil
}
|
[
"func",
"NewClient",
"(",
"cfg",
"*",
"VSphereConfig",
")",
"(",
"storageops",
".",
"Ops",
",",
"error",
")",
"{",
"vSphereConn",
":=",
"&",
"vclib",
".",
"VSphereConnection",
"{",
"Username",
":",
"cfg",
".",
"User",
",",
"Password",
":",
"cfg",
".",
"Password",
",",
"Hostname",
":",
"cfg",
".",
"VCenterIP",
",",
"Insecure",
":",
"cfg",
".",
"InsecureFlag",
",",
"RoundTripperCount",
":",
"cfg",
".",
"RoundTripperCount",
",",
"Port",
":",
"cfg",
".",
"VCenterPort",
",",
"}",
"\n\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"vmObj",
",",
"err",
":=",
"GetVMObject",
"(",
"ctx",
",",
"vSphereConn",
",",
"cfg",
".",
"VMUUID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"cfg",
".",
"VCenterIP",
",",
"cfg",
".",
"VCenterPort",
")",
"\n",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"vmObj",
".",
"Datacenter",
".",
"Name",
"(",
")",
")",
"\n",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"cfg",
".",
"VMUUID",
")",
"\n\n",
"return",
"&",
"vsphereOps",
"{",
"cfg",
":",
"cfg",
",",
"vm",
":",
"vmObj",
",",
"conn",
":",
"vSphereConn",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewClient creates a new vsphere storageops instance
|
[
"NewClient",
"creates",
"a",
"new",
"vsphere",
"storageops",
"instance"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere.go#L44-L71
|
144,163 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere.go
|
Attach
|
func (ops *vsphereOps) Attach(diskPath string) (string, error) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
vmObj, err := ops.renewVM(ctx, ops.vm)
if err != nil {
return "", err
}
diskUUID, err := vmObj.AttachDisk(ctx, diskPath, &vclib.VolumeOptions{SCSIControllerType: vclib.PVSCSIControllerType})
if err != nil {
logrus.Errorf("Failed to attach vsphere disk: %s for VM: %s. err: +%v", diskPath, vmObj.Name(), err)
return "", err
}
return path.Join(diskByIDPath, diskSCSIPrefix+diskUUID), nil
}
|
go
|
func (ops *vsphereOps) Attach(diskPath string) (string, error) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
vmObj, err := ops.renewVM(ctx, ops.vm)
if err != nil {
return "", err
}
diskUUID, err := vmObj.AttachDisk(ctx, diskPath, &vclib.VolumeOptions{SCSIControllerType: vclib.PVSCSIControllerType})
if err != nil {
logrus.Errorf("Failed to attach vsphere disk: %s for VM: %s. err: +%v", diskPath, vmObj.Name(), err)
return "", err
}
return path.Join(diskByIDPath, diskSCSIPrefix+diskUUID), nil
}
|
[
"func",
"(",
"ops",
"*",
"vsphereOps",
")",
"Attach",
"(",
"diskPath",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"vmObj",
",",
"err",
":=",
"ops",
".",
"renewVM",
"(",
"ctx",
",",
"ops",
".",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"diskUUID",
",",
"err",
":=",
"vmObj",
".",
"AttachDisk",
"(",
"ctx",
",",
"diskPath",
",",
"&",
"vclib",
".",
"VolumeOptions",
"{",
"SCSIControllerType",
":",
"vclib",
".",
"PVSCSIControllerType",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"diskPath",
",",
"vmObj",
".",
"Name",
"(",
")",
",",
"err",
")",
"\n",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"path",
".",
"Join",
"(",
"diskByIDPath",
",",
"diskSCSIPrefix",
"+",
"diskUUID",
")",
",",
"nil",
"\n",
"}"
] |
// Attach takes in the path of the vmdk file and returns where it is attached inside the vm instance
|
[
"Attach",
"takes",
"in",
"the",
"path",
"of",
"the",
"vmdk",
"file",
"and",
"returns",
"where",
"it",
"is",
"attached",
"inside",
"the",
"vm",
"instance"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere.go#L174-L190
|
144,164 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere.go
|
Delete
|
func (ops *vsphereOps) Delete(diskPath string) error {
return ops.deleteInternal(diskPath, ops.cfg.VMUUID)
}
|
go
|
func (ops *vsphereOps) Delete(diskPath string) error {
return ops.deleteInternal(diskPath, ops.cfg.VMUUID)
}
|
[
"func",
"(",
"ops",
"*",
"vsphereOps",
")",
"Delete",
"(",
"diskPath",
"string",
")",
"error",
"{",
"return",
"ops",
".",
"deleteInternal",
"(",
"diskPath",
",",
"ops",
".",
"cfg",
".",
"VMUUID",
")",
"\n",
"}"
] |
// Delete virtual disk at given path
|
[
"Delete",
"virtual",
"disk",
"at",
"given",
"path"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere.go#L227-L229
|
144,165 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere.go
|
Describe
|
func (ops *vsphereOps) Describe() (interface{}, error) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
return ops.renewVM(ctx, ops.vm)
}
|
go
|
func (ops *vsphereOps) Describe() (interface{}, error) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
return ops.renewVM(ctx, ops.vm)
}
|
[
"func",
"(",
"ops",
"*",
"vsphereOps",
")",
"Describe",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"return",
"ops",
".",
"renewVM",
"(",
"ctx",
",",
"ops",
".",
"vm",
")",
"\n",
"}"
] |
// Desribe an instance of the virtual machine object to which ops is connected to
|
[
"Desribe",
"an",
"instance",
"of",
"the",
"virtual",
"machine",
"object",
"to",
"which",
"ops",
"is",
"connected",
"to"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere.go#L268-L273
|
144,166 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere.go
|
FreeDevices
|
func (ops *vsphereOps) FreeDevices(blockDeviceMappings []interface{}, rootDeviceName string) ([]string, error) {
return nil, storageops.ErrNotSupported
}
|
go
|
func (ops *vsphereOps) FreeDevices(blockDeviceMappings []interface{}, rootDeviceName string) ([]string, error) {
return nil, storageops.ErrNotSupported
}
|
[
"func",
"(",
"ops",
"*",
"vsphereOps",
")",
"FreeDevices",
"(",
"blockDeviceMappings",
"[",
"]",
"interface",
"{",
"}",
",",
"rootDeviceName",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"return",
"nil",
",",
"storageops",
".",
"ErrNotSupported",
"\n",
"}"
] |
// FreeDevices is not supported by this provider
|
[
"FreeDevices",
"is",
"not",
"supported",
"by",
"this",
"provider"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere.go#L276-L278
|
144,167 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere.go
|
DevicePath
|
func (ops *vsphereOps) DevicePath(diskPath string) (string, error) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
vmObj, err := ops.renewVM(ctx, ops.vm)
if err != nil {
return "", err
}
attached, err := vmObj.IsDiskAttached(ctx, diskPath)
if err != nil {
return "", fmt.Errorf("failed to check if disk: %s is attached on vm: %s. err: %v",
diskPath, vmObj.Name(), err)
}
if !attached {
return "", fmt.Errorf("disk: %s is not attached on vm: %s", diskPath, vmObj.Name())
}
diskUUID, err := vmObj.Datacenter.GetVirtualDiskPage83Data(ctx, diskPath)
if err != nil {
logrus.Errorf("failed to get device path for disk: %s on vm: %s", diskPath, vmObj.Name())
return "", err
}
return path.Join(diskByIDPath, diskSCSIPrefix+diskUUID), nil
}
|
go
|
func (ops *vsphereOps) DevicePath(diskPath string) (string, error) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
vmObj, err := ops.renewVM(ctx, ops.vm)
if err != nil {
return "", err
}
attached, err := vmObj.IsDiskAttached(ctx, diskPath)
if err != nil {
return "", fmt.Errorf("failed to check if disk: %s is attached on vm: %s. err: %v",
diskPath, vmObj.Name(), err)
}
if !attached {
return "", fmt.Errorf("disk: %s is not attached on vm: %s", diskPath, vmObj.Name())
}
diskUUID, err := vmObj.Datacenter.GetVirtualDiskPage83Data(ctx, diskPath)
if err != nil {
logrus.Errorf("failed to get device path for disk: %s on vm: %s", diskPath, vmObj.Name())
return "", err
}
return path.Join(diskByIDPath, diskSCSIPrefix+diskUUID), nil
}
|
[
"func",
"(",
"ops",
"*",
"vsphereOps",
")",
"DevicePath",
"(",
"diskPath",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"vmObj",
",",
"err",
":=",
"ops",
".",
"renewVM",
"(",
"ctx",
",",
"ops",
".",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"attached",
",",
"err",
":=",
"vmObj",
".",
"IsDiskAttached",
"(",
"ctx",
",",
"diskPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"diskPath",
",",
"vmObj",
".",
"Name",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"attached",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"diskPath",
",",
"vmObj",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n\n",
"diskUUID",
",",
"err",
":=",
"vmObj",
".",
"Datacenter",
".",
"GetVirtualDiskPage83Data",
"(",
"ctx",
",",
"diskPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"diskPath",
",",
"vmObj",
".",
"Name",
"(",
")",
")",
"\n",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"path",
".",
"Join",
"(",
"diskByIDPath",
",",
"diskSCSIPrefix",
"+",
"diskUUID",
")",
",",
"nil",
"\n",
"}"
] |
// DevicePath for the given volume i.e path where it's attached
|
[
"DevicePath",
"for",
"the",
"given",
"volume",
"i",
".",
"e",
"path",
"where",
"it",
"s",
"attached"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere.go#L322-L348
|
144,168 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere.go
|
Snapshot
|
func (ops *vsphereOps) Snapshot(volumeID string, readonly bool) (interface{}, error) {
return nil, storageops.ErrNotSupported
}
|
go
|
func (ops *vsphereOps) Snapshot(volumeID string, readonly bool) (interface{}, error) {
return nil, storageops.ErrNotSupported
}
|
[
"func",
"(",
"ops",
"*",
"vsphereOps",
")",
"Snapshot",
"(",
"volumeID",
"string",
",",
"readonly",
"bool",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"nil",
",",
"storageops",
".",
"ErrNotSupported",
"\n",
"}"
] |
// Snapshot the volume with given volumeID
|
[
"Snapshot",
"the",
"volume",
"with",
"given",
"volumeID"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere.go#L358-L360
|
144,169 |
libopenstorage/openstorage
|
pkg/storageops/vsphere/vsphere.go
|
GetVMObject
|
func GetVMObject(ctx context.Context, conn *vclib.VSphereConnection, vmUUID string) (*vclib.VirtualMachine, error) {
// TODO change impl below using multiple goroutines and sync.WaitGroup to make it faster
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if err := conn.Connect(ctx); err != nil {
return nil, err
}
if len(vmUUID) == 0 {
return nil, fmt.Errorf("virtual machine uuid is required")
}
datacenterObjs, err := vclib.GetAllDatacenter(ctx, conn)
if err != nil {
return nil, err
}
// Lookup in each vsphere datacenter for this virtual machine
for _, dc := range datacenterObjs {
vm, err := dc.GetVMByUUID(ctx, vmUUID)
if err != nil {
if err != vclib.ErrNoVMFound {
logrus.Warnf("failed to find vm with uuid: %s in datacenter: %s due to err: %v", vmUUID, dc.Name(), err)
// don't let one bad egg fail entire search. keep looking.
} else {
logrus.Debugf("did not find vm with uuid: %s in datacenter: %s", vmUUID, dc.Name())
}
continue
}
if vm != nil {
return vm, nil
}
}
return nil, fmt.Errorf("failed to find vm with uuid: %s in any datacenter for vc: %s", vmUUID, conn.Hostname)
}
|
go
|
func GetVMObject(ctx context.Context, conn *vclib.VSphereConnection, vmUUID string) (*vclib.VirtualMachine, error) {
// TODO change impl below using multiple goroutines and sync.WaitGroup to make it faster
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if err := conn.Connect(ctx); err != nil {
return nil, err
}
if len(vmUUID) == 0 {
return nil, fmt.Errorf("virtual machine uuid is required")
}
datacenterObjs, err := vclib.GetAllDatacenter(ctx, conn)
if err != nil {
return nil, err
}
// Lookup in each vsphere datacenter for this virtual machine
for _, dc := range datacenterObjs {
vm, err := dc.GetVMByUUID(ctx, vmUUID)
if err != nil {
if err != vclib.ErrNoVMFound {
logrus.Warnf("failed to find vm with uuid: %s in datacenter: %s due to err: %v", vmUUID, dc.Name(), err)
// don't let one bad egg fail entire search. keep looking.
} else {
logrus.Debugf("did not find vm with uuid: %s in datacenter: %s", vmUUID, dc.Name())
}
continue
}
if vm != nil {
return vm, nil
}
}
return nil, fmt.Errorf("failed to find vm with uuid: %s in any datacenter for vc: %s", vmUUID, conn.Hostname)
}
|
[
"func",
"GetVMObject",
"(",
"ctx",
"context",
".",
"Context",
",",
"conn",
"*",
"vclib",
".",
"VSphereConnection",
",",
"vmUUID",
"string",
")",
"(",
"*",
"vclib",
".",
"VirtualMachine",
",",
"error",
")",
"{",
"// TODO change impl below using multiple goroutines and sync.WaitGroup to make it faster",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"if",
"err",
":=",
"conn",
".",
"Connect",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"vmUUID",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"datacenterObjs",
",",
"err",
":=",
"vclib",
".",
"GetAllDatacenter",
"(",
"ctx",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Lookup in each vsphere datacenter for this virtual machine",
"for",
"_",
",",
"dc",
":=",
"range",
"datacenterObjs",
"{",
"vm",
",",
"err",
":=",
"dc",
".",
"GetVMByUUID",
"(",
"ctx",
",",
"vmUUID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"vclib",
".",
"ErrNoVMFound",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"vmUUID",
",",
"dc",
".",
"Name",
"(",
")",
",",
"err",
")",
"\n",
"// don't let one bad egg fail entire search. keep looking.",
"}",
"else",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"vmUUID",
",",
"dc",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"vm",
"!=",
"nil",
"{",
"return",
"vm",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vmUUID",
",",
"conn",
".",
"Hostname",
")",
"\n",
"}"
] |
// GetVMObject fetches the VirtualMachine object corresponding to the given virtual machine uuid
|
[
"GetVMObject",
"fetches",
"the",
"VirtualMachine",
"object",
"corresponding",
"to",
"the",
"given",
"virtual",
"machine",
"uuid"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/vsphere/vsphere.go#L383-L419
|
144,170 |
libopenstorage/openstorage
|
pkg/storagepolicy/sdkstoragepolicy.go
|
Create
|
func (p *SdkPolicyManager) Create(
ctx context.Context,
req *api.SdkOpenStoragePolicyCreateRequest,
) (*api.SdkOpenStoragePolicyCreateResponse, error) {
if req.GetStoragePolicy().GetName() == "" {
return nil, status.Error(codes.InvalidArgument, "Must supply a Storage Policy Name")
} else if req.GetStoragePolicy().GetPolicy() == nil {
return nil, status.Error(codes.InvalidArgument, "Must supply Volume Specs")
}
// Add ownership details to storage policy
// user who has RBAC access to storage policy can create one
req.StoragePolicy.Ownership = api.OwnershipSetUsernameFromContext(ctx, req.GetStoragePolicy().GetOwnership())
// Since VolumeSpecPolicy has oneof method of proto,
// we need to marshal sdkStoragePolicy into string using protobuf jsonpb
m := jsonpb.Marshaler{OrigName: true}
policyStr, err := m.MarshalToString(req.GetStoragePolicy())
if err != nil {
return nil, status.Errorf(codes.Internal, "Json Marshal failed for policy %s: %v", req.GetStoragePolicy().GetName(), err)
}
_, err = p.kv.Create(prefixWithName(req.GetStoragePolicy().GetName()), policyStr, 0)
if err == kvdb.ErrExist {
return nil, status.Errorf(codes.AlreadyExists, "Storage Policy already exist : %v", req.GetStoragePolicy().GetName())
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to save storage policy: %v", err)
}
logrus.Infof("Storage Policy %v is created", req.GetStoragePolicy().GetName())
return &api.SdkOpenStoragePolicyCreateResponse{}, nil
}
|
go
|
func (p *SdkPolicyManager) Create(
ctx context.Context,
req *api.SdkOpenStoragePolicyCreateRequest,
) (*api.SdkOpenStoragePolicyCreateResponse, error) {
if req.GetStoragePolicy().GetName() == "" {
return nil, status.Error(codes.InvalidArgument, "Must supply a Storage Policy Name")
} else if req.GetStoragePolicy().GetPolicy() == nil {
return nil, status.Error(codes.InvalidArgument, "Must supply Volume Specs")
}
// Add ownership details to storage policy
// user who has RBAC access to storage policy can create one
req.StoragePolicy.Ownership = api.OwnershipSetUsernameFromContext(ctx, req.GetStoragePolicy().GetOwnership())
// Since VolumeSpecPolicy has oneof method of proto,
// we need to marshal sdkStoragePolicy into string using protobuf jsonpb
m := jsonpb.Marshaler{OrigName: true}
policyStr, err := m.MarshalToString(req.GetStoragePolicy())
if err != nil {
return nil, status.Errorf(codes.Internal, "Json Marshal failed for policy %s: %v", req.GetStoragePolicy().GetName(), err)
}
_, err = p.kv.Create(prefixWithName(req.GetStoragePolicy().GetName()), policyStr, 0)
if err == kvdb.ErrExist {
return nil, status.Errorf(codes.AlreadyExists, "Storage Policy already exist : %v", req.GetStoragePolicy().GetName())
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to save storage policy: %v", err)
}
logrus.Infof("Storage Policy %v is created", req.GetStoragePolicy().GetName())
return &api.SdkOpenStoragePolicyCreateResponse{}, nil
}
|
[
"func",
"(",
"p",
"*",
"SdkPolicyManager",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkOpenStoragePolicyCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkOpenStoragePolicyCreateResponse",
",",
"error",
")",
"{",
"if",
"req",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"req",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetPolicy",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Add ownership details to storage policy",
"// user who has RBAC access to storage policy can create one",
"req",
".",
"StoragePolicy",
".",
"Ownership",
"=",
"api",
".",
"OwnershipSetUsernameFromContext",
"(",
"ctx",
",",
"req",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetOwnership",
"(",
")",
")",
"\n\n",
"// Since VolumeSpecPolicy has oneof method of proto,",
"// we need to marshal sdkStoragePolicy into string using protobuf jsonpb",
"m",
":=",
"jsonpb",
".",
"Marshaler",
"{",
"OrigName",
":",
"true",
"}",
"\n",
"policyStr",
",",
"err",
":=",
"m",
".",
"MarshalToString",
"(",
"req",
".",
"GetStoragePolicy",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"p",
".",
"kv",
".",
"Create",
"(",
"prefixWithName",
"(",
"req",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
")",
",",
"policyStr",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"kvdb",
".",
"ErrExist",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"AlreadyExists",
",",
"\"",
"\"",
",",
"req",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"req",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
")",
"\n",
"return",
"&",
"api",
".",
"SdkOpenStoragePolicyCreateResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// Create Storage policy
|
[
"Create",
"Storage",
"policy"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storagepolicy/sdkstoragepolicy.go#L97-L128
|
144,171 |
libopenstorage/openstorage
|
pkg/storagepolicy/sdkstoragepolicy.go
|
Delete
|
func (p *SdkPolicyManager) Delete(
ctx context.Context,
req *api.SdkOpenStoragePolicyDeleteRequest,
) (*api.SdkOpenStoragePolicyDeleteResponse, error) {
if req.GetName() == "" {
return nil, status.Error(codes.InvalidArgument, "Must supply a Storage Policy Name")
}
// retrive default storage policy details
inspResp, err := p.Inspect(ctx,
&api.SdkOpenStoragePolicyInspectRequest{
Name: req.GetName(),
},
)
if err != nil {
return &api.SdkOpenStoragePolicyDeleteResponse{}, nil
}
// Only the owner or the admin can delete
if !inspResp.GetStoragePolicy().IsPermitted(ctx, api.Ownership_Admin) {
return nil, status.Errorf(codes.PermissionDenied, "Cannot delete storage policy %v", req.GetName())
}
// release default policy restriction before deleting policy
policy, err := p.DefaultInspect(ctx, &api.SdkOpenStoragePolicyDefaultInspectRequest{})
if err != nil {
return nil, err
}
if policy.GetStoragePolicy() != nil && policy.GetStoragePolicy().GetName() == req.GetName() {
_, err := p.Release(ctx, &api.SdkOpenStoragePolicyReleaseRequest{})
if err != nil {
return nil, status.Errorf(codes.Internal, "Removal of default policy failed with: %v", err)
}
}
_, err = p.kv.Delete(prefixWithName(req.GetName()))
if err != kvdb.ErrNotFound && err != nil {
return nil, status.Errorf(codes.Internal, "Failed to delete Storage Policy %s: %v", req.GetName(), err)
}
logrus.Infof("Storage Policy %v is deleted", req.GetName())
return &api.SdkOpenStoragePolicyDeleteResponse{}, nil
}
|
go
|
func (p *SdkPolicyManager) Delete(
ctx context.Context,
req *api.SdkOpenStoragePolicyDeleteRequest,
) (*api.SdkOpenStoragePolicyDeleteResponse, error) {
if req.GetName() == "" {
return nil, status.Error(codes.InvalidArgument, "Must supply a Storage Policy Name")
}
// retrive default storage policy details
inspResp, err := p.Inspect(ctx,
&api.SdkOpenStoragePolicyInspectRequest{
Name: req.GetName(),
},
)
if err != nil {
return &api.SdkOpenStoragePolicyDeleteResponse{}, nil
}
// Only the owner or the admin can delete
if !inspResp.GetStoragePolicy().IsPermitted(ctx, api.Ownership_Admin) {
return nil, status.Errorf(codes.PermissionDenied, "Cannot delete storage policy %v", req.GetName())
}
// release default policy restriction before deleting policy
policy, err := p.DefaultInspect(ctx, &api.SdkOpenStoragePolicyDefaultInspectRequest{})
if err != nil {
return nil, err
}
if policy.GetStoragePolicy() != nil && policy.GetStoragePolicy().GetName() == req.GetName() {
_, err := p.Release(ctx, &api.SdkOpenStoragePolicyReleaseRequest{})
if err != nil {
return nil, status.Errorf(codes.Internal, "Removal of default policy failed with: %v", err)
}
}
_, err = p.kv.Delete(prefixWithName(req.GetName()))
if err != kvdb.ErrNotFound && err != nil {
return nil, status.Errorf(codes.Internal, "Failed to delete Storage Policy %s: %v", req.GetName(), err)
}
logrus.Infof("Storage Policy %v is deleted", req.GetName())
return &api.SdkOpenStoragePolicyDeleteResponse{}, nil
}
|
[
"func",
"(",
"p",
"*",
"SdkPolicyManager",
")",
"Delete",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkOpenStoragePolicyDeleteRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkOpenStoragePolicyDeleteResponse",
",",
"error",
")",
"{",
"if",
"req",
".",
"GetName",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// retrive default storage policy details",
"inspResp",
",",
"err",
":=",
"p",
".",
"Inspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkOpenStoragePolicyInspectRequest",
"{",
"Name",
":",
"req",
".",
"GetName",
"(",
")",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"&",
"api",
".",
"SdkOpenStoragePolicyDeleteResponse",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"// Only the owner or the admin can delete",
"if",
"!",
"inspResp",
".",
"GetStoragePolicy",
"(",
")",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Admin",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// release default policy restriction before deleting policy",
"policy",
",",
"err",
":=",
"p",
".",
"DefaultInspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkOpenStoragePolicyDefaultInspectRequest",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"policy",
".",
"GetStoragePolicy",
"(",
")",
"!=",
"nil",
"&&",
"policy",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
"==",
"req",
".",
"GetName",
"(",
")",
"{",
"_",
",",
"err",
":=",
"p",
".",
"Release",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkOpenStoragePolicyReleaseRequest",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"p",
".",
"kv",
".",
"Delete",
"(",
"prefixWithName",
"(",
"req",
".",
"GetName",
"(",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"kvdb",
".",
"ErrNotFound",
"&&",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
")",
"\n",
"return",
"&",
"api",
".",
"SdkOpenStoragePolicyDeleteResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// Delete storage policy specified by name
|
[
"Delete",
"storage",
"policy",
"specified",
"by",
"name"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storagepolicy/sdkstoragepolicy.go#L190-L233
|
144,172 |
libopenstorage/openstorage
|
pkg/storagepolicy/sdkstoragepolicy.go
|
Inspect
|
func (p *SdkPolicyManager) Inspect(
ctx context.Context,
req *api.SdkOpenStoragePolicyInspectRequest,
) (*api.SdkOpenStoragePolicyInspectResponse, error) {
if req.GetName() == "" {
return nil, status.Error(codes.InvalidArgument, "Must supply a Storage Policy Name")
}
kvp, err := p.kv.Get(prefixWithName(req.GetName()))
if err == kvdb.ErrNotFound {
return nil, status.Errorf(codes.NotFound, "Policy %s not found", req.GetName())
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get policy %s information: %v", req.GetName(), err)
}
storPolicy := &api.SdkStoragePolicy{}
err = jsonpb.UnmarshalString(string(kvp.Value), storPolicy)
if err != nil {
return nil, status.Errorf(codes.Internal, "Json Unmarshal failed for policy %s: %v", req.GetName(), err)
}
if !storPolicy.IsPermitted(ctx, api.Ownership_Read) {
return nil, status.Errorf(codes.PermissionDenied, "Access denied to storage policy %s", storPolicy.GetName())
}
return &api.SdkOpenStoragePolicyInspectResponse{
StoragePolicy: storPolicy,
}, nil
}
|
go
|
func (p *SdkPolicyManager) Inspect(
ctx context.Context,
req *api.SdkOpenStoragePolicyInspectRequest,
) (*api.SdkOpenStoragePolicyInspectResponse, error) {
if req.GetName() == "" {
return nil, status.Error(codes.InvalidArgument, "Must supply a Storage Policy Name")
}
kvp, err := p.kv.Get(prefixWithName(req.GetName()))
if err == kvdb.ErrNotFound {
return nil, status.Errorf(codes.NotFound, "Policy %s not found", req.GetName())
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get policy %s information: %v", req.GetName(), err)
}
storPolicy := &api.SdkStoragePolicy{}
err = jsonpb.UnmarshalString(string(kvp.Value), storPolicy)
if err != nil {
return nil, status.Errorf(codes.Internal, "Json Unmarshal failed for policy %s: %v", req.GetName(), err)
}
if !storPolicy.IsPermitted(ctx, api.Ownership_Read) {
return nil, status.Errorf(codes.PermissionDenied, "Access denied to storage policy %s", storPolicy.GetName())
}
return &api.SdkOpenStoragePolicyInspectResponse{
StoragePolicy: storPolicy,
}, nil
}
|
[
"func",
"(",
"p",
"*",
"SdkPolicyManager",
")",
"Inspect",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkOpenStoragePolicyInspectRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkOpenStoragePolicyInspectResponse",
",",
"error",
")",
"{",
"if",
"req",
".",
"GetName",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"kvp",
",",
"err",
":=",
"p",
".",
"kv",
".",
"Get",
"(",
"prefixWithName",
"(",
"req",
".",
"GetName",
"(",
")",
")",
")",
"\n",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"storPolicy",
":=",
"&",
"api",
".",
"SdkStoragePolicy",
"{",
"}",
"\n",
"err",
"=",
"jsonpb",
".",
"UnmarshalString",
"(",
"string",
"(",
"kvp",
".",
"Value",
")",
",",
"storPolicy",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"storPolicy",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Read",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
",",
"storPolicy",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkOpenStoragePolicyInspectResponse",
"{",
"StoragePolicy",
":",
"storPolicy",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Inspect storage policy specifed by name
|
[
"Inspect",
"storage",
"policy",
"specifed",
"by",
"name"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storagepolicy/sdkstoragepolicy.go#L236-L264
|
144,173 |
libopenstorage/openstorage
|
pkg/storagepolicy/sdkstoragepolicy.go
|
Enumerate
|
func (p *SdkPolicyManager) Enumerate(
ctx context.Context,
req *api.SdkOpenStoragePolicyEnumerateRequest,
) (*api.SdkOpenStoragePolicyEnumerateResponse, error) {
// get all keyValue pair at /storage/policy/policies
kvp, err := p.kv.Enumerate(policyPrefix + policyPath)
if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get policies from database: %v", err)
}
policies := make([]*api.SdkStoragePolicy, 0)
for _, policy := range kvp {
sdkPolicy := &api.SdkStoragePolicy{}
err = jsonpb.UnmarshalString(string(policy.Value), sdkPolicy)
if err != nil {
return nil, status.Errorf(codes.Internal, "Json Unmarshal failed for policy %s: %v", policy.Key, err)
}
// only enum volumes, owner has read access to
if sdkPolicy.IsPermitted(ctx, api.Ownership_Read) {
policies = append(policies, sdkPolicy)
}
}
return &api.SdkOpenStoragePolicyEnumerateResponse{
StoragePolicies: policies,
}, nil
}
|
go
|
func (p *SdkPolicyManager) Enumerate(
ctx context.Context,
req *api.SdkOpenStoragePolicyEnumerateRequest,
) (*api.SdkOpenStoragePolicyEnumerateResponse, error) {
// get all keyValue pair at /storage/policy/policies
kvp, err := p.kv.Enumerate(policyPrefix + policyPath)
if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to get policies from database: %v", err)
}
policies := make([]*api.SdkStoragePolicy, 0)
for _, policy := range kvp {
sdkPolicy := &api.SdkStoragePolicy{}
err = jsonpb.UnmarshalString(string(policy.Value), sdkPolicy)
if err != nil {
return nil, status.Errorf(codes.Internal, "Json Unmarshal failed for policy %s: %v", policy.Key, err)
}
// only enum volumes, owner has read access to
if sdkPolicy.IsPermitted(ctx, api.Ownership_Read) {
policies = append(policies, sdkPolicy)
}
}
return &api.SdkOpenStoragePolicyEnumerateResponse{
StoragePolicies: policies,
}, nil
}
|
[
"func",
"(",
"p",
"*",
"SdkPolicyManager",
")",
"Enumerate",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkOpenStoragePolicyEnumerateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkOpenStoragePolicyEnumerateResponse",
",",
"error",
")",
"{",
"// get all keyValue pair at /storage/policy/policies",
"kvp",
",",
"err",
":=",
"p",
".",
"kv",
".",
"Enumerate",
"(",
"policyPrefix",
"+",
"policyPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"policies",
":=",
"make",
"(",
"[",
"]",
"*",
"api",
".",
"SdkStoragePolicy",
",",
"0",
")",
"\n",
"for",
"_",
",",
"policy",
":=",
"range",
"kvp",
"{",
"sdkPolicy",
":=",
"&",
"api",
".",
"SdkStoragePolicy",
"{",
"}",
"\n",
"err",
"=",
"jsonpb",
".",
"UnmarshalString",
"(",
"string",
"(",
"policy",
".",
"Value",
")",
",",
"sdkPolicy",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"policy",
".",
"Key",
",",
"err",
")",
"\n",
"}",
"\n",
"// only enum volumes, owner has read access to",
"if",
"sdkPolicy",
".",
"IsPermitted",
"(",
"ctx",
",",
"api",
".",
"Ownership_Read",
")",
"{",
"policies",
"=",
"append",
"(",
"policies",
",",
"sdkPolicy",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkOpenStoragePolicyEnumerateResponse",
"{",
"StoragePolicies",
":",
"policies",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Enumerate all of storage policies
|
[
"Enumerate",
"all",
"of",
"storage",
"policies"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storagepolicy/sdkstoragepolicy.go#L267-L293
|
144,174 |
libopenstorage/openstorage
|
pkg/storagepolicy/sdkstoragepolicy.go
|
SetDefault
|
func (p *SdkPolicyManager) SetDefault(
ctx context.Context,
req *api.SdkOpenStoragePolicySetDefaultRequest,
) (*api.SdkOpenStoragePolicySetDefaultResponse, error) {
if req.GetName() == "" {
return nil, status.Error(codes.InvalidArgument, "Must supply a Storage Policy Name")
}
// verify policy exists, before setting it as default
policy, err := p.Inspect(ctx,
&api.SdkOpenStoragePolicyInspectRequest{
Name: req.GetName(),
},
)
if err != nil {
return nil, err
}
// Only administrator can set policy as default storage
// policy restriction
user, _ := auth.NewUserInfoFromContext(ctx)
if !policy.GetStoragePolicy().GetOwnership().IsAdminByUser(user) {
return nil, status.Errorf(codes.PermissionDenied, "Only the storage system admin can set storage policy as default %v", req.GetName())
}
policyStr, err := json.Marshal(policy.GetStoragePolicy().GetName())
if err != nil {
return nil, status.Errorf(codes.Internal, "Json marshal failed for policy %s :%v", req.GetName(), err)
}
_, err = p.kv.Update(defaultPath, policyStr, 0)
if err == kvdb.ErrNotFound {
if _, err := p.kv.Create(defaultPath, policyStr, 0); err != nil {
return nil, status.Errorf(codes.Internal, "Unable to save default policy details %v", err)
}
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to set default policy: %v", err)
}
logrus.Infof("Storage Policy %v is set as default", policy.GetStoragePolicy().GetName())
return &api.SdkOpenStoragePolicySetDefaultResponse{}, nil
}
|
go
|
func (p *SdkPolicyManager) SetDefault(
ctx context.Context,
req *api.SdkOpenStoragePolicySetDefaultRequest,
) (*api.SdkOpenStoragePolicySetDefaultResponse, error) {
if req.GetName() == "" {
return nil, status.Error(codes.InvalidArgument, "Must supply a Storage Policy Name")
}
// verify policy exists, before setting it as default
policy, err := p.Inspect(ctx,
&api.SdkOpenStoragePolicyInspectRequest{
Name: req.GetName(),
},
)
if err != nil {
return nil, err
}
// Only administrator can set policy as default storage
// policy restriction
user, _ := auth.NewUserInfoFromContext(ctx)
if !policy.GetStoragePolicy().GetOwnership().IsAdminByUser(user) {
return nil, status.Errorf(codes.PermissionDenied, "Only the storage system admin can set storage policy as default %v", req.GetName())
}
policyStr, err := json.Marshal(policy.GetStoragePolicy().GetName())
if err != nil {
return nil, status.Errorf(codes.Internal, "Json marshal failed for policy %s :%v", req.GetName(), err)
}
_, err = p.kv.Update(defaultPath, policyStr, 0)
if err == kvdb.ErrNotFound {
if _, err := p.kv.Create(defaultPath, policyStr, 0); err != nil {
return nil, status.Errorf(codes.Internal, "Unable to save default policy details %v", err)
}
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Failed to set default policy: %v", err)
}
logrus.Infof("Storage Policy %v is set as default", policy.GetStoragePolicy().GetName())
return &api.SdkOpenStoragePolicySetDefaultResponse{}, nil
}
|
[
"func",
"(",
"p",
"*",
"SdkPolicyManager",
")",
"SetDefault",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkOpenStoragePolicySetDefaultRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkOpenStoragePolicySetDefaultResponse",
",",
"error",
")",
"{",
"if",
"req",
".",
"GetName",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// verify policy exists, before setting it as default",
"policy",
",",
"err",
":=",
"p",
".",
"Inspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkOpenStoragePolicyInspectRequest",
"{",
"Name",
":",
"req",
".",
"GetName",
"(",
")",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Only administrator can set policy as default storage",
"// policy restriction",
"user",
",",
"_",
":=",
"auth",
".",
"NewUserInfoFromContext",
"(",
"ctx",
")",
"\n",
"if",
"!",
"policy",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetOwnership",
"(",
")",
".",
"IsAdminByUser",
"(",
"user",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n\n",
"policyStr",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"policy",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"p",
".",
"kv",
".",
"Update",
"(",
"defaultPath",
",",
"policyStr",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"{",
"if",
"_",
",",
"err",
":=",
"p",
".",
"kv",
".",
"Create",
"(",
"defaultPath",
",",
"policyStr",
",",
"0",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"policy",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
")",
"\n",
"return",
"&",
"api",
".",
"SdkOpenStoragePolicySetDefaultResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// SetDefault storage policy
|
[
"SetDefault",
"storage",
"policy"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storagepolicy/sdkstoragepolicy.go#L296-L336
|
144,175 |
libopenstorage/openstorage
|
pkg/storagepolicy/sdkstoragepolicy.go
|
Release
|
func (p *SdkPolicyManager) Release(
ctx context.Context,
req *api.SdkOpenStoragePolicyReleaseRequest,
) (*api.SdkOpenStoragePolicyReleaseResponse, error) {
policy, err := p.DefaultInspect(ctx, &api.SdkOpenStoragePolicyDefaultInspectRequest{})
if err != nil {
return nil, err
}
// only administrator can remove storage policy restriction
user, _ := auth.NewUserInfoFromContext(ctx)
if !policy.GetStoragePolicy().GetOwnership().IsAdminByUser(user) {
return nil, status.Errorf(codes.PermissionDenied, "Only the storage system admin can remove storage policy restriction")
}
// empty represents no policy is set as default
strB, _ := json.Marshal("")
_, err = p.kv.Update(defaultPath, strB, 0)
if err != kvdb.ErrNotFound && err != nil {
return nil, status.Errorf(codes.Internal, "Remove storage policy restriction failed with: %v", err)
}
logrus.Infof("Storage Policy %v restriction is removed", policy.GetStoragePolicy().GetName())
return &api.SdkOpenStoragePolicyReleaseResponse{}, nil
}
|
go
|
func (p *SdkPolicyManager) Release(
ctx context.Context,
req *api.SdkOpenStoragePolicyReleaseRequest,
) (*api.SdkOpenStoragePolicyReleaseResponse, error) {
policy, err := p.DefaultInspect(ctx, &api.SdkOpenStoragePolicyDefaultInspectRequest{})
if err != nil {
return nil, err
}
// only administrator can remove storage policy restriction
user, _ := auth.NewUserInfoFromContext(ctx)
if !policy.GetStoragePolicy().GetOwnership().IsAdminByUser(user) {
return nil, status.Errorf(codes.PermissionDenied, "Only the storage system admin can remove storage policy restriction")
}
// empty represents no policy is set as default
strB, _ := json.Marshal("")
_, err = p.kv.Update(defaultPath, strB, 0)
if err != kvdb.ErrNotFound && err != nil {
return nil, status.Errorf(codes.Internal, "Remove storage policy restriction failed with: %v", err)
}
logrus.Infof("Storage Policy %v restriction is removed", policy.GetStoragePolicy().GetName())
return &api.SdkOpenStoragePolicyReleaseResponse{}, nil
}
|
[
"func",
"(",
"p",
"*",
"SdkPolicyManager",
")",
"Release",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkOpenStoragePolicyReleaseRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkOpenStoragePolicyReleaseResponse",
",",
"error",
")",
"{",
"policy",
",",
"err",
":=",
"p",
".",
"DefaultInspect",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkOpenStoragePolicyDefaultInspectRequest",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// only administrator can remove storage policy restriction",
"user",
",",
"_",
":=",
"auth",
".",
"NewUserInfoFromContext",
"(",
"ctx",
")",
"\n",
"if",
"!",
"policy",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetOwnership",
"(",
")",
".",
"IsAdminByUser",
"(",
"user",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"PermissionDenied",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// empty represents no policy is set as default",
"strB",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"err",
"=",
"p",
".",
"kv",
".",
"Update",
"(",
"defaultPath",
",",
"strB",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"kvdb",
".",
"ErrNotFound",
"&&",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"policy",
".",
"GetStoragePolicy",
"(",
")",
".",
"GetName",
"(",
")",
")",
"\n",
"return",
"&",
"api",
".",
"SdkOpenStoragePolicyReleaseResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// Release storage policy if set as default
|
[
"Release",
"storage",
"policy",
"if",
"set",
"as",
"default"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storagepolicy/sdkstoragepolicy.go#L339-L364
|
144,176 |
libopenstorage/openstorage
|
pkg/storagepolicy/sdkstoragepolicy.go
|
DefaultInspect
|
func (p *SdkPolicyManager) DefaultInspect(
ctx context.Context,
req *api.SdkOpenStoragePolicyDefaultInspectRequest,
) (*api.SdkOpenStoragePolicyDefaultInspectResponse, error) {
var policyName string
defaultPolicy := &api.SdkOpenStoragePolicyDefaultInspectResponse{}
_, err := p.kv.GetVal(defaultPath, &policyName)
// defaultPath key is not created
if err == kvdb.ErrNotFound {
return defaultPolicy, nil
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to retrive default policy details: %v", err)
}
// no default policy found
if policyName == "" {
return defaultPolicy, nil
}
// retrive default storage policy details
inspResp, err := p.Inspect(context.Background(),
&api.SdkOpenStoragePolicyInspectRequest{
Name: policyName,
},
)
if err != nil {
return nil, err
}
return &api.SdkOpenStoragePolicyDefaultInspectResponse{
StoragePolicy: inspResp.GetStoragePolicy(),
}, nil
}
|
go
|
func (p *SdkPolicyManager) DefaultInspect(
ctx context.Context,
req *api.SdkOpenStoragePolicyDefaultInspectRequest,
) (*api.SdkOpenStoragePolicyDefaultInspectResponse, error) {
var policyName string
defaultPolicy := &api.SdkOpenStoragePolicyDefaultInspectResponse{}
_, err := p.kv.GetVal(defaultPath, &policyName)
// defaultPath key is not created
if err == kvdb.ErrNotFound {
return defaultPolicy, nil
} else if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to retrive default policy details: %v", err)
}
// no default policy found
if policyName == "" {
return defaultPolicy, nil
}
// retrive default storage policy details
inspResp, err := p.Inspect(context.Background(),
&api.SdkOpenStoragePolicyInspectRequest{
Name: policyName,
},
)
if err != nil {
return nil, err
}
return &api.SdkOpenStoragePolicyDefaultInspectResponse{
StoragePolicy: inspResp.GetStoragePolicy(),
}, nil
}
|
[
"func",
"(",
"p",
"*",
"SdkPolicyManager",
")",
"DefaultInspect",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkOpenStoragePolicyDefaultInspectRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkOpenStoragePolicyDefaultInspectResponse",
",",
"error",
")",
"{",
"var",
"policyName",
"string",
"\n",
"defaultPolicy",
":=",
"&",
"api",
".",
"SdkOpenStoragePolicyDefaultInspectResponse",
"{",
"}",
"\n\n",
"_",
",",
"err",
":=",
"p",
".",
"kv",
".",
"GetVal",
"(",
"defaultPath",
",",
"&",
"policyName",
")",
"\n",
"// defaultPath key is not created",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"{",
"return",
"defaultPolicy",
",",
"nil",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// no default policy found",
"if",
"policyName",
"==",
"\"",
"\"",
"{",
"return",
"defaultPolicy",
",",
"nil",
"\n",
"}",
"\n\n",
"// retrive default storage policy details",
"inspResp",
",",
"err",
":=",
"p",
".",
"Inspect",
"(",
"context",
".",
"Background",
"(",
")",
",",
"&",
"api",
".",
"SdkOpenStoragePolicyInspectRequest",
"{",
"Name",
":",
"policyName",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkOpenStoragePolicyDefaultInspectResponse",
"{",
"StoragePolicy",
":",
"inspResp",
".",
"GetStoragePolicy",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// DefaultInspect return default storeage policy details
|
[
"DefaultInspect",
"return",
"default",
"storeage",
"policy",
"details"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storagepolicy/sdkstoragepolicy.go#L367-L400
|
144,177 |
libopenstorage/openstorage
|
api/server/sdk/cluster_pair.go
|
Create
|
func (s *ClusterPairServer) Create(
ctx context.Context,
req *api.SdkClusterPairCreateRequest,
) (*api.SdkClusterPairCreateResponse, error) {
if s.cluster() == 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")
}
resp, err := s.cluster().CreatePair(req.GetRequest())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot create cluster with remote pair %s : %v",
req.GetRequest().GetRemoteClusterIp(), err)
}
return &api.SdkClusterPairCreateResponse{
Result: resp,
}, nil
}
|
go
|
func (s *ClusterPairServer) Create(
ctx context.Context,
req *api.SdkClusterPairCreateRequest,
) (*api.SdkClusterPairCreateResponse, error) {
if s.cluster() == 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")
}
resp, err := s.cluster().CreatePair(req.GetRequest())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot create cluster with remote pair %s : %v",
req.GetRequest().GetRemoteClusterIp(), err)
}
return &api.SdkClusterPairCreateResponse{
Result: resp,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"ClusterPairServer",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkClusterPairCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkClusterPairCreateResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"req",
".",
"GetRequest",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"CreatePair",
"(",
"req",
".",
"GetRequest",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetRequest",
"(",
")",
".",
"GetRemoteClusterIp",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"SdkClusterPairCreateResponse",
"{",
"Result",
":",
"resp",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Create a new cluster with remote pair
|
[
"Create",
"a",
"new",
"cluster",
"with",
"remote",
"pair"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/cluster_pair.go#L39-L60
|
144,178 |
libopenstorage/openstorage
|
api/server/sdk/cluster_pair.go
|
Inspect
|
func (s *ClusterPairServer) Inspect(
ctx context.Context,
req *api.SdkClusterPairInspectRequest,
) (*api.SdkClusterPairInspectResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply cluster ID")
}
resp, err := s.cluster().GetPair(req.GetId())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot Get cluster information for %s : %v", req.GetId(), err)
}
return &api.SdkClusterPairInspectResponse{
Result: resp,
}, nil
}
|
go
|
func (s *ClusterPairServer) Inspect(
ctx context.Context,
req *api.SdkClusterPairInspectRequest,
) (*api.SdkClusterPairInspectResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply cluster ID")
}
resp, err := s.cluster().GetPair(req.GetId())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot Get cluster information for %s : %v", req.GetId(), err)
}
return &api.SdkClusterPairInspectResponse{
Result: resp,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"ClusterPairServer",
")",
"Inspect",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkClusterPairInspectRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkClusterPairInspectResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"resp",
",",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"GetPair",
"(",
"req",
".",
"GetId",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetId",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"api",
".",
"SdkClusterPairInspectResponse",
"{",
"Result",
":",
"resp",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Inspect information about a cluster pair
|
[
"Inspect",
"information",
"about",
"a",
"cluster",
"pair"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/cluster_pair.go#L63-L81
|
144,179 |
libopenstorage/openstorage
|
api/server/sdk/cluster_pair.go
|
Enumerate
|
func (s *ClusterPairServer) Enumerate(
ctx context.Context,
req *api.SdkClusterPairEnumerateRequest,
) (*api.SdkClusterPairEnumerateResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
resp, err := s.cluster().EnumeratePairs()
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot list cluster pairs : %v", err)
}
return &api.SdkClusterPairEnumerateResponse{
Result: resp,
}, nil
}
|
go
|
func (s *ClusterPairServer) Enumerate(
ctx context.Context,
req *api.SdkClusterPairEnumerateRequest,
) (*api.SdkClusterPairEnumerateResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
resp, err := s.cluster().EnumeratePairs()
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot list cluster pairs : %v", err)
}
return &api.SdkClusterPairEnumerateResponse{
Result: resp,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"ClusterPairServer",
")",
"Enumerate",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkClusterPairEnumerateRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkClusterPairEnumerateResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"EnumeratePairs",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"api",
".",
"SdkClusterPairEnumerateResponse",
"{",
"Result",
":",
"resp",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Enumerate returns list of cluster pairs
|
[
"Enumerate",
"returns",
"list",
"of",
"cluster",
"pairs"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/cluster_pair.go#L84-L99
|
144,180 |
libopenstorage/openstorage
|
api/server/sdk/cluster_pair.go
|
GetToken
|
func (s *ClusterPairServer) GetToken(
ctx context.Context,
req *api.SdkClusterPairGetTokenRequest,
) (*api.SdkClusterPairGetTokenResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
// Check if admin user - only system.admin can get cluster pair tokens
if userInfo, ok := auth.NewUserInfoFromContext(ctx); ok {
o := api.Ownership{}
if !o.IsAdminByUser(userInfo) {
return nil, status.Error(codes.Unauthenticated, "Must be system admin to get pair token")
}
}
resp, err := s.cluster().GetPairToken(false)
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot generate token: %v", err)
}
return &api.SdkClusterPairGetTokenResponse{
Result: resp,
}, nil
}
|
go
|
func (s *ClusterPairServer) GetToken(
ctx context.Context,
req *api.SdkClusterPairGetTokenRequest,
) (*api.SdkClusterPairGetTokenResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
// Check if admin user - only system.admin can get cluster pair tokens
if userInfo, ok := auth.NewUserInfoFromContext(ctx); ok {
o := api.Ownership{}
if !o.IsAdminByUser(userInfo) {
return nil, status.Error(codes.Unauthenticated, "Must be system admin to get pair token")
}
}
resp, err := s.cluster().GetPairToken(false)
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot generate token: %v", err)
}
return &api.SdkClusterPairGetTokenResponse{
Result: resp,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"ClusterPairServer",
")",
"GetToken",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkClusterPairGetTokenRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkClusterPairGetTokenResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check if admin user - only system.admin can get cluster pair tokens",
"if",
"userInfo",
",",
"ok",
":=",
"auth",
".",
"NewUserInfoFromContext",
"(",
"ctx",
")",
";",
"ok",
"{",
"o",
":=",
"api",
".",
"Ownership",
"{",
"}",
"\n",
"if",
"!",
"o",
".",
"IsAdminByUser",
"(",
"userInfo",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unauthenticated",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"GetPairToken",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"api",
".",
"SdkClusterPairGetTokenResponse",
"{",
"Result",
":",
"resp",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// GetToken gets the authentication token for this cluster
|
[
"GetToken",
"gets",
"the",
"authentication",
"token",
"for",
"this",
"cluster"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/cluster_pair.go#L102-L125
|
144,181 |
libopenstorage/openstorage
|
api/server/sdk/cluster_pair.go
|
ResetToken
|
func (s *ClusterPairServer) ResetToken(
ctx context.Context,
req *api.SdkClusterPairResetTokenRequest,
) (*api.SdkClusterPairResetTokenResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
resp, err := s.cluster().GetPairToken(true)
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot generate token: %v", err)
}
return &api.SdkClusterPairResetTokenResponse{
Result: resp,
}, nil
}
|
go
|
func (s *ClusterPairServer) ResetToken(
ctx context.Context,
req *api.SdkClusterPairResetTokenRequest,
) (*api.SdkClusterPairResetTokenResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
resp, err := s.cluster().GetPairToken(true)
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot generate token: %v", err)
}
return &api.SdkClusterPairResetTokenResponse{
Result: resp,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"ClusterPairServer",
")",
"ResetToken",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkClusterPairResetTokenRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkClusterPairResetTokenResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"GetPairToken",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"api",
".",
"SdkClusterPairResetTokenResponse",
"{",
"Result",
":",
"resp",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// ResetToken gets the authentication token for this cluster
|
[
"ResetToken",
"gets",
"the",
"authentication",
"token",
"for",
"this",
"cluster"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/cluster_pair.go#L128-L143
|
144,182 |
libopenstorage/openstorage
|
api/server/sdk/cluster_pair.go
|
Delete
|
func (s *ClusterPairServer) Delete(
ctx context.Context,
req *api.SdkClusterPairDeleteRequest,
) (*api.SdkClusterPairDeleteResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetClusterId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply valid cluster ID")
}
err := s.cluster().DeletePair(req.GetClusterId())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot delete the cluster pair %s : %v", req.GetClusterId(), err)
}
return &api.SdkClusterPairDeleteResponse{}, nil
}
|
go
|
func (s *ClusterPairServer) Delete(
ctx context.Context,
req *api.SdkClusterPairDeleteRequest,
) (*api.SdkClusterPairDeleteResponse, error) {
if s.cluster() == nil {
return nil, status.Error(codes.Unavailable, "Resource has not been initialized")
}
if len(req.GetClusterId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Must supply valid cluster ID")
}
err := s.cluster().DeletePair(req.GetClusterId())
if err != nil {
return nil, status.Errorf(codes.Internal, "Cannot delete the cluster pair %s : %v", req.GetClusterId(), err)
}
return &api.SdkClusterPairDeleteResponse{}, nil
}
|
[
"func",
"(",
"s",
"*",
"ClusterPairServer",
")",
"Delete",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"api",
".",
"SdkClusterPairDeleteRequest",
",",
")",
"(",
"*",
"api",
".",
"SdkClusterPairDeleteResponse",
",",
"error",
")",
"{",
"if",
"s",
".",
"cluster",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"req",
".",
"GetClusterId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"cluster",
"(",
")",
".",
"DeletePair",
"(",
"req",
".",
"GetClusterId",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetClusterId",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"api",
".",
"SdkClusterPairDeleteResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// Delete removes the cluster pairing
|
[
"Delete",
"removes",
"the",
"cluster",
"pairing"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/cluster_pair.go#L146-L162
|
144,183 |
libopenstorage/openstorage
|
cluster/cluster_not_supported.go
|
Inspect
|
func (m *NullClusterManager) Inspect(arg0 string) (api.Node, error) {
return api.Node{}, ErrNotImplemented
}
|
go
|
func (m *NullClusterManager) Inspect(arg0 string) (api.Node, error) {
return api.Node{}, ErrNotImplemented
}
|
[
"func",
"(",
"m",
"*",
"NullClusterManager",
")",
"Inspect",
"(",
"arg0",
"string",
")",
"(",
"api",
".",
"Node",
",",
"error",
")",
"{",
"return",
"api",
".",
"Node",
"{",
"}",
",",
"ErrNotImplemented",
"\n",
"}"
] |
// NullClusterManager implementations
// Inspect
|
[
"NullClusterManager",
"implementations",
"Inspect"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cluster/cluster_not_supported.go#L78-L80
|
144,184 |
libopenstorage/openstorage
|
cluster/cluster_not_supported.go
|
Remove
|
func (m *NullClusterRemove) Remove(arg0 []api.Node, arg1 bool) error {
return ErrNotImplemented
}
|
go
|
func (m *NullClusterRemove) Remove(arg0 []api.Node, arg1 bool) error {
return ErrNotImplemented
}
|
[
"func",
"(",
"m",
"*",
"NullClusterRemove",
")",
"Remove",
"(",
"arg0",
"[",
"]",
"api",
".",
"Node",
",",
"arg1",
"bool",
")",
"error",
"{",
"return",
"ErrNotImplemented",
"\n",
"}"
] |
// NullClusterRemove implementations
// Remove
|
[
"NullClusterRemove",
"implementations",
"Remove"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cluster/cluster_not_supported.go#L169-L171
|
144,185 |
libopenstorage/openstorage
|
cluster/cluster_not_supported.go
|
EnumerateAlerts
|
func (m *NullClusterAlerts) EnumerateAlerts(arg0, arg1 time.Time, arg2 api.ResourceType) (*api.Alerts, error) {
return nil, ErrNotImplemented
}
|
go
|
func (m *NullClusterAlerts) EnumerateAlerts(arg0, arg1 time.Time, arg2 api.ResourceType) (*api.Alerts, error) {
return nil, ErrNotImplemented
}
|
[
"func",
"(",
"m",
"*",
"NullClusterAlerts",
")",
"EnumerateAlerts",
"(",
"arg0",
",",
"arg1",
"time",
".",
"Time",
",",
"arg2",
"api",
".",
"ResourceType",
")",
"(",
"*",
"api",
".",
"Alerts",
",",
"error",
")",
"{",
"return",
"nil",
",",
"ErrNotImplemented",
"\n",
"}"
] |
// NullClusterAlerts implementations
// EnumerateAlerts
|
[
"NullClusterAlerts",
"implementations",
"EnumerateAlerts"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cluster/cluster_not_supported.go#L193-L195
|
144,186 |
libopenstorage/openstorage
|
cluster/cluster_not_supported.go
|
CreatePair
|
func (m *NullClusterPair) CreatePair(arg0 *api.ClusterPairCreateRequest) (*api.ClusterPairCreateResponse, error) {
return nil, ErrNotImplemented
}
|
go
|
func (m *NullClusterPair) CreatePair(arg0 *api.ClusterPairCreateRequest) (*api.ClusterPairCreateResponse, error) {
return nil, ErrNotImplemented
}
|
[
"func",
"(",
"m",
"*",
"NullClusterPair",
")",
"CreatePair",
"(",
"arg0",
"*",
"api",
".",
"ClusterPairCreateRequest",
")",
"(",
"*",
"api",
".",
"ClusterPairCreateResponse",
",",
"error",
")",
"{",
"return",
"nil",
",",
"ErrNotImplemented",
"\n",
"}"
] |
// NullClusterPair implementations
// CreatePair
|
[
"NullClusterPair",
"implementations",
"CreatePair"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cluster/cluster_not_supported.go#L205-L207
|
144,187 |
libopenstorage/openstorage
|
csi/controller.go
|
ControllerExpandVolume
|
func (s *OsdCsiServer) ControllerExpandVolume(
ctx context.Context,
req *csi.ControllerExpandVolumeRequest,
) (*csi.ControllerExpandVolumeResponse, error) {
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Volume id must be provided")
} else if req.GetCapacityRange() == nil {
return nil, status.Error(codes.InvalidArgument, "Capacity range must be provided")
} else if req.GetCapacityRange().GetRequiredBytes() < 0 || req.GetCapacityRange().GetLimitBytes() < 0 {
return nil, status.Error(codes.InvalidArgument, "Capacity ranges values cannot be negative")
}
// Get Size
spec := &api.VolumeSpecUpdate{}
newSize := uint64(req.GetCapacityRange().GetRequiredBytes())
spec.SizeOpt = &api.VolumeSpecUpdate_Size{
Size: newSize,
}
// Get grpc connection
conn, err := s.getConn()
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to connect to SDK server: %v", err)
}
// Get secret if any was passed
ctx = s.setupContextWithToken(ctx, req.GetSecrets())
// If the new size is greater than the current size, a volume update
// should be issued. Otherwise, no operation should occur.
volumes := api.NewOpenStorageVolumeClient(conn)
// Update volume with new size
_, err = volumes.Update(ctx, &api.SdkVolumeUpdateRequest{
VolumeId: req.GetVolumeId(),
Spec: spec,
})
if err != nil {
if err == kvdb.ErrNotFound {
return nil, status.Errorf(codes.NotFound, "Volume id %s not found", req.GetVolumeId())
}
return nil, status.Errorf(codes.Internal, "Failed to update volume size: %v", err)
}
return &csi.ControllerExpandVolumeResponse{
CapacityBytes: int64(newSize),
NodeExpansionRequired: false,
}, nil
}
|
go
|
func (s *OsdCsiServer) ControllerExpandVolume(
ctx context.Context,
req *csi.ControllerExpandVolumeRequest,
) (*csi.ControllerExpandVolumeResponse, error) {
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Volume id must be provided")
} else if req.GetCapacityRange() == nil {
return nil, status.Error(codes.InvalidArgument, "Capacity range must be provided")
} else if req.GetCapacityRange().GetRequiredBytes() < 0 || req.GetCapacityRange().GetLimitBytes() < 0 {
return nil, status.Error(codes.InvalidArgument, "Capacity ranges values cannot be negative")
}
// Get Size
spec := &api.VolumeSpecUpdate{}
newSize := uint64(req.GetCapacityRange().GetRequiredBytes())
spec.SizeOpt = &api.VolumeSpecUpdate_Size{
Size: newSize,
}
// Get grpc connection
conn, err := s.getConn()
if err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to connect to SDK server: %v", err)
}
// Get secret if any was passed
ctx = s.setupContextWithToken(ctx, req.GetSecrets())
// If the new size is greater than the current size, a volume update
// should be issued. Otherwise, no operation should occur.
volumes := api.NewOpenStorageVolumeClient(conn)
// Update volume with new size
_, err = volumes.Update(ctx, &api.SdkVolumeUpdateRequest{
VolumeId: req.GetVolumeId(),
Spec: spec,
})
if err != nil {
if err == kvdb.ErrNotFound {
return nil, status.Errorf(codes.NotFound, "Volume id %s not found", req.GetVolumeId())
}
return nil, status.Errorf(codes.Internal, "Failed to update volume size: %v", err)
}
return &csi.ControllerExpandVolumeResponse{
CapacityBytes: int64(newSize),
NodeExpansionRequired: false,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"OsdCsiServer",
")",
"ControllerExpandVolume",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"csi",
".",
"ControllerExpandVolumeRequest",
",",
")",
"(",
"*",
"csi",
".",
"ControllerExpandVolumeResponse",
",",
"error",
")",
"{",
"if",
"len",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"req",
".",
"GetCapacityRange",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"req",
".",
"GetCapacityRange",
"(",
")",
".",
"GetRequiredBytes",
"(",
")",
"<",
"0",
"||",
"req",
".",
"GetCapacityRange",
"(",
")",
".",
"GetLimitBytes",
"(",
")",
"<",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get Size",
"spec",
":=",
"&",
"api",
".",
"VolumeSpecUpdate",
"{",
"}",
"\n",
"newSize",
":=",
"uint64",
"(",
"req",
".",
"GetCapacityRange",
"(",
")",
".",
"GetRequiredBytes",
"(",
")",
")",
"\n",
"spec",
".",
"SizeOpt",
"=",
"&",
"api",
".",
"VolumeSpecUpdate_Size",
"{",
"Size",
":",
"newSize",
",",
"}",
"\n\n",
"// Get grpc connection",
"conn",
",",
"err",
":=",
"s",
".",
"getConn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Get secret if any was passed",
"ctx",
"=",
"s",
".",
"setupContextWithToken",
"(",
"ctx",
",",
"req",
".",
"GetSecrets",
"(",
")",
")",
"\n\n",
"// If the new size is greater than the current size, a volume update",
"// should be issued. Otherwise, no operation should occur.",
"volumes",
":=",
"api",
".",
"NewOpenStorageVolumeClient",
"(",
"conn",
")",
"\n\n",
"// Update volume with new size",
"_",
",",
"err",
"=",
"volumes",
".",
"Update",
"(",
"ctx",
",",
"&",
"api",
".",
"SdkVolumeUpdateRequest",
"{",
"VolumeId",
":",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"Spec",
":",
"spec",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"kvdb",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"csi",
".",
"ControllerExpandVolumeResponse",
"{",
"CapacityBytes",
":",
"int64",
"(",
"newSize",
")",
",",
"NodeExpansionRequired",
":",
"false",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// ControllerExpandVolume is a CSI API which resizes a volume
|
[
"ControllerExpandVolume",
"is",
"a",
"CSI",
"API",
"which",
"resizes",
"a",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/controller.go#L396-L446
|
144,188 |
libopenstorage/openstorage
|
cli/drivers.go
|
DriverCommands
|
func DriverCommands() []cli.Command {
commands := []cli.Command{
{
Name: "add",
Aliases: []string{"a"},
Usage: "add a new driver",
Action: driverAdd,
Flags: []cli.Flag{
cli.StringFlag{
Name: "name,n",
Usage: "Driver Name",
},
cli.StringFlag{
Name: "options,o",
Usage: "Comma separated name=value pairs, e.g disk=/dev/xvdg,mount=/var/openstorage/btrfs",
},
},
},
{
Name: "list",
Aliases: []string{"l"},
Usage: "List drivers",
Action: driverList,
},
}
return commands
}
|
go
|
func DriverCommands() []cli.Command {
commands := []cli.Command{
{
Name: "add",
Aliases: []string{"a"},
Usage: "add a new driver",
Action: driverAdd,
Flags: []cli.Flag{
cli.StringFlag{
Name: "name,n",
Usage: "Driver Name",
},
cli.StringFlag{
Name: "options,o",
Usage: "Comma separated name=value pairs, e.g disk=/dev/xvdg,mount=/var/openstorage/btrfs",
},
},
},
{
Name: "list",
Aliases: []string{"l"},
Usage: "List drivers",
Action: driverList,
},
}
return commands
}
|
[
"func",
"DriverCommands",
"(",
")",
"[",
"]",
"cli",
".",
"Command",
"{",
"commands",
":=",
"[",
"]",
"cli",
".",
"Command",
"{",
"{",
"Name",
":",
"\"",
"\"",
",",
"Aliases",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"Usage",
":",
"\"",
"\"",
",",
"Action",
":",
"driverAdd",
",",
"Flags",
":",
"[",
"]",
"cli",
".",
"Flag",
"{",
"cli",
".",
"StringFlag",
"{",
"Name",
":",
"\"",
"\"",
",",
"Usage",
":",
"\"",
"\"",
",",
"}",
",",
"cli",
".",
"StringFlag",
"{",
"Name",
":",
"\"",
"\"",
",",
"Usage",
":",
"\"",
"\"",
",",
"}",
",",
"}",
",",
"}",
",",
"{",
"Name",
":",
"\"",
"\"",
",",
"Aliases",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"Usage",
":",
"\"",
"\"",
",",
"Action",
":",
"driverList",
",",
"}",
",",
"}",
"\n",
"return",
"commands",
"\n",
"}"
] |
// DriverCommands exports the list of CLI driver subcommands.
|
[
"DriverCommands",
"exports",
"the",
"list",
"of",
"CLI",
"driver",
"subcommands",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/cli/drivers.go#L14-L40
|
144,189 |
libopenstorage/openstorage
|
volume/drivers/buse/buse.go
|
Init
|
func Init(params map[string]string) (volume.VolumeDriver, error) {
nbdInit()
inst := &driver{
IODriver: volume.IONotSupported,
StoreEnumerator: common.NewDefaultStoreEnumerator(Name,
kvdb.Instance()),
StatsDriver: volume.StatsNotSupported,
QuiesceDriver: volume.QuiesceNotSupported,
CredsDriver: volume.CredsNotSupported,
CloudBackupDriver: volume.CloudBackupNotSupported,
CloudMigrateDriver: volume.CloudMigrateNotSupported,
}
inst.buseDevices = make(map[string]*buseDev)
if err := os.MkdirAll(BuseMountPath, 0744); err != nil {
return nil, err
}
volumeInfo, err := inst.StoreEnumerator.Enumerate(
&api.VolumeLocator{},
nil,
)
if err == nil {
for _, info := range volumeInfo {
if info.Status == api.VolumeStatus_VOLUME_STATUS_NONE {
info.Status = api.VolumeStatus_VOLUME_STATUS_UP
inst.UpdateVol(info)
}
}
} else {
logrus.Println("Could not enumerate Volumes, ", err)
}
inst.cl = &clusterListener{}
c, err := clustermanager.Inst()
if err != nil {
logrus.Println("BUSE initializing in single node mode")
} else {
logrus.Println("BUSE initializing in clustered mode")
c.AddEventListener(inst.cl)
}
logrus.Println("BUSE initialized and driver mounted at: ", BuseMountPath)
return inst, nil
}
|
go
|
func Init(params map[string]string) (volume.VolumeDriver, error) {
nbdInit()
inst := &driver{
IODriver: volume.IONotSupported,
StoreEnumerator: common.NewDefaultStoreEnumerator(Name,
kvdb.Instance()),
StatsDriver: volume.StatsNotSupported,
QuiesceDriver: volume.QuiesceNotSupported,
CredsDriver: volume.CredsNotSupported,
CloudBackupDriver: volume.CloudBackupNotSupported,
CloudMigrateDriver: volume.CloudMigrateNotSupported,
}
inst.buseDevices = make(map[string]*buseDev)
if err := os.MkdirAll(BuseMountPath, 0744); err != nil {
return nil, err
}
volumeInfo, err := inst.StoreEnumerator.Enumerate(
&api.VolumeLocator{},
nil,
)
if err == nil {
for _, info := range volumeInfo {
if info.Status == api.VolumeStatus_VOLUME_STATUS_NONE {
info.Status = api.VolumeStatus_VOLUME_STATUS_UP
inst.UpdateVol(info)
}
}
} else {
logrus.Println("Could not enumerate Volumes, ", err)
}
inst.cl = &clusterListener{}
c, err := clustermanager.Inst()
if err != nil {
logrus.Println("BUSE initializing in single node mode")
} else {
logrus.Println("BUSE initializing in clustered mode")
c.AddEventListener(inst.cl)
}
logrus.Println("BUSE initialized and driver mounted at: ", BuseMountPath)
return inst, nil
}
|
[
"func",
"Init",
"(",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"volume",
".",
"VolumeDriver",
",",
"error",
")",
"{",
"nbdInit",
"(",
")",
"\n\n",
"inst",
":=",
"&",
"driver",
"{",
"IODriver",
":",
"volume",
".",
"IONotSupported",
",",
"StoreEnumerator",
":",
"common",
".",
"NewDefaultStoreEnumerator",
"(",
"Name",
",",
"kvdb",
".",
"Instance",
"(",
")",
")",
",",
"StatsDriver",
":",
"volume",
".",
"StatsNotSupported",
",",
"QuiesceDriver",
":",
"volume",
".",
"QuiesceNotSupported",
",",
"CredsDriver",
":",
"volume",
".",
"CredsNotSupported",
",",
"CloudBackupDriver",
":",
"volume",
".",
"CloudBackupNotSupported",
",",
"CloudMigrateDriver",
":",
"volume",
".",
"CloudMigrateNotSupported",
",",
"}",
"\n",
"inst",
".",
"buseDevices",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"buseDev",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"BuseMountPath",
",",
"0744",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"volumeInfo",
",",
"err",
":=",
"inst",
".",
"StoreEnumerator",
".",
"Enumerate",
"(",
"&",
"api",
".",
"VolumeLocator",
"{",
"}",
",",
"nil",
",",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"for",
"_",
",",
"info",
":=",
"range",
"volumeInfo",
"{",
"if",
"info",
".",
"Status",
"==",
"api",
".",
"VolumeStatus_VOLUME_STATUS_NONE",
"{",
"info",
".",
"Status",
"=",
"api",
".",
"VolumeStatus_VOLUME_STATUS_UP",
"\n",
"inst",
".",
"UpdateVol",
"(",
"info",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"logrus",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"inst",
".",
"cl",
"=",
"&",
"clusterListener",
"{",
"}",
"\n",
"c",
",",
"err",
":=",
"clustermanager",
".",
"Inst",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"logrus",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"c",
".",
"AddEventListener",
"(",
"inst",
".",
"cl",
")",
"\n",
"}",
"\n\n",
"logrus",
".",
"Println",
"(",
"\"",
"\"",
",",
"BuseMountPath",
")",
"\n",
"return",
"inst",
",",
"nil",
"\n",
"}"
] |
// Init intialized the buse driver
|
[
"Init",
"intialized",
"the",
"buse",
"driver"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/buse.go#L94-L137
|
144,190 |
libopenstorage/openstorage
|
pkg/mount/deleted_mount.go
|
NewDeletedMounter
|
func NewDeletedMounter(
rootSubstring string,
mountImpl MountImpl,
) (*deletedMounter, error) {
devMounter, err := NewDeviceMounter([]string{"/dev/"}, mountImpl, nil, "")
if err != nil {
return nil, err
}
deletedMounts := make(DeviceMap)
for k, v := range devMounter.mounts {
if matchDeleted(rootSubstring, k) {
deletedMounts[k] = v
} else {
for _, p := range v.Mountpoint {
if matchDeleted(rootSubstring, p.Root) {
addMountpoint(deletedMounts, k, p)
}
}
}
}
devMounter.mounts = deletedMounts
return &deletedMounter{deviceMounter: devMounter}, nil
}
|
go
|
func NewDeletedMounter(
rootSubstring string,
mountImpl MountImpl,
) (*deletedMounter, error) {
devMounter, err := NewDeviceMounter([]string{"/dev/"}, mountImpl, nil, "")
if err != nil {
return nil, err
}
deletedMounts := make(DeviceMap)
for k, v := range devMounter.mounts {
if matchDeleted(rootSubstring, k) {
deletedMounts[k] = v
} else {
for _, p := range v.Mountpoint {
if matchDeleted(rootSubstring, p.Root) {
addMountpoint(deletedMounts, k, p)
}
}
}
}
devMounter.mounts = deletedMounts
return &deletedMounter{deviceMounter: devMounter}, nil
}
|
[
"func",
"NewDeletedMounter",
"(",
"rootSubstring",
"string",
",",
"mountImpl",
"MountImpl",
",",
")",
"(",
"*",
"deletedMounter",
",",
"error",
")",
"{",
"devMounter",
",",
"err",
":=",
"NewDeviceMounter",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"mountImpl",
",",
"nil",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"deletedMounts",
":=",
"make",
"(",
"DeviceMap",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"devMounter",
".",
"mounts",
"{",
"if",
"matchDeleted",
"(",
"rootSubstring",
",",
"k",
")",
"{",
"deletedMounts",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"else",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"v",
".",
"Mountpoint",
"{",
"if",
"matchDeleted",
"(",
"rootSubstring",
",",
"p",
".",
"Root",
")",
"{",
"addMountpoint",
"(",
"deletedMounts",
",",
"k",
",",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"devMounter",
".",
"mounts",
"=",
"deletedMounts",
"\n",
"return",
"&",
"deletedMounter",
"{",
"deviceMounter",
":",
"devMounter",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDeletedMounter returns a new deletedMounter
|
[
"NewDeletedMounter",
"returns",
"a",
"new",
"deletedMounter"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/mount/deleted_mount.go#L23-L46
|
144,191 |
libopenstorage/openstorage
|
pkg/mount/deleted_mount.go
|
Unmount
|
func (m *deletedMounter) Unmount(
sourcePath string,
path string,
flags int,
timeout int,
opts map[string]string,
) error {
if sourcePath != AllDevices {
return fmt.Errorf("DeletedMounter accepts only %v as sourcePath",
AllDevices)
}
m.Lock()
defer m.Unlock()
failedUnmounts := make(DeviceMap)
for k, v := range m.mounts {
for _, p := range v.Mountpoint {
logrus.Warnf("Unmounting deleted mount path %v->%v", k, p)
if err := m.mountImpl.Unmount(p.Path, flags, timeout); err != nil {
logrus.Warnf("Failed to unmount mount path %v->%v", k, p)
addMountpoint(failedUnmounts, k, p)
}
}
}
m.mounts = failedUnmounts
if len(m.mounts) > 0 {
return fmt.Errorf("Not all paths could be unmounted")
}
return nil
}
|
go
|
func (m *deletedMounter) Unmount(
sourcePath string,
path string,
flags int,
timeout int,
opts map[string]string,
) error {
if sourcePath != AllDevices {
return fmt.Errorf("DeletedMounter accepts only %v as sourcePath",
AllDevices)
}
m.Lock()
defer m.Unlock()
failedUnmounts := make(DeviceMap)
for k, v := range m.mounts {
for _, p := range v.Mountpoint {
logrus.Warnf("Unmounting deleted mount path %v->%v", k, p)
if err := m.mountImpl.Unmount(p.Path, flags, timeout); err != nil {
logrus.Warnf("Failed to unmount mount path %v->%v", k, p)
addMountpoint(failedUnmounts, k, p)
}
}
}
m.mounts = failedUnmounts
if len(m.mounts) > 0 {
return fmt.Errorf("Not all paths could be unmounted")
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"deletedMounter",
")",
"Unmount",
"(",
"sourcePath",
"string",
",",
"path",
"string",
",",
"flags",
"int",
",",
"timeout",
"int",
",",
"opts",
"map",
"[",
"string",
"]",
"string",
",",
")",
"error",
"{",
"if",
"sourcePath",
"!=",
"AllDevices",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"AllDevices",
")",
"\n",
"}",
"\n\n",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"failedUnmounts",
":=",
"make",
"(",
"DeviceMap",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"m",
".",
"mounts",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"v",
".",
"Mountpoint",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"k",
",",
"p",
")",
"\n",
"if",
"err",
":=",
"m",
".",
"mountImpl",
".",
"Unmount",
"(",
"p",
".",
"Path",
",",
"flags",
",",
"timeout",
")",
";",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"k",
",",
"p",
")",
"\n",
"addMountpoint",
"(",
"failedUnmounts",
",",
"k",
",",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"m",
".",
"mounts",
"=",
"failedUnmounts",
"\n",
"if",
"len",
"(",
"m",
".",
"mounts",
")",
">",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Unmount all deleted mounts.
|
[
"Unmount",
"all",
"deleted",
"mounts",
"."
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/mount/deleted_mount.go#L66-L97
|
144,192 |
libopenstorage/openstorage
|
volume/drivers/fake/fake.go
|
CloudBackupCreate
|
func (d *driver) CloudBackupCreate(
input *api.CloudBackupCreateRequest,
) (*api.CloudBackupCreateResponse, error) {
name, _, err := d.cloudBackupCreate(input)
if err == nil {
resp := &api.CloudBackupCreateResponse{Name: name}
return resp, err
}
return nil, err
}
|
go
|
func (d *driver) CloudBackupCreate(
input *api.CloudBackupCreateRequest,
) (*api.CloudBackupCreateResponse, error) {
name, _, err := d.cloudBackupCreate(input)
if err == nil {
resp := &api.CloudBackupCreateResponse{Name: name}
return resp, err
}
return nil, err
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"CloudBackupCreate",
"(",
"input",
"*",
"api",
".",
"CloudBackupCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"CloudBackupCreateResponse",
",",
"error",
")",
"{",
"name",
",",
"_",
",",
"err",
":=",
"d",
".",
"cloudBackupCreate",
"(",
"input",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"resp",
":=",
"&",
"api",
".",
"CloudBackupCreateResponse",
"{",
"Name",
":",
"name",
"}",
"\n",
"return",
"resp",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}"
] |
// CloudBackupCreate uploads snapshot of a volume to the cloud
|
[
"CloudBackupCreate",
"uploads",
"snapshot",
"of",
"a",
"volume",
"to",
"the",
"cloud"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/fake/fake.go#L465-L474
|
144,193 |
libopenstorage/openstorage
|
volume/drivers/fake/fake.go
|
cloudBackupCreate
|
func (d *driver) cloudBackupCreate(input *api.CloudBackupCreateRequest) (string, string, error) {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return "", "", err
}
// Get volume info
vols, err := d.Inspect([]string{input.VolumeID})
if err != nil {
return "", "", fmt.Errorf("Volume id not found")
}
if len(vols) < 1 {
return "", "", fmt.Errorf("Internal error. Volume found but no data returned")
}
vol := vols[0]
if vol.GetSpec() == nil {
return "", "", fmt.Errorf("Internal error. Volume has no specificiation")
}
taskId := uuid.New()
// Save cloud backup
cloudId := uuid.New()
clusterInfo, err := d.thisCluster.Enumerate()
if err != nil {
return "", "", err
}
_, err = d.kv.Put(backupsKeyPrefix+"/"+taskId, &fakeBackups{
Volume: *vol,
ClusterId: clusterInfo.Id,
Status: api.CloudBackupStatus{
ID: cloudId,
OpType: api.CloudBackupOp,
Status: api.CloudBackupStatusDone,
BytesDone: vol.GetSpec().GetSize(),
StartTime: time.Now(),
CompletedTime: time.Now().Local().Add(1 * time.Second),
NodeID: clusterInfo.NodeId,
CredentialUUID: input.CredentialUUID,
SrcVolumeID: input.VolumeID,
},
Info: api.CloudBackupInfo{
ID: cloudId,
SrcVolumeID: input.VolumeID,
SrcVolumeName: vol.GetLocator().GetName(),
Timestamp: time.Now(),
Metadata: map[string]string{
"fake": "backup",
},
Status: string(api.CloudBackupStatusDone),
},
}, 0)
if err != nil {
return "", "", err
}
return taskId, cloudId, nil
}
|
go
|
func (d *driver) cloudBackupCreate(input *api.CloudBackupCreateRequest) (string, string, error) {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return "", "", err
}
// Get volume info
vols, err := d.Inspect([]string{input.VolumeID})
if err != nil {
return "", "", fmt.Errorf("Volume id not found")
}
if len(vols) < 1 {
return "", "", fmt.Errorf("Internal error. Volume found but no data returned")
}
vol := vols[0]
if vol.GetSpec() == nil {
return "", "", fmt.Errorf("Internal error. Volume has no specificiation")
}
taskId := uuid.New()
// Save cloud backup
cloudId := uuid.New()
clusterInfo, err := d.thisCluster.Enumerate()
if err != nil {
return "", "", err
}
_, err = d.kv.Put(backupsKeyPrefix+"/"+taskId, &fakeBackups{
Volume: *vol,
ClusterId: clusterInfo.Id,
Status: api.CloudBackupStatus{
ID: cloudId,
OpType: api.CloudBackupOp,
Status: api.CloudBackupStatusDone,
BytesDone: vol.GetSpec().GetSize(),
StartTime: time.Now(),
CompletedTime: time.Now().Local().Add(1 * time.Second),
NodeID: clusterInfo.NodeId,
CredentialUUID: input.CredentialUUID,
SrcVolumeID: input.VolumeID,
},
Info: api.CloudBackupInfo{
ID: cloudId,
SrcVolumeID: input.VolumeID,
SrcVolumeName: vol.GetLocator().GetName(),
Timestamp: time.Now(),
Metadata: map[string]string{
"fake": "backup",
},
Status: string(api.CloudBackupStatusDone),
},
}, 0)
if err != nil {
return "", "", err
}
return taskId, cloudId, nil
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"cloudBackupCreate",
"(",
"input",
"*",
"api",
".",
"CloudBackupCreateRequest",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"// Confirm credential id",
"if",
"err",
":=",
"d",
".",
"CredsValidate",
"(",
"input",
".",
"CredentialUUID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// Get volume info",
"vols",
",",
"err",
":=",
"d",
".",
"Inspect",
"(",
"[",
"]",
"string",
"{",
"input",
".",
"VolumeID",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"vols",
")",
"<",
"1",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"vol",
":=",
"vols",
"[",
"0",
"]",
"\n",
"if",
"vol",
".",
"GetSpec",
"(",
")",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"taskId",
":=",
"uuid",
".",
"New",
"(",
")",
"\n",
"// Save cloud backup",
"cloudId",
":=",
"uuid",
".",
"New",
"(",
")",
"\n",
"clusterInfo",
",",
"err",
":=",
"d",
".",
"thisCluster",
".",
"Enumerate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"d",
".",
"kv",
".",
"Put",
"(",
"backupsKeyPrefix",
"+",
"\"",
"\"",
"+",
"taskId",
",",
"&",
"fakeBackups",
"{",
"Volume",
":",
"*",
"vol",
",",
"ClusterId",
":",
"clusterInfo",
".",
"Id",
",",
"Status",
":",
"api",
".",
"CloudBackupStatus",
"{",
"ID",
":",
"cloudId",
",",
"OpType",
":",
"api",
".",
"CloudBackupOp",
",",
"Status",
":",
"api",
".",
"CloudBackupStatusDone",
",",
"BytesDone",
":",
"vol",
".",
"GetSpec",
"(",
")",
".",
"GetSize",
"(",
")",
",",
"StartTime",
":",
"time",
".",
"Now",
"(",
")",
",",
"CompletedTime",
":",
"time",
".",
"Now",
"(",
")",
".",
"Local",
"(",
")",
".",
"Add",
"(",
"1",
"*",
"time",
".",
"Second",
")",
",",
"NodeID",
":",
"clusterInfo",
".",
"NodeId",
",",
"CredentialUUID",
":",
"input",
".",
"CredentialUUID",
",",
"SrcVolumeID",
":",
"input",
".",
"VolumeID",
",",
"}",
",",
"Info",
":",
"api",
".",
"CloudBackupInfo",
"{",
"ID",
":",
"cloudId",
",",
"SrcVolumeID",
":",
"input",
".",
"VolumeID",
",",
"SrcVolumeName",
":",
"vol",
".",
"GetLocator",
"(",
")",
".",
"GetName",
"(",
")",
",",
"Timestamp",
":",
"time",
".",
"Now",
"(",
")",
",",
"Metadata",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
",",
"Status",
":",
"string",
"(",
"api",
".",
"CloudBackupStatusDone",
")",
",",
"}",
",",
"}",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"taskId",
",",
"cloudId",
",",
"nil",
"\n",
"}"
] |
// cloudBackupCreate uploads snapshot of a volume to the cloud and returns the
// backup task id
|
[
"cloudBackupCreate",
"uploads",
"snapshot",
"of",
"a",
"volume",
"to",
"the",
"cloud",
"and",
"returns",
"the",
"backup",
"task",
"id"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/fake/fake.go#L478-L534
|
144,194 |
libopenstorage/openstorage
|
volume/drivers/fake/fake.go
|
CloudBackupRestore
|
func (d *driver) CloudBackupRestore(
input *api.CloudBackupRestoreRequest,
) (*api.CloudBackupRestoreResponse, error) {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return nil, err
}
backup, _, err := d.backupEntry(input.ID, api.CloudBackupOp)
if err != nil {
return nil, err
}
volid, err := d.Create(&api.VolumeLocator{Name: input.RestoreVolumeName}, &api.Source{}, backup.Volume.GetSpec())
if err != nil {
return nil, err
}
vols, err := d.Inspect([]string{volid})
if err != nil {
return nil, fmt.Errorf("Volume id not found")
}
if len(vols) < 1 {
return nil, fmt.Errorf("Internal error. Volume found but no data returned")
}
vol := vols[0]
if vol.GetSpec() == nil {
return nil, fmt.Errorf("Internal error. Volume has no specificiation")
}
cloudId := uuid.New()
clusterInfo, err := d.thisCluster.Enumerate()
if err != nil {
return nil, err
}
_, err = d.kv.Put(backupsKeyPrefix+"/"+cloudId, &fakeBackups{
Volume: *vol,
ClusterId: clusterInfo.Id,
Status: api.CloudBackupStatus{
ID: cloudId,
OpType: api.CloudRestoreOp,
Status: api.CloudBackupStatusDone,
BytesDone: vol.GetSpec().GetSize(),
StartTime: time.Now(),
CompletedTime: time.Now().Local().Add(1 * time.Second),
NodeID: clusterInfo.NodeId,
CredentialUUID: input.CredentialUUID,
SrcVolumeID: volid,
},
}, 0)
if err != nil {
return nil, err
}
return &api.CloudBackupRestoreResponse{
RestoreVolumeID: volid,
}, nil
}
|
go
|
func (d *driver) CloudBackupRestore(
input *api.CloudBackupRestoreRequest,
) (*api.CloudBackupRestoreResponse, error) {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return nil, err
}
backup, _, err := d.backupEntry(input.ID, api.CloudBackupOp)
if err != nil {
return nil, err
}
volid, err := d.Create(&api.VolumeLocator{Name: input.RestoreVolumeName}, &api.Source{}, backup.Volume.GetSpec())
if err != nil {
return nil, err
}
vols, err := d.Inspect([]string{volid})
if err != nil {
return nil, fmt.Errorf("Volume id not found")
}
if len(vols) < 1 {
return nil, fmt.Errorf("Internal error. Volume found but no data returned")
}
vol := vols[0]
if vol.GetSpec() == nil {
return nil, fmt.Errorf("Internal error. Volume has no specificiation")
}
cloudId := uuid.New()
clusterInfo, err := d.thisCluster.Enumerate()
if err != nil {
return nil, err
}
_, err = d.kv.Put(backupsKeyPrefix+"/"+cloudId, &fakeBackups{
Volume: *vol,
ClusterId: clusterInfo.Id,
Status: api.CloudBackupStatus{
ID: cloudId,
OpType: api.CloudRestoreOp,
Status: api.CloudBackupStatusDone,
BytesDone: vol.GetSpec().GetSize(),
StartTime: time.Now(),
CompletedTime: time.Now().Local().Add(1 * time.Second),
NodeID: clusterInfo.NodeId,
CredentialUUID: input.CredentialUUID,
SrcVolumeID: volid,
},
}, 0)
if err != nil {
return nil, err
}
return &api.CloudBackupRestoreResponse{
RestoreVolumeID: volid,
}, nil
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"CloudBackupRestore",
"(",
"input",
"*",
"api",
".",
"CloudBackupRestoreRequest",
",",
")",
"(",
"*",
"api",
".",
"CloudBackupRestoreResponse",
",",
"error",
")",
"{",
"// Confirm credential id",
"if",
"err",
":=",
"d",
".",
"CredsValidate",
"(",
"input",
".",
"CredentialUUID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"backup",
",",
"_",
",",
"err",
":=",
"d",
".",
"backupEntry",
"(",
"input",
".",
"ID",
",",
"api",
".",
"CloudBackupOp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"volid",
",",
"err",
":=",
"d",
".",
"Create",
"(",
"&",
"api",
".",
"VolumeLocator",
"{",
"Name",
":",
"input",
".",
"RestoreVolumeName",
"}",
",",
"&",
"api",
".",
"Source",
"{",
"}",
",",
"backup",
".",
"Volume",
".",
"GetSpec",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"vols",
",",
"err",
":=",
"d",
".",
"Inspect",
"(",
"[",
"]",
"string",
"{",
"volid",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"vols",
")",
"<",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"vol",
":=",
"vols",
"[",
"0",
"]",
"\n",
"if",
"vol",
".",
"GetSpec",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cloudId",
":=",
"uuid",
".",
"New",
"(",
")",
"\n",
"clusterInfo",
",",
"err",
":=",
"d",
".",
"thisCluster",
".",
"Enumerate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"d",
".",
"kv",
".",
"Put",
"(",
"backupsKeyPrefix",
"+",
"\"",
"\"",
"+",
"cloudId",
",",
"&",
"fakeBackups",
"{",
"Volume",
":",
"*",
"vol",
",",
"ClusterId",
":",
"clusterInfo",
".",
"Id",
",",
"Status",
":",
"api",
".",
"CloudBackupStatus",
"{",
"ID",
":",
"cloudId",
",",
"OpType",
":",
"api",
".",
"CloudRestoreOp",
",",
"Status",
":",
"api",
".",
"CloudBackupStatusDone",
",",
"BytesDone",
":",
"vol",
".",
"GetSpec",
"(",
")",
".",
"GetSize",
"(",
")",
",",
"StartTime",
":",
"time",
".",
"Now",
"(",
")",
",",
"CompletedTime",
":",
"time",
".",
"Now",
"(",
")",
".",
"Local",
"(",
")",
".",
"Add",
"(",
"1",
"*",
"time",
".",
"Second",
")",
",",
"NodeID",
":",
"clusterInfo",
".",
"NodeId",
",",
"CredentialUUID",
":",
"input",
".",
"CredentialUUID",
",",
"SrcVolumeID",
":",
"volid",
",",
"}",
",",
"}",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"CloudBackupRestoreResponse",
"{",
"RestoreVolumeID",
":",
"volid",
",",
"}",
",",
"nil",
"\n\n",
"}"
] |
// CloudBackupRestore downloads a cloud backup and restores it to a volume
|
[
"CloudBackupRestore",
"downloads",
"a",
"cloud",
"backup",
"and",
"restores",
"it",
"to",
"a",
"volume"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/fake/fake.go#L565-L622
|
144,195 |
libopenstorage/openstorage
|
volume/drivers/fake/fake.go
|
CloudBackupDelete
|
func (d *driver) CloudBackupDelete(input *api.CloudBackupDeleteRequest) error {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return err
}
_, id, err := d.backupEntry(input.ID, api.CloudBackupOp)
if err != nil {
return err
}
//_, err := d.kv.Delete(backupsKeyPrefix + "/" + id)
_, err = d.kv.Delete(id)
return err
}
|
go
|
func (d *driver) CloudBackupDelete(input *api.CloudBackupDeleteRequest) error {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return err
}
_, id, err := d.backupEntry(input.ID, api.CloudBackupOp)
if err != nil {
return err
}
//_, err := d.kv.Delete(backupsKeyPrefix + "/" + id)
_, err = d.kv.Delete(id)
return err
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"CloudBackupDelete",
"(",
"input",
"*",
"api",
".",
"CloudBackupDeleteRequest",
")",
"error",
"{",
"// Confirm credential id",
"if",
"err",
":=",
"d",
".",
"CredsValidate",
"(",
"input",
".",
"CredentialUUID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"id",
",",
"err",
":=",
"d",
".",
"backupEntry",
"(",
"input",
".",
"ID",
",",
"api",
".",
"CloudBackupOp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"//_, err := d.kv.Delete(backupsKeyPrefix + \"/\" + id)",
"_",
",",
"err",
"=",
"d",
".",
"kv",
".",
"Delete",
"(",
"id",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// CloudBackupDelete deletes the specified backup in cloud
|
[
"CloudBackupDelete",
"deletes",
"the",
"specified",
"backup",
"in",
"cloud"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/fake/fake.go#L625-L639
|
144,196 |
libopenstorage/openstorage
|
volume/drivers/fake/fake.go
|
CloudBackupDeleteAll
|
func (d *driver) CloudBackupDeleteAll(input *api.CloudBackupDeleteAllRequest) error {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return err
}
// Get volume info
if len(input.SrcVolumeID) != 0 {
vols, err := d.Inspect([]string{input.SrcVolumeID})
if err != nil {
return fmt.Errorf("Volume id not found")
}
if len(vols) < 1 {
return fmt.Errorf("Internal error. Volume found but no data returned")
}
vol := vols[0]
if vol.GetSpec() == nil {
return fmt.Errorf("Internal error. Volume has no specificiation")
}
}
kvp, err := d.kv.Enumerate(backupsKeyPrefix)
if err != nil {
return err
}
for _, v := range kvp {
elem := &fakeBackups{}
if err := json.Unmarshal(v.Value, elem); err != nil {
return err
}
if elem.Status.OpType == api.CloudRestoreOp {
continue
}
if len(input.SrcVolumeID) == 0 && len(input.ClusterID) == 0 {
_, err = d.kv.Delete(v.Key)
} else if input.SrcVolumeID == elem.Volume.GetId() {
_, err = d.kv.Delete(v.Key)
} else if input.ClusterID == elem.ClusterId {
_, err = d.kv.Delete(v.Key)
}
if err != nil {
return err
}
}
return nil
}
|
go
|
func (d *driver) CloudBackupDeleteAll(input *api.CloudBackupDeleteAllRequest) error {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return err
}
// Get volume info
if len(input.SrcVolumeID) != 0 {
vols, err := d.Inspect([]string{input.SrcVolumeID})
if err != nil {
return fmt.Errorf("Volume id not found")
}
if len(vols) < 1 {
return fmt.Errorf("Internal error. Volume found but no data returned")
}
vol := vols[0]
if vol.GetSpec() == nil {
return fmt.Errorf("Internal error. Volume has no specificiation")
}
}
kvp, err := d.kv.Enumerate(backupsKeyPrefix)
if err != nil {
return err
}
for _, v := range kvp {
elem := &fakeBackups{}
if err := json.Unmarshal(v.Value, elem); err != nil {
return err
}
if elem.Status.OpType == api.CloudRestoreOp {
continue
}
if len(input.SrcVolumeID) == 0 && len(input.ClusterID) == 0 {
_, err = d.kv.Delete(v.Key)
} else if input.SrcVolumeID == elem.Volume.GetId() {
_, err = d.kv.Delete(v.Key)
} else if input.ClusterID == elem.ClusterId {
_, err = d.kv.Delete(v.Key)
}
if err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"CloudBackupDeleteAll",
"(",
"input",
"*",
"api",
".",
"CloudBackupDeleteAllRequest",
")",
"error",
"{",
"// Confirm credential id",
"if",
"err",
":=",
"d",
".",
"CredsValidate",
"(",
"input",
".",
"CredentialUUID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Get volume info",
"if",
"len",
"(",
"input",
".",
"SrcVolumeID",
")",
"!=",
"0",
"{",
"vols",
",",
"err",
":=",
"d",
".",
"Inspect",
"(",
"[",
"]",
"string",
"{",
"input",
".",
"SrcVolumeID",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"vols",
")",
"<",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"vol",
":=",
"vols",
"[",
"0",
"]",
"\n",
"if",
"vol",
".",
"GetSpec",
"(",
")",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"kvp",
",",
"err",
":=",
"d",
".",
"kv",
".",
"Enumerate",
"(",
"backupsKeyPrefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"kvp",
"{",
"elem",
":=",
"&",
"fakeBackups",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"v",
".",
"Value",
",",
"elem",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"elem",
".",
"Status",
".",
"OpType",
"==",
"api",
".",
"CloudRestoreOp",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"len",
"(",
"input",
".",
"SrcVolumeID",
")",
"==",
"0",
"&&",
"len",
"(",
"input",
".",
"ClusterID",
")",
"==",
"0",
"{",
"_",
",",
"err",
"=",
"d",
".",
"kv",
".",
"Delete",
"(",
"v",
".",
"Key",
")",
"\n",
"}",
"else",
"if",
"input",
".",
"SrcVolumeID",
"==",
"elem",
".",
"Volume",
".",
"GetId",
"(",
")",
"{",
"_",
",",
"err",
"=",
"d",
".",
"kv",
".",
"Delete",
"(",
"v",
".",
"Key",
")",
"\n",
"}",
"else",
"if",
"input",
".",
"ClusterID",
"==",
"elem",
".",
"ClusterId",
"{",
"_",
",",
"err",
"=",
"d",
".",
"kv",
".",
"Delete",
"(",
"v",
".",
"Key",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// CloudBackupDelete deletes all the backups for a given volume in cloud
|
[
"CloudBackupDelete",
"deletes",
"all",
"the",
"backups",
"for",
"a",
"given",
"volume",
"in",
"cloud"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/fake/fake.go#L678-L724
|
144,197 |
libopenstorage/openstorage
|
volume/drivers/fake/fake.go
|
CloudBackupSchedCreate
|
func (d *driver) CloudBackupSchedCreate(
input *api.CloudBackupSchedCreateRequest,
) (*api.CloudBackupSchedCreateResponse, error) {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return nil, err
}
// Check volume
vols, err := d.Inspect([]string{input.SrcVolumeID})
if err != nil {
return nil, fmt.Errorf("Volume id not found")
}
if len(vols) < 1 {
return nil, fmt.Errorf("Internal error. Volume found but no data returned")
}
vol := vols[0]
if vol.GetSpec() == nil {
return nil, fmt.Errorf("Internal error. Volume has no specificiation")
}
id := uuid.New()
_, err = d.kv.Put(schedPrefix+"/"+id, &fakeSchedules{
Id: id,
Info: api.CloudBackupScheduleInfo{
SrcVolumeID: input.SrcVolumeID,
CredentialUUID: input.CredentialUUID,
Schedule: input.Schedule,
MaxBackups: input.MaxBackups,
},
}, 0)
if err != nil {
return nil, err
}
return &api.CloudBackupSchedCreateResponse{
UUID: id,
}, nil
}
|
go
|
func (d *driver) CloudBackupSchedCreate(
input *api.CloudBackupSchedCreateRequest,
) (*api.CloudBackupSchedCreateResponse, error) {
// Confirm credential id
if err := d.CredsValidate(input.CredentialUUID); err != nil {
return nil, err
}
// Check volume
vols, err := d.Inspect([]string{input.SrcVolumeID})
if err != nil {
return nil, fmt.Errorf("Volume id not found")
}
if len(vols) < 1 {
return nil, fmt.Errorf("Internal error. Volume found but no data returned")
}
vol := vols[0]
if vol.GetSpec() == nil {
return nil, fmt.Errorf("Internal error. Volume has no specificiation")
}
id := uuid.New()
_, err = d.kv.Put(schedPrefix+"/"+id, &fakeSchedules{
Id: id,
Info: api.CloudBackupScheduleInfo{
SrcVolumeID: input.SrcVolumeID,
CredentialUUID: input.CredentialUUID,
Schedule: input.Schedule,
MaxBackups: input.MaxBackups,
},
}, 0)
if err != nil {
return nil, err
}
return &api.CloudBackupSchedCreateResponse{
UUID: id,
}, nil
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"CloudBackupSchedCreate",
"(",
"input",
"*",
"api",
".",
"CloudBackupSchedCreateRequest",
",",
")",
"(",
"*",
"api",
".",
"CloudBackupSchedCreateResponse",
",",
"error",
")",
"{",
"// Confirm credential id",
"if",
"err",
":=",
"d",
".",
"CredsValidate",
"(",
"input",
".",
"CredentialUUID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Check volume",
"vols",
",",
"err",
":=",
"d",
".",
"Inspect",
"(",
"[",
"]",
"string",
"{",
"input",
".",
"SrcVolumeID",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"vols",
")",
"<",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"vol",
":=",
"vols",
"[",
"0",
"]",
"\n",
"if",
"vol",
".",
"GetSpec",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"id",
":=",
"uuid",
".",
"New",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"d",
".",
"kv",
".",
"Put",
"(",
"schedPrefix",
"+",
"\"",
"\"",
"+",
"id",
",",
"&",
"fakeSchedules",
"{",
"Id",
":",
"id",
",",
"Info",
":",
"api",
".",
"CloudBackupScheduleInfo",
"{",
"SrcVolumeID",
":",
"input",
".",
"SrcVolumeID",
",",
"CredentialUUID",
":",
"input",
".",
"CredentialUUID",
",",
"Schedule",
":",
"input",
".",
"Schedule",
",",
"MaxBackups",
":",
"input",
".",
"MaxBackups",
",",
"}",
",",
"}",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"CloudBackupSchedCreateResponse",
"{",
"UUID",
":",
"id",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// CloudBackupSchedCreate creates a schedule backup volume to cloud
|
[
"CloudBackupSchedCreate",
"creates",
"a",
"schedule",
"backup",
"volume",
"to",
"cloud"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/fake/fake.go#L876-L915
|
144,198 |
libopenstorage/openstorage
|
volume/drivers/fake/fake.go
|
CloudBackupSchedDelete
|
func (d *driver) CloudBackupSchedDelete(input *api.CloudBackupSchedDeleteRequest) error {
d.kv.Delete(schedPrefix + "/" + input.UUID)
return nil
}
|
go
|
func (d *driver) CloudBackupSchedDelete(input *api.CloudBackupSchedDeleteRequest) error {
d.kv.Delete(schedPrefix + "/" + input.UUID)
return nil
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"CloudBackupSchedDelete",
"(",
"input",
"*",
"api",
".",
"CloudBackupSchedDeleteRequest",
")",
"error",
"{",
"d",
".",
"kv",
".",
"Delete",
"(",
"schedPrefix",
"+",
"\"",
"\"",
"+",
"input",
".",
"UUID",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CloudBackupSchedDelete delete a volume backup schedule to cloud
|
[
"CloudBackupSchedDelete",
"delete",
"a",
"volume",
"backup",
"schedule",
"to",
"cloud"
] |
71b7f37f99c70e697aa31ca57fa8fb1404629329
|
https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/fake/fake.go#L918-L921
|
144,199 |
libopenstorage/openstorage
|
volume/drivers/fake/fake.go
|
CloudBackupSchedEnumerate
|
func (d *driver) CloudBackupSchedEnumerate() (*api.CloudBackupSchedEnumerateResponse, error) {
kvp, err := d.kv.Enumerate(schedPrefix)
if err != nil {
return nil, err
}
schedules := make(map[string]api.CloudBackupScheduleInfo, len(kvp))
for _, v := range kvp {
elem := &fakeSchedules{}
if err := json.Unmarshal(v.Value, elem); err != nil {
return nil, err
}
schedules[elem.Id] = elem.Info
}
return &api.CloudBackupSchedEnumerateResponse{
Schedules: schedules,
}, nil
}
|
go
|
func (d *driver) CloudBackupSchedEnumerate() (*api.CloudBackupSchedEnumerateResponse, error) {
kvp, err := d.kv.Enumerate(schedPrefix)
if err != nil {
return nil, err
}
schedules := make(map[string]api.CloudBackupScheduleInfo, len(kvp))
for _, v := range kvp {
elem := &fakeSchedules{}
if err := json.Unmarshal(v.Value, elem); err != nil {
return nil, err
}
schedules[elem.Id] = elem.Info
}
return &api.CloudBackupSchedEnumerateResponse{
Schedules: schedules,
}, nil
}
|
[
"func",
"(",
"d",
"*",
"driver",
")",
"CloudBackupSchedEnumerate",
"(",
")",
"(",
"*",
"api",
".",
"CloudBackupSchedEnumerateResponse",
",",
"error",
")",
"{",
"kvp",
",",
"err",
":=",
"d",
".",
"kv",
".",
"Enumerate",
"(",
"schedPrefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"schedules",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"api",
".",
"CloudBackupScheduleInfo",
",",
"len",
"(",
"kvp",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"kvp",
"{",
"elem",
":=",
"&",
"fakeSchedules",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"v",
".",
"Value",
",",
"elem",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"schedules",
"[",
"elem",
".",
"Id",
"]",
"=",
"elem",
".",
"Info",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"CloudBackupSchedEnumerateResponse",
"{",
"Schedules",
":",
"schedules",
",",
"}",
",",
"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/volume/drivers/fake/fake.go#L924-L941
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.