/** * Callback for a state change event: log it * @param service the service that has changed. */ @Override public void stateChanged(Service service) { log.info("Entry to state " + service.getServiceState() + " for " + service.getName()); } }
/** * Shutdown callback: stop the service and set an atomic boolean * if it stopped within the shutdown time. */ @Override public void run() { if (service != null) { service.stop(); serviceWasShutdown.set( service.waitForServiceToStop(shutdownTimeMillis)); } else { serviceWasShutdown.set(true); } }
/** * Shutdown operation. * <p> * Subclasses may extend it, but it is primarily * made available for testing. * @return true if the service was stopped and no exception was raised. */ protected boolean shutdown() { Service service; boolean result = false; synchronized (this) { service = serviceRef.get(); serviceRef.clear(); } if (service != null) { try { // Stop the Service service.stop(); result = true; } catch (Throwable t) { LOG.info("Error stopping {}", service.getName(), t); } } return result; } }
private void resetDispatcher() { Dispatcher dispatcher = setupDispatcher(); ((Service)dispatcher).init(this.conf); ((Service)dispatcher).start(); removeService((Service)rmDispatcher); // Need to stop previous rmDispatcher before assigning new dispatcher // otherwise causes "AsyncDispatcher event handler" thread leak ((Service) rmDispatcher).stop(); rmDispatcher = dispatcher; addIfService(rmDispatcher); rmContext.setDispatcher(rmDispatcher); }
@Override public void serviceStop() throws Exception { try { synchronized (serviceMap) { for (Service service : serviceMap.values()) { if (service.getServiceState() == Service.STATE.STARTED) { service.unregisterServiceListener(this); service.stop(); } } serviceMap.clear(); serviceMetaData.clear(); } } finally { super.serviceStop(); } }
/** * Stop a service. * <p/>Do nothing if the service is null or not * in a state in which it can be/needs to be stopped. * <p/> * The service state is checked <i>before</i> the operation begins. * This process is <i>not</i> thread safe. * @param service a service or null */ public static void stop(Service service) { if (service != null) { service.stop(); } }
protected void serviceInit(Configuration conf) throws Exception { List<Service> services = getServices(); if (LOG.isDebugEnabled()) { LOG.debug(getName() + ": initing services, size=" + services.size()); } for (Service service : services) { service.init(conf); } super.serviceInit(conf); }
protected void serviceStart() throws Exception { List<Service> services = getServices(); if (LOG.isDebugEnabled()) { LOG.debug(getName() + ": starting services, size=" + services.size()); } for (Service service : services) { // start the service. If this fails that service // will be stopped and an exception raised service.start(); } super.serviceStart(); }
@Test public void testStopInInitService() throws Throwable { Service service = new StopInInitService(); BreakableStateChangeListener listener = new BreakableStateChangeListener(); service.registerServiceListener(listener); service.init(new Configuration()); assertServiceInState(service, Service.STATE.STOPPED); assertEventCount(listener, 1); }
/** * Get the service name via {@link Service#getName()}. * * If the service is not instantiated, the classname is returned instead. * @return the service name */ public String getServiceName() { Service s = service; String name = null; if (s != null) { try { name = s.getName(); } catch (Exception ignored) { // ignored } } if (name != null) { return "service " + name; } else { return "service " + serviceName; } }
void start() throws InterruptedException { if(dependencies.size() > 0) { synchronized(this) { while(!canStart) { this.wait(1000*60*3L); if (dependenciesFailed) { throw new TezUncheckedException("Skipping service start for " + service.getName() + " as dependencies failed to start"); } } } } if(LOG.isDebugEnabled()) { LOG.debug("Service: " + service.getName() + " trying to start"); } for(Service dependency : dependencies) { if(!dependency.isInState(Service.STATE.STARTED)){ LOG.info("Service: " + service.getName() + " not started because " + " service: " + dependency.getName() + " is in state: " + dependency.getServiceState()); return; } } service.start(); } }
LOG.debug("Stopping service #" + i + ": " + service); STATE state = service.getServiceState();
@Override public synchronized void stateChanged(Service service) { super.stateChanged(service); service.unregisterServiceListener(this); } }
private void resetDispatcher() { Dispatcher dispatcher = setupDispatcher(); ((Service)dispatcher).init(this.conf); ((Service)dispatcher).start(); removeService((Service)rmDispatcher); // Need to stop previous rmDispatcher before assigning new dispatcher // otherwise causes "AsyncDispatcher event handler" thread leak ((Service) rmDispatcher).stop(); rmDispatcher = dispatcher; addIfService(rmDispatcher); rmContext.setDispatcher(rmDispatcher); }
@Override public void serviceStop() throws Exception { try { synchronized (serviceMap) { for (Service service : serviceMap.values()) { if (service.getServiceState() == Service.STATE.STARTED) { service.unregisterServiceListener(this); service.stop(); } } serviceMap.clear(); serviceMetaData.clear(); } } finally { super.serviceStop(); } }
@Override protected void serviceStop() throws Exception { //stop current service. //this triggers a callback that is caught and ignored Service current = activeService; previousService = current; activeService = null; if (current != null) { current.stop(); } }
void initServices(Configuration conf) { for (ServiceWithDependency sd : services.values()) { if (LOG.isDebugEnabled()) { LOG.debug("Initing service : " + sd.service); } sd.service.init(conf); } }