Example #1
0
 ReadOnlyContext(
     final ProcessType processType,
     final RunningMode runningMode,
     final ModelController.OperationTransactionControl transactionControl,
     final ControlledProcessState processState,
     final boolean booting,
     final ModelControllerImpl.ManagementModelImpl managementModel,
     final AbstractOperationContext primaryContext,
     final ModelControllerImpl controller,
     final int operationId,
     final Supplier<SecurityIdentity> securityIdentitySupplier) {
   super(
       processType,
       runningMode,
       transactionControl,
       processState,
       booting,
       controller.getAuditLogger(),
       controller.getNotificationSupport(),
       controller,
       true,
       null,
       securityIdentitySupplier);
   this.primaryContext = primaryContext;
   this.controller = controller;
   this.operationId = operationId;
   this.managementModel = managementModel;
 }
  @Override
  void releaseStepLocks(AbstractOperationContext.Step step) {

    if (this.lockStep == step) {
      modelController.releaseLock();
      lockStep = null;
    }
    if (this.containerMonitorStep == step) {
      awaitContainerMonitor();
      modelController.releaseContainerMonitor();
      containerMonitorStep = null;
    }
  }
 @Override
 void awaitModelControllerContainerMonitor() throws InterruptedException {
   if (affectsRuntime) {
     MGMT_OP_LOGGER.debugf("Entered VERIFY stage; waiting for service container to settle");
     // First wait until any removals we've initiated have begun processing, otherwise
     // the ContainerStateMonitor may not have gotten the notification causing it to untick
     final Map<ServiceName, ServiceController<?>> map = realRemovingControllers;
     synchronized (map) {
       while (!map.isEmpty()) {
         map.wait();
       }
     }
     ContainerStateMonitor.ContainerStateChangeReport changeReport =
         modelController.awaitContainerStateChangeReport(1);
     // If any services are missing, add a verification handler to see if we caused it
     if (changeReport != null && !changeReport.getMissingServices().isEmpty()) {
       ServiceRemovalVerificationHandler removalVerificationHandler =
           new ServiceRemovalVerificationHandler(changeReport);
       addStep(
           new ModelNode(),
           new ModelNode(),
           PathAddress.EMPTY_ADDRESS,
           removalVerificationHandler,
           Stage.VERIFY);
     }
   }
 }
Example #4
0
 @Override
 void releaseStepLocks(Step step) {
   if (step == lockStep) {
     lockStep = null;
     controller.releaseWriteLock(operationId);
   }
 }
 private void awaitContainerMonitor() {
   try {
     modelController.awaitContainerMonitor(respectInterruption, 1);
   } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
     throw MESSAGES.operationCancelledAsynchronously();
   }
 }
 protected boolean boot(List<ModelNode> bootOperations, boolean rollbackOnRuntimeFailure)
     throws ConfigurationPersistenceException {
   return controller.boot(
       bootOperations,
       OperationMessageHandler.logging,
       ModelController.OperationTransactionControl.COMMIT,
       rollbackOnRuntimeFailure);
 }
 protected ModelNode internalExecute(
     final ModelNode operation,
     final OperationMessageHandler handler,
     final ModelController.OperationTransactionControl control,
     final OperationAttachments attachments,
     final OperationStepHandler prepareStep) {
   return controller.internalExecute(operation, handler, control, attachments, prepareStep, false);
 }
 private void acquireContainerMonitor() {
   if (containerMonitorStep == null) {
     if (currentStage == Stage.DONE) {
       throw MESSAGES.invalidModificationAfterCompletedStep();
     }
     modelController.acquireContainerMonitor();
     containerMonitorStep = activeStep;
   }
 }
 public void addResource(PathAddress relativeAddress, Resource toAdd) {
   final PathAddress absoluteAddress = activeStep.address.append(relativeAddress);
   assert isControllingThread();
   Stage currentStage = this.currentStage;
   if (currentStage == null) {
     throw MESSAGES.operationAlreadyComplete();
   }
   if (currentStage != Stage.MODEL) {
     throw MESSAGES.stageAlreadyComplete(Stage.MODEL);
   }
   if (absoluteAddress.size() == 0) {
     throw MESSAGES.duplicateResourceAddress(absoluteAddress);
   }
   if (!isModelAffected()) {
     takeWriteLock();
     model = model.clone();
   }
   affectsModel.put(absoluteAddress, NULL);
   Resource model = this.model;
   final Iterator<PathElement> i = absoluteAddress.iterator();
   while (i.hasNext()) {
     final PathElement element = i.next();
     if (element.isMultiTarget()) {
       throw MESSAGES.cannotWriteTo("*");
     }
     if (!i.hasNext()) {
       final String key = element.getKey();
       if (model.hasChild(element)) {
         throw MESSAGES.duplicateResourceAddress(absoluteAddress);
       } else {
         final PathAddress parent = absoluteAddress.subAddress(0, absoluteAddress.size() - 1);
         final Set<String> childrenNames =
             modelController.getRootRegistration().getChildNames(parent);
         if (!childrenNames.contains(key)) {
           throw MESSAGES.noChildType(key);
         }
         model.registerChild(element, toAdd);
         model = toAdd;
       }
     } else {
       model = model.getChild(element);
       if (model == null) {
         PathAddress ancestor = PathAddress.EMPTY_ADDRESS;
         for (PathElement pe : absoluteAddress) {
           ancestor = ancestor.append(pe);
           if (element.equals(pe)) {
             break;
           }
         }
         throw MESSAGES.resourceNotFound(ancestor, absoluteAddress);
       }
     }
   }
 }
 /** @deprecated internal use only */
 @Deprecated
 protected ModelNode executeReadOnlyOperation(
     final ModelNode operation,
     final OperationMessageHandler handler,
     final ModelController.OperationTransactionControl control,
     final OperationAttachments attachments,
     final OperationStepHandler prepareStep,
     int lockPermit) {
   return controller.executeReadOnlyOperation(
       operation, handler, control, attachments, prepareStep, lockPermit);
 }
