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

gofmt

Browse Source
networking
brl 10 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 package oz
import ( import (
"syscall"
"github.com/op/go-logging" "github.com/op/go-logging"
"os" "os"
"os/signal" "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) sigs := make(chan os.Signal, 3)
signal.Notify(sigs, syscall.SIGCHLD) signal.Notify(sigs, syscall.SIGCHLD)
go func() { 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)) { func handleSIGCHLD(log *logging.Logger, callback func(int, syscall.WaitStatus)) {
var wstatus syscall.WaitStatus var wstatus syscall.WaitStatus
for { for {
pid,err := syscall.Wait4(-1, &wstatus, syscall.WNOHANG, nil) pid, err := syscall.Wait4(-1, &wstatus, syscall.WNOHANG, nil)
switch err { switch err {
case syscall.ECHILD: case syscall.ECHILD:
return return

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

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

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

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

8
fs/cleanup.go
Unescape View File

@ -1,12 +1,12 @@
package fs package fs
import ( import (
"errors"
"github.com/op/go-logging"
"io/ioutil" "io/ioutil"
"sort" "sort"
"strings" "strings"
"syscall" "syscall"
"errors"
"github.com/op/go-logging"
) )
func (fs *Filesystem) Cleanup() error { 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) fs.log.Info("Cleanup() called on filesystem at root %s", fs.root)
for { for {
mnts,err := getMountsBelow(fs.base) mnts, err := getMountsBelow(fs.base)
if err != nil { if err != nil {
return err return err
} }
@ -35,7 +35,7 @@ func (fs *Filesystem) Cleanup() error {
func (mnts mountEntries) unmountAll(log *logging.Logger) (bool, error) { func (mnts mountEntries) unmountAll(log *logging.Logger) (bool, error) {
reterr := error(nil) reterr := error(nil)
atLeastOne := false atLeastOne := false
for _,m := range mnts { for _, m := range mnts {
if err := syscall.Unmount(m.dir, 0); err != nil { if err := syscall.Unmount(m.dir, 0); err != nil {
log.Warning("Failed to unmount mountpoint %s: %v", m.dir, err) log.Warning("Failed to unmount mountpoint %s: %v", m.dir, err)
reterr = err reterr = err

14
fs/fs.go
Unescape View File

@ -19,12 +19,12 @@ type directory struct {
} }
type Filesystem struct { type Filesystem struct {
log *logging.Logger log *logging.Logger
user *user.User user *user.User
name string name string
base string base string
root string root string
xpra string xpra string
userID string userID string
noDefaults bool noDefaults bool
noSysAndProc 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 { func NewFromProfile(profile *oz.Profile, user *user.User, log *logging.Logger) *Filesystem {
fs := NewFilesystem(profile.Name, user, log) fs := NewFilesystem(profile.Name, user, log)
for _,wl := range profile.Whitelist { for _, wl := range profile.Whitelist {
fs.addWhitelist(wl.Path, wl.Path, wl.ReadOnly) fs.addWhitelist(wl.Path, wl.Path, wl.ReadOnly)
} }
for _,bl := range profile.Blacklist { for _, bl := range profile.Blacklist {
fs.addBlacklist(bl.Path) fs.addBlacklist(bl.Path)
} }
fs.noDefaults = profile.NoDefaults fs.noDefaults = profile.NoDefaults
@ -210,9 +210,9 @@ func copyFileInfo(info os.FileInfo, target string) error {
return nil 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 dir := base
for _,sd := range subdirs { for _, sd := range subdirs {
dir = path.Join(dir, sd) dir = path.Join(dir, sd)
if err := os.Mkdir(dir, mode); err != nil && !os.IsExist(err) { if err := os.Mkdir(dir, mode); err != nil && !os.IsExist(err) {
return err return err

2
fs/item.go
Unescape View File

@ -2,12 +2,12 @@ package fs
import ( import (
"fmt" "fmt"
"github.com/op/go-logging"
"os" "os"
"path" "path"
"path/filepath" "path/filepath"
"strings" "strings"
"syscall" "syscall"
"github.com/op/go-logging"
) )
type MountFlag int type MountFlag int

20
fs/setup.go
Unescape View File

@ -1,13 +1,13 @@
package fs package fs
import ( import (
"errors"
"fmt" "fmt"
"os" "os"
"path"
"syscall"
"os/user" "os/user"
"path"
"strconv" "strconv"
"errors" "syscall"
) )
var basicBindDirs = []string{ var basicBindDirs = []string{
@ -44,7 +44,7 @@ func (fs *Filesystem) Setup() error {
if err := fs.createXpraDir(); err != nil { if err := fs.createXpraDir(); err != nil {
return err return err
} }
item,err := fs.newItem(fs.xpra, fs.xpra, false) item, err := fs.newItem(fs.xpra, fs.xpra, false)
if err != nil { if err != nil {
return err return err
} }
@ -60,7 +60,7 @@ func (fs *Filesystem) Setup() error {
} }
func (fs *Filesystem) createXpraDir() error { func (fs *Filesystem) createXpraDir() error {
uid,gid,err := userIds(fs.user) uid, gid, err := userIds(fs.user)
if err != nil { if err != nil {
return err return err
} }
@ -72,15 +72,15 @@ func (fs *Filesystem) createXpraDir() error {
} }
func userIds(user *user.User) (int, int, error) { func userIds(user *user.User) (int, int, error) {
uid,err := strconv.Atoi(user.Uid) uid, err := strconv.Atoi(user.Uid)
if err != nil { 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 { 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 { func (fs *Filesystem) setupRootfs() error {

19
ipc/handlers.go
Unescape View File

@ -1,9 +1,10 @@
package ipc package ipc
import ( import (
"reflect"
"errors" "errors"
"fmt" "fmt"
"github.com/op/go-logging" "github.com/op/go-logging"
"reflect"
) )
type handlerMap map[string]reflect.Value type handlerMap map[string]reflect.Value
@ -16,13 +17,13 @@ type msgDispatcher struct {
hmap handlerMap hmap handlerMap
} }
func createDispatcher(log *logging.Logger, handlers...interface{}) (*msgDispatcher, error) { func createDispatcher(log *logging.Logger, handlers ...interface{}) (*msgDispatcher, error) {
md := &msgDispatcher{ md := &msgDispatcher{
log: log, log: log,
msgs: make(chan *Message), msgs: make(chan *Message),
hmap: make(map[string]reflect.Value), hmap: make(map[string]reflect.Value),
} }
for _,h := range handlers { for _, h := range handlers {
if err := md.hmap.addHandler(h); err != nil { if err := md.hmap.addHandler(h); err != nil {
return nil, err return nil, err
} }
@ -55,9 +56,9 @@ func (md *msgDispatcher) runDispatcher() {
} }
func (handlers handlerMap) dispatch(m *Message) error { func (handlers handlerMap) dispatch(m *Message) error {
h,ok := handlers[m.Type] h, ok := handlers[m.Type]
if !ok { 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) return executeHandler(h, m)
} }
@ -65,7 +66,7 @@ func (handlers handlerMap) dispatch(m *Message) error {
func executeHandler(h reflect.Value, m *Message) error { func executeHandler(h reflect.Value, m *Message) error {
var args [2]reflect.Value var args [2]reflect.Value
args[0] = reflect.ValueOf(m.Body) args[0] = reflect.ValueOf(m.Body)
args[1]= reflect.ValueOf(m) args[1] = reflect.ValueOf(m)
rs := h.Call(args[:]) rs := h.Call(args[:])
if len(rs) != 1 { if len(rs) != 1 {
@ -82,7 +83,7 @@ func (handlers handlerMap) addHandler(h interface{}) error {
if err != nil { if err != nil {
return err return err
} }
if _,ok := handlers[msgType]; ok{ if _, ok := handlers[msgType]; ok {
return fmt.Errorf("duplicate handler registered for message type '%s'", msgType) return fmt.Errorf("duplicate handler registered for message type '%s'", msgType)
} }
handlers[msgType] = reflect.ValueOf(h) handlers[msgType] = reflect.ValueOf(h)
@ -125,5 +126,3 @@ func typeCheckHandler(h interface{}) (string, error) {
} }
return string(in0.Field(0).Tag), nil return string(in0.Field(0).Tag), nil
} }

37
ipc/handlers_test.go
Unescape View File

@ -1,27 +1,28 @@
package ipc package ipc
import ( import (
"testing"
"reflect"
"errors" "errors"
"reflect"
"testing"
) )
func TestTypeCheckHandler(t *testing.T) { func TestTypeCheckHandler(t *testing.T) {
type testStruct struct {} type testStruct struct{}
cases := []interface{} { cases := []interface{}{
"foo", "foo",
func(){}, func() {},
func(a,b int){}, func(a, b int) {},
func(a *testStruct, b *Message) {}, func(a *testStruct, b *Message) {},
func(a,b *int) error{return nil}, func(a, b *int) error { return nil },
func(a *testStruct, 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) error { return nil },
func(a *testStruct, b *Message) int{return 0}, func(a *testStruct, b *Message) int { return 0 },
func(a *testStruct, b *Message, c int) error {return nil}, func(a *testStruct, b *Message, c int) error { return nil },
} }
for i,h := range cases { for i, h := range cases {
if _,err := typeCheckHandler(h); err == nil { if _, err := typeCheckHandler(h); err == nil {
t.Errorf("typeCheckHandler should return an error for case %d", i) 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) { func TestAddHandler(t *testing.T) {
hmap := handlerMap(make(map[string]reflect.Value)) hmap := handlerMap(make(map[string]reflect.Value))
type testStruct struct{ type testStruct struct {
t int "tst" t int "tst"
} }
legit := func(ts *testStruct, m *Message) error { return nil } legit := func(ts *testStruct, m *Message) error { return nil }
@ -48,8 +49,12 @@ func TestAddHandler(t *testing.T) {
} }
func TestDispatch(t *testing.T) { func TestDispatch(t *testing.T) {
type testStruct struct{ t int "tester"} type testStruct struct {
type testStruct2 struct{ t int "tester2"} t int "tester"
}
type testStruct2 struct {
t int "tester2"
}
count := 0 count := 0
h1 := func(ts *testStruct, m *Message) error { h1 := func(ts *testStruct, m *Message) error {
count += 1 count += 1

79
ipc/ipc.go
Unescape View File

@ -6,42 +6,42 @@ import (
"net" "net"
"syscall" "syscall"
"github.com/op/go-logging"
"reflect"
"fmt" "fmt"
"github.com/op/go-logging"
"io" "io"
"reflect"
) )
const maxFdCount = 3 const maxFdCount = 3
type MsgConn struct { type MsgConn struct {
log *logging.Logger log *logging.Logger
conn *net.UnixConn conn *net.UnixConn
buf [1024]byte buf [1024]byte
oob []byte oob []byte
disp *msgDispatcher disp *msgDispatcher
factory MsgFactory factory MsgFactory
isClosed bool isClosed bool
idGen <-chan int idGen <-chan int
respMan *responseManager respMan *responseManager
onClose func() onClose func()
} }
type MsgServer struct { type MsgServer struct {
disp *msgDispatcher disp *msgDispatcher
factory MsgFactory factory MsgFactory
listener *net.UnixListener listener *net.UnixListener
done chan bool done chan bool
idGen <- chan int idGen <-chan int
} }
func NewServer(address string, factory MsgFactory, log *logging.Logger, handlers ...interface{}) (*MsgServer, error) { 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 { if err != nil {
return nil, err return nil, err
} }
listener,err := net.ListenUnix("unix", &net.UnixAddr{address, "unix"}) listener, err := net.ListenUnix("unix", &net.UnixAddr{address, "unix"})
if err != nil { if err != nil {
md.close() md.close()
return nil, err return nil, err
@ -49,31 +49,31 @@ func NewServer(address string, factory MsgFactory, log *logging.Logger, handlers
done := make(chan bool) done := make(chan bool)
idGen := newIdGen(done) idGen := newIdGen(done)
return &MsgServer{ return &MsgServer{
disp: md, disp: md,
factory: factory, factory: factory,
listener: listener, listener: listener,
done: done, done: done,
idGen: idGen, idGen: idGen,
}, nil }, nil
} }
func (s *MsgServer) Run() error { func (s *MsgServer) Run() error {
for { for {
conn,err := s.listener.AcceptUnix() conn, err := s.listener.AcceptUnix()
if err != nil { if err != nil {
s.disp.close() s.disp.close()
s.listener.Close() s.listener.Close()
return err return err
} }
if err := setPassCred(conn); err != nil { 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{ mc := &MsgConn{
conn: conn, conn: conn,
disp: s.disp, disp: s.disp,
oob: createOobBuffer(), oob: createOobBuffer(),
factory: s.factory, factory: s.factory,
idGen: s.idGen, idGen: s.idGen,
respMan: newResponseManager(), respMan: newResponseManager(),
} }
go mc.readLoop() 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) { 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 { if err != nil {
return nil, err 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 { if err != nil {
return nil, err return nil, err
} }
done := make(chan bool) done := make(chan bool)
idGen := newIdGen(done) idGen := newIdGen(done)
mc := &MsgConn{ mc := &MsgConn{
conn: conn, conn: conn,
disp: md, disp: md,
oob: createOobBuffer(), oob: createOobBuffer(),
factory: factory, factory: factory,
idGen: idGen, idGen: idGen,
respMan: newResponseManager(), respMan: newResponseManager(),
onClose: func() { onClose: func() {
md.close() md.close()
@ -114,7 +114,7 @@ func newIdGen(done <-chan bool) <-chan int {
return ch return ch
} }
func idGenLoop(done <-chan bool, out chan <- int) { func idGenLoop(done <-chan bool, out chan<- int) {
current := int(1) current := int(1)
for { for {
select { select {
@ -142,7 +142,7 @@ func (mc *MsgConn) logger() *logging.Logger {
} }
func (mc *MsgConn) processOneMessage() bool { func (mc *MsgConn) processOneMessage() bool {
m,err := mc.readMessage() m, err := mc.readMessage()
if err != nil { if err != nil {
if err == io.EOF { if err == io.EOF {
mc.Close() mc.Close()
@ -216,7 +216,6 @@ func (mc *MsgConn) readMessage() (*Message, error) {
// conn.AddHandlers(fooHandler, simpleHandler) // conn.AddHandlers(fooHandler, simpleHandler)
// //
func (mc *MsgConn) AddHandlers(args ...interface{}) error { func (mc *MsgConn) AddHandlers(args ...interface{}) error {
for len(args) > 0 { for len(args) > 0 {
if err := mc.disp.hmap.addHandler(args[0]); err != nil { if err := mc.disp.hmap.addHandler(args[0]); err != nil {
@ -227,11 +226,11 @@ func (mc *MsgConn) AddHandlers(args ...interface{}) error {
return nil 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...) 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 id := <-mc.idGen
rr := mc.respMan.register(id) rr := mc.respMan.register(id)
@ -239,10 +238,10 @@ func (mc *MsgConn) ExchangeMsg(msg interface{}, fds... int) (ResponseReader, err
rr.Done() rr.Done()
return nil, err 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) msgType, err := getMessageType(msg)
if err != nil { if err != nil {
return err return err
@ -272,9 +271,8 @@ func getMessageType(msg interface{}) (string, error) {
return string(t.Field(0).Tag), nil return string(t.Field(0).Tag), nil
} }
func (mc *MsgConn) newBaseMessage(msgType string, msgID int, body interface{}) (*BaseMsg, error) { 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 { if err != nil {
return nil, err return nil, err
} }
@ -289,13 +287,12 @@ func (mc *MsgConn) sendRaw(data []byte, fds ...int) error {
if len(fds) > 0 { if len(fds) > 0 {
return mc.sendWithFds(data, fds) return mc.sendWithFds(data, fds)
} }
_,err := mc.conn.Write(data) _, err := mc.conn.Write(data)
return err return err
} }
func (mc *MsgConn) sendWithFds(data []byte, fds []int) error { func (mc *MsgConn) sendWithFds(data []byte, fds []int) error {
oob := syscall.UnixRights(fds...) oob := syscall.UnixRights(fds...)
_,_,err := mc.conn.WriteMsgUnix(data, oob, nil) _, _, err := mc.conn.WriteMsgUnix(data, oob, nil)
return err return err
} }

17
ipc/ipc_test.go
Unescape View File

@ -1,8 +1,9 @@
package ipc package ipc
import ( import (
"testing"
"sync"
"os" "os"
"sync"
"testing"
) )
type TestMsg struct { type TestMsg struct {
@ -12,15 +13,17 @@ type TestMsg struct {
type testConnection struct { type testConnection struct {
server *MsgConn server *MsgConn
client *MsgConn client *MsgConn
wg sync.WaitGroup wg sync.WaitGroup
called bool called bool
} }
type testServer struct { type testServer struct {
conn *MsgConn conn *MsgConn
wg sync.WaitGroup wg sync.WaitGroup
} }
const testSocket = "@test" const testSocket = "@test"
var testFactory = NewMsgFactory(new(TestMsg)) var testFactory = NewMsgFactory(new(TestMsg))
func testConnect(handler func(*TestMsg, *Message) error) (*testConnection, error) { 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)) { func runTest(t *testing.T, handler func(*TestMsg, *Message) error, tester func(*testConnection)) {
tc,err := testConnect(handler) tc, err := testConnect(handler)
if err != nil { if err != nil {
t.Error("error setting up test connection:", err) t.Error("error setting up test connection:", err)
} }
@ -86,7 +89,7 @@ func TestUcred(t *testing.T) {
} }
func TestPassFDs(t *testing.T) { func TestPassFDs(t *testing.T) {
fds := []int{1,2} fds := []int{1, 2}
handler := func(tm *TestMsg, msg *Message) error { handler := func(tm *TestMsg, msg *Message) error {
if len(msg.Fds) != len(fds) { if len(msg.Fds) != len(fds) {
t.Errorf("Expecting %d descriptors, got %d", len(fds), len(msg.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...) tc.client.SendMsg(&TestMsg{}, fds...)
}) })
} }

26
ipc/message.go
Unescape View File

@ -2,14 +2,12 @@ package ipc
import ( import (
"encoding/json" "encoding/json"
"syscall" "errors"
"fmt" "fmt"
"reflect" "reflect"
"errors" "syscall"
) )
func NewMsgFactory(msgTypes ...interface{}) MsgFactory { func NewMsgFactory(msgTypes ...interface{}) MsgFactory {
mf := (MsgFactory)(make(map[string]func() interface{})) mf := (MsgFactory)(make(map[string]func() interface{}))
for _, mt := range msgTypes { for _, mt := range msgTypes {
@ -24,7 +22,7 @@ func NewMsgFactory(msgTypes ...interface{}) MsgFactory {
type MsgFactory map[string](func() interface{}) type MsgFactory map[string](func() interface{})
func (mf MsgFactory) create(msgType string) (interface{}, error) { func (mf MsgFactory) create(msgType string) (interface{}, error) {
f,ok := mf[msgType] f, ok := mf[msgType]
if !ok { if !ok {
return nil, fmt.Errorf("cannot create msg type: %s", msgType) 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 Message struct {
Type string Type string
MsgID int MsgID int
Body interface{} Body interface{}
Ucred *syscall.Ucred Ucred *syscall.Ucred
Fds []int Fds []int
mconn *MsgConn mconn *MsgConn
} }
type BaseMsg struct { type BaseMsg struct {
Type string Type string
MsgID int MsgID int
IsResponse bool IsResponse bool
Body json.RawMessage Body json.RawMessage
} }
func (mc *MsgConn) parseMessage(data []byte) (*Message, error) { 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 { if err := json.Unmarshal(data, &base); err != nil {
return nil, err return nil, err
} }
body,err := mc.factory.create(base.Type) body, err := mc.factory.create(base.Type)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -83,11 +81,11 @@ func (mc *MsgConn) parseMessage(data []byte) (*Message, error) {
m.Type = base.Type m.Type = base.Type
m.MsgID = base.MsgID m.MsgID = base.MsgID
m.Body = body m.Body = body
return m,nil return m, nil
} }
func (m *Message) Free() { func (m *Message) Free() {
for _,fd := range m.Fds { for _, fd := range m.Fds {
syscall.Close(fd) syscall.Close(fd)
} }
m.Fds = nil m.Fds = nil
@ -117,6 +115,6 @@ func (m *Message) parseControlData(data []byte) error {
return nil 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...) return m.mconn.sendMessage(msg, m.MsgID, fds...)
} }

14
ipc/response.go
Unescape View File

@ -1,7 +1,8 @@
package ipc package ipc
import ( import (
"time"
"sync" "sync"
"time"
) )
type ResponseReader interface { type ResponseReader interface {
@ -10,10 +11,10 @@ type ResponseReader interface {
} }
type responseWaiter struct { type responseWaiter struct {
rm *responseManager rm *responseManager
id int id int
timeout time.Time timeout time.Time
ch chan *Message ch chan *Message
} }
func (rw *responseWaiter) Chan() <-chan *Message { func (rw *responseWaiter) Chan() <-chan *Message {
@ -28,7 +29,7 @@ func (rw *responseWaiter) Done() {
} }
type responseManager struct { type responseManager struct {
lock sync.Locker lock sync.Locker
responseMap map[int]*responseWaiter responseMap map[int]*responseWaiter
} }
@ -64,7 +65,7 @@ func (rm *responseManager) handle(m *Message) bool {
return true return true
} }
func (rm *responseManager) removeById(id int, klose bool) *responseWaiter{ func (rm *responseManager) removeById(id int, klose bool) *responseWaiter {
rw := rm.responseMap[id] rw := rm.responseMap[id]
if rw == nil { if rw == nil {
return nil return nil
@ -75,4 +76,3 @@ func (rm *responseManager) removeById(id int, klose bool) *responseWaiter{
} }
return rw return rw
} }

1
ipc/response_test.go
Unescape View File

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

37
oz-daemon/client.go
Unescape View File

@ -1,9 +1,10 @@
package daemon package daemon
import ( import (
"github.com/subgraph/oz/ipc"
"errors" "errors"
"strconv"
"fmt" "fmt"
"github.com/subgraph/oz/ipc"
"strconv"
) )
func clientConnect() (*ipc.MsgConn, error) { func clientConnect() (*ipc.MsgConn, error) {
@ -11,7 +12,7 @@ func clientConnect() (*ipc.MsgConn, error) {
} }
func clientSend(msg interface{}) (*ipc.Message, error) { func clientSend(msg interface{}) (*ipc.Message, error) {
c,err := clientConnect() c, err := clientConnect()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -21,17 +22,17 @@ func clientSend(msg interface{}) (*ipc.Message, error) {
return nil, err return nil, err
} }
resp := <- rr.Chan() resp := <-rr.Chan()
rr.Done() rr.Done()
return resp,nil return resp, nil
} }
func ListProfiles() ([]Profile, error) { func ListProfiles() ([]Profile, error) {
resp,err := clientSend(new(ListProfilesMsg)) resp, err := clientSend(new(ListProfilesMsg))
if err != nil { if err != nil {
return nil, err return nil, err
} }
body,ok := resp.Body.(*ListProfilesResp) body, ok := resp.Body.(*ListProfilesResp)
if !ok { if !ok {
return nil, errors.New("ListProfiles response was not expected type") return nil, errors.New("ListProfiles response was not expected type")
} }
@ -39,11 +40,11 @@ func ListProfiles() ([]Profile, error) {
} }
func ListSandboxes() ([]SandboxInfo, error) { func ListSandboxes() ([]SandboxInfo, error) {
resp,err := clientSend(&ListSandboxesMsg{}) resp, err := clientSend(&ListSandboxesMsg{})
if err != nil { if err != nil {
return nil, err return nil, err
} }
body,ok := resp.Body.(*ListSandboxesResp) body, ok := resp.Body.(*ListSandboxesResp)
if !ok { if !ok {
return nil, errors.New("ListSandboxes response was not expected type") return nil, errors.New("ListSandboxes response was not expected type")
} }
@ -51,13 +52,13 @@ func ListSandboxes() ([]SandboxInfo, error) {
} }
func Launch(arg string) error { func Launch(arg string) error {
idx,name,err := parseProfileArg(arg) idx, name, err := parseProfileArg(arg)
if err != nil { if err != nil {
return err return err
} }
resp,err := clientSend(&LaunchMsg{ resp, err := clientSend(&LaunchMsg{
Index: idx, Index: idx,
Name: name, Name: name,
}) })
if err != nil { if err != nil {
return err return err
@ -74,13 +75,13 @@ func Launch(arg string) error {
} }
func Clean(arg string) error { func Clean(arg string) error {
idx,name,err := parseProfileArg(arg) idx, name, err := parseProfileArg(arg)
if err != nil { if err != nil {
return err return err
} }
resp,err := clientSend(&CleanMsg{ resp, err := clientSend(&CleanMsg{
Index: idx, Index: idx,
Name: name, Name: name,
}) })
if err != nil { if err != nil {
return err return err
@ -100,18 +101,18 @@ func parseProfileArg(arg string) (int, string, error) {
if len(arg) == 0 { if len(arg) == 0 {
return 0, "", errors.New("profile argument needed") 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 n, "", nil
} }
return 0, arg, nil return 0, arg, nil
} }
func Logs(count int, follow bool) (chan string, error) { func Logs(count int, follow bool) (chan string, error) {
c,err := clientConnect() c, err := clientConnect()
if err != nil { if err != nil {
return nil, err return nil, err
} }
rr,err := c.ExchangeMsg(&LogsMsg{Count: count, Follow: follow}) rr, err := c.ExchangeMsg(&LogsMsg{Count: count, Follow: follow})
if err != nil { if err != nil {
return nil, err return nil, err
} }

3
oz-daemon/config.go
Unescape View File

@ -1,6 +1,5 @@
package daemon package daemon
type Config struct { type Config struct {
profileDir string `json:"profile_dir"` 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/op/go-logging"
"github.com/subgraph/oz" "github.com/subgraph/oz"
"github.com/subgraph/oz/ipc"
"syscall"
"github.com/subgraph/oz/fs" "github.com/subgraph/oz/fs"
"github.com/subgraph/oz/ipc"
"os/user" "os/user"
"syscall"
) )
type daemonState struct { type daemonState struct {
log *logging.Logger log *logging.Logger
profiles oz.Profiles profiles oz.Profiles
sandboxes []*Sandbox sandboxes []*Sandbox
nextSboxId int nextSboxId int
nextDisplay int nextDisplay int
memBackend *logging.ChannelMemoryBackend memBackend *logging.ChannelMemoryBackend
backends []logging.Backend backends []logging.Backend
} }
func Main() { func Main() {
@ -41,7 +41,7 @@ func Main() {
func initialize() *daemonState { func initialize() *daemonState {
d := &daemonState{} d := &daemonState{}
d.initializeLogging() d.initializeLogging()
ps,err := oz.LoadProfiles("/var/lib/oz/cells.d") ps, err := oz.LoadProfiles("/var/lib/oz/cells.d")
if err != nil { if err != nil {
d.log.Fatalf("Failed to load profiles: %v", err) d.log.Fatalf("Failed to load profiles: %v", err)
} }
@ -53,11 +53,10 @@ func initialize() *daemonState {
return d return d
} }
func (d *daemonState) handleChildExit(pid int, wstatus syscall.WaitStatus) { func (d *daemonState) handleChildExit(pid int, wstatus syscall.WaitStatus) {
d.Debug("Child process pid=%d exited with status %d", pid, wstatus.ExitStatus()) 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 { if sbox.init.Process.Pid == pid {
sbox.remove() sbox.remove()
return return
@ -67,22 +66,22 @@ func (d *daemonState) handleChildExit(pid int, wstatus syscall.WaitStatus) {
} }
func runServer(log *logging.Logger, args ...interface{}) error { 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 { if err != nil {
return err return err
} }
return s.Run() 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) d.Debug("received ping with data [%s]", msg.Data)
return m.Respond(&PingMsg{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) r := new(ListProfilesResp)
index := 1 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}) r.Profiles = append(r.Profiles, Profile{Index: index, Name: p.Name, Path: p.Path})
index += 1 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 { func (d *daemonState) handleLaunch(msg *LaunchMsg, m *ipc.Message) error {
d.Debug("Launch message received: %+v", msg) 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 { if err != nil {
return m.Respond(&ErrorMsg{err.Error()}) return m.Respond(&ErrorMsg{err.Error()})
} }
d.Debug("Would launch %s", p.Name) 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 { if err != nil {
d.Warning("launch of %s failed: %v", p.Name, err) d.Warning("launch of %s failed: %v", p.Name, err)
return m.Respond(&ErrorMsg{err.Error()}) 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 return d.profiles[index-1], nil
} }
for _,p := range d.profiles { for _, p := range d.profiles {
if p.Name == name { if p.Name == name {
return p,nil return p, nil
} }
} }
return nil, fmt.Errorf("could not find profile name '%s'", name) 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 { 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 { if err != nil {
return msg.Respond(&ErrorMsg{err.Error()}) return msg.Respond(&ErrorMsg{err.Error()})
} }
@ -140,7 +139,7 @@ func (d *daemonState) handleClean(clean *CleanMsg, msg *ipc.Message) error {
} }
} }
// XXX // XXX
u,_ := user.Current() u, _ := user.Current()
fs := fs.NewFromProfile(p, u, d.log) fs := fs.NewFromProfile(p, u, d.log)
if err := fs.Cleanup(); err != nil { if err := fs.Cleanup(); err != nil {
return msg.Respond(&ErrorMsg{err.Error()}) return msg.Respond(&ErrorMsg{err.Error()})
@ -160,4 +159,3 @@ func (d *daemonState) handleLogs(logs *LogsMsg, msg *ipc.Message) error {
msg.Respond(&OkMsg{}) msg.Respond(&OkMsg{})
return nil return nil
} }

60
oz-daemon/launch.go
Unescape View File

@ -1,32 +1,32 @@
package daemon package daemon
import ( import (
"bufio"
"fmt"
"github.com/subgraph/oz" "github.com/subgraph/oz"
"github.com/subgraph/oz/fs" "github.com/subgraph/oz/fs"
"os/exec"
"syscall"
"fmt"
"io"
"bufio"
"os/user"
"github.com/subgraph/oz/xpra" "github.com/subgraph/oz/xpra"
"io"
"os" "os"
"os/exec"
"os/user"
"path" "path"
"syscall"
) )
const initPath = "/usr/local/bin/oz-init" const initPath = "/usr/local/bin/oz-init"
type Sandbox struct { type Sandbox struct {
daemon *daemonState daemon *daemonState
id int id int
display int display int
profile *oz.Profile profile *oz.Profile
init *exec.Cmd init *exec.Cmd
cred *syscall.Credential cred *syscall.Credential
fs *fs.Filesystem fs *fs.Filesystem
stderr io.ReadCloser stderr io.ReadCloser
addr string addr string
xpra *xpra.Xpra xpra *xpra.Xpra
} }
/* /*
@ -45,11 +45,11 @@ func createInitCommand(name, chroot string, uid uint32, display int) *exec.Cmd {
cmd := exec.Command(initPath) cmd := exec.Command(initPath)
cmd.Dir = "/" cmd.Dir = "/"
cmd.SysProcAttr = &syscall.SysProcAttr{ cmd.SysProcAttr = &syscall.SysProcAttr{
Chroot: chroot, Chroot: chroot,
Cloneflags: initCloneFlags, Cloneflags: initCloneFlags,
} }
cmd.Env = []string{ cmd.Env = []string{
"INIT_PROFILE="+name, "INIT_PROFILE=" + name,
fmt.Sprintf("INIT_UID=%d", uid), fmt.Sprintf("INIT_UID=%d", uid),
} }
if display > 0 { if display > 0 {
@ -58,8 +58,8 @@ func createInitCommand(name, chroot string, uid uint32, display int) *exec.Cmd {
return cmd return cmd
} }
func (d *daemonState) launch(p *oz.Profile, uid,gid uint32) (*Sandbox, error) { func (d *daemonState) launch(p *oz.Profile, uid, gid uint32) (*Sandbox, error) {
u,err := user.LookupId(fmt.Sprintf("%d", uid)) u, err := user.LookupId(fmt.Sprintf("%d", uid))
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to lookup user for uid=%d: %v", uid, err) 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) cmd := createInitCommand(p.Name, fs.Root(), uid, display)
pp,err := cmd.StderrPipe() pp, err := cmd.StderrPipe()
if err != nil { if err != nil {
fs.Cleanup() fs.Cleanup()
return nil, fmt.Errorf("error creating stderr pipe for init process: %v", err) 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 return nil, err
} }
sbox := &Sandbox{ sbox := &Sandbox{
daemon: d, daemon: d,
id: d.nextSboxId, id: d.nextSboxId,
display: display, display: display,
profile: p, profile: p,
init: cmd, init: cmd,
cred: &syscall.Credential{Uid: uid, Gid: gid}, cred: &syscall.Credential{Uid: uid, Gid: gid},
fs: fs, fs: fs,
addr: path.Join(fs.Root(), "tmp", "oz-init-control"), addr: path.Join(fs.Root(), "tmp", "oz-init-control"),
stderr: pp, stderr: pp,
} }
go sbox.logMessages() go sbox.logMessages()
d.nextSboxId += 1 d.nextSboxId += 1
d.sandboxes = append(d.sandboxes, sbox) d.sandboxes = append(d.sandboxes, sbox)
return sbox,nil return sbox, nil
} }
func (sbox *Sandbox) remove() { func (sbox *Sandbox) remove() {
sboxes := []*Sandbox{} sboxes := []*Sandbox{}
for _,sb := range sbox.daemon.sandboxes { for _, sb := range sbox.daemon.sandboxes {
if sb == sbox { if sb == sbox {
sb.fs.Cleanup() sb.fs.Cleanup()
} else { } else {
@ -142,7 +142,7 @@ func (sbox *Sandbox) logLine(line string) {
func (sbox *Sandbox) getLogFunc(c byte) func(string, ...interface{}) { func (sbox *Sandbox) getLogFunc(c byte) func(string, ...interface{}) {
log := sbox.daemon.log log := sbox.daemon.log
switch(c) { switch c {
case 'D': case 'D':
return log.Debug return log.Debug
case 'I': case 'I':

14
oz-daemon/logging.go
Unescape View File

@ -1,12 +1,12 @@
package daemon package daemon
import ( import (
"github.com/op/go-logging" "github.com/op/go-logging"
"github.com/subgraph/oz/ipc"
"log" "log"
"os" "os"
"github.com/subgraph/oz/ipc"
) )
func (d *daemonState) Debug(format string, args ...interface{}) { func (d *daemonState) Debug(format string, args ...interface{}) {
d.log.Debug(format, args...) d.log.Debug(format, args...)
} }
@ -38,9 +38,11 @@ func (d *daemonState) initializeLogging() {
} }
d.installBackends() d.installBackends()
} }
var format = logging.MustStringFormatter( var format = logging.MustStringFormatter(
"%{color}%{time:15:04:05} â–¶ %{level:.4s} %{id:03x}%{color:reset} %{message}", "%{color}%{time:15:04:05} â–¶ %{level:.4s} %{id:03x}%{color:reset} %{message}",
) )
func (d *daemonState) addBackend(be logging.Backend) { func (d *daemonState) addBackend(be logging.Backend) {
d.backends = append(d.backends, be) d.backends = append(d.backends, be)
d.installBackends() d.installBackends()
@ -48,7 +50,7 @@ func (d *daemonState) addBackend(be logging.Backend) {
func (d *daemonState) removeBackend(be logging.Backend) { func (d *daemonState) removeBackend(be logging.Backend) {
newBackends := []logging.Backend{} newBackends := []logging.Backend{}
for _,b := range d.backends { for _, b := range d.backends {
if b != be { if b != be {
newBackends = append(newBackends, b) newBackends = append(newBackends, b)
} }
@ -66,9 +68,9 @@ func (d *daemonState) installBackends() {
} }
type logFollower struct { type logFollower struct {
daemon *daemonState daemon *daemonState
wrapper logging.Backend wrapper logging.Backend
m *ipc.Message m *ipc.Message
} }
func (lf *logFollower) Log(level logging.Level, calldepth int, rec *logging.Record) error { 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) { 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) be.wrapper = logging.NewBackendFormatter(be, format)
d.addBackend(be.wrapper) d.addBackend(be.wrapper)
} }

36
oz-daemon/protocol.go
Unescape View File

@ -1,4 +1,5 @@
package daemon package daemon
import "github.com/subgraph/oz/ipc" import "github.com/subgraph/oz/ipc"
const SocketName = "@oz-control" const SocketName = "@oz-control"
@ -21,8 +22,8 @@ type ListProfilesMsg struct {
type Profile struct { type Profile struct {
Index int Index int
Name string Name string
Path string Path string
} }
type ListProfilesResp struct { type ListProfilesResp struct {
@ -31,7 +32,7 @@ type ListProfilesResp struct {
type LaunchMsg struct { type LaunchMsg struct {
Index int "Launch" Index int "Launch"
Name string Name string
} }
type ListSandboxesMsg struct { type ListSandboxesMsg struct {
@ -39,7 +40,7 @@ type ListSandboxesMsg struct {
} }
type SandboxInfo struct { type SandboxInfo struct {
Id int Id int
Address string Address string
Profile string Profile string
} }
@ -50,11 +51,11 @@ type ListSandboxesResp struct {
type CleanMsg struct { type CleanMsg struct {
Index int "Clean" Index int "Clean"
Name string Name string
} }
type LogsMsg struct { type LogsMsg struct {
Count int "Logs" Count int "Logs"
Follow bool Follow bool
} }
@ -63,16 +64,15 @@ type LogData struct {
} }
var messageFactory = ipc.NewMsgFactory( var messageFactory = ipc.NewMsgFactory(
new(PingMsg), new(PingMsg),
new(OkMsg), new(OkMsg),
new(ErrorMsg), new(ErrorMsg),
new(ListProfilesMsg), new(ListProfilesMsg),
new(ListProfilesResp), new(ListProfilesResp),
new(LaunchMsg), new(LaunchMsg),
new(ListSandboxesMsg), new(ListSandboxesMsg),
new(ListSandboxesResp), new(ListSandboxesResp),
new(CleanMsg), new(CleanMsg),
new(LogsMsg), new(LogsMsg),
new(LogData), new(LogData),
) )

19
oz-init/client.go
Unescape View File

@ -1,8 +1,9 @@
package ozinit package ozinit
import ( import (
"github.com/subgraph/oz/ipc"
"errors" "errors"
"fmt" "fmt"
"github.com/subgraph/oz/ipc"
) )
func clientConnect(addr string) (*ipc.MsgConn, error) { 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) { func clientSend(addr string, msg interface{}) (*ipc.Message, error) {
c,err := clientConnect(addr) c, err := clientConnect(addr)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -20,13 +21,13 @@ func clientSend(addr string, msg interface{}) (*ipc.Message, error) {
return nil, err return nil, err
} }
resp := <- rr.Chan() resp := <-rr.Chan()
rr.Done() rr.Done()
return resp, nil return resp, nil
} }
func Ping(addr string) error { func Ping(addr string) error {
resp,err := clientSend(addr, new(PingMsg)) resp, err := clientSend(addr, new(PingMsg))
if err != nil { if err != nil {
return err return err
} }
@ -41,12 +42,12 @@ func Ping(addr string) error {
} }
func RunShell(addr, term string) (int, error) { func RunShell(addr, term string) (int, error) {
c,err := clientConnect(addr) c, err := clientConnect(addr)
if err != nil { if err != nil {
return 0, err return 0, err
} }
rr,err := c.ExchangeMsg(&RunShellMsg{Term: term}) rr, err := c.ExchangeMsg(&RunShellMsg{Term: term})
resp := <- rr.Chan() resp := <-rr.Chan()
rr.Done() rr.Done()
c.Close() c.Close()
if err != nil { if err != nil {
@ -54,7 +55,7 @@ func RunShell(addr, term string) (int, error) {
} }
switch body := resp.Body.(type) { switch body := resp.Body.(type) {
case *ErrorMsg: case *ErrorMsg:
return 0,errors.New(body.Msg) return 0, errors.New(body.Msg)
case *OkMsg: case *OkMsg:
if len(resp.Fds) == 0 { if len(resp.Fds) == 0 {
return 0, errors.New("RunShell message returned Ok, but no file descriptor received") 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) return 0, fmt.Errorf("Unexpected message type received: %+v", body)
} }
} }

63
oz-init/init.go
Unescape View File

@ -1,34 +1,34 @@
package ozinit package ozinit
import ( import (
"os" "bufio"
"fmt"
"github.com/kr/pty"
"github.com/op/go-logging"
"github.com/subgraph/oz" "github.com/subgraph/oz"
"github.com/subgraph/oz/fs" "github.com/subgraph/oz/fs"
"github.com/subgraph/oz/ipc" "github.com/subgraph/oz/ipc"
"os/exec"
"syscall"
"github.com/op/go-logging"
"github.com/kr/pty"
"fmt"
"github.com/subgraph/oz/xpra" "github.com/subgraph/oz/xpra"
"io"
"os"
"os/exec"
"os/user" "os/user"
"strconv" "strconv"
"io"
"bufio"
"strings" "strings"
"syscall"
) )
const profileDirectory = "/var/lib/oz/cells.d" const profileDirectory = "/var/lib/oz/cells.d"
const socketAddress = "/tmp/oz-init-control" const socketAddress = "/tmp/oz-init-control"
type initState struct { type initState struct {
log *logging.Logger log *logging.Logger
profile *oz.Profile profile *oz.Profile
uid int uid int
gid int gid int
user *user.User user *user.User
display int display int
fs *fs.Filesystem fs *fs.Filesystem
} }
// By convention oz-init writes log messages to stderr with a single character // 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") l := logging.MustGetLogger("oz-init")
be := logging.NewLogBackend(os.Stderr, "", 0) be := logging.NewLogBackend(os.Stderr, "", 0)
f := logging.MustStringFormatter("%{level:.1s} %{message}") f := logging.MustStringFormatter("%{level:.1s} %{message}")
fbe := logging.NewBackendFormatter(be,f) fbe := logging.NewBackendFormatter(be, f)
logging.SetBackend(fbe) logging.SetBackend(fbe)
return l return l
} }
@ -65,29 +65,29 @@ func parseArgs() *initState {
uidval := getvar("INIT_UID") uidval := getvar("INIT_UID")
dispval := os.Getenv("INIT_DISPLAY") dispval := os.Getenv("INIT_DISPLAY")
p,err := loadProfile(pname) p, err := loadProfile(pname)
if err != nil { if err != nil {
log.Error("Could not load profile %s: %v", pname, err) log.Error("Could not load profile %s: %v", pname, err)
os.Exit(1) os.Exit(1)
} }
uid,err := strconv.Atoi(uidval) uid, err := strconv.Atoi(uidval)
if err != nil { if err != nil {
log.Error("Could not parse INIT_UID argument (%s) into an integer: %v", uidval, err) log.Error("Could not parse INIT_UID argument (%s) into an integer: %v", uidval, err)
os.Exit(1) os.Exit(1)
} }
u,err := user.LookupId(uidval) u, err := user.LookupId(uidval)
if err != nil { if err != nil {
log.Error("Failed to look up user with uid=%s: %v", uidval, err) log.Error("Failed to look up user with uid=%s: %v", uidval, err)
os.Exit(1) os.Exit(1)
} }
gid,err := strconv.Atoi(u.Gid) gid, err := strconv.Atoi(u.Gid)
if err != nil { if err != nil {
log.Error("Failed to parse gid value (%s) from user struct: %v", u.Gid, err) log.Error("Failed to parse gid value (%s) from user struct: %v", u.Gid, err)
os.Exit(1) os.Exit(1)
} }
display := 0 display := 0
if dispval != "" { if dispval != "" {
d,err := strconv.Atoi(dispval) d, err := strconv.Atoi(dispval)
if err != nil { if err != nil {
log.Error("Unable to parse display (%s) into an integer: %v", dispval, err) log.Error("Unable to parse display (%s) into an integer: %v", dispval, err)
os.Exit(1) os.Exit(1)
@ -96,13 +96,13 @@ func parseArgs() *initState {
} }
return &initState{ return &initState{
log: log, log: log,
profile: p, profile: p,
uid: uid, uid: uid,
gid: gid, gid: gid,
user: u, user: u,
display: display, 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) oz.ReapChildProcs(st.log, st.handleChildExit)
s,err := ipc.NewServer(socketAddress, messageFactory, st.log, s, err := ipc.NewServer(socketAddress, messageFactory, st.log,
handlePing, handlePing,
st.handleRunShell, st.handleRunShell,
) )
@ -152,14 +152,14 @@ func (st *initState) startXpraServer() {
return return
} }
xpra := xpra.NewServer(&st.profile.XServer, uint64(st.display), workdir) xpra := xpra.NewServer(&st.profile.XServer, uint64(st.display), workdir)
p,err := xpra.Process.StderrPipe() p, err := xpra.Process.StderrPipe()
if err != nil { if err != nil {
st.log.Warning("Error creating stderr pipe for xpra output: %v", err) st.log.Warning("Error creating stderr pipe for xpra output: %v", err)
os.Exit(1) os.Exit(1)
} }
go st.readXpraOutput(p) go st.readXpraOutput(p)
xpra.Process.Env = []string{ xpra.Process.Env = []string{
"HOME="+ st.user.HomeDir, "HOME=" + st.user.HomeDir,
} }
xpra.Process.SysProcAttr = &syscall.SysProcAttr{} xpra.Process.SysProcAttr = &syscall.SysProcAttr{}
xpra.Process.SysProcAttr.Credential = &syscall.Credential{ xpra.Process.SysProcAttr.Credential = &syscall.Credential{
@ -192,11 +192,11 @@ func (st *initState) readXpraOutput(r io.ReadCloser) {
} }
func loadProfile(name string) (*oz.Profile, error) { func loadProfile(name string) (*oz.Profile, error) {
ps,err := oz.LoadProfiles(profileDirectory) ps, err := oz.LoadProfiles(profileDirectory)
if err != nil { if err != nil {
return nil, err return nil, err
} }
for _,p := range ps { for _, p := range ps {
if name == p.Name { if name == p.Name {
return p, nil 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, "PATH=/usr/bin:/bin")
cmd.Env = append(cmd.Env, fmt.Sprintf("PS1=[%s] $ ", st.profile.Name)) cmd.Env = append(cmd.Env, fmt.Sprintf("PS1=[%s] $ ", st.profile.Name))
st.log.Info("Executing shell...") st.log.Info("Executing shell...")
f,err := ptyStart(cmd) f, err := ptyStart(cmd)
defer f.Close() defer f.Close()
if err != nil { if err != nil {
return msg.Respond(&ErrorMsg{err.Error()}) 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) { func ptyStart(c *exec.Cmd) (ptty *os.File, err error) {
ptty,tty, err := pty.Open() ptty, tty, err := pty.Open()
if err != nil { if err != nil {
return nil, err 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) { func (is *initState) handleChildExit(pid int, wstatus syscall.WaitStatus) {
is.log.Debug("Child process pid=%d exited with status %d", pid, wstatus.ExitStatus()) 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 package ozinit
import "github.com/subgraph/oz/ipc" import "github.com/subgraph/oz/ipc"
type OkMsg struct { type OkMsg struct {
@ -23,4 +24,3 @@ var messageFactory = ipc.NewMsgFactory(
new(PingMsg), new(PingMsg),
new(RunShellMsg), new(RunShellMsg),
) )

53
oz/main.go
Unescape View File

@ -3,11 +3,11 @@ package main
import ( import (
"fmt" "fmt"
"github.com/codegangsta/cli" "github.com/codegangsta/cli"
"os"
"github.com/subgraph/oz/oz-daemon" "github.com/subgraph/oz/oz-daemon"
"strconv"
"io"
"github.com/subgraph/oz/oz-init" "github.com/subgraph/oz/oz-init"
"io"
"os"
"strconv"
) )
func main() { func main() {
@ -17,40 +17,38 @@ func main() {
app.Usage = "command line interface to Oz sandboxes" app.Usage = "command line interface to Oz sandboxes"
app.Author = "Subgraph" app.Author = "Subgraph"
app.Email = "info@subgraph.com" app.Email = "info@subgraph.com"
app.Commands = []cli.Command { app.Commands = []cli.Command{
{ {
Name: "profiles", Name: "profiles",
Usage: "list available application profiles", Usage: "list available application profiles",
Action: handleProfiles, Action: handleProfiles,
}, },
{ {
Name: "launch", Name: "launch",
Usage: "launch an application profile", Usage: "launch an application profile",
Action: handleLaunch, Action: handleLaunch,
}, },
{ {
Name: "list", Name: "list",
Usage: "list running sandboxes", Usage: "list running sandboxes",
Action: handleList, Action: handleList,
}, },
{ {
Name: "shell", Name: "shell",
Usage: "start a shell in a running container", Usage: "start a shell in a running container",
Action: handleShell, Action: handleShell,
}, },
{ {
Name: "clean", Name: "clean",
Action: handleClean, Action: handleClean,
}, },
{ {
Name: "logs", Name: "logs",
Action: handleLogs, Action: handleLogs,
Flags: []cli.Flag { Flags: []cli.Flag{
cli.BoolFlag{ cli.BoolFlag{
Name: "f", Name: "f",
}, },
}, },
}, },
} }
@ -58,12 +56,12 @@ func main() {
} }
func handleProfiles(c *cli.Context) { func handleProfiles(c *cli.Context) {
ps,err := daemon.ListProfiles() ps, err := daemon.ListProfiles()
if err != nil { if err != nil {
fmt.Printf("Error listing profiles: %v\n", err) fmt.Printf("Error listing profiles: %v\n", err)
os.Exit(1) 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) 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) { func handleList(c *cli.Context) {
sboxes,err := daemon.ListSandboxes() sboxes, err := daemon.ListSandboxes()
if err != nil { if err != nil {
fmt.Printf("Error listing running containers: %v\n", err) fmt.Printf("Error listing running containers: %v\n", err)
os.Exit(1) os.Exit(1)
@ -101,13 +99,13 @@ func handleShell(c *cli.Context) {
fmt.Println("Sandbox id argument needed") fmt.Println("Sandbox id argument needed")
os.Exit(1) os.Exit(1)
} }
id,err := strconv.Atoi(c.Args()[0]) id, err := strconv.Atoi(c.Args()[0])
if err != nil { if err != nil {
fmt.Println("Sandbox id argument must be an integer") fmt.Println("Sandbox id argument must be an integer")
os.Exit(1) os.Exit(1)
} }
sb,err := getSandboxById(id) sb, err := getSandboxById(id)
if err != nil { if err != nil {
fmt.Printf("Error retrieving sandbox list: %v\n", err) 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) fmt.Printf("No sandbox found with id = %d\n", id)
} }
term := os.Getenv("TERM") term := os.Getenv("TERM")
fd,err := ozinit.RunShell(sb.Address, term) fd, err := ozinit.RunShell(sb.Address, term)
if err != nil { if err != nil {
fmt.Printf("start shell command failed: %v\n", err) fmt.Printf("start shell command failed: %v\n", err)
os.Exit(1) os.Exit(1)
} }
fmt.Println("Entering interactive shell?\n") fmt.Println("Entering interactive shell?\n")
st,err := SetRawTerminal(0) st, err := SetRawTerminal(0)
HandleResize(fd) HandleResize(fd)
f := os.NewFile(uintptr(fd), "") f := os.NewFile(uintptr(fd), "")
go io.Copy(f, os.Stdin) go io.Copy(f, os.Stdin)
@ -130,15 +128,14 @@ func handleShell(c *cli.Context) {
fmt.Println("done..") fmt.Println("done..")
} }
func getSandboxById(id int) (*daemon.SandboxInfo, error) { func getSandboxById(id int) (*daemon.SandboxInfo, error) {
sboxes,err := daemon.ListSandboxes() sboxes, err := daemon.ListSandboxes()
if err != nil { if err != nil {
return nil, err return nil, err
} }
for _, sb := range sboxes { for _, sb := range sboxes {
if id == sb.Id { if id == sb.Id {
return &sb,nil return &sb, nil
} }
} }
return nil, nil return nil, nil
@ -157,7 +154,7 @@ func handleClean(c *cli.Context) {
func handleLogs(c *cli.Context) { func handleLogs(c *cli.Context) {
follow := c.Bool("f") follow := c.Bool("f")
ch,err := daemon.Logs(0,follow) ch, err := daemon.Logs(0, follow)
if err != nil { if err != nil {
fmt.Println("Logs failed", err) fmt.Println("Logs failed", err)
os.Exit(1) os.Exit(1)

17
oz/term.go
Unescape View File

@ -1,17 +1,18 @@
package main package main
import ( import (
"syscall" "fmt"
"unsafe"
"os" "os"
"os/signal" "os/signal"
"fmt" "syscall"
"unsafe"
) )
type winsize struct { type winsize struct {
Height uint16 Height uint16
Width uint16 Width uint16
x uint16 x uint16
y uint16 y uint16
} }
type State struct { type State struct {
termios Termios termios Termios
@ -101,7 +102,7 @@ func HandleResize(fd int) {
} }
func handleSIGWINCH(fd int) { func handleSIGWINCH(fd int) {
ws,errno := GetWinsize(0) ws, errno := GetWinsize(0)
if errno != 0 { if errno != 0 {
fmt.Printf("error reading winsize: %v\n", errno.Error()) fmt.Printf("error reading winsize: %v\n", errno.Error())
return return
@ -109,4 +110,4 @@ func handleSIGWINCH(fd int) {
if errno := SetWinsize(uintptr(fd), ws); errno != 0 { if errno := SetWinsize(uintptr(fd), ws); errno != 0 {
fmt.Printf("error setting winsize: %v", errno.Error()) fmt.Printf("error setting winsize: %v", errno.Error())
} }
} }

8
profile.go
Unescape View File

@ -65,18 +65,18 @@ var loadedProfiles []*Profile
type Profiles []*Profile type Profiles []*Profile
func (ps Profiles) GetProfileByName(name string) (*Profile,error) { func (ps Profiles) GetProfileByName(name string) (*Profile, error) {
if loadedProfiles == nil { if loadedProfiles == nil {
ps ,err := LoadProfiles(defaultProfileDirectory) ps, err := LoadProfiles(defaultProfileDirectory)
if err != nil { if err != nil {
return nil, err return nil, err
} }
loadedProfiles = ps loadedProfiles = ps
} }
for _,p := range loadedProfiles { for _, p := range loadedProfiles {
if p.Name == name { if p.Name == name {
return p,nil return p, nil
} }
} }
return nil, nil return nil, nil

9
xpra/client.go
Unescape View File

@ -1,9 +1,10 @@
package xpra package xpra
import ( import (
"github.com/subgraph/oz"
"fmt" "fmt"
"os"
"github.com/op/go-logging" "github.com/op/go-logging"
"github.com/subgraph/oz"
"os"
"os/exec" "os/exec"
"syscall" "syscall"
) )
@ -54,11 +55,11 @@ func prepareClientArgs(config *oz.XServerConf, display uint64, workdir string, l
return args return args
} }
func exists(path,label string, log *logging.Logger) bool { func exists(path, label string, log *logging.Logger) bool {
if path == "" { if path == "" {
return false return false
} }
if _,err := os.Stat(path); err != nil { if _, err := os.Stat(path); err != nil {
if !os.IsNotExist(err) { if !os.IsNotExist(err) {
log.Notice("%s file missing at %s, ignored.", label, path) log.Notice("%s file missing at %s, ignored.", label, path)
} else { } else {

4
xpra/server.go
Unescape View File

@ -1,7 +1,8 @@
package xpra package xpra
import ( import (
"github.com/subgraph/oz"
"fmt" "fmt"
"github.com/subgraph/oz"
"os" "os"
"os/exec" "os/exec"
) )
@ -37,4 +38,3 @@ func prepareServerArgs(config *oz.XServerConf, display uint64, workdir string) [
) )
return args return args
} }

5
xpra/xpra.go
Unescape View File

@ -1,7 +1,8 @@
package xpra package xpra
import ( import (
"os/exec"
"github.com/subgraph/oz" "github.com/subgraph/oz"
"os/exec"
) )
type Xpra struct { type Xpra struct {
@ -18,7 +19,6 @@ type Xpra struct {
// Arguments passed to xpra command // Arguments passed to xpra command
xpraArgs []string xpraArgs []string
} }
var xpraDefaultArgs = []string{ var xpraDefaultArgs = []string{
@ -52,4 +52,3 @@ func getDefaultArgs(config *oz.XServerConf) []string {
return args return args
} }

Write Preview
Loading…
Cancel
Save