func GetChain(ctx *cli.Context) (*core.ChainManager, common.Database, common.Database) { dataDir := ctx.GlobalString(DataDirFlag.Name) blockDb, err := ethdb.NewLDBDatabase(path.Join(dataDir, "blockchain")) if err != nil { Fatalf("Could not open database: %v", err) } stateDb, err := ethdb.NewLDBDatabase(path.Join(dataDir, "state")) if err != nil { Fatalf("Could not open database: %v", err) } extraDb, err := ethdb.NewLDBDatabase(path.Join(dataDir, "extra")) if err != nil { Fatalf("Could not open database: %v", err) } eventMux := new(event.TypeMux) chainManager := core.NewChainManager(blockDb, stateDb, eventMux) pow := ethash.New() txPool := core.NewTxPool(eventMux, chainManager.State, chainManager.GasLimit) blockProcessor := core.NewBlockProcessor(stateDb, extraDb, pow, txPool, chainManager, eventMux) chainManager.SetProcessor(blockProcessor) return chainManager, blockDb, stateDb }
func cmdInit(c *cli.Context) error { username := c.Args().First() if username == "" { cli.ShowCommandHelp(c, "init") return cli.NewExitError("", 0) } password := c.Args().Get(1) if password == "" { pwd, err := askPass() if err != nil { if err != gopass.ErrInterrupted { return cli.NewExitError(err.Error(), 2) } return cli.NewExitError("", 2) } password = pwd } s, err := NewStore(c.GlobalString("store"), c.GlobalString("do-upgrades"), c.GlobalString("policy-type"), c.GlobalString("policy-condition"), c.GlobalString("hooks-dir")) if err != nil { return cli.NewExitError(fmt.Sprintf("Error initializing whawty store: %s", err), 3) } if err := s.GetInterface().Init(username, password); err != nil { return cli.NewExitError(fmt.Sprintf("Error initializing whawty store: %s", err), 3) } return cli.NewExitError(fmt.Sprintf("whawty store successfully initialized!"), 0) }
// MakeChain creates a chain manager from set command line flags. func MakeChain(ctx *cli.Context) (chain *core.ChainManager, chainDb common.Database) { datadir := ctx.GlobalString(DataDirFlag.Name) cache := ctx.GlobalInt(CacheFlag.Name) var err error if chainDb, err = ethdb.NewLDBDatabase(filepath.Join(datadir, "chaindata"), cache); err != nil { Fatalf("Could not open database: %v", err) } if ctx.GlobalBool(OlympicFlag.Name) { InitOlympic() _, err := core.WriteTestNetGenesisBlock(chainDb, 42) if err != nil { glog.Fatalln(err) } } eventMux := new(event.TypeMux) pow := ethash.New() //genesis := core.GenesisBlock(uint64(ctx.GlobalInt(GenesisNonceFlag.Name)), blockDB) chain, err = core.NewChainManager(chainDb, nil, pow, eventMux) if err != nil { Fatalf("Could not start chainmanager: %v", err) } proc := core.NewBlockProcessor(chainDb, pow, chain, eventMux) chain.SetProcessor(proc) return chain, chainDb }
func createImageCommandFunc(c *cli.Context) { var image string if len(c.Args()) == 0 { log.Fatal("You need to specify a image") } else { image = c.Args()[0] } clnt := client.New(c.GlobalString("server")) if c.GlobalBool("debug") { clnt.SetDebug() } s := client.Image{ Image: image, Type: prompt.String("Type", prompt.Prompt{Default: "docker", FuncPtr: prompt.Enum, FuncInp: "file,docker"}), BootTagID: *chooseTag(clnt, ""), } // Is this correct? fmt.Println(string(s.JSON())) if !prompt.Bool("Is this correct", true) { os.Exit(1) } // Create image clnt.Image.Create(&s) }
func makedag(ctx *cli.Context) { utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name)) args := ctx.Args() wrongArgs := func() { utils.Fatalf(`Usage: geth makedag <block number> <outputdir>`) } switch { case len(args) == 2: blockNum, err := strconv.ParseUint(args[0], 0, 64) dir := args[1] if err != nil { wrongArgs() } else { dir = filepath.Clean(dir) // seems to require a trailing slash if !strings.HasSuffix(dir, "/") { dir = dir + "/" } _, err = ioutil.ReadDir(dir) if err != nil { utils.Fatalf("Can't find dir") } fmt.Println("making DAG, this could take awhile...") ethash.MakeDAG(blockNum, dir) } default: wrongArgs() } }
func blockRecovery(ctx *cli.Context) { utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name)) arg := ctx.Args().First() if len(ctx.Args()) < 1 && len(arg) > 0 { glog.Fatal("recover requires block number or hash") } cfg := utils.MakeEthConfig(ClientIdentifier, nodeNameVersion, ctx) utils.CheckLegalese(cfg.DataDir) blockDb, err := ethdb.NewLDBDatabase(filepath.Join(cfg.DataDir, "blockchain"), cfg.DatabaseCache) if err != nil { glog.Fatalln("could not open db:", err) } var block *types.Block if arg[0] == '#' { block = core.GetBlockByNumber(blockDb, common.String2Big(arg[1:]).Uint64()) } else { block = core.GetBlockByHash(blockDb, common.HexToHash(arg)) } if block == nil { glog.Fatalln("block not found. Recovery failed") } err = core.WriteHead(blockDb, block) if err != nil { glog.Fatalln("block write err", err) } glog.Infof("Recovery succesful. New HEAD %x\n", block.Hash()) }
func attach(ctx *cli.Context) { utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name)) var client comms.EthereumClient var err error if ctx.Args().Present() { client, err = comms.ClientFromEndpoint(ctx.Args().First(), codec.JSON) } else { cfg := comms.IpcConfig{ Endpoint: ctx.GlobalString(utils.IPCPathFlag.Name), } client, err = comms.NewIpcClient(cfg, codec.JSON) } if err != nil { utils.Fatalf("Unable to attach to geth node - %v", err) } repl := newLightweightJSRE( ctx.GlobalString(utils.JSpathFlag.Name), client, true, ) if ctx.GlobalString(utils.ExecFlag.Name) != "" { repl.batch(ctx.GlobalString(utils.ExecFlag.Name)) } else { repl.welcome() repl.interactive() } }
func push(c *cli.Context) { wd := ensureHome(c) pkg := a1(c, "No package name given") ver := a2(c, "Version is required") h := NewClient(c.GlobalString("host")) // Grab the latest version of the package from the server p, err := h.Get(pkg) if err != nil { die(err) } // Build a release r := &model.Release{ Version: ver, Author: p.Author, Date: time.Now(), PackageId: p.ID, Manifests: makeManifests(path.Join(wd, pkg)), } // Add it p.Releases = append([]*model.Release{r}, p.Releases...) info("Pushing %s %s to K8sPlace", pkg, ver) //d, _ := json.Marshal(p) //fmt.Println(string(d)) if err := h.Update(p); err != nil { die(err) } ftw("Updated %s", p.Name) }
// RecordGenerator abstracts from the way the strings are specified, e.g. via // stdin a file or directly on the command line func RecordGenerator(c *cli.Context) chan *Record { columnSpec, err := ParseColumnSpec(c.GlobalString("f")) if err != nil { log.Fatal(err) } // stdin if len(c.Args()) == 0 || (len(c.Args()) == 1 && c.Args()[0] == "-") { return RecordGeneratorFileDelimiter(os.Stdin, columnSpec, c.GlobalString("delimiter")) } // from filename if len(c.Args()) == 1 { filename := c.Args()[0] if _, err := os.Stat(filename); err == nil { file, err := os.Open(filename) if err != nil { log.Fatal(err) } return RecordGeneratorFile(file, columnSpec) } log.Fatalf("no such file: %s\n", filename) } // direct if len(c.Args()) == 2 { records := make(chan *Record) go func() { records <- &Record{Fields: c.Args(), left: 0, right: 1} close(records) }() return records } return nil }
func (this *App) setup(c *cli.Context) error { if this.client == nil { this.client = api.NewClient(c.GlobalString("server")) } if this.user == nil { // try load user from config if this.config != nil && this.config.CurrentUser != "" { this.user, _ = this.store.FindUserByKey(this.config.CurrentUser) } // still not found if this.user == nil { this.user = this.selectCurrentUser() } } if this.user == nil { return ErrNoUser } if err := this.client.Register(this.user); err != nil { return err } // save config if this.config == nil { this.config = &AppConfig{ CurrentUser: this.user.Key, } this.saveConfig(this.config) } return nil }
// getConfigFilename gets the absolute filename of the config file specified by // the ConfigFilename flag, and whether it exists. // // If the ConfigFilename exists, then it is returned as an absolute path. // If neither of those exist, the absolute ConfigFilename is returned. func getConfigFilename(context *cli.Context) (string, bool) { cf := context.GlobalString("config-filename") if filepath.IsAbs(cf) { // Absolute path specified; user knows what they want. _, err := os.Stat(cf) return cf, err == nil } absCF, err := filepath.Abs(cf) if err != nil { // syscall failure; treat as if file doesn't exist. return cf, false } if _, err := os.Stat(absCF); err == nil { // File exists on relative path. return absCF, true } // Check for config file on path relative to executable. exeFile := os.Args[0] exeDir := filepath.Dir(exeFile) absCF = filepath.Join(exeDir, cf) if _, err := os.Stat(absCF); err == nil { return absCF, true } // This is probably what the user expects if it wasn't found anywhere else. return absCF, false }
// getConfigFilename gets the absolute filename of the config file specified by // the ConfigFilename flag, and whether it exists. // // If the (relative or absolute) ConfigFilename exists, then it is returned. // If the ConfigFilename exists in a valid XDG path, then it is returned. // If neither of those exist, the (relative or absolute) ConfigFilename is returned. func getConfigFilename(context *cli.Context) (string, bool) { cf := context.GlobalString("config-filename") if filepath.IsAbs(cf) { // Absolute path specified; user knows what they want. _, err := os.Stat(cf) return cf, err == nil } absCF, err := filepath.Abs(cf) if err != nil { // syscall failure; treat as if file doesn't exist. return cf, false } if _, err := os.Stat(absCF); err == nil { // File exists on relative path. return absCF, true } if xdgCF, err := xdg.Config.Find(cf); err == nil { // File exists in an XDG directory. return xdgCF, true } // Default to relative path. This is probably what the user expects if // it wasn't found anywhere else. return absCF, false }
func installAction(ctx *cli.Context) { server := ctx.GlobalString("server") ref := ctx.String("ref") if len(ctx.Args()) == 0 { log.Fatal("Need args") } repo := ctx.Args().Get(0) log.Println(repo) u := url.URL{ Scheme: "http", Host: server, } // guess repo if !strings.Contains(repo, "/") { luckyURL := u luckyURL.Path = "/lucky/" + repo var err error repo, err = httpGetString(luckyURL.String()) if err != nil { log.Fatal(err) } if repo == "" { log.Fatal("Guess repo failed, require fullname <owner/reponame>") } } log.Println("use repo:", repo) binURL := u binURL.Path = fmt.Sprintf("%s/%s/%s/%s", repo, ref, runtime.GOOS, runtime.GOARCH) getBinary(binURL, figureBinName(repo)) }
// Fetch returns exercism problems. func Fetch(ctx *cli.Context) { c, err := config.New(ctx.GlobalString("config")) if err != nil { log.Fatal(err) } client := api.NewClient(c) problems, err := client.Fetch(ctx.Args()) if err != nil { log.Fatal(err) } submissionInfo, err := client.Submissions() if err != nil { log.Fatal(err) } if err := setSubmissionState(problems, submissionInfo); err != nil { log.Fatal(err) } hw := user.NewHomework(problems, c) if err := hw.Save(); err != nil { log.Fatal(err) } hw.Summarize(user.HWAll) }
func statusCmd(c *cli.Context) { migrationsPath := c.GlobalString("migrations") targetPath := c.GlobalString("target") migrationsPath, err := migrations.AbsMigrationsPath(migrationsPath) if err != nil { fmt.Printf("Error determining the migrations path: %s\n", err.Error()) os.Exit(1) } list, err := migrations.List(migrationsPath) if err != nil { fmt.Printf("Error listing the available migrations: %s\n", err.Error()) os.Exit(1) } timestamp, err := migrations.CurrentTimestamp(targetPath) if err != nil { fmt.Printf("Error reading the current timestamp: %s\n", err.Error()) os.Exit(1) } if last := migrations.Last(list, timestamp); last != nil { fmt.Printf("Last migration executed: %s\n", last.Name) } else { fmt.Printf("No migration executed yet!\n") } fmt.Printf("Pending migrations: %d\n", len(migrations.Pending(list, timestamp))) }
func cmdActive(c *cli.Context) { if len(c.Args()) > 0 { log.Fatal("Error: Too many arguments given.") } certInfo := getCertPathInfo(c) defaultStore, err := getDefaultStore( c.GlobalString("storage-path"), certInfo.CaCertPath, certInfo.CaKeyPath, ) if err != nil { log.Fatal(err) } mcn, err := newMcn(defaultStore) if err != nil { log.Fatal(err) } host, err := mcn.GetActive() if err != nil { log.Fatalf("Error getting active host: %s", err) } if host != nil { fmt.Println(host.Name) } }
func loginAction(c *cli.Context) { api := getAPI(c) var url string var version string var username string var password string fmt.Printf("URL: ") _, urlErr := fmt.Scanln(&url) if urlErr != nil { panic(urlErr) } fmt.Printf("Username: "******"Version (default: 1): ") _, verErr := fmt.Scanln(&version) if verErr != nil { version = "1" } userData, loginErr := api.Login(url, username, password) if loginErr != nil { LogMessage("Error logging in. Please check username/password.", "r") os.Exit(1) } saveConfig(username, userData.ApiKey, url, version, c.GlobalString("config")) LogMessage("Login successful", "g") }
// MustDataDir retrieves the currently requested data directory, terminating if // none (or the empty string) is specified. func MustDataDir(ctx *cli.Context) string { if path := ctx.GlobalString(DataDirFlag.Name); path != "" { return path } Fatalf("Cannot determine default data directory, please set manually (--datadir)") return "" }
func get(c *cli.Context) { wd := ensureHome(c) pkg := a1(c, "No package name given") info("Getting %s", pkg) h := NewClient(c.GlobalString("host")) p, err := h.Get(pkg) if err != nil { die(err) } pdir := path.Join(wd, p.Name) if err := os.MkdirAll(pdir, 0755); err != nil { die(err) } if len(p.Releases) == 0 { info("There are no releases of %q.", pkg) ftw("Installed empty package %s into %q", p.Name, path.Join(wd, pdir)) return } rel := p.Releases[0] info("Newest Version: %s", rel.Version) ftw("Installed %s %s into %q", p.Name, rel.Version, pdir) }
// CartRemove removes an item from the cart func CartRemove(c *cli.Context) { api := api.Create(c.GlobalString("locale")) conf := config.GetConfig() defer conf.Flush() cartName := conf.CartNameFromCache(c.Args().Get(1)) cartItemID, exists := conf.CartItemIDFromCache(cartName, c.Args().First()) if !exists { fmt.Fprintln(os.Stderr, "Cannot look up CartItemId") os.Exit(1) } cart, exists := conf.Carts[cartName] if !exists { fmt.Fprintln(os.Stderr, "Cannot look up Cart") os.Exit(1) } response, err := api.CartModify(cart.CartID, cart.HMAC, map[string]int{ cartItemID: 0, }) if err != nil { panic(err) } conf.Carts[cartName].HMAC = response.Cart.HMAC fmt.Printf("Removed item from cart %s\n", cartName) }
func console(ctx *cli.Context) { utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name)) cfg := utils.MakeEthConfig(ClientIdentifier, nodeNameVersion, ctx) ethereum, err := eth.New(cfg) if err != nil { utils.Fatalf("%v", err) } client := comms.NewInProcClient(codec.JSON) startEth(ctx, ethereum) repl := newJSRE( ethereum, ctx.GlobalString(utils.JSpathFlag.Name), ctx.GlobalString(utils.RPCCORSDomainFlag.Name), client, true, nil, ) if ctx.GlobalString(utils.ExecFlag.Name) != "" { repl.batch(ctx.GlobalString(utils.ExecFlag.Name)) } else { repl.welcome() repl.interactive() } ethereum.Stop() ethereum.WaitForShutdown() }
func storagepoolAgent(c *cli.Context) { healthCheckInterval := c.GlobalInt("healthcheck-interval") healthCheckBaseDir := c.GlobalString("healthcheck-basedir") healthCheckType := c.String("storagepool-healthcheck-type") cattleUrl := c.GlobalString("url") cattleAccessKey := c.GlobalString("access-key") cattleSecretKey := c.GlobalString("secret-key") if c.GlobalBool("debug") { log.SetLevel(log.DebugLevel) } storagepoolRootDir := c.GlobalString("storagepool-rootdir") driver := c.GlobalString("storagepool-driver") if driver == "" { log.Fatal("required field storagepool-driver has not been set") } cattleClient, err := cattle.NewCattleClient(cattleUrl, cattleAccessKey, cattleSecretKey) if err != nil { log.Fatal(err) } storagepoolAgent := NewStoragepoolAgent(healthCheckInterval, storagepoolRootDir, driver, healthCheckBaseDir, healthCheckType, cattleClient) metadataUrl := c.String("storagepool-metadata-url") if err := storagepoolAgent.Run(metadataUrl); err != nil { log.Fatal(err) } }
func startEth(ctx *cli.Context, eth *eth.Ethereum) { // Start Ethereum itself utils.StartEthereum(eth) am := eth.AccountManager() account := ctx.GlobalString(utils.UnlockedAccountFlag.Name) accounts := strings.Split(account, " ") for i, account := range accounts { if len(account) > 0 { if account == "primary" { utils.Fatalf("the 'primary' keyword is deprecated. You can use integer indexes, but the indexes are not permanent, they can change if you add external keys, export your keys or copy your keystore to another node.") } unlockAccount(ctx, am, account, i) } } // Start auxiliary services if enabled. if !ctx.GlobalBool(utils.IPCDisabledFlag.Name) { if err := utils.StartIPC(eth, ctx); err != nil { utils.Fatalf("Error string IPC: %v", err) } } if ctx.GlobalBool(utils.RPCEnabledFlag.Name) { if err := utils.StartRPC(eth, ctx); err != nil { utils.Fatalf("Error starting RPC: %v", err) } } if ctx.GlobalBool(utils.MiningEnabledFlag.Name) { if err := eth.StartMining(ctx.GlobalInt(utils.MinerThreadsFlag.Name)); err != nil { utils.Fatalf("%v", err) } } }
func preload(context *cli.Context) error { if context.GlobalBool("debug") { logger.Level = logrus.DebugLevel } config = loadConfig(context.GlobalString("config")) return nil }
func runBot(c *cli.Context) { var ( Sapi *slack.Slack cfg *config.Config cfg_path string err error wg sync.WaitGroup ) cfg_path = c.GlobalString("config") Log.Info("Config '%s' will be loaded.", cfg_path) cfg, err = config.New(cfg_path) if err != nil { Log.Error("Config processing error: %s", err) return } Sapi = slack.New(&cfg.Janus) Sapi.Connect() // start Messsage loop wg.Add(1) go func() { defer wg.Done() Sapi.MessageLoop() }() // start Channel info loop wg.Add(1) go func() { defer wg.Done() Sapi.ChannelLoop() }() // all loops started wg.Wait() }
// fetch data for subreddits based on configuration provided func load(configuration *Configuration, context *cli.Context) { timeout := time.Duration(context.GlobalInt("timeout")) jsonOut := context.GlobalBool("json") browserOut := context.GlobalBool("browser") port := context.GlobalString("port") if len(configuration.Subreddits) == 0 { log.Fatalln("No subreddits found") } results := make(chan *Subreddit, len(configuration.Subreddits)) for _, subreddit := range configuration.Subreddits { go fetch(subreddit, results) } collect(results, configuration, timeout) if browserOut { browserOutput(configuration.Subreddits, port) } else if jsonOut { jsonOutput(configuration.Subreddits) } else { prettyOutput(configuration.Subreddits) } }
// Status is a command that allows a user to view their progress in a given // language track. func Status(ctx *cli.Context) { c, err := config.New(ctx.GlobalString("config")) if err != nil { log.Fatal(err) } args := ctx.Args() if len(args) != 1 { fmt.Fprintf(os.Stderr, "Usage: exercism status TRACK_ID") os.Exit(1) } client := api.NewClient(c) trackID := args[0] status, err := client.Status(trackID) if err != nil { if err == api.ErrUnknownTrack { log.Fatalf("There is no track with ID '%s'.", trackID) } else { log.Fatal(err) } } fmt.Println(status) }
func remove(c *cli.Context) { if l := len(c.Args()); l != 1 { oserrf("error: expected 1 argument, got %d", l) return } cfgPath, err := tenetCfgPath(c) if err != nil { oserrf("reading config file: %s", err.Error()) return } cfg, err := buildConfig(cfgPath, CascadeNone) if err != nil { oserrf("reading config file: %s", err.Error()) return } imageName := c.Args().First() if !cfg.HasTenet(imageName) { oserrf(`error: tenet "%s" not found in %q`, imageName, c.GlobalString(tenetCfgFlg.long)) return } if err := cfg.RemoveTenet(imageName, c.String("group")); err != nil { oserrf(err.Error()) return } if err := writeConfigFile(c, cfg); err != nil { oserrf(err.Error()) return } }
// MakeNAT creates a port mapper from set command line flags. func MakeNAT(ctx *cli.Context) nat.Interface { natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name)) if err != nil { Fatalf("Option %s: %v", NATFlag.Name, err) } return natif }
func cmdRun(c *cli.Context) error { s, err := openAndCheck(c) if err != nil { return cli.NewExitError(err.Error(), 3) } webAddr := c.String("web-addr") saslPaths := c.StringSlice("sock") var wg sync.WaitGroup if webAddr != "" { wg.Add(1) go func() { defer wg.Done() if err := runWebAddr(webAddr, s.GetInterface(), c.GlobalString("web-static-dir")); err != nil { fmt.Printf("warning running web interface failed: %s\n", err) } }() } for _, path := range saslPaths { p := path wg.Add(1) go func() { defer wg.Done() if err := runSaslAuthSocket(p, s.GetInterface()); err != nil { fmt.Printf("warning running auth agent(%s) failed: %s\n", p, err) } }() } wg.Wait() return cli.NewExitError(fmt.Sprintf("shutting down since all auth sockets have closed."), 0) }