private void fixRemoteUrl(ResourceStoreRequest request) {
    if (overwriteRemoteUrl != null) {
      return;
    }

    if (P2Constants.SITE_XML.equals(request.getRequestPath())) {
      return;
    }

    try {
      RepositoryItemUid siteUID = createUid(P2Constants.SITE_XML);
      ResourceStoreRequest siteRequest = new ResourceStoreRequest(siteUID.getPath());
      StorageFileItem siteItem;
      try {
        siteItem = (StorageFileItem) getLocalStorage().retrieveItem(this, siteRequest);
      } catch (ItemNotFoundException e) {
        siteItem =
            (StorageFileItem) getRemoteStorage().retrieveItem(this, siteRequest, getRemoteUrl());
      }

      PlexusConfiguration plexusConfig =
          new XmlPlexusConfiguration(
              Xpp3DomBuilder.build(new InputStreamReader(siteItem.getInputStream())));

      this.overwriteRemoteUrl = plexusConfig.getAttribute("url");
      getLogger()
          .info("Remote update site does overwrite the remote url " + this.overwriteRemoteUrl);
    } catch (Exception e) {
      getLogger().debug(e.getMessage(), e);
      this.overwriteRemoteUrl = "";
    }
  }
Beispiel #2
0
  public void processConfiguration(
      ConverterLookup converterLookup,
      Object object,
      ClassLoader classLoader,
      PlexusConfiguration configuration,
      ExpressionEvaluator expressionEvaluator)
      throws ComponentConfigurationException {
    int items = configuration.getChildCount();

    for (int i = 0; i < items; i++) {
      PlexusConfiguration childConfiguration = configuration.getChild(i);

      String elementName = childConfiguration.getName();

      ComponentValueSetter valueSetter =
          new ComponentValueSetter(fromXML(elementName), object, converterLookup);

      valueSetter.configure(childConfiguration, classLoader, expressionEvaluator);
      /*
      Object value = valueSetter.getConverter().fromConfiguration(
          converterLookup, childConfiguration, valueSetter.getValueType(),
          object.getClass(), classLoader, expressionEvaluator
      );

      if ( value != null )
      {
          valueSetter.setValue( value );
      }
      */
    }
  }
  private void writeConfiguration(XMLWriter w, PlexusConfiguration configuration)
      throws ComponentDescriptorCreatorException, PlexusConfigurationException {
    if (configuration == null || configuration.getChildCount() == 0) {
      return;
    }

    if (!configuration.getName().equals("configuration")) {
      throw new ComponentDescriptorCreatorException(
          "The root node of the configuration must be " + "'configuration'.");
    }

    writePlexusConfiguration(w, configuration);
  }
Beispiel #4
0
 /**
  * Recursively convert PLEXUS config to Xpp3Dom.
  *
  * @param config The config to convert
  * @return The Xpp3Dom document
  * @see #execute(String,String,Properties)
  */
 private Xpp3Dom toXppDom(final PlexusConfiguration config) {
   final Xpp3Dom result = new Xpp3Dom(config.getName());
   result.setValue(config.getValue(null));
   for (final String name : config.getAttributeNames()) {
     try {
       result.setAttribute(name, config.getAttribute(name));
     } catch (final PlexusConfigurationException ex) {
       throw new IllegalArgumentException(ex);
     }
   }
   for (final PlexusConfiguration child : config.getChildren()) {
     result.addChild(this.toXppDom(child));
   }
   return result;
 }
  protected void initializePhases() throws PlexusContainerException {
    PlexusConfiguration initializationConfiguration =
        configuration.getChild("container-initialization");

    ContainerInitializationContext initializationContext =
        new ContainerInitializationContext(this, classWorld, containerRealm, configuration);

    // PLXAPI: I think we might only ever need one of these so maybe we can create it with a
    // constructor
    // and store it.
    ComponentConfigurator c = new BasicComponentConfigurator();

    try {
      c.configureComponent(this, initializationConfiguration, containerRealm);
    } catch (ComponentConfigurationException e) {
      throw new PlexusContainerException(
          "Error setting container initialization initializationPhases.", e);
    }

    for (Iterator iterator = initializationPhases.iterator(); iterator.hasNext(); ) {
      ContainerInitializationPhase phase = (ContainerInitializationPhase) iterator.next();

      try {
        phase.execute(initializationContext);
      } catch (ContainerInitializationException e) {
        throw new PlexusContainerException("Error initializaing container in " + phase + ".", e);
      }
    }
  }