Example #11
0
 ReadOnlyContext(
     final ProcessType processType,
     final RunningMode runningMode,
     final ModelController.OperationTransactionControl transactionControl,
     final ControlledProcessState processState,
     final boolean booting,
     final AbstractOperationContext primaryContext,
     final ModelControllerImpl controller,
     final int operationId) {
   super(
       processType,
       runningMode,
       transactionControl,
       processState,
       booting,
       controller.getAuditLogger(),
       controller.getNotificationSupport());
   this.primaryContext = primaryContext;
   this.controller = controller;
   this.operationId = operationId;
 }
Example #12
0
 public ImmutableManagementResourceRegistration getResourceRegistration() {
   final PathAddress address = activeStep.address;
   assert isControllingThread();
   Stage currentStage = this.currentStage;
   if (currentStage == null || currentStage == Stage.DONE) {
     throw MESSAGES.operationAlreadyComplete();
   }
   ImmutableManagementResourceRegistration delegate =
       modelController.getRootRegistration().getSubModel(address);
   return delegate == null
       ? null
       : new DelegatingImmutableManagementResourceRegistration(delegate);
 }
Example #13
0
 @Override
 public void acquireControllerLock() {
   if (lockStep == null) {
     try {
       controller.acquireWriteLock(operationId, true);
       lockStep = activeStep;
     } catch (InterruptedException e) {
       cancelled = true;
       Thread.currentThread().interrupt();
       throw ControllerLogger.ROOT_LOGGER.operationCancelledAsynchronously();
     }
   }
 }
Example #14
0
 private void takeWriteLock() {
   if (lockStep == null) {
     if (currentStage == Stage.DONE) {
       throw MESSAGES.invalidModificationAfterCompletedStep();
     }
     try {
       modelController.acquireLock(respectInterruption);
       lockStep = activeStep;
     } catch (InterruptedException e) {
       Thread.currentThread().interrupt();
       throw MESSAGES.operationCancelledAsynchronously();
     }
   }
 }
Example #15
0
 public ManagementResourceRegistration getResourceRegistrationForUpdate() {
   final PathAddress address = activeStep.address;
   assert isControllingThread();
   Stage currentStage = this.currentStage;
   if (currentStage == null) {
     throw MESSAGES.operationAlreadyComplete();
   }
   // if (currentStage != Stage.MODEL) {
   //    throw MESSAGES.stageAlreadyComplete(Stage.MODEL);
   // }
   if (!affectsResourceRegistration) {
     takeWriteLock();
     affectsResourceRegistration = true;
   }
   return modelController.getRootRegistration().getSubModel(address);
 }
Example #16
0
 public ModelNode readModelForUpdate(final PathAddress requestAddress) {
   final PathAddress address = activeStep.address.append(requestAddress);
   assert isControllingThread();
   Stage currentStage = this.currentStage;
   if (currentStage == null) {
     throw MESSAGES.operationAlreadyComplete();
   }
   if (currentStage != Stage.MODEL) {
     throw MESSAGES.stageAlreadyComplete(Stage.MODEL);
   }
   if (!isModelAffected()) {
     takeWriteLock();
     model = model.clone();
   }
   affectsModel.put(address, NULL);
   Resource model = this.model;
   final Iterator<PathElement> i = address.iterator();
   while (i.hasNext()) {
     final PathElement element = i.next();
     if (element.isMultiTarget()) {
       throw MESSAGES.cannotWriteTo("*");
     }
     if (!i.hasNext()) {
       final String key = element.getKey();
       if (!model.hasChild(element)) {
         final PathAddress parent = address.subAddress(0, address.size() - 1);
         final Set<String> childrenNames =
             modelController.getRootRegistration().getChildNames(parent);
         if (!childrenNames.contains(key)) {
           throw MESSAGES.noChildType(key);
         }
         final Resource newModel = Resource.Factory.create();
         model.registerChild(element, newModel);
         model = newModel;
       } else {
         model = requireChild(model, element, address);
       }
     } else {
       model = requireChild(model, element, address);
     }
   }
   if (model == null) {
     throw new IllegalStateException();
   }
   return model.getModel();
 }
