// Attaches given cinder volume to the compute running kubelet func (os *OpenStack) AttachDisk(instanceID string, diskName string) (string, error) { disk, err := os.getVolume(diskName) if err != nil { return "", err } cClient, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil || cClient == nil { glog.Errorf("Unable to initialize nova client for region: %s", os.region) return "", err } if len(disk.Attachments) > 0 && disk.Attachments[0]["server_id"] != nil { if instanceID == disk.Attachments[0]["server_id"] { glog.V(4).Infof("Disk: %q is already attached to compute: %q", diskName, instanceID) return disk.ID, nil } else { errMsg := fmt.Sprintf("Disk %q is attached to a different compute: %q, should be detached before proceeding", diskName, disk.Attachments[0]["server_id"]) glog.Errorf(errMsg) return "", errors.New(errMsg) } } // add read only flag here if possible spothanis _, err = volumeattach.Create(cClient, instanceID, &volumeattach.CreateOpts{ VolumeID: disk.ID, }).Extract() if err != nil { glog.Errorf("Failed to attach %s volume to %s compute", diskName, instanceID) return "", err } glog.V(2).Infof("Successfully attached %s volume to %s compute", diskName, instanceID) return disk.ID, nil }
func (os *OpenStack) TCPLoadBalancer() (cloudprovider.TCPLoadBalancer, bool) { glog.V(4).Info("openstack.TCPLoadBalancer() called") if err := openstack.Authenticate(os.provider, os.authOpts); err != nil { glog.Warningf("Failed to reauthenticate: %v", err) return nil, false } // TODO: Search for and support Rackspace loadbalancer API, and others. network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find neutron endpoint: %v", err) return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } glog.V(1).Info("Claiming to support TCPLoadBalancer") return &LoadBalancer{network, compute, os.lbOpts}, true }
// Detaches given cinder volume from the compute running kubelet func (os *OpenStack) DetachDisk(instanceID string, partialDiskId string) error { disk, err := os.getVolume(partialDiskId) if err != nil { return err } cClient, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil || cClient == nil { glog.Errorf("Unable to initialize nova client for region: %s", os.region) return err } if len(disk.Attachments) > 0 && disk.Attachments[0]["server_id"] != nil && instanceID == disk.Attachments[0]["server_id"] { // This is a blocking call and effects kubelet's performance directly. // We should consider kicking it out into a separate routine, if it is bad. err = volumeattach.Delete(cClient, instanceID, disk.ID).ExtractErr() if err != nil { glog.Errorf("Failed to delete volume %s from compute %s attached %v", disk.ID, instanceID, err) return err } glog.V(2).Infof("Successfully detached volume: %s from compute: %s", disk.ID, instanceID) } else { errMsg := fmt.Sprintf("Disk: %s has no attachments or is not attached to compute: %s", disk.Name, instanceID) glog.Errorf(errMsg) return errors.New(errMsg) } return nil }
func (os *OpenStack) LoadBalancer() (cloudprovider.LoadBalancer, bool) { glog.V(4).Info("openstack.LoadBalancer() called") // TODO: Search for and support Rackspace loadbalancer API, and others. network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find neutron endpoint: %v", err) return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } glog.V(1).Info("Claiming to support LoadBalancer") if os.lbOpts.LBVersion == "v2" { return &LbaasV2{LoadBalancer{network, compute, os.lbOpts}}, true } else { return &LbaasV1{LoadBalancer{network, compute, os.lbOpts}}, true } }
func (c *Config) computeClient() (*gophercloud.ServiceClient, error) { providerClient, err := c.client() if err != nil { return nil, err } return openstack.NewComputeV2(providerClient, gophercloud.EndpointOpts{Region: c.Region}) }
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 (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 (os *OpenStack) LoadBalancer() (cloudprovider.LoadBalancer, bool) { glog.V(4).Info("openstack.LoadBalancer() called") // TODO: Search for and support Rackspace loadbalancer API, and others. network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find network endpoint: %v", err) return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } lbversion := os.lbOpts.LBVersion if lbversion == "" { // No version specified, try newest supported by server netExts, err := networkExtensions(network) if err != nil { glog.Warningf("Failed to list neutron extensions: %v", err) return nil, false } if netExts["lbaasv2"] { lbversion = "v2" } else if netExts["lbaas"] { lbversion = "v1" } else { glog.Warningf("Failed to find neutron LBaaS extension (v1 or v2)") return nil, false } glog.V(3).Infof("Using LBaaS extension %v", lbversion) } glog.V(1).Info("Claiming to support LoadBalancer") if lbversion == "v2" { return &LbaasV2{LoadBalancer{network, compute, os.lbOpts}}, true } else if lbversion == "v1" { return &LbaasV1{LoadBalancer{network, compute, os.lbOpts}}, true } else { glog.Warningf("Config error: unrecognised lb-version \"%v\"", lbversion) return nil, false } }
func (c *GenericClient) InitComputeClient(d *Driver) error { if c.Compute != nil { return nil } compute, err := openstack.NewComputeV2(c.Provider, gophercloud.EndpointOpts{ Region: d.Region, Availability: c.getEndpointType(d), }) if err != nil { return err } c.Compute = compute return nil }
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"), }) }
// Instances returns an implementation of Instances for OpenStack. func (os *OpenStack) Instances() (cloudprovider.Instances, bool) { glog.V(4).Info("openstack.Instances() called") if err := openstack.Authenticate(os.provider, os.authOpts); err != nil { glog.Warningf("Failed to reauthenticate: %v", err) return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } pager := flavors.ListDetail(compute, nil) flavor_to_resource := make(map[string]*api.NodeResources) err = pager.EachPage(func(page pagination.Page) (bool, error) { flavorList, err := flavors.ExtractFlavors(page) if err != nil { return false, err } for _, flavor := range flavorList { rsrc := api.NodeResources{ Capacity: api.ResourceList{ api.ResourceCPU: *resource.NewQuantity(int64(flavor.VCPUs), resource.DecimalSI), api.ResourceMemory: *resource.NewQuantity(int64(flavor.RAM)*MiB, resource.BinarySI), "openstack.org/disk": *resource.NewQuantity(int64(flavor.Disk)*GB, resource.DecimalSI), "openstack.org/rxTxFactor": *resource.NewMilliQuantity(int64(flavor.RxTxFactor)*1000, resource.DecimalSI), "openstack.org/swap": *resource.NewQuantity(int64(flavor.Swap)*MiB, resource.BinarySI), }, } flavor_to_resource[flavor.ID] = &rsrc } return true, nil }) if err != nil { glog.Warningf("Failed to find compute flavors: %v", err) return nil, false } glog.V(3).Infof("Found %v compute flavors", len(flavor_to_resource)) glog.V(1).Info("Claiming to support Instances") return &Instances{compute, flavor_to_resource}, true }
// 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 (os *OpenStack) Routes() (cloudprovider.Routes, bool) { glog.V(4).Info("openstack.Routes() called") network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find network endpoint: %v", err) return nil, false } netExts, err := networkExtensions(network) if err != nil { glog.Warningf("Failed to list neutron extensions: %v", err) return nil, false } if !netExts["extraroute"] { glog.V(3).Infof("Neutron extraroute extension not found, required for Routes support") return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } r, err := NewRoutes(compute, network, os.routeOpts) if err != nil { glog.Warningf("Error initialising Routes support: %v", err) return nil, false } glog.V(1).Info("Claiming to support Routes") return r, true }
func FetchPublicKey(userName string, config *Config) (*keypairs.KeyPair, error) { regionOpts := gophercloud.EndpointOpts{Region: config.Region} provider, err := initClient(config) if err != nil { return nil, err } computeClient, err := openstack.NewComputeV2(provider, regionOpts) if err != nil { return nil, err } key, err := FindKeyPairByName(computeClient, userName) if err != nil { return nil, err } return key, nil }
func main() { // step-1 var authUsername string = "your_auth_username" var authPassword string = "your_auth_password" var authUrl string = "http://controller:5000" var projectName string = "your_project_id" var regionName string = "your_region_name" authOpts := gophercloud.AuthOptions{ IdentityEndpoint: authUrl, Username: authUsername, Password: authPassword, TenantID: projectName, } provider, _ := openstack.AuthenticatedClient(authOpts) client, _ := openstack.NewComputeV2(provider, gophercloud.EndpointOpts{ Region: regionName, }) // step-2 pager := images.ListDetail(client, images.ListOpts{}) page, _ := pager.AllPages() imageList, _ := images.ExtractImages(page) fmt.Println(imageList) // step-3 pager = flavors.ListDetail(client, flavors.ListOpts{}) page, _ = pager.AllPages() flavorList, _ := flavors.ExtractFlavors(page) fmt.Println(flavorList) // step-4 imageID := "74e6d1ec-9a08-444c-8518-4f232446386d" image, _ := images.Get(client, imageID).Extract() fmt.Println(image) // step-5 flavorID := "1" flavor, _ := flavors.Get(client, flavorID).Extract() fmt.Println(flavor) // step-6 instanceName := "testing" testingInstance, _ := servers.Create(client, servers.CreateOpts{ Name: instanceName, ImageRef: imageID, FlavorRef: flavorID, }).Extract() fmt.Println(testingInstance) // step-7 pager = servers.List(client, servers.ListOpts{}) page, _ = pager.AllPages() serverList, _ := servers.ExtractServers(page) fmt.Println(serverList) // step-8 servers.Delete(client, testingInstance.ID) // step-9 fmt.Println("Checking for existing SSH key pair...") keyPairName := "demokey" pubKeyFile := "~/.ssh/id_rsa.pub" keyPairExists := false pager = keypairs.List(client) page, _ = pager.AllPages() keypairList, _ := keypairs.ExtractKeyPairs(page) for _, k := range keypairList { if k.Name == keyPairName { keyPairExists = true break } } if keyPairExists { fmt.Println("Keypair " + keyPairName + " already exists. Skipping import.") } else { fmt.Println("adding keypair...") bs, _ := ioutil.ReadFile(pubKeyFile) keypairs.Create(client, keypairs.CreateOpts{ Name: keyPairName, PublicKey: string(bs), }).Extract() } pager = keypairs.List(client) page, _ = pager.AllPages() keypairList, _ = keypairs.ExtractKeyPairs(page) fmt.Println(keypairList) // step-10 fmt.Println("Checking for existing security group...") var allInOneSecurityGroup secgroups.SecurityGroup securityGroupName := "all-in-one" securityGroupExists := false pager = secgroups.List(client) page, _ = pager.AllPages() secgroupList, _ := secgroups.ExtractSecurityGroups(page) for _, secGroup := range secgroupList { if secGroup.Name == securityGroupName { allInOneSecurityGroup = secGroup securityGroupExists = true break } } if securityGroupExists { fmt.Println("Security Group " + allInOneSecurityGroup.Name + " already exists. Skipping creation.") } else { allInOneSecurityGroup, _ := secgroups.Create(client, secgroups.CreateOpts{ Name: securityGroupName, Description: "network access for all-in-one application.", }).Extract() secgroups.CreateRule(client, secgroups.CreateRuleOpts{ ParentGroupID: allInOneSecurityGroup.ID, FromPort: 80, ToPort: 80, IPProtocol: "TCP", CIDR: "0.0.0.0/0", }).Extract() secgroups.CreateRule(client, secgroups.CreateRuleOpts{ ParentGroupID: allInOneSecurityGroup.ID, FromPort: 22, ToPort: 22, IPProtocol: "TCP", CIDR: "0.0.0.0/0", }).Extract() } pager = secgroups.List(client) page, _ = pager.AllPages() secgroupList, _ = secgroups.ExtractSecurityGroups(page) fmt.Println(secgroupList) // step-11 userData := `#!/usr/bin/env bash curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \ -i faafo -i messaging -r api -r worker -r demo ` // step-12 fmt.Println("Checking for existing instance...") instanceName = "all-in-one" instanceExists := false pager = servers.List(client, servers.ListOpts{}) page, _ = pager.AllPages() serverList, _ = servers.ExtractServers(page) for _, s := range serverList { if s.Name == instanceName { testingInstance = &s instanceExists = true break } } if instanceExists { fmt.Println("Instance " + testingInstance.Name + " already exists. Skipping creation.") } else { opts := servers.CreateOpts{ Name: instanceName, ImageRef: image.ID, FlavorRef: flavor.ID, SecurityGroups: []string{securityGroupName}, UserData: []byte(userData), } testingInstance, _ = servers.Create(client, keypairs.CreateOptsExt{ CreateOptsBuilder: opts, KeyName: keyPairName, }).Extract() } servers.WaitForStatus(client, testingInstance.ID, "ACTIVE", 300) pager = servers.List(client, servers.ListOpts{}) page, _ = pager.AllPages() serverList, _ = servers.ExtractServers(page) fmt.Println(serverList) // step-13 var privateIP string for t, addrs := range testingInstance.Addresses { if t != "private" || len(privateIP) != 0 { continue } addrs, ok := addrs.([]interface{}) if !ok { continue } for _, addr := range addrs { a, ok := addr.(map[string]interface{}) if !ok || a["version"].(float64) != 4 { continue } ip, ok := a["addr"].(string) if ok && len(ip) != 0 { privateIP = ip fmt.Println("Private IP found: " + privateIP) break } } } // step-14 var publicIP string for t, addrs := range testingInstance.Addresses { if t != "public" || len(publicIP) != 0 { continue } addrs, ok := addrs.([]interface{}) if !ok { continue } for _, addr := range addrs { a, ok := addr.(map[string]interface{}) if !ok || a["version"].(float64) != 4 { continue } ip, ok := a["addr"].(string) if ok && len(ip) != 0 { publicIP = ip fmt.Println("Public IP found: " + publicIP) break } } } // step-15 fmt.Println("Checking for unused Floating IP...") var unusedFloatingIP string pager = floatingip.List(client) page, _ = pager.AllPages() floatingIPList, _ := floatingip.ExtractFloatingIPs(page) for _, ip := range floatingIPList { if ip.InstanceID == "" { unusedFloatingIP = ip.IP break } } networkClient, _ := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Region: regionName, }) pager = networks.List(networkClient, networks.ListOpts{}) page, _ = pager.AllPages() poolList, _ := external.ExtractList(page) for _, pool := range poolList { if len(unusedFloatingIP) != 0 || !pool.External { continue } fmt.Println("Allocating new Floating IP from pool: " + pool.Name) f, _ := floatingip.Create(client, floatingip.CreateOpts{Pool: pool.Name}).Extract() unusedFloatingIP = f.IP } // step-16 if len(publicIP) != 0 { fmt.Println("Instance " + testingInstance.Name + " already has a public ip. Skipping attachment.") } else { floatingip.Associate(client, testingInstance.ID, unusedFloatingIP) } // step-17 var actualIPAddress string if len(publicIP) != 0 { actualIPAddress = publicIP } else if len(unusedFloatingIP) != 0 { actualIPAddress = unusedFloatingIP } else { actualIPAddress = privateIP } fmt.Println("The Fractals app will be deployed to http://" + actualIPAddress) }
func (c *Config) computeV2Client(region string) (*gophercloud.ServiceClient, error) { return openstack.NewComputeV2(c.osClient, gophercloud.EndpointOpts{ Region: region, }) }
func (c *AccessConfig) computeV2Client() (*gophercloud.ServiceClient, error) { return openstack.NewComputeV2(c.osClient, gophercloud.EndpointOpts{ Region: c.Region, Availability: c.getEndpointType(), }) }
func Run() error { var configPath string var commitsToFile bool var target string var verbose bool var showsVersion bool var randomDelay int flag.BoolVar(&commitsToFile, "w", false, "Write to file") flag.StringVar(&target, "t", "/etc/hosts", "Target file to write hosts") flag.BoolVar(&verbose, "V", false, "Verbose mode") flag.StringVar(&configPath, "c", "/etc/monkfish.ini", "Config path") flag.BoolVar(&showsVersion, "version", false, "Just show version and quit") flag.IntVar(&randomDelay, "random-delay", 0, "Random delay before to access OpenStack API, in second") flag.Parse() if showsVersion { showVersion() } loggerf := newLoggerf(verbose) conf := &MonkConf{} if err := conf.Parse(configPath); err != nil { return err } if randomDelay > 0 { hostname, _ := os.Hostname() ha := hash.Checksum([]byte(hostname)) rand.Seed(time.Now().UnixNano() + int64(ha)) delay := rand.Intn(randomDelay) loggerf("Sleeping in %d seconds...", delay) time.Sleep(time.Duration(delay) * time.Second) } auth, err := openstack.AuthenticatedClient(gophercloud.AuthOptions{ IdentityEndpoint: conf.authUrl, Username: conf.username, Password: conf.password, TenantName: conf.tenantName, }) if err != nil { return err } cli, err := openstack.NewComputeV2(auth, gophercloud.EndpointOpts{Region: conf.region}) if err != nil { return err } res, err := servers.List(cli, &servers.ListOpts{Status: "ACTIVE"}).AllPages() if err != nil { return err } svs, err := servers.ExtractServers(res) if err != nil { return err } var targetIo io.Writer if commitsToFile { targetIo, err = ioutil.TempFile("", "monkfish-work--") if err != nil { return err } } else { targetIo = os.Stdout } src, err := os.Open("/etc/hosts.base") if err == nil { data, _ := ioutil.ReadAll(src) targetIo.Write(data) targetIo.Write([]byte("\n")) } for _, i := range svs { if i.Name == "" { loggerf("skip: [%s]%s\n", i.ID, i.Name) continue } loggerf("name: %s\n", i.Name) var name string if conf.useOnlyHostname { name = strings.Split(i.Name, ".")[0] } else { name = i.Name } if wan := findWanIP(i.Addresses); wan != "" { fmt.Fprintf( targetIo, "%s\t\t%s.%s\n", wan, name, conf.domain, ) } if lan := findLanIP(i.Addresses, conf.lanIPPrefix); lan != "" { fmt.Fprintf( targetIo, "%s\t\t%s.%s\n", lan, name, conf.internalDomain, ) } } if commitsToFile { if f, ok := targetIo.(*os.File); ok { tmppath := f.Name() f.Close() os.Chmod(tmppath, 0644) loggerf("Rename %s to %s\n", tmppath, target) err = os.Rename(tmppath, target) if err != nil { return err } defer os.Remove(tmppath) } } loggerf("Complete!\n") return nil }
func Init(cfg *config.Config) (storage.Driver, error) { fields := ef() instanceID, err := getInstanceID(cfg) if err != nil { return nil, err } fields["instanceId"] = instanceID region, err := getInstanceRegion(cfg) if err != nil { return nil, err } fields["region"] = region authOpts := getAuthOptions(cfg) fields["identityEndpoint"] = cfg.RackspaceAuthUrl fields["userId"] = cfg.RackspaceUserId fields["userName"] = cfg.RackspaceUserName if cfg.RackspacePassword == "" { fields["password"] = "" } else { fields["password"] = "******" } fields["tenantId"] = cfg.RackspaceTenantId fields["tenantName"] = cfg.RackspaceTenantName fields["domainId"] = cfg.RackspaceDomainId fields["domainName"] = cfg.RackspaceDomainName provider, err := openstack.AuthenticatedClient(authOpts) if err != nil { return nil, errors.WithFieldsE(fields, "error getting authenticated client", err) } region = strings.ToUpper(region) client, err := openstack.NewComputeV2(provider, gophercloud.EndpointOpts{ Region: region, }) if err != nil { return nil, errors.WithFieldsE(fields, "error getting newComputeV2", err) } clientBlockStorage, err := openstack.NewBlockStorageV1(provider, gophercloud.EndpointOpts{ Region: region, }) if err != nil { return nil, errors.WithFieldsE( fields, "error getting newBlockStorageV1", err) } driver := &Driver{ Provider: provider, Client: client, ClientBlockStorage: clientBlockStorage, Region: region, InstanceID: instanceID, Config: cfg, } return driver, nil }
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.regionName() == "" { if d.region, err = getInstanceRegion(d.r.Config); err != nil { return err } } else { d.region = d.regionName() } fields["region"] = d.region if d.availabilityZoneName() == "" { if d.availabilityZone, err = getInstanceAvailabilityZone(); err != nil { return err } } else { d.availabilityZone = d.availabilityZoneName() } fields["availabilityZone"] = d.availabilityZone 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 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 }