func journalAction(c *cli.Context) {
if len(c.Args()) != 1 {
fmt.Println("One unit file must be provided.")
syscall.Exit(1)
}
jobName := c.Args()[0]
js := registryCtl.GetJobState(jobName)
if js == nil {
fmt.Printf("%s does not appear to be running\n", jobName)
syscall.Exit(1)
}
cmd := fmt.Sprintf("journalctl -u %s --no-pager -l -n %d", jobName, c.Int("lines"))
if c.Bool("follow") {
cmd += " -f"
}
// check if the job is running on this machine
var channel *ssh.Channel
var err error
if machine.IsLocalMachineState(js.MachineState) {
channel = runLocalCommand(cmd)
} else {
channel, err = runRemoteCommand(cmd, js.MachineState.PublicIP)
if err != nil {
log.Fatalf("Unable to run command over SSH: %v", err)
}
}
readSSHChannel(channel)
}
func journalAction(c *cli.Context) {
if len(c.Args()) != 1 {
fmt.Println("One unit file must be provided.")
syscall.Exit(1)
}
jobName := c.Args()[0]
js := registryCtl.GetJobState(jobName)
if js == nil {
fmt.Printf("%s does not appear to be running\n", jobName)
syscall.Exit(1)
}
addr := fmt.Sprintf("%s:22", js.MachineState.PublicIP)
var err error
var sshClient *gossh.ClientConn
if tun := getTunnelFlag(); tun != "" {
sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr)
} else {
sshClient, err = ssh.NewSSHClient("core", addr)
}
if err != nil {
log.Fatal(err.Error())
}
defer sshClient.Close()
cmd := fmt.Sprintf("journalctl -u %s --no-pager -l -n %d", jobName, c.Int("lines"))
if c.Bool("follow") {
cmd += " -f"
}
stdout, err := ssh.Execute(sshClient, cmd)
if err != nil {
log.Fatalf("Unable to run command over SSH: %s", err.Error())
}
for true {
bytes, prefix, err := stdout.ReadLine()
if err != nil {
break
}
fmt.Print(string(bytes))
if !prefix {
fmt.Print("\n")
}
}
}
func startUnitAction(c *cli.Context) {
var err error
// If signing is explicitly set to on, verification will be done also.
toSign := c.Bool("sign")
var sc *sign.SignatureCreator
var sv *sign.SignatureVerifier
if toSign {
var err error
sc, err = sign.NewSignatureCreatorFromSSHAgent()
if err != nil {
fmt.Println("Fail to create SignatureCreator:", err)
return
}
sv, err = sign.NewSignatureVerifierFromSSHAgent()
if err != nil {
fmt.Println("Fail to create SignatureVerifier:", err)
return
}
}
payloads := make([]job.JobPayload, len(c.Args()))
for i, v := range c.Args() {
name := path.Base(v)
payload := registryCtl.GetPayload(name)
if payload == nil {
payload, err = getJobPayloadFromFile(v)
if err != nil {
fmt.Println(err.Error())
return
}
err = registryCtl.CreatePayload(payload)
if err != nil {
fmt.Printf("Creation of payload %s failed: %v\n", payload.Name, err)
return
}
if toSign {
s, err := sc.SignPayload(payload)
if err != nil {
fmt.Printf("Creation of sign for payload %s failed: %v\n", payload.Name, err)
return
}
registryCtl.CreateSignatureSet(s)
}
}
if toSign {
s := registryCtl.GetSignatureSetOfPayload(name)
ok, err := sv.VerifyPayload(payload, s)
if !ok || err != nil {
fmt.Printf("Check of payload %s failed: %v\n", payload.Name, err)
return
}
}
payloads[i] = *payload
}
requirements := parseRequirements(c.String("require"))
// TODO: This must be done in a transaction!
registeredJobs := make(map[string]bool)
for _, jp := range payloads {
j := job.NewJob(jp.Name, requirements, &jp, nil)
err := registryCtl.CreateJob(j)
if err != nil {
fmt.Printf("Creation of job %s failed: %v\n", j.Name, err)
continue
}
registeredJobs[j.Name] = true
}
if !c.Bool("no-block") {
waitForScheduledUnits(registeredJobs, c.Int("block-attempts"), os.Stdout)
}
}
