private void performRecoveryEnvBoottime(
OperationContext context, ModelNode model, final boolean jts, List<ServiceName> deps)
throws OperationFailedException {
// recovery environment
final String recoveryBindingName =
TransactionSubsystemRootResourceDefinition.BINDING
.resolveModelAttribute(context, model)
.asString();
final String recoveryStatusBindingName =
TransactionSubsystemRootResourceDefinition.STATUS_BINDING
.resolveModelAttribute(context, model)
.asString();
final boolean recoveryListener =
TransactionSubsystemRootResourceDefinition.RECOVERY_LISTENER
.resolveModelAttribute(context, model)
.asBoolean();
// XATerminator has no deps, so just add it in there
final XATerminatorService xaTerminatorService = new XATerminatorService(jts);
context
.getServiceTarget()
.addService(TxnServices.JBOSS_TXN_XA_TERMINATOR, xaTerminatorService)
.setInitialMode(Mode.ACTIVE)
.install();
final ArjunaRecoveryManagerService recoveryManagerService =
new ArjunaRecoveryManagerService(recoveryListener, jts);
final ServiceBuilder<RecoveryManagerService> recoveryManagerServiceServiceBuilder =
context
.getServiceTarget()
.addService(TxnServices.JBOSS_TXN_ARJUNA_RECOVERY_MANAGER, recoveryManagerService);
// add dependency on JTA environment bean
recoveryManagerServiceServiceBuilder.addDependencies(deps);
if (jts) {
recoveryManagerServiceServiceBuilder.addDependency(
ServiceName.JBOSS.append("iiop-openjdk", "orb-service"),
ORB.class,
recoveryManagerService.getOrbInjector());
}
recoveryManagerServiceServiceBuilder
.addDependency(
SocketBinding.JBOSS_BINDING_NAME.append(recoveryBindingName),
SocketBinding.class,
recoveryManagerService.getRecoveryBindingInjector())
.addDependency(
SocketBinding.JBOSS_BINDING_NAME.append(recoveryStatusBindingName),
SocketBinding.class,
recoveryManagerService.getStatusBindingInjector())
.addDependency(
SocketBindingManager.SOCKET_BINDING_MANAGER,
SocketBindingManager.class,
recoveryManagerService.getBindingManager())
.addDependency(TxnServices.JBOSS_TXN_CORE_ENVIRONMENT)
.addDependency(TxnServices.JBOSS_TXN_ARJUNA_OBJECTSTORE_ENVIRONMENT)
.setInitialMode(ServiceController.Mode.ACTIVE)
.install();
}
@Override
protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model)
throws OperationFailedException {
ServiceRegistry registry = context.getServiceRegistry(false);
final ServiceName serviceName =
MessagingServices.getActiveMQServiceName(
PathAddress.pathAddress(operation.get(ModelDescriptionConstants.OP_ADDR)));
ServiceController<?> service = registry.getService(serviceName);
if (service != null) {
context.reloadRequired();
} else {
final PathAddress address = PathAddress.pathAddress(operation.require(OP_ADDR));
final String name = address.getLastElement().getValue();
final ServiceTarget target = context.getServiceTarget();
if (model.hasDefined(JGROUPS_CHANNEL.getName())) {
// nothing to do, in that case, the clustering.jgroups subsystem will have setup the stack
} else if (model.hasDefined(RemoteTransportDefinition.SOCKET_BINDING.getName())) {
final GroupBindingService bindingService = new GroupBindingService();
target
.addService(
GroupBindingService.getBroadcastBaseServiceName(serviceName).append(name),
bindingService)
.addDependency(
SocketBinding.JBOSS_BINDING_NAME.append(model.get(SOCKET_BINDING).asString()),
SocketBinding.class,
bindingService.getBindingRef())
.install();
}
}
}
public AbstractProtocolConfigurationBuilder<P> setSocketBinding(String socketBindingName) {
if (socketBindingName != null) {
this.socketBinding =
new InjectedValueDependency<>(
SocketBinding.JBOSS_BINDING_NAME.append(socketBindingName), SocketBinding.class);
}
return this;
}
@Override
protected void performRuntime(
OperationContext context,
ModelNode operation,
ModelNode model,
ServiceVerificationHandler verificationHandler,
List<ServiceController<?>> newControllers)
throws OperationFailedException {
final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
final PathAddress parent = address.subAddress(0, address.size() - 1);
String name = address.getLastElement().getValue();
String bindingRef =
ListenerResourceDefinition.SOCKET_BINDING.resolveModelAttribute(context, model).asString();
String workerName =
ListenerResourceDefinition.WORKER.resolveModelAttribute(context, model).asString();
String bufferPoolName =
ListenerResourceDefinition.BUFFER_POOL.resolveModelAttribute(context, model).asString();
boolean enabled =
ListenerResourceDefinition.ENABLED.resolveModelAttribute(context, model).asBoolean();
OptionMap listenerOptions =
OptionList.resolveOptions(context, model, ListenerResourceDefinition.LISTENER_OPTIONS);
OptionMap socketOptions =
OptionList.resolveOptions(context, model, ListenerResourceDefinition.SOCKET_OPTIONS);
String serverName = parent.getLastElement().getValue();
final ServiceName listenerServiceName = UndertowService.listenerName(name);
final ListenerService<? extends ListenerService> service =
createService(name, serverName, context, model, listenerOptions, socketOptions);
final ServiceBuilder<? extends ListenerService> serviceBuilder =
context.getServiceTarget().addService(listenerServiceName, service);
serviceBuilder
.addDependency(IOServices.WORKER.append(workerName), XnioWorker.class, service.getWorker())
.addDependency(
SocketBinding.JBOSS_BINDING_NAME.append(bindingRef),
SocketBinding.class,
service.getBinding())
.addDependency(
IOServices.BUFFER_POOL.append(bufferPoolName), Pool.class, service.getBufferPool())
.addDependency(
UndertowService.SERVER.append(serverName), Server.class, service.getServerService());
configureAdditionalDependencies(context, serviceBuilder, model, service);
serviceBuilder.setInitialMode(
enabled ? ServiceController.Mode.ACTIVE : ServiceController.Mode.NEVER);
serviceBuilder.addListener(verificationHandler);
final ServiceController<? extends ListenerService> serviceController = serviceBuilder.install();
if (newControllers != null) {
newControllers.add(serviceController);
}
}
protected void performRuntime(
OperationContext context,
ModelNode operation,
ModelNode model,
ServiceVerificationHandler verificationHandler,
List<ServiceController<?>> newControllers)
throws OperationFailedException {
// TODO SASL and properties
final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
final String connectorName = address.getLastElement().getValue();
final ServiceTarget target = context.getServiceTarget();
ServiceName socketBindingName =
SocketBinding.JBOSS_BINDING_NAME.append(
ConnectorResource.SOCKET_BINDING_ATTRIBUTE.validateOperation(model).asString());
RemotingServices.installConnectorServicesForSocketBinding(
target,
RemotingServices.SUBSYSTEM_ENDPOINT,
connectorName,
socketBindingName,
null,
null,
verificationHandler,
newControllers);
// TODO AuthenticationHandler
//
// final ConnectorService connectorService = new ConnectorService();
// connectorService.setOptionMap(createOptionMap(operation));
//
// // Register the service with the container and inject dependencies.
// final ServiceName connectorName = RemotingServices.connectorServiceName(name);
// try {
// newControllers.add(target.addService(connectorName, connectorService)
// .addDependency(connectorName.append("auth-provider"),
// ServerAuthenticationProvider.class, connectorService.getAuthenticationProviderInjector())
// .addDependency(RemotingServices.SUBSYSTEM_ENDPOINT, Endpoint.class,
// connectorService.getEndpointInjector())
// .addListener(verificationHandler)
// .setInitialMode(ServiceController.Mode.ACTIVE)
// .install());
//
// // TODO create XNIO connector service from socket-binding, with dependency on
// connectorName
// } catch (ServiceRegistryException e) {
// throw new OperationFailedException(new ModelNode().set(e.getLocalizedMessage()));
// }
}
private void performCoreEnvironmentBootTime(OperationContext context, ModelNode coreEnvModel)
throws OperationFailedException {
// Configure the core configuration.
final String nodeIdentifier =
TransactionSubsystemRootResourceDefinition.NODE_IDENTIFIER
.resolveModelAttribute(context, coreEnvModel)
.asString();
TransactionLogger.ROOT_LOGGER.debugf("nodeIdentifier=%s%n", nodeIdentifier);
final CoreEnvironmentService coreEnvironmentService =
new CoreEnvironmentService(nodeIdentifier);
String socketBindingName = null;
if (TransactionSubsystemRootResourceDefinition.PROCESS_ID_UUID
.resolveModelAttribute(context, coreEnvModel)
.asBoolean(false)) {
// Use the UUID based id
UuidProcessId id = new UuidProcessId();
coreEnvironmentService.setProcessImplementation(id);
} else {
// Use the socket process id
coreEnvironmentService.setProcessImplementationClassName(ProcessIdType.SOCKET.getClazz());
socketBindingName =
TransactionSubsystemRootResourceDefinition.PROCESS_ID_SOCKET_BINDING
.resolveModelAttribute(context, coreEnvModel)
.asString();
int ports =
TransactionSubsystemRootResourceDefinition.PROCESS_ID_SOCKET_MAX_PORTS
.resolveModelAttribute(context, coreEnvModel)
.asInt();
coreEnvironmentService.setSocketProcessIdMaxPorts(ports);
}
final ServiceBuilder<?> coreEnvBuilder =
context
.getServiceTarget()
.addService(TxnServices.JBOSS_TXN_CORE_ENVIRONMENT, coreEnvironmentService);
if (socketBindingName != null) {
// Add a dependency on the socket id binding
ServiceName bindingName = SocketBinding.JBOSS_BINDING_NAME.append(socketBindingName);
coreEnvBuilder.addDependency(
bindingName,
SocketBinding.class,
coreEnvironmentService.getSocketProcessBindingInjector());
}
coreEnvBuilder.setInitialMode(ServiceController.Mode.ACTIVE).install();
}
@Override
protected void performRuntime(
OperationContext context,
ModelNode operation,
ModelNode model,
ServiceVerificationHandler verificationHandler,
List<ServiceController<?>> newControllers)
throws OperationFailedException {
final ModelNode fullModel =
Resource.Tools.readModel(context.readResource(PathAddress.EMPTY_ADDRESS));
// Use ModClusterExtension.configurationPath here so if we change the PathElement components,
// we don't have to change this code
final ModelNode unresolvedConfig =
fullModel.get(
ModClusterExtension.configurationPath.getKey(),
ModClusterExtension.configurationPath.getValue());
final ModelNode resolvedConfig = resolveConfig(context, unresolvedConfig);
// Add mod_cluster service
final ModClusterService service = new ModClusterService(resolvedConfig);
final ServiceBuilder<ModCluster> serviceBuilder =
context
.getServiceTarget()
.addService(ModClusterService.NAME, service)
.addDependency(WebSubsystemServices.JBOSS_WEB, WebServer.class, service.getWebServer())
.addDependency(
SocketBindingManager.SOCKET_BINDING_MANAGER,
SocketBindingManager.class,
service.getBindingManager())
.addListener(verificationHandler)
.setInitialMode(Mode.ACTIVE);
final ModelNode bindingRefNode =
resolvedConfig.get(ModClusterConfigResourceDefinition.ADVERTISE_SOCKET.getName());
final String bindingRef = bindingRefNode.isDefined() ? bindingRefNode.asString() : null;
if (bindingRef != null) {
serviceBuilder.addDependency(
SocketBinding.JBOSS_BINDING_NAME.append(bindingRef),
SocketBinding.class,
service.getBinding());
}
newControllers.add(serviceBuilder.install());
}
@Override
public Builder<P> configure(OperationContext context, ModelNode model)
throws OperationFailedException {
this.module =
ModelNodes.asModuleIdentifier(MODULE.getDefinition().resolveModelAttribute(context, model));
String binding =
ModelNodes.asString(SOCKET_BINDING.getDefinition().resolveModelAttribute(context, model));
if (binding != null) {
this.socketBinding =
new InjectedValueDependency<>(
SocketBinding.JBOSS_BINDING_NAME.append(binding), SocketBinding.class);
}
for (Property property :
ModelNodes.asPropertyList(
PROPERTIES.getDefinition().resolveModelAttribute(context, model))) {
this.properties.put(property.getName(), property.getValue().asString());
}
return this;
}
public static ServiceController<SocketBinding> installBindingService(
OperationContext context, ModelNode resolvedConfig, String name) throws UnknownHostException {
final ServiceTarget serviceTarget = context.getServiceTarget();
final String intf =
resolvedConfig.get(INTERFACE).isDefined() ? resolvedConfig.get(INTERFACE).asString() : null;
final int port = resolvedConfig.get(PORT).asInt();
final boolean fixedPort = resolvedConfig.get(FIXED_PORT).asBoolean(false);
final String mcastAddr =
resolvedConfig.get(MULTICAST_ADDRESS).isDefined()
? resolvedConfig.get(MULTICAST_ADDRESS).asString()
: null;
final int mcastPort =
resolvedConfig.get(MULTICAST_PORT).isDefined()
? resolvedConfig.get(MULTICAST_PORT).asInt()
: 0;
final InetAddress mcastInet = mcastAddr == null ? null : InetAddress.getByName(mcastAddr);
final SocketBindingService service =
new SocketBindingService(name, port, fixedPort, mcastInet, mcastPort);
final ServiceBuilder<SocketBinding> builder =
serviceTarget.addService(SocketBinding.JBOSS_BINDING_NAME.append(name), service);
if (intf != null) {
builder.addDependency(
NetworkInterfaceService.JBOSS_NETWORK_INTERFACE.append(intf),
NetworkInterfaceBinding.class,
service.getInterfaceBinding());
}
return builder
.addDependency(
SocketBindingManager.SOCKET_BINDING_MANAGER,
SocketBindingManager.class,
service.getSocketBindings())
.setInitialMode(Mode.ON_DEMAND)
.install();
}
static ServiceController<FilterService> install(
String name, ServiceTarget serviceTarget, ModelNode model, OperationContext operationContext)
throws OperationFailedException {
String securityKey = null;
ModelNode securityKeyNode =
ModClusterDefinition.SECURITY_KEY.resolveModelAttribute(operationContext, model);
if (securityKeyNode.isDefined()) {
securityKey = securityKeyNode.asString();
}
String managementAccessPredicateString = null;
ModelNode managementAccessPredicateNode =
ModClusterDefinition.MANAGEMENT_ACCESS_PREDICATE.resolveModelAttribute(
operationContext, model);
if (managementAccessPredicateNode.isDefined()) {
managementAccessPredicateString = managementAccessPredicateNode.asString();
}
Predicate managementAccessPredicate = null;
if (managementAccessPredicateString != null) {
managementAccessPredicate =
PredicateParser.parse(
managementAccessPredicateString, ModClusterService.class.getClassLoader());
}
final ModelNode securityRealm =
ModClusterDefinition.SECURITY_REALM.resolveModelAttribute(operationContext, model);
ModClusterService service =
new ModClusterService(
model,
ModClusterDefinition.HEALTH_CHECK_INTERVAL
.resolveModelAttribute(operationContext, model)
.asInt(),
ModClusterDefinition.MAX_REQUEST_TIME
.resolveModelAttribute(operationContext, model)
.asInt(),
ModClusterDefinition.BROKEN_NODE_TIMEOUT
.resolveModelAttribute(operationContext, model)
.asInt(),
ModClusterDefinition.ADVERTISE_FREQUENCY
.resolveModelAttribute(operationContext, model)
.asInt(),
ModClusterDefinition.ADVERTISE_PATH
.resolveModelAttribute(operationContext, model)
.asString(),
ModClusterDefinition.ADVERTISE_PROTOCOL
.resolveModelAttribute(operationContext, model)
.asString(),
securityKey,
managementAccessPredicate,
ModClusterDefinition.CONNECTIONS_PER_THREAD
.resolveModelAttribute(operationContext, model)
.asInt(),
ModClusterDefinition.CACHED_CONNECTIONS_PER_THREAD
.resolveModelAttribute(operationContext, model)
.asInt(),
ModClusterDefinition.CONNECTION_IDLE_TIMEOUT
.resolveModelAttribute(operationContext, model)
.asInt(),
ModClusterDefinition.REQUEST_QUEUE_SIZE
.resolveModelAttribute(operationContext, model)
.asInt(),
ModClusterDefinition.USE_ALIAS
.resolveModelAttribute(operationContext, model)
.asBoolean());
ServiceBuilder<FilterService> builder =
serviceTarget.addService(UndertowService.FILTER.append(name), service);
builder.addDependency(
SocketBinding.JBOSS_BINDING_NAME.append(
ModClusterDefinition.MANAGEMENT_SOCKET_BINDING
.resolveModelAttribute(operationContext, model)
.asString()),
SocketBinding.class,
service.managementSocketBinding);
builder.addDependency(
SocketBinding.JBOSS_BINDING_NAME.append(
ModClusterDefinition.ADVERTISE_SOCKET_BINDING
.resolveModelAttribute(operationContext, model)
.asString()),
SocketBinding.class,
service.advertiseSocketBinding);
builder.addDependency(
IOServices.WORKER.append(
ModClusterDefinition.WORKER.resolveModelAttribute(operationContext, model).asString()),
XnioWorker.class,
service.workerInjectedValue);
if (securityRealm.isDefined()) {
SecurityRealm.ServiceUtil.addDependency(
builder, service.securityRealm, securityRealm.asString(), false);
}
return builder.install();
}
static void installHttpManagementConnector(
final OperationContext context,
final ModelNode model,
final ServiceTarget serviceTarget,
final ServiceVerificationHandler verificationHandler,
final List<ServiceController<?>> newControllers)
throws OperationFailedException {
ServiceName socketBindingServiceName = null;
ServiceName secureSocketBindingServiceName = null;
ServiceName interfaceSvcName = null;
int port = -1;
int securePort = -1;
final ModelNode interfaceModelNode = validateResolvedModel(INTERFACE, context, model);
if (interfaceModelNode.isDefined()) {
// Legacy config
String interfaceName = interfaceModelNode.asString();
interfaceSvcName = NetworkInterfaceService.JBOSS_NETWORK_INTERFACE.append(interfaceName);
final ModelNode portNode = HTTP_PORT.resolveModelAttribute(context, model);
port = portNode.isDefined() ? portNode.asInt() : -1;
final ModelNode securePortNode = HTTPS_PORT.resolveModelAttribute(context, model);
securePort = securePortNode.isDefined() ? securePortNode.asInt() : -1;
// Log the config
if (securePort > -1) {
if (port > -1) {
ServerLogger.ROOT_LOGGER.creatingHttpManagementServiceOnPortAndSecurePort(
interfaceName, port, securePort);
} else {
ServerLogger.ROOT_LOGGER.creatingHttpManagementServiceOnSecurePort(
interfaceName, securePort);
}
} else if (port > -1) {
ServerLogger.ROOT_LOGGER.creatingHttpManagementServiceOnPort(interfaceName, port);
}
} else {
// Socket-binding reference based config
final ModelNode socketBindingNode = SOCKET_BINDING.resolveModelAttribute(context, model);
if (socketBindingNode.isDefined()) {
final String bindingName = socketBindingNode.asString();
socketBindingServiceName = SocketBinding.JBOSS_BINDING_NAME.append(bindingName);
}
final ModelNode secureSocketBindingNode =
SECURE_SOCKET_BINDING.resolveModelAttribute(context, model);
if (secureSocketBindingNode.isDefined()) {
final String bindingName = secureSocketBindingNode.asString();
secureSocketBindingServiceName = SocketBinding.JBOSS_BINDING_NAME.append(bindingName);
}
// Log the config
if (socketBindingServiceName != null) {
if (secureSocketBindingServiceName != null) {
ServerLogger.ROOT_LOGGER.creatingHttpManagementServiceOnSocketAndSecureSocket(
socketBindingServiceName.getSimpleName(),
secureSocketBindingServiceName.getSimpleName());
} else {
ServerLogger.ROOT_LOGGER.creatingHttpManagementServiceOnSocket(
socketBindingServiceName.getSimpleName());
}
} else if (secureSocketBindingServiceName != null) {
ServerLogger.ROOT_LOGGER.creatingHttpManagementServiceOnSecureSocket(
secureSocketBindingServiceName.getSimpleName());
}
}
ServiceName realmSvcName = null;
final ModelNode realmNode = SECURITY_REALM.resolveModelAttribute(context, model);
if (realmNode.isDefined()) {
realmSvcName = SecurityRealmService.BASE_SERVICE_NAME.append(realmNode.asString());
} else {
ServerLogger.ROOT_LOGGER.httpManagementInterfaceIsUnsecured();
}
boolean consoleEnabled = model.get(ModelDescriptionConstants.CONSOLE_ENABLED).asBoolean(true);
ConsoleMode consoleMode;
if (consoleEnabled) {
consoleMode =
context.getRunningMode() == RunningMode.ADMIN_ONLY
? ConsoleMode.ADMIN_ONLY
: ConsoleMode.CONSOLE;
} else {
consoleMode = ConsoleMode.NO_CONSOLE;
}
ServerEnvironment environment =
(ServerEnvironment)
context
.getServiceRegistry(false)
.getRequiredService(ServerEnvironmentService.SERVICE_NAME)
.getValue();
final HttpManagementService service =
new HttpManagementService(consoleMode, environment.getProductConfig().getConsoleSlot());
ServiceBuilder<HttpManagement> builder =
serviceTarget
.addService(HttpManagementService.SERVICE_NAME, service)
.addDependency(
Services.JBOSS_SERVER_CONTROLLER,
ModelController.class,
service.getModelControllerInjector())
.addDependency(
SocketBindingManagerImpl.SOCKET_BINDING_MANAGER,
SocketBindingManager.class,
service.getSocketBindingManagerInjector())
.addDependency(
ControlledProcessStateService.SERVICE_NAME,
ControlledProcessStateService.class,
service.getControlledProcessStateServiceInjector())
.addInjection(
service.getExecutorServiceInjector(),
Executors.newCachedThreadPool(
new JBossThreadFactory(
new ThreadGroup("HttpManagementService-threads"),
Boolean.FALSE,
null,
"%G - %t",
null,
null,
AccessController.getContext())));
if (interfaceSvcName != null) {
builder
.addDependency(
interfaceSvcName, NetworkInterfaceBinding.class, service.getInterfaceInjector())
.addInjection(service.getPortInjector(), port)
.addInjection(service.getSecurePortInjector(), securePort);
} else {
if (socketBindingServiceName != null) {
builder.addDependency(
socketBindingServiceName, SocketBinding.class, service.getSocketBindingInjector());
}
if (secureSocketBindingServiceName != null) {
builder.addDependency(
secureSocketBindingServiceName,
SocketBinding.class,
service.getSecureSocketBindingInjector());
}
}
if (realmSvcName != null) {
builder.addDependency(
realmSvcName, SecurityRealmService.class, service.getSecurityRealmInjector());
}
if (verificationHandler != null) {
builder.addListener(verificationHandler);
}
ServiceController<?> controller = builder.install();
if (newControllers != null) {
newControllers.add(controller);
}
}