// SignIn signs in the user and retrieves a session. The passed in Settings // object is updated with the most up to date credentials func SignIn(settings *models.Settings) { // if we're already signed in with a valid session, don't sign in again if verify(settings) { return } if settings.Username == "" || settings.Password == "" { promptForCredentials(settings) } login := models.Login{ Username: settings.Username, Password: settings.Password, } b, err := json.Marshal(login) if err != nil { fmt.Println(err.Error()) os.Exit(1) } resp := httpclient.Post(b, fmt.Sprintf("%s/v2/auth/signin", settings.BaasHost), true, settings) var user models.User json.Unmarshal(resp, &user) settings.SessionToken = user.SessionToken settings.UsersID = user.UsersID config.SaveSettings(settings) }
// Logs is a way to stream logs from Kibana to your local terminal. This is // useful because Kibana is hard to look at because it splits every single // log statement into a separate block that spans multiple lines so it's // not very cohesive. This is intended to be similar to the `heroku logs` // command. func Logs(queryString string, tail bool, hours int, minutes int, seconds int, settings *models.Settings) { if settings.Username == "" || settings.Password == "" { // sometimes this will be filled in from env variables // if it is, just use that and don't prompt them settings.Username = "" settings.Password = "" fmt.Println("Please enter your logging dashboard credentials") } // if we remove the session token, the CLI will prompt for the // username/password normally. It will also set the username/password // on the settings object. sessionToken := settings.SessionToken settings.SessionToken = "" helpers.SignIn(settings) env := helpers.RetrieveEnvironment("pod", settings) var domain = env.Data.DNSName if domain == "" { domain = fmt.Sprintf("%s.catalyze.io", env.Data.Namespace) } urlString := fmt.Sprintf("https://%s/__es", domain) offset := time.Duration(hours)*time.Hour + time.Duration(minutes)*time.Minute + time.Duration(seconds)*time.Second timestamp := time.Now().In(time.UTC).Add(-1 * offset) from := 0 query := &models.LogQuery{ Fields: []string{"@timestamp", "message"}, Query: &models.Query{ Wildcard: map[string]string{ "message": queryString, }, }, Filter: &models.FilterRange{ Range: &models.RangeTimestamp{ Timestamp: map[string]string{ "gt": fmt.Sprintf("%04d-%02d-%02dT%02d:%02d:%02dZ", timestamp.Year(), timestamp.Month(), timestamp.Day(), timestamp.Hour(), timestamp.Minute(), timestamp.Second()), }, }, }, Sort: &models.LogSort{ Timestamp: map[string]string{ "order": "asc", }, Message: map[string]string{ "order": "asc", }, }, From: from, Size: 50, } var tr = &http.Transport{ TLSClientConfig: &tls.Config{ MinVersion: tls.VersionTLS12, }, } client := &http.Client{ Transport: tr, } settings.SessionToken = sessionToken config.SaveSettings(settings) fmt.Println(" @timestamp - message") for { query.From = from b, err := json.Marshal(*query) if err != nil { panic(err) } reader := bytes.NewReader(b) req, _ := http.NewRequest("GET", fmt.Sprintf("%s/_search", urlString), reader) req.SetBasicAuth(settings.Username, settings.Password) resp, err := client.Do(req) if err != nil { fmt.Println(err.Error()) } respBody, _ := ioutil.ReadAll(resp.Body) resp.Body.Close() if resp.StatusCode < 200 || resp.StatusCode >= 300 { fmt.Println(fmt.Errorf("%d %s", resp.StatusCode, string(respBody)).Error()) os.Exit(1) } var logs models.Logs json.Unmarshal(respBody, &logs) for _, lh := range *logs.Hits.Hits { fmt.Printf("%s - %s\n", lh.Fields["@timestamp"][0], lh.Fields["message"][0]) } if !tail { break } time.Sleep(2 * time.Second) from += len(*logs.Hits.Hits) } }
// Logout clears the stored user information from the local machine. This does // not remove environment data. func Logout(settings *models.Settings) { settings.SessionToken = "" settings.UsersID = "" config.SaveSettings(settings) }