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)
}
}