Beispiel #6
0
  protected void loadComponentsOnStart()
      throws PlexusConfigurationException, ComponentLookupException {
    PlexusConfiguration[] loadOnStartComponents =
        configuration.getChild("load-on-start").getChildren("component");

    getLogger().debug("Found " + loadOnStartComponents.length + " components to load on start");

    for (int i = 0; i < loadOnStartComponents.length; i++) {
      String role = loadOnStartComponents[i].getChild("role").getValue(null);

      String roleHint = loadOnStartComponents[i].getChild("role-hint").getValue();

      if (role == null) {
        throw new PlexusConfigurationException("Missing 'role' element from load-on-start.");
      }

      if (roleHint == null) {
        getLogger().info("Loading on start [role]: " + "[" + role + "]");

        lookup(role);
      } else if (roleHint.equals("*")) {
        getLogger().info("Loading on start all components with [role]: " + "[" + role + "]");

        lookupList(role);
      } else {
        getLogger().info("Loading on start [role,roleHint]: " + "[" + role + "," + roleHint + "]");

        lookup(role, roleHint);
      }
    }
  }
Beispiel #7
0
  // TODO: Do not swallow exception
  public void initializeResources() throws PlexusConfigurationException {
    PlexusConfiguration[] resourceConfigs = configuration.getChild("resources").getChildren();

    for (int i = 0; i < resourceConfigs.length; ++i) {
      try {
        String name = resourceConfigs[i].getName();

        if (name.equals("jar-repository")) {
          addJarRepository(new File(resourceConfigs[i].getValue()));
        } else if (name.equals("directory")) {
          File directory = new File(resourceConfigs[i].getValue());

          if (directory.exists() && directory.isDirectory()) {
            plexusRealm.addConstituent(directory.toURL());
          }
        } else {
          getLogger().warn("Unknown resource type: " + name);
        }
      } catch (MalformedURLException e) {
        getLogger()
            .error(
                "Error configuring resource: "
                    + resourceConfigs[i].getName()
                    + "="
                    + resourceConfigs[i].getValue(),
                e);
      }
    }
  }
Beispiel #8
0
  private void initializeCoreComponents()
      throws ComponentConfigurationException, ComponentRepositoryException, ContextException {
    BasicComponentConfigurator configurator = new BasicComponentConfigurator();

    PlexusConfiguration c = configuration.getChild("component-repository");

    processCoreComponentConfiguration("component-repository", configurator, c);

    componentRepository.configure(configuration);

    componentRepository.setClassRealm(plexusRealm);

    componentRepository.initialize();

    // Lifecycle handler manager

    c = configuration.getChild("lifecycle-handler-manager");

    processCoreComponentConfiguration("lifecycle-handler-manager", configurator, c);

    lifecycleHandlerManager.initialize();

    // Component manager manager

    c = configuration.getChild("component-manager-manager");

    processCoreComponentConfiguration("component-manager-manager", configurator, c);

    componentManagerManager.setLifecycleHandlerManager(lifecycleHandlerManager);

    // Component discoverer manager

    c = configuration.getChild("component-discoverer-manager");

    processCoreComponentConfiguration("component-discoverer-manager", configurator, c);

    componentDiscovererManager.initialize();

    // Component factory manager

    c = configuration.getChild("component-factory-manager");

    processCoreComponentConfiguration("component-factory-manager", configurator, c);

    if (componentFactoryManager instanceof Contextualizable) {
      Context context = getContext();

      context.put(PlexusConstants.PLEXUS_KEY, this);

      ((Contextualizable) componentFactoryManager).contextualize(getContext());
    }

    // Component factory manager

    c = configuration.getChild("component-composer-manager");

    processCoreComponentConfiguration("component-composer-manager", configurator, c);
  }
