<Insert Picture Here> HK2, GlassFish, WLS and beyond Jerome Dochez GlassFish Architect
<Insert Picture Here>
HK2, GlassFish, WLS and beyond
Jerome DochezGlassFish Architect
2
The following is intended to outline our general product direction. It is intended for information
purposes only, and may not be incorporated into any contract. It is not a commitment to deliver any
material, code, or functionality, and should not be relied upon in making purchasing decisions.
The development, release, and timing of any features or functionality described for Oracle’s products
remains at the sole discretion of Oracle.
3
Current State of affairs
GlassFish–V3 released December 2009•Java EE 6 support•Modular application server based on OSGi•Support for some OSGi RFCs.•Developer focused release (fast startup, iterative deployment features)
–V3.1 work in progress•Adding cluster support•Adding session replication support•Finishing OSGi RFCs implementation
4
Current State of affairs
WebLogic Server–10.3.3 released May 2010• JRockit Flight Recorder•Coherence Integration• SCA, New security plugins, ...–10.3.4 ~ CY '10• Exalogic / Middleware Machine•RAC Datasources• Build Env / Developer Experience – Maven, etc.–CY '11/'12•Next Fusion Middleware• EE6 (Profiles)•Hk2 Integration / Microkernel convergence
5
What is HK2
HK2 is a separate open source project to help build modular server side software.–Used to build GlassFish V3–Provide an abstraction to a module subsystem like an
OSGi runtime• Bindings to Felix, Equinox and Knopplerfish•Can be used in static mode, with no module
subsystem–Provide a simple yet powerful dependency injection•No XML • Purely annotation based• Lazy instantiation/resolution
6
JDK 6
OSGi runtime
HK2
GlassFish V3
Felix, EquinoxBindings
Static Binding
GlassFish V3 Runtime
7
Shared Architecture Vision
•No OSGi dependency in code–e.g Embedded GlassFish does not require OSGi.–Simplified programming model–Fixed some OSGi design patterns not applicable to server side
software :• Focus on dynamic modules (ability to load/unload modules at
runtime)• Lazy loading/resolving rather than Activator/Extender patterns
that often require immediate resolution of modules
•Modules are not off the shelves components
8
GlassFish distinctions
•Modules are created to support GlassFish use cases •Fast startup : move away code that we don't necessarily need on startup.•Container isolation : ability to create distributions with various capabilities (no EJB container or no Web container).•Extensibility : ability to add or remove entire set of components in an installed image.
•Code relationships based on Services.
9
HK2 and WLS
•WLS and GlassFish are both Java EE application servers offered by Oracle
•So where does it intersects ?•WLS 12c is targeted to support :• Java EE 6 platform specifications• Java EE profiles...•HK2 micro-kernel•Dependency Injection•RunLevelService
10
JDK 6
GlassFish
Felix, EquinoxBindings
Iteration one of integration
GlassFish and WLS Clients WLS Server
OSGi Runtime
Static Binding
HK2
11
HK2 Features
•Abstraction to the module subsystem•Service Based Architecture•Services can be looked up or injected•Services annotated with @Service implements interfaces annotated with @Contract•Disambiguate using name •With scopes (singleton, per lookup, per thread)•Configuration handling•Binding to XML files•Transactional access•Support Validation APIs and MBeans/REST
12
Example
Contract Definition@Contractpublic interface SomeContract {void someMethod();
}
Service implementation @Service
public class SomeService implements SomeContract {..}
POJO implements POJI
13
Dependency Injection
•Service implementation @Service
public class Simple implements SomeContract { public void someMethod() {..}}•Simple client @Service
public class AnotherManagedService { @Inject
SomeContract svc;... svc.someMethod();
14
•By Contract@Inject AnInterface aInterface;
•By Name & Contract@Inject(name=“foo”) AnInterface anInterface;
•By Type@Inject AnImplementation aImpl;
“Flavors” of D.I.
15
Service Based Runtime
•Contracts implementations annotated with @Service •Optional name•Scope (singleton, perLookup, threaded)•No scope annotation = singleton•Habitat contains all the services List<Startup> list = habitat.getAllByContract(Startup.class);•Current GlassFish startup code (simplified) for (Startup s : habitat.getAllByContract(Startup.class)) {
Logger.info(“Started “ + s); }
16
Component
•Services are components, with a scope (lifecycle), have dependencies providing contracts implementation•Dependencies are expressed with @Inject•Injected resources can be resources themselves•Service allocation cascading based on D.I.•Injected resources are looked up from the habitat.
17
Server Initialization
•On startup, hk2-jars are introspected :• List of available contracts (indexes)• List of services implementing such contracts.•Lazy lookup of services. •No class-loader is created until a service is actually requested! •Experimenting with ASM to be able to use normal jar rather than enforcing hk2-jar (presence of the inhabitant file is mandatory so far).
18
Component Lifecycle
•PostContruct–Interface implemented to have a postConstruct method called after injection is performed.–Constructor cannot be intercepted.–After postConstruct is called, service is installed in the habitat.•PreDestroy–Interface called when service is removed from the habitat. –Hook for cleanup.
19
Tricks to remember
•Nobody calls services any more, they call contracts implementation.•Services are dynamic, remove an optional jar from the modules directory and its services are not available. •Services use injection to get initialized, very little explicit lookup.•Services initialization will result in multiple sub services cascade initialization :•No multi-threading•No circular references support
20
GlassFish approach to Config
•Special type of components to read/write configuration data to the domain.xml•Mapping defined via interfaces (kind of like JAXB)•Interfaces are annotated with @Configured annotation•Fields are annotated with @Attribute•Sub-elements are annotated with @Element•Supports subclassing and extensibility •Configuration mapping for WLS not finalized yet.
21
Configuration Example
@Configured public interface Server extends … { @Attribute(key=true) String name(); @Attribute String description(); @Element Replication replication;}
@Configured
public interface Replication extends ... {...}
<server name=”foo” description=”some server”> <replication .../></server>
22
Configuration extensibility
@Configuredinterface Server extends … { @Element(“*”) public List<Module> modules}
@Configured interface RailsModule extends Module { @Attribute String name();}
@Configuredpublic interface WebModule extends Module {...}
23
Configuration Extensibility (2)
<server> <rails-module name=”foo”/> <rails-module name=”bar”/> <web-module name=”xyz”/></server>
24
Configuration implementation
•Based on streaming parser•One class implements all @Configured interface (Dom.java)•Each instance of Dom creates a proxy view of the data, the proxy type is the @Configured annotated type. •User's code use interface based access, all configuration data is stored in a network of Dom instances.
25
Transactions
•Simple transactions must be started to change configuration objects. •Mutated object must be identified to the tx.•Concurrent transactions can happen as long as they don't mutate the same config instances.•Transaction are either committed or rollbacked.•Committed transaction are written to the domain.xml and listeners are notified•Transactions can be rejected by the system.•Some transactions require restart of server.
26
wait ! there is more
•Bean Validation•Mbeans–All configured interfaces instances can be automatically registered in the mbean server.
•Generic admin commands–CRUD style commands with no extra code. •REST –All configured interfaces instances available through REST interface –@RestRedirect when rest commands trigger a command invocation rather than just changing the configuration (e.g. deploy).
27
Hk2Runner – JUnit Integration
@RunWith(Hk2Runner.class)public class RunLevelServiceTest { @Inject Habitat h; @Inject(name="default") RunLevelService<?> rls; @Test void testSomething() {...};
28
Hk2 Microkernel Beyond GlassFishHow and why WebLogic Server is converging
on Hk2.
29
WLS Convergence on Hk2
•WebLogic Server• High-end, enterprise features• Very mature product (circa 1998)• Established design• Complex interdependencies between infrastructure components
30
Snapshot of some of thestartup services
XMLService
MessageInterceptionService
MigratableRMIService
EditAccessService
CompatibilityMBeanServerService
HealthMonitorService
MigratableServerServiceImpl
MigrationService
T3InitializationService
T3BindableService
CSharpInitializationService
ChannelRuntimeService
TransactionRecoveryFailBackService
TransactionRecoveryNoOpService
DefaultStoreService
TransactionService
JDBCService
StoreDeploymentService
CustomResourceServerService
CacheProviderServerService
EJBContainerService
J2EEConnectorService
ConfiguratorService
JMSService
DeploymentShutdownService
ApplicationShutdownService
AppClientDeploymentService
FileService
TimerService
HeartbeatHelperService
31
Startup Services (cont)BridgeService
SAFService
ServletContainerService
ConversationService
WTCServerLifeCycleService
WebServicesService
WSATTransactionService
RuntimeServerService
EditServerService
DomainRuntimeService
HarvesterService
ClassDeploymentService
ServerLifeCycleService
EnableAdminListenersService
ConfigImageSourceService
PathService
SNMPAgentDeploymentService
DeploymentRegistrationService
PersistenceRegistrationService
RegistrationService
ValidationService
DeploymentPreStandbyServerService
…
32
Complex Interdependencies
•Each of the services can represent a subsystem
•Each of the services require lifecycle
•Ordering of startup / shutdown is important–Previously used an ordinal numbering scheme, but that was problematic.–Each of the services on the previous diagram are now annotated with a “RunLevel” phase...
33
WLS Lifecycle
34
Motivation
•The Obvious (I.e., we wanted / needed a microkernel)•Model dependencies & lifecycle controls (internal motivation)• Service-oriented approach (internal motivation)• IoC / DI mechanism included (internal motivation)•More flexibility in profile creation (external and internal
motivations)
•DM vs HK2• Hk2 / GlassFish was out there in customer’s hands!• Hk2 abstracted the underlying module system whereas DM assumed OSGi• Hk2’s fast start-up and on-demand loading impressed
35
Notable…
•No “rewrites”•No restarts•Currently working out config details•No change to the way JVMs are started•Server is “primed” at startup, no 1st request delays•Desire to blend best of breed components
=> Hk2 would need to support new features for WLS…
36
New Features in Hk2
•The RunLevelService
•Habitat Listeners & Trackers
•Hk2Runner
•...
37
The RunLevelService
•An annotation based approach for dealing with service start levels integrated into the DI machinery•One default RunLevelService instance for the “platform”.• extensible for any one else to extend or use for subcomponent lifecycle processing.
•“Creates demand” for services (I.e., Eager initialization).•The default is lazy and not something the WLS PM's said they wanted.
38
The RunLevelService (cont)
@Contractpublic interface RunLevelService<T> { ...
/** * Causes this RunLevelService to move to * the specified run level … */ void proceedTo(int runLevel);}
39
The RunLevelService (cont)
• The @Admin Meta Annotation
@Retention(RUNTIME)@Target(TYPE)@org.jvnet.hk2.annotations.RunLevel(value=ServerStates.SRVR_ADMIN)public @interface Admin {}
• Each WLS meta annotation correlates to existing ServerStates
• @Immediate• @Starting• @Running• @StandBy
40
Example ServerService – Boot Service
@Starting@Service (name=ServerServiceTags.KERNEL)public class BootService extends AbstractServerService { @Inject (name=ServerServiceTags.IMAGE_MANAGER_SERVICE_NAME) private ServerService imageManagerService;
public void start() throws ServiceFailureException
public void stop() public void halt()
•Ordering dictated by• Injection• RunLevel
•Constraint Checking
41
Modular Server Services
•Externalize Server Profiles
•A new service is as simple as adding an annotation
•Dynamically creates the services start structure based on the selected server profile
•Keep existing WLS outward appearance• Outward Logging• Current Server State and Lifecycle Changed• Continues use of the Server Services Interface and programming
paradigms
42
Challenges
•Past challenges:–Teasing out dependencies between the subsystems (ordinal start ordering -> dependency based start ordering).
•Future challenges:–Parallelization of startup ServerServices (RLS)–Dynamic & Configuration Driven Services – Hot Rewiring–Hk2 “omni presence” in products - N x Clients & Tools–Visualization of the dependency graph (tooling)–Convergence with JSR-299 / 330