/*
    * Licensed to The Apereo Foundation under one or more contributor license
    * agreements. See the NOTICE file distributed with this work for additional
    * information regarding copyright ownership.
    *
    *
    * The Apereo Foundation licenses this file to you under the Educational
    * Community License, Version 2.0 (the "License"); you may not use this file
    * except in compliance with the License. You may obtain a copy of the License
   * at:
   *
   *   http://opensource.org/licenses/ecl2.txt
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
   * License for the specific language governing permissions and limitations under
   * the License.
   *
   */
  
  package org.opencastproject.serviceregistry.impl.endpoint;
  
  import static javax.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
  import static javax.servlet.http.HttpServletResponse.SC_CREATED;
  import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
  import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
  import static javax.servlet.http.HttpServletResponse.SC_OK;
  import static javax.servlet.http.HttpServletResponse.SC_SERVICE_UNAVAILABLE;
  import static org.apache.commons.lang3.StringUtils.isBlank;
  import static org.apache.commons.lang3.StringUtils.isNotBlank;
  
  import org.opencastproject.job.api.JaxbJob;
  import org.opencastproject.job.api.JaxbJobList;
  import org.opencastproject.job.api.Job;
  import org.opencastproject.job.api.JobParser;
  import org.opencastproject.rest.RestConstants;
  import org.opencastproject.security.api.SecurityService;
  import org.opencastproject.serviceregistry.api.HostRegistration;
  import org.opencastproject.serviceregistry.api.JaxbHostRegistration;
  import org.opencastproject.serviceregistry.api.JaxbHostRegistrationList;
  import org.opencastproject.serviceregistry.api.JaxbServiceHealth;
  import org.opencastproject.serviceregistry.api.JaxbServiceRegistration;
  import org.opencastproject.serviceregistry.api.JaxbServiceRegistrationList;
  import org.opencastproject.serviceregistry.api.JaxbServiceStatisticsList;
  import org.opencastproject.serviceregistry.api.ServiceRegistration;
  import org.opencastproject.serviceregistry.api.ServiceRegistry;
  import org.opencastproject.serviceregistry.api.ServiceRegistryException;
  import org.opencastproject.serviceregistry.api.ServiceState;
  import org.opencastproject.serviceregistry.api.SystemLoad;
  import org.opencastproject.serviceregistry.impl.ServiceRegistryJpaImpl;
  import org.opencastproject.systems.OpencastConstants;
  import org.opencastproject.util.NotFoundException;
  import org.opencastproject.util.UrlSupport;
  import org.opencastproject.util.doc.rest.RestParameter;
  import org.opencastproject.util.doc.rest.RestParameter.Type;
  import org.opencastproject.util.doc.rest.RestQuery;
  import org.opencastproject.util.doc.rest.RestResponse;
  import org.opencastproject.util.doc.rest.RestService;
  
  import org.apache.commons.lang3.StringUtils;
  import org.json.simple.JSONArray;
  import org.json.simple.JSONValue;
  import org.osgi.service.component.ComponentContext;
  import org.osgi.service.component.annotations.Activate;
  import org.osgi.service.component.annotations.Component;
  import org.osgi.service.component.annotations.Reference;
  import org.osgi.service.jaxrs.whiteboard.propertytypes.JaxrsResource;
  
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.ws.rs.DELETE;
  import javax.ws.rs.FormParam;
  import javax.ws.rs.GET;
  import javax.ws.rs.POST;
  import javax.ws.rs.PUT;
  import javax.ws.rs.Path;
  import javax.ws.rs.PathParam;
  import javax.ws.rs.Produces;
  import javax.ws.rs.QueryParam;
  import javax.ws.rs.WebApplicationException;
  import javax.ws.rs.core.Context;
  import javax.ws.rs.core.MediaType;
  import javax.ws.rs.core.Response;
  import javax.ws.rs.core.Response.Status;
  
  /**
   * Displays hosts and the service IDs they provide.
   */
  @Path("/services")
  @RestService(
     name = "serviceregistry",
     title = "Service Registry",
     notes = { "All paths above are relative to the REST endpoint base" },
     abstractText = "Provides registration and management functions for servers and services in this Opencast instance "
         + "or cluster.")
 @Component(
   property = {
     "service.description=Service Registry REST Endpoint",
     "opencast.service.type=org.opencastproject.serviceregistry",
     "opencast.service.path=/services"
   },
   immediate = true,
   service = { ServiceRegistryEndpoint.class }
 )
 @JaxrsResource
 public class ServiceRegistryEndpoint {
 
   /** The remote service maanger */
   protected ServiceRegistry serviceRegistry = null;
 
   private SecurityService securityService = null;
 
   /** This server's URL */
   protected String serverUrl = UrlSupport.DEFAULT_BASE_URL;
 
   /** The service path for this endpoint */
   protected String servicePath = "/";
 
   /** Sets the service registry instance for delegation */
   @Reference
   public void setServiceRegistry(ServiceRegistry serviceRegistry) {
     this.serviceRegistry = serviceRegistry;
   }
 
   @Reference
   public void setSecurityService(SecurityService securityService) {
     this.securityService = securityService;
   }
 
   /**
    * Callback from OSGi that is called when this service is activated.
    *
    * @param cc
    *          OSGi component context
    */
   @Activate
   public void activate(ComponentContext cc) {
     serverUrl = cc.getBundleContext().getProperty(OpencastConstants.SERVER_URL_PROPERTY);
     servicePath = (String) cc.getProperties().get(RestConstants.SERVICE_PATH_PROPERTY);
   }
 
   @GET
   @Path("statistics.json")
   @Produces(MediaType.APPLICATION_JSON)
   @RestQuery(
       name = "statisticsasjson",
       description = "List the service registrations in the cluster, along with some simple statistics",
       returnDescription = "The service statistics.",
       responses = {
           @RestResponse(responseCode = SC_OK, description = "A JSON representation of the service statistics")
       })
   public Response getStatisticsAsJson() {
     try {
       return Response.ok(new JaxbServiceStatisticsList(serviceRegistry.getServiceStatistics())).build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR);
     }
   }
 
   @GET
   @Path("statistics.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "statisticsasxml",
       description = "List the service registrations in the cluster, along with some simple statistics",
       returnDescription = "The service statistics.",
       responses = {
           @RestResponse(responseCode = SC_OK, description = "An XML representation of the service statistics")
       })
   public Response getStatisticsAsXml() throws ServiceRegistryException {
     return getStatisticsAsJson();
   }
 
   @POST
   @Path("sanitize")
   @RestQuery(
       name = "sanitize",
       description = "Sets the given service to NORMAL state",
       returnDescription = "No content",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = true, description = "The service type identifier",
               type = Type.STRING, defaultValue = ""),
           @RestParameter(name = "host", isRequired = true, description = "The host providing the service, "
               + "including the http(s) protocol", type = Type.STRING, defaultValue = "")
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "The service was successfully sanitized"),
           @RestResponse(responseCode = SC_NOT_FOUND,
               description = "No service of that type on that host is registered.")
       })
   public Response sanitize(@FormParam("serviceType") String serviceType, @FormParam("host") String host)
           throws NotFoundException {
     serviceRegistry.sanitize(serviceType, host);
     return Response.status(Status.NO_CONTENT).build();
   }
 
   @POST
   @Path("register")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "register",
       description = "Add a new service registration to the cluster.",
       returnDescription = "The service registration.",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = true, description = "The service type identifier",
               type = Type.STRING, defaultValue = ""),
           @RestParameter(name = "host", isRequired = true, description = "The host providing the service, "
               + "including the http(s) protocol", type = Type.STRING, defaultValue = ""),
           @RestParameter(name = "path", isRequired = true, description = "The service path on the host",
               type = Type.STRING, defaultValue = ""),
           @RestParameter(name = "jobProducer", isRequired = true, description = "Whether this service is a producer of "
               + "long running jobs requiring dispatch", type = Type.STRING, defaultValue = "false")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "An XML representation of the new service registration")
       })
   public JaxbServiceRegistration register(@FormParam("serviceType") String serviceType, @FormParam("host") String host,
           @FormParam("path") String path, @FormParam("jobProducer") boolean jobProducer) {
     try {
       return new JaxbServiceRegistration(serviceRegistry.registerService(serviceType, host, path, jobProducer));
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @POST
   @Path("unregister")
   @RestQuery(
       name = "unregister",
       description = "Removes a service registration.",
       returnDescription = "No content",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = true, description = "The service type identifier",
               type = Type.STRING),
           @RestParameter(name = "host", isRequired = true, description = "The host providing the service, "
               + "including the http(s) protocol", type = Type.STRING)
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "The service was unregistered successfully")
       })
   public Response unregister(@FormParam("serviceType") String serviceType, @FormParam("host") String host) {
     try {
       serviceRegistry.unRegisterService(serviceType, host);
       return Response.status(Status.NO_CONTENT).build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @POST
   @Path("enablehost")
   @RestQuery(
       name = "enablehost",
       description = "Enable a server from the cluster.",
       returnDescription = "No content.",
       restParameters = {
           @RestParameter(name = "host", isRequired = true,
               description = "The host name, including the http(s) protocol", type = Type.STRING)
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "The host was enabled successfully"),
           @RestResponse(responseCode = SC_NOT_FOUND, description = "The host does not exist")
       })
   public Response enableHost(@FormParam("host") String host) throws NotFoundException {
     try {
       serviceRegistry.enableHost(host);
       return Response.status(Status.NO_CONTENT).build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @POST
   @Path("disablehost")
   @RestQuery(
       name = "disablehost",
       description = "Disable a server from the cluster.",
       returnDescription = "No content.",
       restParameters = {
           @RestParameter(name = "host", isRequired = true,
               description = "The host name, including the http(s) protocol", type = Type.STRING)
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "The host was disabled successfully"),
           @RestResponse(responseCode = SC_NOT_FOUND, description = "The host does not exist")
       })
   public Response disableHost(@FormParam("host") String host) throws NotFoundException {
     try {
       serviceRegistry.disableHost(host);
       return Response.status(Status.NO_CONTENT).build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @POST
   @Path("registerhost")
   @RestQuery(
       name = "registerhost",
       description = "Add a new server to the cluster.",
       returnDescription = "No content.",
       restParameters = {
           @RestParameter(name = "host", isRequired = true,
               description = "The host name, including the http(s) protocol", type = Type.STRING),
           @RestParameter(name = "address", isRequired = true, description = "The IP address", type = Type.STRING),
           @RestParameter(name = "nodeName", isRequired = true,
               description = "Descriptive node name", type = Type.STRING),
           @RestParameter(name = "memory", isRequired = true, description = "The allocated memory", type = Type.STRING),
           @RestParameter(name = "cores", isRequired = true, description = "The available cores", type = Type.STRING),
           @RestParameter(name = "maxLoad", isRequired = true, description = "The maximum load this host support",
               type = Type.STRING)
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "The host was registered successfully")
       })
   public void register(@FormParam("host") String host, @FormParam("address") String address,
           @FormParam("nodeName") String nodeName, @FormParam("memory") long memory, @FormParam("cores") int cores,
           @FormParam("maxLoad") float maxLoad) {
     try {
       serviceRegistry.registerHost(host, address, nodeName, memory, cores, maxLoad);
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @POST
   @Path("unregisterhost")
   @RestQuery(
       name = "unregisterhost",
       description = "Removes a server from the cluster.",
       returnDescription = "No content.",
       restParameters = {
         @RestParameter(name = "host", isRequired = true, description = "The host name, including the http(s) protocol",
             type = Type.STRING)
       },
       responses = {
         @RestResponse(responseCode = SC_NO_CONTENT, description = "The host was removed successfully")
       })
   public Response unregister(@FormParam("host") String host) {
     try {
       serviceRegistry.unregisterHost(host);
       return Response.status(Status.NO_CONTENT).build();
     } catch (ServiceRegistryException e) {
       if (e.getCause() instanceof IllegalArgumentException) {
         return Response.status(Status.NOT_FOUND).entity(e.getMessage()).build();
       }
       throw new WebApplicationException(e);
     }
   }
 
   @POST
   @Path("maintenance")
   @RestQuery(
       name = "maintenance",
       description = "Sets the maintenance status for a server in the cluster.",
       returnDescription = "No content.",
       restParameters = {
           @RestParameter(name = "host", isRequired = true, type = Type.STRING,
               description = "The host name, including the http(s) protocol"),
           @RestParameter(name = "maintenance", isRequired = true, type = Type.BOOLEAN,
               description = "Whether this host should be put into maintenance mode (true) or not")
       }, responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "The host was registered successfully"),
           @RestResponse(responseCode = SC_NOT_FOUND, description = "Host not found")
       })
   public Response setMaintenanceMode(@FormParam("host") String host, @FormParam("maintenance") boolean maintenance)
           throws NotFoundException {
     try {
       serviceRegistry.setMaintenanceStatus(host, maintenance);
       return Response.status(Status.NO_CONTENT).build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("available.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "availableasxml",
       description = "Lists available services by service type identifier, ordered by load.",
       returnDescription = "The services list as XML",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = false, type = Type.STRING,
               description = "The service type identifier")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Returned the available services."),
           @RestResponse(responseCode = SC_BAD_REQUEST, description = "No service type specified, bad request.")
       })
   public Response getAvailableServicesAsXml(@QueryParam("serviceType") String serviceType) {
 
     if (isBlank(serviceType)) {
       throw new WebApplicationException(
           Response.status(Status.BAD_REQUEST).entity("Service type must be specified").build());
     }
 
     Map<String, String> properties = securityService.getOrganization().getProperties();
 
     JaxbServiceRegistrationList registrations = new JaxbServiceRegistrationList();
     try {
       for (ServiceRegistration reg : serviceRegistry.getServiceRegistrationsByLoad(serviceType)) {
         JaxbServiceRegistration jaxbReg = new JaxbServiceRegistration(reg);
         URL internalHostUrl = new URL(jaxbReg.getHost());
         String tenantSpecificHost = StringUtils.trimToNull(properties.get("org.opencastproject.host."
             + internalHostUrl.getHost()));
         if (StringUtils.isNotBlank(tenantSpecificHost)) {
           jaxbReg.setHost(tenantSpecificHost);
         }
         registrations.add(jaxbReg);
       }
       return Response.ok(registrations).build();
     } catch (ServiceRegistryException | MalformedURLException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("available.json")
   @Produces(MediaType.APPLICATION_JSON)
   @RestQuery(
       name = "availableasjson",
       description = "Lists available services by service type identifier, ordered by load.",
       returnDescription = "The services list as JSON",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = false, type = Type.STRING,
               description = "The service type identifier")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Returned the available services."),
           @RestResponse(responseCode = SC_BAD_REQUEST, description = "No service type specified, bad request.")
       })
   public Response getAvailableServicesAsJson(@QueryParam("serviceType") String serviceType) {
     return getAvailableServicesAsXml(serviceType);
   }
 
   @GET
   @Path("health.json")
   @Produces(MediaType.APPLICATION_JSON)
   @RestQuery(
       name = "health",
       description = "Checks the status of the registered services",
       returnDescription = "Returns NO_CONTENT if services are in a proper state",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = false, type = Type.STRING,
               description = "The service type identifier"),
           @RestParameter(name = "host", isRequired = false, type = Type.STRING,
               description = "The host, including the http(s) protocol")
       }, responses = {
           @RestResponse(responseCode = SC_OK, description = "Service states returned"),
           @RestResponse(responseCode = SC_NOT_FOUND,
               description = "No service of that type on that host is registered."),
           @RestResponse(responseCode = SC_SERVICE_UNAVAILABLE,
               description = "An error has occurred during stats processing")
       })
   public Response getHealthStatusAsJson(@QueryParam("serviceType") String serviceType, @QueryParam("host") String host)
           throws NotFoundException {
     return getHealthStatus(serviceType, host);
   }
 
   @GET
   @Path("health.xml")
   @Produces(MediaType.APPLICATION_XML)
   @RestQuery(
       name = "health",
       description = "Checks the status of the registered services",
       returnDescription = "Returns NO_CONTENT if services are in a proper state",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = false, type = Type.STRING,
               description = "The service type identifier"),
           @RestParameter(name = "host", isRequired = false, type = Type.STRING,
               description = "The host, including the http(s) protocol")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Service states returned"),
           @RestResponse(responseCode = SC_NOT_FOUND,
               description = "No service of that type on that host is registered."),
           @RestResponse(responseCode = SC_SERVICE_UNAVAILABLE,
               description = "An error has occurred during stats processing")
       })
   public Response getHealthStatus(@QueryParam("serviceType") String serviceType, @QueryParam("host") String host)
           throws NotFoundException {
     try {
       List<ServiceRegistration> services = null;
       if (isNotBlank(serviceType) && isNotBlank(host)) {
         // This is a request for one specific service. Return it, or SC_NOT_FOUND if not found
         ServiceRegistration reg = serviceRegistry.getServiceRegistration(serviceType, host);
         if (reg == null) {
           throw new NotFoundException();
         }
 
         services = new LinkedList<ServiceRegistration>();
         services.add(reg);
       } else if (isBlank(serviceType) && isBlank(host)) {
         // This is a request for all service registrations
         services = serviceRegistry.getServiceRegistrations();
       } else if (isNotBlank(serviceType)) {
         // This is a request for all service registrations of a particular type
         services = serviceRegistry.getServiceRegistrationsByType(serviceType);
       } else if (isNotBlank(host)) {
         // This is a request for all service registrations of a particular host
         services = serviceRegistry.getServiceRegistrationsByHost(host);
       }
 
       int healthy = 0;
       int warning = 0;
       int error = 0;
       for (ServiceRegistration reg : services) {
         if (ServiceState.NORMAL == reg.getServiceState()) {
           healthy++;
         } else if (ServiceState.WARNING == reg.getServiceState()) {
           warning++;
         } else if (ServiceState.ERROR == reg.getServiceState()) {
           error++;
         } else {
            error++;
         }
       }
       JaxbServiceHealth stats = new JaxbServiceHealth(healthy, warning, error);
       return Response.ok(stats).build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("services.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "servicesasxml",
       description = "Returns a service registraton or list of available service registrations as XML.",
       returnDescription = "The services list as XML",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = false, type = Type.STRING,
               description = "The service type identifier"),
           @RestParameter(name = "host", isRequired = false, type = Type.STRING,
               description = "The host, including the http(s) protocol")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Returned the available service."),
           @RestResponse(responseCode = SC_NOT_FOUND,
               description = "No service of that type on that host is registered.")
       })
   public JaxbServiceRegistrationList getRegistrationsAsXml(@QueryParam("serviceType") String serviceType,
           @QueryParam("host") String host) throws NotFoundException {
     JaxbServiceRegistrationList registrations = new JaxbServiceRegistrationList();
     try {
       if (isNotBlank(serviceType) && isNotBlank(host)) {
         // This is a request for one specific service. Return it, or SC_NOT_FOUND if not found
         ServiceRegistration reg = serviceRegistry.getServiceRegistration(serviceType, host);
         if (reg == null) {
           throw new NotFoundException();
         } else {
           return new JaxbServiceRegistrationList(new JaxbServiceRegistration(reg));
         }
       } else if (isBlank(serviceType) && isBlank(host)) {
         // This is a request for all service registrations
         for (ServiceRegistration reg : serviceRegistry.getServiceRegistrations()) {
           registrations.add(new JaxbServiceRegistration(reg));
         }
       } else if (isNotBlank(serviceType)) {
         // This is a request for all service registrations of a particular type
         for (ServiceRegistration reg : serviceRegistry.getServiceRegistrationsByType(serviceType)) {
           registrations.add(new JaxbServiceRegistration(reg));
         }
       } else if (isNotBlank(host)) {
         // This is a request for all service registrations of a particular host
         for (ServiceRegistration reg : serviceRegistry.getServiceRegistrationsByHost(host)) {
           registrations.add(new JaxbServiceRegistration(reg));
         }
       }
       return registrations;
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("services.json")
   @Produces(MediaType.APPLICATION_JSON)
   @RestQuery(
       name = "servicesasjson",
       description = "Returns a service registraton or list of available service registrations as JSON.",
       returnDescription = "The services list as XML",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = false, type = Type.STRING,
               description = "The service type identifier"),
           @RestParameter(name = "host", isRequired = false, type = Type.STRING,
               description = "The host, including the http(s) protocol")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Returned the available service."),
           @RestResponse(responseCode = SC_NOT_FOUND,
               description = "No service of that type on that host is registered.")
       })
   public JaxbServiceRegistrationList getRegistrationsAsJson(@QueryParam("serviceType") String serviceType,
           @QueryParam("host") String host) throws NotFoundException {
     return getRegistrationsAsXml(serviceType, host);
   }
 
   @GET
   @Path("hosts.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "hostsasxml",
       description = "Returns a host registraton or list of available host registrations as XML.",
       returnDescription = "The host list as XML",
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Returned the available hosts.")
       })
   public JaxbHostRegistrationList getHostsAsXml() throws NotFoundException {
     JaxbHostRegistrationList registrations = new JaxbHostRegistrationList();
     try {
       for (HostRegistration reg : serviceRegistry.getHostRegistrations()) {
         registrations.add(new JaxbHostRegistration(reg));
       }
       return registrations;
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("hosts.json")
   @Produces(MediaType.APPLICATION_JSON)
   @RestQuery(
       name = "hostsasjson",
       description = "Returns a host registraton or list of available host registrations as JSON.",
       returnDescription = "The host list as JSON",
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Returned the available hosts.")
       })
   public JaxbHostRegistrationList getHostsAsJson() throws NotFoundException {
     return getHostsAsXml();
   }
 
   @POST
   @Path("job")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "createjob",
       description = "Creates a new job.",
       returnDescription = "An XML representation of the job.",
       restParameters = {
           @RestParameter(name = "jobType", isRequired = true, type = Type.STRING,
               description = "The job type identifier"),
           @RestParameter(name = "host", isRequired = true, type = Type.STRING,
               description = "The creating host, including the http(s) protocol"),
           @RestParameter(name = "operation", isRequired = true, type = Type.STRING,
               description = "The operation this job should execute"),
           @RestParameter(name = "payload", isRequired = false, type = Type.TEXT,
               description = "The job type identifier"),
           @RestParameter(name = "start", isRequired = false, type = Type.BOOLEAN,
               description = "Whether the job should be queued for dispatch and execution"),
           @RestParameter(name = "jobLoad", isRequired = false, type = Type.STRING,
               description = "The load this job will incur on the system"),
           @RestParameter(name = "arg", isRequired = false, type = Type.TEXT,
               description = "An argument for the operation"),
           @RestParameter(name = "arg", isRequired = false, type = Type.TEXT,
               description = "An argument for the operation"),
           @RestParameter(name = "arg", isRequired = false, type = Type.TEXT,
               description = "An argument for the operation"),
           @RestParameter(name = "arg", isRequired = false, type = Type.TEXT,
               description = "An argument for the operation"),
           @RestParameter(name = "arg", isRequired = false, type = Type.TEXT,
               description = "An argument for the operation")
       },
       responses = {
           @RestResponse(responseCode = SC_CREATED, description = "Job created."),
           @RestResponse(responseCode = SC_BAD_REQUEST,
               description = "The required parameters were not supplied, bad request.")
       })
   public Response createJob(@Context HttpServletRequest request) {
     String[] argArray = request.getParameterValues("arg");
     List<String> arguments = null;
     if (argArray != null && argArray.length > 0) {
       arguments = Arrays.asList(argArray);
     }
     String jobType = request.getParameter("jobType");
     String operation = request.getParameter("operation");
     String host = request.getParameter("host");
     String payload = request.getParameter("payload");
     boolean start = StringUtils.isBlank(request.getParameter("start"))
             || Boolean.TRUE.toString().equalsIgnoreCase(request.getParameter("start"));
     try {
       Job job = null;
       if (StringUtils.isNotBlank(request.getParameter("jobLoad"))) {
         Float jobLoad = Float.parseFloat(request.getParameter("jobLoad"));
         job = ((ServiceRegistryJpaImpl) serviceRegistry).createJob(host, jobType, operation, arguments, payload,
               start, serviceRegistry.getCurrentJob(), jobLoad);
       } else {
         job = ((ServiceRegistryJpaImpl) serviceRegistry).createJob(host, jobType, operation, arguments, payload,
                 start, serviceRegistry.getCurrentJob());
       }
       return Response.created(job.getUri()).entity(new JaxbJob(job)).build();
     } catch (IllegalArgumentException e) {
       throw new WebApplicationException(Status.BAD_REQUEST);
     } catch (Exception e) {
       throw new WebApplicationException(e);
     }
   }
 
   @PUT
   @Path("job/{id}.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "updatejob",
       description = "Updates an existing job",
       returnDescription = "No content",
       pathParameters = {
           @RestParameter(name = "id", isRequired = true, type = Type.STRING, description = "The job identifier")
       },
       restParameters = {
           @RestParameter(name = "job", isRequired = true, type = Type.TEXT, description = "The updated job as XML")
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "Job updated."),
           @RestResponse(responseCode = SC_NOT_FOUND, description = "Job not found.")
       })
   public Response updateJob(@PathParam("id") String id, @FormParam("job") String jobXml) throws NotFoundException {
     try {
       Job job = JobParser.parseJob(jobXml);
       serviceRegistry.updateJob(job);
       return Response.status(Status.NO_CONTENT).build();
     } catch (Exception e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("job/{id}.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "jobasxml",
       description = "Returns a job as XML.",
       returnDescription = "The job as XML",
       pathParameters = {
           @RestParameter(name = "id", isRequired = true, type = Type.STRING, description = "The job identifier")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Job found."),
           @RestResponse(responseCode = SC_NOT_FOUND, description = "No job with that identifier exists.")
       })
   public JaxbJob getJobAsXml(@PathParam("id") long id) throws NotFoundException {
     return getJobAsJson(id);
   }
 
   @GET
   @Path("job/{id}.json")
   @Produces(MediaType.APPLICATION_JSON)
   @RestQuery(
       name = "jobasjson",
       description = "Returns a job as JSON.",
       returnDescription = "The job as JSON",
       pathParameters = {
           @RestParameter(name = "id", isRequired = true, type = Type.STRING, description = "The job identifier")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Job found."),
           @RestResponse(responseCode = SC_NOT_FOUND, description = "No job with that identifier exists.")
       })
   public JaxbJob getJobAsJson(@PathParam("id") long id) throws NotFoundException {
     try {
       return new JaxbJob(serviceRegistry.getJob(id));
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("job/{id}/children.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "childrenjobsasxml",
       description = "Returns all children from a job as XML.",
       returnDescription = "A list of children jobs as XML",
       pathParameters = {
           @RestParameter(name = "id", isRequired = true, type = Type.STRING, description = "The parent job identifier")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Jobs found.")
       })
   public JaxbJobList getChildrenJobsAsXml(@PathParam("id") long id) {
     return getChildrenJobsAsJson(id);
   }
 
   @GET
   @Path("job/{id}/children.json")
   @Produces(MediaType.APPLICATION_JSON)
   @RestQuery(
       name = "childrenjobsasjson",
       description = "Returns all children from a job as JSON.",
       returnDescription = "A list of children jobs as JSON",
       pathParameters = {
           @RestParameter(name = "id", isRequired = true, type = Type.STRING, description = "The parent job identifier")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Jobs found.")
       })
   public JaxbJobList getChildrenJobsAsJson(@PathParam("id") long id) {
     try {
       return new JaxbJobList(serviceRegistry.getChildJobs(id));
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("jobs.xml")
   @Produces(MediaType.TEXT_XML)
   public JaxbJobList getJobsAsXml(@QueryParam("serviceType") String serviceType,
       @QueryParam("status") Job.Status status) {
     try {
       return new JaxbJobList(serviceRegistry.getJobs(serviceType, status));
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
 
   }
 
   @GET
   @Path("activeJobs.xml")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "activejobsasxml",
       description = "Returns all active jobs as XML.",
       returnDescription = "A list of active jobs as XML",
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Active jobs found.")
       })
   public JaxbJobList getActiveJobsAsXml() {
     try {
       return new JaxbJobList(serviceRegistry.getActiveJobs());
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("activeJobs.json")
   @Produces(MediaType.APPLICATION_JSON)
   @RestQuery(
       name = "activejobsasjson",
       description = "Returns all active jobs as JSON.",
       returnDescription = "A list of active jobs as JSON",
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Active jobs found.")
       })
   public JaxbJobList getActiveJobsAsJson() {
     try {
       return new JaxbJobList(serviceRegistry.getActiveJobs());
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("count")
   @Produces(MediaType.TEXT_PLAIN)
   @RestQuery(
       name = "count",
       description = "Returns the number of jobs matching the query parameters as plain text.",
       returnDescription = "The number of matching jobs",
       restParameters = {
           @RestParameter(name = "serviceType", isRequired = false, type = Type.STRING,
               description = "The service type identifier"),
           @RestParameter(name = "status", isRequired = false, type = Type.STRING, description = "The job status"),
           @RestParameter(name = "host", isRequired = false, type = Type.STRING,
               description = "The host executing the job"),
           @RestParameter(name = "operation", isRequired = false, type = Type.STRING,
               description = "The job's operation")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Job count returned.")
       })
   public long count(@QueryParam("serviceType") String serviceType, @QueryParam("status") Job.Status status,
           @QueryParam("host") String host, @QueryParam("operation") String operation) {
     try {
       if (isNotBlank(host) && isNotBlank(operation)) {
         if (isBlank(serviceType)) {
           throw new WebApplicationException(Response.serverError().entity("Service type must not be null").build());
         }
         return serviceRegistry.count(serviceType, host, operation, status);
       } else if (isNotBlank(host)) {
         if (isBlank(serviceType)) {
           throw new WebApplicationException(Response.serverError().entity("Service type must not be null").build());
         }
         return serviceRegistry.countByHost(serviceType, host, status);
       } else if (isNotBlank(operation)) {
         if (isBlank(serviceType)) {
           throw new WebApplicationException(Response.serverError().entity("Service type must not be null").build());
         }
         return serviceRegistry.countByOperation(serviceType, operation, status);
       } else {
         return serviceRegistry.count(serviceType, status);
       }
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("maxconcurrentjobs")
   @Produces(MediaType.TEXT_PLAIN)
   @RestQuery(
       name = "maxconcurrentjobs",
       description = "Returns the number of jobs that the servers in this service registry can execute concurrently. "
           + "If there is only one server in this service registry this will be the number of jobs that one server is "
           + "able to do at one time. If it is a distributed install across many servers then this number will be the "
           + "total number of jobs the cluster can process concurrently.",
       returnDescription = "The maximum number of concurrent jobs",
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Maximum number of concurrent jobs returned.")
       })
   @Deprecated
   public Response getMaximumConcurrentWorkflows() {
     return Response.status(Status.MOVED_PERMANENTLY).type(MediaType.TEXT_PLAIN)
             .header("Location", servicePath + "/maxload").build();
   }
 
   @GET
   @Path("maxload")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "maxload",
       description = "Returns the maximum load that servers in this service registry can execute concurrently.  "
           + "If there is only one server in this service registry this will be the maximum load that one server is "
           + "able to handle at one time. If it is a distributed install across many servers then this number will be "
           + "the maximum load the cluster can process concurrently.",
       returnDescription = "The maximum load of the cluster or server",
       restParameters = {
           @RestParameter(name = "host", isRequired = false, type = Type.STRING,
               description = "The host you want to know the maximum load for.")
       },
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Maximum load for the cluster.")
       })
   public Response getMaxLoadOnNode(@QueryParam("host") String host) throws NotFoundException {
     try {
       if (StringUtils.isEmpty(host)) {
         return Response.ok(serviceRegistry.getMaxLoads()).build();
       } else {
         SystemLoad systemLoad = new SystemLoad();
         systemLoad.addNodeLoad(serviceRegistry.getMaxLoadOnNode(host));
         return Response.ok(systemLoad).build();
       }
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("currentload")
   @Produces(MediaType.TEXT_XML)
   @RestQuery(
       name = "currentload",
       description = "Returns the current load on the servers in this service registry.  "
           + "If there is only one server in this service registry this will be the the load that one server.  "
           + "If it is a distributed install across many servers then this number will be a dictionary of the load on "
           + "all nodes in the cluster.",
       returnDescription = "The current load across the cluster",
       restParameters = {},
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Current load for the cluster.")
       })
   public Response getCurrentLoad() {
     try {
       return Response.ok(serviceRegistry.getCurrentHostLoads()).build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
   @GET
   @Path("ownload")
   @Produces(MediaType.TEXT_PLAIN)
   @RestQuery(
       name = "ownload",
       description = "Returns the current load on this service registry's node.",
       returnDescription = "The current load across the cluster",
       restParameters = {},
       responses = {
           @RestResponse(responseCode = SC_OK, description = "Current load for the cluster.")
       })
   public Response getOwnLoad() {
     try {
       return Response.ok(serviceRegistry.getOwnLoad()).build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
 
   @DELETE
   @Path("job/{id}")
   @RestQuery(
       name = "deletejob",
       description = "Deletes a job from the service registry",
       returnDescription = "No data is returned, just the HTTP status code",
       pathParameters = {
           @RestParameter(isRequired = true, name = "id", type = Type.INTEGER, description = "ID of the job to delete")
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "Job successfully deleted"),
           @RestResponse(responseCode = SC_NOT_FOUND, description = "Job with given id could not be found")
       })
   public Response deleteJob(@PathParam("id") long id) throws NotFoundException {
     try {
       serviceRegistry.removeJobs(Collections.singletonList(id));
       return Response.noContent().build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
 
   @POST
   @Path("removejobs")
   @RestQuery(
       name = "removejobs",
       description = "Removes all given jobs and their child jobs",
       returnDescription = "No data is returned, just the HTTP status code",
       restParameters = {
           @RestParameter(name = "jobIds", isRequired = true, description = "The IDs of the jobs to delete",
               type = Type.TEXT),
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "Jobs successfully removed"),
           @RestResponse(responseCode = HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
               description = "Error while removing jobs")
       })
   public Response removeParentlessJobs(@FormParam("jobIds") String jobIds) throws NotFoundException {
     try {
       final JSONArray array = (JSONArray) JSONValue.parse(jobIds);
       final List<Long> jobIdList = Arrays.asList((Long[]) array.toArray(new Long[0]));
       serviceRegistry.removeJobs(jobIdList);
       return Response.noContent().build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
 
   @POST
   @Path("removeparentlessjobs")
   @RestQuery(
       name = "removeparentlessjobs",
       description = "Removes all jobs without a parent job which have passed their lifetime",
       returnDescription = "No data is returned, just the HTTP status code",
       restParameters = {
           @RestParameter(name = "lifetime", isRequired = true, type = Type.INTEGER,
               description = "Lifetime of parentless jobs")
       },
       responses = {
           @RestResponse(responseCode = SC_NO_CONTENT, description = "Parentless jobs successfully removed"),
           @RestResponse(responseCode = HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
               description = "Error while removing parentless jobs")
       })
   public Response removeParentlessJobs(@FormParam("lifetime") int lifetime) {
     try {
       serviceRegistry.removeParentlessJobs(lifetime);
       return Response.noContent().build();
     } catch (ServiceRegistryException e) {
       throw new WebApplicationException(e);
     }
   }
 
 }