Beispiel #9
0
  private void processCoreComponentConfiguration(
      String role, BasicComponentConfigurator configurator, PlexusConfiguration c)
      throws ComponentConfigurationException {
    String implementation = c.getAttribute("implementation", null);

    if (implementation == null) {

      String msg =
          "Core component: '"
              + role
              + "' + which is needed by plexus to function properly cannot "
              + "be instantiated. Implementation attribute was not specified in plexus.conf."
              + "This is highly irregular, your plexus JAR is most likely corrupt.";

      throw new ComponentConfigurationException(msg);
    }

    ComponentDescriptor componentDescriptor = new ComponentDescriptor();

    componentDescriptor.setRole(role);

    componentDescriptor.setImplementation(implementation);

    PlexusConfiguration configuration = new XmlPlexusConfiguration("configuration");

    configuration.addChild(c);

    try {
      configurator.configureComponent(this, configuration, plexusRealm);
    } catch (ComponentConfigurationException e) {
      // TODO: don't like rewrapping the same exception, but better than polluting this all through
      // the config code
      String message = "Error configuring component: " + componentDescriptor.getHumanReadableKey();
      throw new ComponentConfigurationException(message, e);
    }
  }
  private void writePlexusConfiguration(XMLWriter xmlWriter, PlexusConfiguration c)
      throws PlexusConfigurationException {
    if (c.getAttributeNames().length == 0 && c.getChildCount() == 0 && c.getValue() == null) {
      return;
    }

    xmlWriter.startElement(c.getName());

    // ----------------------------------------------------------------------
    // Write the attributes
    // ----------------------------------------------------------------------

    String[] attributeNames = c.getAttributeNames();

    for (int i = 0; i < attributeNames.length; i++) {
      String attributeName = attributeNames[i];

      xmlWriter.addAttribute(attributeName, c.getAttribute(attributeName));
    }

    // ----------------------------------------------------------------------
    // Write the children
    // ----------------------------------------------------------------------

    PlexusConfiguration[] children = c.getChildren();

    if (children.length > 0) {
      for (int i = 0; i < children.length; i++) {
        writePlexusConfiguration(xmlWriter, children[i]);
      }
    } else {
      String value = c.getValue();

      if (value != null) {
        xmlWriter.writeText(value);
      }
    }

    xmlWriter.endElement();
  }
Beispiel #11
0
  private void initializeSystemProperties() throws PlexusConfigurationException {
    PlexusConfiguration[] systemProperties =
        configuration.getChild("system-properties").getChildren("property");

    for (int i = 0; i < systemProperties.length; ++i) {
      String name = systemProperties[i].getAttribute("name");

      String value = systemProperties[i].getAttribute("value");

      if (name == null) {
        throw new PlexusConfigurationException("Missing 'name' attribute in 'property' tag. ");
      }

      if (value == null) {
        throw new PlexusConfigurationException("Missing 'value' attribute in 'property' tag. ");
      }

      System.getProperties().setProperty(name, value);

      getLogger().info("Setting system property: [ " + name + ", " + value + " ]");
    }
  }
