Example #1
0
  /**
   * Immediately change and apply the specified field in the current repository configuration to the
   * new value.
   *
   * @param defn the attribute definition for the value; may not be null
   * @param newValue the new string value
   * @throws RepositoryException if there is a problem obtaining the repository configuration or
   *     applying the change
   * @throws OperationFailedException if there is a problem obtaining the raw value from the
   *     supplied model node
   */
  public void changeField(MappedAttributeDefinition defn, ModelNode newValue)
      throws RepositoryException, OperationFailedException {
    ModeShapeEngine engine = getEngine();
    String repositoryName = repositoryName();

    // Get a snapshot of the current configuration ...
    RepositoryConfiguration config = engine.getRepositoryConfiguration(repositoryName);

    // Now start to make changes ...
    Editor editor = config.edit();

    // Find the Document containing the field ...
    EditableDocument fieldContainer = editor;
    for (String fieldName : defn.getPathToContainerOfField()) {
      fieldContainer = editor.getOrCreateDocument(fieldName);
    }

    // Get the raw value from the model node ...
    Object rawValue = defn.getTypedValue(newValue);

    // Change the field ...
    String fieldName = defn.getFieldName();
    fieldContainer.set(fieldName, rawValue);

    // Apply the changes to the current configuration ...
    Changes changes = editor.getChanges();
    engine.update(repositoryName, changes);
  }
Example #2
0
 private void setRepositoryStorageConfiguration(
     String infinispanConfig, String cacheName, EditableDocument configDoc) {
   EditableDocument storage = configDoc.getOrCreateDocument(FieldName.STORAGE);
   storage.set(FieldName.CACHE_NAME, cacheName);
   // set the ISPN config relative path which will be resolved later on
   storage.set(FieldName.CACHE_CONFIGURATION, infinispanConfig);
 }
 @Override
 protected void writeBinaryStorageConfiguration(
     String repositoryName, OperationContext context, ModelNode model, EditableDocument binaries)
     throws OperationFailedException {
   binaries.set(FieldName.TYPE, FieldValue.BINARY_STORAGE_TYPE_DATABASE);
   // We don't need to add a dependency since we'll look it up by JNDI and we'll
   // not shutdown if the data source is shutdown
   String dataSource =
       ModelAttributes.DATA_SOURCE_JNDI_NAME.resolveModelAttribute(context, model).asString();
   binaries.set(FieldName.DATA_SOURCE_JNDI_NAME, dataSource);
 }
Example #4
0
 private void parseCustomNodeTypes(ModelNode model, EditableDocument configDoc) {
   if (model.hasDefined(ModelKeys.NODE_TYPES)) {
     EditableArray nodeTypesArray = configDoc.getOrCreateArray(FieldName.NODE_TYPES);
     for (ModelNode nodeType : model.get(ModelKeys.NODE_TYPES).asList()) {
       nodeTypesArray.add(nodeType.asString());
     }
   }
 }
  @Override
  public void start(StartContext arg0) {
    // Not much to do, since we've already captured the properties for the index storage.
    // When this is injected into the RepositoryService, the RepositoryService will use the
    // properties to update the configuration.

    // All we need to do is update the relative paths and make them absolute, given the absolute
    // paths that are injected ...

    String binaryStorageBasePath = getBinaryStorageBasePath();
    if (binaryStorageBasePath != null) {
      // Set the binary storage directory ...
      String relativePath = binaryConfig.getString(FieldName.DIRECTORY);
      if (relativePath != null) {
        binaryConfig.set(FieldName.DIRECTORY, binaryStorageBasePath + relativePath);
      }
    }
  }
 @Override
 protected void writeBinaryStorageConfiguration(
     String repositoryName, OperationContext context, ModelNode model, EditableDocument binaries)
     throws OperationFailedException {
   super.writeCommonBinaryStorageConfiguration(repositoryName, context, model, binaries);
   binaries.set(FieldName.TYPE, FieldValue.BINARY_STORAGE_TYPE_FILE);
   String defaultPath = "modeshape/" + repositoryName + "/binaries";
   ModelNode pathNode = ModelAttributes.PATH.resolveModelAttribute(context, model);
   String path = pathNode.isDefined() ? pathNode.asString() : defaultPath;
   String relativeTo =
       ModelAttributes.RELATIVE_TO.resolveModelAttribute(context, model).asString();
   if (model.has(ModelKeys.RELATIVE_TO)
       && model.get(ModelKeys.RELATIVE_TO).asString().contains(DATA_DIR_VARIABLE)) {
     binaryStoragePathInDataDirectory = path;
   }
   path = relativeTo + path;
   binaries.set(FieldName.DIRECTORY, path);
 }
  @Test
  public void shouldStoreDocumentAndFetchAndModifyAndRefetch() throws Exception {
    // Store the document ...
    Document doc = Schematic.newDocument("k1", "value1", "k2", 2);
    Document metadata = Schematic.newDocument("mimeType", "text/plain");
    String key = "can be anything";
    SchematicEntry prior = db.put(key, doc, metadata);
    assert prior == null : "Should not have found a prior entry";

    // Read back from the database ...
    SchematicEntry entry = db.get(key);
    assert entry != null : "Should have found the entry";

    // Verify the content ...
    Document read = entry.getContentAsDocument();
    assert read != null;
    assert "value1".equals(read.getString("k1"));
    assert 2 == read.getInteger("k2");
    assert entry.getContentAsBinary() == null
        : "Should not have a Binary value for the entry's content";
    assert read.containsAll(doc);
    assert read.equals(doc);

    // Modify using an editor ...
    try {
      // tm.begin();
      EditableDocument editable = entry.editDocumentContent();
      editable.setBoolean("k3", true);
      editable.setNumber("k4", 3.5d);
    } finally {
      // tm.commit();
    }

    // Now re-read ...
    SchematicEntry entry2 = db.get(key);
    Document read2 = entry2.getContentAsDocument();
    assert read2 != null;
    assert "value1".equals(read2.getString("k1"));
    assert 2 == read2.getInteger("k2");
    assert true == read2.getBoolean("k3");
    assert 3.4d < read2.getDouble("k4");
  }
