Example #1
0
func main() {
	goptions.ParseAndFail(&options)

	log.Printf("Connecting to mongodb on %s...", options.MongoDB)
	session, err := mgo.Dial(options.MongoDB.String())
	if err != nil {
		log.Fatalf("Could not connect to %s: %s", options.MongoDB, err)
	}
	defer session.Close()
	db := session.DB("") // Use database specified in URL
	usermgr := &MongoUserManager{db.C("users")}
	domainmgr := &MongoDomainManager{db.C("domains")}

	mainrouter := mux.NewRouter()
	approuter := mainrouter.Host(options.Hostname).Subrouter()
	authrouter := approuter.PathPrefix("/auth").Subrouter()
	apirouter := approuter.PathPrefix("/api").Subrouter()

	setupAuthApps(authrouter, usermgr)
	setupApiApps(apirouter, domainmgr, usermgr)

	approuter.PathPrefix("/").Handler(http.FileServer(http.Dir(options.StaticDir)))
	mainrouter.PathPrefix("/").Handler(&Metapage{domainmgr})
	log.Printf("Running webserver...")
	log.Fatalf("Failed to run webserver: %s",
		http.ListenAndServe(options.ListenAddress.String(), mainrouter))
}
Example #2
0
func main() {
	log.Infof("starting schema...")

	options := struct {
		Driver string `goptions:"-t,--type, obligatory, description='Type of database backend'"`
		DSN    string `goptions:"-d,--database, obligatory, description='DSN of the database backend'"`
	}{
	// No defaults
	}
	goptions.ParseAndFail(&options)

	database := &db.DB{
		Driver: options.Driver,
		DSN:    options.DSN,
	}

	log.Debugf("connecting to %s database at %s", database.Driver, database.DSN)
	if err := database.Connect(); err != nil {
		log.Errorf("failed to connect to %s database at %s: %s",
			database.Driver, database.DSN, err)
	}

	if err := database.Setup(); err != nil {
		log.Errorf("failed to set up schema in %s database at %s: %s",
			database.Driver, database.DSN, err)
		return
	}

	log.Infof("deployed schema version %d", db.CurrentSchema)
}
Example #3
0
func main() {
	opts := &Options{}
	goptions.ParseAndFail(opts)

	// Print version number and exit if the version flag is set
	if opts.Version {
		fmt.Printf("gandi-operation v%s\n", shared.VersionNumber)
		return
	}

	// Get gandi client
	client := shared.NewGandiClient(opts.ConfigPath, opts.Testing)

	// Create api and operation instances
	api := api.New(client)
	operation := cli.New(api)

	switch opts.Verbs {
	case "count":
		operation.Count()

	case "list":
		operation.List()

	case "info":
		operation.Info(opts.Info.Operation)

	case "cancel":
		operation.Cancel(opts.Cancel.Operation)

	default:
		goptions.PrintHelp()
	}
}
Example #4
0
func main() {
	xlog.SetOutput(os.Stdout)

	options := struct {
		Topic   string `goptions:"--topic, description='Topic', obligatory"`
		Channel string `goptions:"--channel, description='Channel', obligatory"`
		Lookupd string `goptions:"--lookupd, description='lookupd address', obligatory"`
		DSN     string `goptions:"--dsn, description='MySQL DSN string', obligatory"`
	}{}

	goptions.ParseAndFail(&options)

	sqldb, err := sql.Open("mysql", options.DSN)
	if err != nil {
		xlog.Fatalf("sql.Open failed: %v", err)
	}

	r, err := nsq.NewReader(options.Topic, options.Channel)
	if err != nil {
		xlog.Fatalf("Opening reader for %s/%s failed: %v", options.Topic, options.Channel, err)
	}

	r.AddHandler(&Converter{DB: sqldb})

	if err := r.ConnectToLookupd(options.Lookupd); err != nil {
		xlog.Errorf("Connecting to %s failed: %v", options.Lookupd, err)
	}

	select {}
}
func main() {
	opts := &Options{}
	goptions.ParseAndFail(opts)

	// Print version number and exit if the version flag is set
	if opts.Version {
		fmt.Printf("gandi-domain-zone-record v%s\n", shared.VersionNumber)
		return
	}

	// Get gandi client
	client := shared.NewGandiClient(opts.ConfigPath, opts.Testing)

	// Create api and zone instances
	api := api.New(client)
	record := cli.New(api)

	switch opts.Verbs {
	case "count":
		record.Count(opts.Count.Zone, opts.Count.Version)

	case "list":
		record.List(opts.List.Zone, opts.List.Version)

	case "add":
		record.Add(opts.Add)

	case "delete":
		args := opts.Delete
		record.Delete(args.Zone, args.Version, args.Record)

	default:
		goptions.PrintHelp()
	}
}
func main() {
	options := Options{}

	goptions.ParseAndFail(&options)

	if options.Version {
		fmt.Printf("github-release v%s\n", VERSION)
		return
	}

	if len(options.Verbs) == 0 {
		goptions.PrintHelp()
		return
	}

	VERBOSITY = len(options.Verbosity)

	if cmd, found := commands[options.Verbs]; found {
		err := cmd(options)
		if err != nil {
			if !options.Quiet {
				fmt.Fprintln(os.Stderr, "error:", err)
			}
			os.Exit(1)
		}
	}
}
Example #7
0
func main() {
	opts := &Options{}
	goptions.ParseAndFail(opts)

	// Print version number and exit if the version flag is set
	if opts.Version {
		fmt.Printf("gandi-contact v%s\n", shared.VersionNumber)
		return
	}

	// Get gandi client
	client := shared.NewGandiClient(opts.ConfigPath, opts.Testing)

	// Create api and cli instances
	api := api.New(client)
	contact := cli.New(api)

	switch opts.Verbs {
	case "balance":
		contact.Balance()

	case "info":
		contact.Info(opts.Info.Contact)

	case "create":
		contact.Create(opts.Create)

	case "delete":
		contact.Delete(opts.Delete.Contact)

	default:
		goptions.PrintHelp()
	}
}
Example #8
0
func init() {
	goptions.ParseAndFail(&options)
	options.OutputDir = filepath.Clean(options.OutputDir + "/iowhip_" + Timestamp)

	cleanupc := make(chan os.Signal)
	signal.Notify(cleanupc, syscall.SIGTERM, syscall.SIGKILL, syscall.SIGINT)
	go func() {
		<-cleanupc
		cleanup()
	}()
}
Example #9
0
File: main.go Project: fg1/mugiss
func main() {
	daddr, err := net.ResolveTCPAddr("tcp", "0.0.0.0:8080")
	if err != nil {
		log.Fatal(err)
	}

	options := struct {
		CityFiles     []string      `goptions:"-d, description='Data files to load'"`
		CountryNames  string        `goptions:"-c, description='CSV file holding country names'"`
		CountryShapes string        `goptions:"-c, description='CSV file holding country shapes'"`
		Help          goptions.Help `goptions:"-h, --help, description='Show this help'"`
		ListenAddr    *net.TCPAddr  `goptions:"-l, --listen, description='Listen address for HTTP server'"`
	}{
		CountryNames:  "data/countries_en.csv",
		CountryShapes: "data/countries.csv.bz2",
		ListenAddr:    daddr,
	}
	goptions.ParseAndFail(&options)

	rt_countries = rtreego.NewTree(2, 10, 20)
	_, err = load_freegeodb_countries_csv(rt_countries, options.CountryShapes)
	if err != nil {
		log.Fatal(err)
	}

	countries_exp, err = load_country_names(options.CountryNames)
	if err != nil {
		log.Fatal(err)
	}

	rt = rtreego.NewTree(2, 25, 50)
	total_loaded_cities := 0
	start_t := time.Now()
	for _, fname := range options.CityFiles {
		loaded, err := load_gisgraphy_cities_csv(rt, fname)
		if err != nil {
			log.Fatal(err)
		}
		total_loaded_cities += loaded
	}
	if total_loaded_cities > 0 {
		log.Println("Loaded", total_loaded_cities, "cities in", time.Now().Sub(start_t))
	}

	log.Println("Starting HTTP server on", options.ListenAddr)
	http.HandleFunc("/rg/", reverseGeocodingHandler)
	http.HandleFunc("/gj/", serveGeoJson)
	http.Handle("/", http.FileServer(http.Dir("html")))
	err = http.ListenAndServe(options.ListenAddr.String(), nil)
	if err != nil {
		log.Fatal(err)
	}
}
Example #10
0
func main() {
	goptions.ParseAndFail(&options)

	for _, m := range options.Maps {
		h := m.Handler
		http.Handle(m.Path, http.StripPrefix(m.Path, h))
	}
	log.Printf("Starting webserver on %s...", options.Listen)
	err := http.ListenAndServe(options.Listen, nil)
	if err != nil {
		log.Fatalf("Could not start webserver: %s", err)
	}
}
Example #11
0
func main() {

	options := struct {
		Zone  string        `goptions:"-z, --zone, description='The zone to use'"`
		Token string        `goptions:"--token, description='The token for the CF API'"`
		Email string        `goptions:"--email, description='The email for the CF API'"`
		Help  goptions.Help `goptions:"-h, --help, description='Show this help'"`

		goptions.Verbs
		Add struct {
			Content string `goptions:"-c, --content, obligatory, description='The content for the record'"`
			Name    string `goptions:"-n, --name, obligatory, description='The name of the record'"`
			Type    string `goptions:"-t, --type, description='The type of the record'"`
		} `goptions:"add"`

		Delete struct {
			Content          string `goptions:"-c, --content, obligatory, description='The content for the record'"`
			SkipConfirmation bool   `goptions:"-y, --yes, description='Skip confirmation'"`
		} `goptions:"delete"`
	}{
		Zone:  os.Getenv(CFZone),
		Email: os.Getenv(CFEmail),
		Token: os.Getenv(CFToken),
	}

	goptions.ParseAndFail(&options)

	opts := Options{
		Email: options.Email,
		Token: options.Token,
		Zone:  options.Zone,
	}

	switch {
	case options.Verbs == "add":
		opts.Content = options.Add.Content
		opts.Name = options.Add.Name
		opts.Type = options.Add.Type

		addRecord(&opts)
	case options.Verbs == "delete":
		opts.Content = options.Delete.Content
		opts.SkipConfirm = options.Delete.SkipConfirmation

		deleteRecords(&opts)
	}
}
Example #12
0
func init() {
	options = Options{
		Env: "dev",
	}
	goptions.ParseAndFail(&options)

	if len(options.RootDir) > 0 {
		rootDir = options.RootDir
	} else {
		var err error
		if rootDir, err = filepath.Abs(fmt.Sprintf("%s/../resources/", filepath.Dir(os.Args[0]))); err != nil {
			panic(err)
		}
		options.RootDir = rootDir
	}

	configPath := fmt.Sprintf("%s/config.%s.yml", RootDir(), options.Env)

	config = new(Config)
	if cfgBytes, err := ioutil.ReadFile(configPath); err != nil {
		panic(err)
	} else {
		err := yaml.Unmarshal([]byte(cfgBytes), &config)
		if err != nil {
			panic(err)
		}
	}

	switch GetConfig().Logger.Writer {
	case LOGGER_WRITER_STD_OUT:
		logger = log.NewLogger(log.NewConcurrentWriter(os.Stdout), GetConfig().Logger.Namespace)
	case LOGGER_WRITER_SYSLOG:
		writer, _ := syslog.New(syslog.LOG_DEBUG|syslog.LOG_LOCAL0, GetConfig().Logger.Namespace)
		logger = log.NewLogger(log.NewConcurrentWriter(writer), GetConfig().Logger.Namespace)
	default:
		panic(errors.New(fmt.Sprintf("Unknown logger writer %s", GetConfig().Logger.Writer)))
	}
	logger.SetLevel(log.LevelAtoi[GetConfig().Logger.Level])
	GetLogger().Info("Initializing application", "ver", VERSION)

	hasher := md5.New()
	hasher.Write([]byte(time.Now().Format("2006/01/02 - 15:04:05")))
	instanceId = hex.EncodeToString(hasher.Sum(nil))[:5]
	GetLogger().Info("Initialized application", "instance ID", instanceId)
}
Example #13
0
func main() {
	goptions.ParseAndFail(&options)

	// Use current directory by default
	if options.RootDir == "" {
		options.RootDir = os.Getenv("PWD")
	}

	options.RootDir = strings.TrimRight(options.RootDir, "/")

	fmt.Printf("%+v\n", options)

	err := rename(options.RootDir, options.OldPattern, options.NewPattern)

	if err != nil {
		fmt.Println(err)
	}
}
Example #14
0
// Application entry point
func main() {

	fmt.Printf("\n%s (%s) %s\n\n", APP_TITLE, APP_NAME, APP_VERSION)

	// Set the default values for the command line options
	opt = new(Options)
	opt.Server = DEFAULT_SERVER
	opt.Format = FORMAT_ALL
	opt.BatchSize = BATCH_SIZE

	goptions.ParseAndFail(opt)

	// Lets make sure that the users input file actually exists
	if _, err := os.Stat(opt.InputFile); os.IsNotExist(err) {
		log.Fatal("Input file does not exist")
	}

	processInputFile()
}
Example #15
0
func main() {
	goptions.ParseAndFail(&options)
	//fmt.Printf("] %#v\r\n", options)

	if len(options.Verbs) == 0 {
		fmt.Printf("%s%s \n      built on %s\n\n", progname, progdesc, buildTime)
		goptions.PrintHelp()
		os.Exit(2)
	}

	VERBOSITY = len(options.Verbosity)

	configGet(os.Args[0])

	if cmd, found := commands[options.Verbs]; found {
		err := cmd(options)
		check(err)
	}
}
Example #16
0
func main() {
	goptions.ParseAndFail(&options)

	if len(options.Verbs) == 0 {
		goptions.PrintHelp()
		os.Exit(2)
	}

	VERBOSITY = len(options.Verbosity)

	if cmd, found := commands[options.Verbs]; found {
		err := cmd(options)
		if err != nil {
			if !options.Quiet {
				fmt.Println("error:", err)
			}
			os.Exit(1)
		}
	}
}
Example #17
0
func main() {
	goptions.ParseAndFail(&options)

	goriot.SetAPIKey(options.APIKey)

	session, err := mgo.Dial(options.MongoDB)
	if err != nil {
		log.Fatalf("Could not connect to MongoDB: %s", err)
	}
	db = session.DB("")

	r := httptools.NewRegexpSwitch(map[string]http.Handler{
		"/([a-z]+)/([0-9]+)/parse": httptools.L{
			httptools.SilentHandler(http.HandlerFunc(whitelistHandler)),
			httptools.L{
				httptools.SilentHandler(http.HandlerFunc(parseMatchHistory)),
				http.HandlerFunc(dumpMatchHistory),
			},
		},
		"/([a-z]+)/([0-9]+)": httptools.L{
			httptools.SilentHandler(http.HandlerFunc(whitelistHandler)),
			httptools.MethodSwitch{
				"POST": httptools.L{
					httptools.SilentHandler(http.HandlerFunc(parseMatchHistory)),
					http.HandlerFunc(saveMatchHistory),
				},
				"GET": httptools.L{
					httptools.SilentHandler(http.HandlerFunc(queryMatchHistory)),
					http.HandlerFunc(dumpMatchHistory),
				},
			},
		},
		"/.*": http.FileServer(http.Dir(options.StaticContent)),
	})

	addr := fmt.Sprintf("0.0.0.0:%d", options.Port)
	log.Printf("Starting webserver on %s...", addr)
	if err := http.ListenAndServe(addr, r); err != nil {
		log.Fatalf("Could not start webserver: %s", err)
	}
}
Example #18
0
func main() {
	options := struct {
		Server   string        `goptions:"-s, --server, obligatory, description='Server to connect to'"`
		Password string        `goptions:"-p, --password, description='Don\\'t prompt for password'"`
		Timeout  time.Duration `goptions:"-t, --timeout, description='Connection timeout in seconds'"`
		Help     goptions.Help `goptions:"-h, --help, description='Show this help'"`

		goptions.Verbs
		Execute struct {
			Command string   `goptions:"--command, mutexgroup='input', description='Command to exectute', obligatory"`
			Script  *os.File `goptions:"--script, mutexgroup='input', description='Script to exectute', rdonly"`
		} `goptions:"execute"`
		Delete struct {
			Path  string `goptions:"-n, --name, obligatory, description='Name of the entity to be deleted'"`
			Force bool   `goptions:"-f, --force, description='Force removal'"`
		} `goptions:"delete"`
	}{ // Default values goes here
		Timeout: 10 * time.Second,
	}
	goptions.ParseAndFail(&options)
}
Example #19
0
func main() {
	log.SetFlags(log.Ltime | log.Lshortfile)

	goptions.ParseAndFail(&options)
	//fmt.Printf("] %#v\r\n", options)

	if len(options.Verbs) == 0 {
		goptions.PrintHelp()
		os.Exit(2)
	}

	VERBOSITY = len(options.Verbosity)

	messageIds = make(map[string]bool)
	messageFetchMode = options.Verbs == "fetch"
	if cmd, found := commands[options.Verbs]; found {
		err := cmd(options)
		check(err)
	}

}
Example #20
0
func main() {
	opts := &Options{}
	goptions.ParseAndFail(opts)

	// Print version number and exit if the version flag is set
	if opts.Version {
		fmt.Printf("gandi-domain-zone v%s\n", shared.VersionNumber)
		return
	}

	// Get gandi client
	client := shared.NewGandiClient(opts.ConfigPath, opts.Testing)

	// Create api and zone instances
	api := api.New(client)
	zone := cli.New(api)

	switch opts.Verbs {
	case "count":
		zone.Count()

	case "list":
		zone.List()

	case "info":
		zone.Info(opts.Info.Zone)

	case "create":
		zone.Create(opts.Create.Name)

	case "delete":
		zone.Delete(opts.Delete.Zone)

	case "set":
		zone.Set(opts.Set.Domain, opts.Set.Zone)

	default:
		goptions.PrintHelp()
	}
}
Example #21
0
func main() {
	goptions.ParseAndFail(&options)
	//fmt.Printf("] %#v\r\n", options)

	if len(options.Verbs) == 0 {
		fmt.Printf("%s%s \n      built on %s\n\n", progname, progdesc, buildTime)
		goptions.PrintHelp()
		os.Exit(2)
	}

	VERBOSITY = len(options.Verbosity)

	if cmd, found := commands[options.Verbs]; found {
		err := cmd()
		if err != nil {
			if !options.Quiet {
				fmt.Printf("%s error: %v", progname, err)
			}
			os.Exit(1)
		}
	}
}
Example #22
0
func main() {
	goptions.ParseAndFail(&options)

	session, err := mgo.Dial(options.MongoURL.String())
	if err != nil {
		log.Fatalf("Could not connect to mongodb: %s", err)
	}
	options.ConsistencyMode.Apply(session)

	gfs := session.DB("").GridFS(options.CollectionPrefix)

	log.Printf("Starting server...")
	http.Handle("/",
		sabercat.NewCache(options.CacheTime,
			http.StripPrefix(options.HttpPrefix,
				AddPrefix(options.GridfsPrefix,
					http.FileServer(sabercat.GridDir{
						GridFS:     gfs,
						StripSlash: options.StripSlash,
					})))))
	log.Fatalf("ListenAndServe: %s", http.ListenAndServe(options.Address.String(), nil))
}
Example #23
0
func main() {
	goptions.ParseAndFail(&options)
	defer options.KeyFile.Close()
	pemBytes, err := ioutil.ReadAll(options.KeyFile)
	if err != nil {
		log.Fatalf("Could not read keyfile: %s", err)
	}

	token := jwt.NewToken(options.ClientId, storage.DevstorageRead_writeScope, pemBytes)
	// token.ClaimSet.Aud = aud
	c := &http.Client{}
	oauthToken, err := token.Assert(c)
	if err != nil {
		log.Fatalf("Could not get OAuth token: %s", err)
	}

	c.Transport = &oauth.Transport{
		Token: oauthToken,
	}
	service, err := storage.New(c)
	if err != nil {
		log.Fatalf("Could not use storage API: %s", err)
	}
	objs, err := service.Objects.List(options.Bucket).Do()
	if err != nil {
		log.Fatalf("Could not list content of bucket %s: %s", options.Bucket, err)
	}
	for _, obj := range objs.Items {
		log.Printf("%s/%s: %s\n", options.Bucket, obj.Name, obj.SelfLink)
	}

	data := strings.NewReader("Some Data")
	newObj, err := service.Objects.Insert(options.Bucket, &storage.Object{}).Name("gcs-test").Media(data).Do()
	if err != nil {
		log.Fatalf("Could not create new object: %s", err)
	}
	log.Printf("Uploaded to %s", newObj.SelfLink)
}
Example #24
0
func main() {
	opts := &Options{}
	goptions.ParseAndFail(opts)

	// Print version number and exit if the version flag is set
	if opts.Version {
		fmt.Printf("gandi-domain v%s\n", shared.VersionNumber)
		return
	}

	// Get gandi client
	client := shared.NewGandiClient(opts.ConfigPath, opts.Testing)

	// Create api and cli instances
	api := api.New(client)
	domain := cli.New(api)

	switch opts.Verbs {
	case "count":
		domain.Count()

	case "list":
		domain.List()

	case "info":
		domain.Info(opts.Info.Domain)

	case "available":
		domain.Available(opts.Available.Domain)

	case "create":
		args := opts.Create
		domain.Create(args.Domain, args.Contact, args.Years)

	default:
		goptions.PrintHelp()
	}
}
Example #25
0
func main() {
	goptions.ParseAndFail(&options)
	output, err := os.Create(options.Output)
	if err != nil {
		log.Fatalf("Could not open output file %s: %s", options.Output, err)
	}
	defer output.Close()

	data := []byte(DefaultTemplate)
	if options.Template != nil {
		data, err = ioutil.ReadAll(options.Template)
		if err != nil {
			log.Fatalf("Could not read template file %s: %s", options.Template, err)
		}
	}
	tpl, err := template.New("nginx").Parse(string(data))
	if err != nil {
		log.Fatalf("Could not parse template: %s", err)
	}

	containers, err := allContainers(options.Docker)
	if err != nil {
		log.Fatalf("Could not gather info about running containers: %s", err)
	}
	containers = filterContainers(containers)
	err = tpl.Execute(output, containers)
	if err != nil {
		log.Fatalf("Could not render template: %s", err)
	}

	if !options.DontReload {
		err := exec.Command("nginx", "-s", "reload").Run()
		if err != nil {
			log.Fatalf("Could not make nginx reload its configuration: %s", err)
		}
	}

}
func main() {
	opts := &Options{}
	goptions.ParseAndFail(opts)

	// Print version number and exit if the version flag is set
	if opts.Version {
		fmt.Printf("gandi-domain-zone-version v%s\n", shared.VersionNumber)
		return
	}

	// Get gandi client
	client := shared.NewGandiClient(opts.ConfigPath, opts.Testing)

	// Create api and zone instances
	api := api.New(client)
	version := cli.New(api)

	switch opts.Verbs {
	case "count":
		version.Count(opts.Count.Zone)

	case "list":
		version.List(opts.List.Zone)

	case "new":
		version.New(opts.New.Zone, opts.New.Version)

	case "delete":
		version.Delete(opts.Delete.Zone, opts.Delete.Version)

	case "set":
		version.Set(opts.Set.Zone, opts.Set.Version)

	default:
		goptions.PrintHelp()
	}
}
Example #27
0
func main() {
	goptions.ParseAndFail(&options)

	if options.Lxc {
		log.Fatalf("LXC support not implemented yet")
	}

	pa := NewPixelApi(NewLocalContainerCreator())

	r := httptools.NewRegexpSwitch(map[string]http.Handler{
		"/ws": NewStreamingHandler(pa),
		"/templates/.*": httptools.L{
			httptools.DiscardPathElements(1),
			templateRenderer{
				Dir:  options.TemplateDir,
				Data: TemplateData(),
			},
		},
		"/pixels(/.*)?": httptools.L{
			httptools.DiscardPathElements(1),
			pa,
		},
		"/handshake": http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			io.WriteString(w, "PIXELPIXEL OK")
		}),
		"/.*": httptools.L{
			http.FileServer(http.Dir(options.StaticDir)),
		},
	})

	log.Printf("Starting webserver on %s...", options.Listen)
	err := http.ListenAndServe(options.Listen, r)
	if err != nil {
		log.Fatalf("Could not start webserver: %s", err)
	}
}
Example #28
0
func main() {

	options := struct {
		Database      string `goptions:"-d, --database, obligatory, description='Database to work on'"`
		CPUProfile    string `goptions:"--cpuprofile, description='Record CPU profile for use with pprof.'"`
		goptions.Help `goptions:"-h, --help, description='Show this help'"`

		goptions.Verbs
		Create struct {
			Type string `goptions:"-t, --type, description='Create database with the specified storage type (diskv, leveldb)'"`
		} `goptions:"create"`
		Collections struct{} `goptions:"collections"`
		Dump        struct {
			Collection string `goptions:"-c, --collection, obligatory, description='Collection to dump'"`
		} `goptions:"dump"`
		Insert struct {
			Collection string `goptions:"-c, --collection, obligatory, description='Collection to work on'"`
		} `goptions:"insert"`
		Update struct {
			Collection string `goptions:"-c, --collection, obligatory, description='Collection to work on'"`
			Id         int64  `goptions:"-i, --id, obligatory, description='ID of entry to update'"`
		} `goptions:"update"`
		Delete struct {
			Collection string `goptions:"-c, --collection, obligatory, description='Collection to work on'"`
			Id         int64  `goptions:"-i, --id, obligatory, description='ID of entry to delete'"`
		} `goptions:"delete"`
		Vacuum   struct{} `goptions:"vacuum"`
		AddIndex struct {
			Collection string `goptions:"-c, --collection, obligatory, description='Collection to work on'"`
			Field      string `goptions:"-f, --field, obligatory, description='Field to create index on'"`
		} `goptions:"addindex"`
		RemoveIndex struct {
			Collection string `goptions:"-c, --collection, obligatory, description='Collection to work on'"`
			Field      string `goptions:"-f, --field, obligatory, description='Field to remove index from'"`
		} `goptions:"rmindex"`
		Query struct {
			Collection string             `goptions:"-c, --collection, obligatory, description='Collection to work on'"`
			Expression goptions.Remainder `goptions:"description='query expression'"`
		} `goptions:"query"`
	}{}

	goptions.ParseAndFail(&options)

	if options.CPUProfile != "" {
		f, _ := os.Create(options.CPUProfile)
		pprof.StartCPUProfile(f)
		defer pprof.StopCPUProfile()
	}

	if options.Verbs == "create" {
		typ := epos.STORAGE_AUTO
		switch options.Create.Type {
		case "leveldb":
			typ = epos.STORAGE_LEVELDB
		case "diskv":
			typ = epos.STORAGE_DISKV
		default:
			fmt.Fprintf(os.Stderr, "Error: invalid storage type %s.\n", options.Create.Type)
		}
		db, err := epos.OpenDatabase(options.Database, typ)
		if err != nil {
			panic(err)
		}
		db.Close()
		return
	}

	db, err := epos.OpenDatabase(options.Database, epos.STORAGE_AUTO)
	if err != nil {
		panic(err)
	}
	defer db.Close()

	switch options.Verbs {
	case "query":
		if len(options.Query.Expression) == 0 {
			fmt.Fprintf(os.Stderr, "Error: missing query expression")
			break
		}
		coll := db.Coll(options.Query.Collection)
		cond, err := epos.Expression([]string(options.Query.Expression)[0])
		if err != nil {
			fmt.Fprintf(os.Stderr, "Invalid query expression: %v\n", err)
			break
		}
		result, err := coll.Query(cond)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Query failed: %v\n", err)
			break
		}
		dumpData(result)
	case "dump":
		coll := db.Coll(options.Dump.Collection)
		result, _ := coll.QueryAll()
		dumpData(result)
	case "insert":
		decoder := json.NewDecoder(os.Stdin)
		for {
			var data interface{}
			err := decoder.Decode(&data)
			if err != nil {
				break
			}
			coll := db.Coll(options.Insert.Collection)
			id, err := coll.Insert(data)
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error while inserting item: %v\n", err)
				break
			}
			fmt.Printf("ID = %d\n", id)
		}
	case "vacuum":
		err = db.Vacuum()
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error while running vacuum: %v\n", err)
			os.Exit(1)
		}
	case "addindex":
		coll := db.Coll(options.AddIndex.Collection)
		if err := coll.AddIndex(options.AddIndex.Field); err != nil {
			fmt.Fprintf(os.Stderr, "Error while adding index: %v\n", err)
		}
	case "rmindex":
		coll := db.Coll(options.RemoveIndex.Collection)
		if err := coll.RemoveIndex(options.RemoveIndex.Field); err != nil {
			fmt.Fprintf(os.Stderr, "Error while removing index: %v\n", err)
		}
	case "collections":
		if colls, err := db.Collections(); err != nil {
			fmt.Fprintf(os.Stderr, "Error while fetching collections: %v\n", err)
		} else {
			for _, collname := range colls {
				fmt.Printf("%s\n", collname)
			}
		}
	case "update":
		decoder := json.NewDecoder(os.Stdin)
		var data interface{}
		err := decoder.Decode(&data)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error while decoding JSON document: %v\n", err)
			return
		}
		coll := db.Coll(options.Update.Collection)
		if err := coll.Update(epos.Id(options.Update.Id), data); err != nil {
			fmt.Fprintf(os.Stderr, "Error while updating item %d: %v\n", options.Update.Id, err)
			return
		}
		fmt.Printf("Item %d updated successfully.\n", options.Update.Id)
	case "delete":
		coll := db.Coll(options.Delete.Collection)
		if err := coll.Delete(epos.Id(options.Delete.Id)); err != nil {
			fmt.Fprintf(os.Stderr, "Error while deleeting item %d: %v\n", options.Delete.Id, err)
			return
		}
		fmt.Printf("Item %d deleted.\n", options.Delete.Id)
	default:
		fmt.Fprintf(os.Stderr, "Error: unknown operation %s\n", options.Verbs)
	}
}
Example #29
0
// Main defines the primary handler for transforming an application into a Sparta package.  The
// serviceName is used to uniquely identify your service within a region and will
// be used for subsequent updates.  For provisioning, ensure that you've
// properly configured AWS credentials for the golang SDK.
// See http://docs.aws.amazon.com/sdk-for-go/api/aws/defaults.html#DefaultChainCredentials-constant
// for more information.
func Main(serviceName string, serviceDescription string, lambdaAWSInfos []*LambdaAWSInfo, api *API) error {

	// We need to be able to provision an IAM role that has capabilities to
	// manage the other sources.  That'll give us the role arn to use in the custom
	// resource execution.
	options := struct {
		Noop     bool          `goptions:"-n, --noop, description='Dry-run behavior only (do not provision stack)'"`
		LogLevel string        `goptions:"-l, --level, description='Log level [panic, fatal, error, warn, info, debug]'"`
		Help     goptions.Help `goptions:"-h, --help, description='Show this help'"`

		Verb      goptions.Verbs
		Provision struct {
			S3Bucket string `goptions:"-b,--s3Bucket, description='S3 Bucket to use for Lambda source', obligatory"`
		} `goptions:"provision"`
		Delete struct {
		} `goptions:"delete"`
		Execute struct {
			Port            int `goptions:"-p,--port, description='Alternative port for HTTP binding (default=9999)'"`
			SignalParentPID int `goptions:"-s,--signal, description='Process ID to signal with SIGUSR2 once ready'"`
		} `goptions:"execute"`
		Describe struct {
			OutputFile string `goptions:"-o,--out, description='Output file for HTML description', obligatory"`
		} `goptions:"describe"`
		Explore struct {
			Port int `goptions:"-p,--port, description='Alternative port for HTTP binding (default=9999)'"`
		} `goptions:"explore"`
	}{ // Default values goes here
		LogLevel: "info",
	}
	goptions.ParseAndFail(&options)
	logger, err := NewLogger(options.LogLevel)
	if err != nil {
		goptions.PrintHelp()
		os.Exit(1)
	}
	logger.WithFields(logrus.Fields{
		"Option":  options.Verb,
		"Version": SpartaVersion,
	}).Info("Welcome to Sparta")

	switch options.Verb {
	case "provision":
		logger.Formatter = new(logrus.TextFormatter)
		err = Provision(options.Noop, serviceName, serviceDescription, lambdaAWSInfos, api, options.Provision.S3Bucket, nil, logger)
	case "execute":
		logger.Formatter = new(logrus.JSONFormatter)
		err = Execute(lambdaAWSInfos, options.Execute.Port, options.Execute.SignalParentPID, logger)
	case "delete":
		logger.Formatter = new(logrus.TextFormatter)
		err = Delete(serviceName, logger)
	case "explore":
		logger.Formatter = new(logrus.TextFormatter)
		err = Explore(lambdaAWSInfos, options.Explore.Port, logger)
	case "describe":
		logger.Formatter = new(logrus.TextFormatter)
		fileWriter, err := os.Create(options.Describe.OutputFile)
		if err != nil {
			return fmt.Errorf("Failed to open %s output. Error: %s", options.Describe.OutputFile, err)
		}
		defer fileWriter.Close()
		err = Describe(serviceName, serviceDescription, lambdaAWSInfos, api, fileWriter, logger)
	default:
		goptions.PrintHelp()
		err = fmt.Errorf("Unsupported subcommand: %s", string(options.Verb))
	}
	if nil != err {
		logger.Error(err)
	}
	return err
}
Example #30
0
func main() {
	opts := &Options{}
	goptions.ParseAndFail(opts)

	// Print version number and exit if the version flag is set
	if opts.Version {
		fmt.Printf("gdrive v%s\n", VersionNumber)
		return
	}

	// Get authorized drive client
	drive, err := gdrive.New(opts.AppPath, opts.Advanced, true)
	if err != nil {
		writeError("An error occurred creating Drive client: %v\n", err)
	}

	switch opts.Verbs {
	case "list":
		args := opts.List
		err = cli.List(drive, args.Query, args.TitleFilter, args.MaxResults, args.SharedStatus, args.NoHeader, args.IncludeDocs, args.SizeInBytes)

	case "info":
		err = cli.Info(drive, opts.Info.FileId, opts.Info.SizeInBytes)

	case "folder":
		args := opts.Folder
		err = cli.Folder(drive, args.Title, args.ParentId, args.Share)

	case "upload":
		args := opts.Upload

		// Set custom chunksize if given
		if args.ChunkSize >= (1 << 18) {
			googleapi.SetChunkSize(args.ChunkSize)
		}

		if args.Stdin {
			err = cli.UploadStdin(drive, os.Stdin, args.Title, args.ParentId, args.Share, args.MimeType, args.Convert)
		} else {
			err = cli.Upload(drive, args.File, args.Title, args.ParentId, args.Share, args.MimeType, args.Convert)
		}

	case "download":
		args := opts.Download
		if args.Pop {
			err = cli.DownloadLatest(drive, args.Stdout, args.Format, args.Force)
		} else {
			err = cli.Download(drive, args.FileId, args.Stdout, false, args.Format, args.Force)
		}

	case "delete":
		err = cli.Delete(drive, opts.Delete.FileId)

	case "share":
		err = cli.Share(drive, opts.Share.FileId)

	case "unshare":
		err = cli.Unshare(drive, opts.Unshare.FileId)

	case "url":
		if opts.Url.Download {
			fmt.Println(util.DownloadUrl(opts.Url.FileId))
		} else {
			fmt.Println(util.PreviewUrl(opts.Url.FileId))
		}

	case "quota":
		err = cli.Quota(drive, opts.Quota.SizeInBytes)

	default:
		goptions.PrintHelp()
	}

	if err != nil {
		writeError("%s", err)
	}
}