func (dt *DaoTest) TestDao_NewService(t *C) {
svc := service.Service{}
err := dt.Dao.AddService(svc, &id)
if err == nil {
t.Errorf("Expected failure to create service %-v", svc)
t.Fail()
}
svc.ID = "default"
svc.Name = "default"
svc.PoolID = "default"
svc.Launch = "auto"
svc.DeploymentID = "deployment_id"
err = dt.Dao.AddService(svc, &id)
if err != nil {
t.Errorf("Failure creating service %-v with error: %s", svc, err)
t.Fail()
}
err = dt.Dao.AddService(svc, &id)
if err == nil {
t.Errorf("Expected error creating redundant service %-v", svc)
t.Fail()
}
svc.ID = ""
err = dt.Dao.AddService(svc, &id)
if err == nil {
t.Errorf("Expected error creating service with same name and parent", svc)
t.Fail()
}
}
func (dt *DaoTest) TestDao_NewSnapshot(t *C) {
t.Skip("TODO: fix this test")
// this is technically not a unit test since it depends on the leader
// starting a watch for snapshot requests and the code here is time
// dependent waiting for that leader to start the watch
return
glog.V(0).Infof("TestDao_NewSnapshot started")
defer glog.V(0).Infof("TestDao_NewSnapshot finished")
time.Sleep(2 * time.Second) // wait for Leader to start watching for snapshot requests
service := service.Service{}
service.ID = "service-without-quiesce"
dt.Dao.RemoveService(service.ID, &unused)
// snapshot should work for services without Snapshot Pause/Resume
err := dt.Dao.AddService(service, &id)
if err != nil {
t.Fatalf("Failure creating service %+v with error: %s", service, err)
}
service.ID = "service1-quiesce"
dt.Dao.RemoveService(service.ID, &unused)
service.Snapshot.Pause = fmt.Sprintf("STATE=paused echo %s quiesce $STATE", service.ID)
service.Snapshot.Resume = fmt.Sprintf("STATE=resumed echo %s quiesce $STATE", service.ID)
err = dt.Dao.AddService(service, &id)
if err != nil {
t.Fatalf("Failure creating service %+v with error: %s", service, err)
}
service.ID = "service2-quiesce"
dt.Dao.RemoveService(service.ID, &unused)
service.Snapshot.Pause = fmt.Sprintf("STATE=paused echo %s quiesce $STATE", service.ID)
service.Snapshot.Resume = fmt.Sprintf("STATE=resumed echo %s quiesce $STATE", service.ID)
err = dt.Dao.AddService(service, &id)
if err != nil {
t.Fatalf("Failure creating service %+v with error: %s", service, err)
}
err = dt.Dao.Snapshot(service.ID, &id)
if err != nil {
t.Fatalf("Failure creating snapshot for service %+v with error: %s", service, err)
}
if id == "" {
t.Fatalf("Failure creating snapshot for service %+v - label is empty", service)
}
glog.V(0).Infof("successfully created 1st snapshot with label:%s", id)
err = dt.Dao.Snapshot(service.ID, &id)
if err != nil {
t.Fatalf("Failure creating snapshot for service %+v with error: %s", service, err)
}
if id == "" {
t.Fatalf("Failure creating snapshot for service %+v - label is empty", service)
}
glog.V(0).Infof("successfully created 2nd snapshot with label:%s", id)
time.Sleep(10 * time.Second)
}
func restAddService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var svc service.Service
var serviceID string
err := r.DecodeJsonPayload(&svc)
if err != nil {
glog.V(1).Info("Could not decode service payload: ", err)
restBadRequest(w, err)
return
}
if id, err := utils.NewUUID36(); err != nil {
restBadRequest(w, err)
return
} else {
svc.ID = id
}
now := time.Now()
svc.CreatedAt = now
svc.UpdatedAt = now
//for each endpoint, evaluate its EndpointTemplates
getSvc := func(svcID string) (service.Service, error) {
svc := service.Service{}
err := client.GetService(svcID, &svc)
return svc, err
}
findChild := func(svcID, childName string) (service.Service, error) {
svc := service.Service{}
err := client.FindChildService(dao.FindChildRequest{svcID, childName}, &svc)
return svc, err
}
if err = svc.EvaluateEndpointTemplates(getSvc, findChild); err != nil {
glog.Errorf("Unable to evaluate service endpoints: %v", err)
restServerError(w, err)
return
}
tags := map[string][]string{
"controlplane_service_id": []string{svc.ID},
}
profile, err := svc.MonitoringProfile.ReBuild("1h-ago", tags)
if err != nil {
glog.Errorf("Unable to rebuild service monitoring profile: %v", err)
restServerError(w, err)
return
}
svc.MonitoringProfile = *profile
//add the service to the data store
err = client.AddService(svc, &serviceID)
if err != nil {
glog.Errorf("Unable to add service: %v", err)
restServerError(w, err)
return
}
//automatically assign virtual ips to new service
request := dao.AssignmentRequest{ServiceID: svc.ID, IPAddress: "", AutoAssignment: true}
if err := client.AssignIPs(request, nil); err != nil {
glog.Errorf("Failed to automatically assign IPs: %+v -> %v", request, err)
restServerError(w, err)
return
}
glog.V(0).Info("Added service ", serviceID)
w.WriteJson(&simpleResponse{"Added service", serviceLinks(serviceID)})
}
// updateService internal method to use when service has been validated
func (f *Facade) updateService(ctx datastore.Context, svc *service.Service) error {
id := strings.TrimSpace(svc.ID)
if id == "" {
return errors.New("empty Service.ID not allowed")
}
svc.ID = id
//add assignment info to service so it is availble in zk
f.fillServiceAddr(ctx, svc)
svcStore := f.serviceStore
// verify the service with name and parent does not collide with another existing service
if s, err := svcStore.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 {
if s.ID != svc.ID {
err := fmt.Errorf("service %s found at %s", svc.Name, svc.ParentServiceID)
glog.Errorf("Cannot update service %s: %s", svc.Name, err)
return err
}
}
oldSvc, err := svcStore.Get(ctx, svc.ID)
if err != nil {
return err
}
//Deal with Service Config Files
//For now always make sure originalConfigs stay the same, essentially they are immutable
svc.OriginalConfigs = oldSvc.OriginalConfigs
//check if config files haven't changed
if !reflect.DeepEqual(oldSvc.OriginalConfigs, svc.ConfigFiles) {
//lets validate Service before doing more work....
if err := svc.ValidEntity(); err != nil {
return err
}
tenantID, servicePath, err := f.getTenantIDAndPath(ctx, *svc)
if err != nil {
return err
}
newConfs := make(map[string]*serviceconfigfile.SvcConfigFile)
//config files are different, for each one that is different validate and add to newConfs
for key, oldConf := range oldSvc.OriginalConfigs {
if conf, found := svc.ConfigFiles[key]; found {
if !reflect.DeepEqual(oldConf, conf) {
newConf, err := serviceconfigfile.New(tenantID, servicePath, conf)
if err != nil {
return err
}
newConfs[key] = newConf
}
}
}
//Get current stored conf files and replace as needed
configStore := serviceconfigfile.NewStore()
existingConfs, err := configStore.GetConfigFiles(ctx, tenantID, servicePath)
if err != nil {
return err
}
foundConfs := make(map[string]*serviceconfigfile.SvcConfigFile)
for _, svcConfig := range existingConfs {
foundConfs[svcConfig.ConfFile.Filename] = svcConfig
}
//add or replace stored service config
for _, newConf := range newConfs {
if existing, found := foundConfs[newConf.ConfFile.Filename]; found {
newConf.ID = existing.ID
//delete it from stored confs, left overs will be deleted from DB
delete(foundConfs, newConf.ConfFile.Filename)
}
configStore.Put(ctx, serviceconfigfile.Key(newConf.ID), newConf)
}
//remove leftover non-updated stored confs, conf was probably reverted to original or no longer exists
for _, confToDelete := range foundConfs {
configStore.Delete(ctx, serviceconfigfile.Key(confToDelete.ID))
}
}
svc.UpdatedAt = time.Now()
if err := svcStore.Put(ctx, svc); err != nil {
return err
}
// Remove the service from zookeeper if the pool ID has changed
if oldSvc.PoolID != svc.PoolID {
if err := zkAPI(f).RemoveService(oldSvc); err != nil {
// Synchronizer will eventually clean this service up
glog.Warningf("ZK: Could not delete service %s (%s) from pool %s: %s", svc.Name, svc.ID, oldSvc.PoolID, err)
oldSvc.DesiredState = int(service.SVCStop)
zkAPI(f).UpdateService(oldSvc)
}
}
return zkAPI(f).UpdateService(svc)
}