use of com.sun.enterprise.config.serverbeans.Cluster in project Payara by payara.
the class SetLogFileFormat method execute.
public void execute(AdminCommandContext context) {
String formatterClassName = null;
if (formatter.equalsIgnoreCase(ODL_FORMATTER_NAME)) {
formatterClassName = ODLLogFormatter.class.getName();
} else if (formatter.equalsIgnoreCase(ULF_FORMATTER_NAME)) {
formatterClassName = UniformLogFormatter.class.getName();
} else {
formatterClassName = formatter;
}
if (formatterClassName == null || formatter.isEmpty()) {
formatterClassName = ODLLogFormatter.class.getName();
}
Map<String, String> loggingProperties = new HashMap<String, String>();
loggingProperties.put("com.sun.enterprise.server.logging.GFFileHandler.formatter", formatterClassName);
final ActionReport report = context.getActionReport();
boolean isCluster = false;
boolean isDas = false;
boolean isInstance = false;
boolean isConfig = false;
String targetConfigName = "";
try {
Config config = domain.getConfigNamed(target);
if (config != null) {
targetConfigName = target;
isConfig = true;
} else {
Server targetServer = domain.getServerNamed(target);
if (targetServer != null) {
if (targetServer.isDas()) {
isDas = true;
} else {
isInstance = true;
Cluster clusterForInstance = targetServer.getCluster();
if (clusterForInstance != null) {
targetConfigName = clusterForInstance.getConfigRef();
} else {
targetConfigName = targetServer.getConfigRef();
}
}
} else {
com.sun.enterprise.config.serverbeans.Cluster cluster = domain.getClusterNamed(target);
if (cluster != null) {
isCluster = true;
targetConfigName = cluster.getConfigRef();
}
}
}
if (isDas) {
loggingConfig.updateLoggingProperties(loggingProperties);
} else if ((targetConfigName != null && !targetConfigName.isEmpty()) && (isCluster || isInstance || isConfig)) {
loggingConfig.updateLoggingProperties(loggingProperties, targetConfigName);
} else {
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
String msg = LOCAL_STRINGS.getLocalString("invalid.target.sys.props", "Invalid target: {0}. Valid default target is a server named ''server'' (default) or cluster name.", targetConfigName);
report.setMessage(msg);
return;
}
String successMsg = LOCAL_STRINGS.getLocalString("set.log.file.format.success", "The log file formatter is set to {0} for {1}.", formatterClassName, env.getInstanceName());
report.setMessage(successMsg);
report.setActionExitCode(ActionReport.ExitCode.SUCCESS);
} catch (IOException e) {
report.setMessage(LOCAL_STRINGS.getLocalString("set.log.file.format.failed", "Could not set log file formatter for {0}.", target));
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
}
}
use of com.sun.enterprise.config.serverbeans.Cluster in project Payara by payara.
the class UpdateApplicationRefCommand method execute.
/**
* Execution method for updating the configuration of an ApplicationRef.
* Will be replicated if the target is a cluster.
*
* @param context context for the command.
*/
@Override
public void execute(AdminCommandContext context) {
final ActionReport report = context.getActionReport();
final Logger logger = context.getLogger();
// Make a list of all ApplicationRefs that need to change
List<ApplicationRef> applicationRefsToChange = new ArrayList<>();
// Add the ApplicationRef which is being immediately targetted
{
ApplicationRef primaryApplicationRef = domain.getApplicationRefInTarget(name, target);
if (primaryApplicationRef == null) {
report.failure(logger, LOCAL_STRINGS.getLocalString("appref.not.exists", "Target {1} does not have a reference to application {0}.", name, target));
return;
}
applicationRefsToChange.add(primaryApplicationRef);
}
// Add the implicitly targetted ApplicationRefs if the target is in a cluster or deployment group
{
Cluster cluster = domain.getClusterNamed(target);
// if the target is a cluster
if (cluster != null) {
for (Server server : cluster.getInstances()) {
ApplicationRef instanceAppRef = server.getApplicationRef(name);
// if the server in the cluster contains the ApplicationRef
if (instanceAppRef != null) {
applicationRefsToChange.add(instanceAppRef);
}
}
}
DeploymentGroup dg = domain.getDeploymentGroupNamed(target);
if (dg != null) {
for (Server server : dg.getInstances()) {
ApplicationRef instanceAppRef = server.getApplicationRef(name);
// if the server in the dg contains the ApplicationRef
if (instanceAppRef != null) {
applicationRefsToChange.add(instanceAppRef);
}
}
}
}
// Apply the configuration to the listed ApplicationRefs
try {
ConfigSupport.apply(new ConfigCode() {
@Override
public Object run(ConfigBeanProxy... params) throws PropertyVetoException, TransactionFailure {
for (ConfigBeanProxy proxy : params) {
if (proxy instanceof ApplicationRef) {
ApplicationRef applicationRefProxy = (ApplicationRef) proxy;
if (enabled != null) {
applicationRefProxy.setEnabled(enabled.toString());
}
if (virtualservers != null) {
applicationRefProxy.setVirtualServers(virtualservers);
}
if (lbenabled != null) {
applicationRefProxy.setLbEnabled(lbenabled.toString());
}
}
}
report.setActionExitCode(ActionReport.ExitCode.SUCCESS);
return true;
}
}, applicationRefsToChange.toArray(new ApplicationRef[] {}));
} catch (TransactionFailure ex) {
report.failure(logger, ex.getLocalizedMessage());
}
}
use of com.sun.enterprise.config.serverbeans.Cluster in project Payara by payara.
the class CommandRunnerImpl method doCommand.
/**
* Called from ExecutionContext.execute.
*/
private void doCommand(ExecutionContext inv, AdminCommand command, final Subject subject, final Job job) {
boolean fromCheckpoint = job != null && (job.getState() == AdminCommandState.State.REVERTING || job.getState() == AdminCommandState.State.FAILED_RETRYABLE);
CommandModel model;
try {
CommandModelProvider c = CommandModelProvider.class.cast(command);
model = c.getModel();
} catch (ClassCastException e) {
model = new CommandModelImpl(command.getClass());
}
UploadedFilesManager ufm = null;
ActionReport report = inv.report();
if (!fromCheckpoint) {
report.setActionDescription(model.getCommandName() + " command");
report.setActionExitCode(ActionReport.ExitCode.SUCCESS);
}
ParameterMap parameters;
final AdminCommandContext context = new AdminCommandContextImpl(logger, report, inv.inboundPayload(), inv.outboundPayload(), job.getEventBroker(), job.getId());
context.setSubject(subject);
List<RuntimeType> runtimeTypes = new ArrayList<RuntimeType>();
FailurePolicy fp = null;
Set<CommandTarget> targetTypesAllowed = new HashSet<CommandTarget>();
ActionReport.ExitCode preSupplementalReturn = ActionReport.ExitCode.SUCCESS;
ActionReport.ExitCode postSupplementalReturn = ActionReport.ExitCode.SUCCESS;
CommandRunnerProgressHelper progressHelper = new CommandRunnerProgressHelper(command, model.getCommandName(), job, inv.progressStatusChild);
// If this glassfish installation does not have stand alone instances / clusters at all, then
// lets not even look Supplemental command and such. A small optimization
boolean doReplication = false;
if ((domain.getServers().getServer().size() > 1) || (!domain.getClusters().getCluster().isEmpty())) {
doReplication = true;
} else {
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.devmode", "The GlassFish environment does not have any clusters or instances present; Replication is turned off"));
}
try {
// Get list of suplemental commands
Collection<SupplementalCommand> suplementalCommands = supplementalExecutor.listSuplementalCommands(model.getCommandName());
try {
/*
* Extract any uploaded files and build a map from parameter names
* to the corresponding extracted, uploaded file.
*/
ufm = new UploadedFilesManager(inv.report, logger, inv.inboundPayload());
if (inv.typedParams() != null) {
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.delegatedcommand", "This command is a delegated command. Dynamic reconfiguration will be bypassed"));
InjectionResolver<Param> injectionTarget = new DelegatedInjectionResolver(model, inv.typedParams(), ufm.optionNameToFileMap());
if (injectParameters(model, command, injectionTarget, report)) {
inv.setReport(doCommand(model, command, context, progressHelper));
}
return;
}
parameters = inv.parameters();
if (parameters == null) {
// no parameters, pass an empty collection
parameters = new ParameterMap();
}
if (isSet(parameters, "help") || isSet(parameters, "Xhelp")) {
BufferedReader in = getManPage(model.getCommandName(), model);
String manPage = encodeManPage(in);
if (manPage != null && isSet(parameters, "help")) {
inv.report().getTopMessagePart().addProperty("MANPAGE", manPage);
} else {
report.getTopMessagePart().addProperty(AdminCommandResponse.GENERATED_HELP, "true");
getHelp(command, report);
}
return;
}
try {
if (!fromCheckpoint && !skipValidation(command)) {
validateParameters(model, parameters);
}
} catch (MultiException e) {
// If the cause is UnacceptableValueException -- we want the message
// from it. It is wrapped with a less useful Exception.
Exception exception = e;
for (Throwable cause : e.getErrors()) {
if (cause != null && (cause instanceof UnacceptableValueException)) {
// throw away the wrapper.
exception = (Exception) cause;
break;
}
}
logger.log(Level.SEVERE, KernelLoggerInfo.invocationException, exception);
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(exception.getMessage());
report.setFailureCause(exception);
ActionReport.MessagePart childPart = report.getTopMessagePart().addChild();
childPart.setMessage(getUsageText(model));
return;
}
// initialize the injector and inject
MapInjectionResolver injectionMgr = new MapInjectionResolver(model, parameters, ufm.optionNameToFileMap());
injectionMgr.setContext(context);
if (!injectParameters(model, command, injectionMgr, report)) {
return;
}
CommandSupport.init(habitat, command, context, job);
/*
* Now that parameters have been injected into the command object,
* decide if the current Subject should be permitted to execute
* the command. We need to wait until after injection is done
* because the class might implement its own authorization check
* and that logic might need the injected values.
*/
final Map<String, Object> env = buildEnvMap(parameters);
try {
if (!commandSecurityChecker.authorize(context.getSubject(), env, command, context)) {
/*
* If the command class tried to prepare itself but
* could not then the return is false and the command has
* set the action report accordingly. Don't process
* the command further and leave the action report alone.
*/
return;
}
} catch (SecurityException ex) {
report.setFailureCause(ex);
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(adminStrings.getLocalString("commandrunner.noauth", "User is not authorized for this command"));
return;
} catch (Exception ex) {
report.setFailureCause(ex);
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(adminStrings.getLocalString("commandrunner.errAuth", "Error during authorization"));
return;
}
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.injectiondone", "Parameter mapping, validation, injection completed successfully; Starting paramater injection"));
// Read cluster annotation attributes
org.glassfish.api.admin.ExecuteOn clAnnotation = model.getClusteringAttributes();
if (clAnnotation == null) {
runtimeTypes.add(RuntimeType.DAS);
runtimeTypes.add(RuntimeType.INSTANCE);
fp = FailurePolicy.Error;
} else {
if (clAnnotation.value().length == 0) {
runtimeTypes.add(RuntimeType.DAS);
runtimeTypes.add(RuntimeType.INSTANCE);
} else {
runtimeTypes.addAll(Arrays.asList(clAnnotation.value()));
}
if (clAnnotation.ifFailure() == null) {
fp = FailurePolicy.Error;
} else {
fp = clAnnotation.ifFailure();
}
}
TargetType tgtTypeAnnotation = command.getClass().getAnnotation(TargetType.class);
// @TargetType since we do not want to replicate the command
if (runtimeTypes.contains(RuntimeType.SINGLE_INSTANCE)) {
if (tgtTypeAnnotation != null) {
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(adminStrings.getLocalString("commandrunner.executor.targettype.unallowed", "Target type is not allowed on single instance command {0} ,", model.getCommandName()));
return;
}
// Do not replicate the command when there is
// @ExecuteOn(RuntimeType.SINGLE_INSTANCE)
doReplication = false;
}
String targetName = parameters.getOne("target");
if (targetName == null || model.getModelFor("target").getParam().obsolete()) {
if (command instanceof DeploymentTargetResolver) {
targetName = ((DeploymentTargetResolver) command).getTarget(parameters);
} else {
targetName = "server";
}
}
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.target", "@ExecuteOn parsing and default settings done; Current target is {0}", targetName));
if (serverEnv.isDas()) {
if (tgtTypeAnnotation != null) {
targetTypesAllowed.addAll(Arrays.asList(tgtTypeAnnotation.value()));
}
// If not @TargetType, default it
if (targetTypesAllowed.isEmpty()) {
targetTypesAllowed.add(CommandTarget.DAS);
targetTypesAllowed.add(CommandTarget.STANDALONE_INSTANCE);
targetTypesAllowed.add(CommandTarget.CLUSTER);
targetTypesAllowed.add(CommandTarget.CONFIG);
}
// ONLY if the target is "server"
if (CommandTarget.DAS.isValid(habitat, targetName) && !runtimeTypes.contains(RuntimeType.DAS)) {
runtimeTypes.add(RuntimeType.DAS);
}
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.runtimeTypes", "RuntimeTypes are: {0}", runtimeTypes.toString()));
logger.fine(adminStrings.getLocalString("dynamicreconfiguration,diagnostics.targetTypes", "TargetTypes are: {0}", targetTypesAllowed.toString()));
// Is there a server or a cluster or a config with given name ?
if ((!CommandTarget.DOMAIN.isValid(habitat, targetName)) && (domain.getServerNamed(targetName) == null) && (domain.getClusterNamed(targetName) == null) && (domain.getConfigNamed(targetName) == null) && (domain.getDeploymentGroupNamed(targetName) == null)) {
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(adminStrings.getLocalString("commandrunner.executor.invalidtarget", "Unable to find a valid target with name {0}", targetName));
return;
}
// Does this command allow this target type
boolean isTargetValidType = false;
Iterator<CommandTarget> it = targetTypesAllowed.iterator();
while (it.hasNext()) {
if (it.next().isValid(habitat, targetName)) {
isTargetValidType = true;
break;
}
}
if (!isTargetValidType) {
StringBuilder validTypes = new StringBuilder();
it = targetTypesAllowed.iterator();
while (it.hasNext()) {
validTypes.append(it.next().getDescription()).append(", ");
}
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(adminStrings.getLocalString("commandrunner.executor.invalidtargettype", "Target {0} is not a supported type. Command {1} supports these types of targets only : {2}", targetName, model.getCommandName(), validTypes.toString()));
return;
}
// instance, return error
if ((CommandTarget.CLUSTERED_INSTANCE.isValid(habitat, targetName)) && (!targetTypesAllowed.contains(CommandTarget.CLUSTERED_INSTANCE))) {
Cluster c = domain.getClusterForInstance(targetName);
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(adminStrings.getLocalString("commandrunner.executor.instanceopnotallowed", "The {0} command is not allowed on instance {1} because it is part of cluster {2}", model.getCommandName(), targetName, c.getName()));
return;
}
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.replicationvalidationdone", "All @ExecuteOn attribute and type validation completed successfully. Starting replication stages"));
}
/**
* We're finally ready to actually execute the command instance.
* Acquire the appropriate lock.
*/
Lock lock = null;
boolean lockTimedOut = false;
try {
// XXX: The owner of the lock should not be hardcoded. The
// value is not used yet.
lock = adminLock.getLock(command, "asadmin");
// Set there progress statuses
if (!fromCheckpoint) {
for (SupplementalCommand supplementalCommand : suplementalCommands) {
progressHelper.addProgressStatusToSupplementalCommand(supplementalCommand);
}
}
// If command is undoable, then invoke prepare method
if (command instanceof UndoableCommand) {
UndoableCommand uCmd = (UndoableCommand) command;
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.prepareunodable", "Command execution stage 1 : Calling prepare for undoable command {0}", inv.name()));
if (!uCmd.prepare(context, parameters).equals(ActionReport.ExitCode.SUCCESS)) {
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(adminStrings.getLocalString("commandrunner.executor.errorinprepare", "The command {0} cannot be completed because the preparation for the command failed " + "indicating potential issues : {1}", model.getCommandName(), report.getMessage()));
return;
}
}
ClusterOperationUtil.clearInstanceList();
// Run Supplemental commands that have to run before this command on this instance type
if (!fromCheckpoint) {
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.presupplemental", "Command execution stage 2 : Call pre supplemental commands for {0}", inv.name()));
preSupplementalReturn = supplementalExecutor.execute(suplementalCommands, Supplemental.Timing.Before, context, parameters, ufm.optionNameToFileMap());
if (preSupplementalReturn.equals(ActionReport.ExitCode.FAILURE)) {
report.setActionExitCode(preSupplementalReturn);
if (!StringUtils.ok(report.getTopMessagePart().getMessage())) {
report.setMessage(adminStrings.getLocalString("commandrunner.executor.supplementalcmdfailed", "A supplemental command failed; cannot proceed further"));
}
return;
}
}
// Run main command if it is applicable for this instance type
if ((runtimeTypes.contains(RuntimeType.ALL)) || (serverEnv.isDas() && (CommandTarget.DOMAIN.isValid(habitat, targetName) || runtimeTypes.contains(RuntimeType.DAS))) || runtimeTypes.contains(RuntimeType.SINGLE_INSTANCE) || (serverEnv.isInstance() && runtimeTypes.contains(RuntimeType.INSTANCE))) {
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.maincommand", "Command execution stage 3 : Calling main command implementation for {0}", inv.name()));
report = doCommand(model, command, context, progressHelper);
inv.setReport(report);
}
if (!FailurePolicy.applyFailurePolicy(fp, report.getActionExitCode()).equals(ActionReport.ExitCode.FAILURE)) {
// Run Supplemental commands that have to be run after this command on this instance type
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.postsupplemental", "Command execution stage 4 : Call post supplemental commands for {0}", inv.name()));
postSupplementalReturn = supplementalExecutor.execute(suplementalCommands, Supplemental.Timing.After, context, parameters, ufm.optionNameToFileMap());
if (postSupplementalReturn.equals(ActionReport.ExitCode.FAILURE)) {
report.setActionExitCode(postSupplementalReturn);
report.setMessage(adminStrings.getLocalString("commandrunner.executor.supplementalcmdfailed", "A supplemental command failed; cannot proceed further"));
return;
}
}
} catch (AdminCommandLockTimeoutException ex) {
lockTimedOut = true;
String lockTime = formatSuspendDate(ex.getTimeOfAcquisition());
String logMsg = "Command: " + model.getCommandName() + " failed to acquire a command lock. REASON: time out " + "(current lock acquired on " + lockTime + ")";
String msg = adminStrings.getLocalString("lock.timeout", "Command timed out. Unable to acquire a lock to access " + "the domain. Another command acquired exclusive access " + "to the domain on {0}. Retry the command at a later " + "time.", lockTime);
report.setMessage(msg);
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
} catch (AdminCommandLockException ex) {
lockTimedOut = true;
String lockTime = formatSuspendDate(ex.getTimeOfAcquisition());
String lockMsg = ex.getMessage();
String logMsg;
logMsg = "Command: " + model.getCommandName() + " was blocked. The domain was suspended by a " + "user on:" + lockTime;
if (lockMsg != null && !lockMsg.isEmpty()) {
logMsg += " Reason: " + lockMsg;
}
String msg = adminStrings.getLocalString("lock.notacquired", "The command was blocked. The domain was suspended by " + "a user on {0}.", lockTime);
if (lockMsg != null && !lockMsg.isEmpty()) {
msg += " " + adminStrings.getLocalString("lock.reason", "Reason:") + " " + lockMsg;
}
report.setMessage(msg);
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
} finally {
// command is done, release the lock
if (lock != null && lockTimedOut == false) {
lock.unlock();
}
}
} catch (Exception ex) {
logger.log(Level.SEVERE, KernelLoggerInfo.invocationException, ex);
report.setActionExitCode(ActionReport.ExitCode.FAILURE);
report.setMessage(ex.getMessage());
report.setFailureCause(ex);
ActionReport.MessagePart childPart = report.getTopMessagePart().addChild();
childPart.setMessage(getUsageText(model));
return;
}
if (processEnv.getProcessType().isEmbedded()) {
return;
}
if (preSupplementalReturn == ActionReport.ExitCode.WARNING || postSupplementalReturn == ActionReport.ExitCode.WARNING) {
report.setActionExitCode(ActionReport.ExitCode.WARNING);
}
if (doReplication && (!FailurePolicy.applyFailurePolicy(fp, report.getActionExitCode()).equals(ActionReport.ExitCode.FAILURE)) && (serverEnv.isDas()) && (runtimeTypes.contains(RuntimeType.INSTANCE) || runtimeTypes.contains(RuntimeType.ALL))) {
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.startreplication", "Command execution stages completed on DAS; Starting replication on remote instances"));
ClusterExecutor executor = null;
// This try-catch block is a fix for 13838
try {
if (model.getClusteringAttributes() != null && model.getClusteringAttributes().executor() != null) {
executor = habitat.getService(model.getClusteringAttributes().executor());
} else {
executor = habitat.getService(ClusterExecutor.class, "GlassFishClusterExecutor");
}
} catch (UnsatisfiedDependencyException usdepex) {
logger.log(Level.WARNING, KernelLoggerInfo.cantGetClusterExecutor, usdepex);
}
if (executor != null) {
report.setActionExitCode(executor.execute(model.getCommandName(), command, context, parameters));
if (report.getActionExitCode().equals(ActionReport.ExitCode.FAILURE)) {
report.setMessage(adminStrings.getLocalString("commandrunner.executor.errorwhilereplication", "An error occurred during replication"));
} else {
if (!FailurePolicy.applyFailurePolicy(fp, report.getActionExitCode()).equals(ActionReport.ExitCode.FAILURE)) {
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.afterreplsupplemental", "Command execution stage 5 : Call post-replication supplemental commands for {0}", inv.name()));
ActionReport.ExitCode afterReplicationSupplementalReturn = supplementalExecutor.execute(suplementalCommands, Supplemental.Timing.AfterReplication, context, parameters, ufm.optionNameToFileMap());
if (afterReplicationSupplementalReturn.equals(ActionReport.ExitCode.FAILURE)) {
report.setActionExitCode(afterReplicationSupplementalReturn);
report.setMessage(adminStrings.getLocalString("commandrunner.executor.supplementalcmdfailed", "A supplemental command failed; cannot proceed further"));
return;
}
}
}
}
}
if (report.getActionExitCode().equals(ActionReport.ExitCode.FAILURE)) {
// If command is undoable, then invoke undo method method
if (command instanceof UndoableCommand) {
UndoableCommand uCmd = (UndoableCommand) command;
logger.fine(adminStrings.getLocalString("dynamicreconfiguration.diagnostics.undo", "Command execution failed; calling undo() for command {0}", inv.name()));
uCmd.undo(context, parameters, ClusterOperationUtil.getCompletedInstances());
}
} else {
// TODO : Is there a better way of doing this ? Got to look into it
if ("_register-instance".equals(model.getCommandName())) {
state.addServerToStateService(parameters.getOne("DEFAULT"));
}
if ("_unregister-instance".equals(model.getCommandName())) {
state.removeInstanceFromStateService(parameters.getOne("DEFAULT"));
}
}
} finally {
if (ufm != null) {
ufm.close();
}
}
}
use of com.sun.enterprise.config.serverbeans.Cluster in project Payara by payara.
the class CombinedJavaConfigSystemPropertyListener method changed.
/* force serial behavior; don't allow more than one thread to make a mess here */
@Override
public synchronized UnprocessedChangeEvents changed(PropertyChangeEvent[] events) {
// ignore a REMOVE and an ADD of the same value
final UnprocessedChangeEvents unp = ConfigSupport.sortAndDispatch(events, new Changed() {
@Override
public <T extends ConfigBeanProxy> NotProcessed changed(TYPE type, Class<T> tc, T t) {
NotProcessed result = null;
if (tc == Profiler.class) {
result = new NotProcessed("Creation or changes to a profiler require restart");
} else if (tc == Property.class && t.getParent().getClass() == JavaConfig.class) {
result = new NotProcessed("Addition of properties to JavaConfig requires restart");
} else if (tc == JavaConfig.class && t instanceof JavaConfig) {
final JavaConfig njc = (JavaConfig) t;
logFine(type, njc);
// we must *always* check the jvm options, no way to know except by comparing,
// plus we should send an appropriate message back for each removed/added item
final List<String> curProps = new ArrayList<String>(njc.getJvmOptions());
final boolean jvmOptionsWereChanged = !oldProps.equals(curProps);
final List<String> reasons = handle(oldProps, curProps);
oldProps = curProps;
// something in the JavaConfig itself changed
// to do this well, we ought to keep a list of attributes, so we can make a good message
// saying exactly which attribute what changed
final Map<String, String> curAttrs = collectAttrs(njc);
reasons.addAll(handleAttrs(oldAttrs, curAttrs));
oldAttrs = curAttrs;
result = reasons.isEmpty() ? null : new NotProcessed(CombinedJavaConfigSystemPropertyListener.toString(reasons));
} else if (tc == SystemProperty.class && t instanceof SystemProperty) {
final SystemProperty sp = (SystemProperty) t;
// check to see if this system property is for this instance
ConfigBeanProxy proxy = sp.getParent();
ConfigView p = ConfigSupport.getImpl(proxy);
if (p == ConfigSupport.getImpl(server) || p == ConfigSupport.getImpl(config) || (cluster != null && p == ConfigSupport.getImpl(cluster)) || p == ConfigSupport.getImpl(domain)) {
// check to see if this system property is referenced by any of the options
String pname = sp.getName();
if (referencesProperty(pname, oldProps) || referencesProperty(pname, oldAttrs.values())) {
result = new NotProcessed("The system-property, " + pname + ", that is referenced by the Java configuration, was modified");
}
}
if (type == TYPE.ADD || type == TYPE.CHANGE) {
// create-system-properties
if (proxy instanceof Domain) {
return addToDomain(sp);
} else if (proxy instanceof Config && p == ConfigSupport.getImpl(config)) {
return addToConfig(sp);
} else if (cluster != null && proxy instanceof Cluster && p == ConfigSupport.getImpl(cluster)) {
return addToCluster(sp);
} else if (proxy instanceof Server && p == ConfigSupport.getImpl(server)) {
return addToServer(sp);
}
} else if (type == TYPE.REMOVE) {
if (proxy instanceof Domain) {
return removeFromDomain(sp);
} else if (proxy instanceof Config && p == ConfigSupport.getImpl(config)) {
return removeFromConfig(sp);
} else if (cluster != null && proxy instanceof Cluster && p == ConfigSupport.getImpl(cluster)) {
return removeFromCluster(sp);
} else if (proxy instanceof Server && p == ConfigSupport.getImpl(server)) {
return removeFromServer(sp);
}
}
} else {
// ignore other changes that are reported
}
return result;
}
}, logger);
return unp;
}
use of com.sun.enterprise.config.serverbeans.Cluster in project Payara by payara.
the class ApplicationConfigListener method transactionCommited.
public void transactionCommited(final List<PropertyChangeEvent> changes) {
boolean isUpdatingAttribute = true;
for (PropertyChangeEvent event : changes) {
Object oldValue = event.getOldValue();
Object newValue = event.getNewValue();
if (event.getSource() instanceof Applications) {
if (event.getPropertyName().equals(ServerTags.APPLICATION)) {
if (oldValue == null || newValue == null) {
// we are adding/removing application element here
// and updating existing attribute
isUpdatingAttribute = false;
break;
}
}
} else if (event.getSource() instanceof Server || event.getSource() instanceof Cluster) {
if (event.getPropertyName().equals(ServerTags.APPLICATION_REF)) {
if (oldValue == null || newValue == null) {
// we are adding/removing application-ref element here
// and updating existing attribute
isUpdatingAttribute = false;
break;
}
}
}
}
if (!isUpdatingAttribute) {
// skip the config listener
return;
}
for (PropertyChangeEvent event : changes) {
if (event.getSource() instanceof Application || event.getSource() instanceof ApplicationRef || event.getSource() instanceof Property) {
Object oldValue = event.getOldValue();
Object newValue = event.getNewValue();
String propertyName = null;
if (oldValue != null && newValue != null && oldValue instanceof String && newValue instanceof String && !((String) oldValue).equals((String) newValue)) {
// if it's an attribute change of the application
// element or application-ref element
Object parent = event.getSource();
String appName = null;
if (parent instanceof Application) {
appName = ((Application) parent).getName();
propertyName = event.getPropertyName();
} else if (parent instanceof ApplicationRef) {
appName = ((ApplicationRef) parent).getRef();
propertyName = event.getPropertyName();
} else if (parent instanceof Property) {
appName = ((Property) parent).getParent(Application.class).getName();
propertyName = ((Property) parent).getName();
}
// anything
if (applications.getApplication(appName) == null) {
return;
}
if (ServerTags.ENABLED.equals(propertyName)) {
// enable or disable application accordingly
handleAppEnableChange(event.getSource(), appName, Boolean.valueOf((String) newValue));
} else if (ServerTags.CONTEXT_ROOT.equals(propertyName) || ServerTags.VIRTUAL_SERVERS.equals(propertyName) || ServerTags.AVAILABILITY_ENABLED.equals(propertyName) || ServerTags.CDI_DEV_MODE_ENABLED_PROP.equals(propertyName)) {
// for other changes, reload the application
handleOtherAppConfigChanges(event.getSource(), appName);
}
}
}
}
}
Aggregations