//SetUpSuite is run before the tests to ensure elastic, zookeeper etc. are running. func (dt *DaoTest) SetUpSuite(c *C) { docker.SetUseRegistry(true) dt.Port = 9202 isvcs.Init() isvcs.Mgr.SetVolumesDir("/tmp/serviced-test") esServicedClusterName, _ := utils.NewUUID36() if err := isvcs.Mgr.SetConfigurationOption("elasticsearch-serviced", "cluster", esServicedClusterName); err != nil { c.Fatalf("Could not set elasticsearch-serviced clustername: %s", err) } esLogstashClusterName, _ := utils.NewUUID36() if err := isvcs.Mgr.SetConfigurationOption("elasticsearch-logstash", "cluster", esLogstashClusterName); err != nil { c.Fatalf("Could not set elasticsearch-logstash clustername: %s", err) } isvcs.Mgr.Wipe() if err := isvcs.Mgr.Start(); err != nil { c.Fatalf("Could not start es container: %s", err) } dt.MappingsFile = "controlplane.json" dt.FacadeTest.SetUpSuite(c) dsn := coordzk.NewDSN([]string{"127.0.0.1:2181"}, time.Second*15).String() glog.Infof("zookeeper dsn: %s", dsn) zClient, err := coordclient.New("zookeeper", dsn, "", nil) if err != nil { glog.Fatalf("Could not start es container: %s", err) } zzk.InitializeLocalClient(zClient) dt.zkConn, err = zzk.GetLocalConnection("/") if err != nil { c.Fatalf("could not get zk connection %v", err) } dt.Dao, err = NewControlSvc("localhost", int(dt.Port), dt.Facade, "/tmp", "rsync", 4979, time.Minute*5, "localhost:5000", MockStorageDriver{}) if err != nil { glog.Fatalf("Could not start es container: %s", err) } else { for i := 0; i < 10; i += 1 { id := strconv.Itoa(i) dt.Dao.RemoveService(id, &unused) } for i := 100; i < 110; i += 1 { id := strconv.Itoa(i) dt.Dao.RemoveService(id, &unused) } } }
//CloneService copies a service and mutates id and names func CloneService(fromSvc *Service, suffix string) (*Service, error) { svcuuid, err := utils.NewUUID36() if err != nil { return nil, err } svc := *fromSvc svc.ID = svcuuid svc.DesiredState = int(SVCStop) now := time.Now() svc.CreatedAt = now svc.UpdatedAt = now // add suffix to make certain things unique suffix = strings.TrimSpace(suffix) if len(suffix) == 0 { suffix = "-" + svc.ID[0:12] } svc.Name += suffix for idx, ep := range svc.Endpoints { if ep.Purpose == "export" { svc.Endpoints[idx].Name += suffix svc.Endpoints[idx].Application += suffix svc.Endpoints[idx].ApplicationTemplate += suffix } } for idx := range svc.Volumes { svc.Volumes[idx].ResourcePath += suffix } return &svc, nil }
func (f *Facade) assign(ctx datastore.Context, assignment addressassignment.AddressAssignment) (string, error) { if err := assignment.ValidEntity(); err != nil { return "", err } // Do not add if it already exists if exists, err := f.FindAssignmentByServiceEndpoint(ctx, assignment.ServiceID, assignment.EndpointName); err != nil { return "", err } else if exists != nil { return "", fmt.Errorf("found assignment for %s at %s", assignment.EndpointName, assignment.ServiceID) } // Do not add if already assigned if exists, err := f.FindAssignmentByHostPort(ctx, assignment.IPAddr, assignment.Port); err != nil { return "", err } else if exists != nil { return "", fmt.Errorf("found assignment for port %d at %s", assignment.Port, assignment.IPAddr) } var err error if assignment.ID, err = utils.NewUUID36(); err != nil { return "", err } store := addressassignment.NewStore() if err := store.Put(ctx, addressassignment.Key(assignment.ID), &assignment); err != nil { return "", err } return assignment.ID, nil }
//createSystemUser updates the running instance password as well as the user record in elastic func createSystemUser(s *ControlPlaneDao) error { user := userdomain.User{} err := s.GetUser(SYSTEM_USER_NAME, &user) if err != nil { glog.Warningf("%s", err) glog.V(0).Info("'default' user not found; creating...") // create the system user user := userdomain.User{} user.Name = SYSTEM_USER_NAME userName := SYSTEM_USER_NAME if err := s.AddUser(user, &userName); err != nil { return err } } // update the instance password password, err := utils.NewUUID36() if err != nil { return err } user.Name = SYSTEM_USER_NAME user.Password = password INSTANCE_PASSWORD = password unused := 0 return s.UpdateUser(user, &unused) }
// A new snapshot request instance (SnapshotRequest) func NewSnapshotRequest(serviceId string, snapshotLabel string) (snapshotRequest *SnapshotRequest, err error) { snapshotRequest = &SnapshotRequest{} snapshotRequest.ID, err = utils.NewUUID36() if err == nil { snapshotRequest.ServiceID = serviceId snapshotRequest.SnapshotLabel = snapshotLabel snapshotRequest.SnapshotError = "" } return snapshotRequest, err }
func (d *daemon) getEsClusterName(Type string) string { filename := path.Join(options.VarPath, "isvcs", Type+".clustername") clusterName := "" data, err := ioutil.ReadFile(filename) if err != nil || len(data) <= 0 { clusterName, err = utils.NewUUID36() if err != nil { glog.Fatalf("could not generate uuid: %s", err) } if err := os.MkdirAll(path.Dir(filename), 0770); err != nil { glog.Fatalf("could not create dir %s: %s", path.Dir(filename), err) } if err := ioutil.WriteFile(filename, []byte(clusterName), 0600); err != nil { glog.Fatalf("could not write clustername to %s: %s", filename, err) } } else { clusterName = strings.TrimSpace(string(data)) } return clusterName }
//A new service instance (ServiceState) func BuildFromService(service *service.Service, hostId string) (serviceState *ServiceState, err error) { serviceState = &ServiceState{} serviceState.ID, err = utils.NewUUID36() if err == nil { serviceState.ServiceID = service.ID serviceState.HostID = hostId serviceState.Scheduled = time.Now() serviceState.InSync = true serviceState.Endpoints = service.Endpoints for j, ep := range serviceState.Endpoints { if ep.PortTemplate != "" { port, err := serviceState.evalPortTemplate(ep.PortTemplate) if err != nil { return nil, err } ep.PortNumber = uint16(port) serviceState.Endpoints[j] = ep } } } return serviceState, err }
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)}) }
//BuildService build a service from a ServiceDefinition. func BuildService(sd servicedefinition.ServiceDefinition, parentServiceID string, poolID string, desiredState int, deploymentID string) (*Service, error) { svcuuid, err := utils.NewUUID36() if err != nil { return nil, err } now := time.Now() svc := Service{} svc.ID = svcuuid svc.Name = sd.Name svc.Title = sd.Title svc.Version = sd.Version svc.Context = sd.Context svc.Startup = sd.Command svc.Description = sd.Description svc.Tags = sd.Tags if sd.Instances.Default != 0 { svc.Instances = sd.Instances.Default } else { svc.Instances = sd.Instances.Min } svc.InstanceLimits = sd.Instances svc.ChangeOptions = sd.ChangeOptions svc.ImageID = sd.ImageID svc.PoolID = poolID svc.DesiredState = desiredState svc.Launch = sd.Launch svc.HostPolicy = sd.HostPolicy svc.Hostname = sd.Hostname svc.Privileged = sd.Privileged svc.OriginalConfigs = sd.ConfigFiles svc.ConfigFiles = sd.ConfigFiles svc.Tasks = sd.Tasks svc.ParentServiceID = parentServiceID svc.CreatedAt = now svc.UpdatedAt = now svc.Volumes = sd.Volumes svc.DeploymentID = deploymentID svc.LogConfigs = sd.LogConfigs svc.Snapshot = sd.Snapshot svc.RAMCommitment = sd.RAMCommitment svc.Runs = sd.Runs svc.Actions = sd.Actions svc.HealthChecks = sd.HealthChecks svc.Prereqs = sd.Prereqs svc.PIDFile = sd.PIDFile svc.Endpoints = make([]ServiceEndpoint, 0) for _, ep := range sd.Endpoints { svc.Endpoints = append(svc.Endpoints, ServiceEndpoint{EndpointDefinition: ep}) } tags := map[string][]string{ "controlplane_service_id": []string{svc.ID}, } profile, err := sd.MonitoringProfile.ReBuild("1h-ago", tags) if err != nil { return nil, err } svc.MonitoringProfile = *profile svc.MemoryLimit = sd.MemoryLimit svc.CPUShares = sd.CPUShares return &svc, nil }
// NewService Create a new Service. func NewService() (s *Service, err error) { s = &Service{} s.ID, err = utils.NewUUID36() return s, err }