rename rpc/server.go -> rpc/rpc.go. rpc/server.go will accomodate ServerService

pkg/controller/router.go

@@ -26,12 +26,10 @@ import (
 // getRPCHandler rpc handler
 func getRPCHandler() http.Handler {
 	s := rpc.NewServer()
-	s.RegisterJSONCodec()
 	s.RegisterService(new(rpc.VersionService), "Version")
-	s.RegisterService(new(rpc.SysInfoService), "SysInfo")
-	s.RegisterService(new(rpc.MemStatsService), "MemStats")
 	s.RegisterService(new(rpc.DonutService), "Donut")
 	s.RegisterService(new(rpc.AuthService), "Auth")
+	s.RegisterService(rpc.NewServerService(), "Server")
 	// Add new RPC services here
 	return registerRPC(router.NewRouter(), s)
 }

pkg/controller/rpc/rpc.go

@@ -0,0 +1,34 @@
+/*
+ * Minio Cloud Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package rpc
+
+import (
+	"github.com/gorilla/rpc/v2"
+	"github.com/gorilla/rpc/v2/json"
+)
+
+type Server struct {
+	*rpc.Server
+}
+
+// NewServer - provide a new instance of RPC server
+func NewServer() *Server {
+	s := &Server{}
+	s.Server = rpc.NewServer()
+	s.RegisterCodec(json.NewCodec(), "application/json")
+	return s
+}

pkg/controller/rpc/server.go

@@ -18,34 +18,90 @@ package rpc
 
 import (
 	"net/http"
+	"os"
+	"runtime"
+	"syscall"
 
-	"github.com/gorilla/rpc/v2"
+	"github.com/minio/minio/pkg/probe"
-	"github.com/gorilla/rpc/v2/json"
 )
 
-// Server rpc server container
+type MinioServer struct {
-type Server struct {
+	Name string `json:"name"`
-	RPCServer *rpc.Server
+	IP   string `json:"ip"`
+	ID   string `json:"id"`
 }
 
-// RegisterJSONCodec - register standard json codec
+type ServerArg struct {
-func (s Server) RegisterJSONCodec() {
+	MinioServer
-	s.RPCServer.RegisterCodec(json.NewCodec(), "application/json")
 }
 
-// RegisterService - register new services
+type DummyReply struct{}
-func (s Server) RegisterService(recv interface{}, name string) {
+
-	s.RPCServer.RegisterService(recv, name)
+type MemStatsReply struct {
+	runtime.MemStats `json:"memstats"`
 }
 
-// NewServer - provide a new instance of RPC server
+type DiskStatsReply struct {
-func NewServer() *Server {
+	DiskStats syscall.Statfs_t `json:"diskstats"`
-	s := &Server{}
+}
-	s.RPCServer = rpc.NewServer()
+
-	return s
+type SysInfoReply struct {
+	Hostname  string `json:"hostname"`
+	SysARCH   string `json:"sys.arch"`
+	SysOS     string `json:"sys.os"`
+	SysCPUS   int    `json:"sys.ncpus"`
+	Routines  int    `json:"goroutines"`
+	GOVersion string `json:"goversion"`
+}
+
+type ListReply struct {
+	List []MinioServer `json:"list"`
+}
+
+type ServerService struct {
+	list []MinioServer
+}
+
+func (this *ServerService) Add(r *http.Request, arg *ServerArg, reply *DummyReply) error {
+	this.list = append(this.list, MinioServer{arg.Name, arg.IP, arg.ID})
+	return nil
 }
 
-// ServeHTTP wrapper method for http.Handler interface
+func (this *ServerService) MemStats(r *http.Request, arg *ServerArg, reply *MemStatsReply) error {
-func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	runtime.ReadMemStats(&reply.MemStats)
-	s.RPCServer.ServeHTTP(w, r)
+	return nil
+}
+
+func (this *ServerService) DiskStats(r *http.Request, arg *ServerArg, reply *DiskStatsReply) error {
+	syscall.Statfs("/", &reply.DiskStats)
+	return nil
+}
+
+func (this *ServerService) SysInfo(r *http.Request, arg *ServerArg, reply *SysInfoReply) error {
+	reply.SysARCH = runtime.GOARCH
+	reply.SysOS = runtime.GOOS
+	reply.SysCPUS = runtime.NumCPU()
+	reply.Routines = runtime.NumGoroutine()
+	reply.GOVersion = runtime.Version()
+	var err error
+	reply.Hostname, err = os.Hostname()
+	if err != nil {
+		return probe.WrapError(probe.NewError(err))
+	}
+	return nil
+}
+
+func (this *ServerService) List(r *http.Request, arg *ServerArg, reply *ListReply) error {
+	reply.List = this.list
+	return nil
+}
+
+func NewServerService() *ServerService {
+	s := &ServerService{}
+	s.list = []MinioServer{
+		{"server.one", "192.168.1.1", "192.168.1.1"},
+		{"server.two", "192.168.1.2", "192.168.1.2"},
+		{"server.three", "192.168.1.3", "192.168.1.3"},
+	}
+	return s
 }

pkg/controller/rpc/sysinfo.go

@@ -1,84 +0,0 @@
-/*
- * Minio Cloud Storage, (C) 2015 Minio, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package rpc
-
-import (
-	"net/http"
-	"os"
-	"runtime"
-
-	"github.com/minio/minio/pkg/probe"
-)
-
-// SysInfoService -
-type SysInfoService struct{}
-
-// SysInfoReply -
-type SysInfoReply struct {
-	Hostname  string `json:"hostname"`
-	SysARCH   string `json:"sys.arch"`
-	SysOS     string `json:"sys.os"`
-	SysCPUS   int    `json:"sys.ncpus"`
-	Routines  int    `json:"goroutines"`
-	GOVersion string `json:"goversion"`
-}
-
-// MemStatsService -
-type MemStatsService struct{}
-
-// MemStatsReply -
-type MemStatsReply struct {
-	runtime.MemStats `json:"memstats"`
-}
-
-func setSysInfoReply(sis *SysInfoReply) *probe.Error {
-	sis.SysARCH = runtime.GOARCH
-	sis.SysOS = runtime.GOOS
-	sis.SysCPUS = runtime.NumCPU()
-	sis.Routines = runtime.NumGoroutine()
-	sis.GOVersion = runtime.Version()
-
-	var err error
-	sis.Hostname, err = os.Hostname()
-	if err != nil {
-		return probe.NewError(err)
-	}
-	return nil
-}
-
-func setMemStatsReply(sis *MemStatsReply) *probe.Error {
-	var memStats runtime.MemStats
-	runtime.ReadMemStats(&memStats)
-	sis.MemStats = memStats
-	return nil
-}
-
-// Get method
-func (s *SysInfoService) Get(r *http.Request, args *Args, reply *SysInfoReply) error {
-	if err := setSysInfoReply(reply); err != nil {
-		return probe.WrapError(err)
-	}
-	return nil
-}
-
-// Get method
-func (s *MemStatsService) Get(r *http.Request, args *Args, reply *MemStatsReply) error {
-	if err := setMemStatsReply(reply); err != nil {
-		return probe.WrapError(err)
-	}
-	return nil
-}

pkg/controller/rpc_test.go

@@ -45,7 +45,7 @@ func (s *MySuite) TearDownSuite(c *C) {
 
 func (s *MySuite) TestMemStats(c *C) {
 	op := rpc.Operation{
-		Method:  "MemStats.Get",
+		Method:  "Server.MemStats",
 		Request: rpc.Args{Request: ""},
 	}
 	req, err := rpc.NewRequest(testRPCServer.URL+"/rpc", op, http.DefaultTransport)
@@ -63,7 +63,7 @@ func (s *MySuite) TestMemStats(c *C) {
 
 func (s *MySuite) TestSysInfo(c *C) {
 	op := rpc.Operation{
-		Method:  "SysInfo.Get",
+		Method:  "Server.SysInfo",
 		Request: rpc.Args{Request: ""},
 	}
 	req, err := rpc.NewRequest(testRPCServer.URL+"/rpc", op, http.DefaultTransport)