//New creates a SvcConfigFile
func New(tenantID string, svcPath string, conf servicedefinition.ConfigFile) (*SvcConfigFile, error) {
uuid, err := utils.NewUUID()
if err != nil {
return nil, err
}
svcCF := &SvcConfigFile{ID: uuid, ServiceTenantID: tenantID, ServicePath: svcPath, ConfFile: conf}
if err = svcCF.ValidEntity(); err != nil {
return nil, err
}
return svcCF, nil
}
// SendAction sends an action request to a particular host
func SendAction(conn client.Connection, action *Action) (string, error) {
uuid, err := utils.NewUUID()
if err != nil {
return "", err
}
node := actionPath(action.HostID, uuid)
if err := conn.Create(node, action); err != nil {
return "", err
} else if err := conn.Set(node, action); err != nil {
return "", err
}
return uuid, 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()
}