// ExportEnvironmentsList ...
func ExportEnvironmentsList(envsList []envmanModels.EnvironmentItemModel) error {
log.Debugln("[BITRISE_CLI] - Exporting environments:", envsList)
for _, env := range envsList {
key, value, err := env.GetKeyValuePair()
if err != nil {
return err
}
opts, err := env.GetOptions()
if err != nil {
return err
}
isExpand := envmanModels.DefaultIsExpand
if opts.IsExpand != nil {
isExpand = *opts.IsExpand
}
skipIfEmpty := envmanModels.DefaultSkipIfEmpty
if opts.SkipIfEmpty != nil {
skipIfEmpty = *opts.SkipIfEmpty
}
if err := tools.EnvmanAdd(configs.InputEnvstorePath, key, value, isExpand, skipIfEmpty); err != nil {
log.Errorln("[BITRISE_CLI] - Failed to run envman add")
return err
}
}
return nil
}
func runPlugin(plugin Plugin, args []string, pluginInput PluginInput) error {
if !configs.IsCIMode && configs.CheckIsPluginUpdateCheckRequired() {
// Check for new version
log.Infof("Checking for plugin (%s) new version...", plugin.Name)
if newVersion, err := CheckForNewVersion(plugin); err != nil {
log.Warnf("")
log.Warnf("Failed to check for plugin (%s) new version, error: %s", plugin.Name, err)
} else if newVersion != "" {
log.Warnf("")
log.Warnf("New version (%s) of plugin (%s) available", newVersion, plugin.Name)
route, found, err := ReadPluginRoute(plugin.Name)
if err != nil {
return err
}
if !found {
return fmt.Errorf("no route found for already loaded plugin (%s)", plugin.Name)
}
route.LatestAvailableVersion = newVersion
if err := AddPluginRoute(route); err != nil {
return fmt.Errorf("failed to register available plugin (%s) update (%s), error: %s", plugin.Name, newVersion, err)
}
} else {
log.Debugf("No new version of plugin (%s) available", plugin.Name)
}
if err := configs.SavePluginUpdateCheck(); err != nil {
return err
}
fmt.Println()
} else {
route, found, err := ReadPluginRoute(plugin.Name)
if err != nil {
return err
}
if !found {
return fmt.Errorf("no route found for already loaded plugin (%s)", plugin.Name)
}
if route.LatestAvailableVersion != "" {
log.Warnf("")
log.Warnf("New version (%s) of plugin (%s) available", route.LatestAvailableVersion, plugin.Name)
}
}
// Append common data to plugin iputs
bitriseVersion, err := version.BitriseCliVersion()
if err != nil {
return err
}
pluginInput[pluginInputBitriseVersionKey] = bitriseVersion.String()
pluginInput[pluginInputDataDirKey] = GetPluginDataDir(plugin.Name)
// Prepare plugin envstore
pluginWorkDir, err := pathutil.NormalizedOSTempDirPath("plugin-work-dir")
if err != nil {
return err
}
defer func() {
if err := os.RemoveAll(pluginWorkDir); err != nil {
log.Warnf("Failed to remove path (%s)", pluginWorkDir)
}
}()
pluginEnvstorePath := filepath.Join(pluginWorkDir, "envstore.yml")
if err := tools.EnvmanInitAtPath(pluginEnvstorePath); err != nil {
return err
}
if err := tools.EnvmanAdd(pluginEnvstorePath, configs.EnvstorePathEnvKey, pluginEnvstorePath, false, false); err != nil {
return err
}
log.Debugf("plugin evstore path (%s)", pluginEnvstorePath)
// Add plugin inputs
for key, value := range pluginInput {
if err := tools.EnvmanAdd(pluginEnvstorePath, key, value, false, false); err != nil {
return err
}
}
// Run plugin executable
pluginExecutable, isBin, err := GetPluginExecutablePath(plugin.Name)
if err != nil {
return err
}
cmd := []string{}
if isBin {
log.Debugf("Run plugin binary (%s)", pluginExecutable)
cmd = append([]string{pluginExecutable}, args...)
} else {
log.Debugf("Run plugin sh (%s)", pluginExecutable)
cmd = append([]string{"bash", pluginExecutable}, args...)
}
exitCode, err := tools.EnvmanRun(pluginEnvstorePath, "", cmd)
log.Debugf("Plugin run finished with exit code (%d)", exitCode)
if err != nil {
return err
}
// Read plugin output
outStr, err := tools.EnvmanJSONPrint(pluginEnvstorePath)
if err != nil {
return err
}
envList, err := envmanModels.NewEnvJSONList(outStr)
if err != nil {
return err
}
pluginOutputStr, found := envList[bitrisePluginOutputEnvKey]
if found {
log.Debugf("Plugin output: %s", pluginOutputStr)
}
return nil
}