func main() { var port uint var etcdAddr, logLevel string flag.UintVarP(&port, "port", "p", 19000, "listen port") flag.StringVarP(&etcdAddr, "etcd", "e", defaultEtcdAddr, "address of etcd machine") flag.StringVarP(&logLevel, "log-level", "l", "warn", "log level") flag.Parse() if err := logx.DefaultSetup(logLevel); err != nil { log.WithFields(log.Fields{ "error": err, "level": logLevel, }).Fatal("failed to set up logging") } etcdClient := etcd.NewClient([]string{etcdAddr}) if !etcdClient.SyncCluster() { log.WithFields(log.Fields{ "addr": etcdAddr, }).Fatal("unable to sync etcd cluster") } ctx := lochness.NewContext(etcdClient) _ = Run(port, ctx) }
func main() { // Handle cli flags var port uint var bridge, logLevel string flag.UintVarP(&port, "port", "p", 40001, "listen port") flag.StringVarP(&bridge, "bridge", "b", "mistify0", "bridge to join interfaces to with OVS") flag.StringVarP(&logLevel, "log-level", "l", "warning", "log level: debug/info/warning/error/fatal") flag.Parse() // Set up logging if err := logx.DefaultSetup(logLevel); err != nil { log.WithFields(log.Fields{ "error": err, "func": "logx.DefaultSetup", }).Fatal("Could not set up logging") } o, err := ovs.NewOVS(bridge) if err != nil { os.Exit(1) } // Run HTTP Server if err := o.RunHTTP(port); err != nil { os.Exit(1) } }
func main() { var port uint var etcdAddr, bstalk, logLevel string // Command line flags flag.StringVarP(&bstalk, "beanstalk", "b", "127.0.0.1:11300", "address of beanstalkd server") flag.StringVarP(&logLevel, "log-level", "l", "warn", "log level") flag.StringVarP(&etcdAddr, "etcd", "e", "http://127.0.0.1:4001", "address of etcd server") flag.UintVarP(&port, "http", "p", 7544, "http port to publish metrics. set to 0 to disable") flag.Parse() // Set up logger if err := logx.DefaultSetup(logLevel); err != nil { log.WithFields(log.Fields{ "error": err, "level": logLevel, }).Fatal("unable to to set up logrus") } etcdClient := etcd.NewClient([]string{etcdAddr}) if !etcdClient.SyncCluster() { log.WithFields(log.Fields{ "addr": etcdAddr, }).Fatal("unable to sync etcd cluster") } ctx := lochness.NewContext(etcdClient) log.WithField("address", bstalk).Info("connection to beanstalk") jobQueue, err := jobqueue.NewClient(bstalk, etcdClient) if err != nil { log.WithFields(log.Fields{ "error": err, "address": bstalk, }).Fatal("failed to create jobQueue client") } // Set up metrics m := setupMetrics(port) if m != nil { } agent := ctx.NewMistifyAgent() // Start consuming consume(jobQueue, agent, m) }
// Read configuration from both profile and flags. Flags override profile. func config() error { var err error if B2D.Dir, err = getCfgDir(".boot2docker"); err != nil { return fmt.Errorf("failed to get current directory: %s", err) } filename := os.Getenv("BOOT2DOCKER_PROFILE") if filename == "" { filename = filepath.Join(B2D.Dir, "profile") } profile, err := getProfile(filename) if err != nil && !os.IsNotExist(err) { // undefined/empty profile works return err } if p := os.Getenv("VBOX_INSTALL_PATH"); p != "" && runtime.GOOS == "windows" { B2D.VBM = profile.Get("", "vbm", filepath.Join(p, "VBoxManage.exe")) } else { B2D.VBM = profile.Get("", "vbm", "VBoxManage") } B2D.SSH = profile.Get("", "ssh", "ssh") B2D.VM = profile.Get("", "vm", "boot2docker-vm") B2D.ISO = profile.Get("", "iso", filepath.Join(B2D.Dir, "boot2docker.iso")) if diskSize, err := strconv.ParseUint(profile.Get("", "disksize", "20000"), 10, 32); err != nil { return fmt.Errorf("invalid disk image size: %s", err) } else { B2D.DiskSize = uint(diskSize) } if memory, err := strconv.ParseUint(profile.Get("", "memory", "1024"), 10, 32); err != nil { return fmt.Errorf("invalid memory size: %s", err) } else { B2D.Memory = uint(memory) } if sshPort, err := strconv.ParseUint(profile.Get("", "sshport", "2022"), 10, 16); err != nil { return fmt.Errorf("invalid SSH port: %s", err) } else { B2D.SSHPort = uint16(sshPort) } if dockerPort, err := strconv.ParseUint(profile.Get("", "dockerport", "4243"), 10, 16); err != nil { return fmt.Errorf("invalid DockerPort: %s", err) } else { B2D.DockerPort = uint16(dockerPort) } // Host only networking settings B2D.HostIP = profile.Get("", "hostiP", "192.168.59.3") B2D.DHCPIP = profile.Get("", "dhcpip", "192.168.59.99") B2D.NetworkMask = profile.Get("", "netmask", "255.255.255.0") B2D.LowerIPAddress = profile.Get("", "lowerip", "192.168.59.103") B2D.UpperIPAddress = profile.Get("", "upperip", "192.168.59.254") B2D.DHCPEnabled = profile.Get("", "dhcp", "Yes") // Commandline flags override profile settings. flag.StringVar(&B2D.VBM, "vbm", B2D.VBM, "Path to VirtualBox management utility") flag.StringVar(&B2D.SSH, "ssh", B2D.SSH, "Path to SSH client utility") flag.StringVarP(&B2D.Dir, "dir", "d", B2D.Dir, "boot2docker config directory") flag.StringVar(&B2D.ISO, "iso", B2D.ISO, "Path to boot2docker ISO image") flag.UintVarP(&B2D.DiskSize, "disksize", "s", B2D.DiskSize, "boot2docker disk image size (in MB)") flag.UintVarP(&B2D.Memory, "memory", "m", B2D.Memory, "Virtual machine memory size (in MB)") flag.Var(newUint16Value(B2D.SSHPort, &B2D.SSHPort), "sshport", "Host SSH port (forward to port 22 in VM)") flag.Var(newUint16Value(B2D.DockerPort, &B2D.DockerPort), "dockerport", "Host Docker port (forward to port 4243 in VM)") flag.StringVar(&B2D.HostIP, "hostip", B2D.HostIP, "VirtualBox host-only network IP address") flag.StringVar(&B2D.NetworkMask, "netmask", B2D.NetworkMask, "VirtualBox host-only network mask") flag.StringVar(&B2D.DHCPEnabled, "dhcp", B2D.DHCPEnabled, "Enable VirtualBox host-only network DHCP") flag.StringVar(&B2D.DHCPIP, "dhcpip", B2D.DHCPIP, "VirtualBox host-only network DHCP server address") flag.StringVar(&B2D.LowerIPAddress, "lowerip", B2D.LowerIPAddress, "VirtualBox host-only network DHCP lower bound") flag.StringVar(&B2D.UpperIPAddress, "upperip", B2D.UpperIPAddress, "VirtualBox host-only network DHCP upper bound") flag.Parse() // Name of VM is the second argument. if vm := flag.Arg(1); vm != "" { B2D.VM = vm } return nil }
func main() { var port uint var etcdAddr, bstalk, logLevel string flag.StringVarP(&bstalk, "beanstalk", "b", "127.0.0.1:11300", "address of beanstalkd server") flag.StringVarP(&logLevel, "log-level", "l", "warn", "log level") flag.StringVarP(&etcdAddr, "etcd", "e", "http://127.0.0.1:4001", "address of etcd server") flag.UintVarP(&port, "http", "p", 7543, "address for http interface. set to 0 to disable") flag.Parse() // Set up logger if err := logx.DefaultSetup(logLevel); err != nil { log.WithFields(log.Fields{ "error": err, "level": logLevel, }).Fatal("failed to set up logging") } etcdClient := etcd.NewClient([]string{etcdAddr}) if !etcdClient.SyncCluster() { log.WithFields(log.Fields{ "addr": etcdAddr, }).Fatal("unable to sync etcd cluster") } log.WithField("address", bstalk).Info("connection to beanstalk") jobQueue, err := jobqueue.NewClient(bstalk, etcdClient) if err != nil { log.WithFields(log.Fields{ "error": err, "address": bstalk, }).Fatal("failed to create jobQueue client") } // setup metrics ms := mapsink.New() conf := metrics.DefaultConfig("cplacerd") conf.EnableHostname = false m, _ := metrics.New(conf, ms) if port != 0 { http.Handle("/metrics", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { w.WriteHeader(http.StatusOK) w.Header().Set("Content-Type", "application/json") if err := json.NewEncoder(w).Encode(ms); err != nil { log.WithField("error", err).Error(err) } })) go func() { if err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil); err != nil { log.WithFields(log.Fields{ "error": err, }).Fatal("error serving") } }() } // XXX: we want to try to keep track of where a job is // in this pipeline? would have to persist in the job funcs := []TaskFunc{ TaskFunc{ name: "check job status", function: checkJobStatus, }, TaskFunc{ name: "check guest status", function: checkGuestStatus, }, TaskFunc{ name: "select hypervisor candidate", function: selectHypervisor, }, TaskFunc{ name: "update job action", function: changeJobAction, }, TaskFunc{ name: "add task to worker", function: addJobToWorker, }, TaskFunc{ name: "make task for deletion", function: deleteTask, }, } for _, f := range funcs { f.label = strings.Split(runtime.FuncForPC(reflect.ValueOf(f.function).Pointer()).Name(), ".")[1] } for { task, err := jobQueue.NextCreateTask() if err != nil { if bCE, ok := err.(beanstalk.ConnError); ok { switch bCE { case beanstalk.ErrTimeout: // Empty queue, continue waiting continue case beanstalk.ErrDeadline: // See docs on beanstalkd deadline // We're just going to sleep to let the deadline'd job expire // and try to get another job m.IncrCounter([]string{"beanstalk", "error", "deadline"}, 1) log.Debug(beanstalk.ErrDeadline) time.Sleep(5 * time.Second) continue default: // You have failed me for the last time log.WithField("error", err).Fatal(err) } } log.WithFields(log.Fields{ "task": task, "error": err, }).Error("invalid task") if err := task.Delete(); err != nil { log.WithFields(log.Fields{ "task": task.ID, "error": err, }).Error("unable to delete") } } for _, f := range funcs { fields := log.Fields{ "task": task, } log.WithFields(fields).Debug("running") start := time.Now() rm, err := f.function(jobQueue, task) m.MeasureSince([]string{f.label, "time"}, start) m.IncrCounter([]string{f.label, "count"}, 1) duration := int(time.Since(start).Seconds() * 1000) log.WithFields(fields).WithField("duration", duration).Info("done") if err != nil { m.IncrCounter([]string{f.label, "error"}, 1) log.WithFields(fields).WithField("error", err).Error("task error") task.Job.Status = jobqueue.JobStatusError task.Job.Error = err.Error() if err := task.Job.Save(24 * time.Hour); err != nil { log.WithFields(log.Fields{ "task": task, "error": err, }).Error("unable to save") } } if rm { if err := task.Delete(); err != nil { log.WithFields(log.Fields{ "task": task.ID, "error": err, }).Error("unable to delete") } break } } } }
func main() { var port uint var etcdAddr, bstalk, logLevel, statsd string flag.UintVarP(&port, "port", "p", 18000, "listen port") flag.StringVarP(&etcdAddr, "etcd", "e", defaultEtcdAddr, "address of etcd machine") flag.StringVarP(&bstalk, "beanstalk", "b", "127.0.0.1:11300", "address of beanstalkd server") flag.StringVarP(&logLevel, "log-level", "l", "warn", "log level") flag.StringVarP(&statsd, "statsd", "s", "", "statsd address") flag.Parse() if err := logx.DefaultSetup(logLevel); err != nil { log.WithFields(log.Fields{ "error": err, "func": "logx.DefaultSetup", "level": logLevel, }).Fatal("unable to set up logrus") } etcdClient := etcd.NewClient([]string{etcdAddr}) if !etcdClient.SyncCluster() { log.WithFields(log.Fields{ "error": nil, "func": "etcd.SyncCluster", "addr": etcdAddr, }).Fatal("unable to sync etcd cluster") } ctx := lochness.NewContext(etcdClient) log.WithField("address", bstalk).Info("connection to beanstalk") jobQueue, err := jobqueue.NewClient(bstalk, etcdClient) if err != nil { log.WithFields(log.Fields{ "error": err, "address": bstalk, }).Fatal("failed to create jobQueue client") } // setup metrics sink := mapsink.New() fanout := metrics.FanoutSink{sink} if statsd != "" { ss, _ := metrics.NewStatsdSink(statsd) fanout = append(fanout, ss) } conf := metrics.DefaultConfig("cguestd") conf.EnableHostname = false m, _ := metrics.New(conf, fanout) mctx := &metricsContext{ sink: sink, metrics: m, mmw: mmw.New(m), } if err := Run(port, ctx, jobQueue, mctx); err != nil { log.WithFields(log.Fields{ "error": err, }).Fatal("failed to run server") } }