MQP/jsh
Archived
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

gofmt

Browse Source
This commit is contained in:
Ian Adam Naval 2014-09-16 20:52:57 -04:00
parent b226effff0
commit 1d57896123
6 changed files with 167 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
common.go
View File

@ -13,8 +13,9 @@ type JshOutput struct {
// Size prefixes as integers, using binary representation // Size prefixes as integers, using binary representation
type Unit int type Unit int
const ( const (
B Unit = 2 ^ 0 B Unit = 2 ^ 0
KB Unit = 2 ^ 10 KB Unit = 2 ^ 10
MB Unit = 2 ^ 20 MB Unit = 2 ^ 20
GB Unit = 2 ^ 30 GB Unit = 2 ^ 30

16
free.go
View File

@ -1,8 +1,8 @@
/* File for free-related structs and methods */ /* File for free-related structs and methods */
package jsh package jsh
type MemStat struct { type MemStat struct {
Stat int Stat int
Units Unit Units Unit
} }

186
free/main.go
View File

@ -1,93 +1,93 @@
package main package main
import ( import (
"bufio" "bufio"
"errors" "errors"
"flag" "flag"
"fmt" "fmt"
"jsh" "jsh"
"regexp" "os"
"os" "regexp"
"strconv" "strconv"
) )
func convertUnit(stringUnit string) (jsh.Unit, error) { func convertUnit(stringUnit string) (jsh.Unit, error) {
switch stringUnit { switch stringUnit {
case "B": case "B":
return jsh.B, nil return jsh.B, nil
case "kB": case "kB":
return jsh.KB, nil return jsh.KB, nil
case "mB": case "mB":
return jsh.MB, nil return jsh.MB, nil
case "gB": case "gB":
return jsh.GB, nil return jsh.GB, nil
case "tB": case "tB":
return jsh.TB, nil return jsh.TB, nil
default: default:
return 0, errors.New(fmt.Sprintln("Unknown unit %s", stringUnit)) return 0, errors.New(fmt.Sprintln("Unknown unit %s", stringUnit))
} }
} }
func parseLine(line string) (string, jsh.MemStat, error) { func parseLine(line string) (string, jsh.MemStat, error) {
// Recognizes a alphanumeric or () word, the : character, whitespace, the number we're looking for, // Recognizes a alphanumeric or () word, the : character, whitespace, the number we're looking for,
// more whitespace, and possibly the unit // more whitespace, and possibly the unit
lineRegex := regexp.MustCompile("(?P<key>^[\\w()]+):\\s+(?P<val>\\d+)(\\s+)?(?P<unit>\\w+)?") lineRegex := regexp.MustCompile("(?P<key>^[\\w()]+):\\s+(?P<val>\\d+)(\\s+)?(?P<unit>\\w+)?")
// Parse the line, and construct a map of the valid matches // Parse the line, and construct a map of the valid matches
parsedLine := lineRegex.FindStringSubmatch(line) parsedLine := lineRegex.FindStringSubmatch(line)
names := lineRegex.SubexpNames() names := lineRegex.SubexpNames()
matchedVals := map[string]string{} matchedVals := map[string]string{}
for i, n := range parsedLine { for i, n := range parsedLine {
matchedVals[names[i]] = n matchedVals[names[i]] = n
} }
key := matchedVals["key"] key := matchedVals["key"]
val, err := strconv.Atoi(matchedVals["val"]) val, err := strconv.Atoi(matchedVals["val"])
if err != nil { if err != nil {
return "", jsh.MemStat{}, err return "", jsh.MemStat{}, err
} }
unit, err := convertUnit(matchedVals["unit"]) unit, err := convertUnit(matchedVals["unit"])
if err != nil { if err != nil {
return "", jsh.MemStat{}, err return "", jsh.MemStat{}, err
} }
return key, jsh.MemStat{val, unit}, nil return key, jsh.MemStat{val, unit}, nil
} }
func parseMemInfo() jsh.JshOutput { func parseMemInfo() jsh.JshOutput {
file, err := os.Open("/proc/meminfo") file, err := os.Open("/proc/meminfo")
if err != nil { if err != nil {
return jsh.JshOutput{[]string{}, []error{err}} return jsh.JshOutput{[]string{}, []error{err}}
} }
defer file.Close() defer file.Close()
scanner := bufio.NewScanner(file) scanner := bufio.NewScanner(file)
memInfo := make(map[string]jsh.MemStat) memInfo := make(map[string]jsh.MemStat)
errors := []error{} errors := []error{}
// Read in each line of the meminfo file, and place it in the map // Read in each line of the meminfo file, and place it in the map
for scanner.Scan() { for scanner.Scan() {
key, val, err := parseLine(scanner.Text()) key, val, err := parseLine(scanner.Text())
if err != nil { if err != nil {
errors = append(errors, err) errors = append(errors, err)
} }
memInfo[key] = val memInfo[key] = val
} }
finalOut := jsh.JshOutput{memInfo, errors} finalOut := jsh.JshOutput{memInfo, errors}
return finalOut return finalOut
} }
func runJsonMode() { func runJsonMode() {
output := parseMemInfo() output := parseMemInfo()
fmt.Println("%s", *output.ToJson()) fmt.Println("%s", *output.ToJson())
} }
func main() { func main() {
jsonModePtr := flag.Bool("json", false, "whether to use json mode for output") jsonModePtr := flag.Bool("json", false, "whether to use json mode for output")
flag.Parse() flag.Parse()
if !*jsonModePtr { if !*jsonModePtr {
fmt.Printf("%s", jsh.Fallback("/usr/bin/free")) fmt.Printf("%s", jsh.Fallback("/usr/bin/free"))
} else { } else {
runJsonMode() runJsonMode()
} }
} }

123
ls/main.go
View File

@ -1,76 +1,75 @@
package main package main
import ( import (
"io/ioutil" "flag"
"fmt" "fmt"
"flag" "io/ioutil"
"log" "log"
"syscall" "strconv"
"strconv" "syscall"
) )
func get_fileinfo(f string, size bool, mode bool, inode bool) string {
func get_fileinfo(f string, size bool, mode bool, inode bool) string{ var stat syscall.Stat_t
var stat syscall.Stat_t var ret string
var ret string ret = "{\"name\":\"" + f + "\""
ret = "{\"name\":\"" + f + "\"" if err := syscall.Stat(f, &stat); err != nil {
if err := syscall.Stat(f, &stat); err != nil { log.Fatal(err)
log.Fatal(err) }
} if size {
if(size){ ret = ret + ", \"size\":" + strconv.FormatInt(stat.Size, 10)
ret = ret + ", \"size\":" + strconv.FormatInt(stat.Size,10) }
} if mode {
if(mode){ ret = ret + ", \"mode\":" + strconv.Itoa(int(stat.Mode))
ret = ret + ", \"mode\":" + strconv.Itoa(int(stat.Mode)) }
} if inode {
if(inode){ ret = ret + ", \"inode\":" + strconv.FormatUint(stat.Ino, 10)
ret = ret + ", \"inode\":" + strconv.FormatUint(stat.Ino,10) }
} ret = ret + "}"
ret = ret + "}" return ret
return ret
} }
func main() { func main() {
// here be the ls flags // here be the ls flags
var a_flag bool // all files, even ones starting with . var a_flag bool // all files, even ones starting with .
var mode_flag bool // flags var mode_flag bool // flags
var inode_flag bool // inode var inode_flag bool // inode
var size_flag bool // size var size_flag bool // size
var first = true var first = true
flag.BoolVar(&a_flag, "a", false, "lists all files in directory, even hidden ones") flag.BoolVar(&a_flag, "a", false, "lists all files in directory, even hidden ones")
flag.BoolVar(&mode_flag, "f", false, "include flags for file") flag.BoolVar(&mode_flag, "f", false, "include flags for file")
flag.BoolVar(&inode_flag, "i", false, "include flags for file") flag.BoolVar(&inode_flag, "i", false, "include flags for file")
flag.BoolVar(&size_flag, "s", false, "include flags for file") flag.BoolVar(&size_flag, "s", false, "include flags for file")
// end ls flag // end ls flag
flag.Parse() flag.Parse()
root := "."//flag.Arg(0) root := "." //flag.Arg(0)
dir,_ := ioutil.ReadDir(root) dir, _ := ioutil.ReadDir(root)
fmt.Printf("[\n") fmt.Printf("[\n")
if(!a_flag){ if !a_flag {
for _,entry := range dir{ for _, entry := range dir {
if(entry.Name()[0]!='.'){ if entry.Name()[0] != '.' {
if(!first){ if !first {
fmt.Printf(",") fmt.Printf(",")
}else{ } else {
first = false first = false
}
fmt.Printf("%s\n", get_fileinfo(entry.Name(), size_flag, mode_flag, inode_flag))
}
}
} else {
for _, entry := range dir {
if !first {
fmt.Printf(",")
} else {
first = false
}
fmt.Printf("%s\n", get_fileinfo(entry.Name(), size_flag, mode_flag, inode_flag))
}
} }
fmt.Printf("%s\n", get_fileinfo(entry.Name(), size_flag, mode_flag, inode_flag)) fmt.Printf("]\n")
}
}
}else{
for _,entry := range dir{
if(!first){
fmt.Printf(",")
}else{
first = false
}
fmt.Printf("%s\n", get_fileinfo(entry.Name(), size_flag, mode_flag, inode_flag))
}
}
fmt.Printf("]\n")
} }

2
ps/main.go
View File

@ -25,7 +25,7 @@ func PsOutputToProcesses(out string) *[]jsh.Process {
func runJsonMode() { func runJsonMode() {
// Run procps-ng "ps" with full output // Run procps-ng "ps" with full output
psOut := string(*jsh.FallbackWithArgs("/usr/bin/ps", []string{"auxww"})) psOut := string(*jsh.FallbackWithArgs("/usr/bin/ps", []string{"auxww"}))
processesPtr := PsOutputToProcesses(psOut) processesPtr := PsOutputToProcesses(psOut)
finalOut := jsh.JshOutput{*processesPtr, []string{}} finalOut := jsh.JshOutput{*processesPtr, []string{}}

4
utils.go
View File

@ -2,9 +2,9 @@ package jsh
import ( import (
"math" "math"
"unicode"
"os" "os"
"os/exec" "os/exec"
"unicode"
) )
// FieldsN slices s into substrings after each instance of a whitespace // FieldsN slices s into substrings after each instance of a whitespace
@ -56,7 +56,7 @@ func FallbackWithArgs(program string, args []string) *[]byte {
if err != nil { if err != nil {
panic(err) panic(err)
} }
return &out return &out
} }
func Fallback(program string) *[]byte { func Fallback(program string) *[]byte {