mirrors/minio
1
0
Fork 0
mirror of https://github.com/minio/minio.git synced 2025-11-04 10:11:09 +01:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Add list of servers, for controller args.

Browse Source
This commit is contained in:
Harshavardhana 2015-09-20 17:12:45 -07:00
parent 39e2209755
commit 1f364483e3
4 changed files with 113 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
controller-rpc.go
View File

@ -19,6 +19,7 @@ package main
import (
"errors"
"net/http"
"net/url"
"os"
"strings"
@ -29,7 +30,7 @@ import (
)
type controllerRPCService struct {
serverList []ServerArg
serverList []ServerRep
}
func makeDonut(args *DonutArgs, reply *DefaultRep) *probe.Error {
@ -171,46 +172,92 @@ func (s *controllerRPCService) ResetAuth(r *http.Request, args *AuthArgs, reply
return nil
}
func proxyRequest(method string, url string, arg interface{}, res interface{}) error {
// can be configured to something else in future
func proxyRequest(method, host string, ssl bool, res interface{}) *probe.Error {
u := &url.URL{
Scheme: func() string {
if ssl {
return "https"
}
return "http"
}(),
Host: host,
Path: "/rpc",
}
op := rpcOperation{
Method: method,
Request: arg,
Request: ServerArg{},
}
request, _ := newRPCRequest(url, op, nil)
resp, err := request.Do()
request, err := newRPCRequest(u.String(), op, nil)
if err != nil {
return err.Trace()
}
var resp *http.Response
resp, err = request.Do()
if err != nil {
return err.Trace()
}
if err := json.DecodeClientResponse(resp.Body, res); err != nil {
return probe.NewError(err)
}
return nil
}
func (s *controllerRPCService) AddServer(r *http.Request, args *ControllerArgs, res *ServerRep) error {
for _, host := range args.Hosts {
err := proxyRequest("Server.Add", host, args.SSL, res)
if err != nil {
return probe.WrapError(err)
}
decodeerr := json.DecodeClientResponse(resp.Body, res)
return decodeerr
}
func (s *controllerRPCService) AddServer(r *http.Request, arg *ServerArg, res *DefaultRep) error {
err := proxyRequest("Server.Add", arg.URL, arg, res)
if err == nil {
s.serverList = append(s.serverList, *arg)
s.serverList = append(s.serverList, *res)
}
return err
return nil
}
func (s *controllerRPCService) GetServerMemStats(r *http.Request, arg *ServerArg, res *MemStatsRep) error {
return proxyRequest("Server.MemStats", arg.URL, arg, res)
func (s *controllerRPCService) GetServerMemStats(r *http.Request, args *ControllerArgs, res *MemStatsRep) error {
for _, host := range args.Hosts {
err := proxyRequest("Server.MemStats", host, args.SSL, res)
if err != nil {
return probe.WrapError(err)
}
return nil
}
return errors.New("Invalid argument")
}
func (s *controllerRPCService) GetServerDiskStats(r *http.Request, arg *ServerArg, res *DiskStatsRep) error {
return proxyRequest("Server.DiskStats", arg.URL, arg, res)
func (s *controllerRPCService) GetServerDiskStats(r *http.Request, args *ControllerArgs, res *DiskStatsRep) error {
for _, host := range args.Hosts {
err := proxyRequest("Server.DiskStats", host, args.SSL, res)
if err != nil {
return probe.WrapError(err)
}
return nil
}
return errors.New("Invalid argument")
}
func (s *controllerRPCService) GetServerSysInfo(r *http.Request, arg *ServerArg, res *SysInfoRep) error {
return proxyRequest("Server.SysInfo", arg.URL, arg, res)
func (s *controllerRPCService) GetServerSysInfo(r *http.Request, args *ControllerArgs, res *SysInfoRep) error {
for _, host := range args.Hosts {
err := proxyRequest("Server.SysInfo", host, args.SSL, res)
if err != nil {
return probe.WrapError(err)
}
return nil
}
return errors.New("Invalid argument")
}
func (s *controllerRPCService) ListServers(r *http.Request, arg *ServerArg, res *ListRep) error {
func (s *controllerRPCService) ListServers(r *http.Request, args *ControllerArgs, res *ListRep) error {
res.List = s.serverList
return nil
}
func (s *controllerRPCService) GetServerVersion(r *http.Request, arg *ServerArg, res *VersionRep) error {
return proxyRequest("Server.Version", arg.URL, arg, res)
func (s *controllerRPCService) GetServerVersion(r *http.Request, args *ControllerArgs, res *VersionRep) error {
for _, host := range args.Hosts {
err := proxyRequest("Server.Version", host, args.SSL, res)
if err != nil {
return probe.WrapError(err)
}
return nil
}
return errors.New("Invalid argument")
}

18
controller_rpc_test.go
View File

@ -20,6 +20,7 @@ import (
"io/ioutil"
"net/http"
"net/http/httptest"
"net/url"
"os"
"github.com/gorilla/rpc/v2/json"
@ -29,6 +30,7 @@ import (
type ControllerRPCSuite struct {
root string
url *url.URL
}
var _ = Suite(&ControllerRPCSuite{})
@ -48,6 +50,10 @@ func (s *ControllerRPCSuite) SetUpSuite(c *C) {
testServerRPC = httptest.NewUnstartedServer(getServerRPCHandler())
testServerRPC.Config.Addr = ":9002"
testServerRPC.Start()
url, gerr := url.Parse(testServerRPC.URL)
c.Assert(gerr, IsNil)
s.url = url
}
func (s *ControllerRPCSuite) TearDownSuite(c *C) {
@ -59,7 +65,7 @@ func (s *ControllerRPCSuite) TearDownSuite(c *C) {
func (s *ControllerRPCSuite) TestMemStats(c *C) {
op := rpcOperation{
Method: "Controller.GetServerMemStats",
Request: ServerArg{URL: testServerRPC.URL + "/rpc"},
Request: ControllerArgs{Hosts: []string{s.url.Host}},
}
req, err := newRPCRequest(testControllerRPC.URL+"/rpc", op, http.DefaultTransport)
c.Assert(err, IsNil)
@ -77,7 +83,7 @@ func (s *ControllerRPCSuite) TestMemStats(c *C) {
func (s *ControllerRPCSuite) TestDiskStats(c *C) {
op := rpcOperation{
Method: "Controller.GetServerDiskStats",
Request: ServerArg{URL: testServerRPC.URL + "/rpc"},
Request: ControllerArgs{Hosts: []string{s.url.Host}},
}
req, err := newRPCRequest(testControllerRPC.URL+"/rpc", op, http.DefaultTransport)
c.Assert(err, IsNil)
@ -95,7 +101,7 @@ func (s *ControllerRPCSuite) TestDiskStats(c *C) {
func (s *ControllerRPCSuite) TestSysInfo(c *C) {
op := rpcOperation{
Method: "Controller.GetServerSysInfo",
Request: ServerArg{URL: testServerRPC.URL + "/rpc"},
Request: ControllerArgs{Hosts: []string{s.url.Host}},
}
req, err := newRPCRequest(testControllerRPC.URL+"/rpc", op, http.DefaultTransport)
c.Assert(err, IsNil)
@ -113,7 +119,7 @@ func (s *ControllerRPCSuite) TestSysInfo(c *C) {
func (s *ControllerRPCSuite) TestServerList(c *C) {
op := rpcOperation{
Method: "Controller.ListServers",
Request: ServerArg{URL: testServerRPC.URL + "/rpc"},
Request: ControllerArgs{Hosts: []string{s.url.Host}},
}
req, err := newRPCRequest(testControllerRPC.URL+"/rpc", op, http.DefaultTransport)
c.Assert(err, IsNil)
@ -125,13 +131,13 @@ func (s *ControllerRPCSuite) TestServerList(c *C) {
var reply ServerListRep
c.Assert(json.DecodeClientResponse(resp.Body, &reply), IsNil)
resp.Body.Close()
c.Assert(reply, Not(DeepEquals), ServerListRep{})
c.Assert(reply, Not(DeepEquals), ServerListRep{List: []ServerRep{}})
}
func (s *ControllerRPCSuite) TestServerAdd(c *C) {
op := rpcOperation{
Method: "Controller.AddServer",
Request: ServerArg{URL: testServerRPC.URL + "/rpc"},
Request: ControllerArgs{Hosts: []string{s.url.Host}},
}
req, err := newRPCRequest(testControllerRPC.URL+"/rpc", op, http.DefaultTransport)
c.Assert(err, IsNil)

32
rpc-definitions.go
View File

@ -16,6 +16,8 @@
package main
//// In memory metadata
//// RPC params
// AuthArgs auth params
@ -31,10 +33,13 @@ type DonutArgs struct {
Disks []string
}
// ServerArg server metadata to identify a server
type ServerArg struct {
Name string `json:"name"`
URL string `json:"url"`
// ServerArg server params
type ServerArg struct{}
// ControllerArgs controller params
type ControllerArgs struct {
Hosts []string `json:"hosts"` // hosts is a collection of host or host:port
SSL bool `json:"ssl"`
ID string `json:"id"`
}
@ -42,8 +47,7 @@ type ServerArg struct {
// ServerRep server reply container for Server.List
type ServerRep struct {
Name string `json:"name"`
Address string `json:"address"`
Host string `json:"host"`
ID string `json:"id"`
}
@ -69,13 +73,17 @@ type MemStatsRep struct {
Free uint64 `json:"free"`
}
// Network metadata of a server
type Network struct {
IP string `json:"address"`
NetMask string `json:"netmask"`
Hostname string `json:"hostname"`
Ethernet string `json:"networkInterface"`
}
// NetStatsRep network statistics of a server
type NetStatsRep struct {
Interfaces []struct {
IP string `json:"address"`
Mask string `json:"netmask"`
Ethernet string `json:"networkInterface"`
}
Interfaces []Network
}
// SysInfoRep system information of a server
@ -90,7 +98,7 @@ type SysInfoRep struct {
// ListRep all servers list
type ListRep struct {
List []ServerArg `json:"list"`
List []ServerRep `json:"list"`
}
// VersionRep version reply

21
server-rpc.go
View File

@ -26,9 +26,11 @@ import (
type serverRPCService struct{}
func (s *serverRPCService) Add(r *http.Request, arg *ServerArg, rep *DefaultRep) error {
rep.Message = "Server " + arg.URL + " added successfully"
rep.Error = nil
func (s *serverRPCService) Add(r *http.Request, arg *ServerArg, rep *ServerRep) error {
rep = &ServerRep{
Host: "192.168.1.1:9002",
ID: "6F27CB16-493D-40FA-B035-2A2E5646066A",
}
return nil
}
@ -58,17 +60,8 @@ func (s *serverRPCService) SysInfo(r *http.Request, arg *ServerArg, rep *SysInfo
}
func (s *serverRPCService) NetStats(r *http.Request, arg *ServerArg, rep *NetStatsRep) error {
rep.Interfaces = []struct {
IP string `json:"address"`
Mask string `json:"netmask"`
Ethernet string `json:"networkInterface"`
}{
{
"192.168.1.1",
"255.255.255.0",
"eth0",
},
}
rep.Interfaces = make([]Network, 0)
rep.Interfaces = append(rep.Interfaces, Network{IP: "192.168.1.1", NetMask: "255.255.255.0", Hostname: "hostname1", Ethernet: "eth0"})
return nil
}