Examples with TemplatesConfigurationVersion com.devonfw.cobigen.impl.config.constant.TemplatesConfigurationVersion used on opensource projects

Example 1 with TemplatesConfigurationVersion

use of com.devonfw.cobigen.impl.config.constant.TemplatesConfigurationVersion in project cobigen by devonfw.

the class TemplatesConfigurationReader method readConfiguration.

/**
 * Reads the templates configuration.
 */
private void readConfiguration() {
    // workaround to make JAXB work in OSGi context by
    // https://github.com/ControlSystemStudio/cs-studio/issues/2530#issuecomment-450991188
    final ClassLoader orig = Thread.currentThread().getContextClassLoader();
    if (JvmUtil.isRunningJava9OrLater()) {
        Thread.currentThread().setContextClassLoader(JAXBContext.class.getClassLoader());
    }
    try (InputStream in = Files.newInputStream(this.configFilePath)) {
        Unmarshaller unmarschaller = JAXBContext.newInstance(TemplatesConfiguration.class).createUnmarshaller();
        // Unmarshal without schema checks for getting the version attribute of the root node.
        // This is necessary to provide an automatic upgrade client later on
        Object rootNode = unmarschaller.unmarshal(in);
        if (rootNode instanceof TemplatesConfiguration) {
            BigDecimal configVersion = ((TemplatesConfiguration) rootNode).getVersion();
            if (configVersion == null) {
                throw new InvalidConfigurationException(this.configFilePath.toUri().toString(), "The required 'version' attribute of node \"templatesConfiguration\" has not been set");
            } else {
                VersionValidator validator = new VersionValidator(Type.TEMPLATES_CONFIGURATION, MavenMetadata.VERSION);
                validator.validate(configVersion.floatValue());
            }
        } else {
            throw new InvalidConfigurationException(this.configFilePath.toUri().toString(), "Unknown Root Node. Use \"templatesConfiguration\" as root Node");
        }
        // If we reach this point, the configuration version and root node has been validated.
        // Unmarshal with schema checks for checking the correctness and give the user more hints to
        // correct his failures
        SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        TemplatesConfigurationVersion latestConfigurationVersion = TemplatesConfigurationVersion.getLatest();
        try (InputStream schemaStream = getClass().getResourceAsStream("/schema/" + latestConfigurationVersion + "/templatesConfiguration.xsd");
            InputStream configInputStream = Files.newInputStream(this.configFilePath)) {
            Schema schema = schemaFactory.newSchema(new StreamSource(schemaStream));
            unmarschaller.setSchema(schema);
            rootNode = unmarschaller.unmarshal(configInputStream);
            this.configNode = (TemplatesConfiguration) rootNode;
        }
    } catch (JAXBException e) {
        // try getting SAXParseException for better error handling and user support
        Throwable parseCause = ExceptionUtil.getCause(e, SAXParseException.class, UnmarshalException.class);
        String message = "";
        if (parseCause != null && parseCause.getMessage() != null) {
            message = parseCause.getMessage();
        }
        throw new InvalidConfigurationException(this.configFilePath.toUri().toString(), "Could not parse configuration file:\n" + message, e);
    } catch (SAXException e) {
        // Should never occur. Programming error.
        throw new IllegalStateException("Could not parse templates configuration schema. Please state this as a bug.");
    } catch (NumberFormatException e) {
        // So provide help
        throw new InvalidConfigurationException(this.configFilePath.toUri().toString(), "Invalid version number defined. The version of the templates configuration should consist of 'major.minor' version.", e);
    } catch (IOException e) {
        throw new InvalidConfigurationException(this.configFilePath.toUri().toString(), "Could not read templates configuration file.", e);
    } finally {
        Thread.currentThread().setContextClassLoader(orig);
    }
}

Example 2 with TemplatesConfigurationVersion

use of com.devonfw.cobigen.impl.config.constant.TemplatesConfigurationVersion in project cobigen by devonfw.

the class TemplateConfigurationUpgraderTest method testCorrectUpgrade_v1_2_TO_v2_1.

/**
 * Tests the valid upgrade of a templates configuration from version v1.2 to v2.1.
 *
 * @throws Exception test fails
 */
@Test
public void testCorrectUpgrade_v1_2_TO_v2_1() throws Exception {
    // preparation
    File tmpTargetConfig = this.tempFolder.newFile(ConfigurationConstants.TEMPLATES_CONFIG_FILENAME);
    File sourceTestdata = new File(testFileRootPath + "valid-v1.2/" + ConfigurationConstants.TEMPLATES_CONFIG_FILENAME);
    Files.copy(sourceTestdata, tmpTargetConfig);
    TemplateConfigurationUpgrader sut = new TemplateConfigurationUpgrader();
    TemplatesConfigurationVersion version = sut.resolveLatestCompatibleSchemaVersion(this.tempFolder.getRoot().toPath());
    assertThat(version).as("Source Version").isEqualTo(TemplatesConfigurationVersion.v1_2);
    sut.upgradeConfigurationToLatestVersion(this.tempFolder.getRoot().toPath(), BackupPolicy.ENFORCE_BACKUP);
    assertThat(tmpTargetConfig.toPath().resolveSibling("templates.bak.xml").toFile()).exists().hasSameContentAs(sourceTestdata);
    version = sut.resolveLatestCompatibleSchemaVersion(this.tempFolder.getRoot().toPath());
    assertThat(version).as("Target version").isEqualTo(TemplatesConfigurationVersion.v4_0);
    XMLUnit.setIgnoreWhitespace(true);
    try (FileReader vgl = new FileReader(testFileRootPath + "valid-v2.1/" + ConfigurationConstants.TEMPLATES_CONFIG_FILENAME);
        FileReader tmp = new FileReader(tmpTargetConfig)) {
        new XMLTestCase() {
        }.assertXMLEqual(vgl, tmp);
    }
}

