From eee260576b087ee67f23feb6a81e56e02d06b189 Mon Sep 17 00:00:00 2001 From: brl Date: Sat, 6 Jun 2015 14:46:03 -0400 Subject: [PATCH] gofmt --- child.go | 6 ++-- cmd/oz-daemon/main.go | 1 + cmd/oz-init/main.go | 2 +- fs/cleanup.go | 8 ++--- fs/fs.go | 14 ++++---- fs/item.go | 2 +- fs/setup.go | 20 +++++------ ipc/handlers.go | 19 +++++------ ipc/handlers_test.go | 37 +++++++++++--------- ipc/ipc.go | 79 +++++++++++++++++++++---------------------- ipc/ipc_test.go | 17 ++++++---- ipc/message.go | 26 +++++++------- ipc/response.go | 14 ++++---- ipc/response_test.go | 1 + oz-daemon/client.go | 37 ++++++++++---------- oz-daemon/config.go | 3 +- oz-daemon/daemon.go | 42 +++++++++++------------ oz-daemon/launch.go | 60 ++++++++++++++++---------------- oz-daemon/logging.go | 14 ++++---- oz-daemon/protocol.go | 36 ++++++++++---------- oz-init/client.go | 19 +++++------ oz-init/init.go | 63 +++++++++++++++++----------------- oz-init/protocol.go | 2 +- oz/main.go | 53 ++++++++++++++--------------- oz/term.go | 17 +++++----- profile.go | 8 ++--- xpra/client.go | 9 ++--- xpra/server.go | 4 +-- xpra/xpra.go | 5 ++- 29 files changed, 309 insertions(+), 309 deletions(-) diff --git a/child.go b/child.go index dc91409..f75afa0 100644 --- a/child.go +++ b/child.go @@ -1,13 +1,13 @@ package oz import ( - "syscall" "github.com/op/go-logging" "os" "os/signal" + "syscall" ) -func ReapChildProcs(log *logging.Logger, callback func(int, syscall.WaitStatus)) chan os.Signal { +func ReapChildProcs(log *logging.Logger, callback func(int, syscall.WaitStatus)) chan os.Signal { sigs := make(chan os.Signal, 3) signal.Notify(sigs, syscall.SIGCHLD) go func() { @@ -22,7 +22,7 @@ func ReapChildProcs(log *logging.Logger, callback func(int, syscall.WaitStatus) func handleSIGCHLD(log *logging.Logger, callback func(int, syscall.WaitStatus)) { var wstatus syscall.WaitStatus for { - pid,err := syscall.Wait4(-1, &wstatus, syscall.WNOHANG, nil) + pid, err := syscall.Wait4(-1, &wstatus, syscall.WNOHANG, nil) switch err { case syscall.ECHILD: return diff --git a/cmd/oz-daemon/main.go b/cmd/oz-daemon/main.go index d487ade..abe43eb 100644 --- a/cmd/oz-daemon/main.go +++ b/cmd/oz-daemon/main.go @@ -1,4 +1,5 @@ package main + import ( "github.com/subgraph/oz/oz-daemon" ) diff --git a/cmd/oz-init/main.go b/cmd/oz-init/main.go index f92153b..9675edf 100644 --- a/cmd/oz-init/main.go +++ b/cmd/oz-init/main.go @@ -1,7 +1,7 @@ package main + import "github.com/subgraph/oz/oz-init" func main() { ozinit.Main() } - diff --git a/fs/cleanup.go b/fs/cleanup.go index 5391a1a..3e6efe3 100644 --- a/fs/cleanup.go +++ b/fs/cleanup.go @@ -1,12 +1,12 @@ package fs import ( + "errors" + "github.com/op/go-logging" "io/ioutil" "sort" "strings" "syscall" - "errors" - "github.com/op/go-logging" ) func (fs *Filesystem) Cleanup() error { @@ -18,7 +18,7 @@ func (fs *Filesystem) Cleanup() error { fs.log.Info("Cleanup() called on filesystem at root %s", fs.root) for { - mnts,err := getMountsBelow(fs.base) + mnts, err := getMountsBelow(fs.base) if err != nil { return err } @@ -35,7 +35,7 @@ func (fs *Filesystem) Cleanup() error { func (mnts mountEntries) unmountAll(log *logging.Logger) (bool, error) { reterr := error(nil) atLeastOne := false - for _,m := range mnts { + for _, m := range mnts { if err := syscall.Unmount(m.dir, 0); err != nil { log.Warning("Failed to unmount mountpoint %s: %v", m.dir, err) reterr = err diff --git a/fs/fs.go b/fs/fs.go index 91af669..72903b6 100644 --- a/fs/fs.go +++ b/fs/fs.go @@ -19,12 +19,12 @@ type directory struct { } type Filesystem struct { - log *logging.Logger + log *logging.Logger user *user.User - name string + name string base string root string - xpra string + xpra string userID string noDefaults bool noSysAndProc bool @@ -73,10 +73,10 @@ func (fs *Filesystem) newItem(path, target string, readonly bool) (*mountItem, e func NewFromProfile(profile *oz.Profile, user *user.User, log *logging.Logger) *Filesystem { fs := NewFilesystem(profile.Name, user, log) - for _,wl := range profile.Whitelist { + for _, wl := range profile.Whitelist { fs.addWhitelist(wl.Path, wl.Path, wl.ReadOnly) } - for _,bl := range profile.Blacklist { + for _, bl := range profile.Blacklist { fs.addBlacklist(bl.Path) } fs.noDefaults = profile.NoDefaults @@ -210,9 +210,9 @@ func copyFileInfo(info os.FileInfo, target string) error { return nil } -func createSubdirs(base string, uid,gid int, mode os.FileMode, subdirs ...string) error { +func createSubdirs(base string, uid, gid int, mode os.FileMode, subdirs ...string) error { dir := base - for _,sd := range subdirs { + for _, sd := range subdirs { dir = path.Join(dir, sd) if err := os.Mkdir(dir, mode); err != nil && !os.IsExist(err) { return err diff --git a/fs/item.go b/fs/item.go index 57fe418..20fdc08 100644 --- a/fs/item.go +++ b/fs/item.go @@ -2,12 +2,12 @@ package fs import ( "fmt" + "github.com/op/go-logging" "os" "path" "path/filepath" "strings" "syscall" - "github.com/op/go-logging" ) type MountFlag int diff --git a/fs/setup.go b/fs/setup.go index 08a9f3f..795f8f3 100644 --- a/fs/setup.go +++ b/fs/setup.go @@ -1,13 +1,13 @@ package fs import ( + "errors" "fmt" "os" - "path" - "syscall" "os/user" + "path" "strconv" - "errors" + "syscall" ) var basicBindDirs = []string{ @@ -44,7 +44,7 @@ func (fs *Filesystem) Setup() error { if err := fs.createXpraDir(); err != nil { return err } - item,err := fs.newItem(fs.xpra, fs.xpra, false) + item, err := fs.newItem(fs.xpra, fs.xpra, false) if err != nil { return err } @@ -60,7 +60,7 @@ func (fs *Filesystem) Setup() error { } func (fs *Filesystem) createXpraDir() error { - uid,gid,err := userIds(fs.user) + uid, gid, err := userIds(fs.user) if err != nil { return err } @@ -72,15 +72,15 @@ func (fs *Filesystem) createXpraDir() error { } func userIds(user *user.User) (int, int, error) { - uid,err := strconv.Atoi(user.Uid) + uid, err := strconv.Atoi(user.Uid) if err != nil { - return -1,-1, errors.New("failed to parse uid from user struct: "+ err.Error()) + return -1, -1, errors.New("failed to parse uid from user struct: " + err.Error()) } - gid,err := strconv.Atoi(user.Gid) + gid, err := strconv.Atoi(user.Gid) if err != nil { - return -1,-1, errors.New("failed to parse gid from user struct: "+ err.Error()) + return -1, -1, errors.New("failed to parse gid from user struct: " + err.Error()) } - return uid,gid,nil + return uid, gid, nil } func (fs *Filesystem) setupRootfs() error { diff --git a/ipc/handlers.go b/ipc/handlers.go index 27a9443..2ed39b8 100644 --- a/ipc/handlers.go +++ b/ipc/handlers.go @@ -1,9 +1,10 @@ package ipc + import ( - "reflect" "errors" "fmt" "github.com/op/go-logging" + "reflect" ) type handlerMap map[string]reflect.Value @@ -16,13 +17,13 @@ type msgDispatcher struct { hmap handlerMap } -func createDispatcher(log *logging.Logger, handlers...interface{}) (*msgDispatcher, error) { +func createDispatcher(log *logging.Logger, handlers ...interface{}) (*msgDispatcher, error) { md := &msgDispatcher{ - log: log, + log: log, msgs: make(chan *Message), hmap: make(map[string]reflect.Value), } - for _,h := range handlers { + for _, h := range handlers { if err := md.hmap.addHandler(h); err != nil { return nil, err } @@ -55,9 +56,9 @@ func (md *msgDispatcher) runDispatcher() { } func (handlers handlerMap) dispatch(m *Message) error { - h,ok := handlers[m.Type] + h, ok := handlers[m.Type] if !ok { - return errors.New("no handler found for message type:"+ m.Type) + return errors.New("no handler found for message type:" + m.Type) } return executeHandler(h, m) } @@ -65,7 +66,7 @@ func (handlers handlerMap) dispatch(m *Message) error { func executeHandler(h reflect.Value, m *Message) error { var args [2]reflect.Value args[0] = reflect.ValueOf(m.Body) - args[1]= reflect.ValueOf(m) + args[1] = reflect.ValueOf(m) rs := h.Call(args[:]) if len(rs) != 1 { @@ -82,7 +83,7 @@ func (handlers handlerMap) addHandler(h interface{}) error { if err != nil { return err } - if _,ok := handlers[msgType]; ok{ + if _, ok := handlers[msgType]; ok { return fmt.Errorf("duplicate handler registered for message type '%s'", msgType) } handlers[msgType] = reflect.ValueOf(h) @@ -125,5 +126,3 @@ func typeCheckHandler(h interface{}) (string, error) { } return string(in0.Field(0).Tag), nil } - - diff --git a/ipc/handlers_test.go b/ipc/handlers_test.go index 1b891a3..37d1848 100644 --- a/ipc/handlers_test.go +++ b/ipc/handlers_test.go @@ -1,27 +1,28 @@ package ipc + import ( - "testing" - "reflect" "errors" + "reflect" + "testing" ) func TestTypeCheckHandler(t *testing.T) { - type testStruct struct {} + type testStruct struct{} - cases := []interface{} { + cases := []interface{}{ "foo", - func(){}, - func(a,b int){}, + func() {}, + func(a, b int) {}, func(a *testStruct, b *Message) {}, - func(a,b *int) error{return nil}, - func(a *testStruct, b int) error {return nil}, - func(a *testStruct, b Message) error {return nil}, - func(a *testStruct, b *Message) int{return 0}, - func(a *testStruct, b *Message, c int) error {return nil}, + func(a, b *int) error { return nil }, + func(a *testStruct, b int) error { return nil }, + func(a *testStruct, b Message) error { return nil }, + func(a *testStruct, b *Message) int { return 0 }, + func(a *testStruct, b *Message, c int) error { return nil }, } - for i,h := range cases { - if _,err := typeCheckHandler(h); err == nil { + for i, h := range cases { + if _, err := typeCheckHandler(h); err == nil { t.Errorf("typeCheckHandler should return an error for case %d", i) } } @@ -29,7 +30,7 @@ func TestTypeCheckHandler(t *testing.T) { func TestAddHandler(t *testing.T) { hmap := handlerMap(make(map[string]reflect.Value)) - type testStruct struct{ + type testStruct struct { t int "tst" } legit := func(ts *testStruct, m *Message) error { return nil } @@ -48,8 +49,12 @@ func TestAddHandler(t *testing.T) { } func TestDispatch(t *testing.T) { - type testStruct struct{ t int "tester"} - type testStruct2 struct{ t int "tester2"} + type testStruct struct { + t int "tester" + } + type testStruct2 struct { + t int "tester2" + } count := 0 h1 := func(ts *testStruct, m *Message) error { count += 1 diff --git a/ipc/ipc.go b/ipc/ipc.go index 0d230cd..71f74b3 100644 --- a/ipc/ipc.go +++ b/ipc/ipc.go @@ -6,42 +6,42 @@ import ( "net" "syscall" - "github.com/op/go-logging" - "reflect" "fmt" + "github.com/op/go-logging" "io" + "reflect" ) const maxFdCount = 3 type MsgConn struct { - log *logging.Logger + log *logging.Logger conn *net.UnixConn buf [1024]byte oob []byte - disp *msgDispatcher + disp *msgDispatcher factory MsgFactory isClosed bool - idGen <-chan int - respMan *responseManager - onClose func() + idGen <-chan int + respMan *responseManager + onClose func() } type MsgServer struct { - disp *msgDispatcher - factory MsgFactory + disp *msgDispatcher + factory MsgFactory listener *net.UnixListener - done chan bool - idGen <- chan int + done chan bool + idGen <-chan int } func NewServer(address string, factory MsgFactory, log *logging.Logger, handlers ...interface{}) (*MsgServer, error) { - md,err := createDispatcher(log, handlers...) + md, err := createDispatcher(log, handlers...) if err != nil { return nil, err } - listener,err := net.ListenUnix("unix", &net.UnixAddr{address, "unix"}) + listener, err := net.ListenUnix("unix", &net.UnixAddr{address, "unix"}) if err != nil { md.close() return nil, err @@ -49,31 +49,31 @@ func NewServer(address string, factory MsgFactory, log *logging.Logger, handlers done := make(chan bool) idGen := newIdGen(done) return &MsgServer{ - disp: md, - factory: factory, + disp: md, + factory: factory, listener: listener, - done: done, - idGen: idGen, + done: done, + idGen: idGen, }, nil } func (s *MsgServer) Run() error { for { - conn,err := s.listener.AcceptUnix() + conn, err := s.listener.AcceptUnix() if err != nil { s.disp.close() s.listener.Close() return err } if err := setPassCred(conn); err != nil { - return errors.New("Failed to set SO_PASSCRED on accepted socket connection:"+ err.Error()) + return errors.New("Failed to set SO_PASSCRED on accepted socket connection:" + err.Error()) } mc := &MsgConn{ - conn: conn, - disp: s.disp, - oob: createOobBuffer(), + conn: conn, + disp: s.disp, + oob: createOobBuffer(), factory: s.factory, - idGen: s.idGen, + idGen: s.idGen, respMan: newResponseManager(), } go mc.readLoop() @@ -82,22 +82,22 @@ func (s *MsgServer) Run() error { } func Connect(address string, factory MsgFactory, log *logging.Logger, handlers ...interface{}) (*MsgConn, error) { - md,err := createDispatcher(log, handlers...) + md, err := createDispatcher(log, handlers...) if err != nil { return nil, err } - conn,err := net.DialUnix("unix", nil, &net.UnixAddr{address, "unix"}) + conn, err := net.DialUnix("unix", nil, &net.UnixAddr{address, "unix"}) if err != nil { return nil, err } done := make(chan bool) idGen := newIdGen(done) mc := &MsgConn{ - conn: conn, - disp: md, - oob: createOobBuffer(), + conn: conn, + disp: md, + oob: createOobBuffer(), factory: factory, - idGen: idGen, + idGen: idGen, respMan: newResponseManager(), onClose: func() { md.close() @@ -114,7 +114,7 @@ func newIdGen(done <-chan bool) <-chan int { return ch } -func idGenLoop(done <-chan bool, out chan <- int) { +func idGenLoop(done <-chan bool, out chan<- int) { current := int(1) for { select { @@ -142,7 +142,7 @@ func (mc *MsgConn) logger() *logging.Logger { } func (mc *MsgConn) processOneMessage() bool { - m,err := mc.readMessage() + m, err := mc.readMessage() if err != nil { if err == io.EOF { mc.Close() @@ -216,7 +216,6 @@ func (mc *MsgConn) readMessage() (*Message, error) { // conn.AddHandlers(fooHandler, simpleHandler) // - func (mc *MsgConn) AddHandlers(args ...interface{}) error { for len(args) > 0 { if err := mc.disp.hmap.addHandler(args[0]); err != nil { @@ -227,11 +226,11 @@ func (mc *MsgConn) AddHandlers(args ...interface{}) error { return nil } -func (mc *MsgConn) SendMsg(msg interface{}, fds... int) error { +func (mc *MsgConn) SendMsg(msg interface{}, fds ...int) error { return mc.sendMessage(msg, <-mc.idGen, fds...) } -func (mc *MsgConn) ExchangeMsg(msg interface{}, fds... int) (ResponseReader, error) { +func (mc *MsgConn) ExchangeMsg(msg interface{}, fds ...int) (ResponseReader, error) { id := <-mc.idGen rr := mc.respMan.register(id) @@ -239,10 +238,10 @@ func (mc *MsgConn) ExchangeMsg(msg interface{}, fds... int) (ResponseReader, err rr.Done() return nil, err } - return rr,nil + return rr, nil } -func (mc *MsgConn) sendMessage(msg interface{}, msgID int, fds... int) error { +func (mc *MsgConn) sendMessage(msg interface{}, msgID int, fds ...int) error { msgType, err := getMessageType(msg) if err != nil { return err @@ -272,9 +271,8 @@ func getMessageType(msg interface{}) (string, error) { return string(t.Field(0).Tag), nil } - func (mc *MsgConn) newBaseMessage(msgType string, msgID int, body interface{}) (*BaseMsg, error) { - bodyBytes,err := json.Marshal(body) + bodyBytes, err := json.Marshal(body) if err != nil { return nil, err } @@ -289,13 +287,12 @@ func (mc *MsgConn) sendRaw(data []byte, fds ...int) error { if len(fds) > 0 { return mc.sendWithFds(data, fds) } - _,err := mc.conn.Write(data) + _, err := mc.conn.Write(data) return err } func (mc *MsgConn) sendWithFds(data []byte, fds []int) error { oob := syscall.UnixRights(fds...) - _,_,err := mc.conn.WriteMsgUnix(data, oob, nil) + _, _, err := mc.conn.WriteMsgUnix(data, oob, nil) return err } - diff --git a/ipc/ipc_test.go b/ipc/ipc_test.go index 34f83c7..81d1cb0 100644 --- a/ipc/ipc_test.go +++ b/ipc/ipc_test.go @@ -1,8 +1,9 @@ package ipc + import ( - "testing" - "sync" "os" + "sync" + "testing" ) type TestMsg struct { @@ -12,15 +13,17 @@ type TestMsg struct { type testConnection struct { server *MsgConn client *MsgConn - wg sync.WaitGroup + wg sync.WaitGroup called bool } type testServer struct { conn *MsgConn - wg sync.WaitGroup + wg sync.WaitGroup } + const testSocket = "@test" + var testFactory = NewMsgFactory(new(TestMsg)) func testConnect(handler func(*TestMsg, *Message) error) (*testConnection, error) { @@ -51,7 +54,7 @@ func testConnect(handler func(*TestMsg, *Message) error) (*testConnection, error } func runTest(t *testing.T, handler func(*TestMsg, *Message) error, tester func(*testConnection)) { - tc,err := testConnect(handler) + tc, err := testConnect(handler) if err != nil { t.Error("error setting up test connection:", err) } @@ -86,7 +89,7 @@ func TestUcred(t *testing.T) { } func TestPassFDs(t *testing.T) { - fds := []int{1,2} + fds := []int{1, 2} handler := func(tm *TestMsg, msg *Message) error { if len(msg.Fds) != len(fds) { t.Errorf("Expecting %d descriptors, got %d", len(fds), len(msg.Fds)) @@ -97,4 +100,4 @@ func TestPassFDs(t *testing.T) { tc.client.SendMsg(&TestMsg{}, fds...) }) -} \ No newline at end of file +} diff --git a/ipc/message.go b/ipc/message.go index e72f0d8..b7c52f1 100644 --- a/ipc/message.go +++ b/ipc/message.go @@ -2,14 +2,12 @@ package ipc import ( "encoding/json" - "syscall" + "errors" "fmt" "reflect" - "errors" + "syscall" ) - - func NewMsgFactory(msgTypes ...interface{}) MsgFactory { mf := (MsgFactory)(make(map[string]func() interface{})) for _, mt := range msgTypes { @@ -24,7 +22,7 @@ func NewMsgFactory(msgTypes ...interface{}) MsgFactory { type MsgFactory map[string](func() interface{}) func (mf MsgFactory) create(msgType string) (interface{}, error) { - f,ok := mf[msgType] + f, ok := mf[msgType] if !ok { return nil, fmt.Errorf("cannot create msg type: %s", msgType) } @@ -52,19 +50,19 @@ func (mf MsgFactory) register(mt interface{}) error { } type Message struct { - Type string + Type string MsgID int - Body interface{} + Body interface{} Ucred *syscall.Ucred Fds []int mconn *MsgConn } type BaseMsg struct { - Type string - MsgID int + Type string + MsgID int IsResponse bool - Body json.RawMessage + Body json.RawMessage } func (mc *MsgConn) parseMessage(data []byte) (*Message, error) { @@ -72,7 +70,7 @@ func (mc *MsgConn) parseMessage(data []byte) (*Message, error) { if err := json.Unmarshal(data, &base); err != nil { return nil, err } - body,err := mc.factory.create(base.Type) + body, err := mc.factory.create(base.Type) if err != nil { return nil, err } @@ -83,11 +81,11 @@ func (mc *MsgConn) parseMessage(data []byte) (*Message, error) { m.Type = base.Type m.MsgID = base.MsgID m.Body = body - return m,nil + return m, nil } func (m *Message) Free() { - for _,fd := range m.Fds { + for _, fd := range m.Fds { syscall.Close(fd) } m.Fds = nil @@ -117,6 +115,6 @@ func (m *Message) parseControlData(data []byte) error { return nil } -func (m *Message) Respond(msg interface{}, fds... int) error { +func (m *Message) Respond(msg interface{}, fds ...int) error { return m.mconn.sendMessage(msg, m.MsgID, fds...) } diff --git a/ipc/response.go b/ipc/response.go index d859228..31e69fa 100644 --- a/ipc/response.go +++ b/ipc/response.go @@ -1,7 +1,8 @@ package ipc + import ( - "time" "sync" + "time" ) type ResponseReader interface { @@ -10,10 +11,10 @@ type ResponseReader interface { } type responseWaiter struct { - rm *responseManager - id int + rm *responseManager + id int timeout time.Time - ch chan *Message + ch chan *Message } func (rw *responseWaiter) Chan() <-chan *Message { @@ -28,7 +29,7 @@ func (rw *responseWaiter) Done() { } type responseManager struct { - lock sync.Locker + lock sync.Locker responseMap map[int]*responseWaiter } @@ -64,7 +65,7 @@ func (rm *responseManager) handle(m *Message) bool { return true } -func (rm *responseManager) removeById(id int, klose bool) *responseWaiter{ +func (rm *responseManager) removeById(id int, klose bool) *responseWaiter { rw := rm.responseMap[id] if rw == nil { return nil @@ -75,4 +76,3 @@ func (rm *responseManager) removeById(id int, klose bool) *responseWaiter{ } return rw } - diff --git a/ipc/response_test.go b/ipc/response_test.go index 0b5c6df..3accb4b 100644 --- a/ipc/response_test.go +++ b/ipc/response_test.go @@ -1,4 +1,5 @@ package ipc + import ( "testing" ) diff --git a/oz-daemon/client.go b/oz-daemon/client.go index 8dd8202..71a3eb7 100644 --- a/oz-daemon/client.go +++ b/oz-daemon/client.go @@ -1,9 +1,10 @@ package daemon + import ( - "github.com/subgraph/oz/ipc" "errors" - "strconv" "fmt" + "github.com/subgraph/oz/ipc" + "strconv" ) func clientConnect() (*ipc.MsgConn, error) { @@ -11,7 +12,7 @@ func clientConnect() (*ipc.MsgConn, error) { } func clientSend(msg interface{}) (*ipc.Message, error) { - c,err := clientConnect() + c, err := clientConnect() if err != nil { return nil, err } @@ -21,17 +22,17 @@ func clientSend(msg interface{}) (*ipc.Message, error) { return nil, err } - resp := <- rr.Chan() + resp := <-rr.Chan() rr.Done() - return resp,nil + return resp, nil } func ListProfiles() ([]Profile, error) { - resp,err := clientSend(new(ListProfilesMsg)) + resp, err := clientSend(new(ListProfilesMsg)) if err != nil { return nil, err } - body,ok := resp.Body.(*ListProfilesResp) + body, ok := resp.Body.(*ListProfilesResp) if !ok { return nil, errors.New("ListProfiles response was not expected type") } @@ -39,11 +40,11 @@ func ListProfiles() ([]Profile, error) { } func ListSandboxes() ([]SandboxInfo, error) { - resp,err := clientSend(&ListSandboxesMsg{}) + resp, err := clientSend(&ListSandboxesMsg{}) if err != nil { return nil, err } - body,ok := resp.Body.(*ListSandboxesResp) + body, ok := resp.Body.(*ListSandboxesResp) if !ok { return nil, errors.New("ListSandboxes response was not expected type") } @@ -51,13 +52,13 @@ func ListSandboxes() ([]SandboxInfo, error) { } func Launch(arg string) error { - idx,name,err := parseProfileArg(arg) + idx, name, err := parseProfileArg(arg) if err != nil { return err } - resp,err := clientSend(&LaunchMsg{ + resp, err := clientSend(&LaunchMsg{ Index: idx, - Name: name, + Name: name, }) if err != nil { return err @@ -74,13 +75,13 @@ func Launch(arg string) error { } func Clean(arg string) error { - idx,name,err := parseProfileArg(arg) + idx, name, err := parseProfileArg(arg) if err != nil { return err } - resp,err := clientSend(&CleanMsg{ + resp, err := clientSend(&CleanMsg{ Index: idx, - Name: name, + Name: name, }) if err != nil { return err @@ -100,18 +101,18 @@ func parseProfileArg(arg string) (int, string, error) { if len(arg) == 0 { return 0, "", errors.New("profile argument needed") } - if n,err := strconv.Atoi(arg); err == nil { + if n, err := strconv.Atoi(arg); err == nil { return n, "", nil } return 0, arg, nil } func Logs(count int, follow bool) (chan string, error) { - c,err := clientConnect() + c, err := clientConnect() if err != nil { return nil, err } - rr,err := c.ExchangeMsg(&LogsMsg{Count: count, Follow: follow}) + rr, err := c.ExchangeMsg(&LogsMsg{Count: count, Follow: follow}) if err != nil { return nil, err } diff --git a/oz-daemon/config.go b/oz-daemon/config.go index a55f49f..0c84198 100644 --- a/oz-daemon/config.go +++ b/oz-daemon/config.go @@ -1,6 +1,5 @@ package daemon - type Config struct { profileDir string `json:"profile_dir"` -} \ No newline at end of file +} diff --git a/oz-daemon/daemon.go b/oz-daemon/daemon.go index 85d5119..466146c 100644 --- a/oz-daemon/daemon.go +++ b/oz-daemon/daemon.go @@ -5,20 +5,20 @@ import ( "github.com/op/go-logging" "github.com/subgraph/oz" - "github.com/subgraph/oz/ipc" - "syscall" "github.com/subgraph/oz/fs" + "github.com/subgraph/oz/ipc" "os/user" + "syscall" ) type daemonState struct { - log *logging.Logger - profiles oz.Profiles - sandboxes []*Sandbox - nextSboxId int + log *logging.Logger + profiles oz.Profiles + sandboxes []*Sandbox + nextSboxId int nextDisplay int - memBackend *logging.ChannelMemoryBackend - backends []logging.Backend + memBackend *logging.ChannelMemoryBackend + backends []logging.Backend } func Main() { @@ -41,7 +41,7 @@ func Main() { func initialize() *daemonState { d := &daemonState{} d.initializeLogging() - ps,err := oz.LoadProfiles("/var/lib/oz/cells.d") + ps, err := oz.LoadProfiles("/var/lib/oz/cells.d") if err != nil { d.log.Fatalf("Failed to load profiles: %v", err) } @@ -53,11 +53,10 @@ func initialize() *daemonState { return d } - func (d *daemonState) handleChildExit(pid int, wstatus syscall.WaitStatus) { d.Debug("Child process pid=%d exited with status %d", pid, wstatus.ExitStatus()) - for _,sbox := range d.sandboxes { + for _, sbox := range d.sandboxes { if sbox.init.Process.Pid == pid { sbox.remove() return @@ -67,22 +66,22 @@ func (d *daemonState) handleChildExit(pid int, wstatus syscall.WaitStatus) { } func runServer(log *logging.Logger, args ...interface{}) error { - s,err := ipc.NewServer(SocketName, messageFactory, log, args...) + s, err := ipc.NewServer(SocketName, messageFactory, log, args...) if err != nil { return err } return s.Run() } -func (d * daemonState) handlePing(msg *PingMsg, m *ipc.Message) error { +func (d *daemonState) handlePing(msg *PingMsg, m *ipc.Message) error { d.Debug("received ping with data [%s]", msg.Data) return m.Respond(&PingMsg{msg.Data}) } -func (d * daemonState) handleListProfiles(msg *ListProfilesMsg, m *ipc.Message) error { +func (d *daemonState) handleListProfiles(msg *ListProfilesMsg, m *ipc.Message) error { r := new(ListProfilesResp) index := 1 - for _,p := range d.profiles { + for _, p := range d.profiles { r.Profiles = append(r.Profiles, Profile{Index: index, Name: p.Name, Path: p.Path}) index += 1 } @@ -91,12 +90,12 @@ func (d * daemonState) handleListProfiles(msg *ListProfilesMsg, m *ipc.Message) func (d *daemonState) handleLaunch(msg *LaunchMsg, m *ipc.Message) error { d.Debug("Launch message received: %+v", msg) - p,err := d.getProfileByIdxOrName(msg.Index, msg.Name) + p, err := d.getProfileByIdxOrName(msg.Index, msg.Name) if err != nil { return m.Respond(&ErrorMsg{err.Error()}) } d.Debug("Would launch %s", p.Name) - _,err = d.launch(p, m.Ucred.Uid, m.Ucred.Gid) + _, err = d.launch(p, m.Ucred.Uid, m.Ucred.Gid) if err != nil { d.Warning("launch of %s failed: %v", p.Name, err) return m.Respond(&ErrorMsg{err.Error()}) @@ -112,9 +111,9 @@ func (d *daemonState) getProfileByIdxOrName(index int, name string) (*oz.Profile return d.profiles[index-1], nil } - for _,p := range d.profiles { + for _, p := range d.profiles { if p.Name == name { - return p,nil + return p, nil } } return nil, fmt.Errorf("could not find profile name '%s'", name) @@ -129,7 +128,7 @@ func (d *daemonState) handleListSandboxes(list *ListSandboxesMsg, msg *ipc.Messa } func (d *daemonState) handleClean(clean *CleanMsg, msg *ipc.Message) error { - p,err := d.getProfileByIdxOrName(clean.Index, clean.Name) + p, err := d.getProfileByIdxOrName(clean.Index, clean.Name) if err != nil { return msg.Respond(&ErrorMsg{err.Error()}) } @@ -140,7 +139,7 @@ func (d *daemonState) handleClean(clean *CleanMsg, msg *ipc.Message) error { } } // XXX - u,_ := user.Current() + u, _ := user.Current() fs := fs.NewFromProfile(p, u, d.log) if err := fs.Cleanup(); err != nil { return msg.Respond(&ErrorMsg{err.Error()}) @@ -160,4 +159,3 @@ func (d *daemonState) handleLogs(logs *LogsMsg, msg *ipc.Message) error { msg.Respond(&OkMsg{}) return nil } - diff --git a/oz-daemon/launch.go b/oz-daemon/launch.go index 7d51783..4c1235d 100644 --- a/oz-daemon/launch.go +++ b/oz-daemon/launch.go @@ -1,32 +1,32 @@ package daemon + import ( + "bufio" + "fmt" "github.com/subgraph/oz" "github.com/subgraph/oz/fs" - "os/exec" - "syscall" - "fmt" - "io" - "bufio" - "os/user" "github.com/subgraph/oz/xpra" + "io" "os" + "os/exec" + "os/user" "path" + "syscall" ) const initPath = "/usr/local/bin/oz-init" - type Sandbox struct { - daemon *daemonState - id int + daemon *daemonState + id int display int profile *oz.Profile - init *exec.Cmd - cred *syscall.Credential - fs *fs.Filesystem - stderr io.ReadCloser - addr string - xpra *xpra.Xpra + init *exec.Cmd + cred *syscall.Credential + fs *fs.Filesystem + stderr io.ReadCloser + addr string + xpra *xpra.Xpra } /* @@ -45,11 +45,11 @@ func createInitCommand(name, chroot string, uid uint32, display int) *exec.Cmd { cmd := exec.Command(initPath) cmd.Dir = "/" cmd.SysProcAttr = &syscall.SysProcAttr{ - Chroot: chroot, + Chroot: chroot, Cloneflags: initCloneFlags, } cmd.Env = []string{ - "INIT_PROFILE="+name, + "INIT_PROFILE=" + name, fmt.Sprintf("INIT_UID=%d", uid), } if display > 0 { @@ -58,8 +58,8 @@ func createInitCommand(name, chroot string, uid uint32, display int) *exec.Cmd { return cmd } -func (d *daemonState) launch(p *oz.Profile, uid,gid uint32) (*Sandbox, error) { - u,err := user.LookupId(fmt.Sprintf("%d", uid)) +func (d *daemonState) launch(p *oz.Profile, uid, gid uint32) (*Sandbox, error) { + u, err := user.LookupId(fmt.Sprintf("%d", uid)) if err != nil { return nil, fmt.Errorf("failed to lookup user for uid=%d: %v", uid, err) } @@ -74,7 +74,7 @@ func (d *daemonState) launch(p *oz.Profile, uid,gid uint32) (*Sandbox, error) { } cmd := createInitCommand(p.Name, fs.Root(), uid, display) - pp,err := cmd.StderrPipe() + pp, err := cmd.StderrPipe() if err != nil { fs.Cleanup() return nil, fmt.Errorf("error creating stderr pipe for init process: %v", err) @@ -85,25 +85,25 @@ func (d *daemonState) launch(p *oz.Profile, uid,gid uint32) (*Sandbox, error) { return nil, err } sbox := &Sandbox{ - daemon: d, - id: d.nextSboxId, + daemon: d, + id: d.nextSboxId, display: display, profile: p, - init: cmd, - cred: &syscall.Credential{Uid: uid, Gid: gid}, - fs: fs, - addr: path.Join(fs.Root(), "tmp", "oz-init-control"), - stderr: pp, + init: cmd, + cred: &syscall.Credential{Uid: uid, Gid: gid}, + fs: fs, + addr: path.Join(fs.Root(), "tmp", "oz-init-control"), + stderr: pp, } go sbox.logMessages() d.nextSboxId += 1 d.sandboxes = append(d.sandboxes, sbox) - return sbox,nil + return sbox, nil } func (sbox *Sandbox) remove() { sboxes := []*Sandbox{} - for _,sb := range sbox.daemon.sandboxes { + for _, sb := range sbox.daemon.sandboxes { if sb == sbox { sb.fs.Cleanup() } else { @@ -142,7 +142,7 @@ func (sbox *Sandbox) logLine(line string) { func (sbox *Sandbox) getLogFunc(c byte) func(string, ...interface{}) { log := sbox.daemon.log - switch(c) { + switch c { case 'D': return log.Debug case 'I': diff --git a/oz-daemon/logging.go b/oz-daemon/logging.go index 6f79355..752a10a 100644 --- a/oz-daemon/logging.go +++ b/oz-daemon/logging.go @@ -1,12 +1,12 @@ package daemon + import ( "github.com/op/go-logging" + "github.com/subgraph/oz/ipc" "log" "os" - "github.com/subgraph/oz/ipc" ) - func (d *daemonState) Debug(format string, args ...interface{}) { d.log.Debug(format, args...) } @@ -38,9 +38,11 @@ func (d *daemonState) initializeLogging() { } d.installBackends() } + var format = logging.MustStringFormatter( "%{color}%{time:15:04:05} ▶ %{level:.4s} %{id:03x}%{color:reset} %{message}", ) + func (d *daemonState) addBackend(be logging.Backend) { d.backends = append(d.backends, be) d.installBackends() @@ -48,7 +50,7 @@ func (d *daemonState) addBackend(be logging.Backend) { func (d *daemonState) removeBackend(be logging.Backend) { newBackends := []logging.Backend{} - for _,b := range d.backends { + for _, b := range d.backends { if b != be { newBackends = append(newBackends, b) } @@ -66,9 +68,9 @@ func (d *daemonState) installBackends() { } type logFollower struct { - daemon *daemonState + daemon *daemonState wrapper logging.Backend - m *ipc.Message + m *ipc.Message } func (lf *logFollower) Log(level logging.Level, calldepth int, rec *logging.Record) error { @@ -84,7 +86,7 @@ func (lf *logFollower) remove() { } func (d *daemonState) followLogs(m *ipc.Message) { - be := &logFollower{m:m, daemon: d} + be := &logFollower{m: m, daemon: d} be.wrapper = logging.NewBackendFormatter(be, format) d.addBackend(be.wrapper) } diff --git a/oz-daemon/protocol.go b/oz-daemon/protocol.go index ff16e26..a5a3500 100644 --- a/oz-daemon/protocol.go +++ b/oz-daemon/protocol.go @@ -1,4 +1,5 @@ package daemon + import "github.com/subgraph/oz/ipc" const SocketName = "@oz-control" @@ -21,8 +22,8 @@ type ListProfilesMsg struct { type Profile struct { Index int - Name string - Path string + Name string + Path string } type ListProfilesResp struct { @@ -31,7 +32,7 @@ type ListProfilesResp struct { type LaunchMsg struct { Index int "Launch" - Name string + Name string } type ListSandboxesMsg struct { @@ -39,7 +40,7 @@ type ListSandboxesMsg struct { } type SandboxInfo struct { - Id int + Id int Address string Profile string } @@ -50,11 +51,11 @@ type ListSandboxesResp struct { type CleanMsg struct { Index int "Clean" - Name string + Name string } type LogsMsg struct { - Count int "Logs" + Count int "Logs" Follow bool } @@ -63,16 +64,15 @@ type LogData struct { } var messageFactory = ipc.NewMsgFactory( - new(PingMsg), - new(OkMsg), - new(ErrorMsg), - new(ListProfilesMsg), - new(ListProfilesResp), - new(LaunchMsg), - new(ListSandboxesMsg), - new(ListSandboxesResp), - new(CleanMsg), - new(LogsMsg), - new(LogData), + new(PingMsg), + new(OkMsg), + new(ErrorMsg), + new(ListProfilesMsg), + new(ListProfilesResp), + new(LaunchMsg), + new(ListSandboxesMsg), + new(ListSandboxesResp), + new(CleanMsg), + new(LogsMsg), + new(LogData), ) - diff --git a/oz-init/client.go b/oz-init/client.go index 8671205..a2f9928 100644 --- a/oz-init/client.go +++ b/oz-init/client.go @@ -1,8 +1,9 @@ package ozinit + import ( - "github.com/subgraph/oz/ipc" "errors" "fmt" + "github.com/subgraph/oz/ipc" ) func clientConnect(addr string) (*ipc.MsgConn, error) { @@ -10,7 +11,7 @@ func clientConnect(addr string) (*ipc.MsgConn, error) { } func clientSend(addr string, msg interface{}) (*ipc.Message, error) { - c,err := clientConnect(addr) + c, err := clientConnect(addr) if err != nil { return nil, err } @@ -20,13 +21,13 @@ func clientSend(addr string, msg interface{}) (*ipc.Message, error) { return nil, err } - resp := <- rr.Chan() + resp := <-rr.Chan() rr.Done() return resp, nil } func Ping(addr string) error { - resp,err := clientSend(addr, new(PingMsg)) + resp, err := clientSend(addr, new(PingMsg)) if err != nil { return err } @@ -41,12 +42,12 @@ func Ping(addr string) error { } func RunShell(addr, term string) (int, error) { - c,err := clientConnect(addr) + c, err := clientConnect(addr) if err != nil { return 0, err } - rr,err := c.ExchangeMsg(&RunShellMsg{Term: term}) - resp := <- rr.Chan() + rr, err := c.ExchangeMsg(&RunShellMsg{Term: term}) + resp := <-rr.Chan() rr.Done() c.Close() if err != nil { @@ -54,7 +55,7 @@ func RunShell(addr, term string) (int, error) { } switch body := resp.Body.(type) { case *ErrorMsg: - return 0,errors.New(body.Msg) + return 0, errors.New(body.Msg) case *OkMsg: if len(resp.Fds) == 0 { return 0, errors.New("RunShell message returned Ok, but no file descriptor received") @@ -64,5 +65,3 @@ func RunShell(addr, term string) (int, error) { return 0, fmt.Errorf("Unexpected message type received: %+v", body) } } - - diff --git a/oz-init/init.go b/oz-init/init.go index 69859dc..65e76ec 100644 --- a/oz-init/init.go +++ b/oz-init/init.go @@ -1,34 +1,34 @@ package ozinit import ( - "os" + "bufio" + "fmt" + "github.com/kr/pty" + "github.com/op/go-logging" "github.com/subgraph/oz" "github.com/subgraph/oz/fs" "github.com/subgraph/oz/ipc" - "os/exec" - "syscall" - "github.com/op/go-logging" - "github.com/kr/pty" - "fmt" "github.com/subgraph/oz/xpra" + "io" + "os" + "os/exec" "os/user" "strconv" - "io" - "bufio" "strings" + "syscall" ) const profileDirectory = "/var/lib/oz/cells.d" const socketAddress = "/tmp/oz-init-control" type initState struct { - log *logging.Logger + log *logging.Logger profile *oz.Profile - uid int - gid int - user *user.User + uid int + gid int + user *user.User display int - fs *fs.Filesystem + fs *fs.Filesystem } // By convention oz-init writes log messages to stderr with a single character @@ -38,7 +38,7 @@ func createLogger() *logging.Logger { l := logging.MustGetLogger("oz-init") be := logging.NewLogBackend(os.Stderr, "", 0) f := logging.MustStringFormatter("%{level:.1s} %{message}") - fbe := logging.NewBackendFormatter(be,f) + fbe := logging.NewBackendFormatter(be, f) logging.SetBackend(fbe) return l } @@ -65,29 +65,29 @@ func parseArgs() *initState { uidval := getvar("INIT_UID") dispval := os.Getenv("INIT_DISPLAY") - p,err := loadProfile(pname) + p, err := loadProfile(pname) if err != nil { log.Error("Could not load profile %s: %v", pname, err) os.Exit(1) } - uid,err := strconv.Atoi(uidval) + uid, err := strconv.Atoi(uidval) if err != nil { log.Error("Could not parse INIT_UID argument (%s) into an integer: %v", uidval, err) os.Exit(1) } - u,err := user.LookupId(uidval) + u, err := user.LookupId(uidval) if err != nil { log.Error("Failed to look up user with uid=%s: %v", uidval, err) os.Exit(1) } - gid,err := strconv.Atoi(u.Gid) + gid, err := strconv.Atoi(u.Gid) if err != nil { log.Error("Failed to parse gid value (%s) from user struct: %v", u.Gid, err) os.Exit(1) } display := 0 if dispval != "" { - d,err := strconv.Atoi(dispval) + d, err := strconv.Atoi(dispval) if err != nil { log.Error("Unable to parse display (%s) into an integer: %v", dispval, err) os.Exit(1) @@ -96,13 +96,13 @@ func parseArgs() *initState { } return &initState{ - log: log, + log: log, profile: p, - uid: uid, - gid: gid, - user: u, + uid: uid, + gid: gid, + user: u, display: display, - fs: fs.NewFromProfile(p, u, log), + fs: fs.NewFromProfile(p, u, log), } } @@ -127,7 +127,7 @@ func (st *initState) runInit() { oz.ReapChildProcs(st.log, st.handleChildExit) - s,err := ipc.NewServer(socketAddress, messageFactory, st.log, + s, err := ipc.NewServer(socketAddress, messageFactory, st.log, handlePing, st.handleRunShell, ) @@ -152,14 +152,14 @@ func (st *initState) startXpraServer() { return } xpra := xpra.NewServer(&st.profile.XServer, uint64(st.display), workdir) - p,err := xpra.Process.StderrPipe() + p, err := xpra.Process.StderrPipe() if err != nil { st.log.Warning("Error creating stderr pipe for xpra output: %v", err) os.Exit(1) } go st.readXpraOutput(p) xpra.Process.Env = []string{ - "HOME="+ st.user.HomeDir, + "HOME=" + st.user.HomeDir, } xpra.Process.SysProcAttr = &syscall.SysProcAttr{} xpra.Process.SysProcAttr.Credential = &syscall.Credential{ @@ -192,11 +192,11 @@ func (st *initState) readXpraOutput(r io.ReadCloser) { } func loadProfile(name string) (*oz.Profile, error) { - ps,err := oz.LoadProfiles(profileDirectory) + ps, err := oz.LoadProfiles(profileDirectory) if err != nil { return nil, err } - for _,p := range ps { + for _, p := range ps { if name == p.Name { return p, nil } @@ -228,7 +228,7 @@ func (st *initState) handleRunShell(rs *RunShellMsg, msg *ipc.Message) error { cmd.Env = append(cmd.Env, "PATH=/usr/bin:/bin") cmd.Env = append(cmd.Env, fmt.Sprintf("PS1=[%s] $ ", st.profile.Name)) st.log.Info("Executing shell...") - f,err := ptyStart(cmd) + f, err := ptyStart(cmd) defer f.Close() if err != nil { return msg.Respond(&ErrorMsg{err.Error()}) @@ -238,7 +238,7 @@ func (st *initState) handleRunShell(rs *RunShellMsg, msg *ipc.Message) error { } func ptyStart(c *exec.Cmd) (ptty *os.File, err error) { - ptty,tty, err := pty.Open() + ptty, tty, err := pty.Open() if err != nil { return nil, err } @@ -261,4 +261,3 @@ func ptyStart(c *exec.Cmd) (ptty *os.File, err error) { func (is *initState) handleChildExit(pid int, wstatus syscall.WaitStatus) { is.log.Debug("Child process pid=%d exited with status %d", pid, wstatus.ExitStatus()) } - diff --git a/oz-init/protocol.go b/oz-init/protocol.go index cb285ed..842cf5f 100644 --- a/oz-init/protocol.go +++ b/oz-init/protocol.go @@ -1,4 +1,5 @@ package ozinit + import "github.com/subgraph/oz/ipc" type OkMsg struct { @@ -23,4 +24,3 @@ var messageFactory = ipc.NewMsgFactory( new(PingMsg), new(RunShellMsg), ) - diff --git a/oz/main.go b/oz/main.go index 839dc0a..e29d5ae 100644 --- a/oz/main.go +++ b/oz/main.go @@ -3,11 +3,11 @@ package main import ( "fmt" "github.com/codegangsta/cli" - "os" "github.com/subgraph/oz/oz-daemon" - "strconv" - "io" "github.com/subgraph/oz/oz-init" + "io" + "os" + "strconv" ) func main() { @@ -17,40 +17,38 @@ func main() { app.Usage = "command line interface to Oz sandboxes" app.Author = "Subgraph" app.Email = "info@subgraph.com" - app.Commands = []cli.Command { + app.Commands = []cli.Command{ { - Name: "profiles", - Usage: "list available application profiles", + Name: "profiles", + Usage: "list available application profiles", Action: handleProfiles, }, { - Name: "launch", - Usage: "launch an application profile", + Name: "launch", + Usage: "launch an application profile", Action: handleLaunch, }, { - Name: "list", - Usage: "list running sandboxes", + Name: "list", + Usage: "list running sandboxes", Action: handleList, }, { - Name: "shell", - Usage: "start a shell in a running container", + Name: "shell", + Usage: "start a shell in a running container", Action: handleShell, }, { - Name: "clean", + Name: "clean", Action: handleClean, - }, { - Name: "logs", + Name: "logs", Action: handleLogs, - Flags: []cli.Flag { + Flags: []cli.Flag{ cli.BoolFlag{ Name: "f", }, - }, }, } @@ -58,12 +56,12 @@ func main() { } func handleProfiles(c *cli.Context) { - ps,err := daemon.ListProfiles() + ps, err := daemon.ListProfiles() if err != nil { fmt.Printf("Error listing profiles: %v\n", err) os.Exit(1) } - for i,p := range ps { + for i, p := range ps { fmt.Printf("%2d) %-30s %s\n", i+1, p.Name, p.Path) } } @@ -81,7 +79,7 @@ func handleLaunch(c *cli.Context) { } func handleList(c *cli.Context) { - sboxes,err := daemon.ListSandboxes() + sboxes, err := daemon.ListSandboxes() if err != nil { fmt.Printf("Error listing running containers: %v\n", err) os.Exit(1) @@ -101,13 +99,13 @@ func handleShell(c *cli.Context) { fmt.Println("Sandbox id argument needed") os.Exit(1) } - id,err := strconv.Atoi(c.Args()[0]) + id, err := strconv.Atoi(c.Args()[0]) if err != nil { fmt.Println("Sandbox id argument must be an integer") os.Exit(1) } - sb,err := getSandboxById(id) + sb, err := getSandboxById(id) if err != nil { fmt.Printf("Error retrieving sandbox list: %v\n", err) } @@ -115,13 +113,13 @@ func handleShell(c *cli.Context) { fmt.Printf("No sandbox found with id = %d\n", id) } term := os.Getenv("TERM") - fd,err := ozinit.RunShell(sb.Address, term) + fd, err := ozinit.RunShell(sb.Address, term) if err != nil { fmt.Printf("start shell command failed: %v\n", err) os.Exit(1) } fmt.Println("Entering interactive shell?\n") - st,err := SetRawTerminal(0) + st, err := SetRawTerminal(0) HandleResize(fd) f := os.NewFile(uintptr(fd), "") go io.Copy(f, os.Stdin) @@ -130,15 +128,14 @@ func handleShell(c *cli.Context) { fmt.Println("done..") } - func getSandboxById(id int) (*daemon.SandboxInfo, error) { - sboxes,err := daemon.ListSandboxes() + sboxes, err := daemon.ListSandboxes() if err != nil { return nil, err } for _, sb := range sboxes { if id == sb.Id { - return &sb,nil + return &sb, nil } } return nil, nil @@ -157,7 +154,7 @@ func handleClean(c *cli.Context) { func handleLogs(c *cli.Context) { follow := c.Bool("f") - ch,err := daemon.Logs(0,follow) + ch, err := daemon.Logs(0, follow) if err != nil { fmt.Println("Logs failed", err) os.Exit(1) diff --git a/oz/term.go b/oz/term.go index 2243b44..2fcd52d 100644 --- a/oz/term.go +++ b/oz/term.go @@ -1,17 +1,18 @@ package main + import ( - "syscall" - "unsafe" + "fmt" "os" "os/signal" - "fmt" + "syscall" + "unsafe" ) type winsize struct { Height uint16 - Width uint16 - x uint16 - y uint16 + Width uint16 + x uint16 + y uint16 } type State struct { termios Termios @@ -101,7 +102,7 @@ func HandleResize(fd int) { } func handleSIGWINCH(fd int) { - ws,errno := GetWinsize(0) + ws, errno := GetWinsize(0) if errno != 0 { fmt.Printf("error reading winsize: %v\n", errno.Error()) return @@ -109,4 +110,4 @@ func handleSIGWINCH(fd int) { if errno := SetWinsize(uintptr(fd), ws); errno != 0 { fmt.Printf("error setting winsize: %v", errno.Error()) } -} \ No newline at end of file +} diff --git a/profile.go b/profile.go index 4b42490..bb5807f 100644 --- a/profile.go +++ b/profile.go @@ -65,18 +65,18 @@ var loadedProfiles []*Profile type Profiles []*Profile -func (ps Profiles) GetProfileByName(name string) (*Profile,error) { +func (ps Profiles) GetProfileByName(name string) (*Profile, error) { if loadedProfiles == nil { - ps ,err := LoadProfiles(defaultProfileDirectory) + ps, err := LoadProfiles(defaultProfileDirectory) if err != nil { return nil, err } loadedProfiles = ps } - for _,p := range loadedProfiles { + for _, p := range loadedProfiles { if p.Name == name { - return p,nil + return p, nil } } return nil, nil diff --git a/xpra/client.go b/xpra/client.go index 09560b3..1a20156 100644 --- a/xpra/client.go +++ b/xpra/client.go @@ -1,9 +1,10 @@ package xpra + import ( - "github.com/subgraph/oz" "fmt" - "os" "github.com/op/go-logging" + "github.com/subgraph/oz" + "os" "os/exec" "syscall" ) @@ -54,11 +55,11 @@ func prepareClientArgs(config *oz.XServerConf, display uint64, workdir string, l return args } -func exists(path,label string, log *logging.Logger) bool { +func exists(path, label string, log *logging.Logger) bool { if path == "" { return false } - if _,err := os.Stat(path); err != nil { + if _, err := os.Stat(path); err != nil { if !os.IsNotExist(err) { log.Notice("%s file missing at %s, ignored.", label, path) } else { diff --git a/xpra/server.go b/xpra/server.go index e306a7c..b7a8b14 100644 --- a/xpra/server.go +++ b/xpra/server.go @@ -1,7 +1,8 @@ package xpra + import ( - "github.com/subgraph/oz" "fmt" + "github.com/subgraph/oz" "os" "os/exec" ) @@ -37,4 +38,3 @@ func prepareServerArgs(config *oz.XServerConf, display uint64, workdir string) [ ) return args } - diff --git a/xpra/xpra.go b/xpra/xpra.go index 62fbd1c..723285f 100644 --- a/xpra/xpra.go +++ b/xpra/xpra.go @@ -1,7 +1,8 @@ package xpra + import ( - "os/exec" "github.com/subgraph/oz" + "os/exec" ) type Xpra struct { @@ -18,7 +19,6 @@ type Xpra struct { // Arguments passed to xpra command xpraArgs []string - } var xpraDefaultArgs = []string{ @@ -52,4 +52,3 @@ func getDefaultArgs(config *oz.XServerConf) []string { return args } -