func openService(ns string, serviceName string, c *k8sclient.Client, printURL bool, retry bool) {
if retry {
if err := RetryAfter(40, func() error { return CheckService(ns, serviceName, c) }, 10*time.Second); err != nil {
util.Errorf("Could not find finalized endpoint being pointed to by %s: %v", serviceName, err)
os.Exit(1)
}
}
svcs, err := c.Services(ns).List(kubeApi.ListOptions{})
if err != nil {
util.Errorf("No services found %v\n", err)
}
found := false
for _, service := range svcs.Items {
if serviceName == service.Name {
url := service.ObjectMeta.Annotations[exposeURLAnnotation]
if printURL {
util.Successf("%s\n", url)
} else {
util.Successf("\nOpening URL %s\n", url)
browser.OpenURL(url)
}
found = true
break
}
}
if !found {
util.Errorf("No service %s in namespace %s\n", serviceName, ns)
}
}
func StackoverflowceptionCheck(err error) bool {
if err != nil {
url := "http://stackoverflow.com/search?q="
url += err.Error()
browser.OpenURL(url)
return true
}
return false
}
// Opens a browser tab/window with the login to pocket for authorization.
// Only returns when the user presses enter.
func authorizeInBrowser(requestToken string, redirectURI string) {
template := "https://getpocket.com/auth/authorize?" +
"request_token=%s&redirect_uri=%s"
url := fmt.Sprintf(template, requestToken, redirectURI)
browser.OpenURL(url)
reader := bufio.NewReader(os.Stdin)
fmt.Println("Press enter when authorized")
_, err := reader.ReadString('\n')
checkFatal(err)
}
func main() {
var err error
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %s: command <args>...\n", os.Args[0])
flag.PrintDefaults()
}
flag.Parse()
if len(flag.Args()) < 1 {
flag.Usage()
return
}
ifaceAndPort := fmt.Sprintf("%v:0", *iface)
listener, err := net.Listen("tcp4", ifaceAndPort)
if err != nil {
log.Fatal(err)
}
pr, pw, _ := os.Pipe()
gcChan := make(chan *gctrace, 1)
scvgChan := make(chan *scvgtrace, 1)
parser := Parser{
reader: pr,
gcChan: gcChan,
scvgChan: scvgChan,
}
gcvisGraph = NewGraph(strings.Join(flag.Args(), " "), GCVIS_TMPL)
go startSubprocess(pw, flag.Args())
go parser.Run()
http.HandleFunc("/", indexHandler)
go http.Serve(listener, nil)
url := fmt.Sprintf("http://%s/", listener.Addr())
log.Printf("opening browser window, if this fails, navigate to %s", url)
browser.OpenURL(url)
for {
select {
case gcTrace := <-gcChan:
gcvisGraph.AddGCTraceGraphPoint(gcTrace)
case scvgTrace := <-scvgChan:
gcvisGraph.AddScavengerGraphPoint(scvgTrace)
}
}
}
// main is the entry point for the application.
func main() {
print("Starting - HTTP service on port 8676\n")
print("Press 'ctrl + c' to quit\n")
folderPath, err := osext.ExecutableFolder()
if err != nil {
print(err)
}
browser.OpenURL("http://localhost:8676/index.html")
panic(http.ListenAndServe(":8676", http.FileServer(http.Dir(folderPath))))
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %s: command <args>...\n", os.Args[0])
flag.PrintDefaults()
}
flag.Parse()
if len(flag.Args()) < 1 {
flag.Usage()
return
}
subcommand := NewSubCommand(flag.Args())
parser := NewParser(subcommand.PipeRead)
gcvisGraph := NewGraph(strings.Join(flag.Args(), " "), GCVIS_TMPL)
server := NewHttpServer(*iface, *port, &gcvisGraph)
go subcommand.Run()
go parser.Run()
go server.Start()
url := server.Url()
log.Printf("opening browser window, if this fails, navigate to %s", url)
browser.OpenURL(url)
for {
select {
case gcTrace := <-parser.GcChan:
gcvisGraph.AddGCTraceGraphPoint(gcTrace)
case scvgTrace := <-parser.ScvgChan:
gcvisGraph.AddScavengerGraphPoint(scvgTrace)
case output := <-parser.NoMatchChan:
fmt.Fprintln(os.Stderr, output)
case <-parser.done:
if parser.Err != nil {
fmt.Fprintf(os.Stderr, parser.Err.Error())
os.Exit(1)
}
if subcommand.Err() != nil {
fmt.Fprintf(os.Stderr, subcommand.Err().Error())
os.Exit(1)
}
os.Exit(0)
}
}
}
func ListenAndServe(stateFile, addr, central string, devMode bool) error {
server, err := New(stateFile, central)
if err != nil {
return err
}
if !devMode {
host := addr
if strings.HasPrefix(host, ":") {
host = "localhost" + host
}
err := browser.OpenURL("http://" + host + "/")
if err != nil {
log.Println(err)
}
}
return server.ListenAndServe(addr, devMode)
}
// Open opens a product on the amazon website
func Open(c *cli.Context) {
api := api.Create(c.GlobalString("locale"))
conf := config.GetConfig()
asin, exists := conf.ASINFromCache("Products", c.Args().First())
if !exists {
fmt.Fprintln(os.Stderr, "Cannot look up ASIN")
os.Exit(1)
}
result, err := api.ItemLookup(asin, "Small")
if err != nil {
panic(err)
}
browser.OpenURL(result.Items.ItemList[0].DetailPageURL)
}
func serve(ctx context.Context) error {
wgctx.Add(ctx, "serve")
defer wgctx.Done(ctx, "serve")
env := envctx.FromContext(ctx)
cmd := cmdctx.FromContext(ctx)
// Starting with port zero chooses a random open port
listner, err := net.Listen("tcp", fmt.Sprintf(":%d", cmd.Port))
if err != nil {
return kerr.Wrap("QGLXHWPWQW", err)
}
defer listner.Close()
// Here we get the address we're serving on
address, ok := listner.Addr().(*net.TCPAddr)
if !ok {
return kerr.New("CBLPYVGGUR", "Can't find address (l.Addr() is not *net.TCPAddr)")
}
url := fmt.Sprintf("http://localhost:%d/%s/", address.Port, env.Path)
cmd.Printf("Server now running on %s\n", url)
// We open the default browser and navigate to the address we're serving
// from. This will error if the system doesn't have a browser, so we can
// ignore the error.
browser.OpenURL(url)
withCancel(ctx, func() {
err = http.Serve(listner, nil)
})
if err != nil {
return kerr.Wrap("TUCBTWMRNN", err)
}
if cmd.Debug {
return kerr.New("ATUTBOICGJ", "Connection closed")
}
return nil
}
// Checkout initiates the checkout for a cart
func Checkout(c *cli.Context) {
api := api.Create(c.GlobalString("locale"))
conf := config.GetConfig()
defer conf.Flush()
cartName := conf.CartNameFromCache(c.Args().First())
if cart, exists := conf.Carts[cartName]; exists {
if getResponse, getErr := api.CartGet(cart.CartID, cart.HMAC); getErr == nil {
delete(conf.Carts, cartName)
browser.OpenURL(getResponse.Cart.PurchaseURL)
} else {
panic(getErr)
}
} else {
fmt.Fprintf(os.Stderr, "Cart %s is unknown\n", cartName)
os.Exit(1)
}
}
func main() {
if len(os.Args) < 2 {
log.Fatalf("usage: %s command <args>...", os.Args[0])
}
pr, pw, _ := os.Pipe()
gc := make(chan *gctrace, 1)
scvg := make(chan *scvgtrace, 1)
go startSubprocess(pw)
go startParser(pr, gc, scvg)
l, err := net.Listen("tcp4", "127.0.0.1:0")
if err != nil {
log.Fatal(err)
}
http.HandleFunc("/", index)
go http.Serve(l, nil)
url := fmt.Sprintf("http://%s/", l.Addr())
log.Printf("opening browser window, if this fails, navigate to %s", url)
browser.OpenURL(url)
for {
select {
case gc := <-gc:
mu.Lock()
ts := int(time.Now().UnixNano() / 1e6)
heapuse = append(heapuse, graphPoints{ts, gc.Heap1})
mu.Unlock()
case scvg := <-scvg:
mu.Lock()
ts := int(time.Now().UnixNano() / 1e6)
scvginuse = append(scvginuse, graphPoints{ts, scvg.inuse})
scvgidle = append(scvgidle, graphPoints{ts, scvg.idle})
scvgsys = append(scvgsys, graphPoints{ts, scvg.sys})
scvgreleased = append(scvgreleased, graphPoints{ts, scvg.released})
scvgconsumed = append(scvgconsumed, graphPoints{ts, scvg.consumed})
mu.Unlock()
}
}
}
func openURL(data string, isHTML bool) error {
if isHTML {
tmpfile, err := ioutil.TempFile("", "pmbopenurl")
if err != nil {
return err
}
_, err = tmpfile.Write([]byte(data))
if err != nil {
return err
}
err = tmpfile.Close()
if err != nil {
return err
}
nameWithSuffix := fmt.Sprintf("%s.html", tmpfile.Name())
err = os.Rename(tmpfile.Name(), nameWithSuffix)
if err != nil {
return err
}
go func() {
time.Sleep(15 * time.Second)
logrus.Infof("cleaning up temporary file: %s", nameWithSuffix)
os.Remove(nameWithSuffix)
}()
logrus.Infof("opening file: %s", nameWithSuffix)
return browser.OpenFile(nameWithSuffix)
}
logrus.Infof("opening url: %s", data)
return browser.OpenURL(data)
}
func doServe(c *cli.Context) {
master := c.Bool("master")
theme := c.String("theme")
// Get the presentation path from the command line, or grab the current directory.
presentationPath, _ := os.Getwd()
if len(c.Args()) > 0 {
presentationPath = c.Args()[0]
}
// Check if the path is relative.
if !strings.HasPrefix(presentationPath, "/") {
presentationPath, _ = filepath.Abs(presentationPath)
}
// Check if there is a presentation file present.
if _, err := os.Stat(path.Join(presentationPath, "slides.md")); err != nil {
fmt.Printf("slides.md does not exist at %s\n", presentationPath)
os.Exit(1)
}
if theme != "" {
fmt.Println("Using one of the packaged themes ...")
http.Handle("/css/", http.FileServer(&assetfs.AssetFS{Asset, AssetDir, "themes/" + theme}))
http.Handle("/fonts/", http.FileServer(&assetfs.AssetFS{Asset, AssetDir, "themes/" + theme}))
} else {
if _, err := os.Stat(path.Join(presentationPath, "css", "theme.css")); err == nil {
fmt.Println("Found a theme, using it ...")
http.Handle("/css/", http.FileServer(http.Dir(presentationPath)))
http.Handle("/fonts/", http.FileServer(http.Dir(presentationPath)))
} else {
fmt.Println("No theme found ...")
}
}
// Handle the slides.
http.HandleFunc("/slides.md", func(w http.ResponseWriter, r *http.Request) {
t, _ := template.ParseFiles(path.Join(presentationPath, "slides.md"))
t.Execute(w, "")
})
// Handle images.
http.HandleFunc("/img/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, path.Join(presentationPath, r.URL.Path))
})
// Handle reveal.js files.
http.Handle("/reveal.js/css/", http.FileServer(&assetfs.AssetFS{Asset, AssetDir, ""}))
http.Handle("/reveal.js/js/", http.FileServer(&assetfs.AssetFS{Asset, AssetDir, ""}))
http.Handle("/reveal.js/lib/", http.FileServer(&assetfs.AssetFS{Asset, AssetDir, ""}))
http.Handle("/reveal.js/plugin/", http.FileServer(&assetfs.AssetFS{Asset, AssetDir, ""}))
// Handle the website.
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
opt := &Option{Markdown: "slides.md", Master: master}
indexHTML, _ := Asset("assets/index.html")
indexTemplate := template.Must(template.New("index").Parse(string(indexHTML)))
indexTemplate.Execute(w, opt)
})
fmt.Println("Opening browser and redirecting to the presentation ...")
browser.OpenURL("http://localhost:8989")
err := http.ListenAndServe(":8989", nil)
panic("Error while serving slides: " + err.Error())
}
defer api.Close()
url, err := cluster.GetServiceURL(api, namespace, service, serviceURLTemplate)
if err != nil {
fmt.Fprintln(os.Stderr, err)
if _, ok := err.(cluster.MissingNodePortError); !ok {
fmt.Fprintln(os.Stderr, "Check that minishift is running and that you have specified the correct namespace (-n flag).")
}
os.Exit(1)
}
if https {
url = strings.Replace(url, "http", "https", 1)
}
if serviceURLMode {
fmt.Fprintln(os.Stdout, url)
} else {
fmt.Fprintln(os.Stdout, "Opening kubernetes service "+namespace+"/"+service+" in default browser...")
browser.OpenURL(url)
}
},
}
func init() {
serviceCmd.Flags().StringVarP(&namespace, "namespace", "n", "default", "The service namespace")
serviceCmd.Flags().BoolVar(&serviceURLMode, "url", false, "Display the kubernetes service URL in the CLI instead of opening it in the default browser")
serviceCmd.PersistentFlags().StringVar(&serviceURLFormat, "format", "http://{{.IP}}:{{.Port}}", "Format to output service URL in")
serviceCmd.Flags().BoolVar(&https, "https", false, "Open the service URL with https instead of http")
RootCmd.AddCommand(serviceCmd)
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %s: command <args>...\n", os.Args[0])
flag.PrintDefaults()
}
var pipeRead io.ReadCloser
var subcommand *SubCommand
flag.Parse()
if len(flag.Args()) < 1 {
if terminal.IsTerminal(int(os.Stdin.Fd())) {
flag.Usage()
return
} else {
pipeRead = os.Stdin
}
} else {
subcommand = NewSubCommand(flag.Args())
pipeRead = subcommand.PipeRead
go subcommand.Run()
}
parser := NewParser(pipeRead)
gcvisGraph := NewGraph(strings.Join(flag.Args(), " "), GCVIS_TMPL)
server := NewHttpServer(*iface, *port, &gcvisGraph)
go parser.Run()
go server.Start()
url := server.Url()
if *openBrowser {
log.Printf("opening browser window, if this fails, navigate to %s", url)
browser.OpenURL(url)
} else {
log.Printf("server started on %s", url)
}
for {
select {
case gcTrace := <-parser.GcChan:
gcvisGraph.AddGCTraceGraphPoint(gcTrace)
case scvgTrace := <-parser.ScvgChan:
gcvisGraph.AddScavengerGraphPoint(scvgTrace)
case output := <-parser.NoMatchChan:
fmt.Fprintln(os.Stderr, output)
case <-parser.done:
if parser.Err != nil {
fmt.Fprintf(os.Stderr, parser.Err.Error())
os.Exit(1)
}
break
}
}
if subcommand != nil && subcommand.Err() != nil {
fmt.Fprintf(os.Stderr, subcommand.Err().Error())
os.Exit(1)
}
os.Exit(0)
}
func handleEvents(eventChan chan termbox.Event) {
for ev := range eventChan {
switch ev.Type {
case termbox.EventKey:
switch ev.Key {
case termbox.KeyArrowUp:
case termbox.KeyArrowDown:
case termbox.KeySpace:
// page down
lock.Lock()
totalN := len(events)
lock.Unlock()
if selectedRow >= totalN-1 {
// the last event
continue
}
if !detailView {
if selectedRow/pageSize == totalN/pageSize {
// already the last page, do nothing
continue
}
selectedRow += pageSize
if selectedRow > totalN-1 {
// can't be beyond the range
selectedRow = totalN - 1
}
page++
redrawAll()
}
continue
case termbox.KeyEnter:
if detailView {
browser.OpenURL(currentWebHook.Commits[len(currentWebHook.Commits)-selectedCommit-1].Url)
}
continue
case termbox.KeyCtrlD:
// dashboard page
if dashboardView {
redrawAll()
} else {
drawDashboardByHour()
}
dashboardView = !dashboardView
case termbox.KeyCtrlP:
if projectSummaryView {
redrawAll()
} else {
drawDashboardByProject()
}
projectSummaryView = !projectSummaryView
case termbox.KeyCtrlU:
if userSummaryView {
redrawAll()
} else {
drawDashboardByUser()
}
userSummaryView = !userSummaryView
case termbox.KeyEsc:
if detailView {
detailView = false
redrawAll()
} else {
termbox.Close()
os.Exit(0)
}
}
switch ev.Ch {
case 'j':
if detailView {
if selectedCommit < len(currentWebHook.Commits)-1 {
selectedCommit++
} else {
selectedCommit = 0 // rewind
}
drawDetail()
} else {
lock.Lock()
totalN := len(events)
lock.Unlock()
if selectedRow < totalN-1 {
selectedRow++
if selectedRow%pageSize == 0 {
page++
}
redrawAll()
}
}
case 'K', 'T':
if mainView {
page = 0
selectedRow = 0
redrawAll()
}
case 'G':
if mainView {
lock.Lock()
totalN := len(events)
lock.Unlock()
page = totalN / pageSize
if totalN%pageSize == 0 {
page--
}
selectedRow = totalN - 1
redrawAll()
}
case 'M':
if !detailView {
lock.Lock()
totalN := len(events)
lock.Unlock()
if selectedRow/pageSize == totalN/pageSize {
// already the last page, do nothing
continue
}
selectedRow = page*pageSize + pageSize/2
redrawAll()
}
case 'H':
if !detailView {
selectedRow = page * pageSize
redrawAll()
}
case 'L':
if !detailView {
lock.Lock()
totalN := len(events)
lock.Unlock()
if selectedRow/pageSize == totalN/pageSize {
// already the last page, do nothing
continue
}
selectedRow = page*pageSize + pageSize - 1
redrawAll()
}
case 'k':
if detailView {
if selectedCommit > 0 {
selectedCommit--
} else {
selectedCommit = len(currentWebHook.Commits) - 1
}
drawDetail()
} else {
if selectedRow > 0 {
if selectedRow%pageSize == 0 {
page--
}
selectedRow--
redrawAll()
}
}
case 'd':
// detail page
if detailView {
redrawAll()
} else {
drawDetail()
}
detailView = !detailView
case 'b':
// page up
if !detailView {
selectedRow -= pageSize
if selectedRow < 0 {
selectedRow = 0
} else {
page--
}
redrawAll()
}
case 'q':
if detailView {
detailView = false
redrawAll()
} else if dashboardView {
dashboardView = false
redrawAll()
} else if projectSummaryView {
projectSummaryView = false
redrawAll()
} else if userSummaryView {
userSummaryView = false
redrawAll()
} else {
termbox.Close()
os.Exit(0)
}
selectedCommit = 0
}
case termbox.EventError:
panic(ev.Err)
}
}
}
func main() {
//Create channels
symbols := make(chan string)
output := make(chan string)
//Stage some workers
for w := 1; w <= 10; w++ {
wg.Add(1)
go worker(symbols, output)
}
//Get symbol list from file
f, _ := os.Open("C:\\temp\\test\\symbols.txt")
defer f.Close()
//Read file lines into slice
scanner := bufio.NewScanner(f)
scanner.Split(bufio.ScanLines)
var symlist []string
for scanner.Scan() {
symlist = append(symlist, scanner.Text())
}
//Process each symbol
go func() {
for _, v := range symlist {
symbols <- v
}
close(symbols)
}()
//Wait for workers to complete
go func() {
wg.Wait()
close(output)
}()
//Spit out status as files complete
for i := range output {
fmt.Println(i)
}
fmt.Println("Done...")
//...and now the for the web stuff...
fns := template.FuncMap{
"start": func(x int) bool {
if (x+1)%3 == 1 {
return true
}
return false
},
"finish": func(x, y int) bool {
if (y+1) == x || (y+1)%3 == 0 {
return true
}
return false
},
}
//Parse template
tmpl := template.Must(template.New("main").Funcs(fns).ParseGlob("*.gohtml"))
//Function
http.Handle("/images/", http.StripPrefix("/images/", http.FileServer(http.Dir("c:\\temp\\test\\"))))
http.HandleFunc("/", func(res http.ResponseWriter, req *http.Request) {
// execute template
tmpl.ExecuteTemplate(res, "tmpl.gohtml", symlist)
})
//Call it...
go browser.OpenURL("http://localhost:9002")
// create server
http.ListenAndServe(":9002", nil)
}
func startInternalHTTPServer(authKey string) error {
lg.V(15).Infoln("starting internal api server")
mux, err := createServeMux()
if err != nil {
lg.Error("failed to create router")
return err
}
auth := Auth{Key: authKey, wrapped: mux}
conf := clientconfig.Get()
listener, err := net.Listen("tcp", conf.Settings.Local.ClientBindAddr)
if err != nil {
lg.Warning(err)
listener, err = net.Listen("tcp", "127.0.0.1:")
}
if err != nil {
lg.Warning(err)
ui.Notify("Could not bind any local port (bootstrap)")
lg.Errorln("Could not bind any local port (bootstrap)")
return err
}
go func(listenaddr string) {
// baseURL := fmt.Sprintf()
baseURL := fmt.Sprintf("http://%s?suk=", listenaddr)
for {
select {
case <-ui.Actions.CopyBrowserCodeToClipboard:
bc := browsercode.BrowserCode{Key: authKey}
err := bc.SetHostport(listener.Addr().String())
if err != nil {
lg.Errorln(err)
continue
}
err = bc.CopyToClipboard()
if err != nil {
lg.Errorln(err)
}
case <-ui.Actions.OpenInBrowser:
browser.OpenURL(baseURL + singleUseKeys.New() + "#/")
case <-ui.Actions.Help:
browser.OpenURL(baseURL + singleUseKeys.New() + "#/docs/__/index")
}
singleUseKeys.Cleanup()
}
}(listener.Addr().String())
doneC := make(chan bool, 1)
go func() {
defer listener.Close()
err = http.Serve(listener, auth)
if err != nil {
doneC <- false
}
}()
select {
case ok := <-doneC:
if !ok {
return errors.New("Could not start internal http server")
}
case <-time.After(time.Millisecond * 200):
return nil
}
return nil
}
// Serve the presentation.
func Serve(c *cli.Context) {
master := c.Bool("master")
theme := c.String("theme")
// Get the presentation path from the command line, or grab the current directory.
presentationPath, _ := os.Getwd()
if len(c.Args()) > 0 {
presentationPath = c.Args()[0]
}
// Check if the path is relative.
if !pathIsAbsolute(presentationPath) {
presentationPath, _ = filepath.Abs(presentationPath)
}
// Check if there is a presentation file present.
if fileExists(path.Join(presentationPath, "slides.md")) {
log.Printf("slides.md does not exist at %s\n", presentationPath)
os.Exit(1)
}
// Check if a theme was passed.
if themeExists(theme) {
log.Printf("Using build-in theme [%s]\n", theme)
http.Handle("/css/", http.FileServer(&assetfs.AssetFS{bindata.Asset, bindata.AssetDir, bindata.AssetInfo, "themes/" + theme}))
http.Handle("/fonts/", http.FileServer(&assetfs.AssetFS{bindata.Asset, bindata.AssetDir, bindata.AssetInfo, "themes/" + theme}))
} else {
if !fileExists(path.Join(presentationPath, "css", "theme.css")) {
log.Println("Found a theme in the css directory, using it...")
http.Handle("/css/", http.FileServer(http.Dir(presentationPath)))
http.Handle("/fonts/", http.FileServer(http.Dir(presentationPath)))
} else {
log.Println("No theme found ...")
}
}
// Handle the slides.
http.HandleFunc("/slides.md", func(w http.ResponseWriter, r *http.Request) {
t, _ := template.ParseFiles(path.Join(presentationPath, "slides.md"))
t.Execute(w, "")
})
// Handle images.
http.HandleFunc("/img/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, path.Join(presentationPath, r.URL.Path))
})
// Handle reveal.js files.
http.Handle("/reveal.js/css/", http.FileServer(&assetfs.AssetFS{bindata.Asset, bindata.AssetDir, bindata.AssetInfo, ""}))
http.Handle("/reveal.js/js/", http.FileServer(&assetfs.AssetFS{bindata.Asset, bindata.AssetDir, bindata.AssetInfo, ""}))
http.Handle("/reveal.js/lib/", http.FileServer(&assetfs.AssetFS{bindata.Asset, bindata.AssetDir, bindata.AssetInfo, ""}))
http.Handle("/reveal.js/plugin/", http.FileServer(&assetfs.AssetFS{bindata.Asset, bindata.AssetDir, bindata.AssetInfo, ""}))
// Handle the website.
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
opt := &Option{Markdown: "slides.md", Master: master}
indexHTML, _ := bindata.Asset("assets/index.html")
indexTemplate := template.Must(template.New("index").Parse(string(indexHTML)))
indexTemplate.Execute(w, opt)
})
log.Println("Serving presentation on http://localhost:8989")
log.Println("Opening browser and redirecting to the presentation, press Ctrl-C to stop ...")
browser.OpenURL("http://localhost:8989")
err := http.ListenAndServe(":8989", nil)
log.Fatalf("Error while serving slides: %s\n", err.Error())
}
func AuthorizePocket(code string, callbackUrl string) {
browser.OpenURL("https://getpocket.com/auth/authorize?request_token=" + code + "&redirect_uri=" + callbackUrl)
}
// Monitor monitors log aggregates results into RunStats
func Monitor(bf int) RunStats {
log.Println("MONITORING")
defer fmt.Println("DONE MONITORING")
retry_dial:
ws, err := websocket.Dial("ws://localhost:8080/log", "", "http://localhost/")
if err != nil {
time.Sleep(1 * time.Second)
goto retry_dial
}
retry:
// Get HTML of webpage for data (NHosts, Depth, ...)
doc, err := goquery.NewDocument("http://localhost:8080/")
if err != nil {
log.Println("unable to get log data: retrying:", err)
time.Sleep(10 * time.Second)
goto retry
}
if view {
browser.OpenURL("http://localhost:8080/")
}
nhosts := doc.Find("#numhosts").First().Text()
log.Println("hosts:", nhosts)
depth := doc.Find("#depth").First().Text()
log.Println("depth:", depth)
nh, err := strconv.Atoi(nhosts)
if err != nil {
log.Fatal("unable to convert hosts to be a number:", nhosts)
}
d, err := strconv.Atoi(depth)
if err != nil {
log.Fatal("unable to convert depth to be a number:", depth)
}
clientDone := false
rootDone := false
var rs RunStats
rs.NHosts = nh
rs.Depth = d
rs.BF = bf
var M, S float64
k := float64(1)
first := true
for {
var data []byte
err := websocket.Message.Receive(ws, &data)
if err != nil {
// if it is an eof error than stop reading
if err == io.EOF {
log.Println("websocket terminated before emitting EOF or terminating string")
break
}
continue
}
if bytes.Contains(data, []byte("EOF")) || bytes.Contains(data, []byte("terminating")) {
log.Printf(
"EOF/terminating Detected: need forkexec to report and clients: rootDone(%t) clientDone(%t)",
rootDone, clientDone)
}
if bytes.Contains(data, []byte("root_round")) {
if clientDone || rootDone {
// ignore after we have received our first EOF
continue
}
var entry StatsEntry
err := json.Unmarshal(data, &entry)
if err != nil {
log.Fatal("json unmarshalled improperly:", err)
}
log.Println("root_round:", entry)
if first {
first = false
rs.MinTime = entry.Time
rs.MaxTime = entry.Time
}
if entry.Time < rs.MinTime {
rs.MinTime = entry.Time
} else if entry.Time > rs.MaxTime {
rs.MaxTime = entry.Time
}
rs.AvgTime = ((rs.AvgTime * (k - 1)) + entry.Time) / k
var tM = M
M += (entry.Time - tM) / k
S += (entry.Time - tM) * (entry.Time - M)
k++
rs.StdDev = math.Sqrt(S / (k - 1))
} else if bytes.Contains(data, []byte("forkexec")) {
if rootDone {
continue
}
var ss SysStats
err := json.Unmarshal(data, &ss)
if err != nil {
log.Fatal("unable to unmarshal forkexec:", ss)
}
rs.SysTime = ss.SysTime
rs.UserTime = ss.UserTime
log.Println("FORKEXEC:", ss)
if clientDone {
break
}
rootDone = true
} else if bytes.Contains(data, []byte("client_msg_stats")) {
if clientDone {
continue
}
var cms ClientMsgStats
err := json.Unmarshal(data, &cms)
if err != nil {
log.Fatal("unable to unmarshal client_msg_stats:", string(data))
}
// what do I want to keep out of the Client Message States
// cms.Buckets stores how many were processed at time T
// cms.RoundsAfter stores how many rounds delayed it was
//
// get the average delay (roundsAfter), max and min
// get the total number of messages timestamped
// get the average number of messages timestamped per second?
avg, _, _, _ := ArrStats(cms.Buckets)
// get the observed rate of processed messages
// avg is how many messages per second, we want how many milliseconds between messages
observed := avg / 1000 // set avg to messages per milliseconds
observed = 1 / observed
rs.Rate = observed
rs.Times = cms.Times
if rootDone {
break
}
clientDone = true
}
}
return rs
}
func ServeHTTP() error {
logger := log.New()
installer := NewInstaller(logger)
api := &httpAPI{
Installer: installer,
logger: logger,
clientConfig: installerJSConfig{
Endpoints: map[string]string{
"clusters": "/clusters",
"cluster": "/clusters/:id",
"upload_backup": "/clusters/:id/upload-backup",
"cert": "/clusters/:id/ca-cert",
"events": "/events",
"prompt": "/clusters/:id/prompts/:prompt_id",
"credentials": "/credentials",
"regions": "/regions",
"azureSubscriptions": "/azure/subscriptions",
},
},
}
if creds, err := aws.EnvCreds(); err == nil {
api.AWSEnvCreds = creds
if c, err := creds.Credentials(); err == nil {
api.clientConfig.HasAWSEnvCredentials = true
api.clientConfig.AWSEnvCredentialsID = c.AccessKeyID
}
}
httpRouter := httprouter.New()
httpRouter.GET("/", api.ServeTemplate)
httpRouter.GET("/credentials", api.ServeTemplate)
httpRouter.GET("/credentials/:id", api.ServeTemplate)
httpRouter.GET("/clusters/:id", api.ServeTemplate)
httpRouter.POST("/clusters/:id/upload-backup", api.ReceiveBackup)
httpRouter.GET("/clusters/:id/ca-cert", api.GetCert)
httpRouter.GET("/clusters/:id/delete", api.ServeTemplate)
httpRouter.GET("/oauth/azure", api.ServeTemplate)
httpRouter.DELETE("/clusters/:id", api.DeleteCluster)
httpRouter.GET("/clusters", api.RedirectRoot)
httpRouter.POST("/clusters", api.LaunchCluster)
httpRouter.GET("/events", api.Events)
httpRouter.POST("/clusters/:id/prompts/:prompt_id", api.Prompt)
httpRouter.GET("/assets/*assetPath", api.ServeAsset)
httpRouter.POST("/credentials", api.NewCredential)
httpRouter.DELETE("/credentials/:type/:id", api.DeleteCredential)
httpRouter.GET("/regions", api.GetCloudRegions)
httpRouter.GET("/azure/subscriptions", api.GetAzureSubscriptions)
port := os.Getenv("PORT")
if port == "" {
// if no port is given, use a random one
port = "0"
}
l, err := net.Listen("tcp", fmt.Sprintf(":%s", port))
if err != nil {
return err
}
addr := fmt.Sprintf("http://localhost:%d", l.Addr().(*net.TCPAddr).Port)
fmt.Printf("Open %s in your browser to continue.\n", addr)
browser.OpenURL(addr)
return http.Serve(l, api.CorsHandler(httpRouter, addr))
}
func main() {
flag.BoolVar(&debug, "debug", false, "print debug info")
web := flag.Bool("web", false, "show result in browser and start a web server")
open := flag.Bool("open", false, "open browser")
query := flag.String("q", "", "godoc query keyword")
port := flag.String("port", "9090", "web server port number")
flag.StringVar(&token, "github-token", "", "github token for more github requests")
flag.Parse()
if token == "" {
fmt.Println("specify -github-token can increase github api rate limits: https://github.com/settings/tokens")
}
if *web {
type data struct {
Query string
GitHubs, NonGitHubs []*Critique
}
caches := map[string]data{}
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
query := strings.TrimSpace(r.URL.Query().Get("query"))
if query != "" {
log.Println("Query:", query)
}
d, ok := caches[query]
if ok {
goto render
} else if query != "" {
githubs, nonGithubs, err := report(query)
if err != nil {
log.Println(err)
if _, err := w.Write([]byte(err.Error() + "\n" + string(debugpkg.Stack()))); err != nil {
log.Println(err)
}
debugpkg.PrintStack()
return
}
d = data{
Query: query,
GitHubs: githubs,
NonGitHubs: nonGithubs,
}
caches[query] = d
}
render:
if err := tmpl.ExecuteTemplate(w, "main", d); err != nil {
log.Println(err)
}
})
log.Println("Listening on :" + *port)
if *open {
if err := browser.OpenURL("http://localhost:" + *port); err != nil {
log.Println(err)
}
}
log.Fatal(http.ListenAndServe(":"+*port, nil))
} else {
if *query == "" {
log.Println("Please specify query keyword by -q")
os.Exit(1)
}
githubs, nonGithubs, err := report(*query)
if err != nil {
exit(err)
}
for i, pkgs := range [][]*Critique{githubs, nonGithubs} {
fmt.Println("===========================")
if i == 0 {
fmt.Println("GitHub Packages")
} else {
fmt.Println("Non-GitHub Packages")
}
printPkgs(pkgs, "")
}
}
}
func main() {
params := struct {
User string `flag:"user,ssh connection username"`
Addr string `flag:"addr,ssh host:port"`
Dir string `flag:"dir,remote directory to upload files to"`
Url string `flag:"url,remote url base to open after upload"`
Long bool `flag:"long,generate long subdirectory name"`
}{
User: os.Getenv("USER"),
Addr: "localhost:22",
Dir: "/tmp",
}
autoflags.Define(¶ms)
flag.Parse()
cfg, err := config(params.User)
if err != nil {
log.Fatal(err)
}
res, err := upload(params.Addr, params.Dir, params.Long, cfg, flag.Args())
if res != "" {
fmt.Println(res)
if params.Url != "" {
browser.OpenURL(path.Join(params.Url, path.Base(res)))
}
}
if err != nil {
log.Fatal(err)
}
}