func (c *Test1) Run(cliConnection plugin.CliConnection, args []string) { if args[0] == "new-api" { token, _ := cliConnection.AccessToken() fmt.Println("Access Token:", token) fmt.Println("") app, err := cliConnection.GetApp("test_app") fmt.Println("err for test_app", err) fmt.Println("test_app is: ", app) hasOrg, _ := cliConnection.HasOrganization() fmt.Println("Has Organization Targeted:", hasOrg) currentOrg, _ := cliConnection.GetCurrentOrg() fmt.Println("Current Org:", currentOrg) org, _ := cliConnection.GetOrg(currentOrg.Name) fmt.Println(currentOrg.Name, " Org:", org) orgs, _ := cliConnection.GetOrgs() fmt.Println("Orgs:", orgs) hasSpace, _ := cliConnection.HasSpace() fmt.Println("Has Space Targeted:", hasSpace) currentSpace, _ := cliConnection.GetCurrentSpace() fmt.Println("Current space:", currentSpace) space, _ := cliConnection.GetSpace(currentSpace.Name) fmt.Println("Space:", space) spaces, _ := cliConnection.GetSpaces() fmt.Println("Spaces:", spaces) loggregator, _ := cliConnection.LoggregatorEndpoint() fmt.Println("Loggregator Endpoint:", loggregator) dopplerEndpoint, _ := cliConnection.DopplerEndpoint() fmt.Println("Doppler Endpoint:", dopplerEndpoint) user, _ := cliConnection.Username() fmt.Println("Current user:"******"Current user guid:", userGUID) email, _ := cliConnection.UserEmail() fmt.Println("Current user email:", email) hasAPI, _ := cliConnection.HasAPIEndpoint() fmt.Println("Has API Endpoint:", hasAPI) api, _ := cliConnection.ApiEndpoint() fmt.Println("Current api:", api) version, _ := cliConnection.ApiVersion() fmt.Println("Current api version:", version) loggedIn, _ := cliConnection.IsLoggedIn() fmt.Println("Is Logged In:", loggedIn) isSSLDisabled, _ := cliConnection.IsSSLDisabled() fmt.Println("Is SSL Disabled:", isSSLDisabled) } else if args[0] == "test_1_cmd1" { theFirstCmd() } else if args[0] == "test_1_cmd2" { theSecondCmd() } else if args[0] == "CLI-MESSAGE-UNINSTALL" { uninstalling() } }
func Logs(cliConnection plugin.CliConnection, args []string) { appName := args[1] rawOutput, _ := cliConnection.CliCommandWithoutTerminalOutput("curl", fmt.Sprintf("/v3/apps?names=%s", appName)) apps := V3AppsModel{} output := strings.Join(rawOutput, "") json.Unmarshal([]byte(output), &apps) if len(apps.Apps) == 0 { fmt.Printf("App %s not found\n", appName) return } app := apps.Apps[0] messageQueue := logs.NewNoaaMessageQueue() bufferTime := 25 * time.Millisecond ticker := time.NewTicker(bufferTime) logChan := make(chan logs.Loggable) errChan := make(chan error) dopplerEndpoint, err := cliConnection.DopplerEndpoint() FreakOut(err) ssl, err := cliConnection.IsSSLDisabled() FreakOut(err) tlsConfig := net.NewTLSConfig([]tls.Certificate{}, ssl) noaaConsumer := consumer.New(dopplerEndpoint, tlsConfig, http.ProxyFromEnvironment) defer func() { noaaConsumer.Close() flushMessages(logChan, messageQueue) }() onConnect := func() { fmt.Printf("Tailing logs for app %s...\r\n\r\n", appName) } noaaConsumer.SetOnConnectCallback(onConnect) accessToken, err := cliConnection.AccessToken() FreakOut(err) c, e := noaaConsumer.TailingLogs(app.Guid, accessToken) go func() { for { select { case msg, ok := <-c: if !ok { ticker.Stop() flushMessages(logChan, messageQueue) close(logChan) close(errChan) return } messageQueue.PushMessage(msg) case err := <-e: if err != nil { errChan <- err ticker.Stop() close(logChan) close(errChan) return } } } }() go func() { for range ticker.C { flushMessages(logChan, messageQueue) } }() for { select { case msg := <-logChan: fmt.Printf("%s\r\n", logMessageOutput(msg, time.Local)) case err, ok := <-errChan: if !ok { FreakOut(err) } } } }
func Push(cliConnection plugin.CliConnection, args []string) { appDir := "." buildpack := "null" dockerImage := "" fc := flags.New() fc.NewStringFlag("filepath", "p", "path to app dir or zip to upload") fc.NewStringFlag("buildpack", "b", "the buildpack to use") fc.NewStringFlag("docker-image", "di", "the docker image to use") fc.Parse(args...) if fc.IsSet("p") { appDir = fc.String("p") } if fc.IsSet("b") { buildpack = fmt.Sprintf(`"%s"`, fc.String("b")) } if fc.IsSet("di") { dockerImage = fmt.Sprintf(`"%s"`, fc.String("di")) } mySpace, _ := cliConnection.GetCurrentSpace() lifecycle := "" if dockerImage != "" { lifecycle = `"lifecycle": { "type": "docker", "data": {} }` } else { lifecycle = fmt.Sprintf(`"lifecycle": { "type": "buildpack", "data": { "buildpack": %s } }`, buildpack) } //create the app rawOutput, err := cliConnection.CliCommandWithoutTerminalOutput("curl", "/v3/apps", "-X", "POST", "-d", fmt.Sprintf(`{"name":"%s", "relationships": { "space": {"guid":"%s"}}, %s}`, fc.Args()[1], mySpace.Guid, lifecycle)) FreakOut(err) output := strings.Join(rawOutput, "") app := V3AppModel{} err = json.Unmarshal([]byte(output), &app) FreakOut(err) if app.Error_Code != "" { FreakOut(errors.New("Error creating v3 app: " + app.Error_Code)) } time.Sleep(2 * time.Second) // wait for app to settle before kicking off the log streamer go Logs(cliConnection, args) time.Sleep(2 * time.Second) // b/c sharing the cliConnection makes things break //create package pack := V3PackageModel{} if dockerImage != "" { request := fmt.Sprintf(`{"type": "docker", "data": {"image": %s}}`, dockerImage) rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", fmt.Sprintf("/v3/apps/%s/packages", app.Guid), "-X", "POST", "-d", request) FreakOut(err) output = strings.Join(rawOutput, "") err = json.Unmarshal([]byte(output), &pack) if err != nil { FreakOut(errors.New("Error creating v3 app package: " + app.Error_Code)) } } else { //create the empty package to upload the app bits to rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", fmt.Sprintf("/v3/apps/%s/packages", app.Guid), "-X", "POST", "-d", "{\"type\": \"bits\"}") FreakOut(err) output = strings.Join(rawOutput, "") err = json.Unmarshal([]byte(output), &pack) if err != nil { FreakOut(errors.New("Error creating v3 app package: " + app.Error_Code)) } token, err := cliConnection.AccessToken() FreakOut(err) api, apiErr := cliConnection.ApiEndpoint() FreakOut(apiErr) apiString := fmt.Sprintf("%s", api) if strings.Index(apiString, "s") == 4 { apiString = apiString[:4] + apiString[5:] } //gather files zipper := appfiles.ApplicationZipper{} fileutils.TempFile("uploads", func(zipFile *os.File, err error) { zipper.Zip(appDir, zipFile) _, upload := exec.Command("curl", fmt.Sprintf("%s/v3/packages/%s/upload", apiString, pack.Guid), "-F", fmt.Sprintf("bits=@%s", zipFile.Name()), "-H", fmt.Sprintf("Authorization: %s", token), "-H", "Expect:").Output() FreakOut(upload) }) //waiting for cc to pour bits into blobstore Poll(cliConnection, fmt.Sprintf("/v3/packages/%s", pack.Guid), "READY", 5*time.Minute, "Package failed to upload") } rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", fmt.Sprintf("/v3/packages/%s/droplets", pack.Guid), "-X", "POST", "-d", "{}") FreakOut(err) output = strings.Join(rawOutput, "") droplet := V3DropletModel{} err = json.Unmarshal([]byte(output), &droplet) if err != nil { FreakOut(errors.New("error marshaling the v3 droplet: " + err.Error())) } //wait for the droplet to be ready Poll(cliConnection, fmt.Sprintf("/v3/droplets/%s", droplet.Guid), "STAGED", 10*time.Minute, "Droplet failed to stage") //assign droplet to the app rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", fmt.Sprintf("/v3/apps/%s/droplets/current", app.Guid), "-X", "PUT", "-d", fmt.Sprintf("{\"droplet_guid\":\"%s\"}", droplet.Guid)) FreakOut(err) output = strings.Join(rawOutput, "") //pick the first available shared domain, get the guid space, _ := cliConnection.GetCurrentSpace() nextUrl := "/v2/shared_domains" allDomains := DomainsModel{} for nextUrl != "" { rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", nextUrl) FreakOut(err) output = strings.Join(rawOutput, "") tmp := DomainsModel{} err = json.Unmarshal([]byte(output), &tmp) FreakOut(err) allDomains.Resources = append(allDomains.Resources, tmp.Resources...) if tmp.NextUrl != "" { nextUrl = tmp.NextUrl } else { nextUrl = "" } } domainGuid := allDomains.Resources[0].Metadata.Guid rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", "v2/routes", "-X", "POST", "-d", fmt.Sprintf(`{"host":"%s","domain_guid":"%s","space_guid":"%s"}`, fc.Args()[1], domainGuid, space.Guid)) output = strings.Join(rawOutput, "") var routeGuid string if strings.Contains(output, "CF-RouteHostTaken") { rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", fmt.Sprintf("v2/routes?q=host:%s;domain_guid:%s", fc.Args()[1], domainGuid)) output = strings.Join(rawOutput, "") routes := RoutesModel{} err = json.Unmarshal([]byte(output), &routes) routeGuid = routes.Routes[0].Metadata.Guid } else { route := RouteModel{} err = json.Unmarshal([]byte(output), &route) if err != nil { FreakOut(errors.New("error unmarshaling the route: " + err.Error())) } routeGuid = route.Metadata.Guid } FreakOut(err) route := RouteModel{} err = json.Unmarshal([]byte(output), &route) if err != nil { FreakOut(errors.New("error unmarshaling the route: " + err.Error())) } //map the route to the app rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", "/v3/route_mappings", "-X", "POST", "-d", fmt.Sprintf(`{"relationships": { "route": { "guid": "%s" }, "app": { "guid": "%s" } }`, routeGuid, app.Guid)) FreakOut(err) output = strings.Join(rawOutput, "") //start the app rawOutput, err = cliConnection.CliCommandWithoutTerminalOutput("curl", fmt.Sprintf("/v3/apps/%s/start", app.Guid), "-X", "PUT") FreakOut(err) output = strings.Join(rawOutput, "") fmt.Println("Done pushing! Checkout your processes using 'cf apps'") }