// UninstallPlugin uninstall the given plugin of the given version
// If version is not specified, it uninstalls all the versions of given plugin
func UninstallPlugin(pluginName string, version string) {
pluginsHome, err := common.GetPrimaryPluginsInstallDir()
if err != nil {
logger.Fatalf("Failed to uninstall plugin %s. %s", pluginName, err.Error())
}
if !common.DirExists(filepath.Join(pluginsHome, pluginName, version)) {
logger.Errorf("Plugin %s not found.", strings.TrimSpace(pluginName+" "+version))
os.Exit(0)
}
var failed bool
pluginsDir := filepath.Join(pluginsHome, pluginName)
filepath.Walk(pluginsDir, func(dir string, info os.FileInfo, err error) error {
if err == nil && info.IsDir() && dir != pluginsDir && strings.HasPrefix(filepath.Base(dir), version) {
if err := uninstallVersionOfPlugin(dir, pluginName, filepath.Base(dir)); err != nil {
logger.Errorf("Failed to uninstall plugin %s %s. %s", pluginName, version, err.Error())
failed = true
}
}
return nil
})
if failed {
os.Exit(1)
}
if version == "" {
if err := os.RemoveAll(pluginsDir); err != nil {
logger.Fatalf("Failed to remove directory %s. %s", pluginsDir, err.Error())
}
}
}
// Download fires a HTTP GET request to download a resource to target directory
func Download(url, targetDir, fileName string, silent bool) (string, error) {
if !common.DirExists(targetDir) {
return "", fmt.Errorf("Error downloading file: %s\nTarget dir %s doesn't exists.", url, targetDir)
}
if fileName == "" {
fileName = filepath.Base(url)
}
targetFile := filepath.Join(targetDir, fileName)
resp, err := http.Get(url)
if err != nil {
return "", err
}
if resp.StatusCode >= 400 {
return "", fmt.Errorf("Error downloading file: %s.\n%s", url, resp.Status)
}
defer resp.Body.Close()
out, err := os.Create(targetFile)
if err != nil {
return "", err
}
defer out.Close()
if silent {
_, err = io.Copy(out, resp.Body)
} else {
progressReader := &progressReader{Reader: resp.Body, totalBytes: resp.ContentLength}
_, err = io.Copy(out, progressReader)
fmt.Println()
}
return targetFile, err
}
// Loads all the properties files available in the specified env directory
func loadEnvironment(env string) error {
envDir := filepath.Join(config.ProjectRoot, common.EnvDirectoryName)
dirToRead := path.Join(envDir, env)
if !common.DirExists(dirToRead) {
return errors.New(fmt.Sprintf("%s is an invalid environment", env))
}
isProperties := func(fileName string) bool {
return filepath.Ext(fileName) == ".properties"
}
err := filepath.Walk(dirToRead, func(path string, info os.FileInfo, err error) error {
if isProperties(path) {
p, e := properties.Load(path)
if e != nil {
return errors.New(fmt.Sprintf("Failed to parse: %s. %s", path, e.Error()))
}
for k, v := range p {
err := common.SetEnvVariable(k, v)
if err != nil {
return errors.New(fmt.Sprintf("%s: %s", path, err.Error()))
}
}
}
return nil
})
return err
}
func getEclipseClasspath() string {
eclipseOutDir := path.Join("bin")
if !common.DirExists(eclipseOutDir) {
return ""
}
return eclipseOutDir
}
func createDirectory(dir string) {
if common.DirExists(dir) {
return
}
if err := os.MkdirAll(dir, common.NewDirectoryPermissions); err != nil {
fmt.Printf("Failed to create directory %s: %s\n", defaultReportsDir, err)
os.Exit(1)
}
}
func GetSpecFiles(specSource string) []string {
specFiles := make([]string, 0)
if common.DirExists(specSource) {
specFiles = append(specFiles, FindSpecFilesIn(specSource)...)
} else if common.FileExists(specSource) && IsValidSpecExtension(specSource) {
specFile, _ := filepath.Abs(specSource)
specFiles = append(specFiles, specFile)
}
return specFiles
}
// GetSpecFiles returns the list of spec files present at the given path.
// If the path itself represents a spec file, it returns the same.
func GetSpecFiles(path string) []string {
var specFiles []string
if common.DirExists(path) {
specFiles = append(specFiles, FindSpecFilesIn(path)...)
} else if common.FileExists(path) && IsValidSpecExtension(path) {
f, _ := filepath.Abs(path)
specFiles = append(specFiles, f)
}
return specFiles
}
func createDirectory(filePath string) {
showMessage("create", filePath)
if !common.DirExists(filePath) {
err := os.MkdirAll(filePath, 0755)
if err != nil {
fmt.Printf("Failed to make directory. %s\n", err.Error())
}
} else {
showMessage("skip", filePath)
}
}
func loadEnvDir(envName string) error {
envDirPath := filepath.Join(config.ProjectRoot, common.EnvDirectoryName, envName)
if !common.DirExists(envDirPath) {
if envName != "default" {
return fmt.Errorf("%s environment does not exist", envName)
}
return nil
}
return filepath.Walk(envDirPath, loadEnvFile)
}
func createDirectory(dirPath string) {
showMessage("create", dirPath)
if !common.DirExists(dirPath) {
err := os.MkdirAll(dirPath, common.NewDirectoryPermissions)
if err != nil {
fmt.Printf("Failed to make directory. %s\n", err.Error())
}
} else {
fmt.Println("skip ", dirPath)
}
}
func copyPluginFilesToGauge(installDesc *installDescription, versionInstallDesc *versionInstallDescription, pluginContents string) error {
pluginsDir, err := common.GetPrimaryPluginsInstallDir()
if err != nil {
return err
}
versionedPluginDir := path.Join(pluginsDir, installDesc.Name, versionInstallDesc.Version)
if common.DirExists(versionedPluginDir) {
return errors.New(fmt.Sprintf("Plugin %s %s already installed at %s", installDesc.Name, versionInstallDesc.Version, versionedPluginDir))
}
return common.MirrorDir(pluginContents, versionedPluginDir)
}
func getPluginInstallDir(pluginID, pluginDirName string) (string, error) {
pluginsDir, err := common.GetPrimaryPluginsInstallDir()
if err != nil {
return "", err
}
pluginDirPath := filepath.Join(pluginsDir, pluginID, pluginDirName)
if common.DirExists(pluginDirPath) {
return "", fmt.Errorf("Plugin %s %s already installed at %s", pluginID, pluginDirName, pluginDirPath)
}
return pluginDirPath, nil
}
func copyPluginFilesToGaugeInstallDir(unzippedPluginDir string, pluginId string, version string) error {
logger.Log.Info("Installing Plugin => %s %s\n", pluginId, version)
pluginsDir, err := common.GetPrimaryPluginsInstallDir()
if err != nil {
return err
}
versionedPluginDir := path.Join(pluginsDir, pluginId, version)
if common.DirExists(versionedPluginDir) {
return errors.New(fmt.Sprintf("Plugin %s %s already installed at %s", pluginId, version, versionedPluginDir))
}
return common.MirrorDir(unzippedPluginDir, versionedPluginDir)
}
func UninstallPlugin(pluginName string) {
pluginsDir, err := common.GetPrimaryPluginsInstallDir()
if err != nil {
handleUninstallFailure(err, pluginName)
}
pluginInstallationDir := path.Join(pluginsDir, pluginName)
if common.DirExists(pluginInstallationDir) {
if err = os.RemoveAll(pluginInstallationDir); err != nil {
handleUninstallFailure(err, pluginName)
} else {
logger.Log.Info("%s plugin uninstalled successfully", pluginName)
}
} else {
logger.Log.Info("%s plugin is not installed", pluginName)
}
}
func setWorkingDir(workingDir string) {
targetDir, err := filepath.Abs(workingDir)
if err != nil {
handleCriticalError(errors.New(fmt.Sprintf("Unable to set working directory : %s\n", err)))
}
if !common.DirExists(targetDir) {
err = os.Mkdir(targetDir, 0777)
if err != nil {
handleCriticalError(errors.New(fmt.Sprintf("Unable to set working directory : %s\n", err)))
}
}
err = os.Chdir(targetDir)
_, err = os.Getwd()
if err != nil {
handleCriticalError(errors.New(fmt.Sprintf("Unable to set working directory : %s\n", err)))
}
}
// SetWorkingDir sets the current working directory to specified location
func SetWorkingDir(workingDir string) {
targetDir, err := filepath.Abs(workingDir)
if err != nil {
logger.Log.Critical("Unable to set working directory : %s\n", err.Error())
}
if !common.DirExists(targetDir) {
err = os.Mkdir(targetDir, 0777)
if err != nil {
logger.Log.Critical("Unable to set working directory : %s\n", err.Error())
}
}
err = os.Chdir(targetDir)
_, err = os.Getwd()
if err != nil {
logger.Log.Critical("Unable to set working directory : %s\n", err.Error())
}
}
func IsPluginInstalled(pluginName, pluginVersion string) bool {
pluginsInstallDir, err := common.GetPluginsInstallDir(pluginName)
if err != nil {
return false
}
thisPluginDir := filepath.Join(pluginsInstallDir, pluginName)
if !common.DirExists(thisPluginDir) {
return false
}
if pluginVersion != "" {
pluginJSON := filepath.Join(thisPluginDir, pluginVersion, common.PluginJSONFile)
if common.FileExists(pluginJSON) {
return true
}
return false
}
return true
}
func UninstallPlugin(pluginName string, version string) {
pluginsDir, err := common.GetPrimaryPluginsInstallDir()
if err != nil {
handleUninstallFailure(err, pluginName)
}
pluginInfo := pluginName
if version != "" {
pluginInfo = fmt.Sprintf("%s(%s)", pluginName, version)
}
pluginInstallationDir := path.Join(pluginsDir, pluginName, version)
if common.DirExists(pluginInstallationDir) {
if err = os.RemoveAll(pluginInstallationDir); err != nil {
handleUninstallFailure(err, pluginInfo)
} else {
logger.Info("%s plugin uninstalled successfully", pluginInfo)
}
} else {
logger.Info("%s plugin is not installed", pluginInfo)
}
}
func getIntelliJClasspath() string {
intellijOutDir := path.Join("out", "production")
if !common.DirExists(intellijOutDir) {
return ""
}
cp := ""
walker := func(path string, info os.FileInfo, err error) error {
if path == intellijOutDir {
return nil
}
if info.IsDir() {
appendClasspath(&cp, path)
// we need only top-level directories. Don't walk nested
return filepath.SkipDir
}
return nil
}
filepath.Walk(intellijOutDir, walker)
return cp
}
func createProjectTemplate(language string) error {
// Create the project manifest
showMessage("create", common.ManifestFile)
if common.FileExists(common.ManifestFile) {
showMessage("skip", common.ManifestFile)
}
manifest := &manifest.Manifest{Language: language, Plugins: defaultPlugins}
if err := manifest.Save(); err != nil {
return err
}
// creating the spec directory
showMessage("create", specsDirName)
if !common.DirExists(specsDirName) {
err := os.Mkdir(specsDirName, common.NewDirectoryPermissions)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", specsDirName, err.Error()))
}
} else {
showMessage("skip", specsDirName)
}
// Copying the skeleton file
skelFile, err := common.GetSkeletonFilePath(skelFileName)
if err != nil {
return err
}
specFile := path.Join(specsDirName, skelFileName)
showMessage("create", specFile)
if common.FileExists(specFile) {
showMessage("skip", specFile)
} else {
err = common.CopyFile(skelFile, specFile)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", specFile, err.Error()))
}
}
// Creating the env directory
showMessage("create", common.EnvDirectoryName)
if !common.DirExists(common.EnvDirectoryName) {
err = os.Mkdir(common.EnvDirectoryName, common.NewDirectoryPermissions)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", common.EnvDirectoryName, err.Error()))
}
}
defaultEnv := path.Join(common.EnvDirectoryName, envDefaultDirName)
showMessage("create", defaultEnv)
if !common.DirExists(defaultEnv) {
err = os.Mkdir(defaultEnv, common.NewDirectoryPermissions)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", defaultEnv, err.Error()))
}
}
defaultJSON, err := common.GetSkeletonFilePath(path.Join(common.EnvDirectoryName, common.DefaultEnvFileName))
if err != nil {
return err
}
defaultJSONDest := path.Join(defaultEnv, common.DefaultEnvFileName)
showMessage("create", defaultJSONDest)
err = common.CopyFile(defaultJSON, defaultJSONDest)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", defaultJSONDest, err.Error()))
}
return runner.ExecuteInitHookForRunner(language)
}
func createProjectTemplate(language string) error {
if !install.IsCompatibleLanguagePluginInstalled(language) {
logger.Info("Compatible %s plugin is not installed \n", language)
logger.Info("Installing plugin => %s ... \n\n", language)
if result := install.InstallPlugin(language, ""); !result.Success {
return fmt.Errorf("Failed to install plugin %s . %s \n", language, result.Error.Error())
}
}
// Create the project manifest
showMessage("create", common.ManifestFile)
if common.FileExists(common.ManifestFile) {
showMessage("skip", common.ManifestFile)
}
manifest := &manifest.Manifest{Language: language, Plugins: defaultPlugins}
if err := manifest.Save(); err != nil {
return err
}
// creating the spec directory
showMessage("create", specsDirName)
if !common.DirExists(specsDirName) {
err := os.Mkdir(specsDirName, common.NewDirectoryPermissions)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", specsDirName, err.Error()))
}
} else {
showMessage("skip", specsDirName)
}
// Copying the skeleton file
skelFile, err := common.GetSkeletonFilePath(skelFileName)
if err != nil {
return err
}
specFile := path.Join(specsDirName, skelFileName)
showMessage("create", specFile)
if common.FileExists(specFile) {
showMessage("skip", specFile)
} else {
err = common.CopyFile(skelFile, specFile)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", specFile, err.Error()))
}
}
// Creating the env directory
showMessage("create", common.EnvDirectoryName)
if !common.DirExists(common.EnvDirectoryName) {
err = os.Mkdir(common.EnvDirectoryName, common.NewDirectoryPermissions)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", common.EnvDirectoryName, err.Error()))
}
}
defaultEnv := path.Join(common.EnvDirectoryName, envDefaultDirName)
showMessage("create", defaultEnv)
if !common.DirExists(defaultEnv) {
err = os.Mkdir(defaultEnv, common.NewDirectoryPermissions)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", defaultEnv, err.Error()))
}
}
defaultJSON, err := common.GetSkeletonFilePath(path.Join(common.EnvDirectoryName, common.DefaultEnvFileName))
if err != nil {
return err
}
defaultJSONDest := path.Join(defaultEnv, common.DefaultEnvFileName)
showMessage("create", defaultJSONDest)
err = common.CopyFile(defaultJSON, defaultJSONDest)
if err != nil {
showMessage("error", fmt.Sprintf("Failed to create %s. %s", defaultJSONDest, err.Error()))
}
return runner.ExecuteInitHookForRunner(language)
}
