예제 #1
0
파일: main.go 프로젝트: confiks/ipfs-dc
func main() {
	// Setup context
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// Define a CLI
	dcConfig := &DCConfig{ServiceIdentifier: "omnivore"}

	kingpin.Flag("n", "The index of this node in the pool, if IPFS_POOL_PATH is set").Default("-1").Short('n').IntVar(&dcConfig.PoolIndex)

	var args []string
	kingpin.Arg("args", "arguments").StringsVar(&args)
	kingpin.Parse()

	// Build a node
	ipfsNode, err := BuildNode(ctx, dcConfig)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	fmt.Printf("I am node %s\n", ipfsNode.Identity.Pretty())

	// Respond to incoming providerIDs and streams
	// providerIDsIn, err := StartServiceDiscovery(ctx, ipfsNode, dcConfig)
	// if err != nil {
	// 	fmt.Println(err)
	// 	os.Exit(1)
	// }
	//
	// streamIn, err := StartListening(ipfsNode, dcConfig)
	// if err != nil {
	// 	fmt.Println(err)
	// 	os.Exit(1)
	// }
	//
	// for {
	// 	select {
	// 	case providerIDs := <-providerIDsIn:
	// 		for _, providerID := range providerIDs {
	// 			fmt.Printf("Provider: %s\n", providerID.Pretty())
	//
	// 			stream, err := corenet.Dial(ipfsNode, providerID, dcConfig.ServiceIdentifier)
	// 			if err != nil {
	// 				fmt.Printf("Failed to dial provider %s (%s)\n", providerID.Pretty(), err)
	// 				continue
	// 			}
	//
	// 			fmt.Fprintf(stream, "Hello! I'm peer %s\n", ipfsNode.Identity.Pretty())
	// 			stream.Close()
	// 		}
	//
	// 	case stream := <-streamIn:
	// 		fmt.Printf("Peer %s called!\n", stream.Conn().RemotePeer().Pretty())
	// 	}
	// }
}
예제 #2
0
파일: main.go 프로젝트: leonfs/romulus
package main

import (
	"fmt"

	"github.com/alecthomas/kingpin"
)

var (
	debug   = kingpin.Flag("debug", "Enable debug mode.").Bool()
	timeout = kingpin.Flag("timeout", "Timeout waiting for ping.").OverrideDefaultFromEnvar("PING_TIMEOUT").Required().Short('t').Duration()
	ip      = kingpin.Arg("ip", "IP address to ping.").Required().IP()
	count   = kingpin.Arg("count", "Number of packets to send").Int()
)

func main() {
	kingpin.Version("0.0.1")
	kingpin.Parse()
	fmt.Printf("Would ping: %s with timeout %s and count %d", *ip, *timeout, *count)
}
예제 #3
0
	"github.com/alecthomas/kingpin"
	"github.com/couchbaselabs/logg"
)

//Config is the serialized config.json file
type Config struct {
	SyncEndpoint string `json:"syncEndpoint"`
	Port         int    `json:"port"`
	Bucket       string `json:"bucket"`
	TTL          int    `json:"ttl"`
}

var (
	configFileDescription = "The name of the config file.  Defaults to 'config.json'"
	configFileName        = kingpin.Arg("config file name", configFileDescription).Default("config.json").String()
	config                Config
	logTag                = "SYNC_AUTH"
)

