├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── README.md
├── cmd
    └── hap
    │   ├── cli
    │       ├── build.go
    │       ├── c.go
    │       ├── commands.go
    │       ├── create.go
    │       ├── deploy.go
    │       ├── exec.go
    │       └── push.go
    │   ├── logger.go
    │   └── main.go
├── git.go
├── git_test.go
├── hapfile.go
├── hapfile_test.go
├── remote.go
├── remote_test.go
├── ssh.go
└── ssh_test.go


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | 
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 | 
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 | 
20 | _testmain.go
21 | 
22 | *.exe
23 | *.test
24 | *.prof
25 | 
26 | .DS_Store
27 | bin
28 | pkg
29 | 
30 | *.swp
31 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | Contributing
 2 | =======================
 3 | All attempts to improve this software are greatly appreciated.
 4 | 
 5 | Discussions
 6 | -----------
 7 | Open an issue.
 8 | 
 9 | Standards
10 | ---------
11 | Follow the rules of `gofmt`. A pre-commit hook is highly recommended.
12 | 
13 | Develop
14 | -------------
15 | 1. Fork.
16 | 2. Write tests.
17 | 3. Write code.
18 | 4. Submit Pull Requests.
19 | 5. Repeat 2-4
20 | 
21 | Disclaimer
22 | ----------
23 | All contributions are property of their respective authors and this project.


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2019 GWoo (https://github.com/gwoo)
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without modification,
 5 | are permitted provided that the following conditions are met:
 6 | 
 7 |     * Redistributions of source code must retain the above copyright notice,
 8 | 		this list of conditions and the following disclaimer.
 9 |     * Redistributions in binary form must reproduce the above copyright notice,
10 | 		this list of conditions and the following disclaimer in the documentation
11 | 		and/or other materials provided with the distribution.
12 |     * Neither the name of Lithium, Union of Rad, nor the names of its contributors
13 | 		may be used to endorse or promote products derived from this software
14 | 		without specific prior written permission.
15 | 
16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 | IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
20 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23 | OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
25 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | # Hap - the simple and effective provisioner
 2 | # Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | 
 4 | .PHONY: bin/hap bin/hap-linux-amd64 bin/hap-darwin-amd64 test
 5 | VERSION := $(shell git describe --always --dirty --tags)
 6 | VERSION_FLAGS := -ldflags "-X main.Version=$(VERSION)"
 7 | 
 8 | bin/hap: bin
 9 | 	go build -v $(VERSION_FLAGS) -o $@ ./cmd/hap
10 | 
11 | bin/hap-linux-amd64: bin
12 | 	GOOS=linux GOARCH=amd64 go build -v $(VERSION_FLAGS) -o $@ ./cmd/hap
13 | 
14 | bin/hap-darwin-amd64: bin
15 | 	GOOS=darwin GOARCH=amd64 go build -v $(VERSION_FLAGS) -o $@ ./cmd/hap
16 | 
17 | test:
18 | 	go test -v ./...
19 | 
20 | bin:
21 | 	mkdir bin


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Hap - A simple and effective provisioner.
  2 | 
  3 | Hap helps manage build scripts with git and run them concurrently on multiple remote hosts using composable blocks.
  4 | 
  5 | First, `hap create` to setup a new local repo. Then add hosts to the generated Hapfile. Once hosts are in place, run `hap build` to execute the build blocks and commands specified in the Hapfile for each host. After `hap build` a .happened file is saved with the current sha of remote repo. To run `hap build` again a new commit is required or use the `--force` param.
  6 | 
  7 | To run arbitrary commands use `hap c`, and to execute individual scripts with `hap exec`.
  8 | `hap c` will not push the latest or run from the current directory or use the environment files, those must be added as part of the command.
  9 | `hap exec` will push the latest, use the current directory and the environment.
 10 | 
 11 | If you only have one host, just use the `default` section. Then the `-h,--host` flag while running `hap` is not necessary.
 12 | 
 13 | Make sure every build script is executable before committing to the local repo.
 14 | 
 15 | ## Installation
 16 | 
 17 | #### via Go
 18 | 
 19 |     go get -u github.com/gwoo/hap/cmd/hap
 20 | 
 21 | #### Binaries
 22 | 
 23 | darwin/amd64
 24 | 
 25 |     curl -L -C - -o /usr/local/bin/hap https://github.com/gwoo/hap/releases/download/v2.6/hap-darwin-amd64; chmod a+x /usr/local/bin/hap
 26 | 
 27 | linux/amd64
 28 | 
 29 |     curl -L -C - -o /usr/local/bin/hap https://github.com/gwoo/hap/releases/download/v2.6/hap-linux-amd64; chmod a+x /usr/local/bin/hap
 30 | 
 31 | ## Basic Workflow
 32 | 
 33 | - Run `hap create <name>`
 34 | - Modify `Hapfile`
 35 | - Run `hap -h <host> build`
 36 | 
 37 | ## Environment Variables
 38 | 
 39 | Hap exports `HAP_HOSTNAME`, `HAP_USER`, `HAP_ADDR`, `HAP_IP`, `HAP_PORT` for use in scripts. You can add your own by using the `env` section or the `env` statement in the `host` section.
 40 | 
 41 | ## Hapfile
 42 | 
 43 | The Hapfile uses [git-config](http://git-scm.com/docs/git-config#_syntax) syntax. There are 5 sections, `default`, `host`, `build`, `include`, and `env`. The `default` section holds host config that will be applied to all hosts. The `host` section holds a named host config. A host config includes `addr`, `username`, `password`, `identity`, `build`, and `cmd`, `env`. Only `addr` is required. The `identity` should point to a local ssh private key that has access to the host via the authorized_keys. The `build` section holds mulitple cmds that could be applied to a host. Multiple `build`, `cmd`, or `env` are permitted for each host. In addition, an `include` section accepts multiple `path` statements and an `env` section accepts multiple `file` statements.
 44 | 
 45 | ### sections
 46 | 
 47 | - `host`: Holds the configuration for a machine
 48 |   - `addr`: the host:port of the remote machine
 49 |   - `dir`: base directory on the remote machine
 50 |   - `username`: the name of the user to login and run commands
 51 |   - `password`: password for ssh password based authentication
 52 |   - `identity`: path to ssh private key for key based authentication
 53 |   - `build`: one or more groups of commands to run
 54 |   - `cmd`: one or more commands to run on a specific host
 55 |   - `env`: one or more environment files to apply to this host (can override env sections)
 56 | - `deploy`: Holds the configuration for a deploy
 57 |   - `host`: one or more hosts
 58 |   - `build`: one or more groups of commands to run
 59 |   - `cmd`: one or more commands to run on a specific host
 60 |   - `env`: one or more environment files to apply to this host (can override env sections)
 61 | - `build`: sets of commands to run
 62 |   - `cmd`: one or more commands to run
 63 | - `default` : Holds the standard configurations that can be applied to all hosts
 64 |   - <same as host>
 65 | - `include`: Allows other files to be included in the current configuration
 66 |   - `path`: a path to the Hapfile the hap
 67 | - `env`: make variables available to the all commands
 68 |   - `file`: path to a file that can be sourced
 69 | 
 70 | ## Example Hapfile
 71 | 
 72 | A default build is specified, so init.sh and update.sh are executed for each host.
 73 | Host `one` specifies two commands, notify.sh and cleanup.sh, to be run after the default build commands. For host `one`, the `HAP_HOSTNAME` will be `one`, the `HAP_USER` will be `root`, and the `HAP_ADDR` will be `10.0.20.10:22`. Host `two` specifies no commands, so only the default build will be applied. For host `two`, the `HAP_HOSTNAME` will be `two`, the `HAP_USER` will be `admin`, and the `HAP_ADDR` will be `10.0.20.11:22`. There is also a `deploy` that will return the hostname for `one` and `two`.
 74 | 
 75 |     [default]
 76 |       username = "root"
 77 |       identity = "~/.ssh/id_rsa"
 78 |       build = "initialize" ; applied to all hosts
 79 | 
 80 |     [host "one"]
 81 |       addr = "10.0.20.10:22"
 82 |       cmd = "./notify.sh"
 83 |       cmd = "./cleanup.sh"
 84 | 
 85 |     [host "two"]
 86 |       username = "admin"
 87 |       identity = "~/.ssh/admin_rsa"
 88 |       addr = "10.0.20.11:22"
 89 | 
 90 |     [deploy "get-hostname"]
 91 |       host = one
 92 |       host = two
 93 |       cmd = hostname
 94 | 
 95 |     [build "initialize"]
 96 |       cmd = ./init.sh
 97 |       cmd = ./update.sh
 98 |       cmd = echo "initialized"
 99 | 
100 | ## Usage
101 | 
102 |     Usage of ./bin/hap:
103 |     --dry=false: Show commands without running them.
104 |     -f, --file="Hapfile": Location of a Hapfile.
105 |     --force=false: Force build even if it happened before.
106 |     --help=false: Show help
107 |     -h, --host="": Host to use for commands. Use glob patterns to match multiple hosts. Use --host=* for all hosts.
108 |     -v, --verbose=false: [deprecated] Verbose mode is always on
109 | 
110 |     Available Commands:
111 |     hap build	        Run the builds and commands from the Hapfile.
112 |     hap c <command>		Run an arbitrary command on the remote host.
113 |     hap create <name>	Create a new Hapfile at <name>.
114 |     hap deploy <name>	Run the named deploy defined in the Hapfile.
115 |     hap exec <script>	Execute a script on the remote host.
116 |     hap push		Push current repo to the remote.
117 | 
118 | ## Advanced Usage
119 | 
120 | Sometimes you want to `build` more than one host. If the hosts follow a similar pattern
121 | you can reference all the hosts with a `*`. For example, `app-01` and `app-02` are configured.
122 | Then you can build both with `hap -h app-* build` or `hap -h a* build`.
123 | 
124 | Sometimes you have a lot of hosts that you want to manage in clusters. If you create multiple files
125 | you can use the `--file` flag to specify the location of the config. The file can be named anything.
126 | For example, `hap -f Appfile -h app* push`, will push all the app hosts in the Appfile.
127 | 
128 | ## License
129 | 
130 | The BSD License http://opensource.org/licenses/bsd-license.php.
131 | 


--------------------------------------------------------------------------------
/cmd/hap/cli/build.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package cli
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 
10 | 	"github.com/gwoo/hap"
11 | 	flag "github.com/ogier/pflag"
12 | )
13 | 
14 | var force = flag.BoolP("force", "", false, "Force build even if it happened before.")
15 | var dry = flag.BoolP("dry", "", false, "Show commands without running them.")
16 | 
17 | // Add the build command
18 | func init() {
19 | 	Commands.Add("build", &BuildCmd{})
20 | }
21 | 
22 | // BuildCmd is the build command
23 | type BuildCmd struct{}
24 | 
25 | // IsRemote returns whether this command expects a remote
26 | func (cmd *BuildCmd) IsRemote() bool {
27 | 	return true
28 | }
29 | 
30 | // Help returns help for the build command
31 | func (cmd *BuildCmd) Help() string {
32 | 	return "hap build\tRun the builds and commands from the Hapfile."
33 | }
34 | 
35 | // Run the build command on the remote host
36 | func (cmd *BuildCmd) Run(remote *hap.Remote) (string, error) {
37 | 	if *dry {
38 | 		result := fmt.Sprintf(
39 | 			"[%s] --dry run.\n",
40 | 			remote.Host.Name,
41 | 		)
42 | 		cmds := []string{"cd " + remote.Dir}
43 | 		cmds = remote.Host.AddEnv(cmds)
44 | 		cmds = append(cmds, remote.Host.Cmds()...)
45 | 		for _, cmd := range cmds {
46 | 			result = result + fmt.Sprintf("[%s] %s\n", remote.Host.Name, cmd)
47 | 		}
48 | 		result = result + fmt.Sprintf("[%s] --dry run completed.\n", remote.Host.Name)
49 | 		return result, nil
50 | 	}
51 | 	if result, err := Commands.Get("push").Run(remote); err != nil {
52 | 		return result, err
53 | 	}
54 | 	if err := remote.Build(*force); err != nil {
55 | 		result := fmt.Sprintf("[%s] build failed.", remote.Host.Name)
56 | 		return result, err
57 | 	}
58 | 	result := fmt.Sprintf("[%s] build completed.", remote.Host.Name)
59 | 	return result, nil
60 | }
61 | 


--------------------------------------------------------------------------------
/cmd/hap/cli/c.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package cli
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"strings"
10 | 
11 | 	"github.com/gwoo/hap"
12 | 	flag "github.com/ogier/pflag"
13 | )
14 | 
15 | // Load all the available commands
16 | func init() {
17 | 	Commands.Add("c", &ArbitraryCmd{})
18 | }
19 | 
20 | // ArbitraryCmd is an arbitrary command
21 | type ArbitraryCmd struct {
22 | 	result []byte
23 | 	log    string
24 | }
25 | 
26 | // IsRemote returns whether this command expects a remote
27 | func (cmd *ArbitraryCmd) IsRemote() bool {
28 | 	return true
29 | }
30 | 
31 | // Help returns help on hap c <command>"
32 | func (cmd *ArbitraryCmd) Help() string {
33 | 	return "hap c <command>\tRun an arbitrary command on the remote host."
34 | }
35 | 
36 | // Run takes a remote and runs an arbitrary command on it
37 | func (cmd *ArbitraryCmd) Run(remote *hap.Remote) (string, error) {
38 | 	args := flag.Args()
39 | 	if len(args) <= 1 {
40 | 		return "", fmt.Errorf("error: expects <command>")
41 | 	}
42 | 	arbitrary := strings.Join(args[1:], " ")
43 | 	cmds := []string{arbitrary}
44 | 	if err := remote.Execute(cmds); err != nil {
45 | 		result := fmt.Sprintf("[%s] `%s` failed.", remote.Host.Name, arbitrary)
46 | 		return result, err
47 | 	}
48 | 	result := fmt.Sprintf("[%s] `%s` completed.", remote.Host.Name, arbitrary)
49 | 	return result, nil
50 | }
51 | 


