func ExecuteInitHookForRunner(language string) error {
if err := config.SetProjectRoot([]string{}); err != nil {
return err
}
runnerInfo, err := GetRunnerInfo(language)
if err != nil {
return err
}
command := []string{}
switch runtime.GOOS {
case "windows":
command = runnerInfo.Init.Windows
break
case "darwin":
command = runnerInfo.Init.Darwin
break
default:
command = runnerInfo.Init.Linux
break
}
languageJsonFilePath, err := common.GetLanguageJSONFilePath(language)
runnerDir := filepath.Dir(languageJsonFilePath)
cmd, err := common.ExecuteCommand(command, runnerDir, os.Stdout, os.Stderr)
if err != nil {
return err
}
return cmd.Wait()
}
func StartPlugin(pd *pluginDescriptor, action string) (*plugin, error) {
command := []string{}
switch runtime.GOOS {
case "windows":
command = pd.Command.Windows
break
case "darwin":
command = pd.Command.Darwin
break
default:
command = pd.Command.Linux
break
}
if len(command) == 0 {
return nil, fmt.Errorf("Platform specific command not specified: %s.", runtime.GOOS)
}
cmd, err := common.ExecuteCommand(command, pd.pluginPath, reporter.Current(), reporter.Current())
if err != nil {
return nil, err
}
var mutex = &sync.Mutex{}
go func() {
pState, _ := cmd.Process.Wait()
mutex.Lock()
cmd.ProcessState = pState
mutex.Unlock()
}()
plugin := &plugin{pluginCmd: cmd, descriptor: pd, mutex: mutex}
return plugin, nil
}
func StartPlugin(pd *pluginDescriptor, action string, wait bool) (*exec.Cmd, error) {
command := []string{}
switch runtime.GOOS {
case "windows":
command = pd.Command.Windows
break
case "darwin":
command = pd.Command.Darwin
break
default:
command = pd.Command.Linux
break
}
if len(command) == 0 {
return nil, fmt.Errorf("Platform specific command not specified: %s.", runtime.GOOS)
}
cmd, err := common.ExecuteCommand(command, pd.pluginPath, logger.Log, logger.Log)
if err != nil {
return nil, err
}
if wait {
return cmd, cmd.Wait()
} else {
go func() {
cmd.Wait()
}()
}
return cmd, nil
}
func runInstallCommands(installCommands platformSpecificCommand, workingDir string) error {
command := []string{}
switch runtime.GOOS {
case "windows":
command = installCommands.Windows
break
case "darwin":
command = installCommands.Darwin
break
default:
command = installCommands.Linux
break
}
if len(command) == 0 {
return nil
}
logger.Info("Running plugin install command => %s\n", command)
cmd, err := common.ExecuteCommand(command, workingDir, os.Stdout, os.Stderr)
if err != nil {
return err
}
return cmd.Wait()
}
func initializeTemplate(templateName string) error {
defer util.RemoveTempDir()
unzippedTemplate, err := util.DownloadAndUnzip(getTemplateURL(templateName))
if err != nil {
return err
}
wd := config.ProjectRoot
logger.Log.Info("Copying Gauge template %s to current directory ...", templateName)
filesAdded, err := common.MirrorDir(filepath.Join(unzippedTemplate, templateName), wd)
if err != nil {
return fmt.Errorf("Failed to copy Gauge template: %s", err.Error())
}
metadataFile := filepath.Join(wd, metadataFileName)
metadataContents, err := common.ReadFileContents(metadataFile)
if err != nil {
return fmt.Errorf("Failed to read file contents of %s: %s", metadataFile, err.Error())
}
metadata := &templateMetadata{}
err = json.Unmarshal([]byte(metadataContents), metadata)
if err != nil {
return err
}
if metadata.PostInstallCmd != "" {
cmd, err := common.ExecuteCommand([]string{metadata.PostInstallCmd}, wd, os.Stdout, os.Stderr)
cmd.Wait()
if err != nil {
for _, file := range filesAdded {
pathSegments := strings.Split(file, string(filepath.Separator))
util.Remove(filepath.Join(wd, pathSegments[0]))
}
return fmt.Errorf("Failed to run post install commands: %s", err.Error())
}
}
util.Remove(metadataFile)
return nil
}