func batchHandler(w http.ResponseWriter, r *http.Request) {
sched, err := jobs.New()
if error500(w, err) {
return
}
s, err := services.Services("flynn-lorne", services.DefaultTimeout)
if error500(w, err) {
return
}
hostid := s[0].Attrs["id"]
jobid := jobs.RandomJobID("batch")
host, err := hosts.New(hostid)
if error500(w, err) {
return
}
conn, attachWait, err := host.Attach(&lorne.AttachReq{
JobID: jobid,
Flags: lorne.AttachFlagStdout | lorne.AttachFlagStderr | lorne.AttachFlagStdin | lorne.AttachFlagStream,
}, true)
if error500(w, err) {
return
}
config := docker.Config{
Image: strings.TrimPrefix(r.URL.Path, "/batch/"),
Cmd: strings.Split(r.URL.RawQuery, "+"),
Tty: false,
AttachStdin: false,
AttachStdout: false,
AttachStderr: false,
OpenStdin: false,
StdinOnce: false,
}
schedReq := &sampi.ScheduleReq{
Incremental: true,
HostJobs: map[string][]*sampi.Job{
hostid: {{ID: jobid, Config: &config}}},
}
_, err = sched.Schedule(schedReq)
if error500(w, err) {
return
}
err = attachWait()
if error500(w, err) {
return
}
fw := FlushWriter(w)
scanner := bufio.NewScanner(conn)
for scanner.Scan() {
fmt.Fprintln(fw, scanner.Text())
}
conn.Close()
fw.Write([]byte("\n"))
}
func init() {
var err error
sched, err = sc.New()
if err != nil {
log.Fatal(err)
}
hostid = findHost()
host, err = lc.New(hostid)
if err != nil {
log.Fatal(err)
}
}
func init() {
var err error
sd, err = discover.NewClient()
if err != nil {
log.Fatal(err)
}
sched, err = sc.New()
if err != nil {
log.Fatal(err)
}
hostid = findHost()
host, err = lc.New(hostid)
if err != nil {
log.Fatal(err)
}
}
func runSchedule(cmd *Command, args []string) {
if len(args) != 1 {
cmd.printUsage()
os.Exit(2)
}
err := discoverd.Connect(getTarget() + ":55002") // TODO: fix this
assert(err)
sched, err := client.New()
assert(err)
hosts, err := discoverd.Services("flynn-lorne", discoverd.DefaultTimeout)
assert(err)
hostid := hosts[0].Attrs["id"]
id, err := uuid.NewV4()
jobid := id.String()
assert(err)
config := docker.Config{
Image: args[0],
//Cmd: []string{"start", "web"},
Tty: false,
AttachStdin: false,
AttachStdout: false,
AttachStderr: false,
OpenStdin: false,
StdinOnce: false,
}
schedReq := &sampi.ScheduleReq{
Incremental: true,
HostJobs: map[string][]*sampi.Job{
hostid: {{ID: jobid, Config: &config, TCPPorts: 1}}},
}
_, err = sched.Schedule(schedReq)
assert(err)
if port := getPort(hostid, jobid); port != "" {
fmt.Println(jobid + " created, listening at " + hosts[0].Host + ":" + port)
} else {
fmt.Println("Service was not scheduled")
os.Exit(1)
}
}
func main() {
var err error
scheduler, err = sampic.New()
if err != nil {
log.Fatal(err)
}
disc, err = discover.NewClient()
if err != nil {
log.Fatal(err)
}
router, err = strowgerc.New()
if err != nil {
log.Fatal(err)
}
mux := tigertonic.NewTrieServeMux()
mux.Handle("PUT", "/apps/{app_id}/domains/{domain}", tigertonic.Marshaled(addDomain))
mux.Handle("POST", "/apps/{app_id}/formation/{formation_id}", tigertonic.Marshaled(changeFormation))
mux.Handle("GET", "/apps/{app_id}/jobs", tigertonic.Marshaled(getJobs))
mux.HandleFunc("GET", "/apps/{app_id}/jobs/{job_id}/logs", getJobLog)
mux.HandleFunc("POST", "/apps/{app_id}/jobs", runJob)
http.ListenAndServe("127.0.0.1:1200", tigertonic.Logged(mux, nil))
}
func main() {
disc, err := discover.NewClient()
if err != nil {
log.Fatal(err)
}
scheduler, err := client.New()
if err != nil {
log.Fatal(err)
}
state, err := scheduler.State()
if err != nil {
log.Fatal(err)
}
var firstHost string
for k := range state {
firstHost = k
break
}
if firstHost == "" {
log.Fatal("no hosts")
}
id := randomID()
services, err := disc.Services("flynn-lorne-attach." + firstHost)
if err != nil {
log.Fatal(err)
}
conn, err := net.Dial("tcp", services.OnlineAddrs()[0])
if err != nil {
log.Fatal(err)
}
ws, _ := term.GetWinsize(os.Stdin.Fd())
err = gob.NewEncoder(conn).Encode(&lorne.AttachReq{
JobID: id,
Flags: lorne.AttachFlagStdout | lorne.AttachFlagStderr | lorne.AttachFlagStdin | lorne.AttachFlagStream,
Height: int(ws.Height),
Width: int(ws.Width),
})
if err != nil {
log.Fatal(err)
}
attachState := make([]byte, 1)
if _, err := conn.Read(attachState); err != nil {
log.Fatal(err)
}
switch attachState[0] {
case lorne.AttachError:
log.Fatal("attach error")
}
schedReq := &sampi.ScheduleReq{
Incremental: true,
HostJobs: map[string][]*sampi.Job{firstHost: {{ID: id, Config: &docker.Config{
Image: "titanous/redis",
Cmd: []string{"/bin/bash", "-i"},
Tty: true,
AttachStdin: true,
AttachStdout: true,
AttachStderr: true,
OpenStdin: true,
StdinOnce: true,
Env: []string{
"COLUMNS=" + strconv.Itoa(int(ws.Width)),
"LINES=" + strconv.Itoa(int(ws.Height)),
"TERM=" + os.Getenv("TERM"),
},
}}}},
}
if _, err := scheduler.Schedule(schedReq); err != nil {
log.Fatal(err)
}
if _, err := conn.Read(attachState); err != nil {
log.Fatal(err)
}
oldState, err := term.SetRawTerminal(os.Stdin.Fd())
if err != nil {
log.Fatal(err)
}
go io.Copy(conn, os.Stdin)
if _, err := io.Copy(os.Stdout, conn); err != nil {
log.Fatal(err)
}
term.RestoreTerminal(os.Stdin.Fd(), oldState)
}