/**
   * Writes driver configuration to disk.
   *
   * @param jobFolder The folder in which the job is staged.
   * @param jobId id of the job to be submitted
   * @param clientRemoteId The client remote id
   * @return the configuration
   * @throws IOException
   */
  public Configuration writeConfiguration(
      final File jobFolder, final String jobId, final String clientRemoteId) throws IOException {
    final File driverFolder = new File(jobFolder, PreparedDriverFolderLauncher.DRIVER_FOLDER_NAME);

    final Configuration driverConfiguration1 =
        driverConfigurationProvider.getDriverConfiguration(
            jobFolder.toURI(),
            clientRemoteId,
            jobId,
            Constants.DRIVER_CONFIGURATION_WITH_HTTP_AND_NAMESERVER);
    final ConfigurationBuilder configurationBuilder =
        Tang.Factory.getTang().newConfigurationBuilder();
    for (final ConfigurationProvider configurationProvider : this.configurationProviders) {
      configurationBuilder.addConfiguration(configurationProvider.getConfiguration());
    }
    final Configuration providedConfigurations = configurationBuilder.build();
    final Configuration driverConfiguration =
        Configurations.merge(
            driverConfiguration1,
            Tang.Factory.getTang()
                .newConfigurationBuilder()
                .bindNamedParameter(JobSubmissionDirectory.class, driverFolder.toString())
                .build(),
            providedConfigurations);
    final File driverConfigurationFile =
        new File(driverFolder, fileNames.getDriverConfigurationPath());
    configurationSerializer.toFile(driverConfiguration, driverConfigurationFile);
    return driverConfiguration;
  }
 private void addCustomConfigurationProviderProperties(ManagerParameter parameter) {
   Properties systemProps = System.getProperties();
   String providersStrList =
       systemProps.getProperty(ConfigurationProvider.CONFIG_PROVIDERS_PROPERTY);
   if (providersStrList != null) {
     String[] providersClassNames = providersStrList.split(",");
     if (providersClassNames != null) {
       for (String providerClassName : providersClassNames) {
         if (providerClassName == null || "".equals(providerClassName)) continue;
         try {
           Class<?> providerClass =
               Class.forName(providerClassName.trim(), true, classLoadingUtil.getClassloader());
           ConfigurationProvider configurationProvider =
               ConfigurationProvider.class.cast(providerClass.newInstance());
           parameter.mergeProperties(configurationProvider.getProperties());
         } catch (Exception e) {
           LOG.warning(
               "Cannot load configuration from provider class '"
                   + providerClassName
                   + "'. "
                   + e.getClass().getSimpleName()
                   + " ("
                   + e.getMessage()
                   + ").");
         }
       }
     }
   }
 }
  private void loadProviders(String providersString) {
    String[] providerArray = providersString.split(",");

    for (String p : providerArray) {
      try {
        log.info(String.format("Loading Configuration Provider :: %s", p));

        ConfigurationProvider cp = (ConfigurationProvider) Class.forName(p).newInstance();
        cp.init();

        providers.add(cp);
      } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
        log.warn("Could not load provider class", e);
      } catch (IOException e) {
        log.warn("Could not initialize provider");
      }
    }
  }
  private String lookupKey(String key) {
    for (ConfigurationProvider cp : providers) {
      String value = null;
      try {
        value = cp.getValue(key);
      } catch (IOException e) {
        log.warn(
            String.format(
                "Error retrieving value for \"%s\" from provider (%s)", key, cp.getName()),
            e);
      }

      if (value != null) {
        return value;
      }
    }

    return null;
  }
Esempio n. 5
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  private Configuration build(Object context) {

    Map<Integer, List<Rule>> priorityMap = new LinkedHashMap<Integer, List<Rule>>();
    for (ConfigurationProvider provider : providers) {
      if (provider.handles(context)) {
        Configuration configuration = provider.getConfiguration(context);

        if (configuration != null) {
          List<Rule> rules = configuration.getRules();
          if (rules != null) {
            for (Rule rule : rules) {
              if (rule != null) {
                if (rule instanceof RelocatableRule && ((RelocatableRule) rule).isRelocated())
                  addListValue(priorityMap, ((RelocatableRule) rule).priority(), rule);
                else addListValue(priorityMap, provider.priority(), rule);
              } else {
                log.debug(
                    "Ignoring null Rule from ConfigurationProvider ["
                        + provider.getClass().getName()
                        + "]");
              }
            }
          } else {
            log.debug(
                "Ignoring null List<Rule> from ConfigurationProvider ["
                    + provider.getClass().getName()
                    + "]");
          }
        } else {
          log.debug(
              "Ignoring null Configuration from ConfigurationProvider ["
                  + provider.getClass().getName()
                  + "].");
        }
      }
    }

    ConfigurationBuilder result = ConfigurationBuilder.begin();
    ArrayList<Integer> sortedKeys = new ArrayList<Integer>(priorityMap.keySet());
    Collections.sort(sortedKeys);

    for (Integer integer : sortedKeys) {
      List<Rule> list = priorityMap.get(integer);
      for (final Rule rule : list) {
        result.addRule(rule);

        if (rule instanceof ParameterizedRule) {
          ParameterizedCallback callback =
              new ParameterizedCallback() {
                @Override
                public void call(Parameterized parameterized) {
                  Set<String> names = parameterized.getRequiredParameterNames();
                  ParameterStore store = ((ParameterizedRule) rule).getParameterStore();

                  if (names != null)
                    for (String name : names) {
                      Parameter<?> parameter = store.get(name, new DefaultParameter(name));
                      if (parameter instanceof ConfigurableParameter<?>)
                        ((ConfigurableParameter<?>) parameter).bindsTo(Evaluation.property(name));
                    }

                  parameterized.setParameterStore(store);
                }
              };

          Visitor<Condition> conditionVisitor = new ParameterizedConditionVisitor(callback);
          new ConditionVisit(rule).accept(conditionVisitor);

          Visitor<Operation> operationVisitor = new ParameterizedOperationVisitor(callback);
          new OperationVisit(rule).accept(operationVisitor);
        }
      }
    }

    return result;
  }
 private void addInternalConfigurationProviderProperies(ManagerParameter parameter) {
   parameter.mergeProperties(urlConfigurationProvider.getProperties());
   parameter.mergeProperties(defaultConfigurationProvider.getProperties());
 }