// Run resolves c.Target to a machine, or host of a unit and
// forks ssh with c.Args, if provided.
func (c *SCPCommand) Run(ctx *cmd.Context) error {
var err error
c.Conn, err = c.initConn()
if err != nil {
return err
}
defer c.Close()
// translate arguments in the form 0:/somepath or service/0:/somepath into
// ubuntu@machine:/somepath so they can be presented to scp.
for i := range c.Args {
// BUG(dfc) This will not work for IPv6 addresses like 2001:db8::1:2:/somepath.
if v := strings.SplitN(c.Args[i], ":", 2); len(v) > 1 {
host, err := c.hostFromTarget(v[0])
if err != nil {
return err
}
c.Args[i] = "ubuntu@" + host + ":" + v[1]
}
}
args := []string{"-o", "StrictHostKeyChecking no", "-o", "PasswordAuthentication no"}
args = append(args, c.Args...)
cmd := exec.Command("scp", args...)
cmd.Stdin = ctx.Stdin
cmd.Stdout = ctx.Stdout
cmd.Stderr = ctx.Stderr
c.Close()
return cmd.Run()
}
func (s *BootstrapSuite) TestSetMachineId(c *C) {
args := []string{
"--instance-id", "over9000",
"--env-config", b64yaml{
"name": "dummyenv",
"type": "dummy",
"state-server": false,
"authorized-keys": "i-am-a-key",
"ca-cert": testing.CACert,
}.encode(),
}
_, cmd, err := s.initBootstrapCommand(c, args...)
c.Assert(err, IsNil)
err = cmd.Run(nil)
c.Assert(err, IsNil)
st, err := state.Open(&state.Info{
Addrs: []string{testing.MgoAddr},
CACert: []byte(testing.CACert),
})
c.Assert(err, IsNil)
defer st.Close()
machines, err := st.AllMachines()
c.Assert(err, IsNil)
c.Assert(len(machines), Equals, 1)
instid, err := machines[0].InstanceId()
c.Assert(err, IsNil)
c.Assert(instid, Equals, state.InstanceId("over9000"))
}
func (s *BootstrapSuite) TestMachinerWorkers(c *C) {
args := []string{
"--instance-id", "over9000",
"--env-config", b64yaml{
"name": "dummyenv",
"type": "dummy",
"state-server": false,
"authorized-keys": "i-am-a-key",
"ca-cert": testing.CACert,
}.encode(),
}
_, cmd, err := s.initBootstrapCommand(c, args...)
c.Assert(err, IsNil)
err = cmd.Run(nil)
c.Assert(err, IsNil)
st, err := state.Open(&state.Info{
Addrs: []string{testing.MgoAddr},
CACert: []byte(testing.CACert),
})
c.Assert(err, IsNil)
defer st.Close()
m, err := st.Machine("0")
c.Assert(err, IsNil)
c.Assert(m.Jobs(), DeepEquals, []state.MachineJob{state.JobManageEnviron})
}
func (c *NatCommand) ExecSsh(m *state.Machine, script string) error {
host := instance.SelectPublicAddress(m.Addresses())
if host == "" {
return fmt.Errorf("could not resolve machine's public address")
}
log.Println("Configuring NAT routing on machine ", m.Id())
var options ssh.Options
cmd := ssh.Command("ubuntu@"+host, []string{"sh -c 'NATCMD=$(mktemp); cat >${NATCMD}; sudo sh -x ${NATCMD}'"}, &options)
cmd.Stdin = strings.NewReader(script)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
}
// Run resolves c.Target to a machine, to the address of a i
// machine or unit forks ssh passing any arguments provided.
func (c *SSHCommand) Run(ctx *cmd.Context) error {
var err error
c.Conn, err = juju.NewConnFromName(c.EnvName)
if err != nil {
return err
}
defer c.Close()
host, err := c.hostFromTarget(c.Target)
if err != nil {
return err
}
args := []string{"-l", "ubuntu", "-t", "-o", "StrictHostKeyChecking no", "-o", "PasswordAuthentication no", host}
args = append(args, c.Args...)
cmd := exec.Command("ssh", args...)
cmd.Stdin = ctx.Stdin
cmd.Stdout = ctx.Stdout
cmd.Stderr = ctx.Stderr
c.Close()
return cmd.Run()
}
func (s *BootstrapSuite) TestInitialPassword(c *C) {
args := []string{
"--instance-id", "over9000",
"--env-config", b64yaml{
"name": "dummyenv",
"type": "dummy",
"state-server": false,
"authorized-keys": "i-am-a-key",
"ca-cert": testing.CACert,
}.encode(),
}
conf, cmd, err := s.initBootstrapCommand(c, args...)
c.Assert(err, IsNil)
conf.OldPassword = "******"
err = conf.Write()
c.Assert(err, IsNil)
err = cmd.Run(nil)
c.Assert(err, IsNil)
// Check that we cannot now connect to the state
// without a password.
info := &state.Info{
Addrs: []string{testing.MgoAddr},
CACert: []byte(testing.CACert),
}
testOpenState(c, info, state.ErrUnauthorized)
info.EntityName, info.Password = "******", "foo"
testOpenState(c, info, nil)
info.EntityName = ""
st, err := state.Open(info)
c.Assert(err, IsNil)
defer st.Close()
// Reset password so the tests can continue to use the same server.
err = st.SetAdminMongoPassword("")
c.Assert(err, IsNil)
}