func loadBitriseConfig() (ConfigModel, error) { if err := EnsureBitriseConfigDirExists(); err != nil { return ConfigModel{}, err } configPth := getBitriseConfigFilePath() if exist, err := pathutil.IsPathExists(configPth); err != nil { return ConfigModel{}, err } else if !exist { return ConfigModel{}, nil } bytes, err := fileutil.ReadBytesFromFile(configPth) if err != nil { return ConfigModel{}, err } if len(bytes) == 0 { return ConfigModel{}, errors.New("empty config file") } config := ConfigModel{} if err := json.Unmarshal(bytes, &config); err != nil { return ConfigModel{}, fmt.Errorf("failed to marshal config (%s), error: %s", string(bytes), err) } return config, nil }
// ReadSpecStep ... func ReadSpecStep(pth string) (stepmanModels.StepModel, error) { if isExists, err := pathutil.IsPathExists(pth); err != nil { return stepmanModels.StepModel{}, err } else if !isExists { return stepmanModels.StepModel{}, errors.New(fmt.Sprint("No file found at path", pth)) } bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return stepmanModels.StepModel{}, err } var stepModel stepmanModels.StepModel if err := yaml.Unmarshal(bytes, &stepModel); err != nil { return stepmanModels.StepModel{}, err } if err := stepModel.Normalize(); err != nil { return stepmanModels.StepModel{}, err } if err := stepModel.Validate(false); err != nil { return stepmanModels.StepModel{}, err } if err := stepModel.FillMissingDefaults(); err != nil { return stepmanModels.StepModel{}, err } return stepModel, nil }
// NewConfigFromFile ... func NewConfigFromFile(pth string) (Config, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return Config{}, err } return NewConfigFromBytes(bytes) }
// GetConfigs ... func GetConfigs() (ConfigsModel, error) { configPth := getEnvmanConfigsFilePath() defaultConfigs := createDefaultConfigsModel() if isExist, err := pathutil.IsPathExists(configPth); err != nil { return ConfigsModel{}, err } else if !isExist { return defaultConfigs, nil } bytes, err := fileutil.ReadBytesFromFile(configPth) if err != nil { return ConfigsModel{}, err } type ConfigsFileMode struct { EnvBytesLimitInKB *int `json:"env_bytes_limit_in_kb,omitempty"` EnvListBytesLimitInKB *int `json:"env_list_bytes_limit_in_kb,omitempty"` } var userConfigs ConfigsFileMode if err := json.Unmarshal(bytes, &userConfigs); err != nil { return ConfigsModel{}, err } if userConfigs.EnvBytesLimitInKB != nil { defaultConfigs.EnvBytesLimitInKB = *userConfigs.EnvBytesLimitInKB } if userConfigs.EnvListBytesLimitInKB != nil { defaultConfigs.EnvListBytesLimitInKB = *userConfigs.EnvListBytesLimitInKB } return defaultConfigs, nil }
func readRouteMap() (SteplibRoutes, error) { exist, err := pathutil.IsPathExists(getRoutingFilePath()) if err != nil { return SteplibRoutes{}, err } else if !exist { return SteplibRoutes{}, nil } bytes, err := fileutil.ReadBytesFromFile(getRoutingFilePath()) if err != nil { return SteplibRoutes{}, err } var routeMap map[string]string if err := json.Unmarshal(bytes, &routeMap); err != nil { return SteplibRoutes{}, err } routes := []SteplibRoute{} for key, value := range routeMap { routes = append(routes, SteplibRoute{ SteplibURI: key, FolderAlias: value, }) } return routes, nil }
// ParseStepYml ... func ParseStepYml(pth string, validate bool) (models.StepModel, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return models.StepModel{}, err } var stepModel models.StepModel if err := yaml.Unmarshal(bytes, &stepModel); err != nil { return models.StepModel{}, err } if err := stepModel.Normalize(); err != nil { return models.StepModel{}, err } if validate { if err := stepModel.Audit(); err != nil { return models.StepModel{}, err } } if err := stepModel.FillMissingDefaults(); err != nil { return models.StepModel{}, err } return stepModel, nil }
// CollectEnvironmentsFromFile ... func CollectEnvironmentsFromFile(pth string) ([]envmanModels.EnvironmentItemModel, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return []envmanModels.EnvironmentItemModel{}, err } var envstore envmanModels.EnvsYMLModel if err := yaml.Unmarshal(bytes, &envstore); err != nil { return []envmanModels.EnvironmentItemModel{}, err } for _, env := range envstore.Envs { if err := env.Normalize(); err != nil { return []envmanModels.EnvironmentItemModel{}, err } if err := env.FillMissingDefaults(); err != nil { return []envmanModels.EnvironmentItemModel{}, err } if err := env.Validate(); err != nil { return []envmanModels.EnvironmentItemModel{}, err } } return envstore.Envs, nil }
// ReadSSHConfigFileFromDir ... func ReadSSHConfigFileFromDir(workdirPth string) (SSHConfigModel, error) { configBytes, err := fileutil.ReadBytesFromFile(fullSSHConfigFilePath(workdirPth)) if err != nil { return SSHConfigModel{}, err } return readSSHConfigFromBytes(configBytes) }
// CollectEnvironmentsFromFile ... func CollectEnvironmentsFromFile(pth string) ([]envmanModels.EnvironmentItemModel, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return []envmanModels.EnvironmentItemModel{}, err } return CollectEnvironmentsFromFileContent(bytes) }
// ReadEnvs ... func ReadEnvs(pth string) ([]models.EnvironmentItemModel, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return []models.EnvironmentItemModel{}, err } return ParseEnvsYML(bytes) }
// ParseStepCollection ... func ParseStepCollection(pth string) (models.StepCollectionModel, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return models.StepCollectionModel{}, err } var stepCollection models.StepCollectionModel if err := yaml.Unmarshal(bytes, &stepCollection); err != nil { return models.StepCollectionModel{}, err } return stepCollection, nil }
// ParseStepGroupInfo ... func ParseStepGroupInfo(pth string) (models.StepGroupInfoModel, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return models.StepGroupInfoModel{}, err } var stepGroupInfo models.StepGroupInfoModel if err := yaml.Unmarshal(bytes, &stepGroupInfo); err != nil { return models.StepGroupInfoModel{}, err } return stepGroupInfo, nil }
// LoadConfigFromFile ... func LoadConfigFromFile(pth string) (Model, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return Model{}, err } var m Model if err := json.Unmarshal(bytes, &m); err != nil { return Model{}, err } return m, nil }
func jwtConfigFromJSONKeyFile(pth string) (*jwt.Config, error) { jsonKeyBytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return nil, err } config, err := google.JWTConfigFromJSON(jsonKeyBytes, androidpublisher.AndroidpublisherScope) if err != nil { return nil, err } return config, nil }
// ReadMachineConfigFileFromDir ... func ReadMachineConfigFileFromDir(workdirPth string, appendEnvs EnvItemsModel) (MachineConfigModel, error) { configBytes, err := fileutil.ReadBytesFromFile(path.Join(workdirPth, machineConfigFileName)) if err != nil { return MachineConfigModel{}, fmt.Errorf("ReadMachineConfigFileFromDir: failed to read file: %s", err) } machineConfig, err := readMachineConfigFromBytes(configBytes, appendEnvs) if err != nil { return MachineConfigModel{}, fmt.Errorf("ReadMachineConfigFileFromDir: failed to parse configuration: %s", err) } return machineConfig, nil }
// NewPluginFromYML ... func NewPluginFromYML(ymlPth string) (Plugin, error) { if isExists, err := pathutil.IsPathExists(ymlPth); err != nil { return Plugin{}, err } else if !isExists { return Plugin{}, fmt.Errorf("Plugin yml path (%s) doesn't exist", ymlPth) } bytes, err := fileutil.ReadBytesFromFile(ymlPth) if err != nil { return Plugin{}, err } return NewPluginFromBytes(bytes) }
// ReadOldWorkflowModel ... func ReadOldWorkflowModel(pth string) (oldModels.WorkflowModel, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return oldModels.WorkflowModel{}, err } if strings.HasSuffix(pth, ".json") { log.Debugln("=> Using JSON parser for: ", pth) return WorkflowModelFromJSONBytes(bytes) } log.Debugln("=> Using YAML parser for: ", pth) return WorkflowModelFromYAMLBytes(bytes) }
// NewPluginRoutingFromYMLOrEmpty ... func NewPluginRoutingFromYMLOrEmpty(ymlPth string) (PluginRouting, error) { if exist, err := pathutil.IsPathExists(ymlPth); err != nil { return PluginRouting{}, err } else if exist { bytes, err := fileutil.ReadBytesFromFile(ymlPth) if err != nil { return PluginRouting{}, err } return NewPluginRoutingFromBytes(bytes) } return NewPluginRouting(), nil }
// ReadEnvs ... func ReadEnvs(pth string) ([]models.EnvironmentItemModel, error) { bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return []models.EnvironmentItemModel{}, err } var envsYML models.EnvsYMLModel if err := yaml.Unmarshal(bytes, &envsYML); err != nil { return []models.EnvironmentItemModel{}, err } for _, env := range envsYML.Envs { if err := env.NormalizeEnvironmentItemModel(); err != nil { return []models.EnvironmentItemModel{}, err } } return envsYML.Envs, nil }
// ReadStepSpec ... func ReadStepSpec(uri string) (models.StepCollectionModel, error) { route, found := ReadRoute(uri) if !found { return models.StepCollectionModel{}, errors.New("No route found for lib: " + uri) } pth := GetStepSpecPath(route) bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return models.StepCollectionModel{}, err } var stepLib models.StepCollectionModel if err := json.Unmarshal(bytes, &stepLib); err != nil { return models.StepCollectionModel{}, err } return stepLib, nil }
// ParseGlobalStepInfoYML ... func ParseGlobalStepInfoYML(pth string) (models.GlobalStepInfoModel, bool, error) { if exist, err := pathutil.IsPathExists(pth); err != nil { return models.GlobalStepInfoModel{}, false, err } else if !exist { return models.GlobalStepInfoModel{}, false, nil } bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return models.GlobalStepInfoModel{}, true, err } var globalStepInfo models.GlobalStepInfoModel if err := yaml.Unmarshal(bytes, &globalStepInfo); err != nil { return models.GlobalStepInfoModel{}, true, err } return globalStepInfo, true, nil }
// ReadShareSteplibFromFile ... func ReadShareSteplibFromFile() (ShareModel, error) { if exist, err := pathutil.IsPathExists(getShareFilePath()); err != nil { return ShareModel{}, err } else if !exist { return ShareModel{}, errors.New("No share steplib found") } bytes, err := fileutil.ReadBytesFromFile(getShareFilePath()) if err != nil { return ShareModel{}, err } share := ShareModel{} if err := json.Unmarshal(bytes, &share); err != nil { return ShareModel{}, err } return share, nil }
// ReadBitriseConfig ... func ReadBitriseConfig(pth string) (models.BitriseDataModel, []string, error) { log.Debugln("-> ReadBitriseConfig") if isExists, err := pathutil.IsPathExists(pth); err != nil { return models.BitriseDataModel{}, []string{}, err } else if !isExists { return models.BitriseDataModel{}, []string{}, fmt.Errorf("No file found at path: %s", pth) } bytes, err := fileutil.ReadBytesFromFile(pth) if err != nil { return models.BitriseDataModel{}, []string{}, err } if strings.HasSuffix(pth, ".json") { log.Debugln("=> Using JSON parser for: ", pth) return ConfigModelFromJSONBytes(bytes) } log.Debugln("=> Using YAML parser for: ", pth) return ConfigModelFromYAMLBytes(bytes) }
func create(c *cli.Context) error { toolMode := c.Bool(ToolMode) share, err := ReadShareSteplibFromFile() if err != nil { log.Error(err) log.Fatalln("You have to start sharing with `stepman share start`, or you can read instructions with `stepman share`") } // Input validation tag := c.String(TagKey) if tag == "" { log.Fatalln("No Step tag specified") } gitURI := c.String(GitKey) if gitURI == "" { log.Fatalln("No Step url specified") } stepID := c.String(StepIDKEy) if stepID == "" { stepID = getStepIDFromGit(gitURI) } if stepID == "" { log.Fatalln("No Step id specified") } r := regexp.MustCompile(`[a-z0-9-]+`) if find := r.FindString(stepID); find != stepID { log.Fatalln("StepID doesn't conforms to: [a-z0-9-]") } route, found := stepman.ReadRoute(share.Collection) if !found { log.Fatalf("No route found for collectionURI (%s)", share.Collection) } stepDirInSteplib := stepman.GetStepCollectionDirPath(route, stepID, tag) stepYMLPathInSteplib := path.Join(stepDirInSteplib, "step.yml") if exist, err := pathutil.IsPathExists(stepYMLPathInSteplib); err != nil { log.Fatalf("Failed to check step.yml path in steplib, err: %s", err) } else if exist { log.Warnf("Step already exist in path: %s.", stepDirInSteplib) if val, err := goinp.AskForBool("Would you like to overwrite local version of Step?"); err != nil { log.Fatalf("Failed to get bool, err: %s", err) } else { if !val { log.Errorln("Unfortunately we can't continue with sharing without an overwrite exist step.yml.") log.Fatalln("Please finish your changes, run this command again and allow it to overwrite the exist step.yml!") } } } // Clone Step to tmp dir tmp, err := pathutil.NormalizedOSTempDirPath("") if err != nil { log.Fatalf("Failed to get temp directory, err: %s", err) } log.Infof("Cloning Step from (%s) with tag (%s) to temporary path (%s)", gitURI, tag, tmp) if err := cmdex.GitCloneTag(gitURI, tmp, tag); err != nil { log.Fatalf("Git clone failed, err: %s", err) } // Update step.yml tmpStepYMLPath := path.Join(tmp, "step.yml") bytes, err := fileutil.ReadBytesFromFile(tmpStepYMLPath) if err != nil { log.Fatalf("Failed to read Step from file, err: %s", err) } var stepModel models.StepModel if err := yaml.Unmarshal(bytes, &stepModel); err != nil { log.Fatalf("Failed to unmarchal Step, err: %s", err) } commit, err := cmdex.GitGetCommitHashOfHEAD(tmp) if err != nil { log.Fatalf("Failed to get commit hash, err: %s", err) } stepModel.Source = &models.StepSourceModel{ Git: gitURI, Commit: commit, } stepModel.PublishedAt = pointers.NewTimePtr(time.Now()) // Validate step-yml if err := stepModel.Audit(); err != nil { log.Fatalf("Failed to validate Step, err: %s", err) } for _, input := range stepModel.Inputs { key, value, err := input.GetKeyValuePair() if err != nil { log.Fatalf("Failed to get Step input key-value pair, err: %s", err) } options, err := input.GetOptions() if err != nil { log.Fatalf("Failed to get Step input (%s) options, err: %s", key, err) } if len(options.ValueOptions) > 0 && value == "" { log.Warn("Step input with 'value_options', should contain default value!") log.Fatalf("Missing default value for Step input (%s).", key) } } if strings.Contains(*stepModel.Summary, "\n") { log.Warningln("Step summary should be one line!") } if utf8.RuneCountInString(*stepModel.Summary) > maxSummaryLength { log.Warningf("Step summary should contains maximum (%d) characters, actual: (%d)!", maxSummaryLength, utf8.RuneCountInString(*stepModel.Summary)) } // Copy step.yml to steplib share.StepID = stepID share.StepTag = tag if err := WriteShareSteplibToFile(share); err != nil { log.Fatalf("Failed to save share steplib to file, err: %s", err) } log.Info("Step dir in collection:", stepDirInSteplib) if exist, err := pathutil.IsPathExists(stepDirInSteplib); err != nil { log.Fatalf("Failed to check path (%s), err: %s", stepDirInSteplib, err) } else if !exist { if err := os.MkdirAll(stepDirInSteplib, 0777); err != nil { log.Fatalf("Failed to create path (%s), err: %s", stepDirInSteplib, err) } } log.Infof("Checkout branch: %s", share.ShareBranchName()) collectionDir := stepman.GetCollectionBaseDirPath(route) if err := cmdex.GitCheckout(collectionDir, share.ShareBranchName()); err != nil { if err := cmdex.GitCreateAndCheckoutBranch(collectionDir, share.ShareBranchName()); err != nil { log.Fatalf("Git failed to create and checkout branch, err: %s", err) } } stepBytes, err := yaml.Marshal(stepModel) if err != nil { log.Fatalf("Failed to marcshal Step model, err: %s", err) } if err := fileutil.WriteBytesToFile(stepYMLPathInSteplib, stepBytes); err != nil { log.Fatalf("Failed to write Step to file, err: %s", err) } // Update spec.json if err := stepman.ReGenerateStepSpec(route); err != nil { log.Fatalf("Failed to re-create steplib, err: %s", err) } printFinishCreate(share, stepDirInSteplib, toolMode) return nil }