Example #1
0
func main() {
	kingpin.Version(Version)
	kingpin.Parse()

	setupLoggo(*debug)

	//localRegistry := metrics.NewRegistry()
	//publisher := newPublisher(localRegistry)
	//publisher := newLitePublisher()

	mqttEngine, mqerr := newMqttEngine(*mqttURL)
	wbEngine, wberr := NewWebBrickDriver(mqttEngine)

	if mqerr != nil && wberr != nil {
		panic(err)
	}

	wbEngine.Start()

	//ws := newWsServer(localRegistry)

	//go ws.listenAndServ(*port, *path)

	// Set up channel on which to send signal notifications.
	sigc := make(chan os.Signal, 1)
	signal.Notify(sigc, os.Interrupt, os.Kill)

	// Wait for receiving a signal.
	<-sigc

	// Disconnect the Network Connection.
	if err := engine.disconnect(); err != nil {
		panic(err)
	}
}
Example #2
0
func init() {
	m = macaron.Classic()
	m.Use(modules.Public)

	if _, err := os.Stat("templates"); err == nil {
		m.Use(macaron.Renderer())
	} else {
		m.Use(modules.Renderer)
	}

	kingpin.HelpFlag.Short('h')
	kingpin.Version(VERSION)
	kingpin.Flag("port", "Port to listen").Default("8000").IntVar(&gcfg.port)
	kingpin.Flag("root", "File root directory").Default(".").StringVar(&gcfg.root)
	kingpin.Flag("private", "Only listen on loopback address").BoolVar(&gcfg.private)
	kingpin.Flag("httpauth", "HTTP basic auth (ex: user:pass)").Default("").StringVar(&gcfg.httpauth)
	kingpin.Flag("cert", "TLS cert.pem").StringVar(&gcfg.cert)
	kingpin.Flag("key", "TLS key.pem").StringVar(&gcfg.key)
	kingpin.Flag("gzip", "Enable Gzip support").BoolVar(&gcfg.gzip)
	//kingpin.Flag("ftp", "Enable FTP support").BoolVar(&gcfg.ftp)
	//kingpin.Flag("ftp-port", "FTP listen port").Default("2121").IntVar(&gcfg.ftpPort)
	//kingpin.Flag("ftp-auth", "FTP auth (ex: user:pass)").Default("admin:123456").StringVar(&gcfg.ftpAuth)
	kingpin.Flag("upload", "Enable upload support").BoolVar(&gcfg.upload)
	kingpin.Flag("zipable", "Enable archieve folder into zip").BoolVar(&gcfg.zipable)
}
func main() {
	kingpin.Version(fmt.Sprintf("%s %s", kingpin.CommandLine.Name, version))
	kingpin.Parse()

	level, err := oplogging.LogLevel(*loglevel)
	if err != nil {
		prefixedUserError("Bad loglevel: %s", loglevel)
		os.Exit(1)
	}
	logging.SetLevel(level)

	diffCmd, err := shellwords.NewParser().Parse(*diffCommand)
	if err != nil {
		userError("Error parsing diff command %q: %s", *diffCommand, err.Error())
		os.Exit(1)
	}

	tests, err := testcase.DiscoverTests(*testcasePath)
	if err != nil {
		userError(err.Error())
		os.Exit(1)
	}
	if err = runTests(*logstashPath, tests, *configPaths, diffCmd, *keptEnvVars); err != nil {
		userError(err.Error())
		os.Exit(1)
	}
	os.Exit(0)
}
Example #4
0
File: kaifa.go Project: kaifali/cli
func main() {
	kingpin.Version("0.2.1")
	kingpin.Parse()

	switch *format {
	case "html":
		openBrowser()
	case "json":
		fetchJSON()
	default:
		openBrowser()
	}
}
Example #5
0
func main() {
	kingpin.Version("0.1")
	kingpin.Parse()

	f, err := os.OpenFile(*logfile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
	if err != nil {
		panic(err)
	}
	defer f.Close()

	LogInit(f)
	GetClusterReport(*conf)

}
Example #6
0
func main() {
	kingpin.Version("0.1")
	kingpin.Parse()

	ttyPath := *device

	fmt.Println("Writing packets to: " + ttyPath)
	fmt.Println("Packets are formatted all lower case hex, [src] [dest] [message...]")
	fmt.Println("Quote ascii strings for text conversion")

	serialConfig := &serial.Config{Name: ttyPath, Baud: 9600, Parity: serial.PARITY_EVEN}
	port, err := serial.OpenPort(serialConfig)
	if err != nil {
		panic(err)
	}

	go func() {
		parser := ibus.NewIbusPacketParser()
		for {
			buffer := make([]byte, 1)
			_, err := port.Read(buffer)
			if err != nil {
				panic(err)
			}
			parser.Push(buffer)
			if parser.HasPacket() {
				pkt := parser.GetPacket()
				// echo received packets to simulate bus broadcast
				port.Write(pkt.AsBytes())
				fmt.Println("\n<== " + pkt.AsString())
				fmt.Print("Enter IBUS packet: ")
			}
		}
	}()

	for {
		reader := bufio.NewReader(os.Stdin)
		fmt.Print("Enter IBUS packet: ")
		text, _ := reader.ReadString('\n')
		text = strings.TrimSpace(text)
		hexChars := strings.Split(text, " ")
		packet := new(ibus.IbusPacket)
		packet.Src = hexChars[0]
		packet.Dest = hexChars[1]
		packet.Message = hexChars[2:len(hexChars)]
		fmt.Println("==> " + packet.AsString())
		bytes := packet.AsBytes()
		port.Write(bytes)
	}
}
Example #7
0
func main() {

	kingpin.Version("0.1")
	kingpin.Parse()

	f, err := os.OpenFile(*logfile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
	if err != nil {
		panic(err)
	}
	defer f.Close()

	LogInit(*verbose, f)
	osd_sockets, err := filepath.Glob(*osd_sockets)
	if err != nil {
		log.Error("No sockets found exiting")
	}
	log.Info("Found following sockets", osd_sockets)
	c := make(chan perf)
	perfcounters := make([]PerfCounter, len(osd_sockets))

	for _, osd_socket := range osd_sockets {
		go func() {
			result, err := QueryAdminSocket(osd_socket)
			if err != nil {
				log.Fatal("Querying Socket failed with ", err)
			}
			c <- perf{*result, err}
		}()
		query := <-c
		if query.error == nil {
			perfcounters = append(perfcounters, query.PerfCounter)
			// perf_json, err := json.Marshal(query.PerfCounter)
			// if err == nil {
			// 	fmt.Println(string(perf_json))
			// }
			token, err := get_token()
			if err == nil {
				PostPerfCeilometer(token, query.PerfCounter)
			}

		}

	}
	GetClusterStatus(*conf)
	GetClusterIOPs(*conf)

}
Example #8
0
func parseFlags() {
	kingpin.HelpFlag.Short('h')
	kingpin.Version(versionMessage())
	kingpin.Flag("root", "root directory").Short('r').Default("./").StringVar(&gcfg.Root)
	kingpin.Flag("addr", "listen address").Short('a').Default(":8000").StringVar(&gcfg.Addr)
	kingpin.Flag("cert", "tls cert.pem path").StringVar(&gcfg.Cert)
	kingpin.Flag("key", "tls key.pem path").StringVar(&gcfg.Key)
	kingpin.Flag("httpauth", "HTTP basic auth (ex: user:pass)").Default("").StringVar(&gcfg.HttpAuth)
	kingpin.Flag("theme", "web theme, one of <black|green>").Default("black").StringVar(&gcfg.Theme)
	kingpin.Flag("upload", "enable upload support").BoolVar(&gcfg.Upload)
	kingpin.Flag("xheaders", "used when behide nginx").BoolVar(&gcfg.XHeaders)
	kingpin.Flag("cors", "enable cross-site HTTP request").BoolVar(&gcfg.Cors)
	kingpin.Flag("plistproxy", "plist proxy when server is not https").Default(defaultPlistProxy).Short('p').URLVar(&gcfg.PlistProxy)
	kingpin.Flag("title", "server title").Default("Go HTTP File Server").StringVar(&gcfg.Title)

	kingpin.Parse()
}
Example #9
0
func main() {
	kingpin.Version("1.3")
	kingpin.Parse()

	api := slack.New(*token)

	for {

		users, _ := api.UsersList()

		svc := ec2.New(session.New(), &aws.Config{Region: aws.String(*region)})

		// Call the DescribeInstances Operation
		resp, err := svc.DescribeInstances(nil)
		if err != nil {
			panic(err)
		}

		usersInstances := findLongRunningInstances(resp, users)
		alreadyNotified := getAlreadyNotified()

		for user, instances := range usersInstances {
			msg := ""
			for _, inst := range instances {
				if !contains(alreadyNotified, *inst.InstanceId) {
					msg += fmt.Sprintf("`%v - %v` with id _%v_\n", getTagValue(inst.Tags, "Purpose"), getTagValue(inst.Tags, "Name"), *inst.InstanceId)
					alreadyNotified = append(alreadyNotified, *inst.InstanceId)
				}
			}
			if msg != "" {
				msg := "\nYou have the following instances running in amazon:\n\n" + msg
				msg += "They were all started more then two days ago, are they still needed ?"
				if user == "U02HSGZ3F" || *prod { // ME
					err = api.ChatPostMessage(user, msg, &slack.ChatPostMessageOpt{Username: "******"})
				}

			}

		}
		saveAlreadyNotified(alreadyNotified)
		time.Sleep(time.Duration(*timeout) * time.Minute)
	}
}
Example #10
0
func main() {
	kingpin.Version("0.0.1")
	kingpin.Parse()
	fmt.Printf("Would ping: %s with timeout %s and count %d", *ip, *timeout, *count)
}