func Action(c *cli.Context) {
if len(c.Args()) < 1 {
fmt.Println("ERROR: Please specify a a task\n\n")
cli.ShowAppHelp(c)
return
}
task := c.Args()[0]
tplVars := c.GlobalString("vars")
cfgPath := c.GlobalString("config")
env := c.GlobalString("environment")
host := c.GlobalString("host")
vars := parseVars(tplVars)
file, err := ioutil.ReadFile(cfgPath)
if err != nil {
fmt.Printf("ERROR: could not find the config file: %s\n\n", cfgPath)
cli.ShowAppHelp(c)
return
}
cfg := LoadConfig(file, vars, env)
if host != "" {
Run(task, []string{host}, cfg)
} else {
Run(task, cfg.DeployEnvs[env].Hosts, cfg)
}
}
// GetCmd extracts cmd from command line
func GetCmd(c *cli.Context) (cmd string) {
argc := len(c.Args())
if argc >= 2 {
if cl.fifoFile == "" || argc > 2 {
fmt.Println("Too Many Arguments (Command Must Be the Last One Parameter) !")
cli.ShowAppHelp(c)
os.Exit(1)
}
loop:
for _, arg := range c.Args() {
if arg != cl.fifoFile {
cmd = arg
break loop
}
}
} else if argc == 1 && c.Args()[0] == cl.fifoFile || argc == 0 {
cmd = getPipe(PIPEUSEDBYCMD)
return
fmt.Println("Command Must Be the Last One Parameter!")
cli.ShowAppHelp(c)
os.Exit(1)
} else {
cmd = c.Args()[argc-1]
}
return
}
func runApp(c *cli.Context) {
uri := "amqp://*****:*****@" + c.String("server") + ":5672"
queueName := queueBaseName
queueDurability := c.Bool("durable")
if c.String("queuesuffix") != "" {
queueName = fmt.Sprintf("%s-%s", queueBaseName, c.String("queuesuffix"))
}
if c.Int("consumer") > -1 && c.Int("producer") != 0 {
fmt.Println("Error: Cannot specify both producer and consumer options together")
fmt.Println()
cli.ShowAppHelp(c)
os.Exit(1)
} else if c.Int("consumer") > -1 {
fmt.Println("Running in consumer mode")
config := ConsumerConfig{uri, c.Bool("quiet")}
makeConsumers(config, queueName, queueDurability, c.Int("concurrency"), c.Int("consumer"))
} else if c.Int("producer") != 0 {
fmt.Println("Running in producer mode")
config := ProducerConfig{uri, c.Bool("quiet"), c.Int("bytes"), c.Bool("wait-for-ack")}
makeProducers(config, queueName, queueDurability, c.Int("concurrency"), c.Int("producer"), c.Int("wait"))
} else {
cli.ShowAppHelp(c)
os.Exit(0)
}
}
func run(c *cli.Context) {
user := c.String("User")
if 0 == len(user) {
cli.ShowAppHelp(c)
log.Fatal("User must be provided")
}
text := c.String("Text")
if 0 == len(text) {
cli.ShowAppHelp(c)
log.Fatal("Text must be provided")
}
amqpUri := c.String("AmqpUri")
amqpExchange := c.String("AmqpExchange")
amqpType := "direct"
key := c.String("AmqpKey")
amqpService := xmpptoamqp.NewAmqpService(&amqpUri, nil, nil, nil)
amqpService.ExchangeDeclare(&amqpExchange, &amqpType)
amqpService.Send(&amqpExchange, &key, &user, &text)
log.WithFields(log.Fields{
"user": c.String("User"),
}).Info("Chat sent")
}
func main() {
cli.AppHelpTemplate = AppHelpTemplate
cli.CommandHelpTemplate = CommandHelpTemplate
cli.SubcommandHelpTemplate = SubcommandHelpTemplate
cli.VersionPrinter = printVersion
app := cli.NewApp()
app.Name = "buildkite-agent"
app.Version = agent.Version()
app.Commands = []cli.Command{
clicommand.AgentStartCommand,
{
Name: "artifact",
Usage: "Upload/download artifacts from Buildkite jobs",
Subcommands: []cli.Command{
clicommand.ArtifactUploadCommand,
clicommand.ArtifactDownloadCommand,
clicommand.ArtifactShasumCommand,
},
},
{
Name: "meta-data",
Usage: "Get/set data from Buildkite jobs",
Subcommands: []cli.Command{
clicommand.MetaDataSetCommand,
clicommand.MetaDataGetCommand,
clicommand.MetaDataExistsCommand,
},
},
{
Name: "pipeline",
Usage: "Make changes to the pipeline of the currently running build",
Subcommands: []cli.Command{
clicommand.PipelineUploadCommand,
},
},
clicommand.BootstrapCommand,
}
// When no sub command is used
app.Action = func(c *cli.Context) {
cli.ShowAppHelp(c)
os.Exit(1)
}
// When a sub command can't be found
app.CommandNotFound = func(c *cli.Context, command string) {
cli.ShowAppHelp(c)
os.Exit(1)
}
app.Run(os.Args)
}
func common(c *cli.Context) error {
if c.GlobalString("seed") == "" {
cli.ShowAppHelp(c)
os.Exit(1)
}
if c.GlobalInt("sequence") == 0 {
cli.ShowAppHelp(c)
os.Exit(1)
}
key = parseSeed(c.String("seed"))
return nil
}
func ServiceMaint(c *cli.Context) {
// Get client
cfg, err := NewAppConfig(c)
if err != nil {
log.Errorf("Failed to get client: %v", err)
return
}
action := c.Args().First()
service := c.Args().Tail()[0]
reason := ""
if len(c.Args().Tail()) > 1 {
reason = c.Args().Tail()[1]
}
switch action {
case "enable":
if err = cfg.client.Agent().EnableServiceMaintenance(service, reason); err != nil {
log.Errorf("Error setting maintenance mode: %v", err)
return
}
case "disable":
if err = cfg.client.Agent().DisableServiceMaintenance(service); err != nil {
log.Errorf("Error disabling maintenance mode: %v", err)
return
}
default:
cli.ShowAppHelp(c)
return
}
log.Println("Success")
}
func NewApp() *cli.App {
cmds, err := parseCommands()
if err != nil {
log.Fatal(err)
}
app := cli.NewApp()
app.Name = "gotask"
app.Usage = "Build tool in Go"
app.Version = Version
app.Commands = cmds
app.Flags = []cli.Flag{
compileFlag{Usage: "compile the task binary to pkg.task but do not run it"},
}
app.Action = func(c *cli.Context) {
if c.Bool("c") || c.Bool("compile") {
err := compileTasks()
if err != nil {
log.Fatal(err)
}
return
}
if len(c.Args()) == 0 {
cli.ShowAppHelp(c)
}
}
return app
}
// GenerateDoc generating new documentation
func GenerateDoc(c *cli.Context) {
md := c.String("input")
html := c.String("output")
t := c.String("template")
path := c.String("path")
sidebar := c.String("sidebar")
if md == "" {
cli.ShowAppHelp(c)
return
}
fmt.Println("Begin generate")
sb, _ := NewSidebar(sidebar)
parent := &Dir{sidebar: sb}
dir, err := NewDir(md, html, t, path)
if err != nil {
fmt.Printf("Error read dir %s\n \t%s\n", dir.mdDir, err.Error())
}
err = dir.read()
if err != nil {
fmt.Printf("Error read dir %s\n \t%s\n", dir.mdDir, err.Error())
}
err = dir.write(parent)
if err != nil {
fmt.Printf("Error write dir %s\n", dir.htmlDir)
}
fmt.Println("End generate")
}
func ToggleMaintenanceMode(c *cli.Context) {
cfg, err := NewAppConfig(c)
if err != nil {
log.Errorf("Failed to get client: %v", err)
return
}
action := c.Args().First()
switch action {
case "enable":
if err = cfg.client.Agent().EnableNodeMaintenance(c.String("reason")); err != nil {
log.Errorf("Could not set maintenance mode: %v", err)
return
}
case "disable":
if err = cfg.client.Agent().DisableNodeMaintenance(); err != nil {
log.Errorf("Could not unset maintenance mode: %v", err)
return
}
default:
log.Warningf("Must choose either enable or disable")
cli.ShowAppHelp(c)
return
}
log.Println("Success")
}
func main() {
app := cli.NewApp()
app.Name = "seita"
app.Usage = "Enshrine and retrieve project skeletons"
app.EnableBashCompletion = true
app.Authors = []cli.Author{
{
Name: "Ilkka Laukkanen",
Email: "*****@*****.**",
},
}
app.Commands = []cli.Command{
{
Name: "put",
Aliases: []string{"p"},
Usage: "Offer up this project as a skeleton",
Action: command.Put,
},
{
Name: "make",
Aliases: []string{"m"},
Usage: "Make a new project based on a skeleton",
Action: command.Make,
Before: requireArgs("get", 1),
},
{
Name: "config",
Aliases: []string{"c"},
Usage: "Manipulate configuration",
Subcommands: []cli.Command{
{
Name: "set",
Aliases: []string{"s"},
Usage: "Set configuration variable value",
Action: config.Set,
Before: requireArgs("set", 2),
},
{
Name: "get",
Aliases: []string{"g"},
Usage: "Get configuration variable value",
Action: config.Get,
Before: requireArgs("get", 1),
},
{
Name: "list",
Aliases: []string{"l"},
Usage: "List configuration variables",
Action: config.List,
},
},
},
}
app.Action = func(c *cli.Context) {
cli.ShowAppHelp(c)
}
app.RunAndExitOnError()
}
func UpdateACL(c *cli.Context) {
if len(c.String("id")) > 1 {
log.Errorln("--id is required!")
cli.ShowAppHelp(c)
return
}
cfg, err := NewAppConfig(c)
if err != nil {
log.Errorf("Failed to get client: %v", err)
return
}
_, err = cfg.client.ACL().Update(&api.ACLEntry{
Name: c.String("name"),
Type: c.String("type"),
Rules: c.Args().First(),
ID: c.String("id"),
}, cfg.writeOpts)
if err != nil {
log.Errorf("Could not update ACL: %v", err)
return
}
fmt.Println("Success")
}
func getOpts(context *cli.Context) (string, string, string, string, string) {
etcdURI := context.String("etcd-uri")
redisURI := context.String("redis-uri")
redisQueue := context.String("redis-queue")
deployStateUri := context.String("deploy-state-uri")
cluster := context.String("cluster")
if etcdURI == "" || redisURI == "" || redisQueue == "" || deployStateUri == "" || cluster == "" {
cli.ShowAppHelp(context)
if etcdURI == "" {
color.Red(" Missing required flag --etcd-uri or GOVERNATOR_ETCD_URI")
}
if redisURI == "" {
color.Red(" Missing required flag --redis-uri or GOVERNATOR_REDIS_URI")
}
if redisQueue == "" {
color.Red(" Missing required flag --redis-queue or GOVERNATOR_REDIS_QUEUE")
}
if deployStateUri == "" {
color.Red(" Missing required flag --deploy-state-uri or DEPLOY_STATE_URI")
}
if cluster == "" {
color.Red(" Missing required flag --cluster or CLUSTER")
}
os.Exit(1)
}
return etcdURI, redisURI, redisQueue, deployStateUri, cluster
}
func errExit(ctx *cli.Context, err error, help bool) {
fmt.Fprintf(os.Stderr, "\nError: %v\n\n", err)
if help {
cli.ShowAppHelp(ctx)
}
os.Exit(1)
}
func main() {
app := cli.NewApp()
app.Name = "rabbitmq-cli-consumer"
app.Usage = "Consume RabbitMQ easily to any cli program"
app.Author = "Richard van den Brand"
app.Email = "*****@*****.**"
app.Version = "1.1.0"
app.Flags = []cli.Flag{
cli.StringFlag{
Name: "executable, e",
Usage: "Location of executable",
},
cli.StringFlag{
Name: "configuration, c",
Usage: "Location of configuration file",
},
cli.BoolFlag{
Name: "verbose, V",
Usage: "Enable verbose mode (logs to stdout and stderr)",
},
}
app.Action = func(c *cli.Context) {
if c.String("configuration") == "" && c.String("executable") == "" {
cli.ShowAppHelp(c)
os.Exit(1)
}
verbose := c.Bool("verbose")
logger := log.New(os.Stderr, "", log.Ldate|log.Ltime)
cfg, err := config.LoadAndParse(c.String("configuration"))
command.Cconf = cfg
if err != nil {
logger.Fatalf("Failed parsing configuration: %s\n", err)
}
errLogger, err := createLogger(cfg.Logs.Error, verbose, os.Stderr)
if err != nil {
logger.Fatalf("Failed creating error log: %s", err)
}
infLogger, err := createLogger(cfg.Logs.Info, verbose, os.Stdout)
if err != nil {
logger.Fatalf("Failed creating info log: %s", err)
}
factory := command.Factory(c.String("executable"))
client, err := consumer.New(cfg, factory, errLogger, infLogger)
if err != nil {
errLogger.Fatalf("Failed creating consumer: %s", err)
}
client.Consume()
}
app.Run(os.Args)
}
func GetKvKey(c *cli.Context) {
if !c.Args().Present() {
cli.ShowAppHelp(c)
return
}
// Get client
cfg, err := NewAppConfig(c)
if err != nil {
log.Errorf("Failed to get client: %v", err)
return
}
kv := cfg.client.KV()
var results []*api.KVPair
for _, a := range append([]string{c.Args().First()}, c.Args().Tail()...) {
if c.Bool("recurse") {
pairs, _, err := kv.List(a, cfg.queryOpts)
if err != nil {
log.Debugf("Could not list keys: %v", err)
continue
}
for _, p := range pairs {
results = append(results, p)
}
continue
}
pair, _, err := kv.Get(a, cfg.queryOpts)
if err != nil {
log.Debugf("Could not retrieve key: %v", err)
continue
}
if pair != nil {
results = append(results, pair)
}
}
if len(results) > 0 {
if c.GlobalBool("verbose") {
for _, r := range results {
bytes, err := marshalPrettyKey(r)
if err != nil {
log.Debugf("Could not marshal JSON: %v\n", err)
}
fmt.Println(string(bytes))
}
return
}
for _, r := range results {
fmt.Printf("%s\n", r.Value)
}
return
}
log.Errorln("Key not found")
}
func FireEvent(c *cli.Context) {
if len(c.Args().First()) < 1 || len(c.Args().Tail()) < 1 {
log.Errorln("name and payload are required")
cli.ShowAppHelp(c)
return
}
cfg, err := NewAppConfig(c)
if err != nil {
log.Errorf("Failed to get client: %v", err)
return
}
event := &api.UserEvent{
Name: c.Args().First(),
Payload: []byte(c.Args().Tail()[0]),
NodeFilter: c.String("node"),
ServiceFilter: c.String("service"),
TagFilter: c.String("tag"),
}
eid, _, err := cfg.client.Event().Fire(event, cfg.writeOpts)
if err != nil {
log.Errorf("Could not fire event: %v", err)
return
}
fmt.Println(eid)
}
func main() {
app := cli.NewApp()
cli.AppHelpTemplate = appHelpTemplate
app.Name = "multic"
app.Version = "0.0.5"
app.Usage = "Run shell commands in multiple directories."
app.Flags = []cli.Flag{
cli.BoolFlag{
Name: "list, l",
Usage: "list configured directory groups",
},
cli.StringSliceFlag{
Name: "group, g",
Value: &cli.StringSlice{},
Usage: "specify a directory group",
},
cli.StringFlag{
Name: "configuration, c",
Value: "~/.multic/config",
Usage: "specify a configuration file",
},
}
app.Action = func(ctx *cli.Context) {
args := ctx.Args()
config := config.LoadConfig(ctx.String("configuration"))
if ctx.IsSet("list") {
printDirectoryGroups(config)
} else if len(args) == 0 {
cli.ShowAppHelp(ctx)
} else {
run(config, ctx.StringSlice("group"), args)
}
}
app.Run(os.Args)
}
func main() {
app := cli.NewApp()
app.Name = "swarm-bench"
app.Usage = "Swarm Benchmarking Tool"
app.Version = "0.1.0"
app.Author = ""
app.Email = ""
app.Flags = []cli.Flag{
cli.IntFlag{
Name: "concurrency, c",
Value: 1,
Usage: "Number of multiple requests to perform at a time. Default is one request at a time.",
},
cli.IntFlag{
Name: "requests, n",
Value: 1,
Usage: "Number of containers to start for the benchmarking session. The default is to just start a single container.",
},
cli.StringFlag{
Name: "image, i",
Usage: "Image to use for benchmarking.",
},
}
app.Action = func(c *cli.Context) {
if c.String("image") == "" {
cli.ShowAppHelp(c)
os.Exit(1)
}
bench(c.Int("requests"), c.Int("concurrency"), c.String("image"))
}
app.Run(os.Args)
}
func run(c *cli.Context) {
args := c.Args()
if len(c.Args()) == 0 {
cli.ShowAppHelp(c)
os.Exit(1)
}
doSplay(c)
suppressRegexpSlice := make(regexpSlice, len(c.StringSlice(`suppress-regexp`)))
for i, s := range c.StringSlice(`suppress-regexp`) {
suppressRegexpSlice[i] = regexp.MustCompile(s)
}
forceRegexpSlice := make(regexpSlice, len(c.StringSlice(`force-regexp`)))
for i, s := range c.StringSlice(`force-regexp`) {
forceRegexpSlice[i] = regexp.MustCompile(s)
}
var cmd *exec.Cmd
if len(args) > 1 {
cmd = exec.Command(args[0], args[1:len(args)]...)
} else {
cmd = exec.Command(args[0])
}
doCmd(c, cmd, forceRegexpSlice, suppressRegexpSlice)
}
func domainRecordCreate(ctx *cli.Context) {
if len(ctx.Args()) < 2 {
cli.ShowAppHelp(ctx)
fmt.Printf("Invalid arguments.\n")
os.Exit(1)
}
client := apiv2.NewClient(APIKey)
domainRecord := client.NewDomainRecord()
domainRecord.Name = ctx.Args().First()
domainRecord.Data = ctx.Args()[1]
domainRecord.Type = strings.ToUpper(ctx.String("type"))
if domainRecord.Type == "MX" || domainRecord.Type == "SRV" {
domainRecord.Priority = ctx.Int("priority")
}
if domainRecord.Type == "SRV" {
domainRecord.Port = ctx.Int("port")
domainRecord.Weight = ctx.Int("weight")
}
domain, err := client.FindDomainFromName(domainRecord.Name)
if err != nil {
fmt.Printf("%s\n", err)
}
domainRecord, createErr := client.CreateDomainRecord(domainRecord, domain)
if createErr != nil {
fmt.Printf("%s\n", createErr)
os.Exit(1)
}
WriteOutput(domainRecord)
}
func printTemplates(c *cli.Context) {
args := c.Args()
output := c.App.Writer
if len(args) == 0 {
cli.ShowAppHelp(c)
}
var wg sync.WaitGroup
contents := make(chan string)
for _, candidate := range args {
wg.Add(1)
go func(candidate string) {
defer wg.Done()
candidate = upperFirstChar(candidate)
content := tryGetTemplate(candidate)
if content != "" {
contents <- fmt.Sprintf("# %s\n%s", candidate, content)
}
}(candidate)
}
go func() {
wg.Wait()
close(contents)
}()
for content := range contents {
fmt.Fprintln(output, content)
}
}
func CmdImport(c *cli.Context) {
var file string
var err error
if file = c.String("file"); file == "" {
fmt.Println("file flag missing")
cli.ShowAppHelp(c)
return
}
data, err := ioutil.ReadFile(file)
if err != nil {
fmt.Println(err.Error())
return
}
importer := api.ImportCreate()
kibanaData, err := api.Parse(data)
if err != nil {
fmt.Println(err.Error())
return
}
err = importer.All(api.Create(c.String("uri")), kibanaData)
if err != nil {
fmt.Println(err.Error())
return
}
fmt.Println("Import successful...")
}
func getdestination(c *cli.Context) (string, string, error) {
var mxServer string
var targetAddress string
var err error
myArgs := c.Args()
if len(myArgs) == 0 {
cli.ShowAppHelp(c)
os.Exit(130)
}
debugprint("Entering getdestination \n")
if len(myArgs) > 1 {
if myArgs[1][:1] != "@" {
mxServer = ""
targetAddress = ""
err = fmt.Errorf("Server argument should be like \"@server\" %q provided", myArgs[1])
} else {
mxServer = myArgs[1][1:]
targetAddress = myArgs[0]
}
} else {
targetAddress = myArgs[0]
mxServer, err = resolvmx(strings.SplitAfter(targetAddress, "@")[1])
if err != nil {
mxServer = ""
}
}
debugprint(fmt.Sprintf("Target address is %s, mxServer is %s, error is %v \n",
targetAddress, mxServer, err))
return targetAddress, mxServer, err
}
func Contrib(c *cli.Context) {
if len(c.Args()) == 0 {
cli.ShowAppHelp(c)
os.Exit(1)
}
names, err := getContributors(c.Args())
if err != nil {
log.Fatal(err)
}
number := c.Int("number")
if number == 0 {
number = 1
}
for i, name := range names {
if i >= number {
break
}
fmt.Println(name)
}
os.Exit(0)
}
func main() {
app := cli.NewApp()
app.Name = "runc"
app.Usage = usage
app.Version = version
app.Flags = []cli.Flag{
cli.StringFlag{
Name: "id",
Value: getDefaultID(),
Usage: "specify the ID to be used for the container",
},
cli.BoolFlag{
Name: "debug",
Usage: "enable debug output for logging",
},
cli.StringFlag{
Name: "root",
Value: "/var/run/ocf",
Usage: "root directory for storage of container state (this should be located in tmpfs)",
},
cli.StringFlag{
Name: "criu",
Value: "criu",
Usage: "path to the criu binary used for checkpoint and restore",
},
}
app.Commands = []cli.Command{
checkpointCommand,
eventsCommand,
restoreCommand,
specCommand,
}
app.Before = func(context *cli.Context) error {
if context.GlobalBool("debug") {
logrus.SetLevel(logrus.DebugLevel)
}
return nil
}
// default action is to execute a container
app.Action = func(context *cli.Context) {
if os.Geteuid() != 0 {
cli.ShowAppHelp(context)
logrus.Fatal("runc should be run as root")
}
spec, err := loadSpec(context.Args().First())
if err != nil {
fatal(err)
}
status, err := execContainer(context, spec)
if err != nil {
fatal(err)
}
// exit with the container's exit status so any external supervisor is
// notified of the exit with the correct exit status.
os.Exit(status)
}
if err := app.Run(os.Args); err != nil {
logrus.Fatal(err)
}
}
func init() {
App.Name = "ha"
App.Usage = "HsoubAcademy command line tool, Ha!"
App.Author = "HsoubAcademy Team"
App.Email = "*****@*****.**"
App.Version = "0.0.1"
App.Commands = []cli.Command{
{
Name: "parse",
Aliases: []string{"p"},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "s, stats",
Usage: "Count words and show external links.",
},
},
Usage: "Parse a Markdown file",
Action: RenderWrapper,
},
}
App.Action = func(c *cli.Context) {
if IsFile(c.Args().First()) {
RenderWrapper(c)
} else {
cli.ShowAppHelp(c)
}
}
}
func setDefaultAction(app *cli.App) {
app.Action = func(c *cli.Context) {
// TODO: If in a focused directory show the list of tasks
// If not show the app help or some basic direction to init it
cli.ShowAppHelp(c)
}
}
func runApp(c *cli.Context) {
debug := c.Bool("debug")
if err := validateCLI(c); err != nil {
log.Println("CLI Validation Error:", err)
cli.ShowAppHelp(c)
os.Exit(1)
}
if !debug {
TurnOffLogging()
}
var sitemap *domain.Sitemap
if useSavedResults(c) {
sitemap = runSitemapLoader(c)
} else {
sitemap = runSitemapBuilder(c)
}
if sitemap == nil {
fmt.Println("Could not build Sitemap")
return
}
outputSitemapToConsole(c, sitemap)
if shouldSaveResults(c) {
outputSitemapToFile(c, sitemap)
}
}
func RunAction(c *cli.Context) error {
config.GrpcPort = c.Int("port")
config.Debug = c.Bool("debug")
config.TlsCertFile = c.String("tls-cert-file")
config.TlsKeyFile = c.String("tls-key-file")
config.ClientID = c.String("client-id")
config.ClientSecret = c.String("client-secret")
config.AuthDiscovery = c.String("discovery")
config.RedisAddr = c.String("redis-addr")
config.RedisDB = c.Int("redis-db")
config.RedisPassword = c.String("redis-password")
config.RedisMasterName = c.String("redis-master")
config.RedisSentinel = c.Bool("redis-sentinel")
storage := c.String("storage")
if config.Debug {
log.SetLevel(log.DebugLevel)
}
if storage == "" || storage == "none" {
cli.ShowAppHelp(c)
return errors.New("storage is not set")
}
driver := drivers.GetDriver(storage)
if driver == nil {
return fmt.Errorf("main.go: storage driver '%s' not found\n", storage)
}
s, err := driver.New(c)
if err != nil {
return fmt.Errorf("main.go: error while creating new storage driver: %v", err)
}
srv := listener.NewServer(config, s)
return srv.ListenGRPC()
}