--------------------------------------------------------------------------------
/cmd/hap/cli/commands.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package cli
 6 | 
 7 | import (
 8 | 	"github.com/gwoo/hap"
 9 | )
10 | 
11 | // List of registered commands
12 | var Commands = make(commands)
13 | 
14 | type commands map[string]Command
15 | 
16 | // Add takes a name and a command and adds it to the list
17 | func (c commands) Add(name string, cmd Command) {
18 | 	c[name] = cmd
19 | }
20 | 
21 | // Get takes a name and returns the associated command
22 | func (c commands) Get(name string) Command {
23 | 	if command, ok := Commands[name]; ok {
24 | 		return command
25 | 	}
26 | 	return nil
27 | }
28 | 
29 | // Command interface
30 | type Command interface {
31 | 	IsRemote() bool
32 | 	Help() string
33 | 	Run(*hap.Remote) (string, error)
34 | }
35 | 


--------------------------------------------------------------------------------
/cmd/hap/cli/create.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package cli
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"os"
10 | 	"os/exec"
11 | 	"os/user"
12 | 
13 | 	"github.com/gwoo/hap"
14 | 	flag "github.com/ogier/pflag"
15 | )
16 | 
17 | // Add the create command
18 | func init() {
19 | 	Commands.Add("create", &CreateCmd{})
20 | }
21 | 
22 | // CreateCmd inits the command for setting up remote repo
23 | type CreateCmd struct{}
24 | 
25 | // IsRemote returns whether the command expects a remote or not
26 | func (cmd *CreateCmd) IsRemote() bool {
27 | 	return false
28 | }
29 | 
30 | // Help returns the help on hap create <name>
31 | func (cmd *CreateCmd) Help() string {
32 | 	return "hap create <name>\tCreate a new Hapfile at <name>."
33 | }
34 | 
35 | // Run the command against the remote
36 | func (cmd *CreateCmd) Run(remote *hap.Remote) (string, error) {
37 | 	var err error
38 | 	args := flag.Args()
39 | 	if len(args) <= 1 {
40 | 		return "", fmt.Errorf("error: expects <name>")
41 | 	}
42 | 	work := flag.Arg(1)
43 | 	if err = os.MkdirAll(work, os.ModePerm|os.ModeDir); err != nil {
44 | 		result := fmt.Sprintf("create %s failed.", work)
45 | 		return result, err
46 | 	}
47 | 	c := exec.Command("git", "init", ".")
48 | 	c.Dir = work
49 | 	if result, err := c.CombinedOutput(); err != nil {
50 | 		result := fmt.Sprint(string(result))
51 | 		return result, err
52 | 	}
53 | 	file, err := os.OpenFile(work+"/Hapfile", os.O_CREATE|os.O_RDWR|os.O_APPEND, 0660)
54 | 	if err != nil {
55 | 		result := fmt.Sprintf("create %s failed.", work+"/Hapfile")
56 | 		return result, err
57 | 	}
58 | 	file.WriteString("[default]\n")
59 | 	if u, err := user.Current(); err == nil {
60 | 		file.WriteString(fmt.Sprintf("username = \"%s\"\n", u.Username))
61 | 	}
62 | 	if _, err = hap.NewKeyFile("~/.ssh/id_rsa"); err == nil {
63 | 		file.WriteString(fmt.Sprintf("identity = \"%s\"\n", "~/.ssh/id_rsa"))
64 | 	}
65 | 	if err != nil {
66 | 		result := fmt.Sprintf("create %s failed.", work)
67 | 		return result, err
68 | 	}
69 | 	result := fmt.Sprintf("create %s completed.", work)
70 | 	return result, nil
71 | }
72 | 


--------------------------------------------------------------------------------
/cmd/hap/cli/deploy.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package cli
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 
10 | 	"github.com/gwoo/hap"
11 | )
12 | 
13 | // Add the build command
14 | func init() {
15 | 	Commands.Add("deploy", &DeployCmd{})
16 | }
17 | 
18 | // DeployCmd is the build command
19 | type DeployCmd struct{}
20 | 
21 | // IsRemote returns whether this command expects a remote
22 | func (cmd *DeployCmd) IsRemote() bool {
23 | 	return true
24 | }
25 | 
26 | // Help returns help for the build command
27 | func (cmd *DeployCmd) Help() string {
28 | 	return "hap deploy <name>\tRun the named deploy defined in the Hapfile."
29 | }
30 | 
31 | // Run the build command on the remote host
32 | func (cmd *DeployCmd) Run(remote *hap.Remote) (string, error) {
33 | 	if *dry {
34 | 		result := fmt.Sprintf(
35 | 			"[%s] --dry run.\n",
36 | 			remote.Host.Name,
37 | 		)
38 | 		cmds := []string{"cd " + remote.Dir}
39 | 		cmds = remote.Host.AddEnv(cmds)
40 | 		cmds = append(cmds, remote.Host.Cmds()...)
41 | 		for _, cmd := range cmds {
42 | 			result = result + fmt.Sprintf("[%s] %s\n", remote.Host.Name, cmd)
43 | 		}
44 | 		result = result + fmt.Sprintf("[%s] --dry run completed.\n", remote.Host.Name)
45 | 		return result, nil
46 | 	}
47 | 	if result, err := Commands.Get("push").Run(remote); err != nil {
48 | 		return result, err
49 | 	}
50 | 	if err := remote.Build(true); err != nil {
51 | 		result := fmt.Sprintf("[%s] deploy failed.", remote.Host.Name)
52 | 		return result, err
53 | 	}
54 | 	result := fmt.Sprintf("[%s] deploy completed.", remote.Host.Name)
55 | 	return result, nil
56 | }
57 | 


--------------------------------------------------------------------------------
/cmd/hap/cli/exec.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package cli
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"strings"
10 | 
11 | 	"github.com/gwoo/hap"
12 | 	flag "github.com/ogier/pflag"
13 | )
14 | 
15 | // Add the exec command
16 | func init() {
17 | 	Commands.Add("exec", &ExecCmd{})
18 | }
19 | 
20 | // ExecCmd is the command
21 | type ExecCmd struct{}
22 | 
23 | // IsRemote returns whether the command expects a remote or not
24 | func (cmd *ExecCmd) IsRemote() bool {
25 | 	return true
26 | }
27 | 
28 | // Help returns help on hap exec <script>
29 | func (cmd *ExecCmd) Help() string {
30 | 	return "hap exec <script>\tExecute a script on the remote host."
31 | }
32 | 
33 | // Run takes a remote and executes a script from the repo on it
34 | func (cmd *ExecCmd) Run(remote *hap.Remote) (string, error) {
35 | 	args := flag.Args()
36 | 	if len(args) <= 1 {
37 | 		return "", fmt.Errorf("error: expects <script>")
38 | 	}
39 | 	if result, err := Commands.Get("push").Run(remote); err != nil {
40 | 		return result, err
41 | 	}
42 | 	ex := strings.Join(args[1:], " ")
43 | 	cmds := []string{"cd " + remote.Dir}
44 | 	cmds = remote.Host.AddEnv(cmds)
45 | 	cmds = append(cmds, ex)
46 | 	if err := remote.Execute(cmds); err != nil {
47 | 		result := fmt.Sprintf("[%s] `%s` failed.", remote.Host.Name, args[1])
48 | 		return result, err
49 | 	}
50 | 	result := fmt.Sprintf("[%s] `%s` completed.", remote.Host.Name, args[1])
51 | 	return result, nil
52 | }
53 | 