Example #8
0
 private void parseTextExtraction(ModelNode model, EditableDocument configDoc) {
   if (model.hasDefined(ModelKeys.TEXT_EXTRACTORS_THREAD_POOL_NAME)) {
     EditableDocument extractors = configDoc.getOrCreateDocument(FieldName.TEXT_EXTRACTION);
     String poolName = model.get(ModelKeys.TEXT_EXTRACTORS_THREAD_POOL_NAME).asString();
     extractors.set(FieldName.THREAD_POOL, poolName);
   }
   if (model.hasDefined(ModelKeys.TEXT_EXTRACTORS_MAX_POOL_SIZE)) {
     EditableDocument sequencing = configDoc.getOrCreateDocument(FieldName.TEXT_EXTRACTION);
     int maxPoolSize = model.get(ModelKeys.TEXT_EXTRACTORS_MAX_POOL_SIZE).asInt();
     sequencing.set(FieldName.MAX_POOL_SIZE, maxPoolSize);
   }
 }
Example #9
0
 private void parseSequencing(ModelNode model, EditableDocument configDoc) {
   if (model.hasDefined(ModelKeys.SEQUENCERS_THREAD_POOL_NAME)) {
     EditableDocument sequencing = configDoc.getOrCreateDocument(FieldName.SEQUENCING);
     String sequencingThreadPool = model.get(ModelKeys.SEQUENCERS_THREAD_POOL_NAME).asString();
     sequencing.set(FieldName.THREAD_POOL, sequencingThreadPool);
   }
   if (model.hasDefined(ModelKeys.SEQUENCERS_MAX_POOL_SIZE)) {
     EditableDocument sequencing = configDoc.getOrCreateDocument(FieldName.SEQUENCING);
     int maxPoolSize = model.get(ModelKeys.SEQUENCERS_MAX_POOL_SIZE).asInt();
     sequencing.set(FieldName.MAX_POOL_SIZE, maxPoolSize);
   }
 }
Example #10
0
 private void parseReindexing(ModelNode model, EditableDocument configDoc) {
   if (model.hasDefined(ModelKeys.REINDEXING_ASYNC)) {
     EditableDocument reindexing = configDoc.getOrCreateDocument(FieldName.REINDEXING);
     boolean async = model.get(ModelKeys.REINDEXING_ASYNC).asBoolean();
     reindexing.set(FieldName.REINDEXING_ASYNC, async);
   }
   if (model.hasDefined(ModelKeys.REINDEXING_MODE)) {
     EditableDocument reindexing = configDoc.getOrCreateDocument(FieldName.REINDEXING);
     String mode = model.get(ModelKeys.REINDEXING_MODE).asString();
     reindexing.set(FieldName.REINDEXING_MODE, mode);
   }
 }
