public static ResourceBasedJobTemplate forURI(URI uri, JobCatalogWithTemplates catalog) throws SpecNotFoundException, TemplateException, IOException { try (InputStream is = getInputStreamForURI(uri)) { return new ResourceBasedJobTemplate(is, uri, catalog); } }
public StaticJobTemplate(URI uri, String version, String description, Config config, JobCatalogWithTemplates catalog) throws SpecNotFoundException, TemplateException { this(uri, version, description, config, getSuperTemplateUris(config), catalog); }
@Override public Config getRawTemplateConfig() throws SpecNotFoundException, TemplateException { ensureTemplatesResolved(); return getRawTemplateConfigHelper(Sets.<JobTemplate>newHashSet()); }
@Test public void test() throws Exception { ResourceBasedJobTemplate template = ResourceBasedJobTemplate.forResourcePath("templates/test.template", null); Collection<String> required = template.getRequiredConfigList(); Assert.assertEquals(required.size(), 3); Assert.assertTrue(required.contains("required0")); Assert.assertTrue(required.contains("required1")); Assert.assertTrue(required.contains("required2")); Config rawTemplate = template.getRawTemplateConfig(); Assert.assertEquals(rawTemplate.getString("templated0"), "x"); Assert.assertEquals(rawTemplate.getString("templated1"), "y"); Config resolved = template.getResolvedConfig( ConfigFactory.parseMap(ImmutableMap.of("required0", "r0", "required1", "r1", "required2", "r2"))); Assert.assertEquals(resolved.getString("templated0"), "x"); Assert.assertEquals(resolved.getString("required0"), "r0"); }
private static Properties resolveTemplate(Properties jobProps) throws IOException { try { if (jobProps.containsKey(ConfigurationKeys.JOB_TEMPLATE_PATH)) { Config jobConfig = ConfigUtils.propertiesToConfig(jobProps); Properties resolvedProps = ConfigUtils.configToProperties((ResourceBasedJobTemplate .forResourcePath(jobProps.getProperty(ConfigurationKeys.JOB_TEMPLATE_PATH), new PackagedTemplatesJobCatalogDecorator())) .getResolvedConfig(jobConfig)); return resolvedProps; } else { return jobProps; } } catch (JobTemplate.TemplateException | SpecNotFoundException | URISyntaxException exc) { throw new IOException(exc); } } }
public static ResourceBasedJobTemplate forResourcePath(String path) throws SpecNotFoundException, TemplateException, IOException, URISyntaxException { return forResourcePath(path, new PackagedTemplatesJobCatalogDecorator()); }
@Override public Collection<String> getRequiredConfigList() throws SpecNotFoundException, TemplateException { ensureTemplatesResolved(); Set<String> allRequired = getRequiredConfigListHelper(Sets.<JobTemplate>newHashSet()); final Config rawConfig = getRawTemplateConfig(); Set<String> filteredRequired = Sets.filter(allRequired, new Predicate<String>() { @Override public boolean apply(String input) { return !rawConfig.hasPath(input); } }); return filteredRequired; }
@Override public Config getResolvedConfig(Config userConfig) throws SpecNotFoundException, TemplateException { ensureTemplatesResolved(); return getResolvedConfigHelper(userConfig, Sets.<JobTemplate>newHashSet()); }
/** * Resolves a list of {@link URI}s to actual {@link JobTemplate}s. This pattern is necessary to detect loops in * inheritance and prevent them from causing a stack overflow. */ private synchronized void ensureTemplatesResolved() throws SpecNotFoundException, TemplateException{ if (this.resolved) { return; } Map<URI, JobTemplate> loadedTemplates = Maps.newHashMap(); loadedTemplates.put(getUri(), this); resolveTemplates(loadedTemplates); }
private Set<String> getRequiredConfigListHelper(Set<JobTemplate> alreadyLoadedTemplates) throws SpecNotFoundException, TemplateException { Set<String> requiredConfigs = Sets.newHashSet(getLocallyRequiredConfigList()); for (JobTemplate template : this.superTemplates) { if (!alreadyLoadedTemplates.contains(template)) { alreadyLoadedTemplates.add(template); requiredConfigs.addAll(template instanceof InheritingJobTemplate ? ((InheritingJobTemplate) template).getRequiredConfigListHelper(alreadyLoadedTemplates) : template.getRequiredConfigList()); } } return requiredConfigs; }
public static void main(String[] args) throws Exception { if (args.length != 5) { System.out.println("Usage: PullFileToConfigConverter <pullFilesRootPath> <pullFilesToConvertGlob> resource:///<templatePath> <sysConfigPath> <outputDir>"); System.exit(1); } new PullFileToConfigConverter(new Path(args[0]), new Path(args[1]), new Path(args[2]), new File(args[3]), new Path(args[4])) .convert(); }
private Config getResolvedConfigHelper(Config userConfig, Set<JobTemplate> alreadyLoadedTemplates) throws SpecNotFoundException, TemplateException { Config config = getLocallyResolvedConfig(userConfig); for (JobTemplate template : Lists.reverse(this.superTemplates)) { if (!alreadyLoadedTemplates.contains(template)) { alreadyLoadedTemplates.add(template); Config fallback = template instanceof InheritingJobTemplate ? ((InheritingJobTemplate) template).getResolvedConfigHelper(config, alreadyLoadedTemplates) : template.getResolvedConfig(config); config = config.withFallback(fallback); } } return config; }
private Config getRawTemplateConfigHelper(Set<JobTemplate> alreadyInheritedTemplates) throws SpecNotFoundException, TemplateException { Config rawTemplate = getLocalRawTemplate(); for (JobTemplate template : Lists.reverse(this.superTemplates)) { if (!alreadyInheritedTemplates.contains(template)) { alreadyInheritedTemplates.add(template); Config thisFallback = template instanceof InheritingJobTemplate ? ((InheritingJobTemplate) template).getRawTemplateConfigHelper(alreadyInheritedTemplates) : template.getRawTemplateConfig(); rawTemplate = rawTemplate.withFallback(thisFallback); } } return rawTemplate; }
@Test public void testRequiredAttrList() throws Exception { Properties jobProps = this.userProp; Collection<String> requiredConfigList = ResourceBasedJobTemplate.forURI(new URI( jobProps.getProperty(ConfigurationKeys.JOB_TEMPLATE_PATH)), new PackagedTemplatesJobCatalogDecorator()) .getRequiredConfigList(); Assert.assertEquals(requiredConfigList.size(), 3); Assert.assertTrue( requiredConfigList.contains("required0")); Assert.assertTrue( requiredConfigList.contains("required1")); Assert.assertTrue( requiredConfigList.contains("required2")); }
public static ResourceBasedJobTemplate forResourcePath(String path, JobCatalogWithTemplates catalog) throws SpecNotFoundException, TemplateException, IOException, URISyntaxException { return forURI(new URI(path), catalog); }
public Collection<JobTemplate> getSuperTemplates() throws SpecNotFoundException, TemplateException { ensureTemplatesResolved(); return ImmutableList.copyOf(this.superTemplates); }
private void resolveTemplates(Map<URI, JobTemplate> loadedTemplates) throws SpecNotFoundException, TemplateException { if (this.resolved) { return; } this.superTemplates = Lists.newArrayList(); for (URI uri : this.superTemplateUris) { if (!loadedTemplates.containsKey(uri)) { JobTemplate newTemplate = this.catalog.getTemplate(uri); loadedTemplates.put(uri, newTemplate); if (newTemplate instanceof InheritingJobTemplate) { ((InheritingJobTemplate) newTemplate).resolveTemplates(loadedTemplates); } } this.superTemplates.add(loadedTemplates.get(uri)); } this.resolved = true; }
@Override public JobTemplate answer(InvocationOnMock invocation) throws Throwable { return new TestTemplate((URI) invocation.getArguments()[0], this.superTemplateUris, this.rawTemplate, this.required, this.catalog); } }
@Override protected Config getLocallyResolvedConfig(Config userConfig) throws TemplateException { for (String required : this.required) { if (!userConfig.hasPath(required)) { throw new TemplateException("Missing required property " + required); } } return userConfig.withFallback(getLocalRawTemplate()); }
@CliObjectSupport(argumentNames = {"topics"}) public EmbeddedWikipediaExample(String... topics) throws JobTemplate.TemplateException, IOException { super("Wikipedia"); try { setTemplate(ResourceBasedJobTemplate.forResourcePath("wikipedia.template")); } catch (URISyntaxException | SpecNotFoundException exc) { throw new RuntimeException("Could not instantiate an " + EmbeddedWikipediaExample.class.getName(), exc); } this.setConfiguration("titles", Joiner.on(",").join(topics)); }