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
}
