Exemplo n.º 1
0
func pluginInfo(name string) (ver, short, long string) {
	if os.Getenv("HKPLUGINMODE") == "info" {
		return "", "plugin exec loop", "plugin exec loop"
	}
	short = "no description"
	long = name + ": unknown description"
	var cmd exec.Cmd
	cmd.Args = []string{name}
	cmd.Path = lookupPlugin(name)
	cmd.Env = append([]string{"HKPLUGINMODE=info"}, os.Environ()...)
	buf, err := cmd.Output()
	if err != nil {
		return
	}
	info := string(buf)
	if !strings.HasPrefix(info, name+" ") {
		return
	}
	info = info[len(name)+1:]
	i := strings.Index(info, ": ")
	if i < 0 {
		return
	}
	ver, info = info[:i], info[i+2:]
	i = strings.Index(info, "\n\n")
	if i < 0 || 50 < i || strings.Contains(info[:i], "\n") {
		return
	}
	short, long = info[:i], info[i+2:]
	return ver, strings.TrimSpace(short), strings.TrimSpace(long)
}
Exemplo n.º 2
0
// stem words and add them to vocabulary
func (vocabulary Dictionary) add(words []string, mode string) (wordIDs []int) {
	var lemma string
	wordIDs = make([]int, len(words))
	for idx, word := range words {
		if _, ok := vocabulary.Vtoi[word]; ok {
			wordIDs[idx] = vocabulary.Vtoi[word]
		} else {
			python := new(exec.Cmd)
			args := []string{"lemmatizer.py", "--vocabulary"}
			args = append(args, word)
			args = append(args, "--pos")
			args = append(args, mode)
			python.Args = args
			//       python.Path = "/home/lea/Code/Python/lemmatizer.py"
			python.Path = "/local/lea/thesis/python/lemmatizer.py"
			out, _ := python.Output()
			lemma = strings.Trim(string(out), "\n")
			if _, ok := vocabulary.Vtoi[lemma]; !ok {
				vocabulary.VList[vocabIdx] = lemma
				vocabulary.Vtoi[lemma] = vocabIdx
				vocabulary.Itov[vocabIdx] = lemma
				vocabulary.POSList[vocabIdx] = mode
				vocabIdx++
			}
			wordIDs[idx] = vocabulary.Vtoi[lemma]
		}
	}
	return wordIDs
}
Exemplo n.º 3
0
// Initialize a new ExecutablePlugin from path to executable and daemon mode (true or false)
func NewExecutablePlugin(a Arg, path string) (*ExecutablePlugin, error) {
	jsonArgs, err := json.Marshal(a)
	if err != nil {
		return nil, err
	}
	// Init the cmd
	cmd := new(exec.Cmd)
	cmd.Path = path
	cmd.Args = []string{path, string(jsonArgs)}
	// Link the stdout for response reading
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return nil, err
	}
	stderr, err := cmd.StderrPipe()
	if err != nil {
		return nil, err
	}
	// Init the ExecutablePlugin and return
	ePlugin := new(ExecutablePlugin)
	ePlugin.cmd = cmd
	ePlugin.stdout = stdout
	ePlugin.args = a
	ePlugin.stderr = stderr

	return ePlugin, nil
}
Exemplo n.º 4
0
// Run a command, waiting for it to finish. Will first run CMD's path;
// failing that, will lookup the path and attempt to do the same.
func execvp(cmd *exec.Cmd) error {
	if err := cmd.Start(); err == nil {

		// Wait for command to finish
		return cmd.Wait()

	} else {

		// Didn't work? Search for the executable's path
		path, err := exec.LookPath(cmd.Path)
		if err != nil {
			return err
		}

		// Reset our path
		cmd.Path = path

		// Try again with the executable found in $PATH
		err = cmd.Start()
		if err != nil {
			return err
		}

		return cmd.Wait()
	}
}
Exemplo n.º 5
0
Arquivo: plugin.go Projeto: uriel/hk
func pluginInfo(name string) (ver, short, long string) {
	if os.Getenv("HKPLUGINMODE") == "info" {
		return "", "[plugin exec loop]", "[plugin exec loop]\n"
	}
	var cmd exec.Cmd
	cmd.Args = []string{name}
	cmd.Path = lookupPlugin(name)
	cmd.Env = append([]string{"HKPLUGINMODE=info"}, os.Environ()...)
	buf, err := cmd.Output()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		return "", "[unknown description]", "[unknown description]\n"
	}
	info := string(buf)
	if !strings.HasPrefix(info, name+" ") {
		return "", "[unknown description]", "[unknown description]\n"
	}
	info = info[len(name)+1:]
	i := strings.Index(info, ": ")
	ver, info = info[:i], info[i+2:]
	i = strings.Index(info, "\n\n")
	short, long = info[:i], info[i+2:]
	if len(short) > 50 || strings.Contains(short, "\n") {
		return "", "[unknown description]", "[unknown description]\n"
	}
	return ver, short, long
}
Exemplo n.º 6
0
func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "%s", Help)
		os.Exit(1)
	}
	flag.Parse()

	if *version {
		fmt.Printf("%s", Version)
		os.Exit(0)
	}

	if *unset != "" {
		os.Unsetenv(*unset)
	}

	cmd := new(exec.Cmd)
	cmd.Env = env

	// Check for "-" as an argument, because it means the same as "-i"
	if flag.Arg(0) == "-" {
		cmd.Env = make([]string, 0)
	}

	for i, arg := range flag.Args() {
		if strings.Index(arg, delim) > 0 {
			cmd.Env = append(cmd.Env, arg)
		} else if arg != "-" {
			if *nullEol {
				fatal.Fatalln("cannot specify --null (-0) with command")
			}

			cmd.Path = arg

			cmd.Args = append(cmd.Args, flag.Args()[i:]...)
			cmd.Stdin = os.Stdin
			cmd.Stdout = os.Stdout
			cmd.Stderr = os.Stderr

			err := execvp(cmd)
			if err != nil {
				fatal.Fatalln(err)
			}
			return
		}

		i++
	}

	eol := '\n'
	if *nullEol {
		eol = '\x00'
	}

	for _, e := range env {
		fmt.Printf("%s%c", e, eol)
	}

	return
}
Exemplo n.º 7
0
func RunWithEnvAndWd(command string, args []string, env []string, wd string) (proc *exec.Cmd, err error) {
	//log.Println(command, args)
	//hho := exec.PassThrough
	args = prepend(args, command)
	env = mergeEnv(os.Environ(), env)

	binpath, err := findCmd(findEnv(env, "PATH"), command)
	if err != nil {
		return nil, err
	}

	cmd := new(exec.Cmd)
	cmd.Path = binpath
	cmd.Args = args
	cmd.Env = env
	cmd.Dir = wd
	cmd.Stderr = os.Stderr
	cmd.Stdout = os.Stdout

	err = cmd.Start()
	if err != nil {
		log.Print("Error running command ", command, ": ", err, "\n")
		return nil, err
	}
	return cmd, nil
}
Exemplo n.º 8
0
func execute(path string, vcs string, vcs_verb string) {
	if vcs_verb == "" {
		return
	}
	a := func(wd string, vcs string, vcs_verb string, seq bool) {
		msg := "=== @{!" + vcs_color[vcs] + "} "
		msg += filepath.Base(path)
		msg += "@| (@!" + vcs + "@|) ==="
		var cmd exec.Cmd
		cmd.Dir = wd
		cmd.Args = strings.Split(vcs_verb, " ")
		path, err := exec.LookPath(cmd.Args[0])
		if err != nil {
			path = cmd.Args[0]
		}
		cmd.Path = path
		out, err := cmd.CombinedOutput()
		if err != nil {
			br := color.Colorize("!r")
			rst := color.Colorize("|")
			fmt.Printf(color.Sprint(msg)+"\n%s\n%s%s%s\n\n", out, br, err, rst)
		} else {
			fmt.Printf(color.Sprint(msg)+"\n%s\n", out)
		}
		if !seq {
			quit <- 0
		}
	}
	if *sequential {
		a(path, vcs, vcs_verb, *sequential)
	} else {
		count += 1
		go a(path, vcs, vcs_verb, *sequential)
	}
}
Exemplo n.º 9
0
func (mp *CustomMediaPlayer) PlayFile(file string) error {
	var command exec.Cmd
	command.Path = mp.Executable
	mp.Args[len(mp.Args)-1] = file
	command.Args = mp.Args

	command.Start()
	return nil
}
func (r *RealCommandRunner) resolve(cmd *exec.Cmd) *exec.Cmd {
	originalPath := cmd.Path

	path, err := exec.LookPath(cmd.Path)
	if err != nil {
		path = cmd.Path
	}

	cmd.Path = path

	cmd.Args = append([]string{originalPath}, cmd.Args...)

	return cmd
}
Exemplo n.º 11
0
func (vocabulary *Vocabulary) CreateCovarianceMatrix() {
	vocabulary.Covariances = new(CovarianceStruct)
	args := []string{"wnCovarianceSvsH.py", "--vocabulary"}
	args = append(args, vocabulary.Dictionary.VList...)
	args = append(args, "--pos")
	args = append(args, vocabulary.Dictionary.POSList...)
	cmd := new(exec.Cmd)
	cmd.Args = args
	//   cmd.Path = "/home/lea/Code/Python/wnCovariance.py"
	cmd.Path = "/local/lea/thesis/python/wnCovarianceSvsH.py"
	out, err := cmd.Output()
	if err != nil {
		fmt.Println(err)
	}
	vocabulary.parse(string(out))
}
Exemplo n.º 12
0
func main() {
	args := parseFlags(os.Args)

	if unset != "" {
		os.Unsetenv(unset)
	}

	cmd := exec.Cmd{Env: env}

	// Check for "-" as an argument, because it means the same as "-i"
	if flag.Arg(0) == "-" {
		cmd.Env = []string{}
	}

	for i, arg := range args {
		if strings.Index(arg, "=") > 0 {
			cmd.Env = append(cmd.Env, arg)
		} else if arg != "-" {
			if nullEol {
				fatal.Fatalln("cannot specify --null (-0) with command")
			}

			cmd.Path = arg

			cmd.Args = append(cmd.Args, args[i:]...)
			cmd.Stdin = os.Stdin
			cmd.Stdout = os.Stdout
			cmd.Stderr = os.Stderr

			if err := execvp(cmd); err != nil {
				fatal.Fatalln(err)
			}
			return
		}
	}

	eol := '\n'
	if nullEol {
		eol = '\x00'
	}

	for _, e := range env {
		fmt.Printf("%s%c", e, eol)
	}

	return
}
Exemplo n.º 13
0
func (p *plugin) fetchMailqCount() (count uint64, err error) {

	var path string
	if p.path != "" {
		path = p.path
	} else {
		path, err = exec.LookPath(p.mailq.command)
		if err != nil {
			return
		}
	}

	cmd := exec.Cmd{
		Path: path,
		Args: append([]string{p.mailq.command}, p.mailq.args...),
	}

	if p.path != "" {
		cmd.Path = p.path
	}

	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return
	}

	err = cmd.Start()
	if err != nil {
		return
	}

	count, err = p.mailq.parse(stdout)
	if err != nil {
		cmd.Wait()
		return
	}

	err = cmd.Wait()
	return
}
Exemplo n.º 14
0
func cmd_to_channel(argv []string, name string, out chan string) {
	var cmd exec.Cmd
	cmd.Path = argv[0]
	cmd.Args = argv
	log.Printf("starting '%s'\n", name)

	stdout, err := cmd.StdoutPipe()
	if err != nil {
		log.Println(err)
	}

	stderr, err := cmd.StderrPipe()
	if err != nil {
		log.Println(err)
	}

	if err := cmd.Start(); err != nil {
		log.Fatal(err)
	}

	mux_readers_into_channel(stdout, stderr, out)
	cmd.Wait()
	log.Printf("'%s' finished\n", name)
}
Exemplo n.º 15
0
Arquivo: mail.go Projeto: crooks/yamn
// Pipe mail to an external command (E.g. sendmail -t)
func execSend(payload []byte, execCmd string) {
	sendmail := new(exec.Cmd)
	sendmail.Args = strings.Fields(execCmd)
	sendmail.Path = sendmail.Args[0]

	stdin, err := sendmail.StdinPipe()
	if err != nil {
		panic(err)
	}
	defer stdin.Close()
	sendmail.Stdout = os.Stdout
	sendmail.Stderr = os.Stderr
	err = sendmail.Start()
	if err != nil {
		panic(err)
	}
	stdin.Write(payload)
	stdin.Close()
	err = sendmail.Wait()
	if err != nil {
		//Warn.Printf("%s: %s", execCmd, err)
		panic(err)
	}
}
Exemplo n.º 16
0
// collectGitInfo runs several git commands to compose a Git object.
func collectGitInfo() *Git {
	gitCmds := map[string][]string{
		"id":      {"git", "rev-parse", "HEAD"},
		"branch":  {"git", "rev-parse", "--abbrev-ref", "HEAD"},
		"aname":   {"git", "log", "-1", "--pretty=%aN"},
		"aemail":  {"git", "log", "-1", "--pretty=%aE"},
		"cname":   {"git", "log", "-1", "--pretty=%cN"},
		"cemail":  {"git", "log", "-1", "--pretty=%cE"},
		"message": {"git", "log", "-1", "--pretty=%s"},
		"remotes": {"git", "remote", "-v"},
	}
	results := map[string]string{}
	remotes := map[string]Remote{}
	gitPath, err := exec.LookPath("git")
	if err != nil {
		log.Fatal(err)
	}
	for key, args := range gitCmds {
		cmd := exec.Cmd{}
		cmd.Path = gitPath
		cmd.Args = args
		cmd.Stderr = os.Stderr
		ret, err := cmd.Output()
		if err != nil {
			log.Fatal(err)
		}
		s := string(ret)
		s = strings.TrimRight(s, "\n")
		results[key] = s
	}
	for _, line := range strings.Split(results["remotes"], "\n") {
		matches := remotesRE.FindAllStringSubmatch(line, -1)
		if len(matches) != 1 {
			continue
		}
		if len(matches[0]) != 3 {
			continue
		}
		name := matches[0][1]
		url := matches[0][2]
		r := Remote{
			Name: name,
			Url:  url,
		}
		remotes[name] = r
	}
	h := Head{}
	h.Id = results["id"]
	h.AuthorName = results["aname"]
	h.AuthorEmail = results["aemail"]
	h.CommitterName = results["cname"]
	h.CommitterEmail = results["cemail"]
	h.Message = results["message"]
	g := Git{}
	g.Head = h
	g.Branch = results["branch"]
	for _, r := range remotes {
		g.Remotes = append(g.Remotes, &r)
	}
	return &g
}
Exemplo n.º 17
0
// Info runs several git commands to compose a Git object.
func Info() *Git {
	gitCmds := map[string][]string{
		"id":      {"git", "rev-parse", "HEAD"},
		"branch":  {"git", "rev-parse", "--abbrev-ref", "HEAD"},
		"aname":   {"git", "log", "-1", "--pretty=%aN"},
		"aemail":  {"git", "log", "-1", "--pretty=%aE"},
		"cname":   {"git", "log", "-1", "--pretty=%cN"},
		"cemail":  {"git", "log", "-1", "--pretty=%cE"},
		"message": {"git", "log", "-1", "--pretty=%s"},
		"remotes": {"git", "remote", "-v"},
	}
	results := map[string]string{}
	remotes := map[string]Remote{}
	gitPath, err := exec.LookPath("git")
	if err != nil {
		log.Fatal(err)
	}
	for key, args := range gitCmds {
		if key == "branch" {
			if envBranch := os.Getenv("GIT_BRANCH"); envBranch != "" {
				results[key] = envBranch
				continue
			}
		}

		cmd := exec.Cmd{}
		cmd.Path = gitPath
		cmd.Args = args
		cmd.Stderr = os.Stderr
		ret, err := cmd.Output()
		if err != nil {
			log.Fatal(err)
		}
		s := string(ret)
		s = strings.TrimRight(s, "\n")
		results[key] = s
	}
	for _, line := range strings.Split(results["remotes"], "\n") {
		matches := remotesRE.FindAllStringSubmatch(line, -1)
		if len(matches) != 1 {
			continue
		}
		if len(matches[0]) != 3 {
			continue
		}
		name := matches[0][1]
		url := matches[0][2]
		r := Remote{
			Name: name,
			URL:  url,
		}
		remotes[name] = r
	}
	h := Head{
		ID:             results["id"],
		AuthorName:     results["aname"],
		AuthorEmail:    results["aemail"],
		CommitterName:  results["cname"],
		CommitterEmail: results["cemail"],
		Message:        results["message"],
	}
	g := &Git{
		Head:   h,
		Branch: results["branch"],
	}
	for _, r := range remotes {
		g.Remotes = append(g.Remotes, &r)
	}
	return g
}