func main() { rpcAddr := flag.String("rpcaddr", ":1115", "rpc listen address") httpAddr := flag.String("httpaddr", ":8080", "http frontend listen address") flag.Parse() var s Server f, err := NewHTTPFrontend(*httpAddr) if err != nil { log.Fatal(err) } s.HTTPFrontend = f rpcplus.Register(&Router{s}) rpcplus.HandleHTTP() go http.ListenAndServe(*rpcAddr, nil) d, err := discover.NewClient() if err != nil { log.Fatal(err) } if hostPort := strings.SplitN(*rpcAddr, ":", 2); hostPort[0] != "" { err = d.RegisterWithHost("flynn-strowger-rpc", hostPort[0], hostPort[1], nil) } else { err = d.Register("flynn-strowger-rpc", hostPort[1], nil) } if err != nil { log.Fatal(err) } s.ListenAndServe(nil) }
func (cmd *clientCmd) InitClient(silent bool) { client, err := discover.NewClient() if err != nil { if silent { os.Exit(1) } log.Fatal("Error making client: ", err.Error()) } cmd.client = client }
func NewHTTPFrontend(addr string) (*HTTPFrontend, error) { f := &HTTPFrontend{ Addr: addr, etcd: etcd.NewClient(nil), etcdPrefix: "/strowger/http/", domains: make(map[string]*httpServer), services: make(map[string]*httpServer), } var err error f.discover, err = discover.NewClient() return f, err }
func main() { d, err := discover.NewClient() if err != nil { log.Fatal(err) } if err := d.Register("example-server", os.Args[1], nil); err != nil { log.Fatal(err) } http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { w.Write([]byte("Listening on " + os.Args[1])) }) http.ListenAndServe(":"+os.Args[1], nil) }
func New() (*Client, error) { disc, err := discover.NewClient() if err != nil { return nil, err } services, err := disc.Services("flynn-sampi") if err != nil { return nil, err } addrs := services.OnlineAddrs() if len(addrs) == 0 { return nil, errors.New("sampi: no servers found") } c, err := rpcplus.DialHTTP("tcp", addrs[0]) return &Client{c}, 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 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() { flag.Parse() rpcplus.HandleHTTP() l, err := net.Listen("tcp", *listenAddr) if err != nil { log.Fatal(err) } d, err := discover.NewClient() if err != nil { log.Fatal(err) } if hostPort := strings.SplitN(*listenAddr, ":", 2); hostPort[0] != "" { err = d.RegisterWithHost("flynn-sampi", hostPort[0], hostPort[1], nil) } else { err = d.Register("flynn-sampi", hostPort[1], nil) } if err != nil { log.Fatal(err) } http.Serve(l, nil) }
func main() { flag.Parse() name := flag.Arg(0) port := flag.Arg(1) host := flag.Arg(2) exit := make(chan os.Signal, 1) signal.Notify(exit, os.Interrupt, syscall.SIGTERM) var cleanup func() go func() { <-exit log.Println("Shutting down...") if cleanup != nil { cleanup() } os.Exit(0) }() client, err := discover.NewClient() if err != nil { log.Fatal("Error making client: ", err.Error()) } if host != "" { client.RegisterWithHost(name, host, port, nil) cleanup = func() { client.UnregisterWithHost(name, host, port) } } else { client.Register(name, port, nil) cleanup = func() { client.Unregister(name, port) } } log.Printf("Registered %s on port %s.\n", name, port) set := client.Services(name) for { log.Println(strings.Join(set.OnlineAddrs(), ", ")) time.Sleep(1 * time.Second) } }
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) }
func main() { externalAddr := flag.String("external", "", "external IP of host") flag.Parse() go attachServer() go rpcServer() go allocatePorts() id := randomID() disc, err := discover.NewClient() if err != nil { log.Fatal(err) } if err := disc.Register("flynn-lorne-rpc."+id, "1113", nil); err != nil { log.Fatal(err) } if err := disc.Register("flynn-lorne-attach."+id, "1114", nil); err != nil { log.Fatal(err) } services, err := disc.Services("flynn-sampi") if err != nil { log.Fatal(err) } schedulers := services.Online() if len(schedulers) == 0 { log.Fatal("No sampi instances found") } scheduler, err := rpcplus.DialHTTP("tcp", schedulers[0].Addr) if err != nil { log.Fatal(err) } log.Print("Connected to scheduler") Docker, err = docker.NewClient("http://localhost:4243") if err != nil { log.Fatal(err) } go streamEvents(Docker) go syncScheduler(scheduler) host := sampi.Host{ ID: id, Resources: map[string]sampi.ResourceValue{"memory": sampi.ResourceValue{Value: 1024}}, } jobs := make(chan *sampi.Job) scheduler.StreamGo("Scheduler.RegisterHost", host, jobs) log.Print("Host registered") for job := range jobs { log.Printf("%#v", job.Config) var hostConfig *docker.HostConfig if job.TCPPorts > 0 { port := strconv.Itoa(<-portAllocator) job.Config.Env = append(job.Config.Env, "PORT="+port) job.Config.ExposedPorts = map[string]struct{}{port + "/tcp": struct{}{}} hostConfig = &docker.HostConfig{ PortBindings: map[string][]docker.PortBinding{port + "/tcp": {{HostPort: port}}}, } } if *externalAddr != "" { job.Config.Env = append(job.Config.Env, "EXTERNAL_IP="+*externalAddr, "SD_HOST="+*externalAddr, "DISCOVERD="+*externalAddr+":1111") } state.AddJob(job) container, err := Docker.CreateContainer(job.Config) if err == docker.ErrNoSuchImage { err = Docker.PullImage(docker.PullImageOptions{Repository: job.Config.Image}, os.Stdout) if err != nil { log.Fatal(err) } container, err = Docker.CreateContainer(job.Config) } if err != nil { log.Fatal(err) } state.SetContainerID(job.ID, container.ID) state.WaitAttach(job.ID) if err := Docker.StartContainer(container.ID, hostConfig); err != nil { log.Fatal(err) } state.SetStatusRunning(job.ID) } }