Beispiel #12
0
  public static ComponentSetDescriptor buildComponentSet(PlexusConfiguration c) throws Exception {
    ComponentSetDescriptor csd = new ComponentSetDescriptor();

    // ----------------------------------------------------------------------
    // Components
    // ----------------------------------------------------------------------

    PlexusConfiguration[] components = c.getChild("components").getChildren("component");

    for (int i = 0; i < components.length; i++) {
      PlexusConfiguration component = components[i];

      csd.addComponentDescriptor(buildComponentDescriptor(component));
    }

    // ----------------------------------------------------------------------
    // Dependencies
    // ----------------------------------------------------------------------

    PlexusConfiguration[] dependencies = c.getChild("dependencies").getChildren("dependency");

    for (int i = 0; i < dependencies.length; i++) {
      PlexusConfiguration d = dependencies[i];

      ComponentDependency cd = new ComponentDependency();

      cd.setArtifactId(d.getChild("artifact-id").getValue());

      cd.setGroupId(d.getChild("group-id").getValue());

      cd.setType(d.getChild("type").getValue());

      cd.setVersion(d.getChild("version").getValue());

      csd.addDependency(cd);
    }

    return csd;
  }
  /**
   * Process any additional component configuration files that have been specified. The specified
   * directory is scanned recursively so configurations can be within nested directories to help
   * with component organization.
   */
  private void processConfigurationsDirectory() throws PlexusConfigurationException {
    String s = configuration.getChild("configurations-directory").getValue(null);

    if (s != null) {
      PlexusConfiguration componentsConfiguration = configuration.getChild("components");

      File configurationsDirectory = new File(s);

      if (configurationsDirectory.exists() && configurationsDirectory.isDirectory()) {
        List componentConfigurationFiles;
        try {
          componentConfigurationFiles =
              FileUtils.getFiles(configurationsDirectory, "**/*.conf", "**/*.xml");
        } catch (IOException e) {
          throw new PlexusConfigurationException("Unable to locate configuration files", e);
        }

        for (Iterator i = componentConfigurationFiles.iterator(); i.hasNext(); ) {
          File componentConfigurationFile = (File) i.next();

          Reader reader = null;
          try {
            reader = ReaderFactory.newXmlReader(componentConfigurationFile);
            PlexusConfiguration componentConfiguration =
                PlexusTools.buildConfiguration(
                    componentConfigurationFile.getAbsolutePath(),
                    getInterpolationConfigurationReader(reader));

            componentsConfiguration.addChild(componentConfiguration.getChild("components"));
          } catch (FileNotFoundException e) {
            throw new PlexusConfigurationException(
                "File " + componentConfigurationFile + " disappeared before processing", e);
          } catch (IOException e) {
            throw new PlexusConfigurationException(
                "IO error while reading " + componentConfigurationFile, e);
          } finally {
            IOUtil.close(reader);
          }
        }
      }
    }
  }
 public String getArchiverConfig() {
   return archiverConfig == null ? null : archiverConfig.toString();
 }
Beispiel #15
0
  public static ComponentDescriptor buildComponentDescriptor(PlexusConfiguration configuration)
      throws Exception {
    ComponentDescriptor cd = new ComponentDescriptor();

    cd.setRole(configuration.getChild("role").getValue());

    cd.setRoleHint(configuration.getChild("role-hint").getValue());

    cd.setImplementation(configuration.getChild("implementation").getValue());

    cd.setVersion(configuration.getChild("version").getValue());

    cd.setComponentType(configuration.getChild("component-type").getValue());

    cd.setInstantiationStrategy(configuration.getChild("instantiation-strategy").getValue());

    cd.setLifecycleHandler(configuration.getChild("lifecycle-handler").getValue());

    cd.setComponentProfile(configuration.getChild("component-profile").getValue());

    cd.setComponentComposer(configuration.getChild("component-composer").getValue());

    cd.setComponentFactory(configuration.getChild("component-factory").getValue());

    cd.setDescription(configuration.getChild("description").getValue());

    cd.setAlias(configuration.getChild("alias").getValue());

    String s = configuration.getChild("isolated-realm").getValue();

    if (s != null) {
      cd.setIsolatedRealm(s.equals("true") ? true : false);
    }

    // ----------------------------------------------------------------------
    // Here we want to look for directives for inlining external
    // configurations. we probably want to take them from files or URLs.
    // ----------------------------------------------------------------------

    cd.setConfiguration(configuration.getChild("configuration"));

    // ----------------------------------------------------------------------
    // Requirements
    // ----------------------------------------------------------------------

    PlexusConfiguration[] requirements =
        configuration.getChild("requirements").getChildren("requirement");

    for (int i = 0; i < requirements.length; i++) {
      PlexusConfiguration requirement = requirements[i];

      ComponentRequirement cr = new ComponentRequirement();

      cr.setRole(requirement.getChild("role").getValue());

      cr.setRoleHint(requirement.getChild("role-hint").getValue());

      cr.setFieldName(requirement.getChild("field-name").getValue());

      cd.addRequirement(cr);
    }

    return cd;
  }
  public Object fromConfiguration(
      ConverterLookup converterLookup,
      PlexusConfiguration configuration,
      Class type,
      Class baseType,
      ClassLoader classLoader,
      ExpressionEvaluator expressionEvaluator,
      ConfigurationListener listener)
      throws ComponentConfigurationException {
    Object retValue = fromExpression(configuration, expressionEvaluator, type);
    if (retValue != null) {
      return retValue;
    }

    Class implementation = getClassForImplementationHint(null, configuration, classLoader);

    if (implementation != null) {
      retValue = instantiateObject(implementation);
    } else {
      // we can have 2 cases here:
      //  - provided collection class which is not abstract
      //     like Vector, ArrayList, HashSet - so we will just instantantiate it
      // - we have an abtract class so we have to use default collection type
      int modifiers = type.getModifiers();

      if (Modifier.isAbstract(modifiers)) {
        retValue = getDefaultCollection(type);
      } else {
        try {
          retValue = type.newInstance();
        } catch (IllegalAccessException e) {
          String msg =
              "An attempt to convert configuration entry "
                  + configuration.getName()
                  + "' into "
                  + type
                  + " object failed: "
                  + e.getMessage();

          throw new ComponentConfigurationException(msg, e);
        } catch (InstantiationException e) {
          String msg =
              "An attempt to convert configuration entry "
                  + configuration.getName()
                  + "' into "
                  + type
                  + " object failed: "
                  + e.getMessage();

          throw new ComponentConfigurationException(msg, e);
        }
      }
    }
    // now we have collection and we have to add some objects to it

    for (int i = 0; i < configuration.getChildCount(); i++) {
      PlexusConfiguration c = configuration.getChild(i);

      Class childType = getImplementationClass(null, baseType, c, classLoader);

      ConfigurationConverter converter = converterLookup.lookupConverterForType(childType);

      Object object =
          converter.fromConfiguration(
              converterLookup, c, childType, baseType, classLoader, expressionEvaluator, listener);

      Collection collection = (Collection) retValue;
      collection.add(object);
    }

    return retValue;
  }
