func configfile(c *cli.Context, have map[string]authCred, need map[string]string) error {
dir, err := util.RackDir()
if err != nil {
// return fmt.Errorf("Error retrieving rack directory: %s\n", err)
return nil
}
f := path.Join(dir, "config")
cfg, err := ini.Load(f)
if err != nil {
// return fmt.Errorf("Error loading config file: %s\n", err)
return nil
}
cfg.BlockMode = false
var profile string
if c.GlobalIsSet("profile") {
profile = c.GlobalString("profile")
} else if c.IsSet("profile") {
profile = c.String("profile")
}
section, err := cfg.GetSection(profile)
if err != nil && profile != "" {
return fmt.Errorf("Invalid config file profile: %s\n", profile)
}
for opt := range need {
if val := section.Key(opt).String(); val != "" {
have[opt] = authCred{value: val, from: fmt.Sprintf("config file (profile: %s)", section.Name())}
delete(need, opt)
}
}
return nil
}
func configFile() (string, error) {
dir, err := util.RackDir()
if err != nil {
return "", fmt.Errorf("Error reading from cache: %s", err)
}
filepath := path.Join(dir, "config")
// check if the cache file exists
if _, err := os.Stat(filepath); err == nil {
return filepath, nil
}
// create the cache file if it doesn't already exist
f, err := os.Create(filepath)
defer f.Close()
return filepath, err
}
func ProfileSection(profile string) (*ini.Section, error) {
dir, err := util.RackDir()
if err != nil {
// return fmt.Errorf("Error retrieving rack directory: %s\n", err)
return nil, nil
}
f := path.Join(dir, "config")
cfg, err := ini.Load(f)
if err != nil {
// return fmt.Errorf("Error loading config file: %s\n", err)
return nil, nil
}
cfg.BlockMode = false
section, err := cfg.GetSection(profile)
if err != nil && profile != "" {
return nil, fmt.Errorf("Invalid config file profile: %s\n", profile)
}
return section, nil
}
// Init runs logic for setting up amenities such as command completion.
func Init(c *cli.Context) {
w := c.App.Writer
switch runtime.GOOS {
case "linux", "darwin":
rackDir, err := util.RackDir()
if err != nil {
fmt.Fprintf(w, "Error running `rack init`: %s\n", err)
return
}
rackCompletionPath := path.Join(rackDir, "bash_autocomplete")
rackCompletionFile, err := os.Create(rackCompletionPath)
if err != nil {
fmt.Fprintf(w, "Error creating `rack` bash completion file: %s\n", err)
return
}
_, err = rackCompletionFile.WriteString(rackBashAutocomplete)
if err != nil {
fmt.Fprintf(w, "Error writing to `rack` bash completion file: %s\n", err)
return
}
rackCompletionFile.Close()
var bashName string
if runtime.GOOS == "linux" {
bashName = ".bashrc"
} else {
bashName = ".bash_profile"
}
homeDir, err := util.HomeDir()
if err != nil {
fmt.Fprintf(w, "Unable to access home directory: %s\n", err)
}
bashPath := path.Join(homeDir, bashName)
fmt.Fprintf(w, "Looking for %s in %s\n", bashName, bashPath)
if _, err := os.Stat(bashPath); os.IsNotExist(err) {
fmt.Fprintf(w, "%s doesn't exist. You should create it and/or install your operating system's `bash_completion` package.", bashPath)
} else {
bashFile, err := os.OpenFile(bashPath, os.O_RDWR|os.O_APPEND, 0644)
if err != nil {
fmt.Fprintf(w, "Error opening %s: %s\n", bashPath, err)
return
}
defer bashFile.Close()
sourceContent := fmt.Sprintf("source %s\n", rackCompletionPath)
bashContentsBytes, err := ioutil.ReadAll(bashFile)
if strings.Contains(string(bashContentsBytes), sourceContent) {
fmt.Fprintf(w, "Command completion enabled in %s\n", bashPath)
return
}
_, err = bashFile.WriteString(sourceContent)
if err != nil {
fmt.Fprintf(w, "Error writing to %s: %s\n", bashPath, err)
return
}
_, err = exec.Command("/bin/bash", bashPath).Output()
if err != nil {
fmt.Fprintf(w, "Error sourcing %s: %s\n", bashPath, err)
return
}
fmt.Fprintf(w, "Command completion enabled in %s\n", bashPath)
return
}
default:
fmt.Fprintf(w, "Command completion is not currently available for %s\n", runtime.GOOS)
return
}
}
