// 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
}