func restAddAppTemplate(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
// read uploaded file
file, _, err := r.FormFile("tpl")
if err != nil {
restBadRequest(w, err)
return
}
defer file.Close()
var b bytes.Buffer
_, err = io.Copy(&b, file)
template, err := servicetemplate.FromJSON(b.String())
if err != nil {
restServerError(w, err)
return
}
var templateId string
err = client.AddServiceTemplate(*template, &templateId)
if err != nil {
restServerError(w, err)
return
}
w.WriteJson(&simpleResponse{templateId, servicesLinks()})
}
func restDeployAppTemplate(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var payload dao.ServiceTemplateDeploymentRequest
err := r.DecodeJsonPayload(&payload)
if err != nil {
glog.V(1).Info("Could not decode deployment payload: ", err)
restBadRequest(w, err)
return
}
var tenantID string
err = client.DeployTemplate(payload, &tenantID)
if err != nil {
glog.Error("Could not deploy template: ", err)
restServerError(w, err)
return
}
glog.V(0).Info("Deployed template ", payload)
assignmentRequest := dao.AssignmentRequest{tenantID, "", true}
if err := client.AssignIPs(assignmentRequest, nil); err != nil {
glog.Error("Could not automatically assign IPs: %v", err)
return
}
glog.Infof("Automatically assigned IP addresses to service: %v", tenantID)
// end of automatic IP assignment
w.WriteJson(&simpleResponse{tenantID, servicesLinks()})
}
// restStopService stop the service with the given id and all of its children
func restStopService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
restBadRequest(w, err)
return
}
auto := r.FormValue("auto")
autoLaunch := true
switch auto {
case "1", "True", "true":
autoLaunch = true
case "0", "False", "false":
autoLaunch = false
}
var affected int
if err := client.StopService(dao.ScheduleServiceRequest{serviceID, autoLaunch}, &affected); err != nil {
glog.Errorf("Unexpected error stopping service: %s", err)
restServerError(w, err)
return
}
w.WriteJson(&simpleResponse{"Stopped service", serviceLinks(serviceID)})
}
func restGetAllRunning(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var services []dao.RunningService
err := client.GetRunningServices(&empty, &services)
if err != nil {
glog.Errorf("Could not get services: %v", err)
restServerError(w, err)
return
}
if services == nil {
glog.V(3).Info("Services was nil, returning empty list instead")
services = []dao.RunningService{}
}
for ii, rsvc := range services {
var svc service.Service
if err := client.GetService(rsvc.ServiceID, &svc); err != nil {
glog.Errorf("Could not get services: %v", err)
restServerError(w, err)
}
fillBuiltinMetrics(&svc)
services[ii].MonitoringProfile = svc.MonitoringProfile
}
services = append(services, getIRS()...)
glog.V(2).Infof("Return %d running services", len(services))
w.WriteJson(&services)
}
func restGetService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
sid, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
restBadRequest(w, err)
return
}
if strings.Contains(sid, "isvc-") {
w.WriteJson(isvcs.ISVCSMap[sid])
return
}
svc := service.Service{}
if err := client.GetService(sid, &svc); err != nil {
glog.Errorf("Could not get service %v: %v", sid, err)
restServerError(w, err)
return
}
if svc.ID == sid {
fillBuiltinMetrics(&svc)
w.WriteJson(&svc)
return
}
glog.Errorf("No such service [%v]", sid)
restServerError(w, err)
}
func downloadServiceStateLogs(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceStateID, err := url.QueryUnescape(r.PathParam("serviceStateId"))
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(fmt.Sprintf("Bad Request: %v", err)))
return
}
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(fmt.Sprintf("Bad Request: %v", err)))
return
}
request := dao.ServiceStateRequest{serviceID, serviceStateID}
var logs string
err = client.GetServiceStateLogs(request, &logs)
if err != nil {
glog.Errorf("Unexpected error getting service state logs: %v", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(fmt.Sprintf("Internal Server Error: %v", err)))
return
}
var filename = serviceID + time.Now().Format("2006-01-02-15-04-05") + ".log"
w.Header().Set("Content-Disposition", "attachment; filename="+filename)
w.Header().Set("Content-Type", r.Header.Get("Content-Type"))
w.Write([]byte(logs))
}
// RestBackupFileList implements a rest call that will return a list of the current backup files.
// The return value is a JSON struct of type JsonizableFileInfo.
func RestBackupFileList(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var fileData []dao.BackupFile
if err := client.ListBackups("", &fileData); err != nil {
restServerError(w, err)
return
}
w.WriteJson(&fileData)
}
func RestRestoreStatus(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
restoreStatus := ""
err := client.BackupStatus(0, &restoreStatus)
if err != nil {
glog.Errorf("Unexpected error during restore status: %v", err)
writeJSON(w, &simpleResponse{err.Error(), homeLink()}, http.StatusInternalServerError)
return
}
w.WriteJson(&simpleResponse{restoreStatus, servicesLinks()})
}
func RestBackupCreate(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
dir := ""
filePath := ""
err := client.AsyncBackup(dir, &filePath)
if err != nil {
glog.Errorf("Unexpected error during backup: %v", err)
restServerError(w, err)
return
}
w.WriteJson(&simpleResponse{filePath, servicesLinks()})
}
func restDeployAppTemplateActive(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var active []map[string]string
err := client.DeployTemplateActive("", &active)
if err != nil {
glog.Errorf("Unexpected error during template status: %v", err)
writeJSON(w, &simpleResponse{err.Error(), homeLink()}, http.StatusInternalServerError)
return
}
w.WriteJson(&active)
}
func restGetServiceLogs(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
restBadRequest(w, err)
return
}
var logs string
err = client.GetServiceLogs(serviceID, &logs)
if err != nil {
glog.Errorf("Unexpected error getting service logs: %v", err)
restServerError(w, err)
return
}
w.WriteJson(&simpleResponse{logs, serviceLinks(serviceID)})
}
func restSnapshotService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
restBadRequest(w, err)
return
}
var label string
err = client.Snapshot(serviceID, &label)
if err != nil {
glog.Errorf("Unexpected error snapshotting service: %v", err)
restServerError(w, err)
return
}
w.WriteJson(&simpleResponse{label, serviceLinks(serviceID)})
}
func getNamedServices(client *node.ControlClient, nmregex string, tenantID string) ([]service.Service, error) {
services := []service.Service{}
var emptySlice []string
serviceRequest := dao.ServiceRequest{
Tags: emptySlice,
TenantID: tenantID,
NameRegex: nmregex,
}
if err := client.GetServices(serviceRequest, &services); err != nil {
glog.Errorf("Could not get named services: %v", err)
return nil, err
}
return services, nil
}
func getTaggedServices(client *node.ControlClient, tags, nmregex string, tenantID string) ([]service.Service, error) {
services := []service.Service{}
tagsSlice := strings.Split(tags, ",")
serviceRequest := dao.ServiceRequest{
Tags: tagsSlice,
TenantID: tenantID,
NameRegex: nmregex,
}
if err := client.GetTaggedServices(serviceRequest, &services); err != nil {
glog.Errorf("Could not get tagged services: %v", err)
return nil, err
}
glog.V(2).Infof("Returning %d tagged services", len(services))
return services, nil
}
func restRemoveService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var unused int
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
restBadRequest(w, err)
return
}
err = client.RemoveService(serviceID, &unused)
if err != nil {
glog.Errorf("Could not remove service: %v", err)
restServerError(w, err)
return
}
glog.V(0).Info("Removed service ", serviceID)
w.WriteJson(&simpleResponse{"Removed service", servicesLinks()})
}
// restServiceAutomaticAssignIP rest resource for automatic assigning ips to a service
func restServiceAutomaticAssignIP(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
glog.Errorf("Could not get serviceId: %v", err)
restBadRequest(w, err)
return
}
request := dao.AssignmentRequest{ServiceID: serviceID, IPAddress: "", AutoAssignment: true}
if err := client.AssignIPs(request, nil); err != nil {
glog.Error("Failed to automatically assign IPs: %+v -> %v", request, err)
restServerError(w, err)
return
}
restSuccess(w)
}
func getServices(client *node.ControlClient, tenantID string, since time.Duration) ([]service.Service, error) {
services := []service.Service{}
var emptySlice []string
serviceRequest := dao.ServiceRequest{
Tags: emptySlice,
TenantID: tenantID,
UpdatedSince: since,
NameRegex: "",
}
if err := client.GetServices(serviceRequest, &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
}
// restRemoveVirtualHost removes a vhost name from provided service and endpoint. Parameters are defined in path.
func restRemoveVirtualHost(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
glog.Errorf("Failed getting serviceId: %v", err)
restBadRequest(w, err)
return
}
application, err := url.QueryUnescape(r.PathParam("application"))
if err != nil {
glog.Errorf("Failed getting application: %v", err)
restBadRequest(w, err)
return
}
hostname, err := url.QueryUnescape(r.PathParam("name"))
if err != nil {
glog.Errorf("Failed getting hostname: %v", err)
restBadRequest(w, err)
return
}
var service service.Service
err = client.GetService(serviceID, &service)
if err != nil {
glog.Errorf("Unexpected error getting service (%s): %v", serviceID, err)
restServerError(w, err)
return
}
err = service.RemoveVirtualHost(application, hostname)
if err != nil {
glog.Errorf("Unexpected error removing vhost, %s, from service (%s): %v", hostname, serviceID, err)
restServerError(w, err)
return
}
var unused int
err = client.UpdateService(service, &unused)
if err != nil {
glog.Errorf("Unexpected error removing vhost, %s, from service (%s): %v", hostname, serviceID, err)
restServerError(w, err)
return
}
restSuccess(w)
}
func cpValidateLogin(creds *login, client *node.ControlClient) bool {
glog.V(0).Infof("Attempting to validate user %v against the control center api", creds.Username)
// create a client
user := userdomain.User{
Name: creds.Username,
Password: creds.Password,
}
// call validate token on it
var result bool
err := client.ValidateCredentials(user, &result)
if err != nil {
glog.Errorf("Unable to validate credentials %s", err)
}
return result
}
func restDeployAppTemplateStatus(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var payload dao.ServiceTemplateDeploymentRequest
err := r.DecodeJsonPayload(&payload)
if err != nil {
glog.V(1).Info("Could not decode deployment payload: ", err)
restBadRequest(w, err)
return
}
status := ""
err = client.DeployTemplateStatus(payload, &status)
if err != nil {
glog.Errorf("Unexpected error during template status: %v", err)
writeJSON(w, &simpleResponse{err.Error(), homeLink()}, http.StatusInternalServerError)
return
}
w.WriteJson(&simpleResponse{status, servicesLinks()})
}
func restRemoveAppTemplate(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
templateID, err := url.QueryUnescape(r.PathParam("templateId"))
var unused int
if err != nil {
restBadRequest(w, err)
return
}
err = client.RemoveServiceTemplate(templateID, &unused)
if err != nil {
restServerError(w, err)
return
}
w.WriteJson(&simpleResponse{templateID, servicesLinks()})
}
func RestBackupRestore(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
err := r.ParseForm()
filePath := r.FormValue("filename")
if err != nil || filePath == "" {
restBadRequest(w, err)
return
}
unused := 0
err = client.AsyncRestore(filePath, &unused)
if err != nil {
glog.Errorf("Unexpected error during restore: %v", err)
restServerError(w, err)
return
}
w.WriteJson(&simpleResponse{string(unused), servicesLinks()})
}
func restGetTopServices(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var allServices []service.Service
topServices := []service.Service{}
var serviceRequest dao.ServiceRequest
err := client.GetServices(serviceRequest, &allServices)
if err != nil {
glog.Errorf("Could not get services: %v", err)
restServerError(w, err)
return
}
for _, service := range allServices {
if len(service.ParentServiceID) == 0 {
topServices = append(topServices, service)
}
}
topServices = append(topServices, isvcs.InternalServicesISVC)
glog.V(2).Infof("Returning %d services as top services", len(topServices))
w.WriteJson(&topServices)
}
// restGetVirtualHosts gets all services, then extracts all vhost information and returns it.
func restGetVirtualHosts(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var services []service.Service
var serviceRequest dao.ServiceRequest
err := client.GetServices(serviceRequest, &services)
if err != nil {
glog.Errorf("Unexpected error retrieving virtual hosts: %v", err)
restServerError(w, err)
return
}
serviceTree := make(map[string]service.Service)
for _, service := range services {
serviceTree[service.ID] = service
}
vhosts := make([]virtualHost, 0)
for _, service := range services {
if service.Endpoints == nil {
continue
}
for _, endpoint := range service.Endpoints {
if len(endpoint.VHosts) > 0 {
parent, _ := serviceTree[service.ParentServiceID]
for ; len(parent.ParentServiceID) != 0; parent, _ = serviceTree[parent.ParentServiceID] {
}
for _, vhost := range endpoint.VHosts {
vh := virtualHost{
Name: vhost,
Application: parent.Name,
ServiceName: service.Name,
ServiceEndpoint: endpoint.Application,
}
vhosts = append(vhosts, vh)
}
}
}
}
w.WriteJson(&vhosts)
}
func restDeployService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
var payload dao.ServiceDeploymentRequest
err := r.DecodeJsonPayload(&payload)
if err != nil {
glog.V(1).Info("Could not decode service payload: ", err)
restBadRequest(w, err)
return
}
var serviceID string
err = client.DeployService(payload, &serviceID)
if err != nil {
glog.Errorf("Unable to deploy service: %v", err)
restServerError(w, err)
return
}
glog.V(0).Info("Deployed service ", serviceID)
w.WriteJson(&simpleResponse{"Deployed service", serviceLinks(serviceID)})
}
func restGetRunningForHost(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
hostID, err := url.QueryUnescape(r.PathParam("hostId"))
if err != nil {
restBadRequest(w, err)
return
}
var services []dao.RunningService
err = client.GetRunningServicesForHost(hostID, &services)
if err != nil {
glog.Errorf("Could not get services: %v", err)
restServerError(w, err)
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 host %s", len(services), hostID)
w.WriteJson(&services)
}
func restGetRunningService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceStateID, err := url.QueryUnescape(r.PathParam("serviceStateId"))
if err != nil {
restBadRequest(w, err)
return
}
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if err != nil {
restBadRequest(w, err)
return
}
request := dao.ServiceStateRequest{serviceID, serviceStateID}
var running dao.RunningService
err = client.GetRunningService(request, &running)
if err != nil {
glog.Errorf("Unexpected error retrieving services: %v", err)
restServerError(w, err)
return
}
w.WriteJson(running)
}
func restGetStatusForService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
if strings.Contains(serviceID, "isvc-") {
w.WriteJson([]dao.RunningService{})
return
}
if err != nil {
restBadRequest(w, err)
return
}
var statusmap map[string]dao.ServiceStatus
err = client.GetServiceStatus(serviceID, &statusmap)
if err != nil {
glog.Errorf("Could not get status for service %s: %v", serviceID, err)
restServerError(w, err)
return
}
if statusmap == nil {
glog.V(3).Info("Running services was nil, returning empty map instead")
statusmap = map[string]dao.ServiceStatus{}
}
glog.V(2).Infof("Returning %d states for service %s", len(statusmap), serviceID)
w.WriteJson(&statusmap)
}
func restKillRunning(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceStateID, err := url.QueryUnescape(r.PathParam("serviceStateId"))
if err != nil {
restBadRequest(w, err)
return
}
hostID, err := url.QueryUnescape(r.PathParam("hostId"))
if err != nil {
restBadRequest(w, err)
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, err)
return
}
w.WriteJson(&simpleResponse{"Marked for death", servicesLinks()})
}
func restUpdateService(w *rest.ResponseWriter, r *rest.Request, client *node.ControlClient) {
serviceID, err := url.QueryUnescape(r.PathParam("serviceId"))
glog.V(3).Infof("Received update request for %s", serviceID)
if err != nil {
restBadRequest(w, err)
return
}
var payload service.Service
var unused int
err = r.DecodeJsonPayload(&payload)
if err != nil {
glog.V(1).Info("Could not decode service payload: ", err)
restBadRequest(w, err)
return
}
err = client.UpdateService(payload, &unused)
if err != nil {
glog.Errorf("Unable to update service %s: %v", serviceID, err)
restServerError(w, err)
return
}
glog.V(1).Info("Updated service ", serviceID)
w.WriteJson(&simpleResponse{"Updated service", serviceLinks(serviceID)})
}