Beispiel #1
0
func (s *S) Test_ConfigFileCRUD(t *C) {
	configFile, err := New("tenant_id", "/testpath", servicedefinition.ConfigFile{Content: "Test content", Filename: "testname"})
	t.Assert(err, IsNil)
	configFile2 := SvcConfigFile{}

	if err := s.ps.Get(s.ctx, Key(configFile.ID), &configFile2); !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Expected ErrNoSuchEntity, got: %v", err)
	}

	err = s.ps.Put(s.ctx, Key(configFile.ID), configFile)
	if err != nil {
		t.Errorf("Unexpected failure creating configFile %-v", configFile)
	}

	//Test update
	configFile.ConfFile.Owner = "newowner"
	err = s.ps.Put(s.ctx, Key(configFile.ID), configFile)
	err = s.ps.Get(s.ctx, Key(configFile.ID), &configFile2)
	if err != nil {
		t.Errorf("Unexpected error: %v", err)
	}

	if configFile.ConfFile.Owner != configFile2.ConfFile.Owner {
		t.Errorf("configFiles did not match after update")
	}

	//test delete
	err = s.ps.Delete(s.ctx, Key(configFile.ID))
	err = s.ps.Get(s.ctx, Key(configFile.ID), &configFile2)
	if err != nil && !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Unexpected error: %v", err)
	}

}
func (s *S) Test_ServiceTemplateCRUD(t *C) {

	id := "st_test_id"
	st := ServiceTemplate{ID: id}

	_, err := s.store.Get(s.ctx, st.ID)
	t.Assert(datastore.IsErrNoSuchEntity(err), Equals, true)

	err = s.store.Put(s.ctx, st)
	t.Assert(err, NotNil)

	st.Name = testutils.ValidSvcDef.Name
	st.Services = []servicedefinition.ServiceDefinition{*testutils.ValidSvcDef}
	err = s.store.Put(s.ctx, st)
	t.Assert(err, IsNil)

	st2, err := s.store.Get(s.ctx, st.ID)
	t.Assert(err, IsNil)
	t.Assert(st2, NotNil)
	t.Assert(st2.Equals(&st), Equals, true)

	//Test update
	st.Name = "newName"
	st.Services[0].Command = "blam"
	err = s.store.Put(s.ctx, st)

	st2, err = s.store.Get(s.ctx, st.ID)
	t.Assert(err, IsNil)
	t.Assert(st2, NotNil)
	t.Assert(st2.Equals(&st), Equals, true)

}
Beispiel #3
0
// AddService adds a service; return error if service already exists
func (f *Facade) AddService(ctx datastore.Context, svc service.Service) error {
	glog.V(2).Infof("Facade.AddService: %+v", svc)
	store := f.serviceStore

	_, err := store.Get(ctx, svc.ID)
	if err != nil && !datastore.IsErrNoSuchEntity(err) {
		return err
	} else if err == nil {
		return fmt.Errorf("error adding service; %v already exists", svc.ID)
	}

	// verify the service with parent ID does not exist with the given name
	if s, err := store.FindChildService(ctx, svc.DeploymentID, svc.ParentServiceID, svc.Name); err != nil {
		glog.Errorf("Could not verify service path for %s: %s", svc.Name, err)
		return err
	} else if s != nil {
		err := fmt.Errorf("service %s found at %s", svc.Name, svc.ParentServiceID)
		glog.Errorf("Cannot create service %s: %s", svc.Name, err)
		return err
	}

	// Strip the database version; we already know this is a create
	svc.DatabaseVersion = 0

	// Save a copy for checking configs later
	svcCopy := svc

	err = store.Put(ctx, &svc)
	if err != nil {
		glog.V(2).Infof("Facade.AddService: %+v", err)
		return err
	}
	glog.V(2).Infof("Facade.AddService: id %+v", svc.ID)

	// Compare the incoming config files to see if there are modifications from
	// the original. If there are, we need to perform an update to add those
	// modifications to the service.
	if svcCopy.OriginalConfigs != nil && !reflect.DeepEqual(svcCopy.OriginalConfigs, svcCopy.ConfigFiles) {
		// Get the current service in order to get the database version. We
		// don't save this because it won't have any of the updated config
		// files, among other things.
		cursvc, err := store.Get(ctx, svc.ID)
		if err != nil {
			glog.V(2).Infof("Facade.AddService: %+v", err)
			return err
		}
		svcCopy.DatabaseVersion = cursvc.DatabaseVersion

		for key, _ := range svcCopy.OriginalConfigs {
			glog.V(2).Infof("Facade.AddService: calling updateService for %s due to OriginalConfigs of %+v", svc.Name, key)
		}
		return f.updateService(ctx, &svcCopy)
	}

	glog.V(2).Infof("Facade.AddService: calling zk.updateService for %s %d ConfigFiles", svc.Name, len(svc.ConfigFiles))
	return zkAPI(f).UpdateService(&svc)
}
//func TestPutGetDelete(t *testing.T) {
func (s *S) TestPutGetDelete(t *C) {
	esdriver := s.Driver()
	//	driver, err := getConnection()
	//	if err != nil {
	//		t.Fatalf("Error initializing driver: %v", err)
	//	}

	conn, err := esdriver.GetConnection()
	if err != nil {
		t.Fatalf("Error getting connection: %v", err)
	}

	k := datastore.NewKey("tweet", "1")
	tweet := map[string]string{
		"user":      "******",
		"post_date": "2009-11-15T14:12:12",
		"message":   "trying out Elasticsearch",
	}
	tweetJSON, err := json.Marshal(tweet)
	err = conn.Put(k, datastore.NewJSONMessage(tweetJSON, 0))
	if err != nil {
		t.Errorf("%v", err)
	}

	//Get tweet
	raw, err := conn.Get(k)
	if err != nil {
		t.Fatalf("Unexpected: %v", err)
	}
	glog.Infof("raw is %v", string(raw.Bytes()))
	var tweetMap map[string]string
	json.Unmarshal(raw.Bytes(), &tweetMap)
	glog.Infof("tweet is %v", tweetMap)

	if tweetMap["user"] != "kimchy" {
		t.Errorf("Expected kimchy, found %s", tweetMap["user"])
	}

	//Delete tweet
	err = conn.Delete(k)
	if err != nil {
		t.Errorf("Unexpected delete error: %v", err)
	}

	//test not found
	raw, err = conn.Get(k)
	if raw != nil {
		t.Errorf("Expected nil return;")
	}
	if err == nil {
		t.Error("Expected error, not nil")
	} else if !datastore.IsErrNoSuchEntity(err) {
		glog.Infof("type is %s", reflect.ValueOf(err))
		t.Fatalf("Unexpected: %v", err)
	}

}
Beispiel #5
0
func (s *S) Test_AddressAssignmentCRUD(t *C) {
	defer s.ps.Delete(s.ctx, Key("testid"))

	assignment := &AddressAssignment{
		ID:             "testID",
		AssignmentType: "static",
		ServiceID:      "svcid",
		EndpointName:   "epname",
		IPAddr:         "10.0.1.5",
		HostID:         "hostid",
		Port:           500,
	}
	assignment2 := AddressAssignment{}

	if err := s.ps.Get(s.ctx, Key(assignment.ID), &assignment2); !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Expected ErrNoSuchEntity, got: %v", err)
	}

	err := s.ps.Put(s.ctx, Key(assignment.ID), assignment)
	t.Assert(err, IsNil)

	//Test update
	assignment.EndpointName = "BLAM"
	err = s.ps.Put(s.ctx, Key(assignment.ID), assignment)
	t.Assert(err, IsNil)

	err = s.ps.Get(s.ctx, Key(assignment.ID), &assignment2)
	t.Assert(err, IsNil)

	if assignment.EndpointName != assignment2.EndpointName {
		t.Errorf("assignments did not match after update")
	}

	//test delete
	err = s.ps.Delete(s.ctx, Key(assignment.ID))
	t.Assert(err, IsNil)
	err = s.ps.Get(s.ctx, Key(assignment.ID), &assignment2)
	if err != nil && !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Unexpected error: %v", err)
	}

}
Beispiel #6
0
//addUser places a new user record into elastic searchp
func (this *ControlPlaneDao) AddUser(newUser userdomain.User, userName *string) error {
	glog.V(2).Infof("ControlPlane.NewUser: %+v", newUser)
	name := strings.TrimSpace(*userName)
	newUser.Password = hashPassword(newUser.Password)

	// save the user
	var existing userdomain.User
	if err := this.GetUser(name, &existing); err != nil && !datastore.IsErrNoSuchEntity(err) {
		return err
	}
	store := userdomain.NewStore()
	return store.Put(datastore.Get(), userdomain.Key(name), &newUser)
}
Beispiel #7
0
// GetHost gets a host by id. Returns nil if host not found
func (f *Facade) GetHost(ctx datastore.Context, hostID string) (*host.Host, error) {
	glog.V(2).Infof("Facade.GetHost: id=%s", hostID)

	var value host.Host
	err := f.hostStore.Get(ctx, host.HostKey(hostID), &value)
	glog.V(4).Infof("Facade.GetHost: get error %v", err)
	if datastore.IsErrNoSuchEntity(err) {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return &value, nil
}
Beispiel #8
0
func (s *S) Test_PoolCRUD(t *C) {
	defer s.ps.Delete(s.ctx, Key("testid"))

	pool := New("testID")
	pool.Realm = "default"
	pool2 := ResourcePool{}

	if err := s.ps.Get(s.ctx, Key(pool.ID), &pool2); !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Expected ErrNoSuchEntity, got: %v", err)
	}

	err := s.ps.Put(s.ctx, Key(pool.ID), pool)
	if err != nil {
		t.Errorf("Unexpected failure creating pool %-v", pool)
	}

	//Test update
	pool.CoreLimit = 1024
	err = s.ps.Put(s.ctx, Key(pool.ID), pool)
	err = s.ps.Get(s.ctx, Key(pool.ID), &pool2)
	if err != nil {
		t.Errorf("Unexpected error: %v", err)
	}

	if pool.CoreLimit != pool2.CoreLimit {
		t.Errorf("pools did not match after update")
	}

	//test delete
	err = s.ps.Delete(s.ctx, Key(pool.ID))
	err = s.ps.Get(s.ctx, Key(pool.ID), &pool2)
	if err != nil && !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Unexpected error: %v", err)
	}

}
Beispiel #9
0
func (s *S) TestPutGetDelete(t *C) {
	ctx := s.ctx
	ds := datastore.New()

	key := datastore.NewKey("tweet", "1")
	tweet := tweettest{"kimchy", "", "2009-11-15T14:12:12", "trying out Elasticsearch", version}

	err := ds.Put(ctx, key, &tweet)
	if err != nil {
		t.Errorf("%v", err)
	}

	//Get tweet
	var storedtweet tweettest
	err = ds.Get(ctx, key, &storedtweet)
	if err != nil {
		t.Fatalf("Unexpected: %v", err)
	}
	glog.Infof("tweet is %v", &storedtweet)

	if storedtweet.User != "kimchy" {
		t.Errorf("Expected kimchy, found %s", storedtweet.User)
	}

	//Delete tweet
	err = ds.Delete(ctx, key)
	if err != nil {
		t.Errorf("Unexpected delete error: %v", err)
	}

	//test not found
	err = ds.Get(ctx, key, &storedtweet)
	if err == nil {
		t.Error("Expected error, not nil")
	} else if !datastore.IsErrNoSuchEntity(err) {
		glog.Infof("type is %s", reflect.ValueOf(err))
		t.Fatalf("Unexpected: %v", err)
	}
}
Beispiel #10
0
func (s *FacadeTest) Test_HostCRUD(t *C) {
	testid := "deadb10f"
	poolid := "pool-id"
	defer s.Facade.RemoveHost(s.CTX, testid)

	//fill host with required values
	h, err := host.Build("", "65535", poolid, []string{}...)
	h.ID = testid
	if err != nil {
		t.Fatalf("Unexpected error building host: %v", err)
	}
	glog.Infof("Facade test add host %v", h)
	err = s.Facade.AddHost(s.CTX, h)
	//should fail since pool doesn't exist
	if err == nil {
		t.Errorf("Expected error: %v", err)
	}

	//create pool for test
	rp := pool.New(poolid)
	if err := s.Facade.AddResourcePool(s.CTX, rp); err != nil {
		t.Fatalf("Could not add pool for test: %v", err)
	}
	defer s.Facade.RemoveResourcePool(s.CTX, poolid)

	err = s.Facade.AddHost(s.CTX, h)
	if err != nil {
		t.Errorf("Unexpected error adding host: %v", err)
	}

	//Test re-add fails
	err = s.Facade.AddHost(s.CTX, h)
	if err == nil {
		t.Errorf("Expected already exists error: %v", err)
	}

	h2, err := s.Facade.GetHost(s.CTX, testid)
	if err != nil {
		t.Errorf("Unexpected error: %v", err)
	}
	if h2 == nil {
		t.Error("Unexpected nil host")

	} else if !host.HostEquals(t, h, h2) {
		t.Error("Hosts did not match")
	}

	//Test update
	h.Memory = 1024
	err = s.Facade.UpdateHost(s.CTX, h)
	h2, err = s.Facade.GetHost(s.CTX, testid)
	if err != nil {
		t.Errorf("Unexpected error: %v", err)
	}
	if !host.HostEquals(t, h, h2) {
		t.Error("Hosts did not match")
	}

	//test delete
	err = s.Facade.RemoveHost(s.CTX, testid)
	h2, err = s.Facade.GetHost(s.CTX, testid)
	if err != nil && !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Unexpected error: %v", err)
	}
}
Beispiel #11
0
func (s *S) Test_HostCRUD(t *C) {
	hostID := "deadb40f"
	defer s.hs.Delete(s.ctx, HostKey(hostID))

	var host2 Host

	if err := s.hs.Get(s.ctx, HostKey(hostID), &host2); !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Expected ErrNoSuchEntity, got: %v", err)
	}

	host := New()

	err := s.hs.Put(s.ctx, HostKey(hostID), host)
	if err == nil {
		t.Errorf("Expected failure to create host %-v", host)
	}

	host.ID = hostID
	err = s.hs.Put(s.ctx, HostKey(host.ID), host)
	if err == nil {
		t.Errorf("Expected failure to create host %-v", host)
	}

	//fill host with required values
	host, err = Build("", "65535", "pool-id", []string{}...)
	host.ID = hostID
	if err != nil {
		t.Fatalf("Unexpected error building host: %v", err)
	}
	err = s.hs.Put(s.ctx, HostKey(hostID), host)
	if err != nil {
		t.Errorf("Unexpected error: %v", err)
	}

	err = s.hs.Get(s.ctx, HostKey(hostID), &host2)
	if err != nil {
		t.Errorf("Unexpected error: %v", err)
	}
	if !HostEquals(t, host, &host2) {
		t.Error("Hosts did not match")
	}

	//Test update
	host.Memory = 1024
	err = s.hs.Put(s.ctx, HostKey(host.ID), host)
	err = s.hs.Get(s.ctx, HostKey(hostID), &host2)
	if err != nil {
		t.Errorf("Unexpected error: %v", err)
	}
	if !HostEquals(t, host, &host2) {
		t.Error("Hosts did not match")
	}

	//test delete
	err = s.hs.Delete(s.ctx, HostKey(hostID))
	err = s.hs.Get(s.ctx, HostKey(hostID), &host2)
	if err != nil && !datastore.IsErrNoSuchEntity(err) {
		t.Errorf("Unexpected error: %v", err)
	}

}