func (dt *DaoTest) TestDao_UpdateService(t *C) { dt.Dao.RemoveService("default", &unused) svc, _ := service.NewService() svc.ID = "default0" svc.Name = "default0" svc.PoolID = "default" svc.Launch = "auto" svc.DeploymentID = "deployment_id" err := dt.Dao.AddService(*svc, &id) t.Assert(err, IsNil) svc.Name = "name" err = dt.Dao.UpdateService(*svc, &unused) if err != nil { t.Errorf("Failure updating service %-v with error: %s", svc, err) t.Fail() } result := service.Service{} dt.Dao.GetService("default0", &result) //XXX the time.Time types fail comparison despite being equal... // as far as I can tell this is a limitation with Go result.UpdatedAt = svc.UpdatedAt result.CreatedAt = svc.CreatedAt if !svc.Equals(&result) { t.Errorf("Expected Service %+v, Actual Service %+v", result, *svc) t.Fail() } svc, _ = service.NewService() svc.ID = "default1" svc.Name = "default1" svc.PoolID = "default" svc.Launch = "auto" svc.DeploymentID = "deployment_id" err = dt.Dao.AddService(*svc, &id) t.Assert(err, IsNil) svc.Name = "name" err = dt.Dao.UpdateService(*svc, &unused) if err == nil { t.Errorf("Expected error updating service with same name and parent", svc) t.Fail() } }
func (dt *DaoTest) TestDao_GetService(t *C) { svc, _ := service.NewService() svc.Name = "testname" svc.PoolID = "default" svc.Launch = "auto" svc.DeploymentID = "deployment_id" err := dt.Dao.AddService(*svc, &id) t.Assert(err, IsNil) var result service.Service err = dt.Dao.GetService(svc.ID, &result) t.Assert(err, IsNil) //XXX the time.Time types fail comparison despite being equal... // as far as I can tell this is a limitation with Go result.UpdatedAt = svc.UpdatedAt result.CreatedAt = svc.CreatedAt if !svc.Equals(&result) { t.Errorf("GetService Failed: expected=%+v, actual=%+v", svc, result) } }
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) }