func newOpenstackClient(config *authConfig) (*OpenstackClient, error) { if config == nil { err := errors.New("no OpenStack cloud provider config file given") return nil, err } opts := gophercloud.AuthOptions{ IdentityEndpoint: config.AuthUrl, Username: config.Username, Password: config.Password, TenantName: config.Tenant, TenantID: config.TenantID, AllowReauth: false, } provider, err := openstack.AuthenticatedClient(opts) if err != nil { glog.Info("Failed: Starting openstack authenticate client") return nil, err } authClient := openstack.NewIdentityV2(provider) return &OpenstackClient{ provider, authClient, config, }, nil }
func newCinderClient(configFile string) (*cinderClient, error) { cfg, err := readConfig(configFile) if err != nil { return nil, err } provider, err := openstack.AuthenticatedClient(cfg.toAuthOptions()) if err != nil { return nil, err } client, err := openstack.NewBlockStorageV2(provider, gophercloud.EndpointOpts{ Region: cfg.Global.Region, }) if err != nil { return nil, err } cc := cinderClient{ cinder: client, keyring: cfg.RBD.Keyring, } return &cc, nil }
func TestAuthenticatedClient(t *testing.T) { // Obtain credentials from the environment. ao, err := openstack.AuthOptionsFromEnv() if err != nil { t.Fatalf("Unable to acquire credentials: %v", err) } client, err := openstack.AuthenticatedClient(ao) if err != nil { t.Fatalf("Unable to authenticate: %v", err) } if client.TokenID == "" { t.Errorf("No token ID assigned to the client") } t.Logf("Client successfully acquired a token: %v", client.TokenID) // Find the storage service in the service catalog. storage, err := openstack.NewObjectStorageV1(client, gophercloud.EndpointOpts{ Region: os.Getenv("OS_REGION_NAME"), }) if err != nil { t.Errorf("Unable to locate a storage service: %v", err) } else { t.Logf("Located a storage service at endpoint: [%s]", storage.Endpoint) } }
func (c *Config) client() (*gophercloud.ProviderClient, error) { options := gophercloud.AuthOptions{ IdentityEndpoint: fmt.Sprintf("https://identity.%s.conoha.io/v2.0", c.Region), Username: c.Username, Password: c.Password, TenantName: c.TenantName, } return openstack.AuthenticatedClient(options) }
func (d *driver) Init(context types.Context, config gofig.Config) error { d.config = config fields := eff(map[string]interface{}{}) var err error if d.instanceID, err = d.getInstanceID(); err != nil { return err } fields["moduleName"] = context fields["instanceId"] = d.instanceID if d.region, err = d.getInstanceRegion(); err != nil { return err } fields["region"] = d.region d.region = strings.ToUpper(d.region) authOpts := d.getAuthOptions() fields["identityEndpoint"] = d.authURL() fields["userId"] = d.userID() fields["userName"] = d.userName() if d.password() == "" { fields["password"] = "" } else { fields["password"] = "******" } fields["tenantId"] = d.tenantID() fields["tenantName"] = d.tenantName() fields["domainId"] = d.domainID() fields["domainName"] = d.domainName() if d.provider, err = openstack.AuthenticatedClient(authOpts); err != nil { return goof.WithFieldsE(fields, "error getting authenticated client", err) } if d.client, err = openstack.NewComputeV2(d.provider, gophercloud.EndpointOpts{Region: d.region}); err != nil { goof.WithFieldsE(fields, "error getting newComputeV2", err) } if d.clientBlockStorage, err = openstack.NewBlockStorageV1(d.provider, gophercloud.EndpointOpts{Region: d.region}); err != nil { return goof.WithFieldsE(fields, "error getting newBlockStorageV1", err) } log.WithFields(fields).Info("storage driver initialized") return nil }
func newClient(t *testing.T) (*gophercloud.ServiceClient, error) { ao, err := openstack.AuthOptionsFromEnv() th.AssertNoErr(t, err) client, err := openstack.AuthenticatedClient(ao) th.AssertNoErr(t, err) return openstack.NewBlockStorageV2(client, gophercloud.EndpointOpts{ Region: os.Getenv("OS_REGION_NAME"), }) }
func (d *driver) Init(r *core.RexRay) error { d.r = r fields := ef() var err error if d.instanceID, err = getInstanceID(d.r.Config); err != nil { return err } fields["instanceId"] = d.instanceID if d.region, err = getInstanceRegion(d.r.Config); err != nil { return err } fields["region"] = d.region d.region = strings.ToUpper(d.region) authOpts := getAuthOptions(d.r.Config) fields["identityEndpoint"] = d.r.Config.RackspaceAuthURL fields["userId"] = d.r.Config.RackspaceUserID fields["userName"] = d.r.Config.RackspaceUserName if d.r.Config.RackspacePassword == "" { fields["password"] = "" } else { fields["password"] = "******" } fields["tenantId"] = d.r.Config.RackspaceTenantID fields["tenantName"] = d.r.Config.RackspaceTenantName fields["domainId"] = d.r.Config.RackspaceDomainID fields["domainName"] = d.r.Config.RackspaceDomainName if d.provider, err = openstack.AuthenticatedClient(authOpts); err != nil { return errors.WithFieldsE(fields, "error getting authenticated client", err) } if d.client, err = openstack.NewComputeV2(d.provider, gophercloud.EndpointOpts{Region: d.region}); err != nil { errors.WithFieldsE(fields, "error getting newComputeV2", err) } if d.clientBlockStorage, err = openstack.NewBlockStorageV1(d.provider, gophercloud.EndpointOpts{Region: d.region}); err != nil { return errors.WithFieldsE(fields, "error getting newBlockStorageV1", err) } log.WithField("provider", providerName).Info("storage driver initialized") return nil }
func getProviderClient() (*gophercloud.ProviderClient, error) { opts, err := openstack.AuthOptionsFromEnv() if err != nil { return nil, err } provider, err := openstack.AuthenticatedClient(opts) if err != nil { if strings.Contains(err.Error(), "provide exactly one of Domain") { return nil, fmt.Errorf(envVariablesNotSetError, keystoneDomainIDKey, keystoneDomainNameKey) } } return provider, err }
func newClient(t *testing.T) *gophercloud.ServiceClient { ao, err := openstack.AuthOptionsFromEnv() th.AssertNoErr(t, err) client, err := openstack.AuthenticatedClient(ao) th.AssertNoErr(t, err) c, err := openstack.NewOrchestrationV1(client, gophercloud.EndpointOpts{ Region: os.Getenv("OS_REGION_NAME"), }) th.AssertNoErr(t, err) return c }
// initIdentityClient initializes openstack api using // gophercloud which handles auth tokens keeping api calls // simpler. Currently it uses environment variables for // authenticating with openstack identity. func initIdentityClient() (*gophercloud.ServiceClient, error) { opts, err := openstack.AuthOptionsFromEnv() if err != nil { log.Println("Error fetching openstack env vars: ", err) return nil, err } provider, err := openstack.AuthenticatedClient(opts) if err != nil { log.Println("Error authenticating with openstack: ", err) return nil, err } return openstack.NewIdentityV2(provider), nil }
// NewKeystoneClient initilizes a keystone client with the provided configuration. func NewKeystoneClient(config Config) (KeystoneClient, error) { opts := config.AuthOptions provider, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } client := openstack.NewIdentityV3(provider) // build a closure for ksClient reauthentication client.ReauthFunc = func() error { return openstack.AuthenticateV3(client.ProviderClient, opts) } return &KeystoneClientImpl{client: client, opts: opts, token: nil, monascaURL: nil}, nil }
func newOpenStack(cfg Config) (*OpenStack, error) { provider, err := openstack.AuthenticatedClient(cfg.toAuthOptions()) if err != nil { return nil, err } os := OpenStack{ provider: provider, region: cfg.Global.Region, lbOpts: cfg.LoadBalancer, } return &os, nil }
func initClient(config *Config) (*gophercloud.ProviderClient, error) { opts := gophercloud.AuthOptions{ IdentityEndpoint: config.Auth_Url, Username: config.User, Password: config.Password, TenantName: config.Tenant, } client, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } return client, nil }
func New(cfgFile string) CinderDriver { conf, err := processConfig(cfgFile) isV3 := strings.Contains(conf.Endpoint, "v3") if err != nil { log.Fatal("Error processing cinder driver config file: ", err) } _, err = os.Lstat(conf.MountPoint) if os.IsNotExist(err) { if err := os.MkdirAll(conf.MountPoint, 0755); err != nil { log.Fatal("Failed to create Mount directory during driver init: %v", err) } } auth := gophercloud.AuthOptions{ IdentityEndpoint: conf.Endpoint, Username: conf.Username, Password: conf.Password, TenantID: conf.TenantID, AllowReauth: true, } if isV3 == true && conf.DomainName == "" { log.Warning("V3 endpoint specified, but DomainName not set!") log.Warning("Setting to \"Default\", maybe it'll work.") auth.DomainName = "Default" } if conf.DomainName != "" && isV3 == true { log.Info("Authorizing to a V3 Endpoint") auth.DomainName = conf.DomainName } providerClient, err := openstack.AuthenticatedClient(auth) if err != nil { log.Fatal("Error initiating gophercloud provider client: ", err) } client, err := openstack.NewBlockStorageV2(providerClient, gophercloud.EndpointOpts{Region: "RegionOne"}) if err != nil { log.Fatal("Error initiating gophercloud cinder client: ", err) } d := CinderDriver{ Conf: &conf, Mutex: &sync.Mutex{}, Client: client, } return d }
func networkingClient() (*gophercloud.ServiceClient, error) { opts, err := openstack.AuthOptionsFromEnv() if err != nil { return nil, err } provider, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } return openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Region: os.Getenv("OS_REGION_NAME"), }) }
func NewIdentityClient(a gophercloud.AuthOptions) (*gophercloud.ServiceClient, error) { // authenticate with provider provider, err := openstack.AuthenticatedClient(a) if err != nil { return nil, err } // Create a new client to the provider client := openstack.NewIdentityV2(provider) if client == nil { return nil, errors.New("Could not create new identity client") } return client, nil }
//NewKeystoneV2Client is an constructor for KeystoneV2Client func NewKeystoneV2Client(authURL, userName, password, tenantName string) (KeystoneClient, error) { opts := gophercloud.AuthOptions{ IdentityEndpoint: authURL, Username: userName, Password: password, TenantName: tenantName, AllowReauth: true, } client, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } return &keystoneV2Client{client: openstack.NewIdentityV2(client)}, nil }
func (keystoneAuthenticator *KeystoneAuthenticator) AuthenticatePassword(username string, password string) (user.Info, bool, error) { opts := gophercloud.AuthOptions{ IdentityEndpoint: keystoneAuthenticator.authURL, Username: username, Password: password, } _, err := openstack.AuthenticatedClient(opts) if err != nil { glog.Info("Failed: Starting openstack authenticate client") return nil, false, errors.New("Failed to authenticate") } return &user.DefaultInfo{Name: username}, true, nil }
func TestGetTokenWhenValid(t *testing.T) { // setup opts := testConfig.AuthOptions provider, err := openstack.AuthenticatedClient(opts) assert.NoError(t, err) client := openstack.NewIdentityV3(provider) ksClient := &KeystoneClientImpl{client: client, opts: opts, token: validToken, monascaURL: nil} // do token, err := ksClient.GetToken() // assert assert.NoError(t, err) assert.Equal(t, token, testToken) }
func newClient() (*gophercloud.ServiceClient, error) { ao, err := openstack.AuthOptionsFromEnv() if err != nil { return nil, err } client, err := openstack.AuthenticatedClient(ao) if err != nil { return nil, err } return openstack.NewComputeV2(client, gophercloud.EndpointOpts{ Region: os.Getenv("OS_REGION_NAME"), }) }
func NewNeutronMapper() (*NeutronMapper, error) { mapper := &NeutronMapper{} authURL := config.GetConfig().Section("openstack").Key("auth_url").String() username := config.GetConfig().Section("openstack").Key("username").String() password := config.GetConfig().Section("openstack").Key("password").String() tenantName := config.GetConfig().Section("openstack").Key("tenant_name").String() regionName := config.GetConfig().Section("openstack").Key("region_name").String() opts := gophercloud.AuthOptions{ IdentityEndpoint: authURL, Username: username, Password: password, TenantName: tenantName, } provider, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } /* TODO(safchain) add config param for the Availability */ client, err := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Name: "neutron", Region: regionName, Availability: gophercloud.AvailabilityPublic, }) if err != nil { return nil, err } mapper.client = client // Create a cache with a default expiration time of 5 minutes, and which // purges expired items every 30 seconds expire, err := config.GetConfig().Section("cache").Key("expire").Int() if err != nil { return nil, err } cleanup, err := config.GetConfig().Section("cache").Key("cleanup").Int() if err != nil { return nil, err } mapper.cache = cache.New(time.Duration(expire)*time.Second, time.Duration(cleanup)*time.Second) mapper.cacheUpdaterChan = make(chan string) go mapper.cacheUpdater() return mapper, nil }
// Authenticate is used to authenticate user for given tenant. Request is send to provided Keystone endpoint // Returns authenticated provider client, which is used as a base for service clients. func Authenticate(endpoint, user, password, tenant string) (*gophercloud.ProviderClient, error) { authOpts := gophercloud.AuthOptions{ IdentityEndpoint: endpoint, Username: user, Password: password, TenantName: tenant, AllowReauth: true, } provider, err := openstack.AuthenticatedClient(authOpts) if err != nil { return nil, err } return provider, nil }
// initComputeClient initializes openstack api using // gophercloud which handles auth tokens keeping api calls // simpler. Currently it uses environment variables for // authenticating with openstack identity. func initComputeClient() (*gophercloud.ServiceClient, error) { opts, err := openstack.AuthOptionsFromEnv() if err != nil { log.Println("Error fetching openstack env vars: ", err) return nil, err } provider, err := openstack.AuthenticatedClient(opts) if err != nil { log.Println("Error authenticating with openstack: ", err) return nil, err } return openstack.NewComputeV2(provider, gophercloud.EndpointOpts{ Name: "compute", Region: os.Getenv("OS_REGION_NAME"), }) }
func Init() (storagedriver.Driver, error) { instanceID, err := getInstanceID() if err != nil { return nil, fmt.Errorf("Error: %v", err) } region, err := getInstanceRegion() if err != nil { return nil, fmt.Errorf("Error: %v", err) } opts, err := openstack.AuthOptionsFromEnv() if err != nil { return nil, fmt.Errorf("Error: %v", err) } provider, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, fmt.Errorf("Error: %v", err) } region = strings.ToUpper(region) client, err := openstack.NewComputeV2(provider, gophercloud.EndpointOpts{ Region: region, }) if err != nil { return nil, fmt.Errorf("Error: %v", err) } clientBlockStorage, err := openstack.NewBlockStorageV1(provider, gophercloud.EndpointOpts{ Region: region, }) if err != nil { return nil, fmt.Errorf("Error: %v", err) } driver := &Driver{ Provider: provider, Client: client, ClientBlockStorage: clientBlockStorage, Region: region, InstanceID: instanceID, } return driver, nil }
func TestKeystoneClientReauthenticate(t *testing.T) { // setup opts := testConfig.AuthOptions provider, err := openstack.AuthenticatedClient(opts) assert.NoError(t, err) client := openstack.NewIdentityV3(provider) client.TokenID = "someinvalidtoken" client.ReauthFunc = func() error { return openstack.AuthenticateV3(client.ProviderClient, opts) } ksClient := &KeystoneClientImpl{client: client, opts: opts, token: validToken, monascaURL: nil} // do token, err := ksClient.GetToken() // assert assert.NoError(t, err) assert.Equal(t, token, testToken) }
func NewObjectStorageClient(a gophercloud.AuthOptions, region string) (*gophercloud.ServiceClient, error) { // authenticate with provider provider, err := openstack.AuthenticatedClient(a) if err != nil { return nil, err } // Create a new client to the provider client, err := openstack.NewObjectStorageV1(provider, gophercloud.EndpointOpts{ Region: region, }) if err != nil { return nil, err } return client, nil }
func (s *Swift) Auth() error { if s.authOptions.Username != "" { log.Debugf("(OpenStack) Authenticate by username(%s)", s.authOptions.Username) } else if s.authOptions.UserID != "" { log.Debugf("(OpenStack) Authenticate by user-id(%s)", s.authOptions.UserID) } else { log.Debugf("(OpenStack) Authenticate") } provider, err := openstack.AuthenticatedClient(s.authOptions) if err != nil { return err } s.client, err = openstack.NewObjectStorageV1(provider, s.endpointOptions) if err != nil { return err } return nil }
func (c *Config) loadAndValidate() error { ao := gophercloud.AuthOptions{ Username: c.Username, UserID: c.UserID, Password: c.Password, APIKey: c.APIKey, IdentityEndpoint: c.IdentityEndpoint, TenantID: c.TenantID, TenantName: c.TenantName, DomainID: c.DomainID, DomainName: c.DomainName, } client, err := openstack.AuthenticatedClient(ao) if err != nil { return err } c.osClient = client return nil }
func get_token() (*tokens.Token, error) { authOpts, err := openstack.AuthOptionsFromEnv() // authOpts := gophercloud.AuthOptions{ // IdentityEndpoint: endpoint, // Username: username, // Password: pass, // TenantID: tenantid, // } provider, err := openstack.AuthenticatedClient(authOpts) client := openstack.NewIdentityV2(provider) opts := tokens.AuthOptions{authOpts} bearer_token, err := tokens.Create(client, opts).ExtractToken() if err != nil { return nil, err } return bearer_token, nil }
func NewNeutronMapper(g *graph.Graph, authURL string, username string, password string, tenantName string, regionName string) (*NeutronMapper, error) { mapper := &NeutronMapper{graph: g} opts := gophercloud.AuthOptions{ IdentityEndpoint: authURL, Username: username, Password: password, TenantName: tenantName, AllowReauth: true, } provider, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } /* TODO(safchain) add config param for the Availability */ client, err := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Name: "neutron", Region: regionName, Availability: gophercloud.AvailabilityPublic, }) if err != nil { return nil, err } mapper.client = client // Create a cache with a default expiration time of 5 minutes, and which // purges expired items every 30 seconds expire := config.GetConfig().GetInt("cache.expire") cleanup := config.GetConfig().GetInt("cache.cleanup") mapper.cache = cache.New(time.Duration(expire)*time.Second, time.Duration(cleanup)*time.Second) mapper.nodeUpdaterChan = make(chan graph.Identifier, 500) g.AddEventListener(mapper) return mapper, nil }