func TestDownloadPluginBin(t *testing.T) {
t.Log("example plugin bin - ")
{
pluginBinURL := analyticsPluginBinURL
destinationDir, err := pathutil.NormalizedOSTempDirPath("TestDownloadPluginBin")
require.NoError(t, err)
exist, err := pathutil.IsPathExists(destinationDir)
require.NoError(t, err)
if exist {
err := os.RemoveAll(destinationDir)
require.NoError(t, err)
}
require.NoError(t, os.MkdirAll(destinationDir, 0777))
destinationPth := filepath.Join(destinationDir, "example")
require.NoError(t, downloadPluginBin(pluginBinURL, destinationPth))
exist, err = pathutil.IsPathExists(destinationPth)
require.NoError(t, err)
require.Equal(t, true, exist)
}
}
func (configs ConfigsModel) validate() (string, error) {
// required
if configs.GradleFile == "" {
return "", errors.New("No GradleFile parameter specified!")
}
if exist, err := pathutil.IsPathExists(configs.GradleFile); err != nil {
return "", fmt.Errorf("Failed to check if GradleFile exist at: %s, error: %s", configs.GradleFile, err)
} else if !exist {
return "", fmt.Errorf("GradleFile not exist at: %s", configs.GradleFile)
}
if configs.GradleTasks == "" {
return "", errors.New("No GradleTask parameter specified!")
}
if configs.GradlewPath == "" {
explanation := `
Using a Gradle Wrapper (gradlew) is required, as the wrapper is what makes sure
that the right Gradle version is installed and used for the build.
You can find more information about the Gradle Wrapper (gradlew),
and about how you can generate one (if you would not have one already
in the official guide at: https://docs.gradle.org/current/userguide/gradle_wrapper.html`
return explanation, errors.New("No GradlewPath parameter specified!")
}
if exist, err := pathutil.IsPathExists(configs.GradlewPath); err != nil {
return "", fmt.Errorf("Failed to check if GradlewPath exist at: %s, error: %s", configs.GradlewPath, err)
} else if !exist {
return "", fmt.Errorf("GradlewPath not exist at: %s", configs.GradlewPath)
}
return "", nil
}
func initBitriseWorkPaths() error {
bitriseWorkDirPath, err := pathutil.NormalizedOSTempDirPath("bitrise")
if err != nil {
return err
}
if exist, err := pathutil.IsPathExists(bitriseWorkDirPath); err != nil {
return err
} else if !exist {
if err := os.MkdirAll(bitriseWorkDirPath, 0777); err != nil {
return err
}
}
BitriseWorkDirPath = bitriseWorkDirPath
bitriseWorkStepsDirPath, err := filepath.Abs(filepath.Join(BitriseWorkDirPath, "step_src"))
if err != nil {
return err
}
if exist, err := pathutil.IsPathExists(bitriseWorkStepsDirPath); err != nil {
return err
} else if !exist {
if err := os.MkdirAll(bitriseWorkStepsDirPath, 0777); err != nil {
return err
}
}
BitriseWorkStepsDirPath = bitriseWorkStepsDirPath
return nil
}
func isCacheAvailable(srcDir string) (bool, error) {
carthageDir := filepath.Join(srcDir, carthageDirName)
if exist, err := pathutil.IsPathExists(carthageDir); err != nil {
return false, err
} else if !exist {
return false, nil
}
buildDir := filepath.Join(carthageDir, buildDirName)
if exist, err := pathutil.IsPathExists(buildDir); err != nil {
return false, err
} else if exist {
pattern := filepath.Join(buildDir, "*")
files, err := filepath.Glob(pattern)
if err != nil {
return false, err
}
if len(files) == 0 {
return false, nil
}
} else {
return false, nil
}
// read cahce
cacheContent := ""
cacheFilePth := filepath.Join(srcDir, carthageDirName, cacheFileName)
if exist, err := pathutil.IsPathExists(cacheFilePth); err != nil {
return false, err
} else if exist {
cacheContent, err = fileutil.ReadStringFromFile(cacheFilePth)
if err != nil {
return false, err
}
} else {
return false, nil
}
swiftVersion, err := swiftVersion()
if err != nil {
return false, err
}
resolvedFilePath := filepath.Join(srcDir, resolvedFileName)
resolved, err := contentsOfCartfileResolved(resolvedFilePath)
if err != nil {
return false, err
}
desiredCacheContent := fmt.Sprintf("--Swift version: %s --Swift version \n --%s: %s --%s", swiftVersion, resolvedFileName, resolved, resolvedFileName)
return cacheContent == desiredCacheContent, nil
}
// IsSSHKeypairFileExistInDirectory ...
func IsSSHKeypairFileExistInDirectory(workdirPth string) bool {
privFilePath := fullSSHPrivateKeyFilePath(workdirPth)
pubFilePath := fullSSHPublicKeyFilePath(workdirPth)
exists, err := pathutil.IsPathExists(privFilePath)
if !exists || err != nil {
return false
}
exists, err = pathutil.IsPathExists(pubFilePath)
if !exists || err != nil {
return false
}
return true
}
func TestClonePluginSrc(t *testing.T) {
t.Log("example plugin - latest version")
{
pluginSource := examplePluginGitURL
versionTag := ""
destinationDir, err := pathutil.NormalizedOSTempDirPath("TestClonePluginSrc")
require.NoError(t, err)
exist, err := pathutil.IsPathExists(destinationDir)
require.NoError(t, err)
if exist {
err := os.RemoveAll(destinationDir)
require.NoError(t, err)
}
version, hash, err := clonePluginSrc(pluginSource, versionTag, destinationDir)
require.NoError(t, err)
require.NotNil(t, version)
require.NotEmpty(t, hash)
exist, err = pathutil.IsPathExists(destinationDir)
require.NoError(t, err)
require.Equal(t, true, exist)
}
t.Log("example plugin - 0.9.0 version")
{
pluginSource := examplePluginGitURL
versionTag := "0.9.0"
destinationDir, err := pathutil.NormalizedOSTempDirPath("TestClonePluginSrc")
require.NoError(t, err)
exist, err := pathutil.IsPathExists(destinationDir)
require.NoError(t, err)
if exist {
err := os.RemoveAll(destinationDir)
require.NoError(t, err)
}
version, hash, err := clonePluginSrc(pluginSource, versionTag, destinationDir)
require.NoError(t, err)
require.NotNil(t, version)
require.Equal(t, "0.9.0", version.String())
require.NotEmpty(t, hash)
exist, err = pathutil.IsPathExists(destinationDir)
require.NoError(t, err)
require.Equal(t, true, exist)
}
}
// 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
}
func (configs ConfigsModel) validate() error {
if configs.XamarinSolution == "" {
return errors.New("No XamarinSolution parameter specified!")
}
if exist, err := pathutil.IsPathExists(configs.XamarinSolution); err != nil {
return fmt.Errorf("Failed to check if XamarinSolution exist at: %s, error: %s", configs.XamarinSolution, err)
} else if !exist {
return fmt.Errorf("XamarinSolution not exist at: %s", configs.XamarinSolution)
}
if configs.XamarinConfiguration == "" {
return errors.New("No XamarinConfiguration parameter specified!")
}
if configs.XamarinPlatform == "" {
return errors.New("No XamarinPlatform parameter specified!")
}
if configs.APIKey == "" {
return errors.New("No APIKey parameter specified!")
}
if configs.User == "" {
return errors.New("No User parameter specified!")
}
if configs.Devices == "" {
return errors.New("No Devices parameter specified!")
}
if configs.Series == "" {
return errors.New("No Series parameter specified!")
}
return 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
}
// 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 destroy(c *cli.Context) {
log.Infoln("Destroy")
additionalEnvs, err := config.CreateEnvItemsModelFromSlice(MachineParamsAdditionalEnvs.Get())
if err != nil {
log.Fatalf("Invalid Environment parameter: %s", err)
}
configModel, err := config.ReadMachineConfigFileFromDir(MachineWorkdir.Get(), additionalEnvs)
if err != nil {
log.Fatalln("Failed to read Config file: ", err)
}
isOK, err := pathutil.IsPathExists(path.Join(MachineWorkdir.Get(), "Vagrantfile"))
if err != nil {
log.Fatalln("Failed to check 'Vagrantfile' in the WorkDir: ", err)
}
if !isOK {
log.Fatalln("Vagrantfile not found in the WorkDir!")
}
log.Infof("configModel: %#v", configModel)
if err := doCleanup(configModel, "will-be-destroyed"); err != nil {
log.Fatalf("Failed to Cleanup: %s", err)
}
if err := doDestroy(configModel); err != nil {
log.Fatalf("Failed to Destroy: %s", err)
}
log.Infoln("=> Destroy DONE - OK")
}
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
}
// WriteStepSpecToFile ...
func WriteStepSpecToFile(templateCollection models.StepCollectionModel, route SteplibRoute) error {
pth := GetStepSpecPath(route)
if exist, err := pathutil.IsPathExists(pth); err != nil {
log.Error("Failed to check path:", err)
return err
} else if !exist {
dir, _ := path.Split(pth)
err := os.MkdirAll(dir, 0777)
if err != nil {
return err
}
} else {
err := os.Remove(pth)
if err != nil {
return err
}
}
collection, err := generateStepLib(route, templateCollection)
if err != nil {
return err
}
bytes, err := json.MarshalIndent(collection, "", "\t")
if err != nil {
return err
}
return fileutil.WriteBytesToFile(pth, bytes)
}
// PrepareForStepRun ...
func (toolkit GoToolkit) PrepareForStepRun(step stepmanModels.StepModel, sIDData models.StepIDData, stepAbsDirPath string) error {
fullStepBinPath := stepBinaryCacheFullPath(sIDData)
// try to use cached binary, if possible
if sIDData.IsUniqueResourceID() {
if exists, err := pathutil.IsPathExists(fullStepBinPath); err != nil {
log.Warn("Failed to check cached binary for step, error: %s", err)
} else if exists {
log.Debugln("No need to compile, binary already exists")
return nil
}
}
// it's not cached, so compile it
if step.Toolkit == nil {
return errors.New("No Toolkit information specified in step")
}
if step.Toolkit.Go == nil {
return errors.New("No Toolkit.Go information specified in step")
}
packageName := step.Toolkit.Go.PackageName
return goBuildInIsolation(packageName, stepAbsDirPath, fullStepBinPath)
}
func gitInitWithRemote(cloneIntoDir, repositoryURL string) error {
gitCheckPath := filepath.Join(cloneIntoDir, ".git")
if exist, err := pathutil.IsPathExists(gitCheckPath); err != nil {
return fmt.Errorf("Failed to file path (%s), err: %s", gitCheckPath, err)
} else if exist {
return fmt.Errorf(".git folder already exists in the destination dir (%s)", gitCheckPath)
}
if err := os.MkdirAll(cloneIntoDir, 0777); err != nil {
return fmt.Errorf("Failed to create the clone_destination_dir at: %s", cloneIntoDir)
}
if err := gitInit(cloneIntoDir); err != nil {
return fmt.Errorf("Could not init git repository, err: %s", cloneIntoDir)
}
if err := gitAddRemote(cloneIntoDir, repositoryURL); err != nil {
return fmt.Errorf("Could not add remote, err: %s", err)
}
if err := gitFetch(cloneIntoDir); err != nil {
return fmt.Errorf("Could not fetch from repository, err: %s", err)
}
return nil
}
// FindProvProfileByUUID ...
func FindProvProfileByUUID(provProfileUUID string) (ProvisioningProfileFileInfoModel, error) {
absProvProfileDirPath, err := pathutil.AbsPath(provProfileSystemDirPath)
if err != nil {
return ProvisioningProfileFileInfoModel{}, fmt.Errorf("Failed to get Absolute path of Provisioning Profiles dir: %s", err)
}
// iOS / .mobileprovision
{
mobileProvPth := filepath.Join(absProvProfileDirPath, provProfileUUID+".mobileprovision")
exist, err := pathutil.IsPathExists(mobileProvPth)
if !exist || err != nil {
log.Debugf("No mobileprovision file found at: %s | err: %s", mobileProvPth, err)
} else {
provProfileData, err := CreateProvisioningProfileModelFromFile(mobileProvPth)
if err != nil {
return ProvisioningProfileFileInfoModel{},
fmt.Errorf("Failed to read Provisioning Profile infos from file (path: %s), error: %s",
mobileProvPth, err)
}
return ProvisioningProfileFileInfoModel{
Path: mobileProvPth,
ProvisioningProfileInfo: provProfileData,
}, nil
}
}
// Mac / .provisionprofile
{
macProvProfPth := filepath.Join(absProvProfileDirPath, provProfileUUID+".provisionprofile")
exist, err := pathutil.IsPathExists(macProvProfPth)
if !exist || err != nil {
log.Debugf("No provisionprofile file found at: %s | err: %s", macProvProfPth, err)
return ProvisioningProfileFileInfoModel{}, fmt.Errorf("Failed to find Provisioning Profile with UUID: %s", provProfileUUID)
}
provProfileData, err := CreateProvisioningProfileModelFromFile(macProvProfPth)
if err != nil {
return ProvisioningProfileFileInfoModel{},
fmt.Errorf("Failed to read Provisioning Profile infos from file (path: %s), error: %s",
macProvProfPth, err)
}
return ProvisioningProfileFileInfoModel{
Path: macProvProfPth,
ProvisioningProfileInfo: provProfileData,
}, nil
}
}
func validatePath(pth string) error {
if exist, err := pathutil.IsPathExists(pth); err != nil {
return fmt.Errorf("failed to check bitrise-plugin.yml path (%s), error: %s", pth, err)
} else if !exist {
return fmt.Errorf("no bitrise-plugin.yml found at (%s)", pth)
}
return nil
}
func deleteFileIfExists(pth string) error {
isExists, err := pathutil.IsPathExists(pth)
if err != nil {
return err
}
if !isExists {
return nil
}
return os.Remove(pth)
}
// RemoveDir ...
func RemoveDir(dirPth string) error {
if exist, err := pathutil.IsPathExists(dirPth); err != nil {
return err
} else if exist {
if err := os.RemoveAll(dirPth); err != nil {
return err
}
}
return nil
}
// RemoveFile ...
func RemoveFile(pth string) error {
if exist, err := pathutil.IsPathExists(pth); err != nil {
return err
} else if exist {
if err := os.Remove(pth); err != nil {
return err
}
}
return nil
}
func createChangelog(c *cli.Context) {
//
// Build config
config := releaseman.Config{}
configPath := ""
if c.IsSet("config") {
configPath = c.String("config")
} else {
configPath = releaseman.DefaultConfigPth
}
if exist, err := pathutil.IsPathExists(configPath); err != nil {
log.Warnf("Failed to check if path exist, error: %#v", err)
} else if exist {
config, err = releaseman.NewConfigFromFile(configPath)
if err != nil {
log.Fatalf("Failed to parse release config at (%s), error: %#v", configPath, err)
}
}
config, err := collectChangelogConfigParams(config, c)
if err != nil {
log.Fatalf("Failed to collect config params, error: %#v", err)
}
//
// Validate config
config.Print(releaseman.ChangelogMode)
if !releaseman.IsCIMode {
ok, err := goinp.AskForBoolWithDefault("Are you ready for creating Changelog?", true)
if err != nil {
log.Fatalf("Failed to ask for input, error: %s", err)
}
if !ok {
log.Fatal("Aborted create Changelog")
}
}
//
// Run set version script
if c.IsSet(SetVersionScriptKey) {
setVersionScript := c.String(SetVersionScriptKey)
if err := runSetVersionScript(setVersionScript, config.Release.Version); err != nil {
log.Fatalf("Failed to run set version script, error: %#v", err)
}
}
//
// Generate Changelog
generateChangelog(config)
fmt.Println()
log.Infoln(colorstring.Greenf("v%s Changelog created (%s) 🚀", config.Release.Version, config.Changelog.Path))
}
func (configs ConfigsModel) validate() error {
if configs.ProjectPath == "" {
return errors.New("no ProjectPath parameter specified")
}
if exist, err := pathutil.IsPathExists(configs.ProjectPath); err != nil {
return fmt.Errorf("failed to check if ProjectPath exist at: %s, error: %s", configs.ProjectPath, err)
} else if !exist {
return fmt.Errorf("projectPath not exist at: %s", configs.ProjectPath)
}
if configs.Scheme == "" {
return errors.New("no Scheme parameter specified")
}
if configs.OutputDir == "" {
return errors.New("no OutputDir parameter specified")
}
if configs.OutputTool == "" {
return errors.New("no OutputTool parameter specified")
}
if configs.OutputTool != "xcpretty" && configs.OutputTool != "xcodebuild" {
return fmt.Errorf("invalid OutputTool specified (%s), valid options: [xcpretty xcodebuild]", configs.OutputTool)
}
if configs.IsCleanBuild == "" {
return errors.New("no IsCleanBuild parameter specified")
}
if configs.IsCleanBuild != "yes" && configs.IsCleanBuild != "no" {
return fmt.Errorf("invalid IsCleanBuild specified (%s), valid options: [yes no]", configs.IsCleanBuild)
}
if configs.IsExportXcarchiveZip == "" {
return errors.New("no IsExportXcarchiveZip parameter specified")
}
if configs.IsExportXcarchiveZip != "yes" && configs.IsExportXcarchiveZip != "no" {
return fmt.Errorf("invalid IsExportXcarchiveZip specified (%s), valid options: [yes no]", configs.IsExportXcarchiveZip)
}
if configs.UseDeprecatedExport == "" {
return errors.New("no UseDeprecatedExport parameter specified")
}
if configs.UseDeprecatedExport != "yes" && configs.UseDeprecatedExport != "no" {
return fmt.Errorf("invalid UseDeprecatedExport specified (%s), valid options: [yes no]", configs.UseDeprecatedExport)
}
if configs.ExportAllDsyms == "" {
return errors.New("no ExportAllDsyms parameter specified")
}
if configs.ExportAllDsyms != "yes" && configs.ExportAllDsyms != "no" {
return fmt.Errorf("invalid ExportAllDsyms specified (%s), valid options: [yes no]", configs.ExportAllDsyms)
}
return nil
}
func createDeployPth(deployDir, apkName string) (string, error) {
deployPth := filepath.Join(deployDir, apkName)
if exist, err := pathutil.IsPathExists(deployPth); err != nil {
return "", err
} else if exist {
return "", fmt.Errorf("file already exists at: %s", deployPth)
}
return deployPth, nil
}
// GitUpdate ...
func GitUpdate(git, pth string) error {
if exists, err := pathutil.IsPathExists(pth); err != nil {
return err
} else if !exists {
fmt.Println("[STEPMAN] - Git path does not exist, do clone")
return GitClone(git, pth)
}
fmt.Println("[STEPMAN] - Git path exist, do pull")
return GitPull(pth)
}
// DownloadStep ...
func DownloadStep(collectionURI string, collection models.StepCollectionModel, id, version, commithash string) error {
downloadLocations, err := collection.GetDownloadLocations(id, version)
if err != nil {
return err
}
route, found := ReadRoute(collectionURI)
if !found {
return fmt.Errorf("No routing found for lib: %s", collectionURI)
}
stepPth := GetStepCacheDirPath(route, id, version)
if exist, err := pathutil.IsPathExists(stepPth); err != nil {
return err
} else if exist {
return nil
}
success := false
for _, downloadLocation := range downloadLocations {
switch downloadLocation.Type {
case "zip":
err := retry.Times(2).Wait(3 * time.Second).Try(func(attempt uint) error {
return cmdex.DownloadAndUnZIP(downloadLocation.Src, stepPth)
})
if err != nil {
log.Warn("Failed to download step.zip: ", err)
} else {
success = true
return nil
}
case "git":
err := retry.Times(2).Wait(3 * time.Second).Try(func(attempt uint) error {
return cmdex.GitCloneTagOrBranchAndValidateCommitHash(downloadLocation.Src, stepPth, version, commithash)
})
if err != nil {
log.Warnf("Failed to clone step (%s): %v", downloadLocation.Src, err)
} else {
success = true
return nil
}
default:
return fmt.Errorf("Failed to download: Invalid download location (%#v) for step %#v (%#v)", downloadLocation, id, version)
}
}
if !success {
return errors.New("Failed to download step")
}
return nil
}
func (configs ConfigsModel) validate() error {
if configs.XamarinSolution == "" {
return errors.New("no XamarinSolution parameter specified")
}
if exist, err := pathutil.IsPathExists(configs.XamarinSolution); err != nil {
return fmt.Errorf("failed to check if XamarinSolution exist at: %s, error: %s", configs.XamarinSolution, err)
} else if !exist {
return fmt.Errorf("xamarinSolution not exist at: %s", configs.XamarinSolution)
}
return nil
}
func (configs ConfigsModel) validate() error {
if configs.ApkPath == "" {
return errors.New("no ApkPath parameter specified")
}
if exist, err := pathutil.IsPathExists(configs.ApkPath); err != nil {
return fmt.Errorf("failed to check if apk exist, error: %s", err)
} else if !exist {
return fmt.Errorf("apk not exist at: %s", configs.ApkPath)
}
return nil
}
// InitAtPath ...
func InitAtPath(pth string) error {
if exist, err := pathutil.IsPathExists(pth); err != nil {
return err
} else if !exist {
if err := WriteEnvMapToFile(pth, []models.EnvironmentItemModel{}); err != nil {
return err
}
} else {
errorMsg := "Path already exist: " + pth
return errors.New(errorMsg)
}
return nil
}
// ReadBytesFromFile ...
func ReadBytesFromFile(pth string) ([]byte, error) {
if isExists, err := pathutil.IsPathExists(pth); err != nil {
return []byte{}, err
} else if !isExists {
return []byte{}, fmt.Errorf("No file found at path: %s", pth)
}
bytes, err := ioutil.ReadFile(pth)
if err != nil {
return []byte{}, err
}
return bytes, nil
}
// DeletePlugin ...
func DeletePlugin(pluginName, pluginType string) error {
pluginPath, err := GetPluginPath(pluginName, pluginType)
if err != nil {
return err
}
if exists, err := pathutil.IsPathExists(pluginPath); err != nil {
return fmt.Errorf("Failed to check dir (%s), err: %s", pluginPath, err)
} else if !exists {
return fmt.Errorf("Plugin (%s) not installed", PrintableName(pluginName, pluginType))
}
return os.Remove(pluginPath)
}