How to use

Extension

in

org.nuxeo.runtime.model

@Override
public void unregisterExtension(Extension extension) {
  if (extension.getExtensionPoint().equals("plugins")) {
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      if (contrib instanceof FileImporterDescriptor) {
        unregisterFileImporter((FileImporterDescriptor) contrib);
      } else if (contrib instanceof FolderImporterDescriptor) {
        unregisterFolderImporter((FolderImporterDescriptor) contrib);
      } else if (contrib instanceof CreationContainerListProviderDescriptor) {
        unregisterCreationContainerListProvider((CreationContainerListProviderDescriptor) contrib);
      }
    }
  } else if (extension.getExtensionPoint().equals("unicity")) {
    // nothing to do
  } else if (extension.getExtensionPoint().equals("versioning")) {
    // set to default value
    defaultVersioningOption = DEF_VERSIONING_OPTION;
    versioningAfterAdd = DEF_VERSIONING_AFTER_ADD;
  } else {
    log.warn("Unknown contribution {}: ignored", extension::getExtensionPoint);
  }
}

@Override
public void unregisterExtension(Extension extension) {
  String xp = extension.getExtensionPoint();
  if (NOTIFICATIONS_EP.equals(xp)) {
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      NotificationDescriptor notifDesc = (NotificationDescriptor) contrib;
      notificationRegistry.unregisterNotification(notifDesc);
    }
  } else if (TEMPLATES_EP.equals(xp)) {
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      TemplateDescriptor templateDescriptor = (TemplateDescriptor) contrib;
      templateDescriptor.setContext(extension.getContext());
      unregisterTemplate(templateDescriptor);
    }
  } else if (NOTIFICATION_VETO_EP.equals(xp)) {
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      NotificationListenerVetoDescriptor vetoDescriptor = (NotificationListenerVetoDescriptor) contrib;
      notificationVetoRegistry.removeContribution(vetoDescriptor);
    }
  }
}

@Override
public void registerExtension(Extension extension) {
  super.registerExtension(extension);
  final String extPoint = extension.getExtensionPoint();
  if (UID_GENERATORS_EXTENSION_POINT.equals(extPoint)) {
    log.info("register contributions for extension point: " + UID_GENERATORS_EXTENSION_POINT);
    final Object[] contribs = extension.getContributions();
    registerGenerators(extension, contribs);
  } else if (SEQUENCERS_EXTENSION_POINT.equals(extPoint)) {
    log.info("register contributions for extension point: " + SEQUENCERS_EXTENSION_POINT);
    final Object[] contribs = extension.getContributions();
    registerSequencers(extension, contribs);
    computeDefault();
  } else if (EXTENSION_POINT_SEQUENCER_FACTORY.equals(extPoint)) {
    String msg = "UIDSequencer factory no more supported from version 5.4. Faulty component: "
        + extension.getComponent();
    Framework.getRuntime().getMessageHandler().addWarning(msg);
    log.error(msg);
  } else {
    log.warn("extension not handled: " + extPoint);
  }
}

ExtensionInfoImpl xtinfo = new ExtensionInfoImpl(component, xt.getExtensionPoint());
xtinfo.setTargetComponentName(xt.getTargetComponent());
xtinfo.setContribution(xt.getContributions());
xtinfo.setDocumentation(xt.getDocumentation());
xtinfo.setXml(DocumentationHelper.secureXML(xt.toXML()));

/**
 * Register a given provider identified by its name.
 * New provider with same name will be override.
 * 
 * @param extension
 * @param registeredInfosProviders
 * @throws Exception
 */
private void registerInfosProvider(Extension extension, Map<String, DocumentInformationsProvider> registeredInfosProviders) {
  Object[] contributions = extension.getContributions();
  for (Object contribution : contributions) {
    if(contribution instanceof DocumentInformationsProviderDescriptor){
      DocumentInformationsProviderDescriptor descriptor = (DocumentInformationsProviderDescriptor) contribution;
      if(StringUtils.isNotBlank(descriptor.getName())){
        try {
          DocumentInformationsProvider infosProvider = (DocumentInformationsProvider) extension.getContext().loadClass(descriptor.getProviderClassName()).newInstance();
          registeredInfosProviders.put(descriptor.getName(), infosProvider);
        } catch (InstantiationException | IllegalAccessException
            | ClassNotFoundException e) {
          log.error("Can not register " + descriptor.getName(), e);
        }
        
      } else {
        log.error("Can not register an Informations provider which has no name: "
            .concat(StringUtils.isNotBlank(descriptor.getProviderClassName()) ? descriptor.getProviderClassName() : "null"));
      }
    }
  }
}

@Override
public void registerExtension(Extension extension) {
  Object[] contribs = extension.getContributions();
  for (Object contrib : contribs) {
    registerSchedule((Schedule) contrib);
  }
}

