func GetClient(project string, region string, cache_path string) (Client, error) {
c := Client{}
cache, err := config.LoadCredCache(cache_path)
if err != nil {
fmt.Println("unable to get cache")
return c, err
}
c.cache = cache
if region == "" {
region = defaultRegion
}
c.region = region
if c.cache.Rackspace.User == "" || c.cache.Rackspace.APIKey == "" {
var rack_user string
var rack_pass string
fmt.Printf("rackspace user: "******"%s", &rack_user)
if err != nil {
return c, err
}
fmt.Printf("rackspace api key: ")
_, err = fmt.Scanf("%s", &rack_pass)
if err != nil {
return c, err
}
c.cache.Rackspace.User = rack_user
c.cache.Rackspace.APIKey = rack_pass
c.cache.Save()
if err != nil {
return c, err
}
}
ao := gophercloud.AuthOptions{
Username: c.cache.Rackspace.User,
ApiKey: c.cache.Rackspace.APIKey,
AllowReauth: true,
}
access, err := gophercloud.Authenticate("rackspace-us", ao)
if err != nil {
c.cache.Rackspace.User = ""
c.cache.Rackspace.APIKey = ""
c.cache.Save()
return c, err
}
ac, err := gophercloud.PopulateApi("rackspace")
if err != nil {
return c, err
}
client, err := gophercloud.ServersApi(access, ac)
if err != nil {
return c, err
}
c.client = client
return c, nil
}
func (rax *RaxCloud) createGopherCtx() (err error) {
var (
provider string
authOptions gophercloud.AuthOptions
apiCriteria gophercloud.ApiCriteria
access *gophercloud.Access
csp gophercloud.CloudServersProvider
)
// Create our auth options set by the user's environment
provider, authOptions, err = getAuthOptions()
if err != nil {
return err
}
// Set our API criteria
apiCriteria, err = gophercloud.PopulateApi("rackspace-us")
if err != nil {
return err
}
// Set the region
apiCriteria.Type = "compute"
apiCriteria.Region = os.Getenv("OS_REGION_NAME")
if rax.regionOverride != "" {
log.Printf("Overriding region set in env with %s", rax.regionOverride)
apiCriteria.Region = rax.regionOverride
}
if apiCriteria.Region == "" {
return fmt.Errorf("No region set. Please set the OS_REGION_NAME environment variable or use the --region flag.")
}
// Attempt to authenticate
access, err = gophercloud.Authenticate(provider, authOptions)
if err != nil {
fmt.Printf("ERROR: %v\n\n\n", err)
return err
}
// Get a CSP ref!
csp, err = gophercloud.ServersApi(access, apiCriteria)
if err != nil {
return err
}
rax.gopher = csp
return nil
}
func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
auth, err := b.config.AccessConfig.Auth()
if err != nil {
return nil, err
}
//fetches the api requisites from gophercloud for the appropriate
//openstack variant
api, err := gophercloud.PopulateApi(b.config.RunConfig.OpenstackProvider)
if err != nil {
return nil, err
}
api.Region = b.config.AccessConfig.Region()
csp, err := gophercloud.ServersApi(auth, api)
if err != nil {
log.Printf("Region: %s", b.config.AccessConfig.Region())
return nil, err
}
// Setup the state bag and initial state for the steps
state := new(multistep.BasicStateBag)
state.Put("config", b.config)
state.Put("csp", csp)
state.Put("hook", hook)
state.Put("ui", ui)
// Build the steps
steps := []multistep.Step{
&StepKeyPair{
Debug: b.config.PackerDebug,
DebugKeyPath: fmt.Sprintf("os_%s.pem", b.config.PackerBuildName),
},
&StepRunSourceServer{
Name: b.config.ImageName,
Flavor: b.config.Flavor,
SourceImage: b.config.SourceImage,
},
&common.StepConnectSSH{
SSHAddress: SSHAddress(csp, b.config.SSHPort),
SSHConfig: SSHConfig(b.config.SSHUsername),
SSHWaitTimeout: b.config.SSHTimeout(),
},
&common.StepProvision{},
&stepCreateImage{},
}
// Run!
if b.config.PackerDebug {
b.runner = &multistep.DebugRunner{
Steps: steps,
PauseFn: common.MultistepDebugFn(ui),
}
} else {
b.runner = &multistep.BasicRunner{Steps: steps}
}
b.runner.Run(state)
// If there was an error, return that
if rawErr, ok := state.GetOk("error"); ok {
return nil, rawErr.(error)
}
// If there are no images, then just return
if _, ok := state.GetOk("image"); !ok {
return nil, nil
}
// Build the artifact and return it
artifact := &Artifact{
ImageId: state.Get("image").(string),
BuilderIdValue: BuilderId,
Conn: csp,
}
return artifact, nil
}
func New(authURL, providerName string, credential, builder map[string]interface{}) (*Openstack, error) {
// OpenStack's auto-generated openrc.sh files do not append the suffix
// /tokens to the authentication URL. This ensures it is present when
// specifying the URL.
if strings.Contains(authURL, "://") && !strings.HasSuffix(authURL, "/tokens") {
authURL += "/tokens"
}
o := &Openstack{
AuthURL: authURL,
Provider: providerName,
}
// Credentials
if err := mapstructure.Decode(credential, &o.Creds); err != nil {
return nil, err
}
// Builder data
if err := mapstructure.Decode(builder, &o.Builder); err != nil {
return nil, err
}
if o.Creds.Username == "" {
return nil, errors.New("Username is not set")
}
if o.Creds.Password == "" && o.Creds.ApiKey == "" {
return nil, errors.New("Password/ApiKey is not set")
}
authoptions := gophercloud.AuthOptions{
AllowReauth: true,
ApiKey: o.Creds.ApiKey,
TenantId: o.Creds.TenantId,
TenantName: o.Creds.TenantName,
Username: o.Creds.Username,
Password: o.Creds.Password,
}
access, err := gophercloud.Authenticate(authURL, authoptions)
if err != nil {
return nil, err
}
//fetches the api requisites from gophercloud for the appropriate
//openstack variant
api, err := gophercloud.PopulateApi(providerName)
if err != nil {
return nil, err
}
// if not given the default is used which is returned for that account.
if o.Builder.RawRegion != "" {
api.Region = o.Builder.RawRegion
}
csp, err := gophercloud.ServersApi(access, api)
if err != nil {
log.Printf("Region: %s", o.Builder.RawRegion)
return nil, err
}
o.Client = csp
return o, nil
}