--------------------------------------------------------------------------------
/cmd/hap/cli/push.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package cli
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 
10 | 	"github.com/gwoo/hap"
11 | )
12 | 
13 | // Add the Push command
14 | func init() {
15 | 	Commands.Add("push", &PushCmd{})
16 | }
17 | 
18 | // PushCmd is the push command
19 | type PushCmd struct{}
20 | 
21 | // IsRemote returns whether the command expects a remote
22 | func (cmd *PushCmd) IsRemote() bool {
23 | 	return true
24 | }
25 | 
26 | // Help returns help on the hap push command
27 | func (cmd *PushCmd) Help() string {
28 | 	return "hap push\tPush current repo to the remote."
29 | }
30 | 
31 | // Run takes a remote and pushes to it
32 | func (cmd *PushCmd) Run(remote *hap.Remote) (string, error) {
33 | 	fmt.Printf("[%s] connecting to %s\n", remote.Host.Name, remote.Host.Addr)
34 | 	if err := remote.Push(); err != nil {
35 | 		result := fmt.Sprintf("[%s] push failed.", remote.Host.Name)
36 | 		return result, err
37 | 	}
38 | 	if err := remote.PushSubmodules(); err != nil {
39 | 		result := fmt.Sprintf("[%s] push failed.", remote.Host.Name)
40 | 		return result, err
41 | 	}
42 | 	result := fmt.Sprintf("[%s] push completed.", remote.Host.Name)
43 | 	return result, nil
44 | }
45 | 