/**
 * Read a component from his StreamRef and create a new component (suffixed with `-partial`, and the base component
 * name aliased) with only matching contributions of the extensionPoints parameter.
 *
 * @param ctx RuntimeContext in which the new component will be deployed
 * @param extensionPoints Set of white listed TargetExtensions
 * @param component Reference to the original component
 * @throws IOException Signals that an I/O exception has occurred.
 */
protected void deployPartialComponent(RuntimeContext ctx, Set<TargetExtensions> extensionPoints,
    StreamRef component) throws IOException {
  RegistrationInfo ri = ((DefaultRuntimeContext) ctx).createRegistrationInfo(component);
  String name = ri.getName().getName() + "-partial";
  // Flatten Target Extension Points
  Set<String> targets = extensionPoints.stream()
                     .map(TargetExtensions::getTargetExtensions)
                     .flatMap(Set::stream)
                     .collect(Collectors.toSet());
  String ext = Arrays.stream(ri.getExtensions())
            .filter(e -> targets.contains(TargetExtensions.newTargetExtension(
                e.getTargetComponent().getName(), e.getExtensionPoint())))
            .map(Extension::toXML)
            .collect(joining());
  ctx.deploy(new InlineRef(name, String.format("<component name=\"%s\">%s</component>", name, ext)));
}

private void registerFolderImporter(FolderImporterDescriptor folderImporterDescriptor, Extension extension) {
  String name = folderImporterDescriptor.getName();
  String className = folderImporterDescriptor.getClassName();
  FolderImporter folderImporter;
  try {
    folderImporter = (FolderImporter) extension.getContext().loadClass(className).newInstance();
  } catch (ReflectiveOperationException e) {
    throw new NuxeoException(e);
  }
  folderImporter.setName(name);
  folderImporter.setFileManagerService(this);
  folderImporters.add(folderImporter);
  log.info("registered folder importer: {}", name);
}

/**
 * {@inheritDoc}
 */
@Override
public void unregisterExtension(Extension extension) {
  if(FETCH_INFOS_EXT_POINT.equals(extension.getExtensionPoint())){
    unregisterInfosProvider(extension, infosProvidersRegistry);
  } else if(EXTENDED_FETCH_INFOS_EXT_POINT.equals(extension.getExtensionPoint())){
    unregisterInfosProvider(extension, extendedInfosProvidersRegistry);
  }
}

@Override
public void registerExtension(Extension extension) {
  Object[] contribs = extension.getContributions();
  for (Object contrib : contribs) {
    register((LocationManagerPluginExtension) contrib);
  }
}

private void registerCreationContainerListProvider(CreationContainerListProviderDescriptor ccListProviderDescriptor,
    Extension extension) {
  String name = ccListProviderDescriptor.getName();
  String[] docTypes = ccListProviderDescriptor.getDocTypes();
  String className = ccListProviderDescriptor.getClassName();
  CreationContainerListProvider provider;
  try {
    provider = (CreationContainerListProvider) extension.getContext().loadClass(className).newInstance();
  } catch (ReflectiveOperationException e) {
    throw new NuxeoException(e);
  }
  provider.setName(name);
  provider.setDocTypes(docTypes);
  if (creationContainerListProviders.contains(provider)) {
    // equality and containment tests are based on unique names
    creationContainerListProviders.remove(provider);
  }
  // add the new provider at the beginning of the list
  creationContainerListProviders.add(0, provider);
  log.info("registered creationContaineterList provider: {}", name);
}

/**
 * {@inheritDoc}
 */
@Override
public void registerExtension(Extension extension) {
  if(FETCH_INFOS_EXT_POINT.equals(extension.getExtensionPoint())){
    registerInfosProvider(extension, infosProvidersRegistry);
  } else if(EXTENDED_FETCH_INFOS_EXT_POINT.equals(extension.getExtensionPoint())){
    registerInfosProvider(extension, extendedInfosProvidersRegistry);
  }
}

@Override
public void unregisterExtension(Extension extension) {
  final String extPoint = extension.getExtensionPoint();
  if (UID_GENERATORS_EXTENSION_POINT.equals(extPoint)) {
    log.info("unregister contributions for extension point: " + UID_GENERATORS_EXTENSION_POINT);
    // final Object[] contribs = extension.getContributions();
    // unregisterGenerators(extension, contribs);
  } else if (SEQUENCERS_EXTENSION_POINT.equals(extPoint)) {
    log.info("unregister contributions for extension point: " + SEQUENCERS_EXTENSION_POINT);
    final Object[] contribs = extension.getContributions();
    unregisterSequencers(extension, contribs);
    computeDefault();
  } else {
    log.warn("extension not handled: " + extPoint);
  }
  super.unregisterExtension(extension);
}