Example #11
0
  /**
   * Immediately change and apply the specified sequencer field in the current repository
   * configuration to the new value.
   *
   * @param defn the attribute definition for the value; may not be null
   * @param newValue the new string value
   * @param sequencerName the name of the sequencer
   * @throws RepositoryException if there is a problem obtaining the repository configuration or
   *     applying the change
   * @throws OperationFailedException if there is a problem obtaining the raw value from the
   *     supplied model node
   */
  public void changeSequencerField(
      MappedAttributeDefinition defn, ModelNode newValue, String sequencerName)
      throws RepositoryException, OperationFailedException {
    ModeShapeEngine engine = getEngine();
    String repositoryName = repositoryName();

    // Get a snapshot of the current configuration ...
    RepositoryConfiguration config = engine.getRepositoryConfiguration(repositoryName);

    // Now start to make changes ...
    Editor editor = config.edit();

    // Find the array of sequencer documents ...
    List<String> pathToContainer = defn.getPathToContainerOfField();
    EditableDocument sequencing = editor.getOrCreateDocument(pathToContainer.get(0));
    EditableDocument sequencers = sequencing.getOrCreateArray(pathToContainer.get(1));

    // The container should be an array ...
    for (String configuredSequencerName : sequencers.keySet()) {
      // Look for the entry with a name that matches our sequencer name ...
      if (sequencerName.equals(configuredSequencerName)) {
        // All these entries should be nested documents ...
        EditableDocument sequencer = (EditableDocument) sequencers.get(configuredSequencerName);

        // Change the field ...
        String fieldName = defn.getFieldName();
        // Get the raw value from the model node ...
        Object rawValue = defn.getTypedValue(newValue);
        // And update the field ...
        sequencer.set(fieldName, rawValue);
        break;
      }
    }

    // Get and apply the changes to the current configuration. Note that the 'update' call
    // asynchronously
    // updates the configuration, and returns a Future<JcrRepository> that we could use if we wanted
    // to
    // wait for the changes to take place. But we don't want/need to wait, so we'll not use the
    // Future ...
    Changes changes = editor.getChanges();
    engine.update(repositoryName, changes);
  }
Example #12
0
  /**
   * Immediately change and apply the specified extractor field in the current repository
   * configuration to the new value.
   *
   * @param defn the attribute definition for the value; may not be null
   * @param newValue the new string value
   * @param extractorName the name of the sequencer
   * @throws RepositoryException if there is a problem obtaining the repository configuration or
   *     applying the change
   * @throws OperationFailedException if there is a problem obtaining the raw value from the
   *     supplied model node
   */
  public void changeTextExtractorField(
      MappedAttributeDefinition defn, ModelNode newValue, String extractorName)
      throws RepositoryException, OperationFailedException {
    ModeShapeEngine engine = getEngine();
    String repositoryName = repositoryName();

    // Get a snapshot of the current configuration ...
    RepositoryConfiguration config = engine.getRepositoryConfiguration(repositoryName);

    // Now start to make changes ...
    Editor editor = config.edit();

    // Find the array of sequencer documents ...
    List<String> pathToContainer = defn.getPathToContainerOfField();
    EditableDocument textExtracting = editor.getOrCreateDocument(pathToContainer.get(1));
    EditableDocument extractors = textExtracting.getOrCreateDocument(pathToContainer.get(2));

    // The container should be an array ...
    for (String configuredExtractorName : extractors.keySet()) {
      // Look for the entry with a name that matches our extractor name ...
      if (extractorName.equals(configuredExtractorName)) {
        // All these entries should be nested documents ...
        EditableDocument extractor = (EditableDocument) extractors.get(configuredExtractorName);
        // Change the field ...
        String fieldName = defn.getFieldName();
        // Get the raw value from the model node ...
        Object rawValue = defn.getTypedValue(newValue);
        // And update the field ...
        extractor.set(fieldName, rawValue);
        break;
      }
    }

    Changes changes = editor.getChanges();
    engine.update(repositoryName, changes);
  }
Example #13
0
  private void parseJournaling(
      RepositoryService repositoryService,
      OperationContext context,
      ModelNode model,
      EditableDocument configDoc)
      throws OperationFailedException {
    if (model.hasDefined(ModelKeys.JOURNALING)) {
      EditableDocument journaling = configDoc.getOrCreateDocument(FieldName.JOURNALING);

      // set it temporarily on the repository service because the final location needs to be
      // resolved later
      if (model.hasDefined(ModelKeys.JOURNAL_RELATIVE_TO)) {
        String relativeTo =
            attribute(context, model, ModelAttributes.JOURNAL_RELATIVE_TO).asString();
        repositoryService.setJournalRelativeTo(relativeTo);
      }

      // set it temporarily on the repository service because the final location needs to be
      // resolved later
      if (model.hasDefined(ModelKeys.JOURNAL_PATH)) {
        String path = attribute(context, model, ModelAttributes.JOURNAL_PATH).asString();
        repositoryService.setJournalPath(path);
      }

      int maxDaysToKeepRecords =
          attribute(context, model, ModelAttributes.MAX_DAYS_TO_KEEP_RECORDS).asInt();
      journaling.setNumber(FieldName.MAX_DAYS_TO_KEEP_RECORDS, maxDaysToKeepRecords);

      boolean asyncWrites = attribute(context, model, ModelAttributes.ASYNC_WRITES).asBoolean();
      journaling.setBoolean(FieldName.ASYNC_WRITES_ENABLED, asyncWrites);

      String gcThreadPool =
          attribute(context, model, ModelAttributes.JOURNAL_GC_THREAD_POOL).asString();
      journaling.setString(FieldName.THREAD_POOL, gcThreadPool);

      String gcInitialTime =
          attribute(context, model, ModelAttributes.JOURNAL_GC_INITIAL_TIME).asString();
      journaling.setString(FieldName.INITIAL_TIME, gcInitialTime);
    }
  }
