//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
}
