func (s *scheduler) AddUpdateResourcePool(pool *pool.ResourcePool) error { if p, err := s.facade.GetResourcePool(datastore.Get(), pool.ID); err != nil { return err } else if p == nil { return s.facade.AddResourcePool(datastore.Get(), pool) } return s.facade.UpdateResourcePool(datastore.Get(), pool) }
func (s *scheduler) AddUpdateHost(host *host.Host) error { if h, err := s.facade.GetHost(datastore.Get(), host.ID); err != nil { return err } else if h == nil { return s.facade.AddHost(datastore.Get(), host) } return s.facade.UpdateHost(datastore.Get(), host) }
func (s *scheduler) AddUpdateService(svc *service.Service) error { if sv, err := s.facade.GetService(datastore.Get(), svc.ID); err != nil { return err } else if sv == nil { return s.facade.AddService(datastore.Get(), *svc) } return s.facade.UpdateService(datastore.Get(), *svc) }
func (this *ControlPlaneDao) UpdateService(svc service.Service, unused *int) error { if err := this.facade.UpdateService(datastore.Get(), svc); err != nil { return err } // Create the tenant volume if tenantID, err := this.facade.GetTenantID(datastore.Get(), svc.ID); err != nil { glog.Warningf("Could not get tenant for service %s: %s", svc.ID, err) } else if _, err := this.dfs.GetVolume(tenantID); err != nil { glog.Warningf("Could not create volume for tenant %s: %s", tenantID, err) } return nil }
func (this *ControlPlaneDao) GetRunningService(request dao.ServiceStateRequest, running *dao.RunningService) error { glog.V(3).Infof("ControlPlaneDao.GetRunningService: request=%v", request) *running = dao.RunningService{} serviceID := request.ServiceID poolID, err := this.facade.GetPoolForService(datastore.Get(), serviceID) if err != nil { glog.Errorf("Unable to get service %v: %v", serviceID, err) return err } poolBasedConn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(poolID)) if err != nil { glog.Errorf("Error in getting a connection based on pool %v: %v", poolID, err) return err } if thisRunning, err := zkservice.LoadRunningService(poolBasedConn, request.ServiceID, request.ServiceStateID); err != nil { glog.Errorf("zkservice.LoadRunningService failed (conn: %+v serviceID: %v): %v", poolBasedConn, request.ServiceID, err) return err } else { if thisRunning != nil { *running = *thisRunning } } return nil }
// GetServiceAddressAssignments fills in all AddressAssignments for the specified serviced id. func (this *ControlPlaneDao) GetServiceAddressAssignments(serviceID string, assignments *[]addressassignment.AddressAssignment) error { err := this.facade.GetServiceAddressAssignments(datastore.Get(), serviceID, assignments) if assignments == nil { *assignments = make([]addressassignment.AddressAssignment, 0) } return err }
func (this *ControlPlaneDao) GetRunningServices(request dao.EntityRequest, allRunningServices *[]dao.RunningService) error { // we initialize the data container to something here in case it has not been initialized yet *allRunningServices = make([]dao.RunningService, 0) allPools, err := this.facade.GetResourcePools(datastore.Get()) if err != nil { glog.Error("runningservice.go failed to get resource pool") return err } else if allPools == nil || len(allPools) == 0 { return fmt.Errorf("no resource pools found") } for _, aPool := range allPools { poolBasedConn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(aPool.ID)) if err != nil { glog.Error("runningservice.go Failed to get connection based on pool: %v", aPool.ID) return err } singlePoolRunningServices := []dao.RunningService{} singlePoolRunningServices, err = zkservice.LoadRunningServices(poolBasedConn) if err != nil { glog.Errorf("Failed GetAllRunningServices: %v", err) return err } for _, rs := range singlePoolRunningServices { *allRunningServices = append(*allRunningServices, rs) } } return nil }
func (this *ControlPlaneDao) GetRunningServicesForHost(hostID string, services *[]dao.RunningService) error { // we initialize the data container to something here in case it has not been initialized yet *services = make([]dao.RunningService, 0) myHost, err := this.facade.GetHost(datastore.Get(), hostID) if err != nil { glog.Errorf("Unable to get host %v: %v", hostID, err) return err } else if myHost == nil { return nil } poolBasedConn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(myHost.PoolID)) if err != nil { glog.Errorf("Error in getting a connection based on pool %v: %v", myHost.PoolID, err) return err } *services, err = zkservice.LoadRunningServicesByHost(poolBasedConn, hostID) if err != nil { glog.Errorf("zkservice.LoadRunningServicesByHost (conn: %+v host: %v) failed: %v", poolBasedConn, hostID, err) return err } return nil }
// GetService gets a service. func (this *ControlPlaneDao) GetService(id string, myService *service.Service) error { svc, err := this.facade.GetService(datastore.Get(), id) if svc != nil { *myService = *svc } return err }
func (this *ControlPlaneDao) GetRunningServicesForService(serviceID string, services *[]dao.RunningService) error { // we initialize the data container to something here in case it has not been initialized yet *services = make([]dao.RunningService, 0) poolID, err := this.facade.GetPoolForService(datastore.Get(), serviceID) if err != nil { glog.Errorf("Unable to get service %v: %v", serviceID, err) return err } poolBasedConn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(poolID)) if err != nil { glog.Errorf("Error in getting a connection based on pool %v: %v", poolID, err) return err } svcs, err := zkservice.LoadRunningServicesByService(poolBasedConn, serviceID) if err != nil { glog.Errorf("LoadRunningServicesByService failed (conn: %+v serviceID: %v): %v", poolBasedConn, serviceID, err) return err } for _, svc := range svcs { *services = append(*services, svc) } return nil }
func (d *daemon) initContext() (datastore.Context, error) { datastore.Register(d.dsDriver) ctx := datastore.Get() if ctx == nil { return nil, errors.New("context not available") } return ctx, nil }
// Get a service endpoint. func (this *ControlPlaneDao) GetServiceEndpoints(serviceID string, response *map[string][]dao.ApplicationEndpoint) (err error) { if result, err := this.facade.GetServiceEndpoints(datastore.Get(), serviceID); err == nil { *response = result return nil } else { return err } }
// The tenant id is the root service uuid. Walk the service tree to root to find the tenant id. func (this *ControlPlaneDao) GetTenantId(serviceID string, tenantId *string) error { if tid, err := this.facade.GetTenantID(datastore.Get(), serviceID); err == nil { *tenantId = tid return nil } else { return err } }
// Get tagged services (can also filter by name and/or tenantID) func (this *ControlPlaneDao) GetTaggedServices(request dao.ServiceRequest, services *[]service.Service) error { if svcs, err := this.facade.GetTaggedServices(datastore.Get(), request); err == nil { *services = svcs return nil } else { return err } }
//getService is an internal method that returns a Service without filling in all related service data like address assignments //and modified config files func (f *Facade) getService(ctx datastore.Context, id string) (service.Service, error) { glog.V(3).Infof("Facade.getService: id=%s", id) store := f.serviceStore svc, err := store.Get(datastore.Get(), id) if err != nil || svc == nil { return service.Service{}, err } return *svc, err }
func (this *ControlPlaneDao) GetUser(userName string, user *userdomain.User) error { glog.V(2).Infof("ControlPlaneDao.GetUser: userName=%s", userName) store := userdomain.NewStore() err := store.Get(datastore.Get(), userdomain.Key(userName), user) glog.V(2).Infof("ControlPlaneDao.GetUser: userName=%s, user=%+v, err=%s", userName, user, err) if user == nil { *user = userdomain.User{} } return err }
func (this *ControlPlaneDao) FindChildService(request dao.FindChildRequest, service *service.Service) error { svc, err := this.facade.FindChildService(datastore.Get(), request.ServiceID, request.ChildName) if err != nil { return err } if svc != nil { *service = *svc } else { glog.Warningf("unable to find child of service: %+v", service) } return nil }
//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) }
func (dfs *DistributedFilesystem) desynchronize(image *docker.Image) error { // inspect the image dImg, err := image.Inspect() if err != nil { glog.Errorf("Could not inspect image %s (%s): %s", image.ID, image.UUID, err) return err } // look up services for that tenant svcs, err := dfs.facade.GetServices(datastore.Get(), dao.ServiceRequest{TenantID: image.ID.User}) if err != nil { glog.Errorf("Could not get services for tenant %s from %s (%s): %s", image.ID.User, image.ID, image.UUID, err) return err } for _, svc := range svcs { // figure out which services are using the provided image svcImageID, err := commons.ParseImageID(svc.ImageID) if err != nil { glog.Warningf("Could not parse image %s for %s (%s): %s", svc.ImageID, svc.Name, svc.ID) continue } else if !svcImageID.Equals(image.ID) { continue } // TODO: we need to switch to using dao.ControlPlane conn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(svc.PoolID)) if err != nil { glog.Warningf("Could not acquire connection to the coordinator (%s): %s", svc.PoolID, err) continue } states, err := zkservice.GetServiceStates(conn, svc.ID) if err != nil { glog.Warningf("Could not get running services for %s (%s): %s", svc.Name, svc.ID) continue } for _, state := range states { // check if the instance has been running since before the commit if state.IsRunning() && state.Started.Before(dImg.Created) { state.InSync = false if err := zkservice.UpdateServiceState(conn, &state); err != nil { glog.Warningf("Could not update service state %s for %s (%s) as out of sync: %s", state.ID, svc.Name, svc.ID, err) continue } } } } return nil }
// ResetRegistry will update the host:port of the docker registry func (dfs *DistributedFilesystem) ResetRegistry() error { // get all the services in the system svcs, err := dfs.facade.GetServices(datastore.Get(), dao.ServiceRequest{}) if err != nil { glog.Errorf("Could not get services for updating the registry") return err } imagemap := make(map[string]struct{}) for _, svc := range svcs { imageID, err := commons.ParseImageID(svc.ImageID) if err != nil { glog.Errorf("Could not parse image ID (%s) for service %s (%s): %s", svc.ImageID, svc.Name, svc.ID, err) return err } if imageID.Host == dfs.dockerHost && imageID.Port == dfs.dockerPort { continue } if _, ok := imagemap[imageID.BaseName()]; !ok { if err := dfs.registerImages(imageID.BaseName()); err != nil { glog.Errorf("Could not reregister image %s: %s", imageID.BaseName(), err) return err } imagemap[imageID.BaseName()] = struct{}{} } imageID.Host, imageID.Port = dfs.dockerHost, dfs.dockerPort svc.ImageID = imageID.String() if err := dfs.facade.UpdateService(datastore.Get(), svc); err != nil { glog.Errorf("Could not update service %s (%s) with image %s", svc.Name, svc.ID, svc.ImageID) return err } } return nil }
func (this *ControlPlaneDao) getPoolBasedConnection(serviceID string) (client.Connection, error) { poolID, err := this.facade.GetPoolForService(datastore.Get(), serviceID) if err != nil { glog.V(2).Infof("ControlPlaneDao.GetPoolForService service=%+v err=%s", serviceID, err) return nil, err } poolBasedConn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(poolID)) if err != nil { glog.Errorf("Error in getting a connection based on pool %v: %v", poolID, err) return nil, err } return poolBasedConn, nil }
//UpdateUser updates the user entry in elastic search. NOTE: It is assumed the //pasword is NOT hashed when updating the user record func (this *ControlPlaneDao) UpdateUser(user userdomain.User, unused *int) error { glog.V(2).Infof("ControlPlaneDao.UpdateUser: %+v", user) id := strings.TrimSpace(user.Name) if id == "" { return errors.New("empty User.Name not allowed") } user.Name = id user.Password = hashPassword(user.Password) store := userdomain.NewStore() return store.Put(datastore.Get(), userdomain.Key(user.Name), &user) }
func (this *ControlPlaneDao) RemoveService(id string, unused *int) error { var tenantID string if err := this.GetTenantId(id, &tenantID); err != nil { glog.Errorf("Could not find tenant for service %s: %s", id, err) return err } if err := this.facade.RemoveService(datastore.Get(), id); err != nil { return err } if tenantID == id { // We're deleting the top-level service, so there may be snapshots if err := this.DeleteSnapshots(id, unused); err != nil { return err } } return nil }
// CloneService clones a service. Return error if given serviceID is not found func (this *ControlPlaneDao) CloneService(request dao.ServiceCloneRequest, clonedServiceId *string) error { svc, err := this.facade.GetService(datastore.Get(), request.ServiceID) if err != nil { glog.Errorf("ControlPlaneDao.CloneService: unable to find service id %+v: %s", request.ServiceID, err) return err } cloned, err := service.CloneService(svc, request.Suffix) if err != nil { glog.Errorf("ControlPlaneDao.CloneService: unable to rename service %+v %v: %s", svc.ID, svc.Name, err) return err } if err := this.AddService(*cloned, clonedServiceId); err != nil { return err } return nil }
func (ft *FacadeTest) TestDaoValidServiceForStart(t *C) { testService := service.Service{ ID: "TestDaoValidServiceForStart_ServiceID", Endpoints: []service.ServiceEndpoint{ service.ServiceEndpoint{ EndpointDefinition: servicedefinition.EndpointDefinition{ Name: "TestDaoValidServiceForStart_EndpointName", Protocol: "tcp", PortNumber: 8081, Application: "websvc", Purpose: "import", }, }, }, } err := ft.Facade.validateServicesForStarting(datastore.Get(), &testService) if err != nil { t.Error("Services failed validation for starting: ", err) } }
// RegisterHealthCheck updates the healthStatus and healthTime structures with a health check result. func RegisterHealthCheck(serviceID string, instanceID string, name string, passed string, f *facade.Facade) { lock.Lock() defer lock.Unlock() serviceStatus, ok := healthStatuses[serviceID] if !ok { serviceStatus = make(map[string]map[string]*domain.HealthCheckStatus) healthStatuses[serviceID] = serviceStatus } instanceStatus, ok := serviceStatus[instanceID] if !ok { instanceStatus = make(map[string]*domain.HealthCheckStatus) serviceStatus[instanceID] = instanceStatus } if name == "__instance_shutdown" { delete(serviceStatus, instanceID) return } thisStatus, ok := instanceStatus[name] if !ok { healthChecks, err := f.GetHealthChecksForService(datastore.Get(), serviceID) if err != nil { glog.Errorf("Unable to acquire health checks: %+v", err) return } for iname, icheck := range healthChecks { _, ok = instanceStatus[iname] if !ok { instanceStatus[iname] = &domain.HealthCheckStatus{name, "unknown", 0, icheck.Interval.Seconds(), time.Now().Unix(), ""} } } } thisStatus, ok = instanceStatus[name] if !ok { glog.Warningf("ignoring %s health status %s, not found in service %s", passed, name, serviceID) return } thisStatus.Status = passed thisStatus.Timestamp = time.Now().UTC().Unix() }
func (this *ControlPlaneDao) StopRunningInstance(request dao.HostServiceRequest, unused *int) error { myHost, err := this.facade.GetHost(datastore.Get(), request.HostID) if err != nil { glog.Errorf("Unable to get host %v: %v", request.HostID, err) return err } if myHost == nil { return fmt.Errorf("Host %s does not exist", request.HostID) } poolBasedConn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(myHost.PoolID)) if err != nil { glog.Errorf("Error in getting a connection based on pool %v: %v", myHost.PoolID, err) return err } if err := zkservice.StopServiceInstance(poolBasedConn, request.HostID, request.ServiceStateID); err != nil { glog.Errorf("zkservice.StopServiceInstance failed (conn: %+v hostID: %v serviceStateID: %v): %v", poolBasedConn, request.HostID, request.ServiceStateID, err) return err } return nil }
func (ft *FacadeTest) TestDaoInvalidServiceForStart(t *C) { testService := service.Service{ ID: "TestDaoInvalidServiceForStart_ServiceID", Endpoints: []service.ServiceEndpoint{ service.ServiceEndpoint{ EndpointDefinition: servicedefinition.EndpointDefinition{ Name: "TestDaoInvalidServiceForStart_EndpointName", Protocol: "tcp", PortNumber: 8081, Application: "websvc", Purpose: "import", AddressConfig: servicedefinition.AddressResourceConfig{ Port: 8081, Protocol: commons.TCP, }, }, }, }, } err := ft.Facade.validateServicesForStarting(datastore.Get(), &testService) if err == nil { t.Error("Services should have failed validation for starting...") } }
func (this *ControlPlaneDao) Action(request dao.AttachRequest, unused *int) error { ctx := datastore.Get() svc, err := this.facade.GetService(ctx, request.Running.ServiceID) if err != nil { return err } var command []string if request.Command == "" { return fmt.Errorf("missing command") } if err := svc.EvaluateActionsTemplate(serviceGetter(ctx, this.facade), childFinder(ctx, this.facade), request.Running.InstanceID); err != nil { return err } action, ok := svc.Actions[request.Command] if !ok { return fmt.Errorf("action not found for service %s: %s", svc.ID, request.Command) } command = append([]string{action}, request.Args...) req := zkdocker.Action{ HostID: request.Running.HostID, DockerID: request.Running.DockerID, Command: command, } conn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(svc.PoolID)) if err != nil { return err } _, err = zkdocker.SendAction(conn, &req) return err }
func (s *S) SetUpTest(c *C) { s.ElasticTest.SetUpTest(c) datastore.Register(s.Driver()) s.ctx = datastore.Get() s.hs = NewStore() }