func AuthAccount(rw http.ResponseWriter, req *http.Request, c martini.Context) {
splits := strings.Split(req.Header.Get("Authorization"), " ")
dec, err := base64.StdEncoding.DecodeString(splits[1])
if err != nil {
panic(err)
}
privateKey := string(dec[:len(dec)-1])
var account Account
err = dbmap.SelectOne(&account, "select * from accounts where private_key = $1 limit 1", privateKey)
if err == sql.ErrNoRows {
rw.Header().Set("WWW-Authenticate", "Basic realm=\"Authorization Required\"")
http.Error(rw, "Not Authorized", http.StatusUnauthorized)
} else if err != nil {
panic(err)
}
c.Map(&account)
grohl.AddContext("account", account.Id)
}
func main() {
grohl.AddContext("app", "buttered-scones")
var configFile string
flag.StringVar(&configFile, "config", "", "configuration file path")
flag.Parse()
if configFile == "" {
flag.Usage()
os.Exit(1)
}
config, err := butteredscones.LoadConfiguration(configFile)
if err != nil {
fmt.Printf("error opening configuration file: %s\n", err.Error())
os.Exit(1)
}
clients := make([]client.Client, 0, len(config.Network.Servers))
for _, server := range config.Network.Servers {
tlsConfig, err := config.BuildTLSConfig()
if err != nil {
fmt.Printf("%s\n", err.Error())
os.Exit(1)
}
tlsConfig.ServerName = server.Name
options := &lumberjack.ClientOptions{
Network: "tcp",
Address: server.Addr,
TLSConfig: tlsConfig,
ConnectionTimeout: time.Duration(config.Network.Timeout) * time.Second,
SendTimeout: time.Duration(config.Network.Timeout) * time.Second,
}
client := lumberjack.NewClient(options)
clients = append(clients, client)
}
// clients := []Client{&StdoutClient{}}
db, err := bolt.Open(config.State, 0600, &bolt.Options{Timeout: 2 * time.Second})
if err != nil {
fmt.Printf("error opening state database: %s\n", err.Error())
os.Exit(1)
}
snapshotter := &butteredscones.BoltSnapshotter{DB: db}
if config.Statistics.Addr != "" {
stats_server := &butteredscones.StatisticsServer{
Statistics: butteredscones.GlobalStatistics,
Addr: config.Statistics.Addr,
}
go func() {
err := stats_server.ListenAndServe()
grohl.Report(err, grohl.Data{"msg": "stats server failed to start"})
}()
}
// Default spool size
spoolSize := config.Network.SpoolSize
if spoolSize == 0 {
spoolSize = 1024
}
supervisor := butteredscones.NewSupervisor(config.Files, clients, snapshotter, config.MaxLength)
supervisor.SpoolSize = spoolSize
supervisor.GlobRefresh = 15 * time.Second
supervisor.Start()
signalCh := make(chan os.Signal, 1)
go signal.Notify(signalCh, syscall.SIGTERM, syscall.SIGINT)
signal := <-signalCh
fmt.Printf("Received %s, shutting down cleanly ...\n", signal)
supervisor.Stop()
fmt.Printf("Done shutting down\n")
}
func main() {
hostname, _ := os.Hostname()
externalAddr := flag.String("external", "", "external IP of host")
bindAddr := flag.String("bind", "", "bind containers to this IP")
configFile := flag.String("config", "", "configuration file")
manifestFile := flag.String("manifest", "/etc/flynn-host.json", "manifest file")
hostID := flag.String("id", hostname, "host id")
force := flag.Bool("force", false, "kill all containers booted by flynn-host before starting")
attributes := make(AttributeFlag)
flag.Var(&attributes, "attribute", "key=value pair to add as an attribute")
flag.Parse()
grohl.AddContext("app", "lorne")
grohl.Log(grohl.Data{"at": "start"})
g := grohl.NewContext(grohl.Data{"fn": "main"})
dockerc, err := docker.NewClient("unix:///var/run/docker.sock")
if err != nil {
log.Fatal(err)
}
if *force {
if err := killExistingContainers(dockerc); err != nil {
os.Exit(1)
}
}
state := NewState()
ports := make(chan int)
go allocatePorts(ports, 55000, 65535)
go serveHTTP(&Host{state: state, docker: dockerc}, &attachHandler{state: state, docker: dockerc})
go streamEvents(dockerc, state)
processor := &jobProcessor{
externalAddr: *externalAddr,
bindAddr: *bindAddr,
docker: dockerc,
state: state,
discoverd: os.Getenv("DISCOVERD"),
}
runner := &manifestRunner{
env: parseEnviron(),
externalIP: *externalAddr,
ports: ports,
processor: processor,
docker: dockerc,
}
var disc *discoverd.Client
if *manifestFile != "" {
var r io.Reader
var f *os.File
if *manifestFile == "-" {
r = os.Stdin
} else {
f, err = os.Open(*manifestFile)
if err != nil {
log.Fatal(err)
}
r = f
}
services, err := runner.runManifest(r)
if err != nil {
log.Fatal(err)
}
if f != nil {
f.Close()
}
if d, ok := services["discoverd"]; ok {
processor.discoverd = fmt.Sprintf("%s:%d", d.InternalIP, d.TCPPorts[0])
var disc *discoverd.Client
err = Attempts.Run(func() (err error) {
disc, err = discoverd.NewClientWithAddr(processor.discoverd)
return
})
if err != nil {
log.Fatal(err)
}
}
}
if processor.discoverd == "" && *externalAddr != "" {
processor.discoverd = *externalAddr + ":1111"
}
// HACK: use env as global for discoverd connection in sampic
os.Setenv("DISCOVERD", processor.discoverd)
if disc == nil {
disc, err = discoverd.NewClientWithAddr(processor.discoverd)
if err != nil {
log.Fatal(err)
}
}
sampiStandby, err := disc.RegisterAndStandby("flynn-host", *externalAddr+":1113", map[string]string{"id": *hostID})
if err != nil {
log.Fatal(err)
}
// Check if we are the leader so that we can use the cluster functions directly
sampiCluster := sampi.NewCluster(sampi.NewState())
select {
case <-sampiStandby:
g.Log(grohl.Data{"at": "sampi_leader"})
rpc.Register(sampiCluster)
case <-time.After(5 * time.Millisecond):
go func() {
<-sampiStandby
g.Log(grohl.Data{"at": "sampi_leader"})
rpc.Register(sampiCluster)
}()
}
cluster, err := cluster.NewClientWithSelf(*hostID, NewLocalClient(*hostID, sampiCluster))
if err != nil {
log.Fatal(err)
}
g.Log(grohl.Data{"at": "sampi_connected"})
events := make(chan host.Event)
state.AddListener("all", events)
go syncScheduler(cluster, events)
h := &host.Host{}
if *configFile != "" {
h, err = openConfig(*configFile)
if err != nil {
log.Fatal(err)
}
}
if h.Attributes == nil {
h.Attributes = make(map[string]string)
}
for k, v := range attributes {
h.Attributes[k] = v
}
h.ID = *hostID
for {
newLeader := cluster.NewLeaderSignal()
h.Jobs = state.ClusterJobs()
jobs := make(chan *host.Job)
hostErr := cluster.RegisterHost(h, jobs)
g.Log(grohl.Data{"at": "host_registered"})
processor.Process(ports, jobs)
g.Log(grohl.Data{"at": "sampi_disconnected", "err": *hostErr})
<-newLeader
}
}
func main() {
hostname, _ := os.Hostname()
externalAddr := flag.String("external", "", "external IP of host")
configFile := flag.String("config", "", "configuration file")
manifestFile := flag.String("manifest", "", "manifest file")
hostID := flag.String("id", hostname, "host id")
attributes := make(AttributeFlag)
flag.Var(&attributes, "attribute", "key=value pair to add as an attribute")
flag.Parse()
grohl.AddContext("app", "lorne")
grohl.Log(grohl.Data{"at": "start"})
g := grohl.NewContext(grohl.Data{"fn": "main"})
dockerc, err := docker.NewClient("unix:///var/run/docker.sock")
if err != nil {
log.Fatal(err)
}
state := NewState()
ports := make(chan int)
go allocatePorts(ports, 55000, 65535)
go serveHTTP(&Host{state: state, docker: dockerc}, &attachHandler{state: state, docker: dockerc})
go streamEvents(dockerc, state)
processor := &jobProcessor{
externalAddr: *externalAddr,
docker: dockerc,
state: state,
discoverd: os.Getenv("DISCOVERD"),
}
runner := &manifestRunner{
env: parseEnviron(),
externalIP: *externalAddr,
ports: ports,
processor: processor,
docker: dockerc,
}
var disc *discoverd.Client
if *manifestFile != "" {
f, err := os.Open(*manifestFile)
if err != nil {
log.Fatal(err)
}
services, err := runner.runManifest(f)
if err != nil {
log.Fatal(err)
}
f.Close()
if d, ok := services["discoverd"]; ok {
processor.discoverd = fmt.Sprintf("%s:%d", d.InternalIP, d.TCPPorts[0])
var disc *discoverd.Client
err = Attempts.Run(func() (err error) {
disc, err = discoverd.NewClientUsingAddress(processor.discoverd)
return
})
if err != nil {
log.Fatal(err)
}
}
}
if processor.discoverd == "" && *externalAddr != "" {
processor.discoverd = *externalAddr + ":1111"
}
// HACK: use env as global for discoverd connection in sampic
os.Setenv("DISCOVERD", processor.discoverd)
if disc == nil {
disc, err = discoverd.NewClientUsingAddress(processor.discoverd)
if err != nil {
log.Fatal(err)
}
}
sampiStandby, err := disc.RegisterAndStandby("flynn-host", *externalAddr+":1113", map[string]string{"id": *hostID})
if err != nil {
log.Fatal(err)
}
go func() {
<-sampiStandby
rpc.Register(sampi.NewCluster(sampi.NewState()))
}()
cluster, err := client.New()
if err != nil {
log.Fatal(err)
}
g.Log(grohl.Data{"at": "sampi_connected"})
events := make(chan host.Event)
state.AddListener("all", events)
go syncScheduler(cluster, events)
var h *host.Host
if *configFile != "" {
h, err = openConfig(*configFile)
if err != nil {
log.Fatal(err)
}
} else {
h = &host.Host{Resources: make(map[string]host.ResourceValue)}
}
if _, ok := h.Resources["memory"]; !ok {
h.Resources["memory"] = host.ResourceValue{Value: 1024}
}
h.ID = *hostID
h.Jobs = state.ClusterJobs()
if h.Attributes == nil {
h.Attributes = make(map[string]string)
}
for k, v := range attributes {
h.Attributes[k] = v
}
jobs := make(chan *host.Job)
hostErr := cluster.ConnectHost(h, jobs)
g.Log(grohl.Data{"at": "host_registered"})
processor.Process(ports, jobs)
log.Fatal(*hostErr)
}