Example #14
0
  private void parseSecurity(OperationContext context, ModelNode model, EditableDocument configDoc)
      throws OperationFailedException {
    EditableDocument security = configDoc.getOrCreateDocument(FieldName.SECURITY);

    // Anonymous ...
    EditableDocument anon = security.getOrCreateDocument(FieldName.ANONYMOUS);
    String anonUsername = attribute(context, model, ModelAttributes.ANONYMOUS_USERNAME).asString();
    boolean useAnonIfFailed =
        attribute(context, model, ModelAttributes.USE_ANONYMOUS_IF_AUTH_FAILED).asBoolean();
    anon.set(FieldName.ANONYMOUS_USERNAME, anonUsername);
    anon.set(FieldName.USE_ANONYMOUS_ON_FAILED_LOGINS, useAnonIfFailed);
    List<ModelNode> modelNodes =
        model.hasDefined(ModelKeys.ANONYMOUS_ROLES)
            ? model.get(ModelKeys.ANONYMOUS_ROLES).asList()
            : ModelAttributes.ANONYMOUS_ROLES.getDefaultValue().asList();
    for (ModelNode roleNode : modelNodes) {
      EditableArray anonymousRolesArray = anon.getOrCreateArray(FieldName.ANONYMOUS_ROLES);
      String roleName = roleNode.asString();
      if (!StringUtil.isBlank(roleName)) {
        anonymousRolesArray.addString(roleName);
      }
    }

    EditableArray providers = security.getOrCreateArray(FieldName.PROVIDERS);

    // JBoss authenticator ...
    String securityDomain = attribute(context, model, ModelAttributes.SECURITY_DOMAIN).asString();
    EditableDocument jboss = Schematic.newDocument();
    jboss.set(FieldName.CLASSNAME, JBossDomainAuthenticationProvider.class.getName());
    jboss.set(FieldName.SECURITY_DOMAIN, securityDomain);
    providers.add(jboss);

    // Servlet authenticator ...
    EditableDocument servlet = Schematic.newDocument();
    servlet.set(FieldName.CLASSNAME, "servlet");
    providers.add(servlet);
  }
Example #15
0
  @Override
  public void start(StartContext arg0) throws StartException {
    JcrEngine jcr = getEngine();
    try {
      final String repositoryName = repositoryConfiguration.getName();

      // Get the index storage configuration ...
      IndexStorage indexStorageConfig = indexStorageConfigInjector.getValue();
      Document queryConfig = null;
      if (indexStorageConfig != null) {
        queryConfig = indexStorageConfig.getQueryConfiguration();
      } else {
        // We'll use the default index storage, but this will be overwritten by the *IndexStorageAdd
        // operation
        // (that we're dependent upon). The default for non-AS7 ModeShape repositories is to use
        // RAM index storage, but in AS7 we want to by default store the indexes on the filesystem
        // in the
        // AS7 data directory.
        // We'll do this by setting a path relative to the data directory, and then injecting
        // the "${jboss.server.data.dir}/modeshape" path into the repository service
        // (which will then update the configuration prior to deployment) ...
        EditableDocument query = Schematic.newDocument();
        EditableDocument indexing = query.getOrCreateDocument(FieldName.INDEXING);
        EditableDocument indexStorage = query.getOrCreateDocument(FieldName.INDEX_STORAGE);
        EditableDocument backend = indexing.getOrCreateDocument(FieldName.INDEXING_BACKEND);
        query.set(FieldName.REBUILD_UPON_STARTUP, "if_needed");
        backend.set(FieldName.TYPE, FieldValue.INDEXING_BACKEND_TYPE_LUCENE);
        indexStorage.set(FieldName.TYPE, FieldValue.INDEX_STORAGE_FILESYSTEM);
        String dataDirPath = dataDirectoryPathInjector.getValue();
        indexStorage.set(
            FieldName.INDEX_STORAGE_LOCATION, dataDirPath + "/" + repositoryName + "/indexes");
        queryConfig = query;
      }
      assert queryConfig != null;

      // Get the binary storage configuration ...
      Document binaryConfig = null;
      BinaryStorage binaryStorageConfig = binaryStorageInjector.getValue();
      if (binaryStorageConfig != null) {
        binaryConfig = binaryStorageConfig.getBinaryConfiguration();
      } else {
        // By default, store the binaries in the data directory ...
        EditableDocument binaries = Schematic.newDocument();
        binaries.set(FieldName.TYPE, FieldValue.BINARY_STORAGE_TYPE_FILE);
        String dataDirPath = dataDirectoryPathInjector.getValue();
        binaries.set(FieldName.DIRECTORY, dataDirPath + "/" + repositoryName + "/binaries");
        binaryConfig = binaries;
      }

      // Now update the configuration ...
      Editor editor = repositoryConfiguration.edit();
      editor.setDocument(FieldName.QUERY, queryConfig);
      editor
          .getOrCreateDocument(FieldName.STORAGE)
          .setDocument(FieldName.BINARY_STORAGE, binaryConfig);

      // Apply the changes to the configuration ...
      editor.apply(editor.getChanges());

      // Deploy the repository and use this as the environment ...
      jcr.deploy(repositoryConfiguration.with(this));
    } catch (ConfigurationException e) {
      throw new StartException(e);
    } catch (RepositoryException e) {
      throw new StartException(e);
    }
  }
