BaseConfig.java

package esa.bscs.pds4.packager.config;

import static org.springframework.beans.factory.config.ConfigurableBeanFactory.*;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;
import java.util.Properties;

import org.apache.velocity.app.VelocityEngine;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;

import esa.bscs.pds4.packager.Packager;
import esa.bscs.pds4.packager.PackagerImpl;
import esa.bscs.pds4.packager.aip.AipBuilder;
import esa.bscs.pds4.packager.aip.AipBuilderImpl;
import esa.bscs.pds4.packager.groovy.ProductClassifier;
import esa.bscs.pds4.packager.resolver.BscsDeliveryResolver;
import esa.bscs.pds4.packager.resolver.CurrentTimeResolverImpl;
import esa.bscs.pds4.packager.resolver.DeliveryResolver;
import esa.bscs.pds4.packager.resolver.ProductResolver;
import esa.bscs.pds4.packager.resolver.ProductResolverImpl;
import esa.bscs.pds4.packager.resolver.PsaDeliveryResolver;
import esa.bscs.pds4.packager.resolver.TimeResolver;
import esa.bscs.pds4.reader.Pds4Analyser;
import esa.bscs.pds4.reader.model.Pds4Label;
import esa.bscs.pds4.reader.sax.SaxPds4Analyser;
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyCodeSource;

@Configuration
public class BaseConfig {
    
    @Autowired(required=true)
    protected Environment env;
    
    @Autowired(required=true)
    protected ResourceLoader resourceLoader;
    
    @Bean
    public AipBuilder builder() {
        return new AipBuilderImpl();
    }

    @Bean
    public Packager packager() {    
        return new PackagerImpl();
    }
    
    @Bean
    public Pds4Analyser analyser() {
        return new SaxPds4Analyser();
    }
    
    @Bean
    public DeliveryResolver deliveryResolver() {
        
        final String style = env.getProperty("packager.config.naming.style");
        
        if("bscs".equals(style)) {
            return new BscsDeliveryResolver();
        
        } else if("psa".equals(style)) {
            return new PsaDeliveryResolver();
        
        } else {
            throw new IllegalArgumentException();
        }
    }
    
    @Bean
    public TimeResolver timeResolver() {
        return new CurrentTimeResolverImpl();
    }
    
    @Bean
    public VelocityEngine velocityEngine() {
        
        final Properties properties = new Properties();
        final VelocityEngine ve = new VelocityEngine();        
        
        // Set engine properties
                
        properties.setProperty("resource.loaders", "class");
        properties.setProperty("resource.loader.class.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
        
        // Initialize engine
        
        ve.init(properties);
        
        // Return 
        
        return ve;
    }

    @Bean
    @Scope(SCOPE_PROTOTYPE)
    public ProductResolver productResolver(List<Pds4Label> pds4Labels) {
        return new ProductResolverImpl(pds4Labels);
    }
        
    @Bean
    @Scope(SCOPE_PROTOTYPE)
    @SuppressWarnings({"unchecked", "java:S1160"})
    public ProductClassifier pathClassifier(String bundleId, ProductResolver resolver) throws IOException, ReflectiveOperationException, URISyntaxException {
        
        // Check if there is an specific classifier for the instrument
        
        Resource instrumentClassifier = resourceLoader.getResource(env.getRequiredProperty("packager.classifier.base.url") + bundleId.toLowerCase() + ".groovy");
        
        if(!instrumentClassifier.exists()) {
            instrumentClassifier = resourceLoader.getResource(env.getRequiredProperty("packager.classifier.base.url") + "default" + ".groovy");
        }
        
        // Load base classifier

        try (final GroovyClassLoader groovyClassLoader = new GroovyClassLoader()) {

            final URI baseClassifierUri = ClassLoader.getSystemClassLoader().getResource("classifier/base.groovy").toURI();
    
            groovyClassLoader.parseClass(new GroovyCodeSource(baseClassifierUri));
    
            // Load classifier
            
            final GroovyCodeSource codeSource = new GroovyCodeSource(instrumentClassifier.getURL());
            return (ProductClassifier) groovyClassLoader.parseClass(codeSource).asSubclass(ProductClassifier.class).getConstructor(ProductResolver.class).newInstance(resolver);            
        }
    }
}