--------------------------------------------------------------------------------
/cmd/hap/logger.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package main
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | )
10 | 
11 | // VerboseLogger sets verbose logging either on or off
12 | type VerboseLogger bool
13 | 
14 | // Print wraps fmt.Print
15 | func (vl VerboseLogger) Print(args ...interface{}) {
16 | 	if vl == true {
17 | 		fmt.Print(args...)
18 | 	}
19 | }
20 | 
21 | // Println wraps fmt.Println
22 | func (vl VerboseLogger) Println(args ...interface{}) {
23 | 	if vl == true {
24 | 		fmt.Println(args...)
25 | 	}
26 | }
27 | 
28 | // Printf wraps fmt.Printf
29 | func (vl VerboseLogger) Printf(format string, args ...interface{}) {
30 | 	if vl == true {
31 | 		fmt.Printf(format, args...)
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/cmd/hap/main.go:
--------------------------------------------------------------------------------
  1 | // Hap - the simple and effective provisioner
  2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
  3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
  4 | 
  5 | package main
  6 | 
  7 | import (
  8 | 	"fmt"
  9 | 	"os"
 10 | 	"sort"
 11 | 	"sync"
 12 | 	"text/tabwriter"
 13 | 
 14 | 	"github.com/gwoo/hap"
 15 | 	"github.com/gwoo/hap/cmd/hap/cli"
 16 | 	flag "github.com/ogier/pflag"
 17 | )
 18 | 
 19 | var host = flag.StringP("host", "h", "", "Host to use for commands. Use glob patterns to match multiple hosts. Use --host=* for all hosts.")
 20 | var hapfile = flag.StringP("file", "f", "Hapfile", "Location of a Hapfile.")
 21 | var help = flag.BoolP("help", "", false, "Show help")
 22 | var verbose = flag.BoolP("verbose", "v", false, "[deprecated] Verbose mode is always on")
 23 | 
 24 | var logger VerboseLogger
 25 | 
 26 | // Version is just the version of hap
 27 | var Version string
 28 | 
 29 | func main() {
 30 | 	flag.Usage = Usage
 31 | 	flag.Parse()
 32 | 
 33 | 	if err := new(hap.Git).Exists(); err != nil {
 34 | 		fmt.Println(err)
 35 | 		os.Exit(2)
 36 | 	}
 37 | 	var command cli.Command
 38 | 	if cmd := flag.Arg(0); cmd != "" {
 39 | 		command = cli.Commands.Get(cmd)
 40 | 		if command == nil {
 41 | 			fmt.Printf("Command `%s` not found.\n", cmd)
 42 | 		}
 43 | 	}
 44 | 	if len(os.Args) <= 1 || *help || command == nil {
 45 | 		flag.Usage()
 46 | 		return
 47 | 	}
 48 | 	if !command.IsRemote() {
 49 | 		run(nil, command)
 50 | 		return
 51 | 	}
 52 | 	hf, err := hap.NewHapfile(*hapfile)
 53 | 	if err != nil {
 54 | 		fmt.Println(err)
 55 | 		os.Exit(2)
 56 | 	}
 57 | 	var hosts = make(map[string]*hap.Host, 0)
 58 | 
 59 | 	if _, ok := command.(*cli.DeployCmd); ok {
 60 | 		deploy := flag.Arg(1)
 61 | 		if *host == "" {
 62 | 			*host = "*"
 63 | 		}
 64 | 		hosts, err = hf.GetDeployHosts(deploy, *host)
 65 | 		if err != nil {
 66 | 			fmt.Println(err)
 67 | 			return
 68 | 		}
 69 | 	} else if *host != "" {
 70 | 		hosts = hf.GetHosts(*host)
 71 | 	} else {
 72 | 		fmt.Println("Missing host please specify -h or --host=")
 73 | 		os.Exit(2)
 74 | 	}
 75 | 	if len(hosts) == 0 {
 76 | 		fmt.Println("No host found")
 77 | 		return
 78 | 	}
 79 | 	var wg sync.WaitGroup
 80 | 	for _, h := range hosts {
 81 | 		wg.Add(1)
 82 | 		go func(h *hap.Host) {
 83 | 			defer wg.Done()
 84 | 			run(h, command)
 85 | 		}(h)
 86 | 	}
 87 | 	wg.Wait()
 88 | }
 89 | 
 90 | func run(host *hap.Host, command cli.Command) {
 91 | 	var remote *hap.Remote
 92 | 	var err error
 93 | 	if host != nil {
 94 | 		remote, err = hap.NewRemote(host)
 95 | 		if err != nil {
 96 | 			fmt.Println(err)
 97 | 			return
 98 | 		}
 99 | 		defer remote.Close()
100 | 	}
101 | 	result, err := command.Run(remote)
102 | 	if err != nil {
103 | 		fmt.Println(err)
104 | 	}
105 | 	fmt.Println(result)
106 | }
107 | 
108 | // Usage prints out the hap CLI usage
109 | func Usage() {
110 | 	fmt.Printf("Version: %s\n", Version)
111 | 	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
112 | 	flag.PrintDefaults()
113 | 	fmt.Fprintln(os.Stderr, "\nAvailable Commands:")
114 | 	w := new(tabwriter.Writer)
115 | 	w.Init(os.Stderr, 0, 8, 0, '\t', 0)
116 | 	keys := []string{}
117 | 	for key := range cli.Commands {
118 | 		keys = append(keys, key)
119 | 	}
120 | 	sort.Strings(keys)
121 | 	for _, name := range keys {
122 | 		fmt.Fprintln(w, cli.Commands.Get(name).Help())
123 | 	}
124 | 	w.Flush()
125 | }
126 | 


--------------------------------------------------------------------------------
/git.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package hap
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"os"
10 | 	"os/exec"
11 | )
12 | 
13 | // Git struct
14 | type Git struct {
15 | 	Repo string
16 | 	Work string
17 | 	Key  string
18 | }
19 | 
20 | // Exists checks whether the git executable exists
21 | func (g Git) Exists() error {
22 | 	o, err := exec.LookPath("git")
23 | 	if err != nil {
24 | 		return fmt.Errorf("%s\n%s", o, err)
25 | 	}
26 | 	return nil
27 | }
28 | 
29 | // Commit adds all files, including untracked to the repo
30 | func (g Git) Commit(message string) ([]byte, error) {
31 | 	cmd := exec.Command("git", "add", ".")
32 | 	cmd.Dir = g.Work
33 | 	result, err := cmd.CombinedOutput()
34 | 	if err != nil {
35 | 		return result, err
36 | 	}
37 | 	cmd = exec.Command("git", "commit", "-q", "-m", message)
38 | 	cmd.Dir = g.Work
39 | 	return cmd.CombinedOutput()
40 | }
41 | 
42 | // Branch creates a new branch
43 | func (g Git) Branch(name string) ([]byte, error) {
44 | 	cmd := exec.Command("git", "branch", name)
45 | 	cmd.Dir = g.Work
46 | 	return cmd.CombinedOutput()
47 | }
48 | 
49 | // Checkout switches the branch
50 | func (g Git) Checkout(name string) ([]byte, error) {
51 | 	cmd := exec.Command("git", "checkout", name)
52 | 	cmd.Dir = g.Work
53 | 	return cmd.CombinedOutput()
54 | }
55 | 
56 | // Push forces push to the branch to the remote repo
57 | func (g Git) Push(branch string) ([]byte, error) {
58 | 	if branch == "" {
59 | 		branch = "master"
60 | 	}
61 | 	cmd := exec.Command("git", "push", "-f", g.Repo, branch)
62 | 	cmd.Dir = g.Work
63 | 	cmd.Env = os.Environ()
64 | 	return cmd.CombinedOutput()
65 | }
66 | 
67 | // RevParse returns current revision of HEAD
68 | func (g Git) RevParse() ([]byte, error) {
69 | 	cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
70 | 	cmd.Dir = g.Work
71 | 	return cmd.CombinedOutput()
72 | }
73 | 
74 | // UpdateSubmodules updates and initializes submodules
75 | func (g Git) UpdateSubmodules() ([]byte, error) {
76 | 	cmd := exec.Command("git", "submodule", "update", "--init")
77 | 	cmd.Dir = g.Work
78 | 	return cmd.CombinedOutput()
79 | }
80 | 
81 | // Add this hook to the remote repo
82 | const postReceiveHook string = `cat > ".git/hooks/post-receive" << "EOF"
83 | #!/bin/bash
84 | 
85 | test "${PWD%/.git}" != "$PWD" && cd ..
86 | unset GIT_DIR GIT_WORK_TREE
87 | read oldrev newrev ref
88 | branch=${ref#refs/heads/}
89 | git reset -q --hard
90 | git checkout -q ${branch}
91 | EOF`
92 | 


--------------------------------------------------------------------------------
/git_test.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package hap
 6 | 
 7 | import (
 8 | 	"io/ioutil"
 9 | 	"os"
10 | 	"os/exec"
11 | 	"testing"
12 | )
13 | 
14 | func TestGitExists(t *testing.T) {
15 | 	if err := new(Git).Exists(); err != nil {
16 | 		t.Error(err)
17 | 	}
18 | }
19 | 
20 | func TestGitPush(t *testing.T) {
21 | 	work := "/tmp/hap"
22 | 	repo := "/tmp/hap.git"
23 | 	os.RemoveAll(work)
24 | 	os.RemoveAll(repo)
25 | 	err := os.MkdirAll(work, os.ModePerm|os.ModeDir)
26 | 	if err != nil {
27 | 		t.Error(err)
28 | 		return
29 | 	}
30 | 	err = os.MkdirAll(repo, os.ModePerm|os.ModeDir)
31 | 	if err != nil {
32 | 		t.Error(err)
33 | 		return
34 | 	}
35 | 	cmd := exec.Command("git", "init", "--bare")
36 | 	cmd.Dir = repo
37 | 	result, err := cmd.CombinedOutput()
38 | 	if err != nil {
39 | 		t.Log(string(result))
40 | 		t.Error(err)
41 | 		return
42 | 	}
43 | 	cmd = exec.Command("git", "init", ".")
44 | 	cmd.Dir = work
45 | 	result, err = cmd.CombinedOutput()
46 | 	if err != nil {
47 | 		t.Log(string(result))
48 | 		t.Error(err)
49 | 		return
50 | 	}
51 | 	err = ioutil.WriteFile(work+"/test", []byte("testing"), 0777)
52 | 	if err != nil {
53 | 		t.Error(err)
54 | 		return
55 | 	}
56 | 	git := Git{Work: work, Repo: repo}
57 | 	if result, err := git.Commit("test commit"); err != nil {
58 | 		t.Log(string(result))
59 | 		t.Error(err)
60 | 	}
61 | 	if result, err := git.Push("master"); err != nil {
62 | 		t.Log(string(result))
63 | 		t.Error(err)
64 | 	}
65 | }
66 | 


--------------------------------------------------------------------------------
/hapfile.go:
--------------------------------------------------------------------------------
  1 | // Hap - the simple and effective provisioner
  2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
  3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
  4 | 
  5 | package hap
  6 | 
  7 | import (
  8 | 	"encoding/json"
  9 | 	"fmt"
 10 | 	"log"
 11 | 	"os"
 12 | 	"path"
 13 | 	"path/filepath"
 14 | 	"sort"
 15 | 
 16 | 	gcfg "gopkg.in/gcfg.v1"
 17 | )
 18 | 
 19 | // Hapfile defines the hosts, builds, and default
 20 | type Hapfile struct {
 21 | 	Default Default
 22 | 	Deploys map[string]*Deploy `gcfg:"deploy"`
 23 | 	deploys map[string]map[string]*Host
 24 | 	Hosts   map[string]*Host  `gcfg:"host"`
 25 | 	Builds  map[string]*Build `gcfg:"build"`
 26 | 	Include Include           `gcfg:"include"`
 27 | 	Env     Env               `gcfg:"env"`
 28 | }
 29 | 
 30 | // NewHapfile constructs a new hapfile config
 31 | func NewHapfile(file string) (Hapfile, error) {
 32 | 	hf, err := include(file)
 33 | 	if err != nil {
 34 | 		return hf, err
 35 | 	}
 36 | 	hf.deploys = map[string]map[string]*Host{}
 37 | 	for _, file := range hf.Include.Path {
 38 | 		nhf, err := include(file)
 39 | 		if err != nil {
 40 | 			return hf, err
 41 | 		}
 42 | 		for n, c := range nhf.Deploys {
 43 | 			if _, ok := hf.Deploys[n]; !ok {
 44 | 				hf.Deploys[n] = c
 45 | 			}
 46 | 		}
 47 | 		for n, h := range nhf.Hosts {
 48 | 			if _, ok := hf.Hosts[n]; !ok {
 49 | 				hf.Hosts[n] = h
 50 | 			}
 51 | 		}
 52 | 		for n, b := range nhf.Builds {
 53 | 			if _, ok := hf.Builds[n]; !ok {
 54 | 				hf.Builds[n] = b
 55 | 			}
 56 | 		}
 57 | 		for d, deploy := range nhf.Deploys {
 58 | 			hf.deploys[d] = map[string]*Host{}
 59 | 			for _, n := range deploy.Host {
 60 | 				if _, ok := hf.Hosts[n]; ok {
 61 | 					hf.deploys[d][n] = hf.newDeployHost(hf.Hosts[n], deploy)
 62 | 				}
 63 | 			}
 64 | 		}
 65 | 		for _, file := range nhf.Env.File {
 66 | 			hf.Env.File = append(hf.Env.File, file)
 67 | 		}
 68 | 	}
 69 | 	for _, host := range hf.Hosts {
 70 | 		for _, file := range hf.Env.File {
 71 | 			host.Env = append(host.Env, file)
 72 | 		}
 73 | 		for i, j := 0, len(host.Env)-1; i < j; i, j = i+1, j-1 {
 74 | 			host.Env[i], host.Env[j] = host.Env[j], host.Env[i]
 75 | 		}
 76 | 	}
 77 | 	for d, deploy := range hf.Deploys {
 78 | 		hf.deploys[d] = map[string]*Host{}
 79 | 		for _, n := range deploy.Host {
 80 | 			if _, ok := hf.Hosts[n]; ok {
 81 | 				hf.deploys[d][n] = hf.newDeployHost(hf.Hosts[n], deploy)
 82 | 			}
 83 | 		}
 84 | 	}
 85 | 	return hf, err
 86 | }
 87 | 
 88 | func include(file string) (Hapfile, error) {
 89 | 	var hf Hapfile
 90 | 	err := gcfg.ReadFileInto(&hf, file)
 91 | 	if hf.Deploys == nil {
 92 | 		hf.Deploys = make(map[string]*Deploy, 0)
 93 | 	}
 94 | 	if hf.Hosts == nil {
 95 | 		hf.Hosts = make(map[string]*Host, 0)
 96 | 	}
 97 | 	if hf.Builds == nil {
 98 | 		hf.Builds = make(map[string]*Build, 0)
 99 | 	}
100 | 	return hf, err
101 | }
102 | 
103 | func (hf Hapfile) newDeployHost(host *Host, d *Deploy) *Host {
104 | 	h := &Host{}
105 | 	h.Name = host.Name
106 | 	h.Addr = host.Addr
107 | 	h.Dir = host.Dir
108 | 	h.Username = host.Username
109 | 	h.Identity = host.Identity
110 | 	h.Password = host.Password
111 | 	h.Env = append(host.Env, d.Env...)
112 | 	h.Build = d.Build
113 | 	h.Cmd = d.Cmd
114 | 	return h
115 | }
116 | 
117 | // GetDeployHosts finds a list of hosts matching name string
118 | func (hf Hapfile) GetDeployHosts(deploy, host string) (map[string]*Host, error) {
119 | 	hosts, ok := hf.deploys[deploy]
120 | 	if !ok {
121 | 		return map[string]*Host{}, fmt.Errorf("deploy '%s' not found", deploy)
122 | 	}
123 | 	keys := []string{}
124 | 	for key := range hosts {
125 | 		if matched, _ := filepath.Match(host, key); matched == true {
126 | 			keys = append(keys, key)
127 | 		}
128 | 	}
129 | 	sort.Strings(keys)
130 | 	results := make(map[string]*Host)
131 | 	for _, key := range keys {
132 | 		results[key] = hf.DeployHost(deploy, key)
133 | 	}
134 | 	return results, nil
135 | }
136 | 
137 | // DeployHost takes a name and returns the host
138 | // If the name is empty and default addr exists return default.
139 | // If no default is set it returns a random host.
140 | func (hf Hapfile) DeployHost(deploy, host string) *Host {
141 | 	if h, ok := hf.deploys[deploy][host]; ok {
142 | 		h.Name = host
143 | 		h.SetDefaults(hf.Default)
144 | 		h.BuildCmds(hf.Builds)
145 | 		return h
146 | 	}
147 | 	if hf.Default.Addr != "" {
148 | 		h := Host(hf.Default)
149 | 		h.Name = "default"
150 | 		h.BuildCmds(hf.Builds)
151 | 		return &h
152 | 	}
153 | 	return nil
154 | }
155 | 
156 | // GetHosts finds a list of hosts matching name string
157 | func (hf Hapfile) GetHosts(name string) map[string]*Host {
158 | 	hosts := hf.Hosts
159 | 	keys := []string{}
160 | 	for key := range hosts {
161 | 		if matched, _ := filepath.Match(name, key); matched == true {
162 | 			keys = append(keys, key)
163 | 		}
164 | 	}
165 | 	sort.Strings(keys)
166 | 	results := make(map[string]*Host)
167 | 	for _, key := range keys {
168 | 		results[key] = hf.Host(key)
169 | 	}
170 | 	return results
171 | }
172 | 
173 | // Host takes a name and returns the host
174 | // If the name is empty and default addr exists return default.
175 | // If no default is set it returns a random host.
176 | func (hf Hapfile) Host(name string) *Host {
177 | 	if host, ok := hf.Hosts[name]; ok {
178 | 		host.Name = name
179 | 		host.SetDefaults(hf.Default)
180 | 		host.BuildCmds(hf.Builds)
181 | 		return host
182 | 	}
183 | 	if hf.Default.Addr != "" {
184 | 		host := Host(hf.Default)
185 | 		host.Name = "default"
186 | 		host.BuildCmds(hf.Builds)
187 | 		return &host
188 | 	}
189 | 	return nil
190 | }
191 | 
192 | // String returns the hapfile config as json
193 | func (hf Hapfile) String() string {
194 | 	b, err := json.Marshal(hf)
195 | 	if err != nil {
196 | 		return ""
197 | 	}
198 | 	return string(b)
199 | }
200 | 
201 | // Deploy describes a group of remote machine
202 | type Deploy struct {
203 | 	Host  []string
204 | 	Build []string
205 | 	Cmd   []string
206 | 	Env   []string
207 | }
208 | 
209 | // Default holds the default settings
210 | type Default Host
211 | 
212 | // Host describes a remote machine
213 | type Host struct {
214 | 	Name     string
215 | 	Dir      string
216 | 	Addr     string
217 | 	Username string
218 | 	Identity string
219 | 	Password string
220 | 	Env      []string
221 | 	Build    []string
222 | 	Cmd      []string
223 | 	cmds     []string
224 | }
225 | 
226 | // SetDefaults fills in missing host specific configs with defaults
227 | func (h *Host) SetDefaults(d Default) {
228 | 	if h.Addr == "" {
229 | 		h.Addr = d.Addr
230 | 	}
231 | 	if h.Dir == "" {
232 | 		h.Dir = d.Dir
233 | 	}
234 | 	if h.Username == "" {
235 | 		h.Username = d.Username
236 | 	}
237 | 	if h.Identity == "" {
238 | 		h.Identity = d.Identity
239 | 	}
240 | 	if h.Password == "" {
241 | 		h.Password = d.Password
242 | 	}
243 | 	if len(h.Build) < 1 {
244 | 		h.Build = d.Build
245 | 	}
246 | 	if len(h.Cmd) < 1 {
247 | 		h.Cmd = d.Cmd
248 | 	}
249 | }
250 | 
251 | // GetDir returns the current working directory
252 | func (h *Host) GetDir() string {
253 | 	if h.Dir != "" {
254 | 		return h.Dir
255 | 	}
256 | 	cwd, err := os.Getwd()
257 | 	if err != nil {
258 | 		log.Println(err)
259 | 	}
260 | 	return path.Base(cwd)
261 | }
262 | 
263 | // BuildCmds combines the builds and cmds
264 | func (h *Host) BuildCmds(builds map[string]*Build) {
265 | 	h.cmds = []string{}
266 | 	for _, build := range h.Build {
267 | 		if b, ok := builds[build]; ok {
268 | 			h.cmds = append(h.cmds, b.Cmd...)
269 | 		}
270 | 	}
271 | 	h.cmds = append(h.cmds, h.Cmd...)
272 | }
273 | 
274 | // Cmds returns the cmds to build
275 | func (h *Host) Cmds() []string {
276 | 	return h.cmds
277 | }
278 | 
279 | // AddEnv includes env files in cmds
280 | func (h *Host) AddEnv(cmds []string) []string {
281 | 	for _, file := range h.Env {
282 | 		cmds = append(cmds, fmt.Sprint(". ./", file))
283 | 	}
284 | 	return cmds
285 | }
286 | 
287 | // Build holds the cmds
288 | type Build struct {
289 | 	Cmd []string
290 | }
291 | 
292 | // Include holds the files to include
293 | type Include struct {
294 | 	Path []string
295 | }
296 | 
297 | // Env holds the files to source when running commands
298 | type Env struct {
299 | 	File []string
300 | }
301 | 


--------------------------------------------------------------------------------
/hapfile_test.go:
--------------------------------------------------------------------------------
  1 | // Hap - the simple and effective provisioner
  2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
  3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
  4 | 
  5 | package hap
  6 | 
  7 | import (
  8 | 	"io/ioutil"
  9 | 	"os"
 10 | 	"reflect"
 11 | 	"testing"
 12 | 
 13 | 	gcfg "gopkg.in/gcfg.v1"
 14 | )
 15 | 
 16 | func TestGetHostsString(t *testing.T) {
 17 | 	hf := &Hapfile{Hosts: map[string]*Host{"local": &Host{Addr: "127.0.0.1"}}}
 18 | 	results := hf.GetHosts("local")
 19 | 	if len(results) > 0 && results["local"].Addr == "127.0.0.1" {
 20 | 		return
 21 | 	}
 22 | 	t.Error("host could not be found")
 23 | }
 24 | 
 25 | func TestGetHostsRegex(t *testing.T) {
 26 | 	hf := &Hapfile{Hosts: map[string]*Host{"local": &Host{Addr: "127.0.0.1"}}}
 27 | 	results := hf.GetHosts("lo*")
 28 | 	if len(results) > 0 && results["local"].Addr == "127.0.0.1" {
 29 | 		return
 30 | 	}
 31 | 	t.Error("host could not be found")
 32 | }
 33 | 
 34 | func TestGetHostsAll(t *testing.T) {
 35 | 	hf := &Hapfile{Hosts: map[string]*Host{"local": &Host{Addr: "127.0.0.1"}}}
 36 | 	results := hf.GetHosts("*")
 37 | 	if len(results) > 0 && results["local"].Addr == "127.0.0.1" {
 38 | 		return
 39 | 	}
 40 | 	t.Error("host could not be found")
 41 | }
 42 | 
 43 | func TestGcfgInclude(t *testing.T) {
 44 | 	cfgStr := `; Comment line
 45 | [include]
 46 | path = path/to/file.cfg`
 47 | 	var cfg Hapfile
 48 | 	err := gcfg.ReadStringInto(&cfg, cfgStr)
 49 | 	if err != nil {
 50 | 		t.Fatalf("Failed to parse gcfg data: %s", err)
 51 | 	}
 52 | 	if cfg.Include.Path[0] != "path/to/file.cfg" {
 53 | 		t.Fatalf("Unexpected result: %s", cfg.Include.Path[0])
 54 | 	}
 55 | }
 56 | 
 57 | func TestDefaultHapfile(t *testing.T) {
 58 | 	cfgStr := `; Comment line
 59 | [default]
 60 | username = bob
 61 | password = password
 62 | identity = ~/.ssh/id_rsa`
 63 | 	err := ioutil.WriteFile("TestHapfile", []byte(cfgStr), 0666)
 64 | 	if err != nil {
 65 | 		t.Error(err)
 66 | 	}
 67 | 	hf, err := NewHapfile("TestHapfile")
 68 | 	if err != nil {
 69 | 		t.Error(err)
 70 | 	}
 71 | 	ws := hf.Default.Username
 72 | 	gs := "bob"
 73 | 	if ws != gs {
 74 | 		t.Error("Want:", ws, "Got:", gs)
 75 | 	}
 76 | 	ws = hf.Default.Identity
 77 | 	gs = "~/.ssh/id_rsa"
 78 | 	if ws != gs {
 79 | 		t.Error("Want:", ws, "Got:", gs)
 80 | 	}
 81 | 	err = os.Remove("TestHapfile")
 82 | 	if err != nil {
 83 | 		t.Error(err)
 84 | 	}
 85 | }
 86 | 
 87 | func TestNewHapfileWithInclude(t *testing.T) {
 88 | 	cfgStr := `
 89 | [env]
 90 | file = environment
 91 | 
 92 | [host "primary"]
 93 | addr = "10.0.0.1:22"
 94 | build = "init"
 95 | build = "test"
 96 | env = primary_environment
 97 | 
 98 | [include]
 99 | path = TestAnotherHapfile
100 | 
101 | [build "init"]
102 | cmd = "echo init"`
103 | 
104 | 	err := ioutil.WriteFile("TestHapfile", []byte(cfgStr), 0666)
105 | 	if err != nil {
106 | 		t.Error(err)
107 | 	}
108 | 	cfgStr = `
109 | [env]
110 | file = another_environment
111 | 
112 | [host "secondary"]
113 | addr = "10.0.0.2:22"
114 | build = "init"
115 | build = "test"
116 | env = secondary_environment
117 | 
118 | [build "test"]
119 | cmd = "echo test"`
120 | 	err = ioutil.WriteFile("TestAnotherHapfile", []byte(cfgStr), 0666)
121 | 	if err != nil {
122 | 		t.Error(err)
123 | 	}
124 | 
125 | 	hf, err := NewHapfile("TestHapfile")
126 | 	if err != nil {
127 | 		t.Error(err)
128 | 	}
129 | 	hosts := hf.GetHosts("*")
130 | 	if len(hosts) < 2 {
131 | 		t.Error("Expected at least two hosts")
132 | 	}
133 | 
134 | 	p := hf.Host("primary")
135 | 	w1 := "10.0.0.1:22"
136 | 	g1 := p.Addr
137 | 	if w1 != g1 {
138 | 		t.Error("Want:", w1, "Got:", g1)
139 | 	}
140 | 	w2 := []string{"init", "test"}
141 | 	g2 := p.Build
142 | 	if !reflect.DeepEqual(w2, g2) {
143 | 		t.Error("Want:", w2, "Got:", g2)
144 | 	}
145 | 	w3 := []string{"another_environment", "environment", "primary_environment"}
146 | 	g3 := p.Env
147 | 	if !reflect.DeepEqual(w3, g3) {
148 | 		t.Error("Want:", w3, "Got:", g3)
149 | 	}
150 | 
151 | 	s := hf.Host("secondary")
152 | 	w1 = "10.0.0.2:22"
153 | 	g1 = s.Addr
154 | 	if w1 != g1 {
155 | 		t.Error("Want:", w1, "Got:", g1)
156 | 	}
157 | 	w2 = []string{"init", "test"}
158 | 	g2 = s.Build
159 | 	if !reflect.DeepEqual(w2, g2) {
160 | 		t.Error("Want:", w2, "Got:", g2)
161 | 	}
162 | 
163 | 	w3 = []string{"another_environment", "environment", "secondary_environment"}
164 | 	g3 = s.Env
165 | 	if !reflect.DeepEqual(w3, g3) {
166 | 		t.Error("Want:", w3, "Got:", g3)
167 | 	}
168 | 
169 | 	err = os.Remove("TestHapfile")
170 | 	if err != nil {
171 | 		t.Error(err)
172 | 	}
173 | 	err = os.Remove("TestAnotherHapfile")
174 | 	if err != nil {
175 | 		t.Error(err)
176 | 	}
177 | }
178 | 
179 | func TestNewHapfileWithIncludeBuild(t *testing.T) {
180 | 	cfgStr := `
181 | [env]
182 | file = environment
183 | 
184 | [host "primary"]
185 | addr = "10.0.0.1:22"
186 | build = "init"
187 | build = "test"
188 | env = primary_environment
189 | 
190 | [include]
191 | path = TestAnotherHapfile`
192 | 
193 | 	err := ioutil.WriteFile("TestHapfile", []byte(cfgStr), 0666)
194 | 	if err != nil {
195 | 		t.Error(err)
196 | 	}
197 | 	cfgStr = `
198 | [env]
199 | file = another_environment
200 | 
201 | [host "secondary"]
202 | addr = "10.0.0.2:22"
203 | build = "init"
204 | build = "test"
205 | env = secondary_environment
206 | 
207 | [build "test"]
208 | cmd = "echo test"
209 | 
210 | [build "init"]
211 | cmd = "echo init"`
212 | 	err = ioutil.WriteFile("TestAnotherHapfile", []byte(cfgStr), 0666)
213 | 	if err != nil {
214 | 		t.Error(err)
215 | 	}
216 | 
217 | 	hf, err := NewHapfile("TestHapfile")
218 | 	if err != nil {
219 | 		t.Error(err)
220 | 	}
221 | 	hosts := hf.GetHosts("*")
222 | 	if len(hosts) < 2 {
223 | 		t.Error("Expected at least two hosts")
224 | 	}
225 | 
226 | 	p := hf.Host("primary")
227 | 	w1 := "10.0.0.1:22"
228 | 	g1 := p.Addr
229 | 	if w1 != g1 {
230 | 		t.Error("Want:", w1, "Got:", g1)
231 | 	}
232 | 	w2 := []string{"init", "test"}
233 | 	g2 := p.Build
234 | 	if !reflect.DeepEqual(w2, g2) {
235 | 		t.Error("Want:", w2, "Got:", g2)
236 | 	}
237 | 	w3 := []string{"another_environment", "environment", "primary_environment"}
238 | 	g3 := p.Env
239 | 	if !reflect.DeepEqual(w3, g3) {
240 | 		t.Error("Want:", w3, "Got:", g3)
241 | 	}
242 | 
243 | 	s := hf.Host("secondary")
244 | 	w1 = "10.0.0.2:22"
245 | 	g1 = s.Addr
246 | 	if w1 != g1 {
247 | 		t.Error("Want:", w1, "Got:", g1)
248 | 	}
249 | 	w2 = []string{"init", "test"}
250 | 	g2 = s.Build
251 | 	if !reflect.DeepEqual(w2, g2) {
252 | 		t.Error("Want:", w2, "Got:", g2)
253 | 	}
254 | 
255 | 	w3 = []string{"another_environment", "environment", "secondary_environment"}
256 | 	g3 = s.Env
257 | 	if !reflect.DeepEqual(w3, g3) {
258 | 		t.Error("Want:", w3, "Got:", g3)
259 | 	}
260 | 
261 | 	err = os.Remove("TestHapfile")
262 | 	if err != nil {
263 | 		t.Error(err)
264 | 	}
265 | 	err = os.Remove("TestAnotherHapfile")
266 | 	if err != nil {
267 | 		t.Error(err)
268 | 	}
269 | }
270 | 
271 | func TestCustomWorkingDir(t *testing.T) {
272 | 	cfgStr := `; Comment line
273 | [default]
274 | dir = hap-working-directory
275 | 
276 | [host "one"]
277 | addr = 10.0.0.1:22`
278 | 	err := ioutil.WriteFile("TestHapfile", []byte(cfgStr), 0666)
279 | 	if err != nil {
280 | 		t.Error(err)
281 | 	}
282 | 	hf, err := NewHapfile("TestHapfile")
283 | 	if err != nil {
284 | 		t.Error(err)
285 | 	}
286 | 	host := hf.Host("one")
287 | 	ws := host.GetDir()
288 | 	gs := "hap-working-directory"
289 | 	if ws != gs {
290 | 		t.Error("Want:", ws, "Got:", gs)
291 | 	}
292 | 	err = os.Remove("TestHapfile")
293 | 	if err != nil {
294 | 		t.Error(err)
295 | 	}
296 | }
297 | 
298 | func TestNewHapfileWithDeploy(t *testing.T) {
299 | 	cfgStr := `
300 | [host "one"]
301 | addr = "10.0.0.1:22"
302 | 
303 | [host "two"]
304 | addr = "10.0.0.2:22"
305 | 
306 | [env]
307 | file = environment
308 | 
309 | [deploy "together"]
310 | host = one
311 | host = two
312 | build = init
313 | build = test
314 | cmd = echo
315 | env = another_environment
316 | 
317 | [build "test"]
318 | cmd = "echo test"
319 | 
320 | [build "init"]
321 | cmd = "echo init"`
322 | 	err := ioutil.WriteFile("TestHapfile", []byte(cfgStr), 0666)
323 | 	if err != nil {
324 | 		t.Error(err)
325 | 	}
326 | 
327 | 	hf, err := NewHapfile("TestHapfile")
328 | 	if err != nil {
329 | 		t.Error(err)
330 | 	}
331 | 	hosts, err := hf.GetDeployHosts("together", "*")
332 | 	if err != nil {
333 | 		t.Error(err)
334 | 	}
335 | 	if len(hosts) < 2 {
336 | 		t.Error("Expected at least two hosts")
337 | 	}
338 | 
339 | 	p := hf.DeployHost("together", "one")
340 | 	w1 := "10.0.0.1:22"
341 | 	g1 := p.Addr
342 | 	if w1 != g1 {
343 | 		t.Error("Want:", w1, "Got:", g1)
344 | 	}
345 | 	w2 := []string{"init", "test"}
346 | 	g2 := p.Build
347 | 	if !reflect.DeepEqual(w2, g2) {
348 | 		t.Error("Want:", w2, "Got:", g2)
349 | 	}
350 | 	w21 := []string{"echo"}
351 | 	g21 := p.Cmd
352 | 	if !reflect.DeepEqual(w21, g21) {
353 | 		t.Error("Want:", w21, "Got:", g21)
354 | 	}
355 | 	w3 := []string{"environment", "another_environment"}
356 | 	g3 := p.Env
357 | 	if !reflect.DeepEqual(w3, g3) {
358 | 		t.Error("Want:", w3, "Got:", g3)
359 | 	}
360 | 	w4 := []string{"echo init", "echo test", "echo"}
361 | 	g4 := p.Cmds()
362 | 	if !reflect.DeepEqual(w4, g4) {
363 | 		t.Error("Want:", w21, "Got:", g21)
364 | 	}
365 | 	s := hf.DeployHost("together", "two")
366 | 	w1 = "10.0.0.2:22"
367 | 	g1 = s.Addr
368 | 	if w1 != g1 {
369 | 		t.Error("Want:", w1, "Got:", g1)
370 | 	}
371 | 	w2 = []string{"init", "test"}
372 | 	g2 = s.Build
373 | 	if !reflect.DeepEqual(w2, g2) {
374 | 		t.Error("Want:", w2, "Got:", g2)
375 | 	}
376 | 	w21 = []string{"echo"}
377 | 	g21 = p.Cmd
378 | 	if !reflect.DeepEqual(w21, g21) {
379 | 		t.Error("Want:", w21, "Got:", g21)
380 | 	}
381 | 	w3 = []string{"environment", "another_environment"}
382 | 	g3 = s.Env
383 | 	if !reflect.DeepEqual(w3, g3) {
384 | 		t.Error("Want:", w3, "Got:", g3)
385 | 	}
386 | 
387 | 	err = os.Remove("TestHapfile")
388 | 	if err != nil {
389 | 		t.Error(err)
390 | 	}
391 | }
392 | 
393 | func TestNewHapfileWithDeployAndHost(t *testing.T) {
394 | 	cfgStr := `
395 | [host "one"]
396 | addr = "10.0.0.1:22"
397 | build = test
398 | 
399 | [host "two"]
400 | addr = "10.0.0.2:22"
401 | 
402 | [env]
403 | file = environment
404 | 
405 | [deploy "together"]
406 | host = one
407 | host = two
408 | build = init
409 | build = test
410 | cmd = echo
411 | env = another_environment
412 | 
413 | [build "test"]
414 | cmd = "echo test"
415 | 
416 | [build "init"]
417 | cmd = "echo init"`
418 | 	err := ioutil.WriteFile("TestHapfile", []byte(cfgStr), 0666)
419 | 	if err != nil {
420 | 		t.Error(err)
421 | 	}
422 | 
423 | 	hf, err := NewHapfile("TestHapfile")
424 | 	if err != nil {
425 | 		t.Error(err)
426 | 	}
427 | 	hosts := hf.GetHosts("*")
428 | 	if len(hosts) < 2 {
429 | 		t.Error("Expected at least two hosts")
430 | 	}
431 | 	dhosts, err := hf.GetDeployHosts("together", "*")
432 | 	if err != nil {
433 | 		t.Error(err)
434 | 	}
435 | 	if len(dhosts) < 2 {
436 | 		t.Error("Expected at least two hosts")
437 | 	}
438 | 
439 | 	p := hf.DeployHost("together", "one")
440 | 	w1 := "10.0.0.1:22"
441 | 	g1 := p.Addr
442 | 	if w1 != g1 {
443 | 		t.Error("Want:", w1, "Got:", g1)
444 | 	}
445 | 	w2 := []string{"init", "test"}
446 | 	g2 := p.Build
447 | 	if !reflect.DeepEqual(w2, g2) {
448 | 		t.Error("Want:", w2, "Got:", g2)
449 | 	}
450 | 	w21 := []string{"echo"}
451 | 	g21 := p.Cmd
452 | 	if !reflect.DeepEqual(w21, g21) {
453 | 		t.Error("Want:", w21, "Got:", g21)
454 | 	}
455 | 	w3 := []string{"environment", "another_environment"}
456 | 	g3 := p.Env
457 | 	if !reflect.DeepEqual(w3, g3) {
458 | 		t.Error("Want:", w3, "Got:", g3)
459 | 	}
460 | 	w4 := []string{"echo init", "echo test", "echo"}
461 | 	g4 := p.Cmds()
462 | 	if !reflect.DeepEqual(w4, g4) {
463 | 		t.Error("Want:", w21, "Got:", g21)
464 | 	}
465 | 	s := hf.DeployHost("together", "two")
466 | 	w1 = "10.0.0.2:22"
467 | 	g1 = s.Addr
468 | 	if w1 != g1 {
469 | 		t.Error("Want:", w1, "Got:", g1)
470 | 	}
471 | 	w2 = []string{"init", "test"}
472 | 	g2 = s.Build
473 | 	if !reflect.DeepEqual(w2, g2) {
474 | 		t.Error("Want:", w2, "Got:", g2)
475 | 	}
476 | 	w21 = []string{"echo"}
477 | 	g21 = p.Cmd
478 | 	if !reflect.DeepEqual(w21, g21) {
479 | 		t.Error("Want:", w21, "Got:", g21)
480 | 	}
481 | 	w3 = []string{"environment", "another_environment"}
482 | 	g3 = s.Env
483 | 	if !reflect.DeepEqual(w3, g3) {
484 | 		t.Error("Want:", w3, "Got:", g3)
485 | 	}
486 | 
487 | 	// This host should have fewer commands
488 | 	p = hf.Host("one")
489 | 	w1 = "10.0.0.1:22"
490 | 	g1 = p.Addr
491 | 	if w1 != g1 {
492 | 		t.Error("Want:", w1, "Got:", g1)
493 | 	}
494 | 	w2 = []string{"test"}
495 | 	g2 = p.Build
496 | 	if !reflect.DeepEqual(w2, g2) {
497 | 		t.Error("Want:", w2, "Got:", g2)
498 | 	}
499 | 	var w22 []string
500 | 	g22 := p.Cmd
501 | 	if !reflect.DeepEqual(w22, g22) {
502 | 		t.Error("Want:", w22, "Got:", g22)
503 | 	}
504 | 	w3 = []string{"environment"}
505 | 	g3 = p.Env
506 | 	if !reflect.DeepEqual(w3, g3) {
507 | 		t.Error("Want:", w3, "Got:", g3)
508 | 	}
509 | 	w4 = []string{"echo test"}
510 | 	g4 = p.Cmds()
511 | 	if !reflect.DeepEqual(w4, g4) {
512 | 		t.Error("Want:", w21, "Got:", g21)
513 | 	}
514 | 
515 | 	s = hf.Host("two")
516 | 	w1 = "10.0.0.2:22"
517 | 	g1 = s.Addr
518 | 	if w1 != g1 {
519 | 		t.Error("Want:", w1, "Got:", g1)
520 | 	}
521 | 	g22 = s.Build
522 | 	if !reflect.DeepEqual(w22, g22) {
523 | 		t.Error("Want:", w22, "Got:", g22)
524 | 	}
525 | 	g22 = p.Cmd
526 | 	if !reflect.DeepEqual(w22, g22) {
527 | 		t.Error("Want:", w22, "Got:", g22)
528 | 	}
529 | 	w3 = []string{"environment"}
530 | 	g3 = s.Env
531 | 	if !reflect.DeepEqual(w3, g3) {
532 | 		t.Error("Want:", w3, "Got:", g3)
533 | 	}
534 | 
535 | 	err = os.Remove("TestHapfile")
536 | 	if err != nil {
537 | 		t.Error(err)
538 | 	}
539 | }
540 | 
541 | func TestNewHapfileWithIncludeHosts(t *testing.T) {
542 | 	cfgStr := `
543 | [env]
544 | file = another_environment
545 | 
546 | [host "one"]
547 | addr = "10.0.0.1:22"
548 | 
549 | [host "two"]
550 | addr = "10.0.0.2:22"
551 | 
552 | `
553 | 
554 | 	err := ioutil.WriteFile("TestHostsfile", []byte(cfgStr), 0666)
555 | 	if err != nil {
556 | 		t.Error(err)
557 | 	}
558 | 	cfgStr = `
559 | [env]
560 | file = environment
561 | 
562 | [include]
563 | path = TestHostsfile
564 | 
565 | [deploy "together"]
566 | host = one
567 | host = two
568 | build = init
569 | build = test
570 | cmd = echo
571 | 
572 | [build "test"]
573 | cmd = "echo test"
574 | 
575 | [build "init"]
576 | cmd = "echo init"`
577 | 	err = ioutil.WriteFile("TestHapfile", []byte(cfgStr), 0666)
578 | 	if err != nil {
579 | 		t.Error(err)
580 | 	}
581 | 
582 | 	hf, err := NewHapfile("TestHapfile")
583 | 	if err != nil {
584 | 		t.Error(err)
585 | 	}
586 | 	hosts := hf.GetHosts("*")
587 | 	if len(hosts) < 2 {
588 | 		t.Error("Expected at least two hosts")
589 | 	}
590 | 
591 | 	p := hf.DeployHost("together", "one")
592 | 	w1 := "10.0.0.1:22"
593 | 	g1 := p.Addr
594 | 	if w1 != g1 {
595 | 		t.Error("Want:", w1, "Got:", g1)
596 | 	}
597 | 	w2 := []string{"init", "test"}
598 | 	g2 := p.Build
599 | 	if !reflect.DeepEqual(w2, g2) {
600 | 		t.Error("Want:", w2, "Got:", g2)
601 | 	}
602 | 	w21 := []string{"echo"}
603 | 	g21 := p.Cmd
604 | 	if !reflect.DeepEqual(w21, g21) {
605 | 		t.Error("Want:", w21, "Got:", g21)
606 | 	}
607 | 	w3 := []string{"another_environment", "environment"}
608 | 	g3 := p.Env
609 | 	if !reflect.DeepEqual(w3, g3) {
610 | 		t.Error("Want:", w3, "Got:", g3)
611 | 	}
612 | 	w4 := []string{"echo init", "echo test", "echo"}
613 | 	g4 := p.Cmds()
614 | 	if !reflect.DeepEqual(w4, g4) {
615 | 		t.Error("Want:", w21, "Got:", g21)
616 | 	}
617 | 	s := hf.DeployHost("together", "two")
618 | 	w1 = "10.0.0.2:22"
619 | 	g1 = s.Addr
620 | 	if w1 != g1 {
621 | 		t.Error("Want:", w1, "Got:", g1)
622 | 	}
623 | 	w2 = []string{"init", "test"}
624 | 	g2 = s.Build
625 | 	if !reflect.DeepEqual(w2, g2) {
626 | 		t.Error("Want:", w2, "Got:", g2)
627 | 	}
628 | 	w21 = []string{"echo"}
629 | 	g21 = p.Cmd
630 | 	if !reflect.DeepEqual(w21, g21) {
631 | 		t.Error("Want:", w21, "Got:", g21)
632 | 	}
633 | 	w3 = []string{"another_environment", "environment"}
634 | 	g3 = s.Env
635 | 	if !reflect.DeepEqual(w3, g3) {
636 | 		t.Error("Want:", w3, "Got:", g3)
637 | 	}
638 | 
639 | 	err = os.Remove("TestHostsfile")
640 | 	if err != nil {
641 | 		t.Error(err)
642 | 	}
643 | 	err = os.Remove("TestHapfile")
644 | 	if err != nil {
645 | 		t.Error(err)
646 | 	}
647 | }
648 | 


--------------------------------------------------------------------------------
/remote.go:
--------------------------------------------------------------------------------
  1 | // Hap - the simple and effective provisioner
  2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
  3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
  4 | 
  5 | package hap
  6 | 
  7 | import (
  8 | 	"bufio"
  9 | 	"bytes"
 10 | 	"fmt"
 11 | 	"io"
 12 | 	"io/ioutil"
 13 | 	"net"
 14 | 	"os"
 15 | 	"path/filepath"
 16 | 	"strings"
 17 | 	"sync"
 18 | 
 19 | 	"golang.org/x/crypto/ssh"
 20 | 	gcfg "gopkg.in/gcfg.v1"
 21 | )
 22 | 
 23 | // Formatted script that checks if the build happened.
 24 | const happened string = "if [ \"$(git rev-parse HEAD)\" = \"$(cat .happended)\" ]; then echo \"Already completed. Commit again?\"; exit 2; fi"
 25 | 
 26 | // Remote defines the remote machine to provision
 27 | type Remote struct {
 28 | 	Git        Git
 29 | 	Dir        string
 30 | 	Host       *Host
 31 | 	env        []string
 32 | 	gitSSHFile string
 33 | 	sshConfig  SSHConfig
 34 | 	session    *ssh.Session
 35 | 	writer     io.Writer
 36 | }
 37 | 
 38 | // NewRemote constructs a new remote machine
 39 | func NewRemote(host *Host) (*Remote, error) {
 40 | 	sshConfig := NewSSHConfig(host)
 41 | 	clientConfig, err := NewClientConfig(sshConfig)
 42 | 	if err != nil {
 43 | 		return nil, err
 44 | 	}
 45 | 	sshConfig.ClientConfig = clientConfig
 46 | 	dir := host.GetDir()
 47 | 	repo := fmt.Sprintf("ssh://%s@%s/~/%s", host.Username, host.Addr, dir)
 48 | 	r := &Remote{
 49 | 		sshConfig:  sshConfig,
 50 | 		Git:        Git{Repo: repo, Key: sshConfig.Identity},
 51 | 		Dir:        dir,
 52 | 		Host:       host,
 53 | 		gitSSHFile: filepath.Join(os.TempDir(), "hap-ssh-"+host.Name),
 54 | 	}
 55 | 	var b = "#!/bin/sh\n\nssh "
 56 | 	if r.sshConfig.Identity != "" {
 57 | 		b = b + " -i " + r.sshConfig.Identity
 58 | 	}
 59 | 	b = b + " -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o VerifyHostKeyDNS=no -o CheckHostIP=no $@"
 60 | 	err = ioutil.WriteFile(r.gitSSHFile, []byte(b), 0777)
 61 | 	if err != nil {
 62 | 		return r, fmt.Errorf("error writing git_ssh file: %s, error: %s", r.gitSSHFile, err)
 63 | 	}
 64 | 	return r, nil
 65 | }
 66 | 
 67 | // Connect starts an ssh session to a remote machine
 68 | func (r *Remote) Connect() error {
 69 | 	if r.session != nil {
 70 | 		return nil
 71 | 	}
 72 | 	var client *ssh.Client
 73 | 	var err error
 74 | 	for range r.sshConfig.ClientConfig.Auth {
 75 | 		client, err = ssh.Dial("tcp", r.sshConfig.Addr, r.sshConfig.ClientConfig)
 76 | 		if err != nil {
 77 | 			if len(r.sshConfig.ClientConfig.Auth) == 1 {
 78 | 				return fmt.Errorf("Failed to connect with username=%s identity=%s password=%s",
 79 | 					r.sshConfig.Username, r.sshConfig.Identity, r.sshConfig.Password)
 80 | 			}
 81 | 			r.sshConfig.ClientConfig.Auth = r.sshConfig.ClientConfig.Auth[1:]
 82 | 		}
 83 | 	}
 84 | 	if client == nil {
 85 | 		return fmt.Errorf("Failed to connect to %s", r.Host.Addr)
 86 | 	}
 87 | 	session, err := client.NewSession()
 88 | 	if err != nil {
 89 | 		return fmt.Errorf("Failed to create session: %s", err)
 90 | 	}
 91 | 	r.session = session
 92 | 	return nil
 93 | }
 94 | 
 95 | // Close ends an ssh session with a remote machine
 96 | func (r *Remote) Close() error {
 97 | 	if r.session != nil {
 98 | 		err := r.session.Close()
 99 | 		r.session = nil
100 | 		return err
101 | 	}
102 | 	return nil
103 | }
104 | 
105 | // Initialize sets up a git repo on the remote machine
106 | func (r *Remote) Initialize() error {
107 | 	if err := r.Connect(); err != nil {
108 | 		return err
109 | 	}
110 | 	commands := []string{
111 | 		fmt.Sprintf("GIT_DIR=\"%s\"", r.Dir),
112 | 		fmt.Sprint("mkdir -p $GIT_DIR"),
113 | 		fmt.Sprint("cd $GIT_DIR"),
114 | 		fmt.Sprint("git init -q"),
115 | 		fmt.Sprint("git config receive.denyCurrentBranch ignore"),
116 | 		fmt.Sprint("touch .git/hooks/post-receive"),
117 | 		fmt.Sprint("chmod a+x .git/hooks/post-receive"),
118 | 		fmt.Sprint(postReceiveHook),
119 | 	}
120 | 	return r.Execute(commands)
121 | }
122 | 
123 | // Push updates the repo on the remote machine
124 | func (r *Remote) Push() error {
125 | 	if err := r.Connect(); err != nil {
126 | 		return err
127 | 	}
128 | 	b, err := r.Git.RevParse()
129 | 	if err != nil {
130 | 		return fmt.Errorf("%s\n%s", string(b), err)
131 | 	}
132 | 	branch := strings.TrimSpace(string(b))
133 | 	if branch == "HEAD" {
134 | 		branch = fmt.Sprintf("%s:refs/heads/happened", branch)
135 | 	}
136 | 	if err := r.Initialize(); err != nil {
137 | 		return fmt.Errorf("%s", err)
138 | 	}
139 | 	os.Setenv("GIT_SSH", r.gitSSHFile)
140 | 	if output, err := r.Git.Push(branch); err != nil {
141 | 		return fmt.Errorf("%s\n%s", string(output), err)
142 | 	}
143 | 	return nil
144 | }
145 | 
146 | // PushSubmodules runs Push() to put submodules
147 | // into the proper location on the remote machine
148 | func (r *Remote) PushSubmodules() error {
149 | 	var modules struct {
150 | 		Submodules map[string]*submodule `gcfg:"submodule"`
151 | 	}
152 | 	if err := gcfg.ReadFileInto(&modules, ".gitmodules"); err != nil {
153 | 		return nil
154 | 	}
155 | 	if output, err := r.Git.UpdateSubmodules(); err != nil {
156 | 		return fmt.Errorf("%s\n%s", string(output), err)
157 | 	}
158 | 	var wg sync.WaitGroup
159 | 	errors := []string{}
160 | 	for _, module := range modules.Submodules {
161 | 		wg.Add(1)
162 | 		go func(module *submodule) {
163 | 			defer wg.Done()
164 | 			sr := &Remote{
165 | 				gitSSHFile: r.gitSSHFile,
166 | 				sshConfig:  r.sshConfig,
167 | 				Dir:        filepath.Join(r.Dir, module.Path),
168 | 				Host:       r.Host,
169 | 				Git: Git{
170 | 					Repo: fmt.Sprint(r.Git.Repo, "/", module.Path),
171 | 					Work: module.Path,
172 | 				},
173 | 			}
174 | 			if err := sr.Push(); err != nil {
175 | 				errors = append(errors, fmt.Sprintf("[%s] %s", module.Path, err))
176 | 			}
177 | 		}(module)
178 | 	}
179 | 	wg.Wait()
180 | 	if len(errors) > 0 {
181 | 		return fmt.Errorf("%s", strings.Join(errors, "\n"))
182 | 	}
183 | 	return nil
184 | }
185 | 
186 | // Build executes the builds and cmds
187 | // First execute builds specified in Hapfile
188 | // Then execute any cmds specified in Hapfile
189 | func (r *Remote) Build(force bool) error {
190 | 	cmds := []string{"cd " + r.Dir, "HAP_DIR=`pwd`", "touch .happended"}
191 | 	if !force {
192 | 		cmds = append(cmds, happened)
193 | 	}
194 | 	cmds = r.Host.AddEnv(cmds)
195 | 	cmds = append(cmds, r.Host.Cmds()...)
196 | 	cmds = append(cmds, "cd $HAP_DIR; echo `git rev-parse HEAD` > .happended")
197 | 	return r.Execute(cmds)
198 | }
199 | 
200 | // Execute will shell out to run one or more commands
201 | func (r *Remote) Execute(commands []string) error {
202 | 	if err := r.Connect(); err != nil {
203 | 		return err
204 | 	}
205 | 	defer r.Close()
206 | 	r.session.Stdout = NewRemoteWriter(r.Host.Name, os.Stdout)
207 | 	r.session.Stderr = NewRemoteWriter(r.Host.Name, os.Stderr)
208 | 	cmd := fmt.Sprint(r.Env(), commands[0])
209 | 	if len(commands) > 1 {
210 | 		cmd = fmt.Sprintf("sh -c '%s%s'", r.Env(), strings.Join(commands, "&&"))
211 | 	}
212 | 	if err := r.session.Run(cmd); err != nil {
213 | 		return fmt.Errorf("[%s] %s", r.Host.Name, err)
214 | 	}
215 | 	return nil
216 | }
217 | 
218 | // Env returns the preset environment variables to pass to execute
219 | func (r *Remote) Env() string {
220 | 	host, port, _ := net.SplitHostPort(r.Host.Addr)
221 | 	return fmt.Sprint(
222 | 		"export HAP_HOSTNAME=\"", r.Host.Name, "\";",
223 | 		"export HAP_ADDR=\"", r.Host.Addr, "\";",
224 | 		"export HAP_USER=\"", r.Host.Username, "\";",
225 | 		"export HAP_IP=\"", host, "\";",
226 | 		"export HAP_PORT=\"", port, "\";",
227 | 	)
228 | }
229 | 
230 | // NewRemoteWriter returns a Writer with [host] prepended to the output
231 | func NewRemoteWriter(host string, w io.Writer) io.Writer {
232 | 	return &RemoteWriter{host: host, w: w}
233 | }
234 | 
235 | // RemoteWriter is a Writer with host and io.Writer
236 | type RemoteWriter struct {
237 | 	host string
238 | 	w    io.Writer
239 | }
240 | 
241 | // Write implements the io.Writer interface
242 | func (hw *RemoteWriter) Write(p []byte) (int, error) {
243 | 	var err error
244 | 	l := len(p)
245 | 	scanner := bufio.NewScanner(bytes.NewReader(p))
246 | 	for scanner.Scan() {
247 | 		_, err = fmt.Fprintf(hw.w, "[%s] %s\n", hw.host, scanner.Bytes())
248 | 	}
249 | 	if err != nil {
250 | 		return l, err
251 | 	}
252 | 	if err := scanner.Err(); err != nil {
253 | 		return l, err
254 | 	}
255 | 	return l, nil
256 | }
257 | 
258 | type submodule struct {
259 | 	Path string
260 | 	URL  string
261 | }
262 | 


--------------------------------------------------------------------------------
/remote_test.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package hap
 6 | 
 7 | import (
 8 | 	"testing"
 9 | )
10 | 
11 | func TestRemoteConnect(t *testing.T) {
12 | 
13 | }
14 | 
15 | func TestRemoteInitialize(t *testing.T) {
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/ssh.go:
--------------------------------------------------------------------------------
  1 | // Hap - the simple and effective provisioner
  2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
  3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
  4 | 
  5 | package hap
  6 | 
  7 | import (
  8 | 	"io/ioutil"
  9 | 	"log"
 10 | 	"net"
 11 | 	"os"
 12 | 	"os/user"
 13 | 	"path/filepath"
 14 | 	"strings"
 15 | 
 16 | 	"golang.org/x/crypto/ssh"
 17 | 	"golang.org/x/crypto/ssh/agent"
 18 | )
 19 | 
 20 | // SSHConfig holds the config for ssh connections
 21 | type SSHConfig struct {
 22 | 	Addr         string
 23 | 	Username     string
 24 | 	Identity     string
 25 | 	Password     string
 26 | 	ClientConfig *ssh.ClientConfig
 27 | }
 28 | 
 29 | // NewSSHConfig converts a Host into the SSHConfig
 30 | func NewSSHConfig(host *Host) SSHConfig {
 31 | 	if host.Username == "" {
 32 | 		u, _ := user.Current()
 33 | 		host.Username = u.Name
 34 | 	}
 35 | 	if strings.HasPrefix(host.Identity, ".") {
 36 | 		dir, _ := os.Getwd()
 37 | 		host.Identity = dir + host.Identity[1:]
 38 | 	}
 39 | 	config := SSHConfig{
 40 | 		Addr:     host.Addr,
 41 | 		Username: host.Username,
 42 | 		Identity: host.Identity,
 43 | 		Password: host.Password,
 44 | 	}
 45 | 	return config
 46 | }
 47 | 
 48 | // NewClientConfig constructs a new *ssh.ClientConfig
 49 | func NewClientConfig(config SSHConfig) (*ssh.ClientConfig, error) {
 50 | 	methods := make([]ssh.AuthMethod, 0)
 51 | 	if sock, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK")); err == nil {
 52 | 		method := ssh.PublicKeysCallback(agent.NewClient(sock).Signers)
 53 | 		methods = append(methods, method)
 54 | 	}
 55 | 	if config.Identity != "" {
 56 | 		method, err := NewPublicKeyMethod(config.Identity)
 57 | 		if err == nil {
 58 | 			methods = append(methods, method)
 59 | 		} else {
 60 | 			log.Println("[identity]", err)
 61 | 		}
 62 | 	} else {
 63 | 		home := os.Getenv("HOME")
 64 | 		keys := []string{home + "/.ssh/id_rsa", home + "/.ssh/id_dsa"}
 65 | 		for _, key := range keys {
 66 | 			if method, err := NewPublicKeyMethod(key); err == nil {
 67 | 				methods = append(methods, method)
 68 | 			}
 69 | 		}
 70 | 	}
 71 | 	if config.Password != "" {
 72 | 		methods = append(methods, ssh.Password(config.Password))
 73 | 	}
 74 | 	cfg := &ssh.ClientConfig{
 75 | 		Auth:            methods,
 76 | 		User:            config.Username,
 77 | 		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
 78 | 	}
 79 | 	cfg.SetDefaults()
 80 | 	return cfg, nil
 81 | }
 82 | 
 83 | // NewKeyFile takes a key and returns the key file
 84 | func NewKeyFile(key string) (string, error) {
 85 | 	if string(key[0]) == "~" {
 86 | 		var homeDir string
 87 | 		u, err := user.Current()
 88 | 		if err != nil {
 89 | 			homeDir = os.Getenv("HOME")
 90 | 		} else {
 91 | 			homeDir = u.HomeDir
 92 | 		}
 93 | 		key = strings.Replace(key, "~", homeDir, 1)
 94 | 	}
 95 | 	return filepath.EvalSymlinks(key)
 96 | }
 97 | 
 98 | // NewKey parses and returns the interface for the key type (rsa, dss, etc)
 99 | func NewKey(key string) (ssh.Signer, error) {
100 | 	file, err := NewKeyFile(key)
101 | 	if err != nil {
102 | 		return nil, err
103 | 	}
104 | 	b, err := ioutil.ReadFile(file)
105 | 	if err != nil {
106 | 		return nil, err
107 | 	}
108 | 	return ssh.ParsePrivateKey(b)
109 | }
110 | 
111 | // NewPublicKeyMethod creates a new auth method for public keys
112 | func NewPublicKeyMethod(key string) (ssh.AuthMethod, error) {
113 | 	pk, err := NewKey(key)
114 | 	if err != nil {
115 | 		return nil, err
116 | 	}
117 | 	return ssh.PublicKeys(pk), nil
118 | }
119 | 


--------------------------------------------------------------------------------
/ssh_test.go:
--------------------------------------------------------------------------------
 1 | // Hap - the simple and effective provisioner
 2 | // Copyright (c) 2019 GWoo (https://github.com/gwoo)
 3 | // The BSD License http://opensource.org/licenses/bsd-license.php.
 4 | 
 5 | package hap
 6 | 
 7 | import (
 8 | 	"testing"
 9 | )
10 | 
11 | func TestNewClientConfig(t *testing.T) {
12 | 	sshConfig := SSHConfig{
13 | 		Addr:     "10.0.0.1:22",
14 | 		Username: "bob",
15 | 		Identity: "~/.ssh/id_rsa",
16 | 		Password: "password",
17 | 	}
18 | 	clientConfig, err := NewClientConfig(sshConfig)
19 | 	if err != nil {
20 | 		t.Error(err)
21 | 	}
22 | 	if len(clientConfig.Auth) != 3 {
23 | 		t.Error("There should be 3 auth methods")
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------