func (c *NozzlerCmd) Run(cliConnection plugin.CliConnection, args []string) {
var debug bool
if args[0] != "nozzle" {
return
}
c.ui = terminal.NewUI(os.Stdin, terminal.NewTeePrinter())
fc := flags.NewFlagContext(setupFlags())
err := fc.Parse(args[1:]...)
if err != nil {
c.ui.Failed(err.Error())
}
if fc.IsSet("debug") {
debug = fc.Bool("debug")
}
dopplerEndpoint, err := cliConnection.DopplerEndpoint()
if err != nil {
c.ui.Failed(err.Error())
}
authToken, err := cliConnection.AccessToken()
if err != nil {
c.ui.Failed(err.Error())
}
client := firehose.NewClient(authToken, dopplerEndpoint, debug, c.ui)
client.Start()
}
func (s *FirehoseStatsCmd) Run(cliConnection plugin.CliConnection, args []string) {
if args[0] != "firehose-stats" {
return
}
s.cfUI = terminal.NewUI(os.Stdin, terminal.NewTeePrinter())
dopplerEndpoint, err := cliConnection.DopplerEndpoint()
if err != nil {
s.cfUI.Failed(err.Error())
}
authToken, err := cliConnection.AccessToken()
if err != nil {
s.cfUI.Failed(err.Error())
}
firehoseChan := make(chan *events.Envelope)
client := firehose.NewClient(authToken, dopplerEndpoint, s.cfUI, firehoseChan)
client.Start()
statsUI := stats.New(client, s.cfUI, cliConnection)
statsUI.Start()
}
func (c *NozzlerCmd) Run(cliConnection plugin.CliConnection, args []string) {
var options *firehose.ClientOptions
traceLogger := trace.NewLogger(os.Stdout, true, os.Getenv("CF_TRACE"), "")
c.ui = terminal.NewUI(os.Stdin, os.Stdout, terminal.NewTeePrinter(os.Stdout), traceLogger)
switch args[0] {
case "nozzle":
options = c.buildClientOptions(args)
case "app-nozzle":
options = c.buildClientOptions(args)
appModel, err := cliConnection.GetApp(args[1])
if err != nil {
c.ui.Warn(err.Error())
return
}
options.AppGUID = appModel.Guid
default:
return
}
dopplerEndpoint, err := cliConnection.DopplerEndpoint()
if err != nil {
c.ui.Failed(err.Error())
}
authToken, err := cliConnection.AccessToken()
if err != nil {
c.ui.Failed(err.Error())
}
client := firehose.NewClient(authToken, dopplerEndpoint, options, c.ui)
client.Start()
}
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 (cmd *LogalyzerCmd) Run(cliConnection plugin.CliConnection, args []string) {
port := 8080
aggregationWindow := 2 * time.Second
bufferSize := 100
cmd.ui = terminal.NewUI(os.Stdin, terminal.NewTeePrinter())
cmd.sendChan = make(chan []byte, 256)
if len(args) < 2 {
cmd.ui.Say("Usage: %s\n", cmd.Usage())
cmd.ui.Failed("No App Name given")
}
fc := flags.NewFlagContext(setupFlags())
err := fc.Parse(args[2:]...)
if err != nil {
cmd.ui.Failed(err.Error())
}
if fc.IsSet("p") {
port = fc.Int("p")
}
if fc.IsSet("agg-window") {
aggregationWindow = time.Duration(fc.Int("agg-window")) * time.Second
}
if fc.IsSet("buffer-size") {
bufferSize = fc.Int("buffer-size")
}
appName := args[1]
dopplerEndpoint, err := cliConnection.DopplerEndpoint()
if err != nil {
cmd.ui.Failed(err.Error())
}
appModel, err := cliConnection.GetApp(appName)
if err != nil {
cmd.ui.Failed(err.Error())
}
authToken, err := cliConnection.AccessToken()
if err != nil {
cmd.ui.Failed(err.Error())
}
outputChan := make(chan *events.LogMessage)
errorChan := make(chan error)
dopplerConnection := noaa.NewConsumer(dopplerEndpoint, &tls.Config{InsecureSkipVerify: true}, nil)
go dopplerConnection.TailingLogs(appModel.Guid, authToken, outputChan, errorChan)
go cmd.happyCalcer(aggregationWindow, bufferSize)
go cmd.startServer(cmd.getAssetsDir(), port)
cmd.ui.Say("Webserver is started at http://localhost:%d", port)
for {
select {
case log := <-outputChan:
if log.GetMessageType() == events.LogMessage_ERR {
cmd.errCount++
}
cmd.logCount++
cmd.sendChan <- log.GetMessage()
case err := <-errorChan:
cmd.ui.Failed(err.Error())
}
}
}