/** * Tests that a service that fails in the constructor has the error passed to the error service */ @Test public void testServiceFailsInConstructor() { ServiceLocator locator = LocatorHelper.getServiceLocator( RecordingErrorService.class, ServiceFailsInConstructor.class); ActiveDescriptor<?> serviceDescriptor = locator.getBestDescriptor( BuilderHelper.createContractFilter(ServiceFailsInConstructor.class.getName())); Assert.assertNotNull(serviceDescriptor); try { locator.getService(ServiceFailsInConstructor.class); Assert.fail("Should have failed"); } catch (MultiException me) { Assert.assertTrue(me.getMessage().contains(ERROR_STRING)); } List<ErrorInformation> errors = locator.getService(RecordingErrorService.class).getAndClearErrors(); Assert.assertEquals(1, errors.size()); ErrorInformation ei = errors.get(0); Assert.assertEquals(ErrorType.SERVICE_CREATION_FAILURE, ei.getErrorType()); Assert.assertEquals(serviceDescriptor, ei.getDescriptor()); Assert.assertNull(ei.getInjectee()); Throwable associatedException = ei.getAssociatedException(); Assert.assertTrue(associatedException.getMessage().contains(ERROR_STRING)); }
private String getLogNames(String instanceName, String type) throws IOException { if (habitat.getService(LogManager.class) == null) { // the logger service is not install, so we cannot rely on it. // return an error throw new IOException("The GlassFish LogManager Service is not available. Not installed?"); } LogFilter logFilter = habitat.getService(LogFilter.class); return convertQueryResult(logFilter.getInstanceLogFileNames(instanceName), type); }
/** * This test ensures that spending forever in an onProgress does not hold up other threads from * calling cancel on the RLC */ @Test public void testOnProgressCancelDeadlock() { ServiceLocator locator = Utilities.getServiceLocator(DeadLock1Listener.class); RunLevelController rlc = locator.getService(RunLevelController.class); rlc.proceedTo(1); }
/** * Will create a ServiceLocator after doing test-specific bindings from the TestModule * * @param name The name of the service locator to create. Should be unique per test, otherwise * this method will fail. * @param parent The parent locator this one should have. May be null * @param modules The test modules, that will do test specific bindings. May be null * @return A service locator with all the test specific bindings bound */ public static ServiceLocator create( String name, ServiceLocator parent, HK2TestModule... modules) { ServiceLocator retVal = factory.find(name); Assert.assertNull( "There is already a service locator of this name, change names to ensure a clean test: " + name, retVal); retVal = factory.create(name, parent); if (modules == null || modules.length <= 0) return retVal; DynamicConfigurationService dcs = retVal.getService(DynamicConfigurationService.class); Assert.assertNotNull("Their is no DynamicConfigurationService. Epic fail", dcs); DynamicConfiguration dc = dcs.createDynamicConfiguration(); Assert.assertNotNull("DynamicConfiguration creation failure", dc); for (HK2TestModule module : modules) { module.configure(dc); } dc.commit(); return retVal; }
/** Tests that a third-party service that fails in dispose */ @Test public void testFailingInDisposeThirdPartyService() { ServiceLocator locator = LocatorHelper.getServiceLocator(RecordingErrorService.class); AlwaysFailInDisposeActiveDescriptor thirdPartyDescriptor = new AlwaysFailInDisposeActiveDescriptor(); ServiceLocatorUtilities.addOneDescriptor(locator, thirdPartyDescriptor); ActiveDescriptor<?> serviceDescriptor = locator.getBestDescriptor( BuilderHelper.createContractFilter(SimpleService.class.getName())); Assert.assertNotNull(serviceDescriptor); ServiceHandle<SimpleService> handle = locator.getServiceHandle(SimpleService.class); Assert.assertNotNull(handle); Assert.assertNotNull(handle.getService()); handle.destroy(); List<ErrorInformation> errors = locator.getService(RecordingErrorService.class).getAndClearErrors(); Assert.assertEquals(1, errors.size()); ErrorInformation ei = errors.get(0); Assert.assertEquals(ErrorType.SERVICE_DESTRUCTION_FAILURE, ei.getErrorType()); Assert.assertEquals(serviceDescriptor, ei.getDescriptor()); Assert.assertNull(ei.getInjectee()); Throwable associatedException = ei.getAssociatedException(); Assert.assertTrue(associatedException.getMessage().contains(ERROR_STRING)); }
private synchronized File domainRoot() { if (domainRoot == null) { ServerEnvironment serverEnv = habitat.getService(ServerEnvironment.class); domainRoot = serverEnv.getDomainRoot(); } return domainRoot; }
/** * @see org.glassfish.internal.api.ClassLoaderHierarchy#getAppLibClassLoader(String, List<URI>) */ public ClassLoader getAppLibClassLoader(String application, List<URI> libURIs) throws MalformedURLException { ClassLoaderHierarchy clh = habitat.getService(ClassLoaderHierarchy.class); DelegatingClassLoader connectorCL = clh.getConnectorClassLoader(application); if (libURIs == null || libURIs.isEmpty()) { // Optimization: when there are no libraries, why create an empty // class loader in the hierarchy? Instead return the parent. return connectorCL; } final ClassLoader commonCL = commonCLS.getCommonClassLoader(); DelegatingClassLoader applibCL = AccessController.doPrivileged( new PrivilegedAction<DelegatingClassLoader>() { public DelegatingClassLoader run() { return new DelegatingClassLoader(commonCL); } }); // order of classfinders is important here : // connector's classfinders should be added before libraries' classfinders // as the delegation hierarchy is appCL->app-libsCL->connectorCL->commonCL->API-CL // since we are merging connector and applib classfinders to be at same level, // connector classfinders need to be be before applib classfinders in the horizontal // search path for (DelegatingClassLoader.ClassFinder cf : connectorCL.getDelegates()) { applibCL.addDelegate(cf); } addDelegates(libURIs, applibCL); return applibCL; }
@Before public void setUp() { habitat = getHabitat(); parameters = new ParameterMap(); cr = habitat.getService(CommandRunner.class); assertTrue(cr != null); Resources resources = habitat.<Domain>getService(Domain.class).getResources(); context = new AdminCommandContextImpl( LogDomains.getLogger(ListJavaMailResourcesTest.class, LogDomains.ADMIN_LOGGER), new PropsFileActionReporter()); for (Resource resource : resources.getResources()) { if (resource instanceof MailResource) { origNum = origNum + 1; } } }
private static void bind(ServiceLocator locator, Binder binder) { DynamicConfigurationService dcs = locator.getService(DynamicConfigurationService.class); DynamicConfiguration dc = dcs.createDynamicConfiguration(); locator.inject(binder); binder.bind(dc); dc.commit(); }
protected void configureSpdySupport( final ServiceLocator locator, final NetworkListener listener, final Spdy spdyElement, final FilterChainBuilder builder, final boolean secure) { if (spdyElement != null && spdyElement.getEnabled()) { boolean isNpnMode = spdyElement.getMode() == null || "npn".equalsIgnoreCase(spdyElement.getMode()); // Spdy without NPN is supported, but warn that there may // be consequences to this configuration. if (!secure && isNpnMode) { LOGGER.log( Level.WARNING, "SSL is not enabled for listener {0}. SPDY support will be enabled, but will not be secured. Some clients may not be able to use SPDY in this configuration.", listener.getName()); } // first try to lookup a service appropriate for the mode // that has been configured. AddOn spdyAddon = locator.getService(AddOn.class, "spdy"); // if no service was found, attempt to load via reflection. if (spdyAddon == null) { Class<?> spdyMode; try { spdyMode = Utils.loadClass("org.glassfish.grizzly.spdy.SpdyMode"); } catch (ClassNotFoundException cnfe) { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine( "Unable to load class org.glassfish.grizzly.spdy.SpdyMode. SPDY support cannot be enabled"); } return; } Object[] enumConstants = spdyMode.getEnumConstants(); Object mode = ((isNpnMode) ? enumConstants[1] : enumConstants[0]); spdyAddon = loadAddOn("org.glassfish.grizzly.spdy.SpdyAddOn", new Class[] {spdyMode}, mode); } if (spdyAddon != null) { // Configure SpdyAddOn configureElement(locator, listener, spdyElement, spdyAddon); // Spdy requires access to more information compared to the other addons // that are currently leveraged. As such, we'll need to mock out a // Grizzly NetworkListener to pass to the addon. This mock object will // only provide the information necessary for the addon to operate. // It will be important to keep this mock in sync with the details the // addon requires. spdyAddon.setup(createMockListener(), builder); isSpdyEnabled = true; } } }
/** * Populate serviceLocator with services from classpath * * @see <a * href="https://hk2.java.net/2.4.0-b16/inhabitant-generator.html">https://hk2.java.net/2.4.0-b16/inhabitant-generator.html</a> */ private void populate(ServiceLocator serviceLocator) { DynamicConfigurationService dcs = serviceLocator.getService(DynamicConfigurationService.class); Populator populator = dcs.getPopulator(); try { populator.populate(); } catch (IOException | MultiException e) { throw new MultiException(e); } }
private void deleteJavaMailResource() { parameters = new ParameterMap(); parameters.set("jndi_name", "mailresource"); DeleteJavaMailResource deleteCommand = habitat.getService(DeleteJavaMailResource.class); assertTrue(deleteCommand != null); cr.getCommandInvocation("delete-javamail-resource", context.getActionReport(), adminSubject()) .parameters(parameters) .execute(deleteCommand); assertEquals(ActionReport.ExitCode.SUCCESS, context.getActionReport().getActionExitCode()); }
@Override public void initialize(final ServiceLocator locator) { this.locator = locator; if (locator != null) { injector = locator.getService(Injector.class); MutableServiceLocatorProvider serviceLocatorProvider = injector.getInstance(MutableServiceLocatorProvider.class); if (serviceLocatorProvider != null) { serviceLocatorProvider.setServiceLocator(locator); } } }
/** * Test of execute method, of class ListJdbcResource. delete-javamail-resource mailresource * list-javamail-resources */ @Test public void testExecuteSuccessListNoMailResource() { createJavaMailResource(); parameters = new ParameterMap(); org.glassfish.resources.javamail.admin.cli.ListJavaMailResources listCommand = habitat.getService(org.glassfish.resources.javamail.admin.cli.ListJavaMailResources.class); cr.getCommandInvocation("list-javamail-resources", context.getActionReport(), adminSubject()) .parameters(parameters) .execute(listCommand); List<ActionReport.MessagePart> list = context.getActionReport().getTopMessagePart().getChildren(); assertEquals(origNum + 1, list.size()); origNum = origNum + 1; // as we newly created a resource after test "setup". deleteJavaMailResource(); parameters = new ParameterMap(); listCommand = habitat.getService(org.glassfish.resources.javamail.admin.cli.ListJavaMailResources.class); context = new AdminCommandContextImpl( LogDomains.getLogger(ListJavaMailResourcesTest.class, LogDomains.ADMIN_LOGGER), new PropsFileActionReporter()); cr.getCommandInvocation("list-javamail-resources", context.getActionReport(), adminSubject()) .parameters(parameters) .execute(listCommand); list = context.getActionReport().getTopMessagePart().getChildren(); if ((origNum - 1) == 0) { // Nothing to list. } else { assertEquals(origNum - 1, list.size()); } List<String> listStr = new ArrayList<String>(); for (MessagePart mp : list) { listStr.add(mp.getMessage()); } assertFalse(listStr.contains("mailresource")); assertEquals(ActionReport.ExitCode.SUCCESS, context.getActionReport().getActionExitCode()); }
private void createJavaMailResource() { parameters = new ParameterMap(); parameters.set("mailhost", "localhost"); parameters.set("mailuser", "test"); parameters.set("fromaddress", "*****@*****.**"); parameters.set("jndi_name", "mailresource"); CreateJavaMailResource createCommand = habitat.getService(CreateJavaMailResource.class); assertTrue(createCommand != null); cr.getCommandInvocation("create-javamail-resource", context.getActionReport(), adminSubject()) .parameters(parameters) .execute(createCommand); assertEquals(ActionReport.ExitCode.SUCCESS, context.getActionReport().getActionExitCode()); }
/** * Tests that a service that fails but tells HK2 to NOT report the failure to the error handler * service */ @Test public void testSilentFailureInPostConstruct() { ServiceLocator locator = LocatorHelper.getServiceLocator( RecordingErrorService.class, ServiceDirectsNoErrorService.class); ActiveDescriptor<?> serviceDescriptor = locator.getBestDescriptor( BuilderHelper.createContractFilter(ServiceDirectsNoErrorService.class.getName())); Assert.assertNotNull(serviceDescriptor); try { locator.getService(ServiceDirectsNoErrorService.class); Assert.fail("Should have failed"); } catch (MultiException me) { Assert.assertTrue(me.getMessage().contains(ERROR_STRING)); } List<ErrorInformation> errors = locator.getService(RecordingErrorService.class).getAndClearErrors(); Assert.assertEquals(0, errors.size()); }
/** Test of execute method, of class ListJavaMailResources. list-javamail-resources */ @Test public void testExecuteSuccessListOriginal() { org.glassfish.resources.javamail.admin.cli.ListJavaMailResources listCommand = habitat.getService(org.glassfish.resources.javamail.admin.cli.ListJavaMailResources.class); cr.getCommandInvocation("list-javamail-resources", context.getActionReport(), adminSubject()) .parameters(parameters) .execute(listCommand); List<MessagePart> list = context.getActionReport().getTopMessagePart().getChildren(); if (origNum == 0) { // Nothing to list } else { assertEquals(origNum, list.size()); } assertEquals(ActionReport.ExitCode.SUCCESS, context.getActionReport().getActionExitCode()); }
@Inject private PersistenceUnitInjectionResolver(final ServiceLocator locator) { // Look for persistence units. final ServletConfig servletConfig = locator.getService(ServletConfig.class); for (final Enumeration parameterNames = servletConfig.getInitParameterNames(); parameterNames.hasMoreElements(); ) { final String key = (String) parameterNames.nextElement(); if (key.startsWith(PERSISTENCE_UNIT_PREFIX)) { persistenceUnits.put( key.substring(PERSISTENCE_UNIT_PREFIX.length()), "java:comp/env/" + servletConfig.getInitParameter(key)); } } }
public static void initRecovery(boolean force) { if (_logger.isLoggable(Level.FINE)) { _logger.log(Level.FINE, "initRecovery:recoveryInitialized: " + recoveryInitialized); } if (recoveryInitialized) { // Only start initial recovery if it wasn't started before return; } if (_logger.isLoggable(Level.FINE)) { _logger.log(Level.FINE, "initRecovery:properties: " + properties); } if (properties == null) { if (force) { _logger.log(Level.WARNING, "", new IllegalStateException()); } return; } // Start if force is true or automatic-recovery is set String value = properties.getProperty(Configuration.MANUAL_RECOVERY); if (_logger.isLoggable(Level.FINE)) { _logger.log(Level.FINE, "initRecovery:Configuration.MANUAL_RECOVERY: " + value); } if (force || (isValueSet(value) && "true".equals(value))) { recoveryInitialized = true; ServiceLocator serviceLocator = (ServiceLocator) properties.get(HABITAT); if (serviceLocator != null) { ProcessEnvironment processEnv = serviceLocator.getService(ProcessEnvironment.class); if (processEnv.getProcessType().isServer()) { // Start ResourceManager if it hadn't started yet serviceLocator.getAllServices(BuilderHelper.createNameFilter("ResourceManager")); value = properties.getProperty("pending-txn-cleanup-interval"); int interval = -1; if (isValueSet(value)) { interval = Integer.parseInt(value); } new RecoveryHelperThread(serviceLocator, interval).start(); } // Release all locks RecoveryManager.startResyncThread(); if (_logger.isLoggable(Level.FINE)) _logger.log(Level.FINE, "[JTS] Started ResyncThread"); } } }
/** Ensures we can add a scope to a service with no scope at all */ @Test public void testGiveClassWithNoScopeAScope() { ServiceLocator locator = LocatorHelper.create(); ServiceLocatorUtilities.enableLookupExceptions(locator); Descriptor desc = BuilderHelper.activeLink(NoScopeService.class) .to(NoScopeService.class) .in(ServiceLocatorUtilities.getSingletonAnnotation()) .build(); ServiceLocatorUtilities.addOneDescriptor(locator, desc); NoScopeService one = locator.getService(NoScopeService.class); NoScopeService two = locator.getService(NoScopeService.class); Assert.assertNotNull(one); Assert.assertEquals(one, two); }
/** * Ensures that you can change from one hard-coded scope on the descriptor to a different scope */ @Test public void testSwitchFromExplicitScopeToGhostedScope() { ServiceLocator locator = LocatorHelper.create(); ServiceLocatorUtilities.enableLookupExceptions(locator); ServiceLocatorUtilities.addClasses(locator, GhostedContext.class); Descriptor desc = BuilderHelper.activeLink(SingletonScopedService.class) .to(SingletonScopedService.class) .in(new GhostedScopeImpl(0)) .build(); ServiceLocatorUtilities.addOneDescriptor(locator, desc); SingletonScopedService one = locator.getService(SingletonScopedService.class); SingletonScopedService two = locator.getService(SingletonScopedService.class); Assert.assertNotNull(one); Assert.assertNotSame(one, two); }
public void run() { ResourceRecoveryManager recoveryManager = serviceLocator.getService(ResourceRecoveryManager.class); if (interval <= 0) { // Only start the recovery thread if the interval value is set, and set to a positive value return; } if (_logger.isLoggable(Level.INFO)) { _logger.log( Level.INFO, "Asynchronous thread for incomplete " + "tx is enabled with interval " + interval); } int prevSize = 0; try { while (true) { Thread.sleep(interval * 1000L); if (!RecoveryManager.isIncompleteTxRecoveryRequired()) { if (_logger.isLoggable(Level.FINE)) _logger.log( Level.FINE, "Incomplete transaction recovery is " + "not requeired, waiting for the next interval"); continue; } if (RecoveryManager.sizeOfInCompleteTx() <= prevSize) { if (_logger.isLoggable(Level.FINE)) _logger.log( Level.FINE, "Incomplete transaction recovery is " + "not required, waiting for the next interval SIZE"); continue; } prevSize = RecoveryManager.sizeOfInCompleteTx(); recoveryManager.recoverIncompleteTx(false, null); } } catch (Exception ex) { if (_logger.isLoggable(Level.FINE)) _logger.log(Level.FINE, " Exception occurred in recoverInCompleteTx "); } }
/** * Test of execute method, of class ListJavaMailResource. create-javamail-resource --mailuser=test * --mailhost=localhost [email protected] mailresource list-javamail-resources */ @Test public void testExecuteSuccessListMailResource() { createJavaMailResource(); parameters = new ParameterMap(); org.glassfish.resources.javamail.admin.cli.ListJavaMailResources listCommand = habitat.getService(org.glassfish.resources.javamail.admin.cli.ListJavaMailResources.class); assertTrue(listCommand != null); cr.getCommandInvocation("list-javamail-resources", context.getActionReport(), adminSubject()) .parameters(parameters) .execute(listCommand); List<MessagePart> list = context.getActionReport().getTopMessagePart().getChildren(); assertEquals(origNum + 1, list.size()); List<String> listStr = new ArrayList<String>(); for (MessagePart mp : list) { listStr.add(mp.getMessage()); } assertTrue(listStr.contains("mailresource")); assertEquals(ActionReport.ExitCode.SUCCESS, context.getActionReport().getActionExitCode()); deleteJavaMailResource(); }
/* package */ @SuppressWarnings({"unchecked"}) void register() { ServiceLocator locator = getServiceLocator(); ActiveDescriptor<?> myselfReified = locator.reifyDescriptor(this); DynamicConfigurationService dcs = locator.getService(DynamicConfigurationService.class); DynamicConfiguration dc = dcs.createDynamicConfiguration(); // habitat.add(this); HK2Loader loader = this.model.classLoaderHolder; Set<Type> ctrs = new HashSet<Type>(); ctrs.add(myselfReified.getImplementationClass()); if (ConfigBean.class.isAssignableFrom(this.getClass())) { ctrs.add(ConfigBean.class); } DomDescriptor<Dom> domDesc = new DomDescriptor<Dom>( this, ctrs, Singleton.class, getImplementation(), new HashSet<Annotation>()); domDesc.setLoader(loader); domDescriptor = dc.addActiveDescriptor(domDesc, false); String key = getKey(); for (String contract : model.contracts) { ActiveDescriptor<Dom> alias = new AliasDescriptor<Dom>(locator, domDescriptor, contract, key); dc.addActiveDescriptor(alias, false); } if (key != null) { ActiveDescriptor<Dom> alias = new AliasDescriptor<Dom>(locator, domDescriptor, model.targetTypeName, key); dc.addActiveDescriptor(alias, false); } dc.commit(); serviceHandle = getHabitat().getServiceHandle(domDescriptor); }
/** Tests that we can change the value of a field in a scope with a ghost added annotation */ @Test public void testModifyExistingScopeWithDifferentValue() { ServiceLocator locator = LocatorHelper.create(); ServiceLocatorUtilities.addClasses(locator, GhostedContext.class); Descriptor desc = BuilderHelper.activeLink(GhostedServiceWithValue.class) .to(GhostedServiceWithValue.class) .in(new GhostedScopeImpl(0)) .build(); ServiceLocatorUtilities.addOneDescriptor(locator, desc); GhostedServiceWithValue ghosted = locator.getService(GhostedServiceWithValue.class); Assert.assertNotNull(ghosted); ActiveDescriptor<?> gDesck = ghosted.getDescriptor(); Annotation anno = gDesck.getScopeAsAnnotation(); Assert.assertNotNull(anno); GhostedScope gs = (GhostedScope) anno; Assert.assertEquals(0, gs.value()); }
/** * Enables the Configuration subsystem of HK2. This call is idempotent * * @param locator The non-null service locator in which to enable the configuration subsystem */ public static void enableConfigurationSystem(ServiceLocator locator) { ServiceHandle<ConfiguredByContext> alreadyThere = locator.getServiceHandle(ConfiguredByContext.class); if (alreadyThere != null) { // The assumption is that if this service is there then this is already on, don't do it again return; } ManagerUtilities.enableConfigurationHub(locator); ServiceLocatorUtilities.addClasses(locator, true, ConfiguredValidator.class); ServiceLocatorUtilities.addClasses( locator, true, ConfiguredByContext.class, ConfigurationValidationService.class, ConfiguredByInjectionResolver.class, ConfigurationListener.class, ChildInjectResolverImpl.class); // Creates demand, starts the thing off locator.getService(ConfigurationListener.class); }
public static synchronized Properties getJTSProperties( ServiceLocator serviceLocator, boolean isORBAvailable) { if (orbAvailable == isORBAvailable && properties != null) { // We will need to update the properties if ORB availability changed return properties; } Properties jtsProperties = new Properties(); if (serviceLocator != null) { jtsProperties.put(HABITAT, serviceLocator); ProcessEnvironment processEnv = serviceLocator.getService(ProcessEnvironment.class); if (processEnv.getProcessType().isServer()) { TransactionService txnService = serviceLocator.getService( TransactionService.class, ServerEnvironment.DEFAULT_INSTANCE_NAME); if (txnService != null) { jtsProperties.put(Configuration.HEURISTIC_DIRECTION, txnService.getHeuristicDecision()); jtsProperties.put(Configuration.KEYPOINT_COUNT, txnService.getKeypointInterval()); String automaticRecovery = txnService.getAutomaticRecovery(); boolean isAutomaticRecovery = (isValueSet(automaticRecovery) && "true".equals(automaticRecovery)); if (isAutomaticRecovery) { _logger.log(Level.FINE, "Recoverable J2EE Server"); jtsProperties.put(Configuration.MANUAL_RECOVERY, "true"); } boolean disable_distributed_transaction_logging = false; String dbLoggingResource = null; for (Property prop : txnService.getProperty()) { String name = prop.getName(); String value = prop.getValue(); if (name.equals("disable-distributed-transaction-logging")) { if (isValueSet(value) && "true".equals(value)) { disable_distributed_transaction_logging = true; } } else if (name.equals("xaresource-txn-timeout")) { if (isValueSet(value)) { _logger.log(Level.FINE, "XAResource transaction timeout is" + value); TransactionManagerImpl.setXAResourceTimeOut(Integer.parseInt(value)); } } else if (name.equals("db-logging-resource")) { dbLoggingResource = value; _logger.log(Level.FINE, "Transaction DB Logging Resource Name" + dbLoggingResource); if (dbLoggingResource != null && (" ".equals(dbLoggingResource) || "".equals(dbLoggingResource))) { dbLoggingResource = "jdbc/TxnDS"; } } else if (name.equals("xa-servername")) { if (isValueSet(value)) { jtsProperties.put(JTS_XA_SERVER_NAME, value); } } else if (name.equals("pending-txn-cleanup-interval")) { if (isValueSet(value)) { jtsProperties.put("pending-txn-cleanup-interval", value); } } else if (name.equals(Configuration.COMMIT_ONE_PHASE_DURING_RECOVERY)) { if (isValueSet(value)) { jtsProperties.put(Configuration.COMMIT_ONE_PHASE_DURING_RECOVERY, value); } } else if (name.equals("add-wait-point-during-recovery")) { if (isValueSet(value)) { try { FailureInducer.setWaitPointRecovery(Integer.parseInt(value)); } catch (Exception e) { _logger.log(Level.WARNING, e.getMessage()); } } } } if (dbLoggingResource != null) { disable_distributed_transaction_logging = true; jtsProperties.put(Configuration.DB_LOG_RESOURCE, dbLoggingResource); } /** * JTS_SERVER_ID needs to be unique for each for server instance. This will be used as * recovery identifier along with the hostname for example: if the hostname is 'tulsa' and * iiop-listener-port is 3700 recovery identifier will be tulsa,P3700 */ int jtsServerId = DEFAULT_SERVER_ID; // default value if (isORBAvailable) { jtsServerId = serviceLocator .<GlassFishORBHelper>getService(GlassFishORBHelper.class) .getORBInitialPort(); if (jtsServerId == 0) { // XXX Can this ever happen? jtsServerId = DEFAULT_SERVER_ID; // default value } } jtsProperties.put(JTS_SERVER_ID, String.valueOf(jtsServerId)); /* ServerId is an J2SE persistent server activation API. ServerId is scoped at the ORBD. Since There is no ORBD present in J2EE the value of ServerId is meaningless - except it must have SOME value if persistent POAs are created. */ // For clusters - all servers in the cluster MUST // have the same ServerId so when failover happens // and requests are delivered to a new server, the // ServerId in the request will match the new server. String serverId = String.valueOf(DEFAULT_SERVER_ID); System.setProperty(J2EE_SERVER_ID_PROP, serverId); ServerContext ctx = serviceLocator.getService(ServerContext.class); String instanceName = ctx.getInstanceName(); /** * if the auto recovery is true, always transaction logs will be written irrespective of * disable_distributed_transaction_logging. if the auto recovery is false, then * disable_distributed_transaction_logging will be used to write transaction logs are * not.If disable_distributed_transaction_logging is set to false(by default false) logs * will be written, set to true logs won't be written. */ if (!isAutomaticRecovery && disable_distributed_transaction_logging) { Configuration.disableFileLogging(); } else { // if (dbLoggingResource == null) { Domain domain = serviceLocator.getService(Domain.class); Server server = domain.getServerNamed(instanceName); // Check if the server system property is set String logdir = getTXLogDir(server); // if not, check if the cluster system property is set if (logdir == null) { Cluster cluster = server.getCluster(); if (cluster != null) { logdir = getTXLogDir(cluster); } } // No system properties are set - get tx log dir from transaction service if (logdir == null) { logdir = txnService.getTxLogDir(); } if (logdir == null) { logdir = domain.getLogRoot(); if (logdir == null) { // logdir = FileUtil.getAbsolutePath(".." + File.separator + "logs"); logdir = ".." + File.separator + "logs"; } } else if (!(new File(logdir)).isAbsolute()) { if (_logger.isLoggable(Level.FINE)) { _logger.log( Level.FINE, "Relative pathname specified for transaction log directory : " + logdir); } String logroot = domain.getLogRoot(); if (logroot != null) { logdir = logroot + File.separator + logdir; } else { // logdir = FileUtil.getAbsolutePath(".." + File.separator + "logs" // + File.separator + logdir); logdir = ".." + File.separator + "logs" + File.separator + logdir; } } logdir += File.separator + instanceName + File.separator + "tx"; if (_logger.isLoggable(Level.FINE)) { _logger.log(Level.FINE, "JTS log directory: " + logdir); _logger.log(Level.FINE, "JTS Server id " + jtsServerId); } jtsProperties.put(Configuration.LOG_DIRECTORY, logdir); } jtsProperties.put(Configuration.COMMIT_RETRY, txnService.getRetryTimeoutInSeconds()); jtsProperties.put(Configuration.INSTANCE_NAME, instanceName); } } } properties = jtsProperties; orbAvailable = isORBAvailable; return properties; }
private void bindProvidersAndResources( final Set<ComponentProvider> componentProviders, final ComponentBag componentBag, final Set<Class<?>> resourceClasses, final Set<Object> resourceInstances) { final JerseyResourceContext resourceContext = locator.getService(JerseyResourceContext.class); final DynamicConfiguration dc = Injections.getConfiguration(locator); final Set<Class<?>> registeredClasses = runtimeConfig.getRegisteredClasses(); // Merge programmatic resource classes with component classes. Set<Class<?>> classes = Sets.newIdentityHashSet(); classes.addAll( Sets.filter( componentBag.getClasses(ComponentBag.EXCLUDE_META_PROVIDERS), new Predicate<Class<?>>() { @Override public boolean apply(Class<?> componentClass) { return Providers.checkProviderRuntime( componentClass, componentBag.getModel(componentClass), RuntimeType.SERVER, !registeredClasses.contains(componentClass), resourceClasses.contains(componentClass)); } })); classes.addAll(resourceClasses); // Bind classes. for (Class<?> componentClass : classes) { ContractProvider model = componentBag.getModel(componentClass); if (resourceClasses.contains(componentClass)) { if (bindWithComponentProvider(componentClass, model, componentProviders)) { continue; } if (!Resource.isAcceptable(componentClass)) { LOGGER.warning(LocalizationMessages.NON_INSTANTIABLE_COMPONENT(componentClass)); continue; } if (model != null && !Providers.checkProviderRuntime( componentClass, model, RuntimeType.SERVER, !registeredClasses.contains(componentClass), true)) { model = null; } resourceContext.unsafeBindResource(componentClass, model, dc); } else { ProviderBinder.bindProvider(componentClass, model, dc); } } // Merge programmatic resource instances with other component instances. Set<Object> instances = Sets.newHashSet(); instances.addAll( Sets.filter( componentBag.getInstances(ComponentBag.EXCLUDE_META_PROVIDERS), new Predicate<Object>() { @Override public boolean apply(Object component) { final Class<?> componentClass = component.getClass(); return Providers.checkProviderRuntime( componentClass, componentBag.getModel(componentClass), RuntimeType.SERVER, !registeredClasses.contains(componentClass), resourceInstances.contains(component)); } })); instances.addAll(resourceInstances); // Bind instances. for (Object component : instances) { ContractProvider model = componentBag.getModel(component.getClass()); if (resourceInstances.contains(component)) { if (model != null && !Providers.checkProviderRuntime( component.getClass(), model, RuntimeType.SERVER, !registeredClasses.contains(component.getClass()), true)) { model = null; } resourceContext.unsafeBindResource(component, model, dc); } else { ProviderBinder.bindProvider(component, model, dc); } } dc.commit(); }
@SuppressWarnings({"unchecked", "rawtypes"}) public Task<Void> start() { // Ensuring that jersey will use singletons from the orbit container. ServiceLocator locator = Injections.createLocator(); DynamicConfigurationService dcs = locator.getService(DynamicConfigurationService.class); DynamicConfiguration dc = dcs.createDynamicConfiguration(); final List<Class<?>> classes = new ArrayList<>(providers); if (container != null) { classes.addAll(container.getClasses()); for (final Class<?> c : container.getClasses()) { if (c.isAnnotationPresent(Singleton.class)) { Injections.addBinding( Injections.newFactoryBinder( new Factory() { @Override public Object provide() { return container.get(c); } @Override public void dispose(final Object instance) {} }) .to(c), dc); } } } dc.commit(); final ResourceConfig resourceConfig = new ResourceConfig(); // installing jax-rs classes known by the orbit container. for (final Class c : classes) { if (c.isAnnotationPresent(javax.ws.rs.Path.class) || c.isAnnotationPresent(javax.ws.rs.ext.Provider.class)) { resourceConfig.register(c); } } final WebAppContext webAppContext = new WebAppContext(); final ProtectionDomain protectionDomain = EmbeddedHttpServer.class.getProtectionDomain(); final URL location = protectionDomain.getCodeSource().getLocation(); logger.info(location.toExternalForm()); webAppContext.setInitParameter("useFileMappedBuffer", "false"); webAppContext.setWar(location.toExternalForm()); // this sets the default service locator to one that bridges to the orbit container. webAppContext.getServletContext().setAttribute(ServletProperties.SERVICE_LOCATOR, locator); webAppContext.setContextPath("/*"); webAppContext.addServlet(new ServletHolder(new ServletContainer(resourceConfig)), "/*"); final ContextHandler resourceContext = new ContextHandler(); ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setDirectoriesListed(true); resourceHandler.setWelcomeFiles(new String[] {"index.html"}); resourceHandler.setBaseResource(Resource.newClassPathResource("/web")); resourceContext.setHandler(resourceHandler); resourceContext.setInitParameter("useFileMappedBuffer", "false"); final ContextHandlerCollection contexts = new ContextHandlerCollection(); contexts.setHandlers( new Handler[] { wrapHandlerWithMetrics(resourceContext, "resourceContext"), wrapHandlerWithMetrics(webAppContext, "webAppContext") }); server = new Server(port); server.setHandler(contexts); try { /// Initialize javax.websocket layer final ServerContainer serverContainer = WebSocketServerContainerInitializer.configureContext(webAppContext); for (Class c : classes) { if (c.isAnnotationPresent(ServerEndpoint.class)) { final ServerEndpoint annotation = (ServerEndpoint) c.getAnnotation(ServerEndpoint.class); final ServerEndpointConfig serverEndpointConfig = ServerEndpointConfig.Builder.create(c, annotation.value()) .configurator( new ServerEndpointConfig.Configurator() { @Override public <T> T getEndpointInstance(final Class<T> endpointClass) throws InstantiationException { return container.get(endpointClass); } }) .build(); serverContainer.addEndpoint(serverEndpointConfig); } } } catch (Exception e) { logger.error("Error starting jetty", e); throw new UncheckedException(e); } try { server.start(); } catch (Exception e) { logger.error("Error starting jetty", e); throw new UncheckedException(e); } return Task.done(); }
/** Assumes the configuration field is initialized with a valid ResourceConfig. */ private void initialize() { LOGGER.info(LocalizationMessages.INIT_MSG(Version.getBuildId())); // Lock original ResourceConfig. if (application instanceof ResourceConfig) { ((ResourceConfig) application).lock(); } // add WADL support runtimeConfig.register(WadlModelProcessorFeature.class); // Configure binders and features. runtimeConfig.configureMetaProviders(locator); // Introspecting classes & instances final ResourceBag.Builder resourceBagBuilder = new ResourceBag.Builder(); for (Class<?> c : runtimeConfig.getClasses()) { try { Resource resource = Resource.from(c); if (resource != null) { resourceBagBuilder.registerResource(c, resource); } } catch (IllegalArgumentException ex) { LOGGER.warning(ex.getMessage()); } } for (Object o : runtimeConfig.getSingletons()) { try { Resource resource = Resource.from(o.getClass()); if (resource != null) { resourceBagBuilder.registerResource(o, resource); } } catch (IllegalArgumentException ex) { LOGGER.warning(ex.getMessage()); } } // Adding programmatic resource models for (Resource programmaticResource : runtimeConfig.getResources()) { resourceBagBuilder.registerProgrammaticResource(programmaticResource); } final ResourceBag resourceBag = resourceBagBuilder.build(); runtimeConfig.lock(); // Registering Injection Bindings final Set<ComponentProvider> componentProviders = new HashSet<ComponentProvider>(); for (ComponentProvider provider : ServiceFinder.find(ComponentProvider.class)) { provider.initialize(locator); componentProviders.add(provider); } final ComponentBag componentBag = runtimeConfig.getComponentBag(); bindProvidersAndResources( componentProviders, componentBag, resourceBag.classes, resourceBag.instances); for (ComponentProvider componentProvider : componentProviders) { componentProvider.done(); } // scan for NameBinding annotations attached to the application class Collection<Class<? extends Annotation>> applicationNameBindings = ReflectionHelper.getAnnotationTypes(application.getClass(), NameBinding.class); // find all filters, interceptors and dynamic features final Iterable<RankedProvider<ContainerResponseFilter>> responseFilters = Providers.getAllRankedProviders(locator, ContainerResponseFilter.class); final MultivaluedMap<Class<? extends Annotation>, RankedProvider<ContainerResponseFilter>> nameBoundResponseFilters = filterNameBound(responseFilters, null, componentBag, applicationNameBindings); final Iterable<RankedProvider<ContainerRequestFilter>> requestFilters = Providers.getAllRankedProviders(locator, ContainerRequestFilter.class); final List<RankedProvider<ContainerRequestFilter>> preMatchFilters = Lists.newArrayList(); final MultivaluedMap<Class<? extends Annotation>, RankedProvider<ContainerRequestFilter>> nameBoundRequestFilters = filterNameBound(requestFilters, preMatchFilters, componentBag, applicationNameBindings); final Iterable<RankedProvider<ReaderInterceptor>> readerInterceptors = Providers.getAllRankedProviders(locator, ReaderInterceptor.class); final MultivaluedMap<Class<? extends Annotation>, RankedProvider<ReaderInterceptor>> nameBoundReaderInterceptors = filterNameBound(readerInterceptors, null, componentBag, applicationNameBindings); final Iterable<RankedProvider<WriterInterceptor>> writerInterceptors = Providers.getAllRankedProviders(locator, WriterInterceptor.class); final MultivaluedMap<Class<? extends Annotation>, RankedProvider<WriterInterceptor>> nameBoundWriterInterceptors = filterNameBound(writerInterceptors, null, componentBag, applicationNameBindings); final Iterable<DynamicFeature> dynamicFeatures = Providers.getAllProviders(locator, DynamicFeature.class); ResourceModel resourceModel = new ResourceModel.Builder(resourceBag.getRootResources(), false).build(); resourceModel = processResourceModel(resourceModel); // validate the models validate(resourceModel); bindEnhancingResourceClasses(resourceModel, resourceBag, componentProviders); final RuntimeModelBuilder runtimeModelBuilder = locator.getService(RuntimeModelBuilder.class); runtimeModelBuilder.setGlobalInterceptors(readerInterceptors, writerInterceptors); runtimeModelBuilder.setBoundProviders( nameBoundRequestFilters, nameBoundResponseFilters, nameBoundReaderInterceptors, nameBoundWriterInterceptors, dynamicFeatures); // assembly request processing chain /** * Root hierarchical request matching acceptor. Invoked in a single linear stage as part of the * main linear accepting chain. */ final Router resourceRoutingRoot = runtimeModelBuilder.buildModel(resourceModel.getRuntimeResourceModel(), false); final ContainerFilteringStage preMatchRequestFilteringStage = locator .createAndInitialize(ContainerFilteringStage.Builder.class) .build(preMatchFilters, responseFilters); final RoutingStage routingStage = locator.createAndInitialize(RoutingStage.Builder.class).build(resourceRoutingRoot); final ContainerFilteringStage resourceFilteringStage = locator .createAndInitialize(ContainerFilteringStage.Builder.class) .build(requestFilters, null); final RoutedInflectorExtractorStage routedInflectorExtractorStage = locator.createAndInitialize(RoutedInflectorExtractorStage.class); /** * Root linear request acceptor. This is the main entry point for the whole request processing. */ final Stage<ContainerRequest> rootStage = Stages.chain(locator.createAndInitialize(ReferencesInitializer.class)) .to(locator.createAndInitialize(ContainerMessageBodyWorkersInitializer.class)) .to(preMatchRequestFilteringStage) .to(routingStage) .to(resourceFilteringStage) .build(routedInflectorExtractorStage); // Inject instances. for (Object instance : componentBag.getInstances(ComponentBag.EXCLUDE_META_PROVIDERS)) { locator.inject(instance); } for (Object instance : resourceBag.instances) { locator.inject(instance); } // initiate resource model into JerseyResourceContext JerseyResourceContext jerseyResourceContext = locator.getService(JerseyResourceContext.class); jerseyResourceContext.setResourceModel(resourceModel); this.runtime = locator.createAndInitialize(ServerRuntime.Builder.class).build(rootStage); // inject self locator.inject(this); }