func getFromCache(repo string) (checksResp, error) {
// try and fetch from boltdb
db, err := bolt.Open(DBPath, 0600, &bolt.Options{Timeout: 1 * time.Second})
if err != nil {
return checksResp{}, fmt.Errorf("failed to open bolt database during GET: %v", err)
}
defer db.Close()
resp := checksResp{}
err = db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(RepoBucket))
if b == nil {
return errors.New("No repo bucket")
}
cached := b.Get([]byte(repo))
if cached == nil {
return fmt.Errorf("%q not found in cache", repo)
}
err = json.Unmarshal(cached, &resp)
if err != nil {
return fmt.Errorf("failed to parse JSON for %q in cache", repo)
}
return nil
})
if err != nil {
return resp, err
}
resp.LastRefresh = resp.LastRefresh.UTC()
resp.HumanizedLastRefresh = humanize.Time(resp.LastRefresh.UTC())
return resp, nil
}
func main() {
var simple = flag.Bool("simple", false, "Use simple (debugging) output format")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s [options] <VPN ID>\n", path.Base(os.Args[0]))
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() != 1 {
flag.Usage()
os.Exit(1)
}
client, err := clcv2.NewCLIClient()
if err != nil {
exit.Fatal(err.Error())
}
vpn, err := client.GetVPN(flag.Arg(0))
if err != nil {
exit.Fatalf("failed to query VPN %s: %s", flag.Arg(0), err)
}
if *simple {
pretty.Println(vpn)
} else {
table := tablewriter.NewWriter(os.Stdout)
table.SetAutoFormatHeaders(false)
table.SetAlignment(tablewriter.ALIGN_LEFT)
table.SetAutoWrapText(false)
// table.SetHeader([]string{"CLC => Remote", "CLC Nets", "Remote", "Remote Nets", "ID", "Last Change", })
modifiedStr := humanize.Time(vpn.ChangeInfo.ModifiedDate)
// The ModifiedBy field can be an email address, or an API Key (hex string)
if _, err := hex.DecodeString(vpn.ChangeInfo.ModifiedBy); err == nil {
modifiedStr += " via API Key"
} else {
modifiedStr += ", by " + vpn.ChangeInfo.ModifiedBy
}
table.Append([]string{fmt.Sprintf("%s subnets:", vpn.Local.LocationAlias), strings.Join(vpn.Local.Subnets, ", ")})
table.Append([]string{fmt.Sprintf("%s endpoint:", vpn.Local.LocationAlias), vpn.Local.Address})
table.Append([]string{fmt.Sprintf("%s endpoint:", vpn.Remote.SiteName), vpn.Remote.Address})
table.Append([]string{fmt.Sprintf("%s subnets:", vpn.Remote.SiteName), strings.Join(vpn.Remote.Subnets, ", ")})
table.Append([]string{"IKE configuration:", fmt.Sprintf("%s, %s/%s, Key: %q, NAT traversal: %t, Lifetime: %s",
vpn.IKE.DiffieHellmanGroup,
vpn.IKE.Encryption, vpn.IKE.Hashing, vpn.IKE.PreSharedKey,
vpn.IKE.NatTraversal,
time.Duration(vpn.IKE.Lifetime)*time.Second)})
table.Append([]string{"IPsec configuration:", fmt.Sprintf("%s, %s/%s, %s, Lifetime: %s",
vpn.IPsec.Pfs, vpn.IPsec.Encryption, vpn.IPsec.Hashing,
strings.ToUpper(vpn.IPsec.Protocol), time.Duration(vpn.IPsec.Lifetime)*time.Second)})
table.Append([]string{"Last change:", modifiedStr})
table.Render()
}
}
func homeHandler(w http.ResponseWriter, r *http.Request) {
data.Title = "Home"
data.Posts = make([]Post, 5)
for k, v := range posts[:5] {
data.Posts[k] = *v
data.Posts[k].PrettyDate = humanize.Time(v.Date)
}
fmt.Fprint(w, mustache.RenderFileInLayout("templates/home.html.mustache", "templates/layout.html.mustache", data))
}
func (a arriba) prettyPrintChannelStandup(cstandup channelStandup) string {
text := "¡Ándale! ¡Ándale! here's the standup status :tada:\n"
for _, userID := range cstandup.getKeysByTimestamp() {
standupMsg := cstandup[userID]
humanTime := humanize.Time(standupMsg.ts)
userName := a.getUserName(userID)
text += fmt.Sprintf("*%s*: %s _(%s)_\n", userName, standupMsg.text, humanTime)
}
return text
}
func printStats() {
statTimer := time.NewTicker(30 * time.Second)
for {
<-statTimer.C
var memstats runtime.MemStats
runtime.ReadMemStats(&memstats)
log.Printf("stats [up since: %s]\n", humanize.Time(timeStarted))
log.Printf(" - CPUTemp=%.02f deg C, MemStats.Alloc=%s, MemStats.Sys=%s, totalNetworkMessagesSent=%s\n", globalStatus.CPUTemp, humanize.Bytes(uint64(memstats.Alloc)), humanize.Bytes(uint64(memstats.Sys)), humanize.Comma(int64(totalNetworkMessagesSent)))
log.Printf(" - UAT/min %s/%s [maxSS=%.02f%%], ES/min %s/%s\n", humanize.Comma(int64(globalStatus.UAT_messages_last_minute)), humanize.Comma(int64(globalStatus.UAT_messages_max)), float64(maxSignalStrength)/10.0, humanize.Comma(int64(globalStatus.ES_messages_last_minute)), humanize.Comma(int64(globalStatus.ES_messages_max)))
log.Printf(" - Total traffic targets tracked=%s, last GPS fix: %s, GPS solution type: %d, NACp: %d, est accuracy %.02f m\n", humanize.Comma(int64(len(seenTraffic))), humanize.Time(mySituation.LastFixLocalTime), mySituation.quality, mySituation.NACp, mySituation.Accuracy)
}
}
func main() {
var simple = flag.Bool("simple", false, "Use simple (debugging) output format")
flag.Parse()
client, err := clcv2.NewCLIClient()
if err != nil {
exit.Fatal(err.Error())
}
vpns, err := client.GetVPNs()
if err != nil {
exit.Fatalf("failed to list VPNs: %s", err)
}
if len(vpns) == 0 {
fmt.Printf("No VPNs registered for account %s.\n", client.AccountAlias)
} else if *simple {
pretty.Println(vpns)
} else {
table := tablewriter.NewWriter(os.Stdout)
table.SetAutoFormatHeaders(false)
table.SetAlignment(tablewriter.ALIGN_LEFT)
table.SetAutoWrapText(true)
table.SetHeader([]string{"CLC => Remote", "CLC Nets",
"Remote", "Remote Nets", "ID", "Last Change",
})
for _, v := range vpns {
modifiedStr := humanize.Time(v.ChangeInfo.ModifiedDate)
// The ModifiedBy field can be an email address, or an API Key (hex string)
if _, err := hex.DecodeString(v.ChangeInfo.ModifiedBy); err == nil {
modifiedStr += " via API Key"
} else if len(v.ChangeInfo.ModifiedBy) > 6 {
modifiedStr += " by " + v.ChangeInfo.ModifiedBy[:6]
} else {
modifiedStr += " by " + v.ChangeInfo.ModifiedBy
}
table.Append([]string{
fmt.Sprintf("%s => %-15s", v.Local.LocationAlias, v.Remote.Address),
strings.Join(v.Local.Subnets, ", "),
v.Remote.SiteName,
strings.Join(v.Remote.Subnets, ", "),
v.ID,
modifiedStr,
})
}
table.Render()
}
}
func (a arriba) prettyPrintChannelStandup(cstandup channelStandup) string {
text := "¡Ándale! ¡Ándale! here's the standup status :tada:\n"
for _, userID := range cstandup.getKeysByTimestamp() {
standupMsg := cstandup[userID]
humanTime := humanize.Time(standupMsg.ts)
userName := a.getUserName(userID)
// Inject zero-width unicode character in username to avoid notifying users
if len(userName) > 1 {
userName = string(userName[0]) + "\ufeff" + string(userName[1:])
}
text += fmt.Sprintf("*%s*: %s _(%s)_\n", userName, standupMsg.text, humanTime)
}
return text
}
func (p PgpUI) OutputSignatureSuccess(_ context.Context, arg keybase1.OutputSignatureSuccessArg) error {
signedAt := keybase1.FromTime(arg.SignedAt)
un := ColorString("bold", arg.Username)
output := func(fmtString string, args ...interface{}) {
s := fmt.Sprintf(fmtString, args...)
s = ColorString("green", s)
p.w.Write([]byte(s))
}
if signedAt.IsZero() {
output("Signature verified. Signed by %s.\n", un)
} else {
output("Signature verified. Signed by %s %s (%s).\n", un, humanize.Time(signedAt), signedAt)
}
output("PGP Fingerprint: %s.\n", arg.Fingerprint)
return nil
}
// InitSystem register's dice commands on module load
func InitSystem(mod *modules.Module) {
owner := &modules.OwnerPermission{}
mod.AddResponse(quitreg, func(r *modules.Response) {
r.Respond("okey, " + r.Nick + "! Goodbye everypony!")
syscall.Kill(syscall.Getpid(), syscall.SIGINT)
}, owner)
mod.AddResponse(restartreg, func(r *modules.Response) {
r.Respond("okey, " + r.Nick + "! Reebooot!")
syscall.Kill(syscall.Getpid(), syscall.SIGUSR2)
}, owner)
mod.AddResponse(joinpartreg, func(r *modules.Response) {
if r.Matches[1] == "join" {
if len(r.Matches)-1 >= 3 && r.Matches[3] != "" {
r.Server.Join("#" + r.Matches[3])
r.Respond("okey, " + r.Nick + "! let'z join " + "#" + r.Matches[3])
} else {
r.Mention("tell me where to join!")
}
} else if r.Matches[1] == "part" {
if len(r.Matches)-1 >= 3 && r.Matches[3] != "" {
r.Respond("okey, " + r.Nick + "! let'z leave " + "#" + r.Matches[3])
r.Server.Part("#" + r.Matches[3])
} else if r.Channel != "" {
r.Respond("okey, " + r.Nick + " leaving from here!")
r.Server.Part(r.Channel)
} else {
r.Mention("tell me from what to leave!")
}
}
}, owner)
mod.AddResponse(nickreg, func(r *modules.Response) {
r.Server.Nick(r.Matches[1])
r.Respond("okey, " + r.Nick + "! Let'z talk as another pony!")
}, owner)
mod.AddResponse(statsreg, func(r *modules.Response) {
mem := &runtime.MemStats{}
runtime.ReadMemStats(mem)
r.Respond("PID: " + strconv.Itoa(syscall.Getpid()) + ", last (re)start: " + human.Time(startTime) + ", sys memory: " + human.Bytes(mem.Sys))
}, owner)
}
func (c *CmdDecrypt) explainDecryptionFailure(info *keybase1.SaltpackEncryptedMessageInfo) {
if info == nil {
return
}
out := c.G().UI.GetTerminalUI().ErrorWriter()
prnt := func(s string, args ...interface{}) {
fmt.Fprintf(out, s, args...)
}
if len(info.Devices) > 0 {
prnt("Decryption failed; try one of these devices instead:\n")
for _, d := range info.Devices {
t := keybase1.FromTime(d.CTime)
prnt(" * %s (%s); provisioned %s (%s)\n", ColorString("bold", d.Name), d.Type,
humanize.Time(t), t.Format("2006-01-02 15:04:05 MST"))
}
if info.NumAnonReceivers > 0 {
prnt("Additionally, there were %d hidden receivers for this message\n", info.NumAnonReceivers)
}
} else if info.NumAnonReceivers > 0 {
prnt("Decryption failed; it was encrypted for %d hidden receivers, which may or may not you\n", info.NumAnonReceivers)
} else {
prnt("Decryption failed; message wasn't encrypted for any of your known keys\n")
}
}
func HumanizeTime(then int64) string {
return humanize.Time(time.Unix(then, 0))
}
// Show condensed details of multiple servers
// @client: authenticated CLCv2 Client
// @servnames: server names
func showServers(client *clcv2.CLIClient, servnames ...string) {
var truncate = func(s string, maxlen int) string {
if len(s) >= maxlen {
s = s[:maxlen]
}
return s
}
table := tablewriter.NewWriter(os.Stdout)
table.SetAutoFormatHeaders(false)
table.SetAlignment(tablewriter.ALIGN_LEFT)
table.SetAutoWrapText(true)
table.SetHeader([]string{
"Name", "Group", "Description", "OS",
"IP", "CPU", "Mem", "Storage",
"Status", "Last Change",
})
for _, servname := range servnames {
server, err := client.GetServer(servname)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to list details of server %q: %s", servname, err)
continue
}
grp, err := client.GetGroup(server.GroupId)
if err != nil {
exit.Fatalf("failed to resolve %s group UUID: %s", servname, err)
}
IPs := []string{}
for _, ip := range server.Details.IpAddresses {
if ip.Public != "" {
IPs = append(IPs, ip.Public)
}
if ip.Internal != "" {
IPs = append(IPs, ip.Internal)
}
}
status := server.Details.PowerState
if server.Details.InMaintenanceMode {
status = "MAINTENANCE"
} else if server.Status != "active" {
status = server.Status
}
desc := server.Description
if server.IsTemplate {
desc = "TPL: " + desc
}
modifiedStr := humanize.Time(server.ChangeInfo.ModifiedDate)
/* The ModifiedBy field can be an email address, or an API Key (hex string) */
if _, err := hex.DecodeString(server.ChangeInfo.ModifiedBy); err == nil {
modifiedStr += " via API Key"
} else {
modifiedStr += " by " + truncate(server.ChangeInfo.ModifiedBy, 6)
}
// Append a tilde (~) to indicate it has snapshots
serverName := server.Name
if len(server.Details.Snapshots) > 0 {
serverName += "~"
}
table.Append([]string{
serverName, grp.Name, truncate(desc, 30), truncate(server.OsType, 15),
strings.Join(IPs, " "),
fmt.Sprint(server.Details.Cpu), fmt.Sprintf("%d G", server.Details.MemoryMb/1024),
fmt.Sprintf("%d G", server.Details.StorageGb),
status, modifiedStr,
})
}
table.Render()
}
func (fi FileInfo) representTimeDetailed() string {
return humanize.Time(fi.f.ModTime()) + " (" + fi.f.ModTime().String() + ")"
}
func newChecksResp(repo string, forceRefresh bool) (checksResp, error) {
if !forceRefresh {
resp, err := getFromCache(repo)
if err != nil {
// just log the error and continue
log.Println(err)
} else {
resp.Grade = grade(resp.Average * 100) // grade is not stored for some repos, yet
return resp, nil
}
}
// fetch the repo and grade it
err := goGet(repo, "")
if err != nil {
return checksResp{}, fmt.Errorf("could not clone repo: %v", err)
}
dir := dirName(repo)
filenames, err := check.GoFiles(dir)
if err != nil {
return checksResp{}, fmt.Errorf("could not get filenames: %v", err)
}
if len(filenames) == 0 {
return checksResp{}, fmt.Errorf("no .go files found")
}
checks := []check.Check{
check.GoFmt{Dir: dir, Filenames: filenames},
check.GoVet{Dir: dir, Filenames: filenames},
check.GoLint{Dir: dir, Filenames: filenames},
check.GoCyclo{Dir: dir, Filenames: filenames},
check.License{Dir: dir, Filenames: []string{}},
check.Misspell{Dir: dir, Filenames: filenames},
check.IneffAssign{Dir: dir, Filenames: filenames},
check.ErrCheck{Dir: dir, Filenames: filenames},
}
ch := make(chan score)
for _, c := range checks {
go func(c check.Check) {
p, summaries, err := c.Percentage()
if err != nil {
log.Printf("ERROR: (%s) %v", c.Name(), err)
}
s := score{
Name: c.Name(),
Description: c.Description(),
FileSummaries: summaries,
Weight: c.Weight(),
Percentage: p,
}
ch <- s
}(c)
}
resp := checksResp{
Repo: repo,
Files: len(filenames),
LastRefresh: time.Now().UTC(),
HumanizedLastRefresh: humanize.Time(time.Now().UTC()),
}
var total float64
var totalWeight float64
var issues = make(map[string]bool)
for i := 0; i < len(checks); i++ {
s := <-ch
resp.Checks = append(resp.Checks, s)
total += s.Percentage * s.Weight
totalWeight += s.Weight
for _, fs := range s.FileSummaries {
issues[fs.Filename] = true
}
}
total /= totalWeight
sort.Sort(ByWeight(resp.Checks))
resp.Average = total
resp.Issues = len(issues)
resp.Grade = grade(total * 100)
return resp, nil
}
func (fi FileInfo) representTime() string {
return humanize.Time(fi.f.ModTime())
}
func printStats() {
statTimer := time.NewTicker(30 * time.Second)
for {
<-statTimer.C
var memstats runtime.MemStats
runtime.ReadMemStats(&memstats)
log.Printf("stats [started: %s]\n", humanize.RelTime(time.Time{}, stratuxClock.Time, "ago", "from now"))
log.Printf(" - CPUTemp=%.02f deg C, MemStats.Alloc=%s, MemStats.Sys=%s, totalNetworkMessagesSent=%s\n", globalStatus.CPUTemp, humanize.Bytes(uint64(memstats.Alloc)), humanize.Bytes(uint64(memstats.Sys)), humanize.Comma(int64(totalNetworkMessagesSent)))
log.Printf(" - UAT/min %s/%s [maxSS=%.02f%%], ES/min %s/%s\n, Total traffic targets tracked=%s", humanize.Comma(int64(globalStatus.UAT_messages_last_minute)), humanize.Comma(int64(globalStatus.UAT_messages_max)), float64(maxSignalStrength)/10.0, humanize.Comma(int64(globalStatus.ES_messages_last_minute)), humanize.Comma(int64(globalStatus.ES_messages_max)), humanize.Comma(int64(len(seenTraffic))))
if globalSettings.GPS_Enabled {
log.Printf(" - Last GPS fix: %s, GPS solution type: %d using %d satellites (%d/%d seen/tracked), NACp: %d, est accuracy %.02f m\n", humanize.Time(mySituation.LastFixLocalTime), mySituation.quality, mySituation.Satellites, mySituation.SatellitesSeen, mySituation.SatellitesTracked, mySituation.NACp, mySituation.Accuracy)
log.Printf(" - GPS vertical velocity: %.02f ft/sec; GPS vertical accuracy: %v m\n", mySituation.GPSVertVel, mySituation.AccuracyVert)
}
}
}
// Show details of a single server
// @client: authenticated CLCv2 Client
// @servname: server name
func showServer(client *clcv2.CLIClient, servname string) {
server, err := client.GetServer(servname)
if err != nil {
exit.Fatalf("failed to list details of server %q: %s", servname, err)
}
grp, err := client.GetGroup(server.GroupId)
if err != nil {
exit.Fatalf("failed to resolve group UUID: %s", err)
}
/* First public, then private */
IPs := []string{}
for _, ip := range server.Details.IpAddresses {
if ip.Public != "" {
IPs = append(IPs, ip.Public)
}
}
for _, ip := range server.Details.IpAddresses {
if ip.Internal != "" {
IPs = append(IPs, ip.Internal)
}
}
table := tablewriter.NewWriter(os.Stdout)
table.SetAutoFormatHeaders(false)
table.SetAlignment(tablewriter.ALIGN_LEFT)
table.SetAutoWrapText(true)
// CPU, Memory, IP and Power status are not filled in until the server reaches 'active' state.
if server.Status == "active" {
table.SetHeader([]string{
"Name", "Group", "Description", "OS",
"CPU", "Mem", "IP", "Power",
"Last Change",
})
} else {
table.SetHeader([]string{
"Name", "Group", "Description", "OS",
"Status",
"Owner", "Last Change",
})
}
modifiedStr := humanize.Time(server.ChangeInfo.ModifiedDate)
/* The ModifiedBy field can be an email address, or an API Key (hex string) */
if _, err := hex.DecodeString(server.ChangeInfo.ModifiedBy); err == nil {
modifiedStr += " via API Key"
} else if len(server.ChangeInfo.ModifiedBy) > 6 {
modifiedStr += " by " + server.ChangeInfo.ModifiedBy[:6]
} else {
modifiedStr += " by " + server.ChangeInfo.ModifiedBy
}
if server.Status == "active" {
table.Append([]string{
server.Name, grp.Name, server.Description, server.OsType,
fmt.Sprint(server.Details.Cpu), fmt.Sprintf("%d G", server.Details.MemoryMb/1024), strings.Join(IPs, " "), server.Details.PowerState,
modifiedStr,
})
} else {
table.Append([]string{
server.Name, grp.Name, server.Description, server.OsType,
server.Status,
server.ChangeInfo.CreatedBy, modifiedStr,
})
}
table.Render()
// Disks
if len(server.Details.Disks) > 0 {
fmt.Printf("\nDisks of %s (total storage: %d GB)\n", server.Name, server.Details.StorageGb)
table = tablewriter.NewWriter(os.Stdout)
table.SetAutoFormatHeaders(false)
table.SetAlignment(tablewriter.ALIGN_RIGHT)
table.SetAutoWrapText(true)
table.SetHeader([]string{"Disk ID", "Disk Size/GB", "Paths"})
for _, d := range server.Details.Disks {
table.Append([]string{d.Id, fmt.Sprint(d.SizeGB), strings.Join(d.PartitionPaths, ", ")})
}
table.Render()
}
// Partitions
if len(server.Details.Partitions) > 0 {
fmt.Printf("\nPartitions of %s:\n", server.Name)
table = tablewriter.NewWriter(os.Stdout)
table.SetAutoFormatHeaders(false)
table.SetAlignment(tablewriter.ALIGN_RIGHT)
table.SetAutoWrapText(true)
table.SetHeader([]string{"Partition Path", "Partition Size/GB"})
for _, p := range server.Details.Partitions {
table.Append([]string{p.Path, fmt.Sprintf("%.1f", p.SizeGB)})
}
table.Render()
}
// Snapshots
if len(server.Details.Snapshots) > 0 {
fmt.Println()
table = tablewriter.NewWriter(os.Stdout)
table.SetAutoFormatHeaders(false)
table.SetAlignment(tablewriter.ALIGN_CENTRE)
table.SetAutoWrapText(true)
table.SetHeader([]string{fmt.Sprintf("Snapshots of %s", server.Name)})
for _, s := range server.Details.Snapshots {
table.Append([]string{s.Name})
}
table.Render()
}
}