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
}
// GetTenants is used to retrieve list of available tenant for authenticated user
// List of tenants can then be used to authenticate user for each given tenant
func (c Common) GetTenants(endpoint, user, password string) (map[string]string, error) {
tnts := map[string]string{}
provider, err := Authenticate(endpoint, user, password, "")
if err != nil {
return nil, err
}
client := openstack.NewIdentityV2(provider)
opts := tenants.ListOpts{}
pager := tenants.List(client, &opts)
page, err := pager.AllPages()
if err != nil {
return tnts, err
}
tenantList, err := tenants.ExtractTenants(page)
if err != nil {
return tnts, err
}
for _, t := range tenantList {
tnts[t.ID] = t.Name
}
return tnts, nil
}
func TestGetQuotaset(t *testing.T) {
client, err := newClient()
if err != nil {
t.Fatalf("Unable to create a compute client: %v", err)
}
idclient := openstack.NewIdentityV2(client.ProviderClient)
quotaset, err := quotasets.Get(client, findTenant(t, idclient)).Extract()
if err != nil {
t.Fatal(err)
}
t.Logf("QuotaSet details:\n")
t.Logf(" instances=[%d]\n", quotaset.Instances)
t.Logf(" cores=[%d]\n", quotaset.Cores)
t.Logf(" ram=[%d]\n", quotaset.Ram)
t.Logf(" key_pairs=[%d]\n", quotaset.KeyPairs)
t.Logf(" metadata_items=[%d]\n", quotaset.MetadataItems)
t.Logf(" security_groups=[%d]\n", quotaset.SecurityGroups)
t.Logf(" security_group_rules=[%d]\n", quotaset.SecurityGroupRules)
t.Logf(" fixed_ips=[%d]\n", quotaset.FixedIps)
t.Logf(" floating_ips=[%d]\n", quotaset.FloatingIps)
t.Logf(" injected_file_content_bytes=[%d]\n", quotaset.InjectedFileContentBytes)
t.Logf(" injected_file_path_bytes=[%d]\n", quotaset.InjectedFilePathBytes)
t.Logf(" injected_files=[%d]\n", quotaset.InjectedFiles)
}
func (c *GenericClient) InitIdentityClient(d *Driver) error {
if c.Identity != nil {
return nil
}
identity := openstack.NewIdentityV2(c.Provider)
c.Identity = identity
return nil
}
func createClient(t *testing.T, auth bool) *gophercloud.ServiceClient {
ao := v2AuthOptions(t)
provider, err := openstack.NewClient(ao.IdentityEndpoint)
th.AssertNoErr(t, err)
if auth {
err = openstack.AuthenticateV2(provider, ao)
th.AssertNoErr(t, err)
}
return openstack.NewIdentityV2(provider)
}
// 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
}
//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 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
}
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
}
//GetOpenstackClient makes openstack client
func GetOpenstackClient(authURL, userName, password, domainName, tenantName, version string) (*gophercloud.ServiceClient, error) {
opts := gophercloud.AuthOptions{
IdentityEndpoint: authURL,
Username: userName,
Password: password,
DomainName: domainName,
TenantName: tenantName,
AllowReauth: true,
}
client, err := openstack.AuthenticatedClient(opts)
if err != nil {
return nil, err
}
client.HTTPClient = cloud.NewHTTPClient()
if version == "v2.0" {
return openstack.NewIdentityV2(client), nil
} else if version == "v3" {
return openstack.NewIdentityV3(client), nil
} else {
return nil, fmt.Errorf("Unsupported keystone version: %s", version)
}
}