matth
/
subgraph-oz
mirror of https://github.com/xSmurf/oz.git
1
1
Fork 0
Code Releases Activity

gofmt

Browse Source
networking
brl 9 years ago
parent e28f599224
commit eee260576b
29 changed files with 309 additions and 309 deletions
Show Stats Download Patch File Download Diff File

6
child.go
Unescape View File

@ -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

1
cmd/oz-daemon/main.go
Unescape View File

@ -1,4 +1,5 @@
package main
import (
"github.com/subgraph/oz/oz-daemon"
)

2
cmd/oz-init/main.go
Unescape View File

@ -1,7 +1,7 @@
package main
import "github.com/subgraph/oz/oz-init"
func main() {
ozinit.Main()
}

8
fs/cleanup.go
Unescape View File

@ -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

14
fs/fs.go
Unescape View File

@ -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

2
fs/item.go
Unescape View File

@ -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

20
fs/setup.go
Unescape View File

@ -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 {

19
ipc/handlers.go
Unescape View File

@ -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
}

37
ipc/handlers_test.go
Unescape View File

@ -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

79
ipc/ipc.go
Unescape View File

@ -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
}

15
ipc/ipc_test.go
Unescape View File

@ -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))

26
ipc/message.go
Unescape View File

@ -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...)
}

14
ipc/response.go
Unescape View File

@ -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
}

1
ipc/response_test.go
Unescape View File

@ -1,4 +1,5 @@
package ipc
import (
"testing"
)

37
oz-daemon/client.go
Unescape View File

@ -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
}

1
oz-daemon/config.go
Unescape View File

@ -1,6 +1,5 @@
package daemon
type Config struct {
profileDir string `json:"profile_dir"`
}

42
oz-daemon/daemon.go
Unescape View File

@ -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
}

60
oz-daemon/launch.go
Unescape View File

@ -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':

14
oz-daemon/logging.go
Unescape View File

@ -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)
}

36
oz-daemon/protocol.go
Unescape View File

@ -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),
)

19
oz-init/client.go
Unescape View File

@ -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)
}
}

63
oz-init/init.go
Unescape View File

@ -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())
}

2
oz-init/protocol.go
Unescape View File

@ -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),
)

53
oz/main.go
Unescape View File

@ -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)

15
oz/term.go
Unescape View File

@ -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

8
profile.go
Unescape View File

@ -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

9
xpra/client.go
Unescape View File

@ -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 {

4
xpra/server.go
Unescape View File

@ -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
}

5
xpra/xpra.go
Unescape View File

@ -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
}

Write Preview
Loading…
Cancel
Save