//GetHost gets the host for the given hostID or nil
func (c *Client) GetHost(hostID string) (*host.Host, error) {
response := host.New()
if err := c.call("GetHost", hostID, response); err != nil {
return nil, err
}
return response, nil
}
func TestGetInfo(t *testing.T) {
ip, err := utils.GetIPAddress()
if err != nil {
t.Fatalf("Unexpected error %v", err)
}
staticIPs := []string{ip}
agent := NewServer(staticIPs)
h := host.New()
request := BuildHostRequest{IP: "", PoolID: "testpool"}
err = agent.BuildHost(request, h)
if err != nil && !strings.Contains(err.Error(), "not valid for this host") {
t.Fatalf("Unexpected error %v", err)
}
if len(h.IPs) != 0 {
t.Fatalf("Unexpected result %v (%d)", h.IPs, len(h.IPs))
}
request = BuildHostRequest{IP: "127.0.0.1", PoolID: "testpool"}
err = agent.BuildHost(request, h)
if err == nil || err.Error() != "loopback address 127.0.0.1 cannot be used to register a host" {
t.Fatalf("Unexpected error %v", err)
}
request = BuildHostRequest{IP: "", PoolID: "testpool"}
err = agent.BuildHost(request, h)
if err == nil || !strings.Contains(err.Error(), "not valid for this host") {
t.Errorf("Unexpected error %v", err)
}
}
func TestClient(t *testing.T) {
t.Skipf("Test cluster is not set up properly")
zookeeper.EnsureZkFatjar()
basePath := ""
tc, err := zklib.StartTestCluster(1, nil, nil)
if err != nil {
t.Fatalf("could not start test zk cluster: %s", err)
}
defer os.RemoveAll(tc.Path)
defer tc.Stop()
time.Sleep(time.Second)
servers := []string{fmt.Sprintf("127.0.0.1:%d", tc.Servers[0].Port)}
dsnBytes, err := json.Marshal(zookeeper.DSN{Servers: servers, Timeout: time.Second * 15})
if err != nil {
t.Fatal("unexpected error creating zk DSN: %s", err)
}
dsn := string(dsnBytes)
zClient, err := client.New("zookeeper", dsn, basePath, nil)
zzk.InitializeLocalClient(zClient)
conn, err := zzk.GetLocalConnection("/")
if err != nil {
t.Fatal("unexpected error getting connection")
}
h := host.New()
h.ID = "nodeID"
h.IPAddr = "192.168.1.5"
h.PoolID = "default1"
defer func(old func(string, os.FileMode) error) {
mkdirAll = old
}(mkdirAll)
dir, err := ioutil.TempDir("", "serviced_var_")
if err != nil {
t.Fatalf("could not create tempdir: %s", err)
}
defer os.RemoveAll(dir)
c, err := NewClient(h, dir)
if err != nil {
t.Fatalf("unexpected error creating client: %s", err)
}
defer c.Close()
time.Sleep(time.Second * 5)
// therefore, we need to check that the client was added under the pool from root
nodePath := fmt.Sprintf("/storage/clients/%s", h.IPAddr)
glog.Infof("about to check for %s", nodePath)
if exists, err := conn.Exists(nodePath); err != nil {
t.Fatalf("did not expect error checking for existence of %s: %s", nodePath, err)
} else {
if !exists {
t.Fatalf("could not find %s", nodePath)
}
}
}
func (t HostAPITest) AddHost(config api.HostConfig) (*host.Host, error) {
if t.fail {
return nil, ErrInvalidHost
} else if config.PoolID == NilPool {
return nil, nil
}
h := host.New()
h.ID = fmt.Sprintf("%s-%s", config.Address.Host, config.PoolID)
return h, nil
}
func TestServer(t *testing.T) {
t.Skip() // the zookeeper part doesnt work in this test, but does work in real life
zookeeper.EnsureZkFatjar()
basePath := ""
tc, err := zklib.StartTestCluster(1, nil, nil)
if err != nil {
t.Fatalf("could not start test zk cluster: %s", err)
}
defer os.RemoveAll(tc.Path)
defer tc.Stop()
time.Sleep(time.Second)
servers := []string{fmt.Sprintf("127.0.0.1:%d", tc.Servers[0].Port)}
dsnBytes, err := json.Marshal(zookeeper.DSN{Servers: servers, Timeout: time.Second * 15})
if err != nil {
t.Fatal("unexpected error creating zk DSN: %s", err)
}
dsn := string(dsnBytes)
zClient, err := client.New("zookeeper", dsn, basePath, nil)
if err != nil {
t.Fatal("unexpected error getting zk client")
}
zzk.InitializeLocalClient(zClient)
defer func(orig func(nfs.Driver, string, string) error) {
nfsMount = orig
}(nfsMount)
var local, remote string
nfsMount = func(driver nfs.Driver, a, b string) error {
glog.Infof("client is mounting %s to %s", a, b)
remote = a
local = b
return nil
}
// creating a UUID in order to make a unique poolID
// the poolID is somehow being saved on the filesystem (zookeeper config somewhere?)
// making the poolID unique on every run will ensure it is stateless
uuid, err := utils.NewUUID()
if err != nil {
t.Fatal("New UUID could not be created")
}
hostServer := host.New()
hostServer.ID = "nodeID"
hostServer.IPAddr = "192.168.1.50"
hostServer.PoolID = uuid
hostClient1 := host.New()
hostClient1.ID = "nodeID_client1"
hostClient1.IPAddr = "192.168.1.100"
hostClient1.PoolID = uuid
mockNfsDriver := &mockNfsDriverT{
exportPath: "/exports",
exportName: "serviced_var",
}
// TODO: this gets stuck at server.go:90 call to conn.CreateDir hangs
s, err := NewServer(mockNfsDriver, hostServer, path.Join(mockNfsDriver.exportPath, mockNfsDriver.exportName))
if err != nil {
t.Fatalf("unexpected error creating Server: %s", err)
}
conn, err := zzk.GetLocalConnection("/")
if err != nil {
t.Fatalf("unexpected error getting connection: %s", err)
}
shutdown := make(chan interface{})
defer close(shutdown)
go s.Run(shutdown, conn)
// give it some time
time.Sleep(time.Second * 5)
if !mockNfsDriver.syncCalled {
t.Fatalf("sync() should have been called by now")
}
if len(mockNfsDriver.clients) != 0 {
t.Fatalf("Expected number of clients: 0 --- Found: %v (%v)", len(mockNfsDriver.clients), mockNfsDriver.clients)
}
mockNfsDriver.syncCalled = false
tmpVar, err := ioutil.TempDir("", "serviced_var")
if err != nil {
t.Fatalf("could not create tempdir: %s", err)
}
defer os.RemoveAll(tmpVar)
c1, err := NewClient(hostClient1, tmpVar)
if err != nil {
t.Fatalf("could not create client: %s", err)
}
// give it some time
time.Sleep(time.Second * 2)
if !mockNfsDriver.syncCalled {
t.Fatalf("sync() should have been called by now")
}
if len(mockNfsDriver.clients) != 1 {
t.Fatalf("expecting 1 client, got %d", len(mockNfsDriver.clients))
}
if mockNfsDriver.clients[0] != hostClient1.IPAddr {
t.Fatalf("expecting '%s', got '%s'", hostServer.IPAddr, mockNfsDriver.clients[0])
}
shareName := fmt.Sprintf("%s:%s", hostServer.IPAddr, mockNfsDriver.ExportPath())
if remote != shareName {
t.Fatalf("remote should be %s, not %s", remote, shareName)
}
glog.Info("about to call c1.Close()")
c1.Close()
}