Beispiel #17
0
  public Object fromConfiguration(
      ConverterLookup converterLookup,
      PlexusConfiguration configuration,
      Class type,
      Class baseType,
      ClassLoader classLoader,
      ExpressionEvaluator expressionEvaluator)
      throws ComponentConfigurationException {
    Object retValue = fromExpression(configuration, expressionEvaluator, type);
    if (retValue != null) {
      return retValue;
    }

    Class implementation = getClassForImplementationHint(null, configuration, classLoader);

    if (implementation != null) {
      retValue = instantiateObject(implementation);
    } else {
      // we can have 2 cases here:
      //  - provided collection class which is not abstract
      //     like Vector, ArrayList, HashSet - so we will just instantantiate it
      // - we have an abtract class so we have to use default collection type
      int modifiers = type.getModifiers();

      if (Modifier.isAbstract(modifiers)) {
        retValue = getDefaultCollection(type);
      } else {
        try {
          retValue = type.newInstance();
        } catch (IllegalAccessException e) {
          String msg =
              "An attempt to convert configuration entry "
                  + configuration.getName()
                  + "' into "
                  + type
                  + " object failed: "
                  + e.getMessage();

          throw new ComponentConfigurationException(msg, e);
        } catch (InstantiationException e) {
          String msg =
              "An attempt to convert configuration entry "
                  + configuration.getName()
                  + "' into "
                  + type
                  + " object failed: "
                  + e.getMessage();

          throw new ComponentConfigurationException(msg, e);
        }
      }
    }
    // now we have collection and we have to add some objects to it

    for (int i = 0; i < configuration.getChildCount(); i++) {
      PlexusConfiguration c = configuration.getChild(i);
      // Object o = null;

      String configEntry = c.getName();

      String name = StringUtils.capitalizeFirstLetter(fromXML(configEntry));

      Class childType = getClassForImplementationHint(null, c, classLoader);

      if (childType == null) {
        // Some classloaders don't create Package objects for classes
        // so we have to resort to slicing up the class name

        String baseTypeName = baseType.getName();

        int lastDot = baseTypeName.lastIndexOf('.');

        String className;

        if (lastDot == -1) {
          className = name;
        } else {
          String basePackage = baseTypeName.substring(0, lastDot);

          className = basePackage + "." + name;
        }

        childType = loadClass(className, classLoader);
      }

      ConfigurationConverter converter = converterLookup.lookupConverterForType(childType);

      Object object =
          converter.fromConfiguration(
              converterLookup, c, childType, baseType, classLoader, expressionEvaluator);

      Collection collection = (Collection) retValue;
      collection.add(object);
    }

    return retValue;
  }