func (cmd *OrgUsers) Run(c *cli.Context) {
org := cmd.orgReq.GetOrganization()
all := c.Bool("a")
cmd.ui.Say("Getting users in org %s as %s...",
terminal.EntityNameColor(org.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
roles := orgRoles
if all {
roles = []string{models.ORG_USER}
}
for _, role := range roles {
displayName := orgRoleToDisplayName[role]
users, apiErr := cmd.userRepo.ListUsersInOrgForRole(org.Guid, role)
cmd.ui.Say("")
cmd.ui.Say("%s", terminal.HeaderColor(displayName))
for _, user := range users {
cmd.ui.Say(" %s", user.Username)
}
if apiErr != nil {
cmd.ui.Failed("Failed fetching org-users for role %s.\n%s", apiErr.Error(), displayName)
return
}
}
}
// delete is a subcommand to delete a snippet.
func delete(c *cli.Context) {
force := c.Bool("f")
snippetName := c.Args().First()
if len(snippetName) == 0 {
log.Fatal("please enter snippet name")
}
s := NewSnippet(conf.SnippetDirectory, snippetName)
if !s.Exists() {
log.Fatal("This snippet doesn't exists.")
}
if !force {
reader := bufio.NewReader(os.Stdin)
fmt.Print("sure you want to delete %s [yn]?")
ret, err := reader.ReadString('\n')
if err != nil {
log.Fatal(err)
}
if ret != "y\n" {
return
}
}
if err := s.Delete(); err != nil {
log.Fatal(err)
}
fmt.Printf("%s has been deleted.\n", snippetName)
}
func generate(c *cli.Context) error {
generateServer := c.Bool("server")
outDir := c.String("dir")
hostnames := c.StringSlice("hostname")
return Generate(generateServer, outDir, hostnames)
}
func (cmd CreateBuildpack) createBuildpack(buildpackName string, c *cli.Context) (buildpack models.Buildpack, apiErr error) {
position, err := strconv.Atoi(c.Args()[2])
if err != nil {
apiErr = errors.NewWithFmt("Invalid position. %s", err.Error())
return
}
enabled := c.Bool("enable")
disabled := c.Bool("disable")
if enabled && disabled {
apiErr = errors.New("Cannot specify both enabled and disabled.")
return
}
var enableOption *bool = nil
if enabled {
enableOption = &enabled
}
if disabled {
disabled = false
enableOption = &disabled
}
buildpack, apiErr = cmd.buildpackRepo.Create(buildpackName, &position, enableOption, nil)
return
}
func (cmd *Push) getAppParamsFromManifest(c *cli.Context) []models.AppParams {
if c.Bool("no-manifest") {
return []models.AppParams{}
}
var path string
if c.String("f") != "" {
path = c.String("f")
} else {
var err error
path, err = os.Getwd()
if err != nil {
cmd.ui.Failed(T("Could not determine the current working directory!"), err)
}
}
m, err := cmd.manifestRepo.ReadManifest(path)
if err != nil {
if m.Path == "" && c.String("f") == "" {
return []models.AppParams{}
} else {
cmd.ui.Failed(T("Error reading manifest file:\n{{.Err}}", map[string]interface{}{"Err": err.Error()}))
}
}
apps, err := m.Applications()
if err != nil {
cmd.ui.Failed("Error reading manifest file:\n%s", err)
}
cmd.ui.Say(T("Using manifest file {{.Path}}\n",
map[string]interface{}{"Path": terminal.EntityNameColor(m.Path)}))
return apps
}
func newBuilder(c *cli.Context) builder.Builder {
db, err := docker.NewBuilderFromEnv()
if err != nil {
must(err)
}
db.DryRun = c.Bool("dry")
db.Image = c.String("builder.image")
g := builder.NewGitHubClient(c.String("github.token"))
var backend builder.Builder = builder.UpdateGitHubCommitStatus(db, g, fmt.Sprintf(logsURLTemplate, c.String("url")))
if uri := c.String("stats"); uri != "" {
u := urlParse(uri)
switch u.Scheme {
case "dogstatsd":
c, err := statsd.New(u.Host)
must(err)
backend = datadog.WithStats(
backend,
c,
)
default:
must(fmt.Errorf("Unknown stats backend: %v", u.Scheme))
}
}
b := worker.NewBuilder(backend)
b.Reporter = newReporter(c)
return b
}
func secretParseCmd(name string, value string, c *cli.Context) (*model.Secret, error) {
secret := &model.Secret{}
secret.Name = name
secret.Value = value
secret.Images = c.StringSlice("image")
secret.Events = c.StringSlice("event")
secret.SkipVerify = c.Bool("skip-verify")
secret.Conceal = c.Bool("conceal")
if len(secret.Images) == 0 {
return nil, fmt.Errorf("Please specify the --image parameter")
}
// TODO(bradrydzewski) below we use an @ sybmol to denote that the secret
// value should be loaded from a file (inspired by curl). I'd prefer to use
// a --input flag to explicitly specify a filepath instead.
if strings.HasPrefix(secret.Value, "@") {
path := secret.Value[1:]
out, ferr := ioutil.ReadFile(path)
if ferr != nil {
return nil, ferr
}
secret.Value = string(out)
}
return secret, nil
}
func (cmd ListStack) Run(c *cli.Context) {
stackName := c.Args()[0]
stack, apiErr := cmd.stacksRepo.FindByName(stackName)
if c.Bool("guid") {
cmd.ui.Say(stack.Guid)
} else {
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Say(T("Getting stack '{{.Stack}}' in org {{.OrganizationName}} / space {{.SpaceName}} as {{.Username}}...",
map[string]interface{}{"Stack": stackName,
"OrganizationName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
cmd.ui.Ok()
cmd.ui.Say("")
table := terminal.NewTable(cmd.ui, []string{T("name"), T("description")})
table.Add(stack.Name, stack.Description)
table.Print()
}
}
func run(c *cli.Context) {
plugin := Plugin{
Mount: c.StringSlice("mount"),
Path: c.String("path"),
Repo: c.String("repo.name"),
Default: c.String("repo.branch"),
Branch: c.String("commit.branch"),
}
sftp, err := sftp.New(
c.String("server"),
c.String("username"),
c.String("password"),
c.String("key"),
)
if err != nil {
log.Fatal(err)
}
defer sftp.(io.Closer).Close()
if c.Bool("rebuild") {
now := time.Now()
err = plugin.Rebuild(sftp)
log.Printf("cache built in %v", time.Since(now))
}
if c.Bool("restore") {
now := time.Now()
err = plugin.Restore(sftp)
log.Printf("cache restored in %v", time.Since(now))
}
if err != nil {
log.Println(err) // this plugins does not fail on error
}
}
func RunApp(c *cli.Context) {
dbUrl := c.String("db-url")
if dbUrl == "" {
showErrorAndAbort("you need to provide 'db-url' or $DATABASE_URL needs to be set")
}
if c.Bool("debug") {
logger.SetLevel(loggo.Debug)
}
if c.Bool("quiet") {
logger.SetLevel(loggo.Warning)
}
fixturesPaths := GetFixturesDirectories(c.String("fixtures-path"), c.String("env"))
logger.Debugf("searching for fixtures in: %v", fixturesPaths)
fixtures, err := LoadDirectories(fixturesPaths)
if err != nil {
showErrorAndAbort(err.Error())
}
logger.Debugf("found the following fixtures: %+v", fixtures)
logger.Infof("connecting to DB %s", dbUrl)
populator, err := NewPopulator(dbUrl)
if err != nil {
showErrorAndAbort(err.Error())
}
if err := populator.PopulateData(fixtures); err != nil {
showErrorAndAbort(err.Error())
}
}
func images(c *cli.Context) {
filter := "my_images"
if c.Bool("global") {
filter = "global"
}
images, err := docli.GetImages(filter)
if err != nil {
fatalf(err.Error())
}
switch filter {
case "global":
fmt.Println("Global Images:")
default:
fmt.Println("My Images:")
}
for _, i := range images {
fmt.Printf("%s (slug: %s id: %d)\n",
i.Name,
i.Slug,
i.ID)
}
}
func doGet(c *cli.Context) {
argURL := c.Args().Get(0)
doUpdate := c.Bool("update")
if argURL == "" {
cli.ShowCommandHelp(c, "get")
os.Exit(1)
}
url, err := url.Parse(argURL)
utils.DieIf(err)
if !url.IsAbs() {
url.Scheme = "https"
url.Host = "github.com"
if url.Path[0] != '/' {
url.Path = "/" + url.Path
}
}
remote, err := NewRemoteRepository(url)
utils.DieIf(err)
if remote.IsValid() == false {
utils.Log("error", fmt.Sprintf("Not a valid repository: %s", url))
os.Exit(1)
}
getRemoteRepository(remote, doUpdate)
}
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 runVerify(c *cli.Context) {
config := common.NewConfig()
err := config.LoadConfig(c.String("config"))
if err != nil {
log.Fatalln(err)
return
}
// verify if runner exist
runners := []*common.RunnerConfig{}
for _, runner := range config.Runners {
if common.VerifyRunner(runner.URL, runner.Token) {
runners = append(runners, runner)
}
}
if !c.Bool("delete") {
return
}
// check if anything changed
if len(config.Runners) == len(runners) {
return
}
config.Runners = runners
// save config file
err = config.SaveConfig(c.String("config"))
if err != nil {
log.Fatalln("Failed to update", c.String("config"), err)
}
log.Println("Updated", c.String("config"))
}
//Assign a pull request to the current user.
// If it's taken, show a message with the "--steal" optional flag.
//If the user doesn't have permissions, add a comment #volunteer
func takeCmd(c *cli.Context) {
if !c.Args().Present() {
gordon.Fatalf("usage: take ID")
}
number := c.Args()[0]
pr, err := m.GetPullRequest(number)
if err != nil {
gordon.Fatalf("%s", err)
}
user, err := m.GetGithubUser()
if err != nil {
gordon.Fatalf("%s", err)
}
if pr.Assignee != nil && !c.Bool("steal") {
gordon.Fatalf("Use --steal to steal the PR from %s", pr.Assignee.Login)
}
pr.Assignee = user
patchedPR, err := m.PatchPullRequest(number, pr)
if err != nil {
gordon.Fatalf("%s", err)
}
if patchedPR.Assignee.Login != user.Login {
m.AddComment(number, "#volunteer")
fmt.Printf("No permission to assign. You '%s' was added as #volunteer.\n", user.Login)
} else {
m.AddComment(number, fmt.Sprintf("#assignee=%s", patchedPR.Assignee.Login))
fmt.Printf("Assigned PR %s to %s\n", brush.Green(number), patchedPR.Assignee.Login)
}
}
func (cmd DeleteServiceAuthTokenFields) Run(c *cli.Context) {
tokenLabel := c.Args()[0]
tokenProvider := c.Args()[1]
if c.Bool("f") == false {
if !cmd.ui.ConfirmDelete(T("service auth token"), fmt.Sprintf("%s %s", tokenLabel, tokenProvider)) {
return
}
}
cmd.ui.Say(T("Deleting service auth token as {{.CurrentUser}}",
map[string]interface{}{
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
token, apiErr := cmd.authTokenRepo.FindByLabelAndProvider(tokenLabel, tokenProvider)
switch apiErr.(type) {
case nil:
case *errors.ModelNotFoundError:
cmd.ui.Ok()
cmd.ui.Warn(T("Service Auth Token {{.Label}} {{.Provider}} does not exist.", map[string]interface{}{"Label": tokenLabel, "Provider": tokenProvider}))
return
default:
cmd.ui.Failed(apiErr.Error())
}
apiErr = cmd.authTokenRepo.Delete(token)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
}
func add(c *cli.Context) {
log.Debugln("[ENVMAN] - Work path:", envman.CurrentEnvStoreFilePath)
key := c.String(KeyKey)
expand := !c.Bool(NoExpandKey)
replace := !c.Bool(AppendKey)
var value string
if stdinValue != "" {
value = stdinValue
} else if c.IsSet(ValueKey) {
value = c.String(ValueKey)
} else if c.String(ValueFileKey) != "" {
if v, err := loadValueFromFile(c.String(ValueFileKey)); err != nil {
log.Fatal("[ENVMAN] - Failed to read file value: ", err)
} else {
value = v
}
}
if err := addEnv(key, value, expand, replace); err != nil {
log.Fatal("[ENVMAN] - Failed to add env:", err)
}
log.Debugln("[ENVMAN] - Env added")
if err := logEnvs(); err != nil {
log.Fatal("[ENVMAN] - Failed to print:", err)
}
}
func lint(c *cli.Context) {
home := home(c)
all := c.Bool("all")
if all {
action.LintAll(home)
return
}
minArgs(c, 1, "lint")
a := c.Args()
chartNameOrPath := a[0]
fromHome := util.WorkspaceChartDirectory(home, chartNameOrPath)
fromAbs := filepath.Clean(chartNameOrPath)
_, err := os.Stat(fromAbs)
if err == nil {
action.Lint(fromAbs)
} else {
action.Lint(fromHome)
}
}
func before(c *cli.Context) error {
initLogFormatter()
initHelpAndVersionFlags()
initAppHelpTemplate()
// Log level
if logLevel, err := log.ParseLevel(c.String(LogLevelKey)); err != nil {
log.Fatal("[BITRISE_CLI] - Failed to parse log level:", err)
} else {
log.SetLevel(logLevel)
}
// Befor parsing cli, and running command
// we need to decide wich path will be used by envman
envman.CurrentEnvStoreFilePath = c.String(PathKey)
if envman.CurrentEnvStoreFilePath == "" {
if path, err := envStorePathInCurrentDir(); err != nil {
log.Fatal("[ENVMAN] - Failed to set envman work path in current dir:", err)
} else {
envman.CurrentEnvStoreFilePath = path
}
}
envman.ToolMode = c.Bool(ToolKey)
if envman.ToolMode {
log.Info("[ENVMAN] - Tool mode on")
}
if _, err := envman.GetConfigs(); err != nil {
log.Fatal("[ENVMAN] - Failed to init configs:", err)
}
return nil
}
func (cmd *Curl) Run(c *cli.Context) {
path := c.Args()[0]
method := c.String("X")
headers := c.StringSlice("H")
body := c.String("d")
verbose := c.Bool("v")
reqHeader := strings.Join(headers, "\n")
if verbose {
trace.EnableTrace()
}
respHeader, respBody, apiResponse := cmd.curlRepo.Request(method, path, reqHeader, body)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed("Error creating request:\n%s", apiResponse.Message)
return
}
if verbose {
return
}
if c.Bool("i") {
cmd.ui.Say("%s", respHeader)
}
cmd.ui.Say("%s", respBody)
return
}
func restoreContainer(context *cli.Context, spec *specs.Spec, config *configs.Config, imagePath string) (code int, err error) {
var (
rootuid = 0
rootgid = 0
id = context.Args().First()
)
factory, err := loadFactory(context)
if err != nil {
return -1, err
}
container, err := factory.Load(id)
if err != nil {
container, err = factory.Create(id, config)
if err != nil {
return -1, err
}
}
options := criuOptions(context)
status, err := container.Status()
if err != nil {
logrus.Error(err)
}
if status == libcontainer.Running {
fatalf("Container with id %s already running", id)
}
setManageCgroupsMode(context, options)
// ensure that the container is always removed if we were the process
// that created it.
detach := context.Bool("detach")
if !detach {
defer destroy(container)
}
process := &libcontainer.Process{}
tty, err := setupIO(process, rootuid, rootgid, "", false, detach)
if err != nil {
return -1, err
}
defer tty.Close()
handler := newSignalHandler(tty, !context.Bool("no-subreaper"))
if err := container.Restore(process, options); err != nil {
return -1, err
}
if err := tty.ClosePostStart(); err != nil {
return -1, err
}
if pidFile := context.String("pid-file"); pidFile != "" {
if err := createPidFile(pidFile, process); err != nil {
process.Signal(syscall.SIGKILL)
process.Wait()
return -1, err
}
}
if detach {
return 0, nil
}
return handler.forward(process)
}
func (factory *AppRunnerCommandFactory) updateAppRoutes(c *cli.Context) {
appName := c.Args().First()
userDefinedRoutes := c.Args().Get(1)
noRoutesFlag := c.Bool("no-routes")
if appName == "" || (userDefinedRoutes == "" && !noRoutesFlag) {
factory.UI.SayIncorrectUsage("Please enter 'ltc update-routes APP_NAME NEW_ROUTES' or pass '--no-routes' flag.")
factory.ExitHandler.Exit(exit_codes.InvalidSyntax)
return
}
desiredRoutes := app_runner.RouteOverrides{}
var err error
if !noRoutesFlag {
desiredRoutes, err = factory.ParseRouteOverrides(userDefinedRoutes)
if err != nil {
factory.UI.SayLine(err.Error())
factory.ExitHandler.Exit(exit_codes.InvalidSyntax)
return
}
}
if err := factory.AppRunner.UpdateAppRoutes(appName, desiredRoutes); err != nil {
factory.UI.SayLine(fmt.Sprintf("Error updating routes: %s", err))
factory.ExitHandler.Exit(exit_codes.CommandFailed)
return
}
factory.UI.SayLine(fmt.Sprintf("Updating %s routes. You can check this app's current routes by running 'ltc status %s'", appName, appName))
}
func (cmd *Push) Run(c *cli.Context) {
appSet := cmd.findAndValidateAppsToPush(c)
_, apiErr := cmd.authRepo.RefreshAuthToken()
if apiErr != nil {
cmd.ui.Failed(fmt.Sprintf("Error refreshing auth token.\n%s", apiErr.Error()))
return
}
routeActor := actors.NewRouteActor(cmd.ui, cmd.routeRepo)
noHostname := c.Bool("no-hostname")
for _, appParams := range appSet {
cmd.fetchStackGuid(&appParams)
app := cmd.createOrUpdateApp(appParams)
cmd.updateRoutes(routeActor, app, appParams, noHostname)
cmd.ui.Say(T("Uploading {{.AppName}}...",
map[string]interface{}{"AppName": terminal.EntityNameColor(app.Name)}))
apiErr := cmd.appBitsRepo.UploadApp(app.Guid, *appParams.Path, cmd.describeUploadOperation)
if apiErr != nil {
cmd.ui.Failed(fmt.Sprintf(T("Error uploading application.\n{{.ApiErr}}",
map[string]interface{}{"ApiErr": apiErr.Error()})))
return
}
cmd.ui.Ok()
if appParams.ServicesToBind != nil {
cmd.bindAppToServices(*appParams.ServicesToBind, app)
}
cmd.restart(app, appParams, c)
}
}
func (cmd CreateBuildpack) createBuildpack(buildpackName string, c *cli.Context) (buildpack models.Buildpack, apiErr error) {
position, err := strconv.Atoi(c.Args()[2])
if err != nil {
apiErr = errors.NewWithFmt(T("Invalid position. {{.ErrorDescription}}", map[string]interface{}{"ErrorDescription": err.Error()}))
return
}
enabled := c.Bool("enable")
disabled := c.Bool("disable")
if enabled && disabled {
apiErr = errors.New(T("Cannot specify both {{.Enabled}} and {{.Disabled}}.", map[string]interface{}{
"Enabled": "enabled",
"Disabled": "disabled",
}))
return
}
var enableOption *bool = nil
if enabled {
enableOption = &enabled
}
if disabled {
disabled = false
enableOption = &disabled
}
buildpack, apiErr = cmd.buildpackRepo.Create(buildpackName, &position, enableOption, nil)
return
}
func (cmd CreateBuildpack) createBuildpack(buildpackName string, c *cli.Context) (buildpack cf.Buildpack, apiResponse net.ApiResponse) {
position, err := strconv.Atoi(c.Args()[2])
if err != nil {
apiResponse = net.NewApiResponseWithMessage("Invalid position. %s", err.Error())
return
}
enabled := c.Bool("enable")
disabled := c.Bool("disable")
if enabled && disabled {
apiResponse = net.NewApiResponseWithMessage("Cannot specify both enabled and disabled.")
return
}
var enableOption *bool = nil
if enabled {
enableOption = &enabled
}
if disabled {
disabled = false
enableOption = &disabled
}
buildpack, apiResponse = cmd.buildpackRepo.Create(buildpackName, &position, enableOption)
return
}
func InstallAction(c *cli.Context) {
if c.Bool("debug") {
log.SetOutputLevel(log.Ldebug)
}
if len(c.Args()) < 1 {
log.Fatal("Need at lease one argument")
}
// log.Println(GOBIN)
pkgName := c.Args().First()
// TODO: use myname for now
if len(strings.Split(pkgName, "/")) == 1 {
pkgName = "gobuild-official/" + pkgName
}
prompt("Repository %v", pkgName)
dest, err := downloadSource(pkgName)
if err != nil {
log.Fatal(err)
}
err = deployPackage(pkgName, dest, GOBIN)
if err != nil {
log.Fatal(err)
}
prompt("Program [%s] installed", pkgName)
}
// add is a subcommand to create a new snippet.
func add(c *cli.Context) {
snippetName := c.Args().First()
if len(snippetName) == 0 {
log.Fatal("please enter snippet name")
}
s := NewSnippet(conf.SnippetDirectory, snippetName)
if s.Exists() {
log.Fatal("This snippet already exists.")
}
stdinFlag := c.Bool("s")
switch {
case stdinFlag:
// read contents from standard input
buf, err := ioutil.ReadAll(os.Stdin)
if err != nil {
log.Fatal(err)
}
// write contents to snippet
s.Write(buf)
default:
f, err := s.Create()
if err != nil {
log.Fatal(err)
}
f.Close()
openSnippetWithEditor(s)
}
}
func DisplayPullRequests(c *cli.Context, pulls []*gh.PullRequest, notrunc bool) {
w := newTabwriter()
fmt.Fprintf(w, "NUMBER\tSHA\tLAST UPDATED\tCONTRIBUTOR\tASSIGNEE\tTITLE")
if c.Bool("lgtm") {
fmt.Fprintf(w, "\tLGTM")
}
fmt.Fprintf(w, "\n")
for _, p := range pulls {
if !notrunc {
p.Title = truncate(p.Title)
}
var assignee string
if p.Assignee != nil {
assignee = p.Assignee.Login
}
fmt.Fprintf(w, "%d\t%s\t%s\t%s\t%s\t%s", p.Number, p.Head.Sha[:8], HumanDuration(time.Since(p.UpdatedAt)), p.User.Login, assignee, p.Title)
if c.Bool("lgtm") {
lgtm := strconv.Itoa(p.ReviewComments)
if p.ReviewComments >= 2 {
lgtm = Green(lgtm)
} else if p.ReviewComments == 0 {
lgtm = DarkRed(lgtm)
} else {
lgtm = DarkYellow(lgtm)
}
fmt.Fprintf(w, "\t%s", lgtm)
}
fmt.Fprintf(w, "\n")
}
if err := w.Flush(); err != nil {
fmt.Fprintf(os.Stderr, "%s", err)
}
}
func deleteVersion(c *cli.Context) {
if c.NArg() != 1 {
cliutils.Exit(cliutils.ExitCodeError, "Wrong number of arguments. "+cliutils.GetDocumentationMessage())
}
versionDetails, err := utils.CreateVersionDetails(c.Args().Get(0))
if err != nil {
cliutils.Exit(cliutils.ExitCodeError, err.Error())
}
bintrayDetails, err := createBintrayDetails(c, true)
if err != nil {
cliutils.Exit(cliutils.ExitCodeError, err.Error())
}
if !c.Bool("quiet") {
var confirm string
fmt.Print("Delete version " + versionDetails.Version +
" of package " + versionDetails.Package + "? (y/n): ")
fmt.Scanln(&confirm)
if !cliutils.ConfirmAnswer(confirm) {
return
}
}
err = commands.DeleteVersion(versionDetails, bintrayDetails)
cliutils.ExitOnErr(err)
}
func Action(c *cli.Context) {
if len(c.Args()) != 1 {
logrus.Fatalf("usage: gotty-client [GoTTY URL]")
}
// setting up logrus
logrus.SetOutput(os.Stderr)
if c.Bool("debug") {
logrus.SetLevel(logrus.DebugLevel)
} else {
logrus.SetLevel(logrus.InfoLevel)
}
// create Client
url := c.Args()[0]
client, err := gottyclient.NewClient(url)
if err != nil {
logrus.Fatalf("Cannot create client: %v", err)
}
if c.Bool("skip-tls-verify") {
client.SkipTLSVerify = true
}
// loop
if err = client.Loop(); err != nil {
logrus.Fatalf("Communication error: %v", err)
}
}