func NewSwift(c *config.Config) *Swift { s := &Swift{} // Auth options var err error s.authOptions, err = openstack.AuthOptionsFromEnv() if err == nil { log.Debugf("(OpenStack) Use auth parameters in ENV.") } else { log.Debugf("(OpenStack) Use auth parameters via command-line options.") s.authOptions = gophercloud.AuthOptions{ IdentityEndpoint: c.IdentityEndpoint, UserID: c.UserID, Username: c.Username, Password: c.Password, TenantID: c.TenantID, TenantName: c.TenantName, } } // Endpoint options s.endpointOptions = gophercloud.EndpointOpts{} if c.RegionName != "" { s.endpointOptions.Region = c.RegionName } // Enable auto reauth s.authOptions.AllowReauth = true // Container Name s.containerName = c.ContainerName return s }
func createAuthenticatedClient(t *testing.T) *gophercloud.ServiceClient { // Obtain credentials from the environment. ao, err := openstack.AuthOptionsFromEnv() th.AssertNoErr(t, err) // Trim out unused fields. ao.Username, ao.TenantID, ao.TenantName = "", "", "" if ao.UserID == "" { t.Logf("Skipping identity v3 tests because no OS_USERID is present.") return nil } // Create a client and manually authenticate against v3. providerClient, err := openstack.NewClient(ao.IdentityEndpoint) if err != nil { t.Fatalf("Unable to instantiate client: %v", err) } err = openstack.AuthenticateV3(providerClient, ao) if err != nil { t.Fatalf("Unable to authenticate against identity v3: %v", err) } // Create a service client. return openstack.NewIdentityV3(providerClient) }
func TestGetToken(t *testing.T) { // Obtain credentials from the environment. ao, err := openstack.AuthOptionsFromEnv() if err != nil { t.Fatalf("Unable to acquire credentials: %v", err) } // Trim out unused fields. Skip if we don't have a UserID. ao.Username, ao.TenantID, ao.TenantName = "", "", "" if ao.UserID == "" { t.Logf("Skipping identity v3 tests because no OS_USERID is present.") return } // Create an unauthenticated client. provider, err := openstack.NewClient(ao.IdentityEndpoint) if err != nil { t.Fatalf("Unable to instantiate client: %v", err) } // Create a service client. service := openstack.NewIdentityV3(provider) // Use the service to create a token. token, err := tokens3.Create(service, ao, nil).Extract() if err != nil { t.Fatalf("Unable to get token: %v", err) } t.Logf("Acquired token: %s", token.ID) }
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 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 v2AuthOptions(t *testing.T) gophercloud.AuthOptions { // Obtain credentials from the environment. ao, err := openstack.AuthOptionsFromEnv() th.AssertNoErr(t, err) // Trim out unused fields. Prefer authentication by API key to password. ao.UserID, ao.DomainID, ao.DomainName = "", "", "" if ao.APIKey != "" { ao.Password = "" } return ao }
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 }
// 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 }
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 }
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 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"), }) }
// 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 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 (c *AccessConfig) Prepare(ctx *interpolate.Context) []error { if c.EndpointType != "internal" && c.EndpointType != "internalURL" && c.EndpointType != "admin" && c.EndpointType != "adminURL" && c.EndpointType != "public" && c.EndpointType != "publicURL" && c.EndpointType != "" { return []error{fmt.Errorf("Invalid endpoint type provided")} } if c.Region == "" { c.Region = os.Getenv("OS_REGION_NAME") } // Legacy RackSpace stuff. We're keeping this around to keep things BC. if c.APIKey == "" { c.APIKey = os.Getenv("SDK_API_KEY") } if c.Password == "" { c.Password = os.Getenv("SDK_PASSWORD") } if c.Region == "" { c.Region = os.Getenv("SDK_REGION") } if c.TenantName == "" { c.TenantName = os.Getenv("SDK_PROJECT") } if c.Username == "" { c.Username = os.Getenv("SDK_USERNAME") } // Get as much as possible from the end ao, _ := openstack.AuthOptionsFromEnv() // Override values if we have them in our config overrides := []struct { From, To *string }{ {&c.Username, &ao.Username}, {&c.UserID, &ao.UserID}, {&c.Password, &ao.Password}, {&c.APIKey, &ao.APIKey}, {&c.IdentityEndpoint, &ao.IdentityEndpoint}, {&c.TenantID, &ao.TenantID}, {&c.TenantName, &ao.TenantName}, {&c.DomainID, &ao.DomainID}, {&c.DomainName, &ao.DomainName}, } for _, s := range overrides { if *s.From != "" { *s.To = *s.From } } // Build the client itself client, err := openstack.NewClient(ao.IdentityEndpoint) if err != nil { return []error{err} } // If we have insecure set, then create a custom HTTP client that // ignores SSL errors. if c.Insecure { config := &tls.Config{InsecureSkipVerify: true} transport := &http.Transport{TLSClientConfig: config} client.HTTPClient.Transport = transport } // Auth err = openstack.Authenticate(client, ao) if err != nil { return []error{err} } c.osClient = client return nil }