func RestGetService(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var allServices []*dao.Service if err := client.GetServices(&empty, &allServices); err != nil { glog.Errorf("Could not get services: %v", err) RestServerError(w) return } sid, err := url.QueryUnescape(r.PathParam("serviceId")) if err != nil { RestBadRequest(w) return } for _, service := range allServices { if service.Id == sid { w.WriteJson(&service) return } } glog.Errorf("No such service [%v]", sid) RestServerError(w) }
func getNamedServices(client *serviced.ControlClient, nmregex string) ([]*dao.Service, error) { services := []*dao.Service{} if err := client.GetServices(&empty, &services); err != nil { glog.Errorf("Could not get named services: %v", err) return nil, err } return filterByNameRegex(nmregex, services) }
func RestGetPools(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var poolsMap map[string]*dao.ResourcePool err := client.GetResourcePools(&empty, &poolsMap) if err != nil { glog.Error("Could not get resource pools: ", err) RestServerError(w) return } w.WriteJson(&poolsMap) }
func getServices(client *serviced.ControlClient) ([]*dao.Service, error) { services := []*dao.Service{} if err := client.GetServices(&empty, &services); err != nil { glog.Errorf("Could not get services: %v", err) return nil, err } glog.V(2).Infof("Returning %d services", len(services)) return services, nil }
func RestGetHosts(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var hosts map[string]*dao.Host err := client.GetHosts(&empty, &hosts) if err != nil { glog.Errorf("Could not get hosts: %v", err) RestServerError(w) return } glog.V(2).Infof("Returning %d hosts", len(hosts)) w.WriteJson(&hosts) }
func RestGetServiceLogs(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { serviceId, err := url.QueryUnescape(r.PathParam("serviceId")) if err != nil { RestBadRequest(w) return } var logs string err = client.GetServiceLogs(serviceId, &logs) if err != nil { glog.Errorf("Unexpected error getting logs: %v", err) RestServerError(w) } w.WriteJson(&SimpleResponse{logs, serviceLinks(serviceId)}) }
func getTaggedServices(client *serviced.ControlClient, tags, nmregex string) ([]*dao.Service, error) { services := []*dao.Service{} var ts interface{} ts = strings.Split(tags, ",") if err := client.GetTaggedServices(&ts, &services); err != nil { glog.Errorf("Could not get tagged services: %v", err) return nil, err } if nmregex != "" { return filterByNameRegex(nmregex, services) } glog.V(2).Infof("Returning %d tagged services", len(services)) return services, nil }
func RestGetAllRunning(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var services []*dao.RunningService err := client.GetRunningServices(&empty, &services) if err != nil { glog.Errorf("Could not get services: %v", err) RestServerError(w) return } if services == nil { glog.V(3).Info("Services was nil, returning empty list instead") services = []*dao.RunningService{} } glog.V(2).Infof("Return %d running services", len(services)) w.WriteJson(&services) }
func RestRemovePool(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { poolId, err := url.QueryUnescape(r.PathParam("poolId")) if err != nil { RestBadRequest(w) return } var unused int err = client.RemoveResourcePool(poolId, &unused) if err != nil { glog.Error("Could not remove resource pool: ", err) RestServerError(w) return } glog.V(0).Info("Removed pool ", poolId) w.WriteJson(&SimpleResponse{"Removed resource pool", poolsLinks()}) }
func RestRemoveHost(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var unused int hostId, err := url.QueryUnescape(r.PathParam("hostId")) if err != nil { RestBadRequest(w) return } err = client.RemoveHost(hostId, &unused) if err != nil { glog.Errorf("Could not remove host: %v", err) RestServerError(w) return } glog.V(0).Info("Removed host ", hostId) w.WriteJson(&SimpleResponse{"Removed host", hostsLinks()}) }
func RestAddPool(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var payload dao.ResourcePool var poolId string err := r.DecodeJsonPayload(&payload) if err != nil { glog.V(1).Info("Could not decode pool payload: ", err) RestBadRequest(w) return } err = client.AddResourcePool(payload, &poolId) if err != nil { glog.Error("Unable to add pool: ", err) RestServerError(w) return } glog.V(0).Info("Added pool ", poolId) w.WriteJson(&SimpleResponse{"Added resource pool", poolLinks(poolId)}) }
func RestDeployAppTemplate(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var payload dao.ServiceTemplateDeploymentRequest err := r.DecodeJsonPayload(&payload) if err != nil { glog.V(1).Info("Could not decode deployment payload: ", err) RestBadRequest(w) return } var unused int err = client.DeployTemplate(payload, &unused) if err != nil { glog.Error("Could not deploy template: ", err) RestServerError(w) return } glog.V(0).Info("Deployed template ", payload) w.WriteJson(&SimpleResponse{"Deployed app template", servicesLinks()}) }
func RestGetTopServices(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var allServices []*dao.Service topServices := []*dao.Service{} err := client.GetServices(&empty, &allServices) if err != nil { glog.Errorf("Could not get services: %v", err) RestServerError(w) return } for _, service := range allServices { if len(service.ParentServiceId) == 0 { topServices = append(topServices, service) } } glog.V(2).Infof("Returning %d services as top services", len(topServices)) w.WriteJson(&topServices) }
func RestGetRunningForService(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { serviceId, err := url.QueryUnescape(r.PathParam("serviceId")) if err != nil { RestBadRequest(w) return } var services []*dao.RunningService err = client.GetRunningServicesForService(serviceId, &services) if err != nil { glog.Errorf("Could not get services: %v", err) RestServerError(w) return } if services == nil { glog.V(3).Info("Running services was nil, returning empty list instead") services = []*dao.RunningService{} } glog.V(2).Infof("Returning %d running services for service %s", len(services), serviceId) w.WriteJson(&services) }
func RestGetHostsForResourcePool(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var poolHosts []*dao.PoolHost poolId, err := url.QueryUnescape(r.PathParam("poolId")) if err != nil { glog.V(1).Infof("Unable to acquire pool ID: %v", err) RestBadRequest(w) return } err = client.GetHostsForResourcePool(poolId, &poolHosts) if err != nil { glog.Errorf("Could not get hosts: %v", err) RestServerError(w) return } if poolHosts == nil { glog.V(3).Info("Pool hosts was nil, returning empty list instead") poolHosts = []*dao.PoolHost{} } glog.V(2).Infof("Returning %d hosts for pool %s", len(poolHosts), poolId) w.WriteJson(&poolHosts) }
func RestGetRunningService(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { serviceStateId, err := url.QueryUnescape(r.PathParam("serviceStateId")) if err != nil { RestBadRequest(w) return } serviceId, err := url.QueryUnescape(r.PathParam("serviceId")) if err != nil { RestBadRequest(w) return } request := dao.ServiceStateRequest{serviceId, serviceStateId} var running dao.RunningService err = client.GetRunningService(request, &running) if err != nil { glog.Errorf("Unexpected error getting logs: %v", err) RestServerError(w) } w.WriteJson(running) }
func RestAddHost(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var payload dao.Host var hostId string err := r.DecodeJsonPayload(&payload) if err != nil { glog.V(1).Infof("Could not decode host payload: %v", err) RestBadRequest(w) return } // Save the pool ID and IP address for later. GetInfo wipes these pool := payload.PoolId ipAddr := payload.IpAddr remoteClient, err := serviced.NewAgentClient(payload.IpAddr) if err != nil { glog.Errorf("Could not create connection to host %s: %v", payload.IpAddr, err) RestServerError(w) return } err = remoteClient.GetInfo(0, &payload) if err != nil { glog.Errorf("Unable to get remote host info: %v", err) RestBadRequest(w) return } // Reset the pool ID and IP address payload.PoolId = pool parts := strings.Split(ipAddr, ":") payload.IpAddr = parts[0] err = client.AddHost(payload, &hostId) if err != nil { glog.Errorf("Unable to add host: %v", err) RestServerError(w) return } glog.V(0).Info("Added host ", hostId) w.WriteJson(&SimpleResponse{"Added host", hostLinks(hostId)}) }
func RestUpdatePool(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { poolId, err := url.QueryUnescape(r.PathParam("poolId")) if err != nil { RestBadRequest(w) return } var payload dao.ResourcePool var unused int err = r.DecodeJsonPayload(&payload) if err != nil { glog.V(1).Info("Could not decode pool payload: ", err) RestBadRequest(w) return } err = client.UpdateResourcePool(payload, &unused) if err != nil { glog.Error("Unable to update pool: ", err) RestServerError(w) return } glog.V(1).Info("Updated pool ", poolId) w.WriteJson(&SimpleResponse{"Updated resource pool", poolLinks(poolId)}) }
func RestUpdateHost(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { hostId, err := url.QueryUnescape(r.PathParam("hostId")) if err != nil { RestBadRequest(w) return } glog.V(3).Infof("Received update request for %s", hostId) var payload dao.Host var unused int err = r.DecodeJsonPayload(&payload) if err != nil { glog.V(1).Infof("Could not decode host payload: %v", err) RestBadRequest(w) return } err = client.UpdateHost(payload, &unused) if err != nil { glog.Errorf("Unable to update host: %v", err) RestServerError(w) return } glog.V(1).Info("Updated host ", hostId) w.WriteJson(&SimpleResponse{"Updated host", hostLinks(hostId)}) }
func RestUpdateService(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { serviceId, err := url.QueryUnescape(r.PathParam("serviceId")) glog.V(3).Infof("Received update request for %s", serviceId) if err != nil { RestBadRequest(w) return } var payload dao.Service var unused int err = r.DecodeJsonPayload(&payload) if err != nil { glog.V(1).Info("Could not decode service payload: ", err) RestBadRequest(w) return } err = client.UpdateService(payload, &unused) if err != nil { glog.Errorf("Unable to update service %s: %v", serviceId, err) RestServerError(w) return } glog.V(1).Info("Updated service ", serviceId) w.WriteJson(&SimpleResponse{"Updated service", serviceLinks(serviceId)}) }
func RestKillRunning(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { serviceStateId, err := url.QueryUnescape(r.PathParam("serviceStateId")) if err != nil { RestBadRequest(w) return } hostId, err := url.QueryUnescape(r.PathParam("hostId")) if err != nil { RestBadRequest(w) return } request := dao.HostServiceRequest{hostId, serviceStateId} glog.V(1).Info("Received request to kill ", request) var unused int err = client.StopRunningInstance(request, &unused) if err != nil { glog.Errorf("Unable to stop service: %v", err) RestServerError(w) return } w.WriteJson(&SimpleResponse{"Marked for death", servicesLinks()}) }
func RestAddService(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var payload dao.Service var serviceId string err := r.DecodeJsonPayload(&payload) if err != nil { glog.V(1).Info("Could not decode service payload: ", err) RestBadRequest(w) return } service, err := dao.NewService() if err != nil { glog.Errorf("Could not create service: %v", err) RestServerError(w) return } now := time.Now() service.Name = payload.Name service.Description = payload.Description service.Context = payload.Context service.Tags = payload.Tags service.PoolId = payload.PoolId service.ImageId = payload.ImageId service.Startup = payload.Startup service.Instances = payload.Instances service.ParentServiceId = payload.ParentServiceId service.DesiredState = payload.DesiredState service.Launch = payload.Launch service.Endpoints = payload.Endpoints service.ConfigFiles = payload.ConfigFiles service.Volumes = payload.Volumes service.CreatedAt = now service.UpdatedAt = now //for each endpoint, evaluate it's Application if err = service.EvaluateEndpointTemplates(client); err != nil { glog.Errorf("Unable to evaluate service endpoints: %v", err) RestServerError(w) return } //add the service to the data store err = client.AddService(*service, &serviceId) if err != nil { glog.Errorf("Unable to add service: %v", err) RestServerError(w) return } //deploy the service, in other words start it var unused int sduuid, _ := dao.NewUuid() deployment := dao.ServiceDeployment{sduuid, "", service.Id, now} err = client.AddServiceDeployment(deployment, &unused) if err != nil { glog.Errorf("Unable to add service deployment: %v", err) RestServerError(w) return } glog.V(0).Info("Added service ", serviceId) w.WriteJson(&SimpleResponse{"Added service", serviceLinks(serviceId)}) }
func RestGetAppTemplates(w *rest.ResponseWriter, r *rest.Request, client *serviced.ControlClient) { var unused int var templatesMap map[string]*dao.ServiceTemplate client.GetServiceTemplates(unused, &templatesMap) w.WriteJson(&templatesMap) }