Exec external commands

cache-nuget.go

package main

import (
	"bufio"
	"flag"
	"fmt"
	"log"
	"os"
	"os/exec"
	"time"
)

type task struct {
	cmd *exec.Cmd
}

func (t *task) Run() error {
	log.Printf("running %v", t.cmd.Args)

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

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

	out := bufio.NewScanner(stout)
	for out.Scan() {
		log.Print(out.Text())
	}
	if err := out.Err(); err != nil {
		return err
	}

	return nil
}

var (
	workingDir string
	logFile    string
	slnFile    string
	vpn        string
)

func checkCommands() error {
	if _, err := exec.LookPath("hg"); err != nil {
		return err
	}
	if _, err := exec.LookPath("nuget"); err != nil {
		return err
	}
	return nil
}

func connVPN(name string) error {
	conn := exec.Command("rasdial", name)

	stdout, err := conn.StdoutPipe()

	if err != nil {
		return err
	}

	if err := conn.Start(); err != nil {
		return err
	}

	out := bufio.NewScanner(stdout)
	var result string
	if out.Scan() {
		result = out.Text()
	}
	if result == fmt.Sprintf("You are already connected to %v.", name) {
		log.Println("VPN already connected")
		return nil
	}

	time.Sleep(time.Second * 50)

	test := exec.Command("rasdial", name)
	if err := test.Run(); err != nil {
		return err
	}

	return nil
}

func newTask(name string, arg ...string) *task {
	cmd := exec.Command(name, arg...)
	cmd.Dir = workingDir
	return &task{cmd}
}

func init() {
	const (
		directoryUsage = "If omitted, the working directory will be the directory the program is running in."
		logUsage       = "Log to the file specified."
		solutionUsage  = "Specify the solution file to restore NuGet packages for."
		vpnUsage       = "Specify the VPN connection to connect. (required)"

		defaultDir     = ""
		defaultLogFile = ""
		defaultSln     = "CruiseControl.sln"
		defaultVPN     = ""
	)

	flag.StringVar(&workingDir, "directory", defaultDir, directoryUsage)
	flag.StringVar(&workingDir, "d", defaultDir, directoryUsage)

	flag.StringVar(&logFile, "log", defaultLogFile, logUsage)
	flag.StringVar(&logFile, "l", defaultLogFile, logUsage)

	flag.StringVar(&slnFile, "solution", defaultSln, solutionUsage)
	flag.StringVar(&slnFile, "s", defaultSln, solutionUsage)

	flag.StringVar(&vpn, "vpn", defaultVPN, vpnUsage)
	flag.StringVar(&vpn, "v", defaultVPN, vpnUsage)
}

func main() {
	flag.Parse()

	if logFile != "" {
		file, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0666)
		if err != nil {
			log.Fatal(err)
		}
		defer file.Close()
		log.SetOutput(file)
	}

	log.Println("=== Nuget Package Caching ===")

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

	if vpn == "" {
		log.Fatal("Error: must specify a VPN connection name")
	}

	log.Printf("Connecting to %q", vpn)

	if err := connVPN(vpn); err != nil {
		log.Fatal(err)
	}

	log.Printf("Working Directory: %q  Solution File: %q  Log File: %q\n", workingDir, slnFile, logFile)

	hgPull := newTask("hg", "pull")

	if err := hgPull.Run(); err != nil {
		log.Fatal(err)
	}

	hgUpdate := newTask("hg", "update")

	if err := hgUpdate.Run(); err != nil {
		log.Fatal(err)
	}

	ngRestore := newTask("nuget", "restore", slnFile)

	if err := ngRestore.Run(); err != nil {
		log.Fatal(err)
	}

}