MyFavMirrors
/
minio
mirror of https://github.com/minio/minio.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #833 from krishnasrinivas/server-service-2 

Add json rpc ServerService - provides only dummy data right now
This commit is contained in:
Harshavardhana 2015-09-17 15:51:46 -07:00
parent 156ebf6a60 c49407ced4
commit e821d4d0cc
5 changed files with 113 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/controller/router.go
View File

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

34
pkg/controller/rpc/rpc.go Normal file
View File

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

96
pkg/controller/rpc/server.go
View File

@ -18,34 +18,90 @@ package rpc
import (
"net/http"
"os"
"runtime"
"syscall"
"github.com/gorilla/rpc/v2"
"github.com/gorilla/rpc/v2/json"
"github.com/minio/minio/pkg/probe"
)
// Server rpc server container
type Server struct {
RPCServer *rpc.Server
type MinioServer struct {
Name string `json:"name"`
IP string `json:"ip"`
ID string `json:"id"`
}
// RegisterJSONCodec - register standard json codec
func (s Server) RegisterJSONCodec() {
s.RPCServer.RegisterCodec(json.NewCodec(), "application/json")
type ServerArg struct {
MinioServer
}
// RegisterService - register new services
func (s Server) RegisterService(recv interface{}, name string) {
s.RPCServer.RegisterService(recv, name)
type DummyReply struct{}
type MemStatsReply struct {
runtime.MemStats `json:"memstats"`
}
// NewServer - provide a new instance of RPC server
func NewServer() *Server {
s := &Server{}
s.RPCServer = rpc.NewServer()
type DiskStatsReply struct {
DiskStats syscall.Statfs_t `json:"diskstats"`
}
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
}
func (this *ServerService) MemStats(r *http.Request, arg *ServerArg, reply *MemStatsReply) error {
runtime.ReadMemStats(&reply.MemStats)
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
}
// ServeHTTP wrapper method for http.Handler interface
func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
s.RPCServer.ServeHTTP(w, r)
}

84
pkg/controller/rpc/sysinfo.go
View File

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

4
pkg/controller/rpc_test.go
View File

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