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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
libopenstorage/openstorage | api/client/volume/client.go | CloudBackupSchedEnumerate | func (v *volumeClient) CloudBackupSchedEnumerate() (*api.CloudBackupSchedEnumerateResponse, error) {
enumerateResponse := &api.CloudBackupSchedEnumerateResponse{}
req := v.c.Get().Resource(api.OsdBackupPath + "/sched")
response := req.Do()
if response.Error() != nil {
return nil, response.FormatError()
}
if err := response.Unmarshal(enumerateResponse); err != nil {
return nil, err
}
return enumerateResponse, nil
} | go | func (v *volumeClient) CloudBackupSchedEnumerate() (*api.CloudBackupSchedEnumerateResponse, error) {
enumerateResponse := &api.CloudBackupSchedEnumerateResponse{}
req := v.c.Get().Resource(api.OsdBackupPath + "/sched")
response := req.Do()
if response.Error() != nil {
return nil, response.FormatError()
}
if err := response.Unmarshal(enumerateResponse); err != nil {
return nil, err
}
return enumerateResponse, nil
} | [
"func",
"(",
"v",
"*",
"volumeClient",
")",
"CloudBackupSchedEnumerate",
"(",
")",
"(",
"*",
"api",
".",
"CloudBackupSchedEnumerateResponse",
",",
"error",
")",
"{",
"enumerateResponse",
":=",
"&",
"api",
".",
"CloudBackupSchedEnumerateResponse",
"{",
"}",
"\n",
"req",
":=",
"v",
".",
"c",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"api",
".",
"OsdBackupPath",
"+",
"\"",
"\"",
")",
"\n",
"response",
":=",
"req",
".",
"Do",
"(",
")",
"\n",
"if",
"response",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"response",
".",
"FormatError",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"response",
".",
"Unmarshal",
"(",
"enumerateResponse",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"enumerateResponse",
",",
"nil",
"\n",
"}"
] | // CloudBackupSchedEnumerate enumerates the configured backup-schedules in the cluster | [
"CloudBackupSchedEnumerate",
"enumerates",
"the",
"configured",
"backup",
"-",
"schedules",
"in",
"the",
"cluster"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/client/volume/client.go#L734-L745 | train |
libopenstorage/openstorage | pkg/auth/systemtoken/systemtoken.go | NewManager | func NewManager(cfg *Config) (auth.TokenGenerator, error) {
if cfg == nil ||
len(cfg.ClusterId) == 0 ||
len(cfg.NodeId) == 0 ||
len(cfg.SharedSecret) == 0 {
return nil, fmt.Errorf("Must supply claims, clusterUuid, nodeId, and system secret")
}
claims := &auth.Claims{
Issuer: cfg.ClusterId,
Subject: cfg.NodeId,
Name: "Internal cluster communication",
Email: "support@openstorage.io",
Roles: []string{"system.admin"},
Groups: []string{"*"},
}
return &manager{
config: cfg,
claims: claims,
}, nil
} | go | func NewManager(cfg *Config) (auth.TokenGenerator, error) {
if cfg == nil ||
len(cfg.ClusterId) == 0 ||
len(cfg.NodeId) == 0 ||
len(cfg.SharedSecret) == 0 {
return nil, fmt.Errorf("Must supply claims, clusterUuid, nodeId, and system secret")
}
claims := &auth.Claims{
Issuer: cfg.ClusterId,
Subject: cfg.NodeId,
Name: "Internal cluster communication",
Email: "support@openstorage.io",
Roles: []string{"system.admin"},
Groups: []string{"*"},
}
return &manager{
config: cfg,
claims: claims,
}, nil
} | [
"func",
"NewManager",
"(",
"cfg",
"*",
"Config",
")",
"(",
"auth",
".",
"TokenGenerator",
",",
"error",
")",
"{",
"if",
"cfg",
"==",
"nil",
"||",
"len",
"(",
"cfg",
".",
"ClusterId",
")",
"==",
"0",
"||",
"len",
"(",
"cfg",
".",
"NodeId",
")",
"==",
"0",
"||",
"len",
"(",
"cfg",
".",
"SharedSecret",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"claims",
":=",
"&",
"auth",
".",
"Claims",
"{",
"Issuer",
":",
"cfg",
".",
"ClusterId",
",",
"Subject",
":",
"cfg",
".",
"NodeId",
",",
"Name",
":",
"\"",
"\"",
",",
"Email",
":",
"\"",
"\"",
",",
"Roles",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"Groups",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"}",
"\n\n",
"return",
"&",
"manager",
"{",
"config",
":",
"cfg",
",",
"claims",
":",
"claims",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewManager initializes the system token generator | [
"NewManager",
"initializes",
"the",
"system",
"token",
"generator"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/systemtoken/systemtoken.go#L27-L48 | train |
libopenstorage/openstorage | pkg/auth/systemtoken/systemtoken.go | GetAuthenticator | func (m *manager) GetAuthenticator() (auth.Authenticator, error) {
return auth.NewJwtAuth(&auth.JwtAuthConfig{
SharedSecret: []byte(m.config.SharedSecret),
})
} | go | func (m *manager) GetAuthenticator() (auth.Authenticator, error) {
return auth.NewJwtAuth(&auth.JwtAuthConfig{
SharedSecret: []byte(m.config.SharedSecret),
})
} | [
"func",
"(",
"m",
"*",
"manager",
")",
"GetAuthenticator",
"(",
")",
"(",
"auth",
".",
"Authenticator",
",",
"error",
")",
"{",
"return",
"auth",
".",
"NewJwtAuth",
"(",
"&",
"auth",
".",
"JwtAuthConfig",
"{",
"SharedSecret",
":",
"[",
"]",
"byte",
"(",
"m",
".",
"config",
".",
"SharedSecret",
")",
",",
"}",
")",
"\n",
"}"
] | // GetAuthenticator returns an authenticator for this issuer used by the SDK | [
"GetAuthenticator",
"returns",
"an",
"authenticator",
"for",
"this",
"issuer",
"used",
"by",
"the",
"SDK"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/systemtoken/systemtoken.go#L57-L61 | train |
libopenstorage/openstorage | pkg/auth/systemtoken/systemtoken.go | GetToken | func (m *manager) GetToken(opts *auth.Options) (string, error) {
signature, err := auth.NewSignatureSharedSecret(m.config.SharedSecret)
if err != nil {
return "", err
}
return auth.Token(m.claims, signature, opts)
} | go | func (m *manager) GetToken(opts *auth.Options) (string, error) {
signature, err := auth.NewSignatureSharedSecret(m.config.SharedSecret)
if err != nil {
return "", err
}
return auth.Token(m.claims, signature, opts)
} | [
"func",
"(",
"m",
"*",
"manager",
")",
"GetToken",
"(",
"opts",
"*",
"auth",
".",
"Options",
")",
"(",
"string",
",",
"error",
")",
"{",
"signature",
",",
"err",
":=",
"auth",
".",
"NewSignatureSharedSecret",
"(",
"m",
".",
"config",
".",
"SharedSecret",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"auth",
".",
"Token",
"(",
"m",
".",
"claims",
",",
"signature",
",",
"opts",
")",
"\n",
"}"
] | // GetToken returns a token which can be used for
// authentication and communication from node to node. | [
"GetToken",
"returns",
"a",
"token",
"which",
"can",
"be",
"used",
"for",
"authentication",
"and",
"communication",
"from",
"node",
"to",
"node",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/systemtoken/systemtoken.go#L65-L72 | train |
libopenstorage/openstorage | api/server/sdk/rest_gateway.go | restServerSetupHandlers | func (s *sdkRestGateway) restServerSetupHandlers() (http.Handler, error) {
// Create an HTTP server router
mux := http.NewServeMux()
// Swagger files using packr
swaggerUIBox := packr.NewBox("./swagger-ui")
swaggerJSONBox := packr.NewBox("./api")
mime.AddExtensionType(".svg", "image/svg+xml")
// Handler to return swagger.json
mux.HandleFunc("/swagger.json", func(w http.ResponseWriter, r *http.Request) {
w.Write(swaggerJSONBox.Bytes("api.swagger.json"))
})
// Handler to access the swagger ui. The UI pulls the swagger
// json file from /swagger.json
// The link below MUST have th last '/'. It is really important.
// This link is deprecated
prefix := "/swagger-ui/"
mux.Handle(prefix,
http.StripPrefix(prefix, http.FileServer(swaggerUIBox)))
// This is the new location
prefix = "/sdk/"
mux.Handle(prefix,
http.StripPrefix(prefix, http.FileServer(swaggerUIBox)))
// Create a router just for HTTP REST gRPC Server Gateway
gmux := runtime.NewServeMux()
// Connect to gRPC unix domain socket
conn, err := grpcserver.Connect(
s.grpcServer.Address(),
[]grpc.DialOption{grpc.WithInsecure()})
if err != nil {
return nil, fmt.Errorf("Failed to connect to gRPC handler: %v", err)
}
// REST Gateway Handlers
handlers := []func(context.Context, *runtime.ServeMux, *grpc.ClientConn) (err error){
api.RegisterOpenStorageClusterHandler,
api.RegisterOpenStorageNodeHandler,
api.RegisterOpenStorageVolumeHandler,
api.RegisterOpenStorageObjectstoreHandler,
api.RegisterOpenStorageCredentialsHandler,
api.RegisterOpenStorageSchedulePolicyHandler,
api.RegisterOpenStorageCloudBackupHandler,
api.RegisterOpenStorageIdentityHandler,
api.RegisterOpenStorageMountAttachHandler,
api.RegisterOpenStorageAlertsHandler,
api.RegisterOpenStorageClusterPairHandler,
api.RegisterOpenStorageMigrateHandler,
api.RegisterOpenStorageRoleHandler,
api.RegisterOpenStoragePolicyHandler,
}
// Register the REST Gateway handlers
for _, handler := range handlers {
err := handler(context.Background(), gmux, conn)
if err != nil {
return nil, err
}
}
// Pass all other unhandled paths to the gRPC gateway
mux.Handle("/", gmux)
// Enable cors
c := cors.New(cors.Options{
AllowedOrigins: []string{"*"},
AllowedMethods: []string{"GET", "POST", "DELETE", "HEAD", "PUT", "OPTIONS"},
AllowCredentials: true,
})
cmux := c.Handler(mux)
return cmux, nil
} | go | func (s *sdkRestGateway) restServerSetupHandlers() (http.Handler, error) {
// Create an HTTP server router
mux := http.NewServeMux()
// Swagger files using packr
swaggerUIBox := packr.NewBox("./swagger-ui")
swaggerJSONBox := packr.NewBox("./api")
mime.AddExtensionType(".svg", "image/svg+xml")
// Handler to return swagger.json
mux.HandleFunc("/swagger.json", func(w http.ResponseWriter, r *http.Request) {
w.Write(swaggerJSONBox.Bytes("api.swagger.json"))
})
// Handler to access the swagger ui. The UI pulls the swagger
// json file from /swagger.json
// The link below MUST have th last '/'. It is really important.
// This link is deprecated
prefix := "/swagger-ui/"
mux.Handle(prefix,
http.StripPrefix(prefix, http.FileServer(swaggerUIBox)))
// This is the new location
prefix = "/sdk/"
mux.Handle(prefix,
http.StripPrefix(prefix, http.FileServer(swaggerUIBox)))
// Create a router just for HTTP REST gRPC Server Gateway
gmux := runtime.NewServeMux()
// Connect to gRPC unix domain socket
conn, err := grpcserver.Connect(
s.grpcServer.Address(),
[]grpc.DialOption{grpc.WithInsecure()})
if err != nil {
return nil, fmt.Errorf("Failed to connect to gRPC handler: %v", err)
}
// REST Gateway Handlers
handlers := []func(context.Context, *runtime.ServeMux, *grpc.ClientConn) (err error){
api.RegisterOpenStorageClusterHandler,
api.RegisterOpenStorageNodeHandler,
api.RegisterOpenStorageVolumeHandler,
api.RegisterOpenStorageObjectstoreHandler,
api.RegisterOpenStorageCredentialsHandler,
api.RegisterOpenStorageSchedulePolicyHandler,
api.RegisterOpenStorageCloudBackupHandler,
api.RegisterOpenStorageIdentityHandler,
api.RegisterOpenStorageMountAttachHandler,
api.RegisterOpenStorageAlertsHandler,
api.RegisterOpenStorageClusterPairHandler,
api.RegisterOpenStorageMigrateHandler,
api.RegisterOpenStorageRoleHandler,
api.RegisterOpenStoragePolicyHandler,
}
// Register the REST Gateway handlers
for _, handler := range handlers {
err := handler(context.Background(), gmux, conn)
if err != nil {
return nil, err
}
}
// Pass all other unhandled paths to the gRPC gateway
mux.Handle("/", gmux)
// Enable cors
c := cors.New(cors.Options{
AllowedOrigins: []string{"*"},
AllowedMethods: []string{"GET", "POST", "DELETE", "HEAD", "PUT", "OPTIONS"},
AllowCredentials: true,
})
cmux := c.Handler(mux)
return cmux, nil
} | [
"func",
"(",
"s",
"*",
"sdkRestGateway",
")",
"restServerSetupHandlers",
"(",
")",
"(",
"http",
".",
"Handler",
",",
"error",
")",
"{",
"// Create an HTTP server router",
"mux",
":=",
"http",
".",
"NewServeMux",
"(",
")",
"\n\n",
"// Swagger files using packr",
"swaggerUIBox",
":=",
"packr",
".",
"NewBox",
"(",
"\"",
"\"",
")",
"\n",
"swaggerJSONBox",
":=",
"packr",
".",
"NewBox",
"(",
"\"",
"\"",
")",
"\n",
"mime",
".",
"AddExtensionType",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"// Handler to return swagger.json",
"mux",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"w",
".",
"Write",
"(",
"swaggerJSONBox",
".",
"Bytes",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
")",
"\n\n",
"// Handler to access the swagger ui. The UI pulls the swagger",
"// json file from /swagger.json",
"// The link below MUST have th last '/'. It is really important.",
"// This link is deprecated",
"prefix",
":=",
"\"",
"\"",
"\n",
"mux",
".",
"Handle",
"(",
"prefix",
",",
"http",
".",
"StripPrefix",
"(",
"prefix",
",",
"http",
".",
"FileServer",
"(",
"swaggerUIBox",
")",
")",
")",
"\n",
"// This is the new location",
"prefix",
"=",
"\"",
"\"",
"\n",
"mux",
".",
"Handle",
"(",
"prefix",
",",
"http",
".",
"StripPrefix",
"(",
"prefix",
",",
"http",
".",
"FileServer",
"(",
"swaggerUIBox",
")",
")",
")",
"\n\n",
"// Create a router just for HTTP REST gRPC Server Gateway",
"gmux",
":=",
"runtime",
".",
"NewServeMux",
"(",
")",
"\n\n",
"// Connect to gRPC unix domain socket",
"conn",
",",
"err",
":=",
"grpcserver",
".",
"Connect",
"(",
"s",
".",
"grpcServer",
".",
"Address",
"(",
")",
",",
"[",
"]",
"grpc",
".",
"DialOption",
"{",
"grpc",
".",
"WithInsecure",
"(",
")",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// REST Gateway Handlers",
"handlers",
":=",
"[",
"]",
"func",
"(",
"context",
".",
"Context",
",",
"*",
"runtime",
".",
"ServeMux",
",",
"*",
"grpc",
".",
"ClientConn",
")",
"(",
"err",
"error",
")",
"{",
"api",
".",
"RegisterOpenStorageClusterHandler",
",",
"api",
".",
"RegisterOpenStorageNodeHandler",
",",
"api",
".",
"RegisterOpenStorageVolumeHandler",
",",
"api",
".",
"RegisterOpenStorageObjectstoreHandler",
",",
"api",
".",
"RegisterOpenStorageCredentialsHandler",
",",
"api",
".",
"RegisterOpenStorageSchedulePolicyHandler",
",",
"api",
".",
"RegisterOpenStorageCloudBackupHandler",
",",
"api",
".",
"RegisterOpenStorageIdentityHandler",
",",
"api",
".",
"RegisterOpenStorageMountAttachHandler",
",",
"api",
".",
"RegisterOpenStorageAlertsHandler",
",",
"api",
".",
"RegisterOpenStorageClusterPairHandler",
",",
"api",
".",
"RegisterOpenStorageMigrateHandler",
",",
"api",
".",
"RegisterOpenStorageRoleHandler",
",",
"api",
".",
"RegisterOpenStoragePolicyHandler",
",",
"}",
"\n\n",
"// Register the REST Gateway handlers",
"for",
"_",
",",
"handler",
":=",
"range",
"handlers",
"{",
"err",
":=",
"handler",
"(",
"context",
".",
"Background",
"(",
")",
",",
"gmux",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Pass all other unhandled paths to the gRPC gateway",
"mux",
".",
"Handle",
"(",
"\"",
"\"",
",",
"gmux",
")",
"\n\n",
"// Enable cors",
"c",
":=",
"cors",
".",
"New",
"(",
"cors",
".",
"Options",
"{",
"AllowedOrigins",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"AllowedMethods",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"AllowCredentials",
":",
"true",
",",
"}",
")",
"\n",
"cmux",
":=",
"c",
".",
"Handler",
"(",
"mux",
")",
"\n",
"return",
"cmux",
",",
"nil",
"\n",
"}"
] | // restServerSetupHandlers sets up the handlers to the swagger ui and
// to the gRPC REST Gateway. | [
"restServerSetupHandlers",
"sets",
"up",
"the",
"handlers",
"to",
"the",
"swagger",
"ui",
"and",
"to",
"the",
"gRPC",
"REST",
"Gateway",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/sdk/rest_gateway.go#L94-L169 | train |
libopenstorage/openstorage | pkg/seed/git.go | Load | func (g *Git) Load(dest string) error {
g.ready = false
cmd := exec.Command("git", "clone", g.host, dest)
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("'wd: %s git clone %s': %s: %s", dest, g.host, output, err)
}
if len(g.revision) == 0 {
g.ready = true
return nil
}
cmd = exec.Command("git", "checkout", g.revision)
cmd.Dir = dest
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("wd %v 'git checkout %s': %s: %s", cmd.Dir, g.revision, output, err)
}
cmd = exec.Command("git", "reset", "--hard")
cmd.Dir = dest
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("wd %v 'git reset --hard %s': %s: %s", cmd.Dir, g.revision, output, err)
}
g.ready = true
return nil
} | go | func (g *Git) Load(dest string) error {
g.ready = false
cmd := exec.Command("git", "clone", g.host, dest)
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("'wd: %s git clone %s': %s: %s", dest, g.host, output, err)
}
if len(g.revision) == 0 {
g.ready = true
return nil
}
cmd = exec.Command("git", "checkout", g.revision)
cmd.Dir = dest
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("wd %v 'git checkout %s': %s: %s", cmd.Dir, g.revision, output, err)
}
cmd = exec.Command("git", "reset", "--hard")
cmd.Dir = dest
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("wd %v 'git reset --hard %s': %s: %s", cmd.Dir, g.revision, output, err)
}
g.ready = true
return nil
} | [
"func",
"(",
"g",
"*",
"Git",
")",
"Load",
"(",
"dest",
"string",
")",
"error",
"{",
"g",
".",
"ready",
"=",
"false",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"g",
".",
"host",
",",
"dest",
")",
"\n\n",
"if",
"output",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"dest",
",",
"g",
".",
"host",
",",
"output",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"g",
".",
"revision",
")",
"==",
"0",
"{",
"g",
".",
"ready",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"g",
".",
"revision",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"dest",
"\n",
"if",
"output",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cmd",
".",
"Dir",
",",
"g",
".",
"revision",
",",
"output",
",",
"err",
")",
"\n",
"}",
"\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"dest",
"\n",
"if",
"output",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cmd",
".",
"Dir",
",",
"g",
".",
"revision",
",",
"output",
",",
"err",
")",
"\n",
"}",
"\n\n",
"g",
".",
"ready",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] | // Load from URI into dest. | [
"Load",
"from",
"URI",
"into",
"dest",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/seed/git.go#L24-L49 | train |
libopenstorage/openstorage | volume/drivers/buse/nbd.go | Create | func Create(device Device, id string, size int64) *NBD {
if shuttingDown {
logrus.Warnf("Cannot create NBD device during shutdown")
return nil
}
if size >= 0 {
globalMutex.Lock()
defer globalMutex.Unlock()
dev := &NBD{device: device,
devicePath: "",
size: size,
deviceFile: nil,
socket: 0,
mutex: &sync.Mutex{},
}
nbdDevices[id] = dev
return dev
}
return nil
} | go | func Create(device Device, id string, size int64) *NBD {
if shuttingDown {
logrus.Warnf("Cannot create NBD device during shutdown")
return nil
}
if size >= 0 {
globalMutex.Lock()
defer globalMutex.Unlock()
dev := &NBD{device: device,
devicePath: "",
size: size,
deviceFile: nil,
socket: 0,
mutex: &sync.Mutex{},
}
nbdDevices[id] = dev
return dev
}
return nil
} | [
"func",
"Create",
"(",
"device",
"Device",
",",
"id",
"string",
",",
"size",
"int64",
")",
"*",
"NBD",
"{",
"if",
"shuttingDown",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"size",
">=",
"0",
"{",
"globalMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"dev",
":=",
"&",
"NBD",
"{",
"device",
":",
"device",
",",
"devicePath",
":",
"\"",
"\"",
",",
"size",
":",
"size",
",",
"deviceFile",
":",
"nil",
",",
"socket",
":",
"0",
",",
"mutex",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"}",
"\n\n",
"nbdDevices",
"[",
"id",
"]",
"=",
"dev",
"\n",
"return",
"dev",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Create creates a NBD type interface | [
"Create",
"creates",
"a",
"NBD",
"type",
"interface"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/nbd.go#L102-L125 | train |
libopenstorage/openstorage | volume/drivers/buse/nbd.go | Size | func (nbd *NBD) Size(size int64) (err error) {
if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_BLKSIZE, 4096); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_BLKSIZE",
Err: err,
}
} else if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_SIZE_BLOCKS, uintptr(size/4096)); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_SIZE_BLOCKS",
Err: err,
}
}
return err
} | go | func (nbd *NBD) Size(size int64) (err error) {
if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_BLKSIZE, 4096); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_BLKSIZE",
Err: err,
}
} else if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_SIZE_BLOCKS, uintptr(size/4096)); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_SIZE_BLOCKS",
Err: err,
}
}
return err
} | [
"func",
"(",
"nbd",
"*",
"NBD",
")",
"Size",
"(",
"size",
"int64",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
"=",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_SET_BLKSIZE",
",",
"4096",
")",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"os",
".",
"PathError",
"{",
"Op",
":",
"nbd",
".",
"deviceFile",
".",
"Name",
"(",
")",
",",
"Path",
":",
"\"",
"\"",
",",
"Err",
":",
"err",
",",
"}",
"\n",
"}",
"else",
"if",
"err",
"=",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_SET_SIZE_BLOCKS",
",",
"uintptr",
"(",
"size",
"/",
"4096",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"os",
".",
"PathError",
"{",
"Op",
":",
"nbd",
".",
"deviceFile",
".",
"Name",
"(",
")",
",",
"Path",
":",
"\"",
"\"",
",",
"Err",
":",
"err",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}"
] | // Size sets the size of the NBD. | [
"Size",
"sets",
"the",
"size",
"of",
"the",
"NBD",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/nbd.go#L138-L154 | train |
libopenstorage/openstorage | volume/drivers/buse/nbd.go | Connect | func (nbd *NBD) Connect() (dev string, err error) {
pair, err := syscall.Socketpair(syscall.SOCK_STREAM, syscall.AF_UNIX, 0)
if err != nil {
return "", err
}
// Find free NBD device.
for i := 0; ; i++ {
dev = fmt.Sprintf("/dev/nbd%d", i)
if _, err = os.Stat(dev); os.IsNotExist(err) {
dev = ""
return "", errors.New("No more NBD devices left.")
}
if _, err = os.Stat(fmt.Sprintf("/sys/block/nbd%d/pid", i)); !os.IsNotExist(err) {
continue // Busy.
}
logrus.Infof("Attempting to open device %v", dev)
if nbd.deviceFile, err = os.Open(dev); err == nil {
// Possible candidate.
ioctl(nbd.deviceFile.Fd(), BLKROSET, 0)
if err := ioctl(nbd.deviceFile.Fd(), NBD_SET_SOCK, uintptr(pair[0])); err == nil {
nbd.socket = pair[1]
break // Success.
}
}
}
// Setup.
if err = nbd.Size(nbd.size); err != nil {
// Already set by nbd.Size().
} else if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_FLAGS, 1); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_FLAGS",
Err: err,
}
} else {
go nbd.connect()
go nbd.handle()
}
nbd.devicePath = dev
return dev, err
} | go | func (nbd *NBD) Connect() (dev string, err error) {
pair, err := syscall.Socketpair(syscall.SOCK_STREAM, syscall.AF_UNIX, 0)
if err != nil {
return "", err
}
// Find free NBD device.
for i := 0; ; i++ {
dev = fmt.Sprintf("/dev/nbd%d", i)
if _, err = os.Stat(dev); os.IsNotExist(err) {
dev = ""
return "", errors.New("No more NBD devices left.")
}
if _, err = os.Stat(fmt.Sprintf("/sys/block/nbd%d/pid", i)); !os.IsNotExist(err) {
continue // Busy.
}
logrus.Infof("Attempting to open device %v", dev)
if nbd.deviceFile, err = os.Open(dev); err == nil {
// Possible candidate.
ioctl(nbd.deviceFile.Fd(), BLKROSET, 0)
if err := ioctl(nbd.deviceFile.Fd(), NBD_SET_SOCK, uintptr(pair[0])); err == nil {
nbd.socket = pair[1]
break // Success.
}
}
}
// Setup.
if err = nbd.Size(nbd.size); err != nil {
// Already set by nbd.Size().
} else if err = ioctl(nbd.deviceFile.Fd(), NBD_SET_FLAGS, 1); err != nil {
err = &os.PathError{
Op: nbd.deviceFile.Name(),
Path: "ioctl NBD_SET_FLAGS",
Err: err,
}
} else {
go nbd.connect()
go nbd.handle()
}
nbd.devicePath = dev
return dev, err
} | [
"func",
"(",
"nbd",
"*",
"NBD",
")",
"Connect",
"(",
")",
"(",
"dev",
"string",
",",
"err",
"error",
")",
"{",
"pair",
",",
"err",
":=",
"syscall",
".",
"Socketpair",
"(",
"syscall",
".",
"SOCK_STREAM",
",",
"syscall",
".",
"AF_UNIX",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// Find free NBD device.",
"for",
"i",
":=",
"0",
";",
";",
"i",
"++",
"{",
"dev",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"dev",
")",
";",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"dev",
"=",
"\"",
"\"",
"\n",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
")",
")",
";",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"continue",
"// Busy.",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"dev",
")",
"\n",
"if",
"nbd",
".",
"deviceFile",
",",
"err",
"=",
"os",
".",
"Open",
"(",
"dev",
")",
";",
"err",
"==",
"nil",
"{",
"// Possible candidate.",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"BLKROSET",
",",
"0",
")",
"\n",
"if",
"err",
":=",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_SET_SOCK",
",",
"uintptr",
"(",
"pair",
"[",
"0",
"]",
")",
")",
";",
"err",
"==",
"nil",
"{",
"nbd",
".",
"socket",
"=",
"pair",
"[",
"1",
"]",
"\n",
"break",
"// Success.",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Setup.",
"if",
"err",
"=",
"nbd",
".",
"Size",
"(",
"nbd",
".",
"size",
")",
";",
"err",
"!=",
"nil",
"{",
"// Already set by nbd.Size().",
"}",
"else",
"if",
"err",
"=",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_SET_FLAGS",
",",
"1",
")",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"&",
"os",
".",
"PathError",
"{",
"Op",
":",
"nbd",
".",
"deviceFile",
".",
"Name",
"(",
")",
",",
"Path",
":",
"\"",
"\"",
",",
"Err",
":",
"err",
",",
"}",
"\n",
"}",
"else",
"{",
"go",
"nbd",
".",
"connect",
"(",
")",
"\n",
"go",
"nbd",
".",
"handle",
"(",
")",
"\n",
"}",
"\n\n",
"nbd",
".",
"devicePath",
"=",
"dev",
"\n\n",
"return",
"dev",
",",
"err",
"\n",
"}"
] | // Connect the network block device. | [
"Connect",
"the",
"network",
"block",
"device",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/nbd.go#L157-L202 | train |
libopenstorage/openstorage | volume/drivers/buse/nbd.go | Disconnect | func (nbd *NBD) Disconnect() {
nbd.mutex.Lock()
defer nbd.mutex.Unlock()
logrus.Infof("Disconnecting device %v...", nbd.devicePath)
syscall.Unmount(nbd.devicePath, 0)
if nbd.IsConnected() {
logrus.Infof("Issuing a disconnect on %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_DISCONNECT, 0)
logrus.Infof("Clearing NBD queue %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_CLEAR_QUE, 0)
logrus.Infof("Clearing NBD socket %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_CLEAR_SOCK, 0)
logrus.Infof("Closing NBD device file %v", nbd.devicePath)
nbd.deviceFile.Close()
nbd.deviceFile = nil
dummy := make([]byte, 1)
logrus.Infof("Waking up control socket for %v", nbd.devicePath)
syscall.Write(nbd.socket, dummy)
logrus.Infof("Closing control socket for %v", nbd.devicePath)
syscall.Close(nbd.socket)
nbd.socket = 0
}
logrus.Infof("Disconnected device %v", nbd.devicePath)
} | go | func (nbd *NBD) Disconnect() {
nbd.mutex.Lock()
defer nbd.mutex.Unlock()
logrus.Infof("Disconnecting device %v...", nbd.devicePath)
syscall.Unmount(nbd.devicePath, 0)
if nbd.IsConnected() {
logrus.Infof("Issuing a disconnect on %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_DISCONNECT, 0)
logrus.Infof("Clearing NBD queue %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_CLEAR_QUE, 0)
logrus.Infof("Clearing NBD socket %v", nbd.devicePath)
ioctl(nbd.deviceFile.Fd(), NBD_CLEAR_SOCK, 0)
logrus.Infof("Closing NBD device file %v", nbd.devicePath)
nbd.deviceFile.Close()
nbd.deviceFile = nil
dummy := make([]byte, 1)
logrus.Infof("Waking up control socket for %v", nbd.devicePath)
syscall.Write(nbd.socket, dummy)
logrus.Infof("Closing control socket for %v", nbd.devicePath)
syscall.Close(nbd.socket)
nbd.socket = 0
}
logrus.Infof("Disconnected device %v", nbd.devicePath)
} | [
"func",
"(",
"nbd",
"*",
"NBD",
")",
"Disconnect",
"(",
")",
"{",
"nbd",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"nbd",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n\n",
"syscall",
".",
"Unmount",
"(",
"nbd",
".",
"devicePath",
",",
"0",
")",
"\n",
"if",
"nbd",
".",
"IsConnected",
"(",
")",
"{",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_DISCONNECT",
",",
"0",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_CLEAR_QUE",
",",
"0",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"ioctl",
"(",
"nbd",
".",
"deviceFile",
".",
"Fd",
"(",
")",
",",
"NBD_CLEAR_SOCK",
",",
"0",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"nbd",
".",
"deviceFile",
".",
"Close",
"(",
")",
"\n",
"nbd",
".",
"deviceFile",
"=",
"nil",
"\n\n",
"dummy",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"syscall",
".",
"Write",
"(",
"nbd",
".",
"socket",
",",
"dummy",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"syscall",
".",
"Close",
"(",
"nbd",
".",
"socket",
")",
"\n",
"nbd",
".",
"socket",
"=",
"0",
"\n",
"}",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nbd",
".",
"devicePath",
")",
"\n",
"}"
] | // Disconnect disconnects the network block device | [
"Disconnect",
"disconnects",
"the",
"network",
"block",
"device"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/buse/nbd.go#L205-L231 | train |
libopenstorage/openstorage | pkg/auth/oidc.go | NewOIDC | func NewOIDC(config *OIDCAuthConfig) (*OIDCAuthenticator, error) {
p, err := oidc.NewProvider(context.Background(), config.Issuer)
if err != nil {
return nil, fmt.Errorf("Unable to communicate with OIDC provider %s: %v",
config.Issuer,
err)
}
v := p.Verifier(&oidc.Config{
ClientID: config.ClientID,
SkipClientIDCheck: config.SkipClientIDCheck,
})
return &OIDCAuthenticator{
url: config.Issuer,
usernameClaim: config.UsernameClaim,
namespace: config.Namespace,
provider: p,
verifier: v,
}, nil
} | go | func NewOIDC(config *OIDCAuthConfig) (*OIDCAuthenticator, error) {
p, err := oidc.NewProvider(context.Background(), config.Issuer)
if err != nil {
return nil, fmt.Errorf("Unable to communicate with OIDC provider %s: %v",
config.Issuer,
err)
}
v := p.Verifier(&oidc.Config{
ClientID: config.ClientID,
SkipClientIDCheck: config.SkipClientIDCheck,
})
return &OIDCAuthenticator{
url: config.Issuer,
usernameClaim: config.UsernameClaim,
namespace: config.Namespace,
provider: p,
verifier: v,
}, nil
} | [
"func",
"NewOIDC",
"(",
"config",
"*",
"OIDCAuthConfig",
")",
"(",
"*",
"OIDCAuthenticator",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"oidc",
".",
"NewProvider",
"(",
"context",
".",
"Background",
"(",
")",
",",
"config",
".",
"Issuer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"config",
".",
"Issuer",
",",
"err",
")",
"\n",
"}",
"\n\n",
"v",
":=",
"p",
".",
"Verifier",
"(",
"&",
"oidc",
".",
"Config",
"{",
"ClientID",
":",
"config",
".",
"ClientID",
",",
"SkipClientIDCheck",
":",
"config",
".",
"SkipClientIDCheck",
",",
"}",
")",
"\n",
"return",
"&",
"OIDCAuthenticator",
"{",
"url",
":",
"config",
".",
"Issuer",
",",
"usernameClaim",
":",
"config",
".",
"UsernameClaim",
",",
"namespace",
":",
"config",
".",
"Namespace",
",",
"provider",
":",
"p",
",",
"verifier",
":",
"v",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewOIDC returns a new OIDC authenticator | [
"NewOIDC",
"returns",
"a",
"new",
"OIDC",
"authenticator"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/oidc.go#L55-L74 | train |
libopenstorage/openstorage | pkg/auth/oidc.go | AuthenticateToken | func (o *OIDCAuthenticator) AuthenticateToken(ctx context.Context, rawtoken string) (*Claims, error) {
idToken, err := o.verifier.Verify(ctx, rawtoken)
if err != nil {
return nil, fmt.Errorf("Token failed validation: %v", err)
}
// Check for required claims
var claims map[string]interface{}
if err := idToken.Claims(&claims); err != nil {
return nil, fmt.Errorf("Unable to get claim map from token: %v", err)
}
for _, requiredClaim := range requiredClaims {
if _, ok := claims[requiredClaim]; !ok {
// Claim missing
return nil, fmt.Errorf("Required claim %v missing from token", requiredClaim)
}
}
return o.parseClaims(claims)
} | go | func (o *OIDCAuthenticator) AuthenticateToken(ctx context.Context, rawtoken string) (*Claims, error) {
idToken, err := o.verifier.Verify(ctx, rawtoken)
if err != nil {
return nil, fmt.Errorf("Token failed validation: %v", err)
}
// Check for required claims
var claims map[string]interface{}
if err := idToken.Claims(&claims); err != nil {
return nil, fmt.Errorf("Unable to get claim map from token: %v", err)
}
for _, requiredClaim := range requiredClaims {
if _, ok := claims[requiredClaim]; !ok {
// Claim missing
return nil, fmt.Errorf("Required claim %v missing from token", requiredClaim)
}
}
return o.parseClaims(claims)
} | [
"func",
"(",
"o",
"*",
"OIDCAuthenticator",
")",
"AuthenticateToken",
"(",
"ctx",
"context",
".",
"Context",
",",
"rawtoken",
"string",
")",
"(",
"*",
"Claims",
",",
"error",
")",
"{",
"idToken",
",",
"err",
":=",
"o",
".",
"verifier",
".",
"Verify",
"(",
"ctx",
",",
"rawtoken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Check for required claims",
"var",
"claims",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"idToken",
".",
"Claims",
"(",
"&",
"claims",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"requiredClaim",
":=",
"range",
"requiredClaims",
"{",
"if",
"_",
",",
"ok",
":=",
"claims",
"[",
"requiredClaim",
"]",
";",
"!",
"ok",
"{",
"// Claim missing",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"requiredClaim",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"o",
".",
"parseClaims",
"(",
"claims",
")",
"\n",
"}"
] | // AuthenticateToken will verify the validity of the provided token with the OIDC | [
"AuthenticateToken",
"will",
"verify",
"the",
"validity",
"of",
"the",
"provided",
"token",
"with",
"the",
"OIDC"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/oidc.go#L77-L96 | train |
libopenstorage/openstorage | pkg/auth/oidc.go | Username | func (o *OIDCAuthenticator) Username(claims *Claims) string {
return getUsername(o.usernameClaim, claims)
} | go | func (o *OIDCAuthenticator) Username(claims *Claims) string {
return getUsername(o.usernameClaim, claims)
} | [
"func",
"(",
"o",
"*",
"OIDCAuthenticator",
")",
"Username",
"(",
"claims",
"*",
"Claims",
")",
"string",
"{",
"return",
"getUsername",
"(",
"o",
".",
"usernameClaim",
",",
"claims",
")",
"\n",
"}"
] | // Username returns the configured unique id of the user | [
"Username",
"returns",
"the",
"configured",
"unique",
"id",
"of",
"the",
"user"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/oidc.go#L99-L101 | train |
libopenstorage/openstorage | pkg/auth/oidc.go | parseClaims | func (o *OIDCAuthenticator) parseClaims(claims map[string]interface{}) (*Claims, error) {
// If we have namespace set, then use it to get custom claims:
if len(o.namespace) > 0 {
for _, cc := range customClaims {
// Check if there claims needed are under a namespace
if v, ok := claims[o.namespace+cc]; ok {
// Move it to the top of the json tree overwriting anything
// there with the same name.
claims[cc] = v
}
}
}
// Marshal into byte stream so that we can unmarshal into SDK Claims
cbytes, err := json.Marshal(claims)
if err != nil {
return nil, fmt.Errorf("Internal error, unable to re-encode OIDC token claims: %v", err)
}
// Return claims
var sdkClaims Claims
if err := json.Unmarshal(cbytes, &sdkClaims); err != nil {
return nil, fmt.Errorf("Unable to get claims from token: %v", err)
}
if err := validateUsername(o.usernameClaim, &sdkClaims); err != nil {
return nil, err
}
return &sdkClaims, nil
} | go | func (o *OIDCAuthenticator) parseClaims(claims map[string]interface{}) (*Claims, error) {
// If we have namespace set, then use it to get custom claims:
if len(o.namespace) > 0 {
for _, cc := range customClaims {
// Check if there claims needed are under a namespace
if v, ok := claims[o.namespace+cc]; ok {
// Move it to the top of the json tree overwriting anything
// there with the same name.
claims[cc] = v
}
}
}
// Marshal into byte stream so that we can unmarshal into SDK Claims
cbytes, err := json.Marshal(claims)
if err != nil {
return nil, fmt.Errorf("Internal error, unable to re-encode OIDC token claims: %v", err)
}
// Return claims
var sdkClaims Claims
if err := json.Unmarshal(cbytes, &sdkClaims); err != nil {
return nil, fmt.Errorf("Unable to get claims from token: %v", err)
}
if err := validateUsername(o.usernameClaim, &sdkClaims); err != nil {
return nil, err
}
return &sdkClaims, nil
} | [
"func",
"(",
"o",
"*",
"OIDCAuthenticator",
")",
"parseClaims",
"(",
"claims",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"*",
"Claims",
",",
"error",
")",
"{",
"// If we have namespace set, then use it to get custom claims:",
"if",
"len",
"(",
"o",
".",
"namespace",
")",
">",
"0",
"{",
"for",
"_",
",",
"cc",
":=",
"range",
"customClaims",
"{",
"// Check if there claims needed are under a namespace",
"if",
"v",
",",
"ok",
":=",
"claims",
"[",
"o",
".",
"namespace",
"+",
"cc",
"]",
";",
"ok",
"{",
"// Move it to the top of the json tree overwriting anything",
"// there with the same name.",
"claims",
"[",
"cc",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Marshal into byte stream so that we can unmarshal into SDK Claims",
"cbytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"claims",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Return claims",
"var",
"sdkClaims",
"Claims",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"cbytes",
",",
"&",
"sdkClaims",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"validateUsername",
"(",
"o",
".",
"usernameClaim",
",",
"&",
"sdkClaims",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"sdkClaims",
",",
"nil",
"\n",
"}"
] | // This will let us unit test this function without having a real OIDC | [
"This",
"will",
"let",
"us",
"unit",
"test",
"this",
"function",
"without",
"having",
"a",
"real",
"OIDC"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/oidc.go#L104-L135 | train |
libopenstorage/openstorage | pkg/storageops/utils.go | AddElementToMap | func AddElementToMap(
sets map[string][]interface{},
elem interface{},
key string,
) {
if s, ok := sets[key]; ok {
sets[key] = append(s, elem)
} else {
sets[key] = make([]interface{}, 0)
sets[key] = append(sets[key], elem)
}
} | go | func AddElementToMap(
sets map[string][]interface{},
elem interface{},
key string,
) {
if s, ok := sets[key]; ok {
sets[key] = append(s, elem)
} else {
sets[key] = make([]interface{}, 0)
sets[key] = append(sets[key], elem)
}
} | [
"func",
"AddElementToMap",
"(",
"sets",
"map",
"[",
"string",
"]",
"[",
"]",
"interface",
"{",
"}",
",",
"elem",
"interface",
"{",
"}",
",",
"key",
"string",
",",
")",
"{",
"if",
"s",
",",
"ok",
":=",
"sets",
"[",
"key",
"]",
";",
"ok",
"{",
"sets",
"[",
"key",
"]",
"=",
"append",
"(",
"s",
",",
"elem",
")",
"\n",
"}",
"else",
"{",
"sets",
"[",
"key",
"]",
"=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"sets",
"[",
"key",
"]",
"=",
"append",
"(",
"sets",
"[",
"key",
"]",
",",
"elem",
")",
"\n",
"}",
"\n",
"}"
] | // AddElementToMap adds to the given 'elem' to the 'sets' map with given 'key' | [
"AddElementToMap",
"adds",
"to",
"the",
"given",
"elem",
"to",
"the",
"sets",
"map",
"with",
"given",
"key"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/utils.go#L20-L31 | train |
libopenstorage/openstorage | pkg/storageops/utils.go | GetEnvValueStrict | func GetEnvValueStrict(key string) (string, error) {
if val := os.Getenv(key); len(val) != 0 {
return strings.TrimSpace(val), nil
}
return "", fmt.Errorf("env variable %s is not set", key)
} | go | func GetEnvValueStrict(key string) (string, error) {
if val := os.Getenv(key); len(val) != 0 {
return strings.TrimSpace(val), nil
}
return "", fmt.Errorf("env variable %s is not set", key)
} | [
"func",
"GetEnvValueStrict",
"(",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"val",
":=",
"os",
".",
"Getenv",
"(",
"key",
")",
";",
"len",
"(",
"val",
")",
"!=",
"0",
"{",
"return",
"strings",
".",
"TrimSpace",
"(",
"val",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"}"
] | // GetEnvValueStrict fetches value for env variable "key". Returns error if not found or empty | [
"GetEnvValueStrict",
"fetches",
"value",
"for",
"env",
"variable",
"key",
".",
"Returns",
"error",
"if",
"not",
"found",
"or",
"empty"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/storageops/utils.go#L34-L40 | train |
libopenstorage/openstorage | alerts/action.go | clearActionFunc | func clearActionFunc(manager Manager, filters ...Filter) error {
myAlerts, err := manager.Enumerate(filters...)
if err != nil {
return err
}
for _, myAlert := range myAlerts {
myAlert.Cleared = true
if err := manager.Raise(myAlert); err != nil {
return err
}
}
return nil
} | go | func clearActionFunc(manager Manager, filters ...Filter) error {
myAlerts, err := manager.Enumerate(filters...)
if err != nil {
return err
}
for _, myAlert := range myAlerts {
myAlert.Cleared = true
if err := manager.Raise(myAlert); err != nil {
return err
}
}
return nil
} | [
"func",
"clearActionFunc",
"(",
"manager",
"Manager",
",",
"filters",
"...",
"Filter",
")",
"error",
"{",
"myAlerts",
",",
"err",
":=",
"manager",
".",
"Enumerate",
"(",
"filters",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"myAlert",
":=",
"range",
"myAlerts",
"{",
"myAlert",
".",
"Cleared",
"=",
"true",
"\n",
"if",
"err",
":=",
"manager",
".",
"Raise",
"(",
"myAlert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // clearActionFunc first enumerates, then changes Cleared flag to true,
// then updates it.
// Raise method determines if ttlOption needs to be applied based on clear flag. | [
"clearActionFunc",
"first",
"enumerates",
"then",
"changes",
"Cleared",
"flag",
"to",
"true",
"then",
"updates",
"it",
".",
"Raise",
"method",
"determines",
"if",
"ttlOption",
"needs",
"to",
"be",
"applied",
"based",
"on",
"clear",
"flag",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/alerts/action.go#L39-L53 | train |
libopenstorage/openstorage | pkg/auth/selfsigned.go | NewJwtAuth | func NewJwtAuth(config *JwtAuthConfig) (*JwtAuthenticator, error) {
if config == nil {
return nil, fmt.Errorf("Must provide configuration")
}
// Check at least one is set
if len(config.SharedSecret) == 0 &&
len(config.RsaPublicPem) == 0 &&
len(config.ECDSPublicPem) == 0 {
return nil, fmt.Errorf("Server was passed empty authentication information with no shared secret or pem files set")
}
authenticator := &JwtAuthenticator{
config: *config,
usernameClaim: config.UsernameClaim,
}
var err error
if len(config.SharedSecret) != 0 {
authenticator.sharedSecretKey = config.SharedSecret
}
if len(config.RsaPublicPem) != 0 {
authenticator.rsaKey, err = jwt.ParseRSAPublicKeyFromPEM(config.RsaPublicPem)
if err != nil {
return nil, fmt.Errorf("Unable to parse rsa public key: %v", err)
}
}
if len(config.ECDSPublicPem) != 0 {
authenticator.ecdsKey, err = jwt.ParseECPublicKeyFromPEM(config.ECDSPublicPem)
if err != nil {
return nil, fmt.Errorf("Unable to parse ecds public key: %v", err)
}
}
return authenticator, nil
} | go | func NewJwtAuth(config *JwtAuthConfig) (*JwtAuthenticator, error) {
if config == nil {
return nil, fmt.Errorf("Must provide configuration")
}
// Check at least one is set
if len(config.SharedSecret) == 0 &&
len(config.RsaPublicPem) == 0 &&
len(config.ECDSPublicPem) == 0 {
return nil, fmt.Errorf("Server was passed empty authentication information with no shared secret or pem files set")
}
authenticator := &JwtAuthenticator{
config: *config,
usernameClaim: config.UsernameClaim,
}
var err error
if len(config.SharedSecret) != 0 {
authenticator.sharedSecretKey = config.SharedSecret
}
if len(config.RsaPublicPem) != 0 {
authenticator.rsaKey, err = jwt.ParseRSAPublicKeyFromPEM(config.RsaPublicPem)
if err != nil {
return nil, fmt.Errorf("Unable to parse rsa public key: %v", err)
}
}
if len(config.ECDSPublicPem) != 0 {
authenticator.ecdsKey, err = jwt.ParseECPublicKeyFromPEM(config.ECDSPublicPem)
if err != nil {
return nil, fmt.Errorf("Unable to parse ecds public key: %v", err)
}
}
return authenticator, nil
} | [
"func",
"NewJwtAuth",
"(",
"config",
"*",
"JwtAuthConfig",
")",
"(",
"*",
"JwtAuthenticator",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check at least one is set",
"if",
"len",
"(",
"config",
".",
"SharedSecret",
")",
"==",
"0",
"&&",
"len",
"(",
"config",
".",
"RsaPublicPem",
")",
"==",
"0",
"&&",
"len",
"(",
"config",
".",
"ECDSPublicPem",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"authenticator",
":=",
"&",
"JwtAuthenticator",
"{",
"config",
":",
"*",
"config",
",",
"usernameClaim",
":",
"config",
".",
"UsernameClaim",
",",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"if",
"len",
"(",
"config",
".",
"SharedSecret",
")",
"!=",
"0",
"{",
"authenticator",
".",
"sharedSecretKey",
"=",
"config",
".",
"SharedSecret",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"RsaPublicPem",
")",
"!=",
"0",
"{",
"authenticator",
".",
"rsaKey",
",",
"err",
"=",
"jwt",
".",
"ParseRSAPublicKeyFromPEM",
"(",
"config",
".",
"RsaPublicPem",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"ECDSPublicPem",
")",
"!=",
"0",
"{",
"authenticator",
".",
"ecdsKey",
",",
"err",
"=",
"jwt",
".",
"ParseECPublicKeyFromPEM",
"(",
"config",
".",
"ECDSPublicPem",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"authenticator",
",",
"nil",
"\n",
"}"
] | // New returns a JwtAuthenticator | [
"New",
"returns",
"a",
"JwtAuthenticator"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/selfsigned.go#L51-L87 | train |
libopenstorage/openstorage | pkg/auth/selfsigned.go | AuthenticateToken | func (j *JwtAuthenticator) AuthenticateToken(ctx context.Context, rawtoken string) (*Claims, error) {
// Parse token
token, err := jwt.Parse(rawtoken, func(token *jwt.Token) (interface{}, error) {
// Verify Method
if strings.HasPrefix(token.Method.Alg(), "RS") {
// RS256, RS384, or RS512
return j.rsaKey, nil
} else if strings.HasPrefix(token.Method.Alg(), "ES") {
// ES256, ES384, or ES512
return j.ecdsKey, nil
} else if strings.HasPrefix(token.Method.Alg(), "HS") {
// HS256, HS384, or HS512
return j.sharedSecretKey, nil
}
return nil, fmt.Errorf("Unknown token algorithm: %s", token.Method.Alg())
})
if err != nil {
return nil, err
}
if !token.Valid {
return nil, fmt.Errorf("Token failed validation")
}
// Get claims
claims, ok := token.Claims.(jwt.MapClaims)
if claims == nil || !ok {
return nil, fmt.Errorf("No claims found in token")
}
// Check for required claims
for _, requiredClaim := range requiredClaims {
if _, ok := claims[requiredClaim]; !ok {
// Claim missing
return nil, fmt.Errorf("Required claim %v missing from token", requiredClaim)
}
}
// Token now has been verified.
// Claims holds all the authorization information.
// Here we need to first decode it then unmarshal it from JSON
parts := strings.Split(token.Raw, ".")
claimBytes, err := jwt.DecodeSegment(parts[1])
if err != nil {
return nil, fmt.Errorf("Failed to decode claims: %v", err)
}
var sdkClaims Claims
err = json.Unmarshal(claimBytes, &sdkClaims)
if err != nil {
return nil, fmt.Errorf("Unable to get sdkclaims: %v", err)
}
if err := validateUsername(j.usernameClaim, &sdkClaims); err != nil {
return nil, err
}
return &sdkClaims, nil
} | go | func (j *JwtAuthenticator) AuthenticateToken(ctx context.Context, rawtoken string) (*Claims, error) {
// Parse token
token, err := jwt.Parse(rawtoken, func(token *jwt.Token) (interface{}, error) {
// Verify Method
if strings.HasPrefix(token.Method.Alg(), "RS") {
// RS256, RS384, or RS512
return j.rsaKey, nil
} else if strings.HasPrefix(token.Method.Alg(), "ES") {
// ES256, ES384, or ES512
return j.ecdsKey, nil
} else if strings.HasPrefix(token.Method.Alg(), "HS") {
// HS256, HS384, or HS512
return j.sharedSecretKey, nil
}
return nil, fmt.Errorf("Unknown token algorithm: %s", token.Method.Alg())
})
if err != nil {
return nil, err
}
if !token.Valid {
return nil, fmt.Errorf("Token failed validation")
}
// Get claims
claims, ok := token.Claims.(jwt.MapClaims)
if claims == nil || !ok {
return nil, fmt.Errorf("No claims found in token")
}
// Check for required claims
for _, requiredClaim := range requiredClaims {
if _, ok := claims[requiredClaim]; !ok {
// Claim missing
return nil, fmt.Errorf("Required claim %v missing from token", requiredClaim)
}
}
// Token now has been verified.
// Claims holds all the authorization information.
// Here we need to first decode it then unmarshal it from JSON
parts := strings.Split(token.Raw, ".")
claimBytes, err := jwt.DecodeSegment(parts[1])
if err != nil {
return nil, fmt.Errorf("Failed to decode claims: %v", err)
}
var sdkClaims Claims
err = json.Unmarshal(claimBytes, &sdkClaims)
if err != nil {
return nil, fmt.Errorf("Unable to get sdkclaims: %v", err)
}
if err := validateUsername(j.usernameClaim, &sdkClaims); err != nil {
return nil, err
}
return &sdkClaims, nil
} | [
"func",
"(",
"j",
"*",
"JwtAuthenticator",
")",
"AuthenticateToken",
"(",
"ctx",
"context",
".",
"Context",
",",
"rawtoken",
"string",
")",
"(",
"*",
"Claims",
",",
"error",
")",
"{",
"// Parse token",
"token",
",",
"err",
":=",
"jwt",
".",
"Parse",
"(",
"rawtoken",
",",
"func",
"(",
"token",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"// Verify Method",
"if",
"strings",
".",
"HasPrefix",
"(",
"token",
".",
"Method",
".",
"Alg",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"// RS256, RS384, or RS512",
"return",
"j",
".",
"rsaKey",
",",
"nil",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasPrefix",
"(",
"token",
".",
"Method",
".",
"Alg",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"// ES256, ES384, or ES512",
"return",
"j",
".",
"ecdsKey",
",",
"nil",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasPrefix",
"(",
"token",
".",
"Method",
".",
"Alg",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"// HS256, HS384, or HS512",
"return",
"j",
".",
"sharedSecretKey",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"token",
".",
"Method",
".",
"Alg",
"(",
")",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"token",
".",
"Valid",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get claims",
"claims",
",",
"ok",
":=",
"token",
".",
"Claims",
".",
"(",
"jwt",
".",
"MapClaims",
")",
"\n",
"if",
"claims",
"==",
"nil",
"||",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check for required claims",
"for",
"_",
",",
"requiredClaim",
":=",
"range",
"requiredClaims",
"{",
"if",
"_",
",",
"ok",
":=",
"claims",
"[",
"requiredClaim",
"]",
";",
"!",
"ok",
"{",
"// Claim missing",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"requiredClaim",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Token now has been verified.",
"// Claims holds all the authorization information.",
"// Here we need to first decode it then unmarshal it from JSON",
"parts",
":=",
"strings",
".",
"Split",
"(",
"token",
".",
"Raw",
",",
"\"",
"\"",
")",
"\n",
"claimBytes",
",",
"err",
":=",
"jwt",
".",
"DecodeSegment",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"sdkClaims",
"Claims",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"claimBytes",
",",
"&",
"sdkClaims",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"validateUsername",
"(",
"j",
".",
"usernameClaim",
",",
"&",
"sdkClaims",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"sdkClaims",
",",
"nil",
"\n",
"}"
] | // AuthenticateToken determines if a token is valid and if it is, returns
// the information in the claims. | [
"AuthenticateToken",
"determines",
"if",
"a",
"token",
"is",
"valid",
"and",
"if",
"it",
"is",
"returns",
"the",
"information",
"in",
"the",
"claims",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/auth/selfsigned.go#L91-L150 | train |
libopenstorage/openstorage | volume/drivers/coprhd/coprhd.go | getAuthSession | func (d *driver) getAuthSession() (session *napping.Session, err error) {
e := ApiError{}
s := napping.Session{
Userinfo: d.creds,
Client: d.httpClient,
}
url := d.url + loginUri
resp, err := s.Get(url, nil, nil, &e)
if err != nil {
return
}
token := resp.HttpResponse().Header.Get("X-SDS-AUTH-TOKEN")
h := http.Header{}
h.Set("X-SDS-AUTH-TOKEN", token)
session = &napping.Session{
Client: d.httpClient,
Header: &h,
}
return
} | go | func (d *driver) getAuthSession() (session *napping.Session, err error) {
e := ApiError{}
s := napping.Session{
Userinfo: d.creds,
Client: d.httpClient,
}
url := d.url + loginUri
resp, err := s.Get(url, nil, nil, &e)
if err != nil {
return
}
token := resp.HttpResponse().Header.Get("X-SDS-AUTH-TOKEN")
h := http.Header{}
h.Set("X-SDS-AUTH-TOKEN", token)
session = &napping.Session{
Client: d.httpClient,
Header: &h,
}
return
} | [
"func",
"(",
"d",
"*",
"driver",
")",
"getAuthSession",
"(",
")",
"(",
"session",
"*",
"napping",
".",
"Session",
",",
"err",
"error",
")",
"{",
"e",
":=",
"ApiError",
"{",
"}",
"\n\n",
"s",
":=",
"napping",
".",
"Session",
"{",
"Userinfo",
":",
"d",
".",
"creds",
",",
"Client",
":",
"d",
".",
"httpClient",
",",
"}",
"\n\n",
"url",
":=",
"d",
".",
"url",
"+",
"loginUri",
"\n\n",
"resp",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"url",
",",
"nil",
",",
"nil",
",",
"&",
"e",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"token",
":=",
"resp",
".",
"HttpResponse",
"(",
")",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n\n",
"h",
":=",
"http",
".",
"Header",
"{",
"}",
"\n\n",
"h",
".",
"Set",
"(",
"\"",
"\"",
",",
"token",
")",
"\n\n",
"session",
"=",
"&",
"napping",
".",
"Session",
"{",
"Client",
":",
"d",
".",
"httpClient",
",",
"Header",
":",
"&",
"h",
",",
"}",
"\n\n",
"return",
"\n",
"}"
] | // getAuthSession returns an authenticated API Session | [
"getAuthSession",
"returns",
"an",
"authenticated",
"API",
"Session"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/volume/drivers/coprhd/coprhd.go#L253-L281 | train |
libopenstorage/openstorage | pkg/grpcserver/grpcutil.go | Connect | func Connect(address string, dialOptions []grpc.DialOption) (*grpc.ClientConn, error) {
u, err := url.Parse(address)
if err == nil && (!u.IsAbs() || u.Scheme == "unix") {
dialOptions = append(dialOptions,
grpc.WithDialer(
func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("unix", u.Path, timeout)
}))
}
dialOptions = append(dialOptions, grpc.WithBackoffMaxDelay(time.Second))
conn, err := grpc.Dial(address, dialOptions...)
if err != nil {
return nil, err
}
// We wait for 1 minute until conn.GetState() is READY.
// The interval for this check is 1 second.
if err := util.WaitFor(1*time.Minute, 10*time.Millisecond, func() (bool, error) {
if conn.GetState() == connectivity.Ready {
return false, nil
}
return true, nil
}); err != nil {
return nil, fmt.Errorf("Connection timed out")
}
return conn, nil
} | go | func Connect(address string, dialOptions []grpc.DialOption) (*grpc.ClientConn, error) {
u, err := url.Parse(address)
if err == nil && (!u.IsAbs() || u.Scheme == "unix") {
dialOptions = append(dialOptions,
grpc.WithDialer(
func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("unix", u.Path, timeout)
}))
}
dialOptions = append(dialOptions, grpc.WithBackoffMaxDelay(time.Second))
conn, err := grpc.Dial(address, dialOptions...)
if err != nil {
return nil, err
}
// We wait for 1 minute until conn.GetState() is READY.
// The interval for this check is 1 second.
if err := util.WaitFor(1*time.Minute, 10*time.Millisecond, func() (bool, error) {
if conn.GetState() == connectivity.Ready {
return false, nil
}
return true, nil
}); err != nil {
return nil, fmt.Errorf("Connection timed out")
}
return conn, nil
} | [
"func",
"Connect",
"(",
"address",
"string",
",",
"dialOptions",
"[",
"]",
"grpc",
".",
"DialOption",
")",
"(",
"*",
"grpc",
".",
"ClientConn",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"address",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"(",
"!",
"u",
".",
"IsAbs",
"(",
")",
"||",
"u",
".",
"Scheme",
"==",
"\"",
"\"",
")",
"{",
"dialOptions",
"=",
"append",
"(",
"dialOptions",
",",
"grpc",
".",
"WithDialer",
"(",
"func",
"(",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"net",
".",
"DialTimeout",
"(",
"\"",
"\"",
",",
"u",
".",
"Path",
",",
"timeout",
")",
"\n",
"}",
")",
")",
"\n",
"}",
"\n\n",
"dialOptions",
"=",
"append",
"(",
"dialOptions",
",",
"grpc",
".",
"WithBackoffMaxDelay",
"(",
"time",
".",
"Second",
")",
")",
"\n",
"conn",
",",
"err",
":=",
"grpc",
".",
"Dial",
"(",
"address",
",",
"dialOptions",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// We wait for 1 minute until conn.GetState() is READY.",
"// The interval for this check is 1 second.",
"if",
"err",
":=",
"util",
".",
"WaitFor",
"(",
"1",
"*",
"time",
".",
"Minute",
",",
"10",
"*",
"time",
".",
"Millisecond",
",",
"func",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"conn",
".",
"GetState",
"(",
")",
"==",
"connectivity",
".",
"Ready",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // Connect address by grpc | [
"Connect",
"address",
"by",
"grpc"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/pkg/grpcserver/grpcutil.go#L33-L61 | train |
libopenstorage/openstorage | csi/v0.3/node.go | NodeGetId | func (s *OsdCsiServer) NodeGetId(
ctx context.Context,
req *csi.NodeGetIdRequest,
) (*csi.NodeGetIdResponse, error) {
clus, err := s.cluster.Enumerate()
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to Enumerate cluster: %s", err)
}
result := &csi.NodeGetIdResponse{
NodeId: clus.NodeId,
}
logrus.Infof("NodeId is %s", result.NodeId)
return result, nil
} | go | func (s *OsdCsiServer) NodeGetId(
ctx context.Context,
req *csi.NodeGetIdRequest,
) (*csi.NodeGetIdResponse, error) {
clus, err := s.cluster.Enumerate()
if err != nil {
return nil, status.Errorf(codes.Internal, "Unable to Enumerate cluster: %s", err)
}
result := &csi.NodeGetIdResponse{
NodeId: clus.NodeId,
}
logrus.Infof("NodeId is %s", result.NodeId)
return result, nil
} | [
"func",
"(",
"s",
"*",
"OsdCsiServer",
")",
"NodeGetId",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"csi",
".",
"NodeGetIdRequest",
",",
")",
"(",
"*",
"csi",
".",
"NodeGetIdResponse",
",",
"error",
")",
"{",
"clus",
",",
"err",
":=",
"s",
".",
"cluster",
".",
"Enumerate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"result",
":=",
"&",
"csi",
".",
"NodeGetIdResponse",
"{",
"NodeId",
":",
"clus",
".",
"NodeId",
",",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"result",
".",
"NodeId",
")",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // NodeGetId is a CSI API which gets the PX NodeId for the local node | [
"NodeGetId",
"is",
"a",
"CSI",
"API",
"which",
"gets",
"the",
"PX",
"NodeId",
"for",
"the",
"local",
"node"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/v0.3/node.go#L52-L68 | train |
libopenstorage/openstorage | csi/v0.3/node.go | NodeUnpublishVolume | func (s *OsdCsiServer) NodeUnpublishVolume(
ctx context.Context,
req *csi.NodeUnpublishVolumeRequest,
) (*csi.NodeUnpublishVolumeResponse, error) {
logrus.Debugf("NodeUnPublishVolume req[%#v]", req)
// Check arguments
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Volume id must be provided")
}
if len(req.GetTargetPath()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Target path must be provided")
}
// Get volume information
_, err := util.VolumeFromName(s.driver, req.GetVolumeId())
if err != nil {
return nil, status.Errorf(codes.NotFound, "Volume id %s not found: %s",
req.GetVolumeId(),
err.Error())
}
// Get information about the target since the request does not
// tell us if it is for block or mount point.
// https://github.com/container-storage-interface/spec/issues/285
fileInfo, err := os.Lstat(req.GetTargetPath())
if err != nil && os.IsNotExist(err) {
// For idempotency, return that there is nothing to unmount
logrus.Infof("NodeUnpublishVolume on target path %s but it does "+
"not exist, returning there is nothing to do", req.GetTargetPath())
return &csi.NodeUnpublishVolumeResponse{}, nil
} else if err != nil {
return nil, status.Errorf(
codes.Internal,
"Unknown error while verifying target location %s: %s",
req.GetTargetPath(),
err.Error())
}
// Check if it is block or not
if fileInfo.Mode()&os.ModeSymlink != 0 {
// If block, we just need to remove the link.
os.Remove(req.GetTargetPath())
} else {
if !fileInfo.IsDir() {
return nil, status.Errorf(
codes.NotFound,
"Target location %s is not a directory", req.GetTargetPath())
}
// Mount volume onto the path
if err = s.driver.Unmount(req.GetVolumeId(), req.GetTargetPath(), nil); err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to unmount volume %s onto %s: %s",
req.GetVolumeId(),
req.GetTargetPath(),
err.Error())
}
}
if s.driver.Type() == api.DriverType_DRIVER_TYPE_BLOCK {
if err = s.driver.Detach(req.GetVolumeId(), nil); err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to detach volume: %s",
err.Error())
}
}
logrus.Infof("Volume %s unmounted", req.GetVolumeId())
return &csi.NodeUnpublishVolumeResponse{}, nil
} | go | func (s *OsdCsiServer) NodeUnpublishVolume(
ctx context.Context,
req *csi.NodeUnpublishVolumeRequest,
) (*csi.NodeUnpublishVolumeResponse, error) {
logrus.Debugf("NodeUnPublishVolume req[%#v]", req)
// Check arguments
if len(req.GetVolumeId()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Volume id must be provided")
}
if len(req.GetTargetPath()) == 0 {
return nil, status.Error(codes.InvalidArgument, "Target path must be provided")
}
// Get volume information
_, err := util.VolumeFromName(s.driver, req.GetVolumeId())
if err != nil {
return nil, status.Errorf(codes.NotFound, "Volume id %s not found: %s",
req.GetVolumeId(),
err.Error())
}
// Get information about the target since the request does not
// tell us if it is for block or mount point.
// https://github.com/container-storage-interface/spec/issues/285
fileInfo, err := os.Lstat(req.GetTargetPath())
if err != nil && os.IsNotExist(err) {
// For idempotency, return that there is nothing to unmount
logrus.Infof("NodeUnpublishVolume on target path %s but it does "+
"not exist, returning there is nothing to do", req.GetTargetPath())
return &csi.NodeUnpublishVolumeResponse{}, nil
} else if err != nil {
return nil, status.Errorf(
codes.Internal,
"Unknown error while verifying target location %s: %s",
req.GetTargetPath(),
err.Error())
}
// Check if it is block or not
if fileInfo.Mode()&os.ModeSymlink != 0 {
// If block, we just need to remove the link.
os.Remove(req.GetTargetPath())
} else {
if !fileInfo.IsDir() {
return nil, status.Errorf(
codes.NotFound,
"Target location %s is not a directory", req.GetTargetPath())
}
// Mount volume onto the path
if err = s.driver.Unmount(req.GetVolumeId(), req.GetTargetPath(), nil); err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to unmount volume %s onto %s: %s",
req.GetVolumeId(),
req.GetTargetPath(),
err.Error())
}
}
if s.driver.Type() == api.DriverType_DRIVER_TYPE_BLOCK {
if err = s.driver.Detach(req.GetVolumeId(), nil); err != nil {
return nil, status.Errorf(
codes.Internal,
"Unable to detach volume: %s",
err.Error())
}
}
logrus.Infof("Volume %s unmounted", req.GetVolumeId())
return &csi.NodeUnpublishVolumeResponse{}, nil
} | [
"func",
"(",
"s",
"*",
"OsdCsiServer",
")",
"NodeUnpublishVolume",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"csi",
".",
"NodeUnpublishVolumeRequest",
",",
")",
"(",
"*",
"csi",
".",
"NodeUnpublishVolumeResponse",
",",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"req",
")",
"\n\n",
"// Check arguments",
"if",
"len",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"status",
".",
"Error",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get volume information",
"_",
",",
"err",
":=",
"util",
".",
"VolumeFromName",
"(",
"s",
".",
"driver",
",",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Get information about the target since the request does not",
"// tell us if it is for block or mount point.",
"// https://github.com/container-storage-interface/spec/issues/285",
"fileInfo",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"// For idempotency, return that there is nothing to unmount",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"\n",
"return",
"&",
"csi",
".",
"NodeUnpublishVolumeResponse",
"{",
"}",
",",
"nil",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetTargetPath",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Check if it is block or not",
"if",
"fileInfo",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeSymlink",
"!=",
"0",
"{",
"// If block, we just need to remove the link.",
"os",
".",
"Remove",
"(",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"if",
"!",
"fileInfo",
".",
"IsDir",
"(",
")",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"req",
".",
"GetTargetPath",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Mount volume onto the path",
"if",
"err",
"=",
"s",
".",
"driver",
".",
"Unmount",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"req",
".",
"GetTargetPath",
"(",
")",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"req",
".",
"GetTargetPath",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"driver",
".",
"Type",
"(",
")",
"==",
"api",
".",
"DriverType_DRIVER_TYPE_BLOCK",
"{",
"if",
"err",
"=",
"s",
".",
"driver",
".",
"Detach",
"(",
"req",
".",
"GetVolumeId",
"(",
")",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"req",
".",
"GetVolumeId",
"(",
")",
")",
"\n\n",
"return",
"&",
"csi",
".",
"NodeUnpublishVolumeResponse",
"{",
"}",
",",
"nil",
"\n",
"}"
] | // NodeUnpublishVolume is a CSI API call which unmounts the volume. | [
"NodeUnpublishVolume",
"is",
"a",
"CSI",
"API",
"call",
"which",
"unmounts",
"the",
"volume",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/v0.3/node.go#L184-L258 | train |
libopenstorage/openstorage | csi/v0.3/node.go | NodeGetCapabilities | func (s *OsdCsiServer) NodeGetCapabilities(
ctx context.Context,
req *csi.NodeGetCapabilitiesRequest,
) (*csi.NodeGetCapabilitiesResponse, error) {
logrus.Debugf("NodeGetCapabilities req[%#v]", req)
return &csi.NodeGetCapabilitiesResponse{
Capabilities: []*csi.NodeServiceCapability{
{
Type: &csi.NodeServiceCapability_Rpc{
Rpc: &csi.NodeServiceCapability_RPC{
Type: csi.NodeServiceCapability_RPC_UNKNOWN,
},
},
},
},
}, nil
} | go | func (s *OsdCsiServer) NodeGetCapabilities(
ctx context.Context,
req *csi.NodeGetCapabilitiesRequest,
) (*csi.NodeGetCapabilitiesResponse, error) {
logrus.Debugf("NodeGetCapabilities req[%#v]", req)
return &csi.NodeGetCapabilitiesResponse{
Capabilities: []*csi.NodeServiceCapability{
{
Type: &csi.NodeServiceCapability_Rpc{
Rpc: &csi.NodeServiceCapability_RPC{
Type: csi.NodeServiceCapability_RPC_UNKNOWN,
},
},
},
},
}, nil
} | [
"func",
"(",
"s",
"*",
"OsdCsiServer",
")",
"NodeGetCapabilities",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"csi",
".",
"NodeGetCapabilitiesRequest",
",",
")",
"(",
"*",
"csi",
".",
"NodeGetCapabilitiesResponse",
",",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"req",
")",
"\n\n",
"return",
"&",
"csi",
".",
"NodeGetCapabilitiesResponse",
"{",
"Capabilities",
":",
"[",
"]",
"*",
"csi",
".",
"NodeServiceCapability",
"{",
"{",
"Type",
":",
"&",
"csi",
".",
"NodeServiceCapability_Rpc",
"{",
"Rpc",
":",
"&",
"csi",
".",
"NodeServiceCapability_RPC",
"{",
"Type",
":",
"csi",
".",
"NodeServiceCapability_RPC_UNKNOWN",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NodeGetCapabilities is a CSI API function which seems to be setup for
// future patches | [
"NodeGetCapabilities",
"is",
"a",
"CSI",
"API",
"function",
"which",
"seems",
"to",
"be",
"setup",
"for",
"future",
"patches"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/csi/v0.3/node.go#L262-L280 | train |
libopenstorage/openstorage | api/server/server.go | StartGraphAPI | func StartGraphAPI(name string, restBase string) error {
graphPlugin := newGraphPlugin(name)
if _, _, err := startServer(name, restBase, 0, graphPlugin); err != nil {
return err
}
return nil
} | go | func StartGraphAPI(name string, restBase string) error {
graphPlugin := newGraphPlugin(name)
if _, _, err := startServer(name, restBase, 0, graphPlugin); err != nil {
return err
}
return nil
} | [
"func",
"StartGraphAPI",
"(",
"name",
"string",
",",
"restBase",
"string",
")",
"error",
"{",
"graphPlugin",
":=",
"newGraphPlugin",
"(",
"name",
")",
"\n",
"if",
"_",
",",
"_",
",",
"err",
":=",
"startServer",
"(",
"name",
",",
"restBase",
",",
"0",
",",
"graphPlugin",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // StartGraphAPI starts a REST server to receive GraphDriver commands from
// the Linux container engine. | [
"StartGraphAPI",
"starts",
"a",
"REST",
"server",
"to",
"receive",
"GraphDriver",
"commands",
"from",
"the",
"Linux",
"container",
"engine",
"."
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/server.go#L54-L61 | train |
libopenstorage/openstorage | api/server/server.go | StartVolumeMgmtAPI | func StartVolumeMgmtAPI(
name, sdkUds string,
mgmtBase string,
mgmtPort uint16,
auth bool,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
) (*http.Server, *http.Server, error) {
var (
unixServer, portServer *http.Server
err error
)
volMgmtApi := newVolumeAPI(name, sdkUds)
if auth {
unixServer, portServer, err = startServerWithAuth(
name,
mgmtBase,
mgmtPort,
volMgmtApi,
authProviderType,
authProvider,
)
} else {
unixServer, portServer, err = startServer(
name,
mgmtBase,
mgmtPort,
volMgmtApi,
)
}
return unixServer, portServer, err
} | go | func StartVolumeMgmtAPI(
name, sdkUds string,
mgmtBase string,
mgmtPort uint16,
auth bool,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
) (*http.Server, *http.Server, error) {
var (
unixServer, portServer *http.Server
err error
)
volMgmtApi := newVolumeAPI(name, sdkUds)
if auth {
unixServer, portServer, err = startServerWithAuth(
name,
mgmtBase,
mgmtPort,
volMgmtApi,
authProviderType,
authProvider,
)
} else {
unixServer, portServer, err = startServer(
name,
mgmtBase,
mgmtPort,
volMgmtApi,
)
}
return unixServer, portServer, err
} | [
"func",
"StartVolumeMgmtAPI",
"(",
"name",
",",
"sdkUds",
"string",
",",
"mgmtBase",
"string",
",",
"mgmtPort",
"uint16",
",",
"auth",
"bool",
",",
"authProviderType",
"secrets",
".",
"AuthTokenProviders",
",",
"authProvider",
"osecrets",
".",
"Secrets",
",",
")",
"(",
"*",
"http",
".",
"Server",
",",
"*",
"http",
".",
"Server",
",",
"error",
")",
"{",
"var",
"(",
"unixServer",
",",
"portServer",
"*",
"http",
".",
"Server",
"\n",
"err",
"error",
"\n",
")",
"\n",
"volMgmtApi",
":=",
"newVolumeAPI",
"(",
"name",
",",
"sdkUds",
")",
"\n\n",
"if",
"auth",
"{",
"unixServer",
",",
"portServer",
",",
"err",
"=",
"startServerWithAuth",
"(",
"name",
",",
"mgmtBase",
",",
"mgmtPort",
",",
"volMgmtApi",
",",
"authProviderType",
",",
"authProvider",
",",
")",
"\n",
"}",
"else",
"{",
"unixServer",
",",
"portServer",
",",
"err",
"=",
"startServer",
"(",
"name",
",",
"mgmtBase",
",",
"mgmtPort",
",",
"volMgmtApi",
",",
")",
"\n\n",
"}",
"\n",
"return",
"unixServer",
",",
"portServer",
",",
"err",
"\n",
"}"
] | // StartVolumeMgmtAPI starts a REST server to receive volume management API commands | [
"StartVolumeMgmtAPI",
"starts",
"a",
"REST",
"server",
"to",
"receive",
"volume",
"management",
"API",
"commands"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/server.go#L64-L97 | train |
libopenstorage/openstorage | api/server/server.go | StartVolumePluginAPI | func StartVolumePluginAPI(
name, sdkUds string,
pluginBase string,
pluginPort uint16,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
) error {
var secretsStore secrets.Auth
var err error
// Only initialize secrets store if we have a valid auth provider.
if authProvider != nil && authProviderType != secrets.TypeNone {
secretsStore, err = secrets.NewAuth(authProviderType, authProvider)
if err != nil {
return err
}
}
volPluginApi := newVolumePlugin(name, sdkUds, secretsStore)
if _, _, err := startServer(
name,
pluginBase,
pluginPort,
volPluginApi,
); err != nil {
return err
}
return nil
} | go | func StartVolumePluginAPI(
name, sdkUds string,
pluginBase string,
pluginPort uint16,
authProviderType secrets.AuthTokenProviders,
authProvider osecrets.Secrets,
) error {
var secretsStore secrets.Auth
var err error
// Only initialize secrets store if we have a valid auth provider.
if authProvider != nil && authProviderType != secrets.TypeNone {
secretsStore, err = secrets.NewAuth(authProviderType, authProvider)
if err != nil {
return err
}
}
volPluginApi := newVolumePlugin(name, sdkUds, secretsStore)
if _, _, err := startServer(
name,
pluginBase,
pluginPort,
volPluginApi,
); err != nil {
return err
}
return nil
} | [
"func",
"StartVolumePluginAPI",
"(",
"name",
",",
"sdkUds",
"string",
",",
"pluginBase",
"string",
",",
"pluginPort",
"uint16",
",",
"authProviderType",
"secrets",
".",
"AuthTokenProviders",
",",
"authProvider",
"osecrets",
".",
"Secrets",
",",
")",
"error",
"{",
"var",
"secretsStore",
"secrets",
".",
"Auth",
"\n",
"var",
"err",
"error",
"\n\n",
"// Only initialize secrets store if we have a valid auth provider.",
"if",
"authProvider",
"!=",
"nil",
"&&",
"authProviderType",
"!=",
"secrets",
".",
"TypeNone",
"{",
"secretsStore",
",",
"err",
"=",
"secrets",
".",
"NewAuth",
"(",
"authProviderType",
",",
"authProvider",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"volPluginApi",
":=",
"newVolumePlugin",
"(",
"name",
",",
"sdkUds",
",",
"secretsStore",
")",
"\n",
"if",
"_",
",",
"_",
",",
"err",
":=",
"startServer",
"(",
"name",
",",
"pluginBase",
",",
"pluginPort",
",",
"volPluginApi",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // StartVolumePluginAPI starts a REST server to receive volume API commands
// from the linux container engine | [
"StartVolumePluginAPI",
"starts",
"a",
"REST",
"server",
"to",
"receive",
"volume",
"API",
"commands",
"from",
"the",
"linux",
"container",
"engine"
] | 71b7f37f99c70e697aa31ca57fa8fb1404629329 | https://github.com/libopenstorage/openstorage/blob/71b7f37f99c70e697aa31ca57fa8fb1404629329/api/server/server.go#L101-L129 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.