From fc6db10c2296ad429d41313d629ebaec6fd52242 Mon Sep 17 00:00:00 2001 From: Jeff Carr Date: Thu, 6 Jun 2019 09:35:17 -0700 Subject: [PATCH] make an error handling function Signed-off-by: Jeff Carr --- bench1/fast-timer.go | 33 ++++++++++ bench1/readWriteOps.go | 115 +++++++++++++++++++++++++++++++++++ bench1/stuff.go | 0 build/main.go | 48 ++++++--------- config.go | 29 +++++++++ example-pprof/main.go | 78 ++++++++++++++++++++++++ example-pprof/profile001.pdf | Bin 0 -> 15819 bytes main.go | 48 ++++++++++++++- go.mod => resources/go.mod | 0 go.sum => resources/go.sum | 0 10 files changed, 321 insertions(+), 30 deletions(-) create mode 100644 bench1/fast-timer.go create mode 100644 bench1/readWriteOps.go create mode 100644 bench1/stuff.go create mode 100644 example-pprof/main.go create mode 100644 example-pprof/profile001.pdf rename go.mod => resources/go.mod (100%) rename go.sum => resources/go.sum (100%) diff --git a/bench1/fast-timer.go b/bench1/fast-timer.go new file mode 100644 index 0000000..875d1f3 --- /dev/null +++ b/bench1/fast-timer.go @@ -0,0 +1,33 @@ +package main + +import ( + "fmt" + "time" +) + +var start time.Time + +func init() { + start = time.Now() +} + +func main() { + fmt.Println("main() started", time.Since(start)) + chan1 := make(chan string, 2) + chan2 := make(chan string, 2) + + chan1 <- "Value 1" + chan1 <- "Value 2" + chan2 <- "Value 1" + chan2 <- "Value 2" + + select { + case res := <-chan1: + fmt.Println("Response from chan1", res, time.Since(start)) + case res := <-chan2: + fmt.Println("Response from chan2", res, time.Since(start)) + } + + fmt.Println("main() stopped", time.Since(start)) + for {} +} diff --git a/bench1/readWriteOps.go b/bench1/readWriteOps.go new file mode 100644 index 0000000..a8b7fad --- /dev/null +++ b/bench1/readWriteOps.go @@ -0,0 +1,115 @@ +// In the previous example we used explicit locking with +// [mutexes](mutexes) to synchronize access to shared state +// across multiple goroutines. Another option is to use the +// built-in synchronization features of goroutines and +// channels to achieve the same result. This channel-based +// approach aligns with Go's ideas of sharing memory by +// communicating and having each piece of data owned +// by exactly 1 goroutine. + +package main + +import ( + "fmt" + "math/rand" + "sync/atomic" + "time" +) + +// In this example our state will be owned by a single +// goroutine. This will guarantee that the data is never +// corrupted with concurrent access. In order to read or +// write that state, other goroutines will send messages +// to the owning goroutine and receive corresponding +// replies. These `readOp` and `writeOp` `struct`s +// encapsulate those requests and a way for the owning +// goroutine to respond. +type readOp struct { + key int + resp chan int +} +type writeOp struct { + key int + val int + resp chan bool +} + +func main() { + + // As before we'll count how many operations we perform. + var readOps uint64 + var writeOps uint64 + + // The `reads` and `writes` channels will be used by + // other goroutines to issue read and write requests, + // respectively. + reads := make(chan readOp) + writes := make(chan writeOp) + + // Here is the goroutine that owns the `state`, which + // is a map as in the previous example but now private + // to the stateful goroutine. This goroutine repeatedly + // selects on the `reads` and `writes` channels, + // responding to requests as they arrive. A response + // is executed by first performing the requested + // operation and then sending a value on the response + // channel `resp` to indicate success (and the desired + // value in the case of `reads`). + go func() { + var state = make(map[int]int) + for { + select { + case read := <-reads: + read.resp <- state[read.key] + case write := <-writes: + state[write.key] = write.val + write.resp <- true + } + } + }() + + // This starts 100 goroutines to issue reads to the + // state-owning goroutine via the `reads` channel. + // Each read requires constructing a `readOp`, sending + // it over the `reads` channel, and the receiving the + // result over the provided `resp` channel. + for r := 0; r < 100; r++ { + go func() { + for { + read := readOp{ + key: rand.Intn(5), + resp: make(chan int)} + reads <- read + <-read.resp + atomic.AddUint64(&readOps, 1) + time.Sleep(time.Millisecond) + } + }() + } + + // We start 10 writes as well, using a similar + // approach. + for w := 0; w < 10; w++ { + go func() { + for { + write := writeOp{ + key: rand.Intn(5), + val: rand.Intn(100), + resp: make(chan bool)} + writes <- write + <-write.resp + atomic.AddUint64(&writeOps, 1) + time.Sleep(time.Millisecond) + } + }() + } + + // Let the goroutines work for a second. + time.Sleep(time.Second) + + // Finally, capture and report the op counts. + readOpsFinal := atomic.LoadUint64(&readOps) + fmt.Println("readOps:", readOpsFinal) + writeOpsFinal := atomic.LoadUint64(&writeOps) + fmt.Println("writeOps:", writeOpsFinal) +} diff --git a/bench1/stuff.go b/bench1/stuff.go new file mode 100644 index 0000000..e69de29 diff --git a/build/main.go b/build/main.go index 126d1ca..a866fed 100644 --- a/build/main.go +++ b/build/main.go @@ -1,5 +1,7 @@ package main +// This should build and upload the binary to mirrors + import "log" // import "fmt" import "os" @@ -20,7 +22,22 @@ var builddir string var homedir string func main() { - os.Chdir("~/go/src/wit/cloud-control-panel") + // os.Chdir("~/go/src/wit/cloud-control-panel") + + // set epoch, version, + // set build cloud-control-panel + + // get build time + // go build -ldflags + // " + // -X main.GITCOMMIT=${GITCOMMIT} + // -X main.GOVERSION='${GOVERSION}' + // -X main.BUILDTIME='${BUILDTIME}' + // -X main.VERSION=${VERSION} + // " + + // upload binary to mirrors.wit.com/cloud/control-panel + setupUser() @@ -36,39 +53,13 @@ func main() { shell.Run("pwd") for { - time.Sleep(time.Second * 5) build() os.Exit(0) + time.Sleep(time.Second * 5) } } - /* - // slow down the polling to every 2 seconds - shell.SetDelayInMsec(2000) - shell.Run("ping -c 6 localhost") - - // capture ping output into a file - fout, _ := os.Create("/tmp/example1.ping.stdout") - ferr, _ := os.Create("/tmp/example1.ping.stderr") - shell.SetStdout(fout) - shell.SetStderr(ferr) - - shell.Run("ping -c 5 localhost") - - // turn out process exit debugging - shell.SpewOn() - - fout, _ = os.Create("/tmp/example1.fail.stdout") - ferr, _ = os.Create("/tmp/example1.fail.stderr") - shell.SetStdout(fout) - shell.SetStderr(ferr) - - // TODO: this might not be working - // check error handling - shell.Run("ls /tmpthisisnothere") - */ - func build() { // shell.SetDelayInMsec(50) shell.Run("go get -v .") @@ -91,7 +82,6 @@ func ping() { shell.Run("ping -c 6 localhost") } - // func setupUser() string, string, string { func setupUser() { // look up the user information diff --git a/config.go b/config.go index af65b8d..c813c32 100644 --- a/config.go +++ b/config.go @@ -16,10 +16,12 @@ import "os/user" import "flag" import "fmt" import "runtime" +// import "runtime/debug" import "io/ioutil" import "strings" import "reflect" import "bytes" +// import "sys" import "github.com/golang/protobuf/jsonpb" import pb "git.wit.com/wit/witProtobuf" @@ -271,6 +273,33 @@ func parseConfig() { log.Println("config.Gitref =", config.Gitref) log.Println("config.Goversion =", config.Goversion) log.Println("config.Dirty =", config.Dirty) + + log.Println("runtime.Version =", runtime.Version()) + log.Println("runtime Number of CPUs =", runtime.NumCPU()) + log.Println("runtime Number of GoRoutines =", runtime.NumGoroutine()) + + log.Println("runtime.GOARCH =", runtime.GOARCH) + + stackSlice := make([]byte, 12512) + s := runtime.Stack(stackSlice, false) + fmt.Printf("\n%s", stackSlice[0:s]) + // blah := runtime.Stack() + spew.Dump(s) + + // bi, biok := debug.ReadBuildInfo() + // log.Println("debug.BuildInfo() ok =", biok) + // spew.Dump(bi.Path) + // spew.Dump(bi.Main) + // log.Println("debug.BuildInfo.Path =", bi.Path) + + errChan <- "hello" + errChan <- "hello" + errChan <- "hello" + errChan <- fmt.Errorf("mainMouseClick() got b = nil") + errChan <- "hello" + + // for {} + // os.Exit(0) } func chompBytesBuffer(buf *bytes.Buffer) string { diff --git a/example-pprof/main.go b/example-pprof/main.go new file mode 100644 index 0000000..6051db6 --- /dev/null +++ b/example-pprof/main.go @@ -0,0 +1,78 @@ +package main + +// run this and then hit: +// http://localhost:6060/debug/pprof/ +// +// Also run from the command line: +// go tool pprof 'localhost:6060/debug/pprof/wit_pprof_experiment_thing?debug=1' +// +// https://medium.com/@cep21/creating-custom-go-profiles-with-pprof-b737dfc58e11 + +import "fmt" +import "log" +import "net/http" +import _ "net/http/pprof" // the _ means only the init() is needed +import "os" +import "runtime/pprof" +import "sync/atomic" +import "time" + +var libProfile *pprof.Profile + +func init() { + profName := "wit_pprof_experiment_thing" // this ends up in the URL + libProfile = pprof.Lookup(profName) + if libProfile == nil { + libProfile = pprof.NewProfile(profName) + } +} + +type someResource struct { + *os.File +} + +var fileIndex = int64(0) + +func MustResource() *someResource { + f, err := os.Create(fmt.Sprintf("/tmp/%d.txt", atomic.AddInt64(&fileIndex, 1))) + if err != nil { + panic(err) + } + r := &someResource{f} + libProfile.Add(r, 1) + return r +} + +func (r *someResource) Close() error { + libProfile.Remove(r) + return r.File.Close() +} + +func trackAFunction() { + tracked := new(byte) + libProfile.Add(tracked, 1) + defer libProfile.Remove(tracked) + time.Sleep(time.Second) +} + +func usesAResource() { + res := MustResource() + defer res.Close() + for i := 0; i < 10; i++ { + time.Sleep(time.Second) + } +} + +func main() { + http.HandleFunc("/nonblock", func(rw http.ResponseWriter, req *http.Request) { + go usesAResource() + }) + http.HandleFunc("/functiontrack", func(rw http.ResponseWriter, req *http.Request) { + trackAFunction() + }) + http.HandleFunc("/block", func(rw http.ResponseWriter, req *http.Request) { + usesAResource() + }) + log.Println("Running!") + log.Println(http.ListenAndServe("localhost:6060", nil)) +} diff --git a/example-pprof/profile001.pdf b/example-pprof/profile001.pdf new file mode 100644 index 0000000000000000000000000000000000000000..29b15f39bc0d56315c34174bcc6541965cb94228 GIT binary patch literal 15819 zcmb8W1yEf*7w?S}Def+Z;_hDDp}4!d7I!ZcEAH;@?(XjH?(PLH^m(6GznSmey*bIw zf3IXEYb9sSF!Ljp5frATr(uR7u01V#hGGKH0j%}RpuT8wYgmO-?l#!I~rh{pHR(|k}5zPr%&aq^Z z;ujUg(P@>0lw9Trz`(~fxj3&}ostA0t~`l1eqQuX3nyejk;?{DrE+dHOIhTGv-RZ6sru8{lI%^Aw z>N*!Ini5JFH8}XVs6{pOkw6{zks#3O`qZ#JMH#wMSWvzY_plORgrc}5`nXS&BOy_J zOIsk%;YZeBXPDS->jNyfhA|@2s4SFm+|^}rwzOLX_X(t4U&R$R;_EoZn(8~ck1L>q z;@b&A5@P5(i z(!DnTv;uqpdH}7y?tA&3xc3)-m9)avR`&m9ZA48+O$T84JMr&E?|=Vr#_&&P09pkX z8$$rCjIOaEfEYmk$GMEIt>ODv^ndrIl{7Rk)#bN#2B^PFbO0s>HUK>{3qbRawZOaI zcXKkR$NBw&-^6#E)b*=1dK78rB{4I+C>}?$k|85DqTL~IE zn(7;G%-e+2fgLqZRrXJu#p z@bV9V0YJ|{NB{2%BY>HS`9F@!X|tk&#_}9ee%#C0dkbJ}F5w24^+IS7TIH?Nf#8g2h31ht zp|&tLw*;@LxwWsb1y4#y_8WQIm|&^|TLdC5wJgQO>9FF(qF;J5a9Jj!++Kzt^+qBC ztAb!}t-aar;t?kK>{#{bWf2;h6`M1nZ>YD|Cp>X+i`wu~BzSPqcMxx<>vx|Rxvn)0 zc-^x;>ljc6en@X=DzB0Cs2jsueB$zg-|A`Wn|fc@(%Nr$;Ecv%(CUEJ+H6Wu;osV~ zybu+j6J0%Xn4fMuhe2MY)O|I)Q>ZMcT24xMBM1?8bd7p{_v6iQ;qrQsyuld~&~z4&u5PmE(2Uz)!1U{{FNc^6jL=lIu-+_*J}PB4X}buVL7ih<%^gr8rFwIM>PxugTkJ#yD+K$Z+Ol6v=h&Q=dpHoLs;bKCxtIf` zIU}}PMD=xY_1lQg$>^JWoNCt^jD?k@^=E_a9grk8_C#k8l{J{bzQNBoMqq8YL=pYz z#=rw32Jnt9>LB(u4wqnUshS=5;5x>j44j+^EnKVh7wunGc#R+;q8FDLpD6n}fel#P zI2TF0M4Y`xv;d?R+Q3q2JmMDXSdUKrfw%)DcdV}2GH=kAwjha`ZwFJ0Fef+lEa%C0 z>sZ!GdMwY-FZ6gu*Iv9z0LBCSi&Df8uMXDl!|#Pd@q6KN?A1}JA5bVJtU2S=t6{C>qN8X4a_*S#rf8YW?H%Daz>Lo7Wc~7>` z*A`ZrhpuO&-1;7P7CA|LUvUd()$uQE;RTY|-|1q#R6NBvLkXBRdwmg!D`N*F;^R6l z&%pXRgB&tF@5_XwqZ}CSUWS036AXO7@>k&XkD*KX0m#%^;vV$G*+!%QP~?s zV?62f3zg~knb^vTnd@w&iAJ;*tXVPb_*%0>G^l;2IiT2(z()paY(_>v#QrIFBZR7- zlkZ`7Uh&1Rq&Q}{QUpo(iJSg38iG#z#MsDEJhP6gZb(NN?rY42Cnzw@K5k728Jr{|F?vHJ<{jmcTNa&n zxR`p;MqgQ5xSL*{t795`{*&T5NJ;~21fvklssbOHRkjXcPqeru@H>CCQPWZyg#&~% zTJ;u+i~~`f7D$3B+LN*Vh&7Ta(vJC-ADOqZZuFfRi60^;lTC(a9)0Y1U*nu;J2VX5 z)?_Sv9tRr8met@3+{R=bbSpffw={?h0%s_;-bkYj*AFGF@UFV}T{0vd_aijuMz#a< z4JTN>(Gdl{=x+xZ0cy+O;EkB-&AgcN#!hUV5`MvgK_mJJX94OLEt)CNqe*BEIf_Ax z%ofxv&K55H)HQ`XG*3mZ$==vE3A#?~9*(`6ozWpq3V4b&>?*e16IKI1kaOtbnnF(4 zY%KQfJ>^~Oy9DF87^cps)xokYWJE5hl@9UghN zsC(6CSwHqEoWxQZvyC z4!qn+tuKreo|~ZKXmV)|6oSAVe=!4TI>}65Wc8aoQ4U&XkzM4gVVSrv)Gan_A&~p} zNo3mW>-8i(LL{{Xw<*HleMPzP9s`+p4?ALh@x4TW53^hv@k=Ha%(vF~mNgC25qj9q z9=}5h$lERzVqGrj5XVlPAPpgwhqJ~UV_CJg9kfVJZ>bm~AvS5tx!hvwxzg#*l??s) zyW)LOexu-x<`uL`g=!zNOocnbU21@CNpm~4N4C37tp76b+%sH?Nd9heM( zeNn9mSy|A^5+rrUv2ctDUfKh0cG#n)eHF6{;;@zUIS@G10c!P>u`HF~u<^^-d`Z;z zD#P(9wqqIKkTP|7no5+|GP`QYz8`*i#f7--+%>(!lEp2wV4G;m{Ps1#DKF2@yulsa zZt$YPdVDq}B5v^qSg?Z3sp!TD!;6Q$ooerb*0&NC5tf}%-R6dRJ&>6Bf7N$YZ zrNzK!xbx`Bl;D=q3j??vIkt*YIT_e!;9HERn~+NOgRC&qu|ftEW6{hjy3#C%V~s@) z_SFaF7YAWSUwQZs@Byoe2|=wA8+r4Oa`px;hJ z!efTcqi!BYG=8&aco)2apYH~%RlYK!n$4PUza$oT(xX%81q2nxmGPhcjv2-A+aut! zQq2yzVJ*z&`kInuL6jaIq}j1rd87_44S?2m>C5bhp4+`zf|8VyE3Tum5ZBZt(U{Cf z*}dOVf`cHIs2%T!&4Z1xzxd=;yA3)Uux*09ENn&dlM~uw^8mTZ1v~^+@2iKZQ$G}M z_=}WfHF$o*lHvDW<9gaO1`87yUl{H@wyZa?Q46L@mj>zW$&HR9&MXTy*~tLA3j+6m zXuQFa<3)kEJZX~-ZnE)xl$dX+GFjtf@rF99w#`UNQ-;cQ5RAM_-se7IeO}VK_bY8T zKNXhT1Jbd{3CWu}DSZ!((|))K@ghl4#5>BA(~m9`1m37pXkXP`rW6tXRJ{TlxxCSZ}vC}@}x$)i2t)G}@*8XR_2 zS_y$4hW_Q`P}c$O%4e-%i+8876xhn{K)R3~}{B zX0=+os+?#_{TQDSRdU9@BmB*vJ|m8&JV!d7{1QF|joFk^ z{dme2u>&FI;KbTwk@^)g%r9N7TH!{Nb;7eW3p|STq7bCX%Z+%u=B};9XiTW!D-~c= zwL@zTVdrDmLwLJo=xO!eq*WbQAYn5%+$#&lsw6mlwDkw+Sj(O$sM&&@ba{1wiYY0r zA?y`b_WoI#MP*d{9P&7c0n6d3v}hAqCm~E4g({~jA}Obb)V3atJL5^e5ci@{F;Lh$ zl068Vf~BBnw1d{%NZAvhbC)>BWYDP5kbX3>A=WtIvaIfGr8bL9_yqWPf_(EYq}( z1D5Q>UJm=E8cyC66d^BOTq>-#wt;37^m-8^nC=R<) z_qfl_^oOgjkoGAfgXf_vVafLh`Wpspg@qT6`3>W?h2A^-^OgP>BB#vqOm$rN+4{u9 ziLf1~=y9o3+fASh5ffw+sa#B5_k5Vg<)JIG;>STiaYi!P#8+IA*sVEhzSYv;f>m*M zUt3x2c#BQo*AS$P%H*Y5jx!8DkWaHNS=@Xs7%}bGRSl8~U~+=P0`Qs^zK+ zzJ>AiTGl-PcCz+nJ~Q}w?aJ!z0L%W6+~$_ae#}LDxW;778%&alWK1`t*>BUYN5dvm zbp-A1yf5D#@`MR3v=hyYC-;*jn3mMsp~iwe!tu+&LyvL}65NRX=P;?b&oxtAREAK6 zVG8HTM4e67NSoD#ulcqIOxwkR1$+1B%&`#K$qf!WY&7^K6)WV~1ex1Uf_Oq?wrJ=c zDv`-`bJb}8=l$UsfqAqt*dmdsmSAc~nxE2#OE>0mc}e&{vTiVIIRU6yH|Rw-ps%Bh z5&hCu2KZz+izg*~tu)bGgH^{d@r{6!qVRPn)70B)o&(SG5Se8$Jr992H!CB0 zx^~E8hIb%Bg@ke#Tr_2on#@*-t0h_OF%}1Tbcj$Z(gHTyHgIf^3}1Cby##)l3O+8N zbBIAn_*eh6=rHhL)+p6Fz+*Iym+5T6vvD1^mzd!;S4yeArS2+<$cp9jm7mlll1CF{ z+Lu*(C}iDTC>gQZ7GGT8v#Q_Z-LOyUd}GrfH@Sr=eP&_n zIi%0u)6{S%wz9{73Az|;wN@2)8werQigmuI$qjC6PVFrUI~16#GUM{z8mgQ$JA!uA z5}DvYwKb2m)3tWsg(FWuj16pA7M=|F6q$c)hVi>}U(jA~)E-VLTD(C;|iT|A`Dz$fxd^a7ous2_}o@70}GPISbFB z>E;NShf>#k-pFmNmhqIGyk08cI`k!dTUm?A{LNxMSfxUe+R%B@uhppXd%wq2;(IIO z7zIi}4bx~|gJuA^qJ*#0pLfobM0)K4S*9b%7`NEQlGFM%I!@?x!j2mgE2~`> zZok`yt#@FSI*0{!h=h2AuM8GI&4Ri!^06QK@!E>wE2X1W&mMtljy z)ie8|Fyt@rBFYt%-&9J|Yo1A(N1mqP_i2JGW{xC>WAO*>h4a-cgj)8; z*&N=>2apE?y?Memmw+5d$>2D>@J3i|Eo0?1xw6Wqq5xirU(Ehf3`R?zp&Sgt#vEb+ zTgEHfA{e`UX5RcNXIqB@ywL68g0P1-)((vp{dqrY4kwT)TOTDC4{a_UdzAJXzy!Kf z#fc8l=>rE)$36W^yLT2uVmbnlojPRTd+j*2iC<|N;d++SLWde#DAF$qOTD^IYIyclE2&wp3*OCfcZe5dNC)<`9I?^mu}ES?55V%@s!i(z_M^Z6uIjMv$COf8O z!E>ReFyb!QT2wKW^dlmQ&-*q9NSZnRm-b78S6`tU!5g)~8$H|`)ywBeQ5{o~+R%4T zG`N|h#WI2ENgCsgnDpCjn`)+FYZedd5m^s5kPaJE7Q5tY55#lcFN z7U0{ZEpYoy+)Q51uA&0g9s}ce4|f>Wio&`!pX;J>wxmDD0Fz1<5JjlsbAsOce00btvg3VVt(FaHt$JF31PWk02-i!a$jAcG&S^x3?6+uT_hgMaL3wFy9E7`U|sbUWm1 zNLlI;N1Cbft=Cie0D%W2#daEYv}KZWI6O*xf3qI57}kP$u&x~l6)FQf43|T<;LCIX zC4Wy{*SPJ0uGbvLKwfWV5$wUUY?5qez!w-uB3P}E5E$RxUmXD%wGVb zj-Kaw$qHQJ_n*Tk5(qA#pk_22Hcm|7VCcoa?Qt=1nJuTLuTJK##Z!x%+mIL0oA9oh z@V5%-Y40VkCF#tHL)516Fz25_pkts`*v9BYbkb(nPmLNTUL<;bT?X%RgBYnE;aF)R z$_{vB!Dc-vaGYs-c%EZg!^0*25|^7C5XBFrPXj{OmpUOo-oA&o+^4;JEMGmrJ3c3lPS7Sz!quSfNi=YFX~ib=Q+L?vhP< zr$$yr&@X)$w(b=HycaXZo4D-wkz3(NN5F#3l*aYAI$Vqzv_Cy0$TBEx{l!_BdZ~MH zXlV-wIwlSl_Fjhrf*l@R=rFHkmWOiItscJ!Vsx+prDWVq>G7 zO7Di%;T?8M!!T=2;6vki&K+TXF}geGllPErA{iihiaRKpNtoYf!I<%5q575z7hK4y z%d}dc$T&tIfZ;?ajyN)o%DraF4w(OGGXONo$ZXdf*AOk&<9Q-IyiteoqT&6BK;T$( z=x_ymYnydpq7bRI==DNZ=JVZd-C0c5A0vUt-_OcmY??}7*naQW#noO%gNpwPwQSK9 zvkz<%S%6=4!IWKhzzAh1j8wnHcluqQ<|JLmh*^dLu>$@b;`fyKo>L<%im zb*HItoo^iM>h{qoc!$>uMfT)|N3}wq&My3Ql8V~dr@>Ew<(UcNam%rU+a zk$)kLArk3kSC@-gd>BXpwp%*o`Ev5xw)wMN818eby~OLj0Qu<6rel*Q5E|OZCrl(E z-@LX?h~V}86u5k{+~JzxK=U8i+G~i3Stn{5&q+6Em+r&DN90<`X8iN94~_Dx#AwylIfLst8vQ#|OC`Y6Ut z==>8iWj|o=8&Mx_H=#+jI_>)|o2e?CVv zD1o}I!_K51Z8yqRAQlE#uC%fY)}jSCy47SHlV;9g&BPUPn~}PX`W+_7Te!>fT29mQ zVbyrJ@ACP6PJGRLWbu+Of*;$17l}afipu18Y;sZ{ghd#O^~~yt<*5B4QmU#$+L*1P>9D!5u>D2An>h3B6={}4 zd0Rs}wXLv`M-jT55n@NT>f9F!=N2jF>!}LwD}5fK_0jT}_{e-R45nEHc7FAN&1G$0 z^m$$un$L3(h(rV=ex@zF!3A=B)UsaZ1|Flzs5guO>rXdW*mWN|exfaBD8sZQsc70< z*M2;8tYp)`95J=$nQ+9(Uu#hEF;PX1a5LTQ~ut=3Q zDi6AlWtrfK91o8Mu@p*Se$TjYbW+$vGHkF{I@^~B#zzsk`|>F6o009A_~plUqCL7O z@JHo?bcM=(9DZ(%?)t;=A($ZWSi`yl6zs`bSTwsD1KDd(IcZYw2@(y|Y_w_dac^d| zydumnS?TTjHlDm27IC~#csjt^AQIJOXp0u)gHkZFc!}!Vz1UHj85pY55407uS?1QR zNyF6XK8lj7=PCG~5T{v@Vgd`i`=|T4Al<3qa!kctHj;-tw#2TUiIWM+*8)`|L^OCz zy-1~I*ZZkSjI|bJ{Ws#;Rj@L?!oI5I5pqgwjP?L$@Iu`6+t9|;n`miqb*({{S`^s5 zdd?M1l~D;#&q?7TIgOFbnRG5E+X4BU=!v z%dD$S<@!-**7a#gyinU((ylP-KK+tD`8K!!7FR)aS>m%|{orcLaDAApR}puvF%MVE zOiK_^o#7f8IPZB1Vd`&JYUqixF63Ufycyfb7&68P)*yo?g3r5D3Qas$1$|VJN}!QZ zp?;@}Ejh+7otgws3a$p8S-_Kx4Om0;3Tq#@o(i=R+kD?cTDf%1) zsmNfF~~Rj6G@dbMctQ)fSRSfezbOse2of>bTxMdWkx)WK=lO%2KZ55 zkyV2-0t*h3CM(60C{JRSCSk6BgrIwH%#N9$GFoOY)vcI znAL;YjPk-vn&nU7l2&$-Sk?JMx_6fvJR#xFCeW?67;{SS(O7CJLKxOUA%qUxc-rfY z+r%6-pOL}kNQKFHx&^w&D~0eN;(jkNTvvV83tonXZ}%+Vx(Iw~zyzNKU4pIoCcfj8 z3aNc*sz(EMz@eZw6Ou*O;T%d2%r1+o7Td^Di{-ghtj(kpP75$E8+ z<>Lr{IWlRRv&Ybhif9Ub8a1A-3;xj0gt=AfwP$6B1QoykO`9`OIzRML-O~0DM_3DJ_!((*((ZFyK%Ws=$yb zT$PAs{P9Z@73iqU?_m>7RueeT6NL4t20xc3i@1!J1A6rZ^mT?yzEv zEu8Neun`Q5+5epqX~NCZuG9mxvFG>n-D9?2!Vc8@5JOf0p~q0jDzmx;N);EL-ooMO zv8Po(?Q4z)n~2B-`r@;-*_tRqCx$3xxA>?)0;NIp^6f$>6F;`FL&&big!_y-7^trF z>}k4%S}|5}w*LN&)2=m|N*K=#MDlo-#|Ac}nW*nc!r0NnmdhqRfxsX{V$(~J(d6?C zxLw@mVUA+Shg*AFR?suCebHkVujED5d-k$2mIlh*{&Jvc_(OxaBeKQ zGGJRy{@y)-`N}~+gErkl=*oPK30hq)WtEYvKbdJ$=1B<0xzx$Qc+$73%kxgCQq`?k z?uL$dVDzN#d7E|X;vg)Q#jbeYQ<2!FXVd6aUxbLgZY)U&expQnROxMnLI*x6^7)%@ zYtZd6Bd(r$xr{Taa$gFsA?3Wq_>>#jXv(I|SXJFsz_nu^cmp{wfr1tUKB^n1_--B;z47(9%yI z%!U5}7M7@KD%+S(g4=x< zGpad0Xm-zJj*!3-3^a8*inpFH)2(Yj^qQY8CVH~GrnYe4Mpcx;Fo{>qkD8=ws1B4> z-j>y06nI>~1-R}vG6YT32Y5Y3Yf15FkAvsmCzTW8IgYL3LE=!K2O`(93T|YT+8B{C zr`;n{48+$vSbR=mq19K9<}l|;*?Y!K7GoJ;u+?6CTN^R+TT|&9dGO}67uLt-uF&0S z6m=_0s)_c8bQPx$f{xJo;bf~U`!)oHM*>5eqyu5+F7`>RTq}<1K}@%8BFWVZ&>^}Y zRjpE{en-+lw|xd(Z3iVfJ;cRMcdoJu3~LN~>Q3B%w9_p#7c?*eRt6>z5z#MLCTO#j z>8!d+6BkN?4ze^bWa05B*yJumodKI>M)U7Ry+okf-nee5p-3hktBmKCCo+hGuY&0} z2t?aXAOyx*e#|6~`oxG9tYTS|E`gBzImNy>1rK&HdtMOGedUl9Wf72_6xq9x<&OmH z=FR?=if$jt(E7l%OCkg}uf$I@sBI+BS4fO}DRCjukSww*LIvjl6kRzJLSkw_aM>x8 zAFp<9Ey>2cFQqQ9Dsb94L1~kamG_5V@H6JB_M`UXda`WZfa;5Y=XSh;w8; zWimTXOx~e}f|ZlhcQiY6oo-}zo!|VM55?HKbt1;m1W>4g{^0Ko4^Z>4(7A0 z*KUacgbYNk^e9!u(altf%r14`=4@p*Y^9WPDA?%&n$E2mO4Wo9Dlq{ClDo?}@M`K{ zwX>NSHnF1g<8$mWUNEie!_jVj9DU#+AJW`JJlqzzxuy`qZ9zF0aJ zPl2#(gJmApiv>r?kyGWxC@7)K+JkR^_LLIrT!neXEiF8pqF5U9hRSenJy9@!GSSz} zP9zQU7TO}mG=kwDqJ~(ga$u=SbB*%@A&_woK1*oXw?f*n9$**DH$-IZYgm%bpG+#Y z>B)Y8Z}j@ZV!A_VoUMJ?D{g$tt-8XS?FLr30L^Fo0-CYV58Ax-$Zle6B#XW>6YtG& zS$k>Xv(W4c|8v1SAp*g_Y0dkfx}-zJS1I2CjXv;wVZ`F3`6-7uQY4wl$jaox0UKXD9{WKxB?1WVqD zTw*t?1<+s0LnNmN|KW%vcBc>oWV|_`%|FU;ppNZ8f-T1!w~^?FOLupR36s z9C0!8kSu;`p!g?IZ3^}xQ0OI?q$bM=@IFHH7s+XD5S zK^>uK{4h$|LA2JD-XA|7%ISqZnpgepd@(mJUGC2IMJb@G-g$xc4 zq(=F-IxjpL2k!Uev}2PYw!j*OU$-&A12DNV&|pe;u1QU*#wXd!yseIE*z&jqb7{xAQt`?$-fXpo5`UDTWu5IH%t5m8?UKy%+4}KDzVI^3IyNYHy|* z-_X_Z51oW))4FD9?=~@k;%w$1(tjlmvV3bnSvC7i)6eBpMYmV3I5rcPP_!WF07BS4 zbw`_pOk0(AMZ@FRiO}=iu%lTmp3iV;|G}G?Nzr>N&_E4t+C{36j|b781!^)Zy&tly z7}B^xk4`tu=*h*OBMIb_{;Xh#Pi^OrRUd*s8uKTC``6QA^rCbr6QKZPQe^gYeMn$# zOX(xV!F-7&Bf;CxFXxOrJf(S#>u+5$-KrX)1*tyl=B0F0jVB`lL|;)y$#y~~dKpXW z&HaTO8c8oA{Hd+{Mfs^j_*{PQcTdR5Zo&SfM1Ez$2-w5J*ESBV@@ghuX>l}+J=eOq zj$I5jn+;6Z^z4bO+!QDLEOoxxLWqX1E&3gUPob+GvrGBms8N*j^j^D$bOj;HyD0!Qu+8K!KV+6!KI?G zy)`9NgcJ3UyHU?mWzYz3c5nQKlWshFjQRo-hgT#dc_`D%cC?q%dZyH5rG~x4nm_hv zXOU>+`0c=HB%9g6l5H{~zk{RDA|9|eRGoe;d8mBv5519%?bCoa%&B}WNs`Lp)pH(M zXOmrb-^S9152J$I;MMDu{TpGSar1c>yU5b6ezvHQT0Y)(Z!O+pQNA#yNAyY6gi;7` z#G^3^>+};4vS0+|aGsQ8^m)L%252LE&)(fnJmjMT-Xb%ooK4t2 zHVv?8m$;f>c6Cqy$AJQ6yQp+>Rc7Wj zRH}`r99tgv>3k-(@Anhjrk=|`PfsYOn0f=fSznR^D;|hD1np224nN=mOtyoAi%Kn7 z1StHRXA7KaWk3&ScF$Wuj_~X}reIMKk~v^7wMIg&LYi-DV}MxOLx#VWhziqb1nA2~ zNkw4Knj3D|cokSOxPR5@dbH4k7N#ZVV$tEFBv4<)tH0)y>Pa-)tnz`}+IF*k4!9MdPsj+B6R< zgJsEt>sKycB@(ch%Fi3c(MBpx`>yghg1swDa;aU&j118#WPYd>1o(KVE9{glj9&M{ zN7r><9S!+P%X{C78RO5dqnwz>d(nHO-OePrfU)qpJ z%t^s*KR^hkjN_}~dFqZHL7m*WM|ZlXtYhQ0ZF_QgclXEhipBeApTtqy@EItPG-u`F z(fyZ&g29!JWN5zeTT`-BofPzO8a(Od5B0eRgjb(I|BTm?p&Ln=;730%Gu5f%8oKWp zo(o7D(Fxy;=NWyq;XMxsZ--+;;Vl5UCx`LKXbp@mrGu(#P%uO!3*!@p<&h3sBOodm zo};;UXonNYRt{OvE=6v)ACLL``!%|BiU5|g%*jx(G#OvpHbqXCm~cyWFU7h#+w+IO|O%U)6=hHO6G1ZJZeHxMCiR zTmn$l-5Ai{jre!7K*ktuVlc3L= z&&FeWc+iE+K>!uv*+y&=O1RjQ&|1>R-A~w|kna}@R>YF3nhx1&H0lQ})Oxv|%e?%& zq?vzh)h!Hfx;XEa*7R7m^yp+XejdJ0{Kc?3f$BmWzR`xI#TI|5!k_%C#kT{0{UlR9 z&X;CU@~aPhq}cBarWdJm-jy|mC3n=St7xTtY=RuEpcA5Fh@j1 zW24?~R;bUERJx(W>`C>KC6RV)d11Cw`bWnJwBz@$uXAVqQcBT;nU`#4Pc=tzltDht z7}oOp9Ti&=vUYOf7KKH&sX19hQ0d~Qq_TThy6vCkvvZUh$rAf9i%{8R-Hhhh4gCcc z85VK%GrZgO-5$rwrcag4C?$V{(+h$(%!Oa;F_ACh7$~x3wcGId(&UKRmEZH-aKM)pY%a~$eOa&`;j+FMM4&Vz3UQ~yU7k%X;+gqBQm9OFE#14|wedpm-_jUqDfOTe8?MbR> zq%Ib)S_2AvTk(=eV5GKOkzs$f@_E@$o*kI$IvY?d>*`J2GH_GyRfUaE#DVF7t?R6q zLc;sKxwsF4Jn=djRL>aPiD4V4{;D^SLW$8#A%b1K~dzBo9gzZ^t1*R1u+ zEE5G_ND?BIrP&GiaT%@%>y-9J?1uo6v6NVuA)|ip3Uqnm8t}m*@iO7G`Hs5qn;E9YAA15z| zjU}Y^i+!H&nNSKwQ=2=pAv#y{8t#)L=C)UGyWv&-d?l^wfWf2JBgpT!PjBe}x@xdQ zwnp#MZz&c)Yf=DX^onVGuN@GeS6Y$)H1z*Pr9RM|f1pzIjP#65fAdT1|4aGMe}GB< zcZi#&+_04&9YV`9rTaH{M4jMNQ8c+&Ew-D?DNmrvd2%`WI0A^*HZAKIajuSE{nf`F zsQG7&*V{uO_iV{{N@v2>gjCneSR2L-p=pY~%abMb@~_FJkR_sHFLfn!4r`;|%(dKe zh7H58*SQuSVcVULgMb%Q*Z^$*o6STk~Uwq*_=S)89 zcUUH^=jq)?^A2$@BO_*1SLxCLz`cTei#HsuwW9{Lep?L!ZA?jh#QQQmsvi|+$ndRL zzi*I81BnJXPO@*1P7@xJw7Uin#v3M=qg;^B#?YVn0JY8fYt425dJF6*D1JafOeJfN zHwpAA&N&1F5>#($pd=HAXm4WXMk(y;F2F9Vr+7rUNBQTwDP@uJu4`c*mN`nm5%W(m zLK(s!X>e@MW2!nlryXv2yD<7NMq0TvLMfXYoAp{ch?}8x+Lyoz&Hv5fpVa(KyfHKU zokaQ%zU*&S>n}p=17Q<1w9~gWwXwIh{exnCNK(3%?}(b3qJX4?6s44@rJjSGoVBHt zHTySeIYVQIzw9h@jo%TpfA-=33sZ)m9mVEe24M?>`Q#>cGR zX){B>2aopeeA)+(_rGiYGrqiop8X#d?;{p}x#ZWiGyE9p|9A1Gws!UcCc3r&MutCQ zebfC%o1WpXk^VEXfIqSS>$C`2y)&SuR>lBYWm79YD?8J_g+Bu+n;O`g*u8Uq49p(~ z?5~@R@dLa2*Zr?|%yj=!|MkSc`f-r|-)`o2zL4e5H2=5XUtXA)K7hlI@}vDxGrrI3 zdt!QQX0muSAzHk0Li~qZG zKln+zKM|8KHTV;+k1qctBpu#!NdIq`BK^M;m@>B31`hh~P%fFiuBojxfS!h)g@z75 zW@2w|W5+@Jj(WbU#jfwF+N&jI-&&0~| zKK=jD=;&Bk-!tKgVNcVEgYmzekt--~8I! z>b{?J+dsIqys4||QaNku_oRQs{I7#1W@YrA+mFQm*-Ccyy0-RzqD%h{l`=pP K6AMWTL;WAdGB5uC literal 0 HcmV?d00001 diff --git a/main.go b/main.go index 1ef12d7..e29bf7e 100644 --- a/main.go +++ b/main.go @@ -3,7 +3,9 @@ package main import "log" import "os" import "time" -// import "reflect" +import "reflect" +import "os/signal" +import "syscall" // this is the king of dns libraries import "github.com/miekg/dns" @@ -11,6 +13,7 @@ import "github.com/miekg/dns" import "git.wit.com/wit/gui" import pb "git.wit.com/wit/witProtobuf" import "git.wit.com/jcarr/dnssecsocket" +import "git.wit.com/wit/shell" import "github.com/gobuffalo/packr" import "github.com/davecgh/go-spew/spew" @@ -21,6 +24,8 @@ var BUILDTIME string // this is passed in as an ldflag var VERSION string // this is passed in as an ldflag var State string // used as a State machine +var sigChan chan os.Signal +var errChan chan interface{} type myButtonInfo struct { Account *pb.Account // associated with what account? @@ -57,6 +62,9 @@ type myButtonInfo struct { // i18n with 'po' file support // https://github.com/leonelquinteros/gotext +// a good example of using interface{} +// https://github.com/Jeffail/tunny + func onExit(err error) { log.Println("Sleep for 1 second") time.Sleep(1 * 1000 * 1000 * 1000) @@ -86,6 +94,8 @@ func lookupAAAA(hostname string) string { } func main() { + go handleErrors() + // This puts all the files in that directory in the binary // This directory includes the default config file if there is not already one packrBox = packr.NewBox("./resources") @@ -167,3 +177,39 @@ func r() { } } } + +func init() { + log.Println("init() WAS HERE") + log.Println("init() WAS HERE") + log.Println("init() WAS HERE") + + errChan = make(chan interface{}, 3) + shell.InitCallback(handleShell) // asks for all the shell errors to be sent here + + sigChan = make(chan os.Signal, 3) + signal.Notify(sigChan, syscall.SIGUSR1) +} + +// get's sent the return values and errors from git.wit.com/wit/shell/ +func handleShell(err interface{}, ret int) { + log.Println("shell.Run() END Returned ", ret) + errChan <- err +} + +func handleErrors() { + for val := range errChan { + log.Println("handleErrors() val =", val) + log.Println("handleErrors() reflect.TypeOf(val) =", reflect.TypeOf(val)) + log.Printf("handleErrors() val type T = %T\n", val) + } +} + +// trap signals +/* +go func() { + s := make(chan os.Signal, 1) + signal.Notify(s, syscall.SIGQUIT) + <-s + panic("give me the stack") +}() +*/ diff --git a/go.mod b/resources/go.mod similarity index 100% rename from go.mod rename to resources/go.mod diff --git a/go.sum b/resources/go.sum similarity index 100% rename from go.sum rename to resources/go.sum