Example #17
0
 public ServiceController<?> removeService(final ServiceName name)
     throws UnsupportedOperationException {
   assert isControllingThread();
   Stage currentStage = this.currentStage;
   if (currentStage == null) {
     throw MESSAGES.operationAlreadyComplete();
   }
   if (currentStage != Stage.RUNTIME && currentStage != Stage.VERIFY && !isRollingBack()) {
     throw MESSAGES.serviceRemovalRuntimeOperationsOnly();
   }
   if (!affectsRuntime) {
     takeWriteLock();
     affectsRuntime = true;
     acquireContainerMonitor();
     awaitContainerMonitor();
   }
   ServiceController<?> controller = modelController.getServiceRegistry().getService(name);
   if (controller != null) {
     doRemove(controller);
   }
   return controller;
 }
Example #18
0
 public ServiceRegistry getServiceRegistry(final boolean modify)
     throws UnsupportedOperationException {
   assert isControllingThread();
   Stage currentStage = this.currentStage;
   if (currentStage == null) {
     throw MESSAGES.operationAlreadyComplete();
   }
   if (!(!modify
       || currentStage == Stage.RUNTIME
       || currentStage == Stage.MODEL
       || currentStage == Stage.VERIFY
       || isRollingBack())) {
     throw MESSAGES.serviceRegistryRuntimeOperationsOnly();
   }
   if (modify && !affectsRuntime) {
     takeWriteLock();
     affectsRuntime = true;
     acquireContainerMonitor();
     awaitContainerMonitor();
   }
   return modelController.getServiceRegistry();
 }
Example #19
0
 @Override
 ConfigurationPersister.PersistenceResource createPersistenceResource()
     throws ConfigurationPersistenceException {
   return modelController.writeModel(model, affectsModel.keySet());
 }
  public void start(final StartContext context) throws StartException {

    if (configurationPersister == null) {
      throw MESSAGES.persisterNotInjected();
    }
    final ServiceController<?> serviceController = context.getController();
    final ServiceContainer container = serviceController.getServiceContainer();
    final ServiceTarget target = context.getChildTarget();
    final ExecutorService executorService = injectedExecutorService.getOptionalValue();
    ManagementResourceRegistration rootResourceRegistration =
        rootDescriptionProvider != null
            ? ManagementResourceRegistration.Factory.create(rootDescriptionProvider)
            : ManagementResourceRegistration.Factory.create(rootResourceDefinition);
    final ModelControllerImpl controller =
        new ModelControllerImpl(
            container,
            target,
            rootResourceRegistration,
            new ContainerStateMonitor(container),
            configurationPersister,
            processType,
            runningModeControl,
            prepareStep,
            processState,
            executorService,
            expressionResolver,
            authorizer,
            auditLogger);

    // Initialize the model
    initModel(controller.getRootResource(), controller.getRootRegistration());
    this.controller = controller;

    final long bootStackSize = getBootStackSize();
    final Thread bootThread =
        new Thread(
            null,
            new Runnable() {
              public void run() {
                try {
                  try {
                    boot(
                        new BootContext() {
                          public ServiceTarget getServiceTarget() {
                            return target;
                          }
                        });
                  } finally {
                    processState.setRunning();
                  }
                } catch (Throwable t) {
                  container.shutdown();
                  if (t instanceof StackOverflowError) {
                    ROOT_LOGGER.errorBootingContainer(t, bootStackSize, BOOT_STACK_SIZE_PROPERTY);
                  } else {
                    ROOT_LOGGER.errorBootingContainer(t);
                  }
                } finally {
                  bootThreadDone();
                }
              }
            },
            "Controller Boot Thread",
            bootStackSize);
    bootThread.start();
  }
 protected void finishBoot() throws ConfigurationPersistenceException {
   controller.finishBoot();
   configurationPersister.successfulBoot();
 }
Example #22
0
 public <T> ServiceBuilder<T> addServiceValue(
     final ServiceName name, final Value<? extends Service<T>> value) {
   final ServiceBuilder<T> realBuilder =
       modelController.getServiceTarget().addServiceValue(name, value);
   return new ContextServiceBuilder<T>(realBuilder, name);
 }
 protected void runPerformControllerInitialization(BootContext context) {
   performControllerInitialization(
       context.getServiceTarget(), controller.getRootResource(), controller.getRootRegistration());
 }
Example #24
0
 @Override
 public ModelNode resolveExpressions(ModelNode node) throws OperationFailedException {
   return modelController.resolveExpressions(node);
 }