func init() {
	// parse config file
	kingpin.Parse()
	if *configFileName == "" {
		kingpin.Errorf("Config file name missing")
		return
	}
	configFile, err := os.Open(*configFileName)
	if err != nil {
		logg.LogPanic("Unable to open file: %v.  Err: %v", *configFileName, err.Error())
		return
예제 #4
0
파일: app.go 프로젝트: skarnecki/gotail
	"fmt"
	"net/http"

	"log"

	"os"

	"github.com/alecthomas/kingpin"
	"github.com/gorilla/mux"
	"github.com/skarnecki/gotail/frontend"
	"github.com/skarnecki/gotail/pump"
	"golang.org/x/net/websocket"
)

var (
	filename = kingpin.Arg("filename", "Path to tailed file.").Required().ExistingFile()
	number   = kingpin.Flag("number", "Starting lines number.").Default("10").Int()
	host     = kingpin.Flag("host", "Listening host, default 0.0.0.0").Default("0.0.0.0").IP()
	port     = kingpin.Flag("port", "listening port, default 9001").Default("9001").Int()
	cert     = kingpin.Flag("cert", "path to cert file (HTTPS)").ExistingFile()
	key      = kingpin.Flag("key", "path to key file (HTTPS)").ExistingFile()
	user     = kingpin.Flag("user", "Basic auth user").String()
	password = kingpin.Flag("password", "Basic auth password").String()
)

func main() {
	logger := log.New(os.Stdout, "logger: ", log.Lshortfile)
	kingpin.Parse()
	filechannel := make(chan string, 100)
	go pump.TailFile(filechannel, *filename)
예제 #5
0
package main

import (
	"log"
	"os"
	"os/user"
	"path/filepath"
	"strconv"
	"syscall"

	"github.com/alecthomas/kingpin"
	"github.com/go-fsnotify/fsnotify"
)

var (
	cliDir        = kingpin.Arg("dir", "The directory to enforce permissions.").Required().String()
	cliChownUser  = kingpin.Flag("chown-user", "Name of the user to Chown the directory with.").Required().String()
	cliChownGroup = kingpin.Flag("chown-group", "Name of group to Chown the directory with.").Required().String()
	cliChmodDir   = kingpin.Flag("chmod-dir", "The mode to be assigned to directories.").Default("0775").Int64()
	cliChmodFile  = kingpin.Flag("chmod-file", "The mode to be assigned to files.").Default("0664").Int64()

	uid int
	gid int
)

func main() {
	kingpin.Parse()

	u, err := user.Lookup(*cliChownUser)
	if err != nil {
		panic(err)
예제 #6
0
package main

import (
	"github.com/alecthomas/kingpin"
	"github.com/cathalgarvey/buckfast/scrapedia"
	"github.com/cathalgarvey/buckfast/spritzlib"
	"io/ioutil"
	"log"
	"strings"
)

var (
	infile      = kingpin.Arg("infile", "File to read. If prefixed with 'wikipedia:', fetches the corresponding wikipedia page instead (needs to be exact target page title)").Required().String()
	wpm         = kingpin.Flag("wpm", "Approximate words per minute").Default("400").Short('w').Int()
	pivotColour = kingpin.Flag("pivot-colour", "Preferred pivot colour, one of red, green, blue, yellow, cyan, magenta, white, black.").
			Default("green").
			Short('p').
			Enum("red", "green", "blue", "cyan", "magenta", "yellow", "black", "white")
		//String()
	plainColour = kingpin.Flag("plain-colour", "Preferred non-pivot text colour, one of red, green, blue, yellow, cyan, magenta, white, black.").
			Default("white").
			Short('P').
			Enum("red", "green", "blue", "cyan", "magenta", "yellow", "black", "white")
		//    String()
	bgColour = kingpin.Flag("background-colour", "Text background colour, one of red, green, blue, yellow, cyan, magenta, white, black.").
			Default("").
			Short('b').
			Enum("red", "green", "blue", "cyan", "magenta", "yellow", "black", "white")
		//    String()
	boldText = kingpin.Flag("bold", "Whether to print bold.").Bool()
)
			String()
	keptEnvVars = kingpin.
			Flag("keep-env", "Add this environment variable to the list of variables that will be preserved from the calling process's environment. Defaults to an empty list, except TZ which will be set to \"UTC\".").
			PlaceHolder("VARNAME").
			Strings()
	loglevel = kingpin.
			Flag("loglevel", fmt.Sprintf("Set the desired level of logging (one of: %s).", strings.Join(loglevels, ", "))).
			Default("WARNING").
			Enum(loglevels...)
	logstashPath = kingpin.
			Flag("logstash-path", "Set the path to the Logstash executable.").
			Default("/opt/logstash/bin/logstash").
			String()

	// Arguments
	testcasePath = kingpin.
			Arg("testcases", "Test case file or a directory containing one or more test case files.").
			Required().
			ExistingFileOrDir()
	configPaths = kingpin.
			Arg("config", "Logstash configuration file or a directory containing one or more configuration files.").
			Required().
			ExistingFilesOrDirs()
)

// runTests runs Logstash with a set of configuration files against a
// slice of test cases and compares the actual events against the
// expected set. Returns an error if at least one test case fails or
// if there's a problem running the tests.
func runTests(logstashPath string, tests []testcase.TestCase, configPaths []string, diffCommand []string, keptEnvVars []string) error {
	ok := true
	for _, t := range tests {
예제 #8
0
package main

import (
	"bufio"
	"fmt"
	"github.com/alecthomas/kingpin"
	"github.com/paocalvi/serial"
	"ibus"
	"os"
	"strings"
)

var (
	device = kingpin.Arg("device", "serial device to communicate with").Required().String()
)

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)
	}
예제 #9
0
파일: main.go 프로젝트: sorenmat/botbrother
	"os/signal"
	"strings"
	"syscall"
	"time"

	"github.com/alecthomas/kingpin"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/ec2"
	"github.com/bluele/slack"
)

const filename = "notified.json"

var token = kingpin.Flag("token", "The slack API token").OverrideDefaultFromEnvar("TOKEN").Required().String()
var timeout = kingpin.Arg("wait", "Wait in minutes before checking for changes").Default("10").Int()
var expireTime = kingpin.Arg("expire", "Age in hours before notifing about the instance").Default("48").Int()
var region = kingpin.Arg("region", "Amazon EC2 region to scan for instances").Default("eu-west-1").String()
var prod = kingpin.Flag("prod", "Running for real?").OverrideDefaultFromEnvar("PROD").Default("false").Bool()

func findUser(list []*slack.User, searchid string) string {
	for _, u := range list {
		if u.Id == searchid {
			return u.Id
		}

		if u.Profile.Email != "" {
			data := strings.Split(u.Profile.Email, "@")
			if data[0] == searchid {
				return u.Id
			}
예제 #10
0
파일: main.go 프로젝트: confiks/ipfs-dc
func main() {
	cfg := new(initCfg)
	kingpin.Flag("n", "number of ipfs nodes to initialize").Short('n').IntVar(&cfg.Count)
	kingpin.Flag("port", "port to start allocations from").Default("4002").Short('p').IntVar(&cfg.PortStart)
	kingpin.Flag("force", "force initialization (overwrite existing configs)").Short('f').BoolVar(&cfg.Force)
	kingpin.Flag("mdns", "turn on mdns for nodes").BoolVar(&cfg.Mdns)
	kingpin.Flag("bootstrap", "select bootstrapping style for cluster").Default("star").StringVar(&cfg.Bootstrap)
	kingpin.Flag("utp", "use utp for addresses").BoolVar(&cfg.Utp)

	wait := kingpin.Flag("wait", "wait for nodes to come fully online before exiting").Bool()

	var args []string
	kingpin.Arg("args", "arguments").StringsVar(&args)
	kingpin.Parse()

	if len(args) == 0 {
		kingpin.Usage()
		return
	}

	switch args[0] {
	case "init":
		if cfg.Count == 0 {
			fmt.Printf("please specify number of nodes: '%s init -n 10'\n", os.Args[0])
			os.Exit(1)
		}
		err := IpfsInit(cfg)
		handleErr("ipfs init err: ", err)
	case "start":
		err := IpfsStart(*wait)
		handleErr("ipfs start err: ", err)
	case "stop", "kill":
		if len(args) > 1 {
			i, err := strconv.Atoi(args[1])
			if err != nil {
				fmt.Println("failed to parse node number: ", err)
				os.Exit(1)
			}
			err = KillNode(i)
			if err != nil {
				fmt.Println("failed to kill node: ", err)
			}
			return
		}
		err := IpfsKillAll()
		handleErr("ipfs kill err: ", err)
	case "restart":
		err := IpfsKillAll()
		handleErr("ipfs kill err: ", err)

		err = IpfsStart(*wait)
		handleErr("ipfs start err: ", err)
	case "shell":
		if len(args) < 2 {
			fmt.Println("please specify which node you want a shell for")
			os.Exit(1)
		}
		n, err := strconv.Atoi(args[1])
		handleErr("parse err: ", err)

		err = IpfsShell(n)
		handleErr("ipfs shell err: ", err)
	case "connect":
		if len(args) < 3 {
			fmt.Println("iptb connect [node] [node]")
			os.Exit(1)
		}

		from, err := parseRange(args[1])
		if err != nil {
			fmt.Printf("failed to parse: %s\n", err)
			return
		}

		to, err := parseRange(args[2])
		if err != nil {
			fmt.Printf("failed to parse: %s\n", err)
			return
		}

		for _, f := range from {
			for _, t := range to {
				err = ConnectNodes(f, t)
				if err != nil {
					fmt.Printf("failed to connect: %s\n", err)
					return
				}
			}
		}

	case "get":
		if len(args) < 3 {
			fmt.Println("iptb get [attr] [node]")
			os.Exit(1)
		}
		attr := args[1]
		num, err := strconv.Atoi(args[2])
		handleErr("error parsing node number: ", err)

		val, err := GetAttr(attr, num)
		handleErr("error getting attribute: ", err)
		fmt.Println(val)
	default:
		kingpin.Usage()
		fmt.Println(helptext)
		os.Exit(1)
	}
}
예제 #11
0
파일: kaifa.go 프로젝트: kaifali/cli
package main

import (
	"fmt"
	"os"

	"github.com/alecthomas/kingpin"
	"github.com/parnurzeal/gorequest"
	"github.com/toqueteos/webbrowser"
)

const htmlURL string = "http://kaifa.at/services/"
const jsonURL string = "http://kaifa.at/api/services/"

var (
	keyword = kingpin.Arg("keyword", "Keyword of service").Required().String()
	format  = kingpin.Flag("format", "Format: html,json").Default("html").String()
)

func main() {
	kingpin.Version("0.2.1")
	kingpin.Parse()

	switch *format {
	case "html":
		openBrowser()
	case "json":
		fetchJSON()
	default:
		openBrowser()
	}
예제 #12
0
파일: main.go 프로젝트: joushou/qptools
	"fmt"
	"io/ioutil"
	"net"
	"os"
	"strings"

	"github.com/alecthomas/kingpin"
	"github.com/chzyer/readline"
	"github.com/joushou/qp"
	"github.com/joushou/qptools/client"
)

var (
	service = kingpin.Flag("service", "service name to use when connecting (aname)").Short('s').String()
	user    = kingpin.Flag("user", "username to use when connecting (uname)").Short('u').String()
	address = kingpin.Arg("address", "address to connect to").Required().String()
	command = stringList(kingpin.Arg("command", "command to execute (disables interactive mode)"))
	rawtls  = kingpin.Flag("rawtls", "wrap connection in TLS").Short('t').Bool()
)

type slist []string

func (i *slist) Set(value string) error {
	*i = append(*i, value)
	return nil
}

func (i *slist) String() string {
	return ""
}
예제 #13
0
func Arg(name string, helpOptional ...string) *kingpin.ArgClause {
	help := strings.Join(helpOptional, " ")
	return kingpin.Arg(name, help)
}
예제 #14
0
파일: args.go 프로젝트: sharadmv/metasense
func parseArgs() Args {
	args := Args{}
	args.filename = kingpin.Arg("filename", "Name of file.").Required().String()
	kingpin.Parse()
	return args
}
예제 #15
0
파일: main.go 프로젝트: nyushi/install
import (
	"fmt"
	"os"
	"strconv"

	"github.com/alecthomas/kingpin"
	"github.com/nyushi/install"
)

var (
	owner = kingpin.Flag("owner", "").Short('o').String()
	group = kingpin.Flag("group", "").Short('g').String()
	mode  = kingpin.Flag("mode", "").Short('m').String()
	dir   = kingpin.Flag("directory", "").Short('d').Bool()
	_args = kingpin.Arg("src", "").Strings()
)

func main() {
	kingpin.Parse()

	opt := &install.InstallOption{}
	if *owner != "" {
		opt.Owner = *owner
	}
	if *group != "" {
		opt.Group = *group
	}
	if *mode != "" {
		m, err := strconv.ParseInt(*mode, 8, 32)
		if err != nil {
예제 #16
0
package main

import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"io"
	"os"

	"github.com/alecthomas/kingpin"
)

var (
	inputFile     = kingpin.Arg("source", "Input source file.").Required().String()
	outputFile    = kingpin.Flag("output", "Where the generated code will be written.").Short('o').String()
	packageName   = kingpin.Flag("package", "The output package name.").Short('p').Required().String()
	interfaceName = kingpin.Flag("interface", "The name of the interface that will be wrapped.").Short('i').Required().String()
	constructors  = kingpin.Flag("constructor", "The name of a constructor that will be wrapped.").Short('c').Strings()
)

func main() {
	var err error

	kingpin.Parse()

	parsed, err := parseFile(*inputFile)
	fatalError(err)

	writer := NewAgentWriter(*interfaceName, *packageName, parsed)