@Override
public void registerExtension(Extension extension) {
  log.info("Registering notification extension");
  String xp = extension.getExtensionPoint();
  if (NOTIFICATIONS_EP.equals(xp)) {
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      NotificationDescriptor notifDesc = (NotificationDescriptor) contrib;
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      TemplateDescriptor templateDescriptor = (TemplateDescriptor) contrib;
      templateDescriptor.setContext(extension.getContext());
      registerTemplate(templateDescriptor);
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      registerGeneralSettings((GeneralSettingsDescriptor) contrib);
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      NotificationListenerHookDescriptor desc = (NotificationListenerHookDescriptor) contrib;
    Object[] contribs = extension.getContributions();
    for (Object contrib : contribs) {
      NotificationListenerVetoDescriptor desc = (NotificationListenerVetoDescriptor) contrib;

/**
 * Unregister a provider.
 * 
 * @param extension
 * @param registeredInfosProviders
 */
private void unregisterInfosProvider(Extension extension, Map<String, DocumentInformationsProvider> registeredInfosProviders) {
  Object[] contributions = extension.getContributions();
  for (Object contribution : contributions) {
    if(contribution instanceof DocumentInformationsProviderDescriptor){
      registeredInfosProviders.remove(((DocumentInformationsProviderDescriptor) contribution).getName());
    }
  }
}

FileImporter newPlugin;
try {
  newPlugin = className != null ? (FileImporter) extension.getContext().loadClass(className).newInstance()
      : oldPlugin;
} catch (ReflectiveOperationException e) {
FileImporter plugin;
try {
  plugin = (FileImporter) extension.getContext().loadClass(className).newInstance();
} catch (ReflectiveOperationException e) {
  throw new NuxeoException(e);

/**
 * Unregisters an extension.
 */
@Override
public void unregisterExtension(Extension extension) {
  super.unregisterExtension(extension);
  Object[] contributions = extension.getContributions();
  if (contributions != null) {
    String point = extension.getExtensionPoint();
    if (point.equals("lifecycle")) {
      for (Object lifeCycle : contributions) {
        LifeCycleDescriptor lifeCycleDescriptor = (LifeCycleDescriptor) lifeCycle;
        lifeCycles.removeContribution(lifeCycleDescriptor);
      }
    } else if (point.equals("types")) {
      for (Object contrib : contributions) {
        LifeCycleTypesDescriptor desc = (LifeCycleTypesDescriptor) contrib;
        lifeCycleTypes.removeContribution(desc);
      }
    }
  }
}

@Override
public void registerExtension(Extension extension) {
  String xp = extension.getExtensionPoint();
  Object[] contribs = extension.getContributions();
  switch (xp) {
  case XP_DOCTYPE:
      sbd.context = extension.getContext();
      schemaManager.registerSchema(sbd);

protected void registerGenerators(Extension extension, final Object[] contribs) {
  // read the list of generators
  for (Object contrib : contribs) {
    final UIDGeneratorDescriptor generatorDescriptor = (UIDGeneratorDescriptor) contrib;
    final String generatorName = generatorDescriptor.getName();
    UIDGenerator generator;
    try {
      generator = (UIDGenerator) extension.getContext()
                        .loadClass(generatorDescriptor.getClassName())
                        .newInstance();
    } catch (ReflectiveOperationException e) {
      throw new RuntimeException(e);
    }
    final String[] propNames = generatorDescriptor.getPropertyNames();
    if (propNames.length == 0) {
      log.error("no property name defined on generator " + generatorName);
    }
    // set the property name on generator
    generator.setPropertyNames(propNames);
    // Register Generator for DocTypes and property name
    final String[] docTypes = generatorDescriptor.getDocTypes();
    registerGeneratorForDocTypes(generator, docTypes);
    log.info("registered UID generator: " + generatorName);
  }
}

/**
 * Register extensions.
 */
@Override
public void registerExtension(Extension extension) {
  Object[] contributions = extension.getContributions();
  if (contributions != null) {
    String point = extension.getExtensionPoint();
    if (point.equals("lifecycle")) {
      for (Object contribution : contributions) {
        LifeCycleDescriptor desc = (LifeCycleDescriptor) contribution;
        lifeCycles.addContribution(desc);
        // look for delete state to warn about usage
        if (!"default".equals(desc.getName())
            && desc.getStates().stream().map(LifeCycleState::getName).anyMatch(
                isEqual(DELETED_STATE))) {
          log.warn("The 'deleted' state is deprecated and shouldn't be use anymore."
              + " Please consider removing it from you life cycle policy and use trash service instead.");
        }
      }
    } else if (point.equals("lifecyclemanager")) {
      log.warn("Ignoring deprecated lifecyclemanager extension point");
    } else if (point.equals("types")) {
      for (Object mapping : contributions) {
        LifeCycleTypesDescriptor desc = (LifeCycleTypesDescriptor) mapping;
        lifeCycleTypes.addContribution(desc);
      }
    }
  }
}