From 4eb75e1db1a8f368f789750c69ff86d5bcb14edd Mon Sep 17 00:00:00 2001 From: Aaron Lindsay Date: Mon, 2 Sep 2013 23:35:48 -0400 Subject: [PATCH] Continue reorganization, add asinkd stop cmd, make asinkd socket configurable --- {client => asink}/database.go | 0 {client => asink}/hash.go | 0 client/asink.go => asink/main.go | 0 {client => asink}/net.go | 0 {client => asink}/path_map.go | 0 {client => asink}/storage.go | 0 {client => asink}/storage_ftp.go | 0 {client => asink}/storage_local.go | 0 {client => asink}/watcher.go | 0 asinkd/exit.go | 1 + asinkd/main.go | 5 +++++ asinkd/{rpc.go => rpc_client.go} | 3 +-- asinkd/{admin_rpc.go => rpc_server.go} | 17 ++++++++++++++--- asinkd/server.go | 23 +++++++++++++++++++++-- asinkd/{rpc_users.go => user_admin.go} | 17 +++++++++++++---- 15 files changed, 55 insertions(+), 11 deletions(-) rename {client => asink}/database.go (100%) rename {client => asink}/hash.go (100%) rename client/asink.go => asink/main.go (100%) rename {client => asink}/net.go (100%) rename {client => asink}/path_map.go (100%) rename {client => asink}/storage.go (100%) rename {client => asink}/storage_ftp.go (100%) rename {client => asink}/storage_local.go (100%) rename {client => asink}/watcher.go (100%) rename asinkd/{rpc.go => rpc_client.go} (83%) rename asinkd/{admin_rpc.go => rpc_server.go} (82%) rename asinkd/{rpc_users.go => user_admin.go} (85%) diff --git a/client/database.go b/asink/database.go similarity index 100% rename from client/database.go rename to asink/database.go diff --git a/client/hash.go b/asink/hash.go similarity index 100% rename from client/hash.go rename to asink/hash.go diff --git a/client/asink.go b/asink/main.go similarity index 100% rename from client/asink.go rename to asink/main.go diff --git a/client/net.go b/asink/net.go similarity index 100% rename from client/net.go rename to asink/net.go diff --git a/client/path_map.go b/asink/path_map.go similarity index 100% rename from client/path_map.go rename to asink/path_map.go diff --git a/client/storage.go b/asink/storage.go similarity index 100% rename from client/storage.go rename to asink/storage.go diff --git a/client/storage_ftp.go b/asink/storage_ftp.go similarity index 100% rename from client/storage_ftp.go rename to asink/storage_ftp.go diff --git a/client/storage_local.go b/asink/storage_local.go similarity index 100% rename from client/storage_local.go rename to asink/storage_local.go diff --git a/client/watcher.go b/asink/watcher.go similarity index 100% rename from client/watcher.go rename to asink/watcher.go diff --git a/asinkd/exit.go b/asinkd/exit.go index 263e7fe..f822f09 100644 --- a/asinkd/exit.go +++ b/asinkd/exit.go @@ -13,6 +13,7 @@ var exitWaiterChan chan int func init() { exitWaiterCount = 0 exitWaiterChan = make(chan int) + exitCalled = make(chan int) go setupCleanExitOnSignals() } diff --git a/asinkd/main.go b/asinkd/main.go index 0744753..65d7bad 100644 --- a/asinkd/main.go +++ b/asinkd/main.go @@ -17,6 +17,11 @@ var commands []Command = []Command{ fn: StartServer, explanation: "Start the server daemon", }, + Command{ + cmd: "stop", + fn: StopServer, + explanation: "Stop the server daemon", + }, Command{ cmd: "useradd", fn: UserAdd, diff --git a/asinkd/rpc.go b/asinkd/rpc_client.go similarity index 83% rename from asinkd/rpc.go rename to asinkd/rpc_client.go index b50b2d1..718690d 100644 --- a/asinkd/rpc.go +++ b/asinkd/rpc_client.go @@ -7,8 +7,7 @@ import ( "syscall" ) -func RPCCall(method string, args interface{}, reply interface{}) error { - socket := "/tmp/asink.sock" +func RPCCall(socket, method string, args interface{}, reply interface{}) error { client, err := rpc.DialHTTP("unix", socket) if err != nil { if err2, ok := err.(*net.OpError); ok { diff --git a/asinkd/admin_rpc.go b/asinkd/rpc_server.go similarity index 82% rename from asinkd/admin_rpc.go rename to asinkd/rpc_server.go index 303f833..72045af 100644 --- a/asinkd/admin_rpc.go +++ b/asinkd/rpc_server.go @@ -65,15 +65,26 @@ func (u *UserModifier) RemoveUser(user *User, result *int) error { return err } -func StartRPC(tornDown chan int, adb *AsinkDB) { +type ServerStopper int + +func (s *ServerStopper) StopServer(code *int, result *int) error { + Exit(*code) + *result = 0 + return nil +} + +func StartRPC(sock string, tornDown chan int, adb *AsinkDB) { defer func() { tornDown <- 0 }() //the main thread waits for this to ensure the socket is closed usermod := new(UserModifier) usermod.adb = adb - rpc.Register(usermod) + + serverstop := new(ServerStopper) + rpc.Register(serverstop) + rpc.HandleHTTP() - l, err := net.Listen("unix", "/tmp/asink.sock") + l, err := net.Listen("unix", sock) if err != nil { panic(err) } diff --git a/asinkd/server.go b/asinkd/server.go index f10bb3f..438f199 100644 --- a/asinkd/server.go +++ b/asinkd/server.go @@ -17,6 +17,7 @@ import ( //global variables var eventsRegexp *regexp.Regexp var port int = 8080 +var rpcSock string var adb *AsinkDB func init() { @@ -30,17 +31,21 @@ func init() { } } +const sock_usage = "Socket to use to connect to the Asink server." +const sock_default = "/var/run/asink/asinkd.sock" + func StartServer(args []string) { const port_usage = "Port on which to serve HTTP API" flags := flag.NewFlagSet("start", flag.ExitOnError) flags.IntVar(&port, "port", 8080, port_usage) flags.IntVar(&port, "p", 8080, port_usage+" (shorthand)") - + flags.StringVar(&rpcSock, "sock", sock_default, sock_usage) + flags.StringVar(&rpcSock, "s", sock_default, sock_usage+" (shorthand)") flags.Parse(args) rpcTornDown := make(chan int) - go StartRPC(rpcTornDown, adb) + go StartRPC(rpcSock, rpcTornDown, adb) http.HandleFunc("/", rootHandler) http.HandleFunc("/events", eventHandler) @@ -59,6 +64,20 @@ func StartServer(args []string) { <-rpcTornDown } +func StopServer(args []string) { + flags := flag.NewFlagSet("stop", flag.ExitOnError) + flags.StringVar(&rpcSock, "sock", sock_default, sock_usage) + flags.StringVar(&rpcSock, "s", sock_default, sock_usage+" (shorthand)") + flags.Parse(args) + + i := 99 + returnCode := 0 + err := RPCCall(rpcSock, "ServerStopper.StopServer", &returnCode, &i) + if err != nil { + panic(err) + } +} + func rootHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "You're probably looking for /events/") } diff --git a/asinkd/rpc_users.go b/asinkd/user_admin.go similarity index 85% rename from asinkd/rpc_users.go rename to asinkd/user_admin.go index 1504068..d159bdb 100644 --- a/asinkd/rpc_users.go +++ b/asinkd/user_admin.go @@ -27,6 +27,9 @@ func (b *boolIsSetFlag) Set(value string) error { return err } +const rpcSocketDefault = "/var/run/asink/asinkd.sock" +const rpcSocketDescription = "Socket to use to connect to the Asink server." + func (b *boolIsSetFlag) String() string { return fmt.Sprintf("%v", *b) } func (b *boolIsSetFlag) IsBoolFlag() bool { return true } @@ -34,6 +37,7 @@ func (b *boolIsSetFlag) IsBoolFlag() bool { return true } func UserAdd(args []string) { flags := flag.NewFlagSet("useradd", flag.ExitOnError) admin := flags.Bool("admin", false, "User should be an administrator") + rpcSocket := flags.String("sock", rpcSocketDefault, rpcSocketDescription) flags.Parse(args) if flags.NArg() != 1 { @@ -66,7 +70,7 @@ func UserAdd(args []string) { user.PWHash = HashPassword(passwordOne) i := 99 - err = RPCCall("UserModifier.AddUser", user, &i) + err = RPCCall(*rpcSocket, "UserModifier.AddUser", user, &i) if err != nil { if _, ok := err.(rpc.ServerError); ok && err.Error() == DuplicateUsernameErr.Error() { fmt.Println("Error: " + err.Error()) @@ -77,7 +81,11 @@ func UserAdd(args []string) { } func UserDel(args []string) { - if len(args) != 1 { + flags := flag.NewFlagSet("userdel", flag.ExitOnError) + rpcSocket := flags.String("sock", rpcSocketDefault, rpcSocketDescription) + flags.Parse(args) + + if flags.NArg() != 1 { fmt.Println("Error: please supply a username (and only one)") os.Exit(1) } @@ -86,7 +94,7 @@ func UserDel(args []string) { user.Username = args[0] i := 99 - err := RPCCall("UserModifier.RemoveUser", user, &i) + err := RPCCall(*rpcSocket, "UserModifier.RemoveUser", user, &i) if err != nil { if _, ok := err.(rpc.ServerError); ok && err.Error() == NoUserErr.Error() { fmt.Println("Error: " + err.Error()) @@ -109,6 +117,7 @@ func UserMod(args []string) { flags.BoolVar(&rpcargs.UpdatePassword, "p", false, "Change the user's password (short version)") flags.BoolVar(&rpcargs.UpdateLogin, "login", false, "Change the user's username") flags.BoolVar(&rpcargs.UpdateLogin, "l", false, "Change the user's username (short version)") + rpcSocket := flags.String("sock", rpcSocketDefault, rpcSocketDescription) flags.Parse(args) if flags.NArg() != 1 { @@ -153,7 +162,7 @@ func UserMod(args []string) { } i := 99 - err := RPCCall("UserModifier.ModifyUser", rpcargs, &i) + err := RPCCall(*rpcSocket, "UserModifier.ModifyUser", rpcargs, &i) if err != nil { if _, ok := err.(rpc.ServerError); ok && err.Error() == NoUserErr.Error() { fmt.Println("Error: " + err.Error())