/** * Creates a new JAXB annotated service registration based on an existing service registration * * @param serviceRegistration */ public JaxbServiceRegistration(ServiceRegistration serviceRegistration) { this.host = serviceRegistration.getHost(); this.jobProducer = serviceRegistration.isJobProducer(); this.maintenanceMode = serviceRegistration.isInMaintenanceMode(); this.active = serviceRegistration.isActive(); this.online = serviceRegistration.isOnline(); this.onlineFrom = serviceRegistration.getOnlineFrom(); this.path = serviceRegistration.getPath(); this.serviceType = serviceRegistration.getServiceType(); this.serviceState = serviceRegistration.getServiceState(); this.stateChanged = serviceRegistration.getStateChanged(); this.warningStateTrigger = serviceRegistration.getWarningStateTrigger(); this.errorStateTrigger = serviceRegistration.getErrorStateTrigger(); }
@Override public int compare(ServiceStatistics o1, ServiceStatistics o2) { ServiceRegistration reg1 = o1.getServiceRegistration(); ServiceRegistration reg2 = o2.getServiceRegistration(); int typeComparison = reg1.getServiceType().compareTo(reg2.getServiceType()); return typeComparison == 0 ? reg1.getHost().compareTo(reg2.getHost()) : typeComparison; } });
public void updateService(ServiceRegistration registration) { if (!registration.isActive()) { services.remove(Tuple.tuple(registration.getHost(), registration.getServiceType())); logger.trace("Removing inactive service '{}'", registration); } else { services.put(Tuple.tuple(registration.getHost(), registration.getServiceType()), registration.getServiceState()); } sendNotification(JmxUtil.createUpdateNotification(this, sequenceNumber++, "Service updated")); }
if (!hostBaseUrls.contains(service.getHost())) { logger.trace("Not considering {} because it's host {} is not available for dispatching", service, service.getHost()); continue; if (!jobType.equals(service.getServiceType())) { logger.trace("Not considering {} because it is of the wrong job type", service); continue; if (service.getServiceState() == ERROR) { logger.trace("Not considering {} because it is in error state", service); continue; if (service.isInMaintenanceMode()) { logger.trace("Not considering {} because it is in maintenance mode", service); continue; if (!service.isOnline()) { logger.trace("Not considering {} because it is currently offline", service); continue;
hostsStatistics.updateHost(((ServiceRegistrationJpaImpl) service).getHostRegistration()); servicesStatistics.updateService(service); if (!service.isJobProducer()) continue; if (service.isInMaintenanceMode()) continue; String serviceUrl = UrlSupport.concat(service.getHost(), service.getPath(), "dispatch"); if (unresponsive.remove(service)) { logger.info("Service {} is still online", service); } else if (!service.isOnline()) { try { setOnlineStatus(service.getServiceType(), service.getHost(), service.getPath(), true, true); logger.info("Service {} is back online", service); } catch (ServiceRegistryException e) { if (!service.isOnline()) continue; logger.warn("Service {} is not working as expected: {}", service, response.getStatusLine()); if (!service.isOnline()) continue; logger.warn("Unable to reach {} : {}", service, e); unRegisterService(service.getServiceType(), service.getHost()); unresponsive.remove(service); logger.warn("Marking {} as offline", service);
public HostsStatistics(List<ServiceStatistics> statistics) { for (ServiceStatistics stats : statistics) { String host = stats.getServiceRegistration().getHost(); boolean online = stats.getServiceRegistration().isOnline(); boolean inMaintenanceMode = stats.getServiceRegistration().isInMaintenanceMode(); if (!stats.getServiceRegistration().isActive()) { hosts.remove(host); logger.trace("Removing inactive host '{}'", host); continue; } if (online && !inMaintenanceMode) { hosts.put(host, ONLINE); } else if (online && inMaintenanceMode) { hosts.put(host, MAINTENANCE); } else { hosts.put(host, OFFLINE); } } }
public String list() { try { StringBuilder sb = new StringBuilder(); for (ServiceRegistration reg : serviceRegistry.getServiceRegistrations()) { sb.append(reg.getServiceType()); sb.append("@"); sb.append(reg.getHost()); if (reg.isInMaintenanceMode()) { sb.append(" (maintenance mode)"); } sb.append("\n"); } return sb.toString(); } catch (ServiceRegistryException e) { return "Error: " + e.getMessage() + "\n"; } }
@Override public SystemLoad getCurrentHostLoads() { SystemLoad systemLoad = new SystemLoad(); for (String host : hosts.keySet()) { NodeLoad node = new NodeLoad(); node.setHost(host); for (ServiceRegistration service : services.get(host)) { if (service.isInMaintenanceMode() || !service.isOnline()) { continue; } Set<Job> hostJobs = jobHosts.get(service); float loadSum = 0.0f; if (hostJobs != null) { for (Job job : hostJobs) { if (job.getStatus() != null && JOB_STATUSES_INFLUENCING_LOAD_BALANCING.contains(job.getStatus())) { loadSum += job.getJobLoad(); } } } node.setLoadFactor(node.getLoadFactor() + loadSum); } systemLoad.addNodeLoad(node); } return systemLoad; }
if (registration.isJobProducer() && !registration.isInMaintenanceMode()) { ServiceRegistrationInMemoryImpl inMemoryRegistration = (ServiceRegistrationInMemoryImpl) registration; JobProducer service = inMemoryRegistration.getService(); } else if (!registration.isJobProducer()) { logger.warn("This implementation of the service registry doesn't support dispatching to remote services");
/** * {@inheritDoc} * * @see org.opencastproject.serviceregistry.api.ServiceRegistry#unRegisterService(java.lang.String, java.lang.String) */ @Override public void unRegisterService(String serviceType, String host) throws ServiceRegistryException { List<ServiceRegistrationInMemoryImpl> servicesOnHost = services.get(host); if (servicesOnHost != null) { Iterator<ServiceRegistrationInMemoryImpl> ri = servicesOnHost.iterator(); while (ri.hasNext()) { ServiceRegistration registration = ri.next(); if (serviceType.equals(registration.getServiceType())) ri.remove(); } } }
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 {
if (!hostBaseUrls.contains(service.getHost())) { logger.trace("Not considering {} because it's host {} is not available for dispatching", service, service.getHost()); continue; if (!jobType.equals(service.getServiceType())) { logger.trace("Not considering {} because it is of the wrong job type", service); continue; if (service.getServiceState() == ERROR) { logger.trace("Not considering {} because it is in error state", service); continue; if (service.isInMaintenanceMode()) { logger.trace("Not considering {} because it is in maintenance mode", service); continue; if (!service.isOnline()) { logger.trace("Not considering {} because it is currently offline", service); continue; if (host.getBaseUrl().equals(service.getHost())) { hostLoadMax = host.getMaxLoad(); break; logger.warn("Unable to determine max load for host {}", service.getHost()); Float hostLoad = systemLoad.get(service.getHost()).getLoadFactor(); if (hostLoad == null)
public ServicesStatistics(String hostName, List<ServiceStatistics> statistics) { this.hostName = hostName; for (ServiceStatistics stats : statistics) { if (!stats.getServiceRegistration().isActive()) { logger.trace("Ignoring inactive service '{}'", stats); continue; } String host = stats.getServiceRegistration().getHost(); String serviceType = stats.getServiceRegistration().getServiceType(); ServiceState serviceState = stats.getServiceRegistration().getServiceState(); services.put(Tuple.tuple(host, serviceType), serviceState); } }
/** * {@inheritDoc} * * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object obj) { if (!(obj instanceof ServiceRegistration)) return false; ServiceRegistration registration = (ServiceRegistration) obj; return getHost().equals(registration.getHost()) && getServiceType().equals(registration.getServiceType()); }
String serviceUrl = UrlSupport.concat(registration.getHost(), registration.getPath(), "dispatch"); HttpPost post = new HttpPost(serviceUrl); try { logger.debug("Trying to dispatch job {} of type '{}' to {}", new String[] { Long.toString(job.getId()), job.getJobType(), registration.getHost() }); if (!START_WORKFLOW.equals(job.getOperation())) setCurrentJob(job.toJob()); responseStatusCode = response.getStatusLine().getStatusCode(); if (responseStatusCode == HttpStatus.SC_NO_CONTENT) { return registration.getHost(); } else if (responseStatusCode == HttpStatus.SC_SERVICE_UNAVAILABLE) { logger.debug("Service {} is currently refusing to accept jobs of type {}", registration,
@Override public boolean equals(Object obj) { if (!(obj instanceof ServiceRegistration)) return false; ServiceRegistration registration = (ServiceRegistration) obj; return getHost().equals(registration.getHost()) && getServiceType().equals(registration.getServiceType()); }
/** * Gets the failed jobs history for the given service registration * * @param serviceRegistration * @return the failed jobs history size * @throws IllegalArgumentException * if parameter is null * @throws ServiceRegistryException */ private int getHistorySize(ServiceRegistration serviceRegistration) throws IllegalArgumentException, ServiceRegistryException { if (serviceRegistration == null) throw new IllegalArgumentException("serviceRegistration must not be null!"); Query query = null; EntityManager em = null; logger.debug("Calculating count of jobs who failed due to service {}", serviceRegistration.toString()); try { em = emf.createEntityManager(); query = em.createNamedQuery("Job.count.history.failed"); query.setParameter("serviceType", serviceRegistration.getServiceType()); query.setParameter("host", serviceRegistration.getHost()); Number number = (Number) query.getSingleResult(); return number.intValue(); } catch (Exception e) { throw new ServiceRegistryException(e); } finally { if (em != null) em.close(); } }
unRegisterService(serviceRegistration.getServiceType(), serviceRegistration.getHost());