Example #16
0
  @Override
  protected void performRuntime(
      final OperationContext context,
      final ModelNode operation,
      final ModelNode model,
      final ServiceVerificationHandler verificationHandler,
      final List<ServiceController<?>> newControllers)
      throws OperationFailedException {

    final ServiceTarget target = context.getServiceTarget();
    final AddressContext addressContext = AddressContext.forOperation(operation);
    final String repositoryName = addressContext.repositoryName();
    final String cacheName = attribute(context, model, ModelAttributes.CACHE_NAME, repositoryName);
    String infinispanConfig = attribute(context, model, ModelAttributes.CACHE_CONFIG, null);
    String configRelativeTo =
        attribute(context, model, ModelAttributes.CONFIG_RELATIVE_TO).asString();
    final boolean enableMonitoring =
        attribute(context, model, ModelAttributes.ENABLE_MONITORING).asBoolean();
    final String gcThreadPool =
        attribute(context, model, ModelAttributes.GARBAGE_COLLECTION_THREAD_POOL, null);
    final String gcInitialTime =
        attribute(context, model, ModelAttributes.GARBAGE_COLLECTION_INITIAL_TIME, null);
    final int gcIntervalInHours =
        attribute(context, model, ModelAttributes.GARBAGE_COLLECTION_INTERVAL).asInt();
    final String optThreadPool =
        attribute(context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_THREAD_POOL, null);
    final String optInitialTime =
        attribute(context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_INITIAL_TIME, null);
    final int optIntervalInHours =
        attribute(context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_INTERVAL).asInt();
    final Integer optTarget =
        intAttribute(
            context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_CHILD_COUNT_TARGET, null);
    final Integer eventBusSize = intAttribute(context, model, ModelAttributes.EVENT_BUS_SIZE, null);
    final Integer optTolerance =
        intAttribute(
            context, model, ModelAttributes.DOCUMENT_OPTIMIZATION_CHILD_COUNT_TOLERANCE, null);

    // Create a document for the repository configuration ...
    EditableDocument configDoc = Schematic.newDocument();
    configDoc.set(FieldName.NAME, repositoryName);

    // Determine the JNDI name ...
    configDoc.set(
        FieldName.JNDI_NAME,
        ""); // always set to empty string, since we'll register in JNDI here ...
    final String jndiName = ModeShapeJndiNames.JNDI_BASE_NAME + repositoryName;
    String jndiAlias = ModeShapeJndiNames.jndiNameFrom(model, repositoryName);
    if (jndiName.equals(jndiAlias)) {
      jndiAlias = null;
    }

    if (eventBusSize != null) {
      configDoc.setNumber(FieldName.EVENT_BUS_SIZE, eventBusSize);
    }

    // Parse the cache configuration
    if (StringUtil.isBlank(infinispanConfig)) {
      infinispanConfig = "modeshape/" + repositoryName + "-cache-config.xml";
    } else {
      // check if it's a system property
      String infinispanConfigSystemProperty = System.getProperty(infinispanConfig);
      if (!StringUtil.isBlank(infinispanConfigSystemProperty)) {
        infinispanConfig = infinispanConfigSystemProperty;
      }
    }
    // Set the storage information (that was set on the repository ModelNode) ...
    setRepositoryStorageConfiguration(infinispanConfig, cacheName, configDoc);

    // Always set whether monitoring is enabled ...
    enableMonitoring(enableMonitoring, configDoc);

    // Initial node-types if configured
    parseCustomNodeTypes(model, configDoc);

    // Workspace information is on the repository model node (unlike the XML) ...
    EditableDocument workspacesDoc = parseWorkspaces(context, model, configDoc);

    // security
    parseSecurity(context, model, configDoc);

    // Now create the repository service that manages the lifecycle of the JcrRepository instance
    // ...
    RepositoryConfiguration repositoryConfig =
        new RepositoryConfiguration(configDoc, repositoryName);
    String configRelativeToSystemProperty = System.getProperty(configRelativeTo);
    if (!StringUtil.isBlank(configRelativeToSystemProperty)) {
      configRelativeTo = configRelativeToSystemProperty;
    }
    if (!configRelativeTo.endsWith("/")) {
      configRelativeTo = configRelativeTo + "/";
    }
    RepositoryService repositoryService =
        new RepositoryService(repositoryConfig, infinispanConfig, configRelativeTo);
    ServiceName repositoryServiceName = ModeShapeServiceNames.repositoryServiceName(repositoryName);

    // Sequencing
    parseSequencing(model, configDoc);

    // Text Extraction
    parseTextExtraction(model, configDoc);

    // Reindexing
    parseReindexing(model, configDoc);

    // Journaling
    parseJournaling(repositoryService, context, model, configDoc);

    // Add the EngineService's dependencies ...
    ServiceBuilder<JcrRepository> repositoryServiceBuilder =
        target.addService(repositoryServiceName, repositoryService);

    // Add dependency to the ModeShape engine service ...
    repositoryServiceBuilder.addDependency(
        ModeShapeServiceNames.ENGINE, ModeShapeEngine.class, repositoryService.getEngineInjector());
    repositoryServiceBuilder.setInitialMode(ServiceController.Mode.ACTIVE);

    // Add garbage collection information ...
    if (gcThreadPool != null) {
      configDoc
          .getOrCreateDocument(FieldName.GARBAGE_COLLECTION)
          .setString(FieldName.THREAD_POOL, gcThreadPool);
    }
    if (gcInitialTime != null) {
      configDoc
          .getOrCreateDocument(FieldName.GARBAGE_COLLECTION)
          .setString(FieldName.INITIAL_TIME, gcInitialTime);
    }
    configDoc
        .getOrCreateDocument(FieldName.GARBAGE_COLLECTION)
        .setNumber(FieldName.INTERVAL_IN_HOURS, gcIntervalInHours);

    // Add document optimization information ...
    if (optTarget != null) {
      EditableDocument docOpt =
          configDoc
              .getOrCreateDocument(FieldName.STORAGE)
              .getOrCreateDocument(FieldName.DOCUMENT_OPTIMIZATION);
      if (optThreadPool != null) {
        docOpt.setString(FieldName.THREAD_POOL, optThreadPool);
      }
      if (optInitialTime != null) {
        docOpt.setString(FieldName.INITIAL_TIME, optInitialTime);
      }
      docOpt.setNumber(FieldName.INTERVAL_IN_HOURS, optIntervalInHours);
      docOpt.setNumber(FieldName.OPTIMIZATION_CHILD_COUNT_TARGET, optTarget.intValue());
      if (optTolerance != null) {
        docOpt.setNumber(FieldName.OPTIMIZATION_CHILD_COUNT_TOLERANCE, optTolerance.intValue());
      }
    }

    // Add the dependency to the Security Manager
    repositoryServiceBuilder.addDependency(
        SecurityManagementService.SERVICE_NAME,
        ISecurityManagement.class,
        repositoryService.getSecurityManagementServiceInjector());

    // Add dependency, if necessary, to the workspaces cache container
    String workspacesInfinispanConfig =
        attribute(context, model, ModelAttributes.WORKSPACES_CACHE_CONTAINER, null);
    if (workspacesInfinispanConfig != null
        && !workspacesInfinispanConfig.toLowerCase().equalsIgnoreCase(infinispanConfig)) {
      workspacesDoc.set(FieldName.WORKSPACE_CACHE_CONFIGURATION, workspacesInfinispanConfig);
    }

    repositoryServiceBuilder.addDependency(
        Services.JBOSS_SERVICE_MODULE_LOADER,
        ModuleLoader.class,
        repositoryService.getModuleLoaderInjector());

    // Set up the JNDI binder service ...
    final ReferenceFactoryService<JcrRepository> referenceFactoryService =
        new ReferenceFactoryService<JcrRepository>();
    ServiceName referenceFactoryServiceName =
        ModeShapeServiceNames.referenceFactoryServiceName(repositoryName);
    final ServiceBuilder<?> referenceBuilder =
        target.addService(referenceFactoryServiceName, referenceFactoryService);
    referenceBuilder.addDependency(
        repositoryServiceName, JcrRepository.class, referenceFactoryService.getInjector());
    referenceBuilder.setInitialMode(ServiceController.Mode.ACTIVE);

    ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName);
    BinderService binder = new BinderService(bindInfo.getBindName());
    ServiceBuilder<?> binderBuilder = target.addService(bindInfo.getBinderServiceName(), binder);
    if (jndiAlias != null) {
      ContextNames.BindInfo aliasInfo = ContextNames.bindInfoFor(jndiAlias);
      ServiceName alias = aliasInfo.getBinderServiceName();
      binderBuilder.addAliases(alias);
      LOG.debugv(
          "Binding repository {0} to JNDI name {1} and {2}",
          repositoryName, bindInfo.getAbsoluteJndiName(), aliasInfo.getAbsoluteJndiName());
    } else {
      LOG.debugv(
          "Binding repository {0} to JNDI name {1}",
          repositoryName, bindInfo.getAbsoluteJndiName());
    }
    binderBuilder.addDependency(
        referenceFactoryServiceName,
        ManagedReferenceFactory.class,
        binder.getManagedObjectInjector());
    binderBuilder.addDependency(
        bindInfo.getParentContextServiceName(),
        ServiceBasedNamingStore.class,
        binder.getNamingStoreInjector());
    binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE);

    // Add dependency to the data directory ...
    ServiceName dataDirServiceName = ModeShapeServiceNames.dataDirectoryServiceName(repositoryName);
    ServiceController<String> dataDirServiceController =
        RelativePathService.addService(
            dataDirServiceName,
            "modeshape/" + repositoryName,
            ModeShapeExtension.JBOSS_DATA_DIR_VARIABLE,
            target);
    newControllers.add(dataDirServiceController);
    repositoryServiceBuilder.addDependency(
        dataDirServiceName, String.class, repositoryService.getDataDirectoryPathInjector());

    // Add the default binary storage service which will provide the binary configuration
    BinaryStorageService defaultBinaryService = BinaryStorageService.createDefault();
    ServiceName defaultBinaryStorageServiceName =
        ModeShapeServiceNames.binaryStorageDefaultServiceName(repositoryName);
    ServiceBuilder<BinaryStorage> binaryStorageBuilder =
        target.addService(defaultBinaryStorageServiceName, defaultBinaryService);
    binaryStorageBuilder.setInitialMode(ServiceController.Mode.ACTIVE);
    // Add dependency to the binaries storage service, which captures the properties for the
    // binaries storage
    repositoryServiceBuilder.addDependency(
        defaultBinaryStorageServiceName,
        BinaryStorage.class,
        repositoryService.getBinaryStorageInjector());

    // Add monitor service
    final MonitorService monitorService = new MonitorService();
    final ServiceBuilder<RepositoryMonitor> monitorBuilder =
        target.addService(ModeShapeServiceNames.monitorServiceName(repositoryName), monitorService);
    monitorBuilder.addDependency(
        ModeShapeServiceNames.repositoryServiceName(repositoryName),
        JcrRepository.class,
        monitorService.getJcrRepositoryInjector());
    monitorBuilder.setInitialMode(ServiceController.Mode.ACTIVE);

    // Now add the controller for the RepositoryService ...
    newControllers.add(repositoryServiceBuilder.install());
    newControllers.add(referenceBuilder.install());
    newControllers.add(binderBuilder.install());
    newControllers.add(binaryStorageBuilder.install());
    newControllers.add(monitorBuilder.install());
  }
Example #17
0
 private void enableMonitoring(boolean enableMonitoring, EditableDocument configDoc) {
   EditableDocument monitoring = configDoc.getOrCreateDocument(FieldName.MONITORING);
   monitoring.set(FieldName.MONITORING_ENABLED, enableMonitoring);
 }
Example #18
0
  private EditableDocument parseWorkspaces(
      OperationContext context, ModelNode model, EditableDocument configDoc)
      throws OperationFailedException {
    EditableDocument workspacesDoc = configDoc.getOrCreateDocument(FieldName.WORKSPACES);
    boolean allowWorkspaceCreation =
        attribute(context, model, ModelAttributes.ALLOW_WORKSPACE_CREATION).asBoolean();
    String defaultWorkspaceName =
        attribute(context, model, ModelAttributes.DEFAULT_WORKSPACE).asString();
    workspacesDoc.set(FieldName.ALLOW_CREATION, allowWorkspaceCreation);
    workspacesDoc.set(FieldName.DEFAULT, defaultWorkspaceName);
    if (model.hasDefined(ModelKeys.PREDEFINED_WORKSPACE_NAMES)) {
      for (ModelNode name : model.get(ModelKeys.PREDEFINED_WORKSPACE_NAMES).asList()) {
        workspacesDoc.getOrCreateArray(FieldName.PREDEFINED).add(name.asString());
      }

      if (model.hasDefined(ModelKeys.WORKSPACES_INITIAL_CONTENT)) {
        EditableDocument initialContentDocument =
            workspacesDoc.getOrCreateDocument(FieldName.INITIAL_CONTENT);
        List<ModelNode> workspacesInitialContent =
            model.get(ModelKeys.WORKSPACES_INITIAL_CONTENT).asList();
        for (ModelNode initialContent : workspacesInitialContent) {
          Property initialContentProperty = initialContent.asProperty();
          initialContentDocument.set(
              initialContentProperty.getName(), initialContentProperty.getValue().asString());
        }
      }
    }
    if (model.hasDefined(ModelKeys.DEFAULT_INITIAL_CONTENT)) {
      EditableDocument initialContentDocument =
          workspacesDoc.getOrCreateDocument(FieldName.INITIAL_CONTENT);
      initialContentDocument.set(
          FieldName.DEFAULT_INITIAL_CONTENT,
          model.get(ModelKeys.DEFAULT_INITIAL_CONTENT).asString());
    }
    return workspacesDoc;
  }
Example #19
0
  @Override
  public void start(StartContext arg0) throws StartException {
    ModeShapeEngine engine = getEngine();

    try {
      final String repositoryName = repositoryName();

      // Get the index storage configuration ...
      IndexStorage indexStorageConfig = indexStorageConfigInjector.getValue();
      Document queryConfig = null;
      if (indexStorageConfig != null) {
        queryConfig = indexStorageConfig.getQueryConfiguration();
      } else {
        // We'll use the default index storage, but this will be overwritten by the *IndexStorageAdd
        // operation
        // (that we're dependent upon). The default for non-AS7 ModeShape repositories is to use
        // RAM index storage, but in AS7 we want to by default store the indexes on the filesystem
        // in the
        // AS7 data directory.
        // We'll do this by setting a path relative to the data directory, and then injecting
        // the "${jboss.server.data.dir}/modeshape" path into the repository service
        // (which will then update the configuration prior to deployment) ...
        EditableDocument query = Schematic.newDocument();
        EditableDocument indexing = query.getOrCreateDocument(FieldName.INDEXING);
        EditableDocument indexStorage = query.getOrCreateDocument(FieldName.INDEX_STORAGE);
        EditableDocument backend = indexing.getOrCreateDocument(FieldName.INDEXING_BACKEND);
        query.set(FieldName.REBUILD_UPON_STARTUP, QueryRebuild.IF_MISSING.toString().toLowerCase());
        backend.set(FieldName.TYPE, FieldValue.INDEXING_BACKEND_TYPE_LUCENE);
        indexStorage.set(FieldName.TYPE, FieldValue.INDEX_STORAGE_FILESYSTEM);
        String dataDirPath = dataDirectoryPathInjector.getValue();
        indexStorage.set(
            FieldName.INDEX_STORAGE_LOCATION, dataDirPath + "/" + repositoryName + "/indexes");
        queryConfig = query;
      }
      assert queryConfig != null;

      // Get the binary storage configuration ...
      Document binaryConfig = null;
      BinaryStorage binaryStorageConfig = binaryStorageInjector.getValue();
      if (binaryStorageConfig != null) {
        binaryConfig = binaryStorageConfig.getBinaryConfiguration();
      } else {
        // By default, store the binaries in the data directory ...
        EditableDocument binaries = Schematic.newDocument();
        binaries.set(FieldName.TYPE, FieldValue.BINARY_STORAGE_TYPE_FILE);
        String dataDirPath = dataDirectoryPathInjector.getValue();
        binaries.set(FieldName.DIRECTORY, dataDirPath + "/" + repositoryName + "/binaries");
        binaryConfig = binaries;
      }

      // Create a new configuration document ...
      EditableDocument config = Schematic.newDocument(repositoryConfiguration.getDocument());
      config.setDocument(FieldName.QUERY, queryConfig);
      config
          .getOrCreateDocument(FieldName.STORAGE)
          .setDocument(FieldName.BINARY_STORAGE, binaryConfig);

      if (LOG.isDebugEnabled()) {
        LOG.debugv("ModeShape configuration for '{0}' repository: {1}", repositoryName, config);
        Problems problems = repositoryConfiguration.validate();
        if (problems.isEmpty()) {
          LOG.debugv(
              "Problems with configuration for '{0}' repository: {1}", repositoryName, problems);
        }
      }

      // Create a new (updated) configuration ...
      repositoryConfiguration = new RepositoryConfiguration(config, repositoryName);

      // Deploy the repository and use this as the environment ...
      engine.deploy(repositoryConfiguration.with(this));
    } catch (ConfigurationException e) {
      throw new StartException(e);
    } catch (RepositoryException e) {
      throw new StartException(e);
    }
  }