Example 3 with TemplatesConfigurationVersion

use of com.devonfw.cobigen.impl.config.constant.TemplatesConfigurationVersion in project cobigen by devonfw.

the class HealthCheckImpl method perform.

@Override
public HealthCheckReport perform(Path configurationPath) {
    // 1. Get configuration resources
    // determine expected template configurations to be defined
    ContextConfiguration contextConfiguration = new ContextConfiguration(configurationPath);
    List<String> expectedTemplatesConfigurations = Lists.newArrayList();
    Set<String> hasConfiguration = Sets.newHashSet();
    Set<String> isAccessible = Sets.newHashSet();
    Map<String, Path> upgradeableConfigurations = Maps.newHashMap();
    Set<String> upToDateConfigurations = Sets.newHashSet();
    Path pathForCobigenTemplates = null;
    for (Trigger t : contextConfiguration.getTriggers()) {
        expectedTemplatesConfigurations.add(t.getTemplateFolder());
    }
    // 2. Determine current state
    TemplateConfigurationUpgrader templateConfigurationUpgrader = new TemplateConfigurationUpgrader();
    pathForCobigenTemplates = configurationPath.resolve("src" + File.separator + "main" + File.separator + "templates");
    for (String expectedTemplateFolder : expectedTemplatesConfigurations) {
        if (Files.exists(pathForCobigenTemplates)) {
            String configPath = (configurationPath + File.separator + "src" + File.separator + "main" + File.separator + "templates").toString();
            hasConfiguration.add(configPath);
            isAccessible.add(configPath);
            Path expectedTemplateFolderForResolvedVer = pathForCobigenTemplates.resolve(expectedTemplateFolder.replace("/", File.separator).toString());
            TemplatesConfigurationVersion resolvedVersion = templateConfigurationUpgrader.resolveLatestCompatibleSchemaVersion(expectedTemplateFolderForResolvedVer);
            if (resolvedVersion != null) {
                if (resolvedVersion != TemplatesConfigurationVersion.getLatest()) {
                    upgradeableConfigurations.put(expectedTemplateFolder, pathForCobigenTemplates);
                } else {
                    upToDateConfigurations.add(expectedTemplateFolder);
                }
            }
        } else {
            Path templateFolder = configurationPath.resolve(expectedTemplateFolder);
            Path templatesConfigurationPath = templateFolder.resolve(ConfigurationConstants.TEMPLATES_CONFIG_FILENAME);
            File templatesConfigurationFile = templatesConfigurationPath.toFile();
            if (templatesConfigurationFile.exists()) {
                hasConfiguration.add(expectedTemplateFolder);
                if (templatesConfigurationFile.canWrite()) {
                    isAccessible.add(expectedTemplateFolder);
                    TemplatesConfigurationVersion resolvedVersion = templateConfigurationUpgrader.resolveLatestCompatibleSchemaVersion(templateFolder);
                    if (resolvedVersion != null) {
                        if (resolvedVersion != TemplatesConfigurationVersion.getLatest()) {
                            upgradeableConfigurations.put(expectedTemplateFolder, templateFolder);
                        } else {
                            upToDateConfigurations.add(expectedTemplateFolder);
                        }
                    }
                }
            }
        }
    }
    this.healthCheckReport.setExpectedTemplatesConfigurations(expectedTemplatesConfigurations);
    this.healthCheckReport.setHasConfiguration(hasConfiguration);
    this.healthCheckReport.setIsAccessible(isAccessible);
    this.healthCheckReport.setUpgradeableConfigurations(upgradeableConfigurations);
    this.healthCheckReport.setUpToDateConfigurations(upToDateConfigurations);
    return this.healthCheckReport;
}

Example 4 with TemplatesConfigurationVersion

use of com.devonfw.cobigen.impl.config.constant.TemplatesConfigurationVersion in project cobigen by devonfw.

the class TemplateConfigurationUpgraderTest method testCorrectV2_1SchemaDetection.

/**
 * Tests the valid upgrade of a templates configuration from version v1.2 to v2.1.
 *
 * @throws Exception test fails
 */
@Test
public void testCorrectV2_1SchemaDetection() throws Exception {
    // preparation
    File targetConfig = new File(testFileRootPath + "valid-v2.1");
    TemplatesConfigurationVersion version = new TemplateConfigurationUpgrader().resolveLatestCompatibleSchemaVersion(targetConfig.toPath());
    assertThat(version).isEqualTo(TemplatesConfigurationVersion.v4_0);
}