func main() {
_, err := docopt.Parse(Usage, nil, true, Version, false)
if err != nil {
log.Fatalf("[error] %s", err)
}
c, err := config.Read(os.Stdin)
if err != nil {
log.Fatalf("[error] parsing config: %s", err)
}
s := server.New(c)
log.Printf("[info] starting sdns %s", Version)
err = s.Start()
if err != nil {
log.Fatalf("[error] %s", err)
}
log.Printf("[info] binding on %s", s.Config.Bind)
gracefully.Shutdown()
log.Printf("[info] stopping")
err = s.Stop()
if err != nil {
log.Fatalf("[error] %s", err)
}
log.Printf("[info] bye :)")
}
func main() {
args, err := docopt.Parse(Usage, nil, true, Version, false)
if err != nil {
log.Fatal("[error] %s", err)
}
topic := args["--topic"].(string)
addr := args["--address"].(string)
nsqd := args["--nsqd-tcp-address"].(string)
log.Printf("starting http_to_nsq %s", Version)
log.Printf("--> binding to %s", addr)
log.Printf("--> publishing to %s as topic %q", nsqd, topic)
prod, err := nsq.NewProducer(nsqd, nsq.NewConfig())
if err != nil {
log.Fatal("[error] starting producer: %s", err)
}
server := &http_to_nsq.Server{
Log: log.New(os.Stderr, "", log.LstdFlags),
Secret: args["--secret"].(string),
Topic: "builds",
Publisher: prod,
}
err = http.ListenAndServe(addr, server)
if err != nil {
log.Fatal("[error] binding: %s", err)
}
}
func main() {
args, err := docopt.Parse(Usage, nil, true, Version, false)
log.Check(err)
log.Info("starting system %s", Version)
client, err := statsd.Dial(args["--statsd-address"].(string))
log.Check(err)
extended := args["--extended"].(bool)
name := args["--name"].(string)
if "hostname" == name {
host, err := os.Hostname()
log.Check(err)
name = host
}
c := collector.New(namespace.New(client, name))
c.Add(memory.New(interval(args, "--memory-interval"), extended))
c.Add(cpu.New(interval(args, "--cpu-interval"), extended))
c.Add(disk.New(interval(args, "--disk-interval")))
c.Start()
Shutdown()
c.Stop()
}
func main() {
args, err := docopt.Parse(usage, nil, true, version, true)
if err != nil {
cli.Fatalf("error parsing arguments: %s", err)
}
file := args["--config"].(string)
c, err := config.New(file)
if err != nil {
cli.Fatalf("error loading configuration: %s", err)
}
switch {
case args["help"].(bool):
if name, ok := args["<task>"].(string); ok {
cli.Help(c, name)
} else {
cli.List(c)
}
case args["variables"].(bool):
cli.ListVariables(c)
default:
if name, ok := args["<task>"].(string); ok {
cli.Run(c, name, args["<arg>"].([]string))
} else {
cli.List(c)
}
}
}
func main() {
args, err := docopt.Parse(usage, nil, true, version, false)
if err != nil {
log.Fatalf("error: %s", err)
}
log.SetHandler(cli.Default)
if l, err := log.ParseLevel(args["--log-level"].(string)); err == nil {
log.SetLevel(l)
}
if args["help"].(bool) {
showHelp(args["<topic>"])
return
}
session := session.New(aws.NewConfig())
project := &project.Project{
Log: log.Log,
Path: ".",
}
if args["--dry-run"].(bool) {
log.SetLevel(log.WarnLevel)
project.Service = dryrun.New(session)
project.Concurrency = 1
} else {
project.Service = lambda.New(session)
}
if dir, ok := args["--chdir"].(string); ok {
if err := os.Chdir(dir); err != nil {
log.Fatalf("error: %s", err)
}
}
if err := project.Open(); err != nil {
log.Fatalf("error opening project: %s", err)
}
switch {
case args["list"].(bool):
list(project)
case args["deploy"].(bool):
deploy(project, args["<name>"].([]string), args["--env"].([]string))
case args["delete"].(bool):
delete(project, args["<name>"].([]string), args["--yes"].(bool))
case args["invoke"].(bool):
invoke(project, args["<name>"].([]string), args["--verbose"].(bool), args["--async"].(bool))
case args["rollback"].(bool):
rollback(project, args["<name>"].([]string), args["<version>"])
case args["build"].(bool):
build(project, args["<name>"].([]string))
case args["logs"].(bool):
tail(project, args["<name>"].([]string), args["--filter"].(string))
}
}
func run(argv []string, in io.Reader, out io.Writer) {
arguments, err := docopt.Parse(usage, argv, true, version, false)
check(err)
indent, err := strconv.Atoi(arguments["--indentation"].(string))
check(err)
DiLaurentis(in, out, indent)
}
func main() {
args, err := docopt.Parse(Usage, nil, true, Version, false)
if err != nil {
log.Fatalf("error: %s", err)
}
log.Printf("starting nsq_to_postgres version %s", Version)
// Read config
file := args["--config"].(string)
b, err := ioutil.ReadFile(file)
if err != nil {
log.Fatalf("error reading config: %s", err)
}
// Unmarshal config
config := new(Config)
err = yaml.Unmarshal(b, config)
if err != nil {
log.Fatalf("error unmarshalling config: %s", err)
}
// Validate config
err = config.Postgres.Validate()
if err != nil {
log.Fatalf("configuration error: %s", err)
}
// Apply nsq config
c := queue.NewConsumer("", "nsq_to_postgres")
for k, v := range config.Nsq {
c.Set(k, v)
}
// Connect
log.Printf("connecting to postgres")
db, err := client.New(config.Postgres)
if err != nil {
log.Fatalf("error connecting: %s", err)
}
// Bootstrap with table
err = db.Bootstrap()
if err != nil {
log.Printf("error bootstrapping: %s", err)
}
// Start consumer
log.Printf("starting consumer")
c.Start(handler.New(db))
gracefully.Shutdown()
log.Printf("stopping consumer")
c.Stop()
log.Printf("bye :)")
}
func main() {
arguments, err := docopt.Parse(Usage, nil, true, Version, false)
check(err)
words := arguments["<word>"].([]string)
for _, w := range words {
Spell(w)
fmt.Println()
}
}
func main() {
args, err := docopt.Parse(Usage, nil, true, Version, true)
if err != nil {
Fatalf("Failed to parse arguments: %s", err)
}
if args["--template-file"] == nil && args["--template-data"] == nil {
fmt.Println(Usage)
return
}
Run(
args["<key=value>"].([]string),
getPipedString(),
getStringFromInterface(args["--template-file"]),
getStringFromInterface(args["--template-data"]),
)
}
func main() {
args, err := docopt.Parse(usage, nil, true, version, false)
if err != nil {
log.Fatalf("error parsing arguments: %s", err)
}
file := args["<file>"].(string)
c, err := config.New(file)
if err != nil {
log.Fatalf("error loading configuration: %s", err)
}
log.Printf("starting monitor")
watch.NewMonitor(c).Start()
gracefully.Shutdown()
log.Printf("stopping monitor")
}
func main() {
arguments, err := docopt.Parse(usage, nil, true, version, false)
check(err)
hnClient := hn.New()
instapaperClient := instapaper.New(arguments["<username>"].(string), arguments["<password>"].(string))
limit, err := strconv.Atoi(arguments["--limit"].(string))
check(err)
stories, err := hnClient.TopStories()
check(err)
s := semaphore.New(10)
var wg sync.WaitGroup
for i, id := range stories {
if i >= limit {
break
}
wg.Add(1)
s.Acquire(1)
go func(id int) {
defer wg.Done()
defer s.Release(1)
story, err := hnClient.GetPost(id)
check(err)
if story.URL == nil {
fmt.Println("Skipping", *story.Title)
return
}
_, err = instapaperClient.Add(instapaper.AddParams{
URL: *story.URL,
Title: story.Title,
})
check(err)
fmt.Println("Saved", *story.Title)
}(id)
}
wg.Wait()
}
func main() {
arguments, err := docopt.Parse(Usage, nil, true, Version, false)
check(err)
cmd := arguments["<cmd>"].(string)
args := arguments["<args>"].([]string)
iterations := parseInt(arguments["--iterations"].(string))
parallel := arguments["--parallel"].(bool)
fmt.Println("Running", cmd, args, iterations, "times.")
if parallel {
executeParallel(iterations, cmd, args...)
} else {
executeSerial(iterations, cmd, args...)
}
fmt.Println()
fmt.Println("Completed", iterations, "iterations without any errors.")
}
func main() {
arguments, err := docopt.Parse(usage, nil, true, version, false)
check(err)
config := readConfig(arguments)
f, err := os.Create("config.json")
check(err)
defer f.Close()
b, err := json.Marshal(config)
check(err)
// Prettifying is not required, but makes it easier for humans to read.
var buf bytes.Buffer
err = json.Indent(&buf, b, " ", "\t")
check(err)
_, err = buf.WriteTo(f)
check(err)
}
func main() {
usage := `9pmount
Usage:
9pmount <mount_point> (--address <address>)
Options:
-h --help Show this screen.
--version Show version.
--address Address of 9pserver`
args, err := docopt.Parse(usage, nil, true, "9pmount 0.1", false)
mount_point := args["<mount_point>"].(string)
address = args["<address>"].(string)
nfs := pathfs.NewPathNodeFs(&P9Fs{FileSystem: pathfs.NewDefaultFileSystem()}, nil)
server, _, err := nodefs.MountRoot(mount_point, nfs.Root(), nil)
if err != nil {
log.Fatalf("Mount fail: %v\n", err)
}
server.Serve()
}
func main() {
arguments, err := docopt.Parse(Usage, nil, true, Version, false)
check(err)
owner := arguments["<owner>"].(string)
repo := arguments["<repo>"].(string)
token := arguments["<token>"].(string)
initializeClient(token)
contributors := getContributors(owner, repo)
names := getNames(contributors)
percentFemale, percentMale := predictGenderStats(names)
percentUnknown := (100 - percentFemale - percentMale)
fmt.Println("\nContributors by Gender:")
fmt.Printf("\n - Female: %.2f%%\n", percentFemale)
fmt.Printf("\n - Male: %.2f%%\n", percentMale)
fmt.Printf("\n - Unknown: %.2f%%\n\n", percentUnknown)
}
func main() {
args, err := docopt.Parse(usage, nil, true, version, false)
if err != nil {
log.Fatal(err)
}
region := args["--region"].(string)
bucket := args["<bucket>"].(string)
file := args["<file>"].(string)
cfg := &ls.Config{
Bucket: bucket,
Region: region,
}
files, err := ls.List(file, cfg)
if err != nil {
log.Fatal(err)
}
listFiles(files)
}
func main() {
args, err := docopt.Parse(usage, nil, true, version, true)
if err != nil {
fatalf("Failed to parse arguments: %v\n%v", args, err)
}
var file, dir string
fileOrDir := resolvePath(args["<file-or-directory>"].(string))
stat, err := os.Stat(fileOrDir)
if os.IsNotExist(err) {
fatalf("No such file or directory: %v\n%v", fileOrDir, err)
}
if stat.IsDir() {
dir = fileOrDir
} else {
file = fileOrDir
dir = filepath.Dir(file)
}
if args["--output-directory"] == nil {
args["--output-directory"] = dir
}
if args["--schema-directory"] == nil {
args["--schema-directory"] = dir
}
cli := &Cli{
dir: dir,
file: file,
outputDir: resolvePath(args["--output-directory"].(string)),
schemaDir: resolvePath(args["--schema-directory"].(string)),
encoding: args["--encoding"].(string),
fixEncoding: args["--fix-encoding"].(bool),
noOutputFile: args["--no-output-file"].(bool),
outputSchema: args["--output-schema"].(bool),
skipValidation: args["--skip-validation"].(bool),
}
cli.run()
}
func main() {
arguments, err := docopt.Parse(Usage, nil, true, "Anaytics Go CLI", false)
check(err)
writeKey := getOptionalString(arguments, "--writeKey")
if writeKey == "" {
writeKey = os.Getenv("SEGMENT_WRITE_KEY")
if writeKey == "" {
log.Fatal("either $SEGMENT_WRITE_KEY or --writeKey must be provided")
}
}
client := analytics.New(writeKey)
client.Size = 1
client.Verbose = true
if arguments["track"].(bool) {
m := &analytics.Track{
Event: arguments["<event>"].(string),
}
properties := getOptionalString(arguments, "--properties")
if properties != "" {
var parsedProperties map[string]interface{}
err := json.Unmarshal([]byte(properties), &parsedProperties)
check(err)
m.Properties = parsedProperties
}
setCommonFields(m, arguments)
check(client.Track(m))
}
if arguments["screen"].(bool) || arguments["page"].(bool) {
m := &analytics.Page{
Name: arguments["<name>"].(string),
}
/* Bug in Go library - page has traits not properties.
properties := getOptionalString(arguments, "--properties")
if properties != "" {
var parsedProperties map[string]interface{}
err := json.Unmarshal([]byte(properties), &parsedProperties)
check(err)
t.Properties = parsedProperties
}
*/
setCommonFields(m, arguments)
check(client.Page(m))
}
if arguments["identify"].(bool) {
m := &analytics.Identify{}
traits := getOptionalString(arguments, "--traits")
if traits != "" {
var parsedTraits map[string]interface{}
err := json.Unmarshal([]byte(traits), &parsedTraits)
check(err)
m.Traits = parsedTraits
}
setCommonFields(m, arguments)
check(client.Identify(m))
}
if arguments["group"].(bool) {
m := &analytics.Group{
GroupId: arguments["--groupId"].(string),
}
traits := getOptionalString(arguments, "--traits")
if traits != "" {
var parsedTraits map[string]interface{}
err := json.Unmarshal([]byte(traits), &parsedTraits)
check(err)
m.Traits = parsedTraits
}
setCommonFields(m, arguments)
check(client.Group(m))
}
if arguments["alias"].(bool) {
m := &analytics.Alias{
PreviousId: arguments["--previousId"].(string),
}
setCommonFields(m, arguments)
check(client.Alias(m))
}
client.Close()
}
func main() {
m, err := docopt.Parse(Usage, nil, true, Version, false)
if err != nil {
logrus.Fatal(err)
}
if m["--debug"].(bool) {
logrus.SetLevel(logrus.DebugLevel)
}
if m["--json-log"].(bool) {
logrus.SetFormatter(logrus_ecslogs.NewFormatter())
}
concurrency, err := strconv.Atoi(m["--concurrency"].(string))
if err != nil {
logrus.Fatal(err)
}
// Load and validate DB configuration.
config := &mongodb.Config{
Init: m["--init"].(bool),
Hostname: m["--hostname"].(string),
Port: m["--port"].(string),
Username: m["--username"].(string),
Password: m["--password"].(string),
Database: m["--database"].(string),
}
_, err = govalidator.ValidateStruct(config)
if err != nil {
logrus.Error(err)
return
}
// If in init mode, save list of collections to schema file. Users will then have to modify the
// file and fill in fields they want to export to their Segment warehouse.
fileName := m["--schema"].(string)
if config.Init {
mongodb.InitSchema(config, fileName)
return
}
// Build Segment client and define publish function for when we scan over the collections.
writeKey := m["--write-key"].(string)
if writeKey == "" {
logrus.Fatal("Write key is required when not in init mode.")
}
description, err := mongodb.ParseSchema(fileName)
if err == io.EOF {
logrus.Error("Empty schema, did you run `--init`?")
} else if err != nil {
logrus.Fatal("Unable to parse schema", err)
}
segmentClient := objects.New(writeKey)
defer segmentClient.Close()
setWrapperFunc := func(o *objects.Object) {
err := segmentClient.Set(o)
if err != nil {
logrus.WithFields(logrus.Fields{"id": o.ID, "collection": o.Collection, "properties": o.Properties}).Warn(err)
}
}
logrus.Info("[%v] Mongo source started with writeKey ", Version, writeKey)
if err := mongodb.Run(config, description, concurrency, setWrapperFunc); err != nil {
logrus.Error("mongodb source failed to complete", err)
os.Exit(1)
}
}
func Run(d driver.Driver) {
app := &driver.Base{d}
m, err := docopt.Parse(usage, nil, true, Version, false)
if err != nil {
logrus.Error(err)
return
}
segmentClient := objects.New(m["--write-key"].(string))
setWrapper := func(o *objects.Object) {
if err := segmentClient.Set(o); err != nil {
logrus.WithFields(logrus.Fields{"id": o.ID, "collection": o.Collection, "properties": o.Properties}).Warn(err)
}
}
config := &domain.Config{
Init: m["--init"].(bool),
Hostname: m["--hostname"].(string),
Port: m["--port"].(string),
Username: m["--username"].(string),
Password: m["--password"].(string),
Database: m["--database"].(string),
ExtraOptions: m["<extra-driver-options>"].([]string),
}
if m["--debug"].(bool) {
logrus.SetLevel(logrus.DebugLevel)
}
concurrency, err := strconv.Atoi(m["--concurrency"].(string))
if err != nil {
logrus.Error(err)
return
}
// Validate the configuration
if _, err := govalidator.ValidateStruct(config); err != nil {
logrus.Error(err)
return
}
// Open the schema
schemaFile, err := os.OpenFile(m["--schema"].(string), os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
logrus.Error(err)
return
}
defer schemaFile.Close()
if err := app.Driver.Init(config); err != nil {
logrus.Error(err)
return
}
// Initialize the source
if config.Init {
description, err := app.Driver.Describe()
if err != nil {
logrus.Error(err)
return
}
if err := description.Save(schemaFile); err != nil {
logrus.Error(err)
return
}
schemaFile.Sync()
logrus.Infof("Saved to `%s`", schemaFile.Name())
return
}
description, err := domain.NewDescriptionFromReader(schemaFile)
if err == io.EOF {
logrus.Error("Empty schema, did you run `--init`?")
return
} else if err != nil {
logrus.Error(err)
return
}
sem := make(semaphore.Semaphore, concurrency)
for table := range description.Iter() {
sem.Acquire()
go func(table *domain.Table) {
defer sem.Release()
logrus.WithFields(logrus.Fields{"table": table.TableName, "schema": table.SchemaName}).Info("Scan started")
if err := app.ScanTable(table, setWrapper); err != nil {
logrus.Error(err)
}
logrus.WithFields(logrus.Fields{"table": table.TableName, "schema": table.SchemaName}).Info("Scan finished")
}(table)
}
sem.Wait()
segmentClient.Close()
// Log status
for table := range description.Iter() {
logrus.WithFields(logrus.Fields{"schema": table.SchemaName, "table": table.TableName, "count": table.State.ScannedRows}).Info("Sync Finished")
}
}
