path: root/jetty-start/src/main/java/org/eclipse/jetty/start/Module.java

//
//  ========================================================================
//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//

package org.eclipse.jetty.start;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.text.CollationKey;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Represents a Module metadata, as defined in Jetty.
 */
public class Module
{
    public static class NameComparator implements Comparator<Module>
    {
        private Collator collator = Collator.getInstance();

        @Override
        public int compare(Module o1, Module o2)
        {
            // by name (not really needed, but makes for predictable test cases)
            CollationKey k1 = collator.getCollationKey(o1.name);
            CollationKey k2 = collator.getCollationKey(o2.name);
            return k1.compareTo(k2);
        }
    }

    public static class DepthComparator implements Comparator<Module>
    {
        private Collator collator = Collator.getInstance();

        @Override
        public int compare(Module o1, Module o2)
        {
            // order by depth first.
            int diff = o1.depth - o2.depth;
            if (diff != 0)
            {
                return diff;
            }
            // then by name (not really needed, but makes for predictable test cases)
            CollationKey k1 = collator.getCollationKey(o1.name);
            CollationKey k2 = collator.getCollationKey(o2.name);
            return k1.compareTo(k2);
        }
    }

    /** The file of the module */
    private File file;
    /** The name of this Module */
    private String name;
    /** The depth of the module in the tree */
    private int depth = 0;
    /** List of Modules, by name, that this Module depends on */
    private Set<String> parentNames;
    /** List of Modules, by name, that this Module optionally depend on */
    private Set<String> optionalParentNames;
    /** The Edges to parent modules */
    private Set<Module> parentEdges;
    /** The Edges to child modules */
    private Set<Module> childEdges;
    /** List of xml configurations for this Module */
    private List<String> xmls;
    /** List of ini template lines */
    private List<String> initialise;
    /** List of library options for this Module */
    private List<String> libs;
    /** List of downloads for this Module */
    private List<String> downloads;

    /** Is this Module enabled via start.jar command line, start.ini, or start.d/*.ini ? */
    private boolean enabled = false;
    /** List of sources that enabled this module */
    private final Set<String> sources = new HashSet<>();

    public Module(File file) throws FileNotFoundException, IOException
    {
        this.file = file;

        String name = file.getName();
        // Strip .ini
        name = Pattern.compile(".mod$",Pattern.CASE_INSENSITIVE).matcher(name).replaceFirst("");

        init();
        process();
    }

    public void addChildEdge(Module child)
    {
        if (childEdges.contains(child))
        {
            // already present, skip
            return;
        }
        this.childEdges.add(child);
    }

    public void addParentEdge(Module parent)
    {
        if (parentEdges.contains(parent))
        {
            // already present, skip
            return;
        }
        this.parentEdges.add(parent);
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj == null)
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        Module other = (Module)obj;
        if (name == null)
        {
            if (other.name != null)
            {
                return false;
            }
        }
        else if (!name.equals(other.name))
        {
            return false;
        }
        return true;
    }

    public Set<Module> getChildEdges()
    {
        return childEdges;
    }

    public int getDepth()
    {
        return depth;
    }

    public List<String> getLibs()
    {
        return libs;
    }

    public String getName()
    {
        return name;
    }

    public Set<String> getOptionalParentNames()
    {
        return optionalParentNames;
    }

    public Set<Module> getParentEdges()
    {
        return parentEdges;
    }

    public Set<String> getParentNames()
    {
        return parentNames;
    }

    public List<String> getXmls()
    {
        return xmls;
    }

    public List<String> getInitialise()
    {
        return initialise;
    }

    public List<String> getDownloads()
    {
        return downloads;
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = (prime * result) + ((name == null)?0:name.hashCode());
        return result;
    }

    public void init()
    {
        String name = file.getName();

        // Strip .ini
        this.name = Pattern.compile(".mod$",Pattern.CASE_INSENSITIVE).matcher(name).replaceFirst("");

        parentNames = new HashSet<>();
        optionalParentNames = new HashSet<>();
        parentEdges = new HashSet<>();
        childEdges = new HashSet<>();
        xmls = new ArrayList<>();
        initialise = new ArrayList<>();
        libs = new ArrayList<>();
        downloads = new ArrayList<>();
    }

    public boolean isEnabled()
    {
        return enabled;
    }

    public void process() throws FileNotFoundException, IOException
    {
        Pattern section = Pattern.compile("\\s*\\[([^]]*)\\]\\s*");

        if (!FS.canReadFile(file))
        {
            StartLog.debug("Skipping read of missing file: %s",file.getAbsolutePath());
            return;
        }

        try (FileReader reader = new FileReader(file))
        {
            try (BufferedReader buf = new BufferedReader(reader))
            {
                String line;
                String sectionType = "";
                while ((line = buf.readLine()) != null)
                {
                    line = line.trim();
                    Matcher sectionMatcher = section.matcher(line);

                    if (sectionMatcher.matches())
                    {
                        sectionType = sectionMatcher.group(1).trim().toUpperCase();
                    }
                    else
                    {
                        // blank lines and comments are valid for initialize section
                        if (line.length() == 0 || line.startsWith("#"))
                        {
                            if ("INI".equals(sectionType))
                            {
                                initialise.add(line);
                            }
                        }
                        else
                        {
                            switch (sectionType)
                            {
                                case "DEPEND":
                                    parentNames.add(line);
                                    break;
                                case "LIB":
                                    libs.add(line);
                                    break;
                                case "XML":
                                    xmls.add(line);
                                    break;
                                case "OPTIONAL":
                                    optionalParentNames.add(line);
                                    break;
                                case "DOWNLOAD":
                                    downloads.add(line);
                                    break;                             
                                case "INI":
                                    initialise.add(line);
                                    break;
                            }
                        }
                    }
                }
            }
        }
    }

    public void setDepth(int depth)
    {
        this.depth = depth;
    }

    public void setEnabled(boolean enabled)
    {
        this.enabled = enabled;
    }

    public void addSources(List<String> sources)
    {
        this.sources.addAll(sources);
    }

    public void clearSources()
    {
        this.sources.clear();
    }

    public Set<String> getSources()
    {
        return Collections.unmodifiableSet(sources);
    }

    @Override
    public String toString()
    {
        StringBuilder str = new StringBuilder();
        str.append("Module[").append(name);
        if (enabled)
        {
            str.append(",enabled");
        }
        str.append(']');
        return str.toString();
    }
}