func auditStepLibBeforeSharePullRequest(gitURI string) error { if exist, err := stepman.RootExistForCollection(gitURI); err != nil { return err } else if !exist { return fmt.Errorf("Missing routing for collection, call 'stepman setup -c %s' before audit.", gitURI) } collection, err := stepman.ReadStepSpec(gitURI) if err != nil { return err } for stepID, stepGroup := range collection.Steps { log.Debugf("Start audit StepGrup, with ID: (%s)", stepID) for version, step := range stepGroup.Versions { log.Debugf("Start audit Step (%s) (%s)", stepID, version) if err := auditStepModelBeforeSharePullRequest(step, stepID, version); err != nil { log.Errorf(" * "+colorstring.Redf("[FAILED] ")+"Failed audit (%s) (%s)", stepID, version) return fmt.Errorf(" Error: %s", err.Error()) } log.Infof(" * "+colorstring.Greenf("[OK] ")+"Success audit (%s) (%s)", stepID, version) } } return nil }
// ReadStepInfo ... func ReadStepInfo(collectionURI, stepID, stepVersionID string, isSetupCollectionIfMissing, isSilentSetup bool) (models.StepVersionModel, error) { // Input validation if stepID == "" { return models.StepVersionModel{}, errors.New("Missing required input: step id") } // Check if setup was done for collection if exist, err := stepman.RootExistForCollection(collectionURI); err != nil { return models.StepVersionModel{}, fmt.Errorf("Failed to check if setup was done for steplib (%s), error: %s", collectionURI, err) } else if !exist { if !isSetupCollectionIfMissing { return models.StepVersionModel{}, fmt.Errorf("Collection does not exist (uri: %s), error: %s", collectionURI, err) } if err := setupSteplib(collectionURI, isSilentSetup); err != nil { return models.StepVersionModel{}, errors.New("Failed to setup steplib") } } // Check if step exist in collection collection, err := stepman.ReadStepSpec(collectionURI) if err != nil { return models.StepVersionModel{}, fmt.Errorf("Failed to read steps spec (spec.json), err: %s", err) } stepWithVersion, stepFound := collection.GetStepVersion(stepID, stepVersionID) if !stepFound { if stepVersionID == "" { return models.StepVersionModel{}, fmt.Errorf("Collection doesn't contain any version of step (id:%s)", stepID) } return models.StepVersionModel{}, fmt.Errorf("Collection doesn't contain step (id:%s) (version:%s)", stepID, stepVersionID) } return stepWithVersion, nil }
func listSteps(stepLibURI, format string) error { // Check if setup was done for collection if exist, err := stepman.RootExistForCollection(stepLibURI); err != nil { return err } else if !exist { if err := setupSteplib(stepLibURI, format != OutputFormatRaw); err != nil { log.Fatal("Failed to setup steplib") } } stepLib, err := stepman.ReadStepSpec(stepLibURI) if err != nil { return err } switch format { case OutputFormatRaw: printRawStepList(stepLibURI, stepLib, false) break case OutputFormatJSON: if err := printJSONStepList(stepLibURI, stepLib, false); err != nil { return err } break default: return fmt.Errorf("Invalid format: %s", format) } return nil }
func download(c *cli.Context) error { // Input validation collectionURI := c.String(CollectionKey) if collectionURI == "" { log.Fatalln("[STEPMAN] - No step collection specified") } route, found := stepman.ReadRoute(collectionURI) if !found { log.Fatal("No route found for lib: " + collectionURI) } id := c.String(IDKey) if id == "" { log.Fatal("[STEPMAN] - Missing step id") } collection, err := stepman.ReadStepSpec(collectionURI) if err != nil { log.Fatal("[STEPMAN] - Failed to read step spec:", err) } version := c.String(VersionKey) if version == "" { log.Debug("[STEPMAN] - Missing step version -- Use latest version") latest, err := collection.GetLatestStepVersion(id) if err != nil { log.Fatal("[STEPMAN] - Failed to get step latest version: ", err) } log.Debug("[STEPMAN] - Latest version of step: ", latest) version = latest } update := c.Bool(UpdateKey) // Check step exist in collection step, found := collection.GetStep(id, version) if !found { if update { log.Infof("[STEPMAN] - Collection doesn't contain step (id:%s) (version:%s) -- Updating collection", id, version) if err := stepman.ReGenerateStepSpec(route); err != nil { log.Fatalf("[STEPMAN] - Failed to update collection:%s error:%v", collectionURI, err) } if _, found := collection.GetStep(id, version); !found { log.Fatalf("[STEPMAN] - Even the updated collection doesn't contain step (id:%s) (version:%s)", id, version) } } else { log.Fatalf("[STEPMAN] - Collection doesn't contain step (id:%s) (version:%s)", id, version) } } if err := stepman.DownloadStep(collectionURI, collection, id, version, step.Source.Commit); err != nil { log.Fatal("[STEPMAN] - Failed to download step") } return nil }
func updateCollection(steplibSource string) (models.StepCollectionModel, error) { route, found := stepman.ReadRoute(steplibSource) if !found { log.Warnf("No route found for collection: %s, cleaning up routing..", steplibSource) if err := stepman.CleanupDanglingLib(steplibSource); err != nil { log.Errorf("Error cleaning up lib: %s", steplibSource) } log.Infof("Call 'stepman setup -c %s' for a clean setup", steplibSource) return models.StepCollectionModel{}, fmt.Errorf("No route found for StepLib: %s", steplibSource) } isLocalSteplib := strings.HasPrefix(steplibSource, "file://") if isLocalSteplib { if err := stepman.CleanupRoute(route); err != nil { return models.StepCollectionModel{}, fmt.Errorf("Failed to cleanup route for StepLib: %s", steplibSource) } if err := setupSteplib(steplibSource, false); err != nil { return models.StepCollectionModel{}, fmt.Errorf("Failed to setup StepLib: %s", steplibSource) } } else { pth := stepman.GetCollectionBaseDirPath(route) if exists, err := pathutil.IsPathExists(pth); err != nil { return models.StepCollectionModel{}, err } else if !exists { return models.StepCollectionModel{}, errors.New("Not initialized") } gitPullErr := retry.Times(2).Wait(3 * time.Second).Try(func(attempt uint) error { if attempt > 0 { log.Infoln("Retrying ...") } return cmdex.GitPull(pth) }) if gitPullErr != nil { return models.StepCollectionModel{}, fmt.Errorf("Failed to update StepLib git repository, error: %s", gitPullErr) } if err := stepman.ReGenerateStepSpec(route); err != nil { return models.StepCollectionModel{}, err } } return stepman.ReadStepSpec(steplibSource) }
func updateCollection(steplibSource string) (models.StepCollectionModel, error) { route, found := stepman.ReadRoute(steplibSource) if !found { return models.StepCollectionModel{}, fmt.Errorf("No collection found for lib, call 'stepman delete -c %s' for cleanup", steplibSource) } pth := stepman.GetCollectionBaseDirPath(route) if exists, err := pathutil.IsPathExists(pth); err != nil { return models.StepCollectionModel{}, err } else if !exists { return models.StepCollectionModel{}, errors.New("Not initialized") } if err := cmdex.GitPull(pth); err != nil { return models.StepCollectionModel{}, err } if err := stepman.ReGenerateStepSpec(route); err != nil { return models.StepCollectionModel{}, err } return stepman.ReadStepSpec(steplibSource) }
func stepInfo(c *cli.Context) error { // Input validation format := c.String(FormatKey) collectionURI := c.String(CollectionKey) YMLPath := c.String(StepYMLKey) isShort := c.Bool(ShortKey) id := c.String(IDKey) version := c.String(VersionKey) if format == "" { format = OutputFormatRaw } else if !(format == OutputFormatRaw || format == OutputFormatJSON) { return fmt.Errorf("Invalid output format: %s", format) } if YMLPath == "" && collectionURI == "" { return fmt.Errorf("Missing required input: no StepLib, nor step.yml path defined as step info source") } if YMLPath != "" { // // Local step info step, err := stepman.ParseStepYml(YMLPath, false) if err != nil { return fmt.Errorf("Failed to parse step.yml (path:%s), err: %s", YMLPath, err) } inputs, err := getEnvInfos(step.Inputs) if err != nil { return fmt.Errorf("Failed to get step (path:%s) input infos, err: %s", YMLPath, err) } outputs, err := getEnvInfos(step.Outputs) if err != nil { return fmt.Errorf("Failed to get step (path:%s) output infos, err: %s", YMLPath, err) } stepInfo := models.StepInfoModel{ StepLib: YMLPath, Description: *step.Description, Source: *step.SourceCodeURL, Inputs: inputs, Outputs: outputs, } if err := printStepInfo(stepInfo, format, isShort, true); err != nil { return fmt.Errorf("Failed to print step info, err: %s", err) } } else { // // StepLib step info // Input validation if id == "" { return errors.New("Missing required input: step id") } // Check if setup was done for collection if exist, err := stepman.RootExistForCollection(collectionURI); err != nil { return fmt.Errorf("Failed to check if setup was done for steplib (%s), error: %s", collectionURI, err) } else if !exist { if err := setupSteplib(collectionURI, format != OutputFormatRaw); err != nil { return errors.New("Failed to setup steplib") } } // Check if step exist in collection collection, err := stepman.ReadStepSpec(collectionURI) if err != nil { return fmt.Errorf("Failed to read steps spec (spec.json), err: %s", err) } step, stepFound := collection.GetStep(id, version) if !stepFound { if version == "" { return fmt.Errorf("Collection doesn't contain any version of step (id:%s)", id) } return fmt.Errorf("Collection doesn't contain step (id:%s) (version:%s)", id, version) } latest, err := collection.GetLatestStepVersion(id) if err != nil { return fmt.Errorf("Failed to get latest version of step (id:%s)", id) } if version == "" { version = latest } inputs, err := getEnvInfos(step.Inputs) if err != nil { return fmt.Errorf("Failed to get step (id:%s) input infos, err: %s", id, err) } outputs, err := getEnvInfos(step.Outputs) if err != nil { return fmt.Errorf("Failed to get step (id:%s) output infos, err: %s", id, err) } stepInfo := models.StepInfoModel{ ID: id, Version: version, Latest: latest, Description: *step.Description, StepLib: collectionURI, Source: *step.SourceCodeURL, Inputs: inputs, Outputs: outputs, } route, found := stepman.ReadRoute(collectionURI) if !found { return fmt.Errorf("No route found for collection: %s", collectionURI) } globalStepInfoPth := stepman.GetStepGlobalInfoPath(route, id) if globalStepInfoPth != "" { globalInfo, found, err := stepman.ParseGlobalStepInfoYML(globalStepInfoPth) if err != nil { return fmt.Errorf("Failed to get step (path:%s) output infos, err: %s", globalStepInfoPth, err) } if found { stepInfo.GlobalInfo = globalInfo } } if err := printStepInfo(stepInfo, format, isShort, false); err != nil { return fmt.Errorf("Failed to print step info, err: %s", err) } } return nil }
func activate(c *cli.Context) error { // Input validation collectionURI := c.String(CollectionKey) if collectionURI == "" { log.Fatalln("[STEPMAN] - No step collection specified") } id := c.String(IDKey) if id == "" { log.Fatal("[STEPMAN] - Missing step id") } path := c.String(PathKey) if path == "" { log.Fatal("[STEPMAN] - Missing destination path") } version := c.String(VersionKey) copyYML := c.String(CopyYMLKey) update := c.Bool(UpdateKey) // Check if step exist in collection collection, err := stepman.ReadStepSpec(collectionURI) if err != nil { log.Fatalln("[STEPMAN] - Failed to read steps spec (spec.json)") } _, stepFound := collection.GetStep(id, version) if !stepFound { if !update { if version == "" { log.Fatalf("[STEPMAN] - Collection doesn't contain any version of step (id:%s)", id) } else { log.Fatalf("[STEPMAN] - Collection doesn't contain step (id:%s) (version:%s)", id, version) } } if version == "" { log.Infof("[STEPMAN] - Collection doesn't contain any version of step (id:%s) -- Updating StepLib", id) } else { log.Infof("[STEPMAN] - Collection doesn't contain step (id:%s) (version:%s) -- Updating StepLib", id, version) } collection, err = updateCollection(collectionURI) if err != nil { log.Fatalf("Failed to update collection (%s), err: %s", collectionURI, err) } _, stepFound := collection.GetStep(id, version) if !stepFound { if version != "" { log.Fatalf("[STEPMAN] - Even the updated collection doesn't contain step (id:%s) (version:%s)", id, version) } else { log.Fatalf("[STEPMAN] - Even the updated collection doesn't contain any version of step (id:%s)", id) } } } // If version doesn't provided use latest if version == "" { log.Debug("[STEPMAN] - Missing step version -- Use latest version") latest, err := collection.GetLatestStepVersion(id) if err != nil { log.Fatal("[STEPMAN] - Failed to get step latest version: ", err) } log.Debug("[STEPMAN] - Latest version of step: ", latest) version = latest } // Check step exist in local cache step, found := collection.GetStep(id, version) if !found { log.Fatalf("[STEPMAN] - Collection doesn't contain step (id:%s) (version:%s)", id, version) } if step.Source == nil { log.Fatal("Invalid step, missing Source property") } route, found := stepman.ReadRoute(collectionURI) if !found { log.Fatalf("No route found for lib: %s", collectionURI) } stepCacheDir := stepman.GetStepCacheDirPath(route, id, version) if exist, err := pathutil.IsPathExists(stepCacheDir); err != nil { log.Fatal("[STEPMAN] - Failed to check path:", err) } else if !exist { log.Debug("[STEPMAN] - Step does not exist, download it") if err := stepman.DownloadStep(collectionURI, collection, id, version, step.Source.Commit); err != nil { log.Fatal("[STEPMAN] - Failed to download step:", err) } } // Copy to specified path srcFolder := stepCacheDir destFolder := path if exist, err := pathutil.IsPathExists(destFolder); err != nil { log.Fatalln("[STEPMAN] - Failed to check path:", err) } else if !exist { if err := os.MkdirAll(destFolder, 0777); err != nil { log.Fatalln("[STEPMAN] - Failed to create path:", err) } } if err = cmdex.CopyDir(srcFolder+"/", destFolder, true); err != nil { log.Fatalln("[STEPMAN] - Failed to copy step:", err) } // Copy step.yml to specified path if copyYML != "" { if exist, err := pathutil.IsPathExists(copyYML); err != nil { log.Fatalln("[STEPMAN] - Failed to check path:", err) } else if exist { log.Fatalln("[STEPMAN] - Copy yml destination path exist") } stepCollectionDir := stepman.GetStepCollectionDirPath(route, id, version) stepYMLSrc := stepCollectionDir + "/step.yml" if err = cmdex.CopyFile(stepYMLSrc, copyYML); err != nil { log.Fatalln("[STEPMAN] - Failed to copy step.yml:", err) } } return nil }
func export(c *cli.Context) error { // Input validation steplibURI := c.String("steplib") outputPth := c.String("output") exportTypeStr := c.String("export-type") if steplibURI == "" { return fmt.Errorf("Missing required input: steplib") } if outputPth == "" { return fmt.Errorf("Missing required input: output") } exportType := exportTypeFull if exportTypeStr != "" { var err error exportType, err = parseExportType(exportTypeStr) if err != nil { return err } } log.Infof("Exporting StepLib (%s) spec, export-type: %s, output: %s", steplibURI, exportTypeStr, outputPth) // Setup StepLib if exist, err := stepman.RootExistForCollection(steplibURI); err != nil { return fmt.Errorf("Failed to check if setup was done for StepLib, error: %s", err) } else if !exist { log.Infof("StepLib does not exist, setup...") if err := setupSteplib(steplibURI, false); err != nil { return fmt.Errorf("Failed to setup StepLib, error: %s", err) } } // Prepare spec stepLibSpec, err := stepman.ReadStepSpec(steplibURI) if err != nil { log.Fatalln("Failed to read StepLib spec, error: %s", err) } switch exportType { case exportTypeMinimal: stepLibSpec = convertToMinimalSpec(stepLibSpec) case exportTypeLatest: stepLibSpec = convertToLatestSpec(stepLibSpec) } stepLibSpecBytes, err := json.Marshal(stepLibSpec) if err != nil { return fmt.Errorf("Failed to marshal StepLib, error: %s", err) } // Export spec outputDir := filepath.Dir(outputPth) exist, err := pathutil.IsDirExists(outputDir) if err != nil { return fmt.Errorf("Failed to check if dir (%s) exist, error: %s", outputDir, err) } if !exist { if err := os.MkdirAll(outputDir, 0777); err != nil { return fmt.Errorf("Failed to create dir (%s), error: %s", outputDir, err) } } if err := fileutil.WriteBytesToFile(outputPth, stepLibSpecBytes); err != nil { return fmt.Errorf("Failed to write StepLib spec to: %s, error: %s", outputPth, err) } log.Infof("StepLib spec exported to: %s", outputPth) return nil }