jetty-quickstart/src/main/java/org/eclipse/jetty/quickstart/AttributeNormalizer.java - jetty - Git at Google

 //
 //  ========================================================================
 //  Copyright (c) 1995-2017 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.quickstart;

 import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Stack;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Stream;

 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
 import org.eclipse.jetty.util.resource.Resource;

 /**
  * Normalize Attribute to String.
  * <p>
  * Replaces and expands:
  * <ul>
  * <li>${WAR}</li>
  * <li>${WAR.path}</li>
  * <li>${WAR.uri}</li>
  * <li>${jetty.base}</li>
  * <li>${jetty.base.uri}</li>
  * <li>${jetty.home}</li>
  * <li>${jetty.home.uri}</li>
  * <li>${user.home}</li>
  * <li>${user.home.uri}</li>
  * <li>${user.dir}</li>
  * <li>${user.dir.uri}</li>
  * </ul>
  */
 public class AttributeNormalizer
 {
     private static final Logger LOG = Log.getLogger(AttributeNormalizer.class);
     private static final Pattern __propertyPattern = Pattern.compile("(?<=[^$]|^)\\$\\{([^}]*)\\}");

     private static class Attribute
     {
         final String key;
         final String value;
         final int weight;

         public Attribute(String key, String value, int weight)
         {
             this.key = key;
             this.value = value;
             this.weight = weight;
         }
     }

     private static URI toCanonicalURI(URI uri)
     {
         uri = uri.normalize();
         String ascii = uri.toASCIIString();
         if (ascii.endsWith("/"))
         {
             try
             {
                 uri = new URI(ascii.substring(0,ascii.length()-1));
             }
             catch(URISyntaxException e)
             {
                 throw new IllegalArgumentException(e);
             }
         }
         return uri;
     }

     private static Path toCanonicalPath(String path)
     {
         if (path == null)
             return null;
         if (path.length()>1 && path.endsWith("/"))
             path = path.substring(0,path.length()-1);
         return toCanonicalPath(FileSystems.getDefault().getPath(path));
     }

     private static Path toCanonicalPath(Path path)
     {
         if (path == null)
         {
             return null;
         }
         if (Files.exists(path))
         {
             try
             {
                 return path.toRealPath();
             }
             catch (IOException e)
             {
                 throw new IllegalArgumentException(e);
             }
         }
         return path.toAbsolutePath();
     }

     private static class PathAttribute extends Attribute
     {
         public final Path path;

         public PathAttribute(String key, Path path, int weight)
         {
             super(key,path.toString(),weight);
             this.path = path;
         }

         @Override
         public String toString()
         {
             return String.format("PathAttribute[%s=>%s]",key,path);
         }
     }

     private static class URIAttribute extends Attribute
     {
         public final URI uri;

         public URIAttribute(String key, URI uri, int weight)
         {
             super(key,uri.toASCIIString(),weight);
             this.uri = uri;
         }

         @Override
         public String toString()
         {
             return String.format("URIAttribute[%s=>%s]",key,uri);
         }
     }

     private static Comparator<Attribute> attrComparator = new Comparator<Attribute>()
     {
         @Override
         public int compare(Attribute o1, Attribute o2)
         {
             if( (o1.value == null) && (o2.value != null) )
             {
                 return -1;
             }

             if( (o1.value != null) && (o2.value == null) )
             {
                 return 1;
             }

             if( (o1.value == null) && (o2.value == null) )
             {
                 return 0;
             }

             // Different lengths?
             int diff = o2.value.length() - o1.value.length();
             if(diff != 0)
             {
                 return diff;
             }

             // Different names?
             diff = o2.value.compareTo(o1.value);
             if(diff != 0)
             {
                 return diff;
             }

             // The paths are the same, base now on weight
             return o2.weight - o1.weight;
         }
     };

     private static void add(List<PathAttribute>paths,List<URIAttribute> uris,String key,int weight)
     {
         String value = System.getProperty(key);
         if (value!=null)
         {
             Path path = toCanonicalPath(value);
             paths.add(new PathAttribute(key,path,weight));
             uris.add(new URIAttribute(key+".uri",toCanonicalURI(path.toUri()),weight));
         }
     }

     private URI warURI;
     private Map<String,Attribute> attributes = new HashMap<>();
     private List<PathAttribute> paths = new ArrayList<>();
     private List<URIAttribute> uris = new ArrayList<>();

     public AttributeNormalizer(Resource baseResource)
     {
         if (baseResource==null)
             throw new IllegalArgumentException("No base resource!");

         warURI = toCanonicalURI(baseResource.getURI());
         if (!warURI.isAbsolute())
             throw new IllegalArgumentException("WAR URI is not absolute: " + warURI);

         add(paths,uris,"jetty.base",9);
         add(paths,uris,"jetty.home",8);
         add(paths,uris,"user.home",7);
         add(paths,uris,"user.dir",6);

         if (warURI.getScheme().equalsIgnoreCase("file"))
             paths.add(new PathAttribute("WAR.path",toCanonicalPath(new File(warURI).toString()),10));
         uris.add(new URIAttribute("WAR.uri", warURI,9)); // preferred encoding
         uris.add(new URIAttribute("WAR", warURI,8)); // legacy encoding

         Collections.sort(paths,attrComparator);
         Collections.sort(uris,attrComparator);

         Stream.concat(paths.stream(),uris.stream()).forEach(a->attributes.put(a.key,a));

         if (LOG.isDebugEnabled())
         {
             for (Attribute attr : attributes.values())
             {
                 LOG.debug(attr.toString());
             }
         }
     }

     /**
      * Normalize a URI, URL, or File reference by replacing known attributes with ${key} attributes.
      *
      * @param o the object to normalize into a string
      * @return the string representation of the object, with expansion keys.
      */
     public String normalize(Object o)
     {
         try
         {
             // Find a URI
             URI uri = null;
             Path path = null;
             if (o instanceof URI)
                 uri = toCanonicalURI(((URI)o));
             else if (o instanceof Resource)
                 uri = toCanonicalURI(((Resource)o).getURI());
             else if (o instanceof URL)
                 uri = toCanonicalURI(((URL)o).toURI());
             else if (o instanceof File)
                 path = ((File)o).getAbsoluteFile().getCanonicalFile().toPath();
             else if (o instanceof Path)
                 path = (Path)o;
             else
             {
                 String s = o.toString();
                 try
                 {
                     uri = new URI(s);
                     if (uri.getScheme() == null)
                     {
                         // Unknown scheme? not relevant to normalize
                         return s;
                     }
                 }
                 catch(URISyntaxException e)
                 {
                     // This path occurs for many reasons, but most common is when this
                     // is executed on MS Windows, on a string like "D:\jetty"
                     // and the new URI() fails for
                     // java.net.URISyntaxException: Illegal character in opaque part at index 2: D:\jetty
                     return s;
                 }
             }

             if (uri!=null)
             {
                 if ("jar".equalsIgnoreCase(uri.getScheme()))
                 {
                     String raw = uri.getRawSchemeSpecificPart();
                     int bang = raw.indexOf("!/");
                     String normal = normalize(raw.substring(0,bang));
                     String suffix = raw.substring(bang);
                     return "jar:" + normal + suffix;
                 }
                 else
                 {
                     if(uri.isAbsolute())
                     {
                         return normalizeUri(uri);
                     }
                 }
             }
             else if (path!=null)
                 return normalizePath(path);
         }
         catch (Exception e)
         {
             LOG.warn(e);
         }
         return String.valueOf(o);
     }

     protected String normalizeUri(URI uri)
     {
         for (URIAttribute a : uris)
         {
             try
             {
                 if (uri.compareTo(a.uri)==0)
                     return String.format("${%s}",a.key);

                 if (!a.uri.getScheme().equalsIgnoreCase(uri.getScheme()))
                     continue;
                 if (a.uri.getHost()==null && uri.getHost()!=null)
                     continue;
                 if (a.uri.getHost()!=null && !a.uri.getHost().equals(uri.getHost()))
                     continue;

                 if (a.uri.getPath().equals(uri.getPath()))
                     return a.value;

                 if (!uri.getPath().startsWith(a.uri.getPath()))
                     continue;

                 String s = uri.getPath().substring(a.uri.getPath().length());

                 if (s.charAt(0)!='/')
                     continue;

                 return String.format("${%s}%s",a.key,new URI(s).toASCIIString());
             }
             catch(URISyntaxException e)
             {
                 LOG.ignore(e);
             }
         }
         return uri.toASCIIString();
     }

     protected String normalizePath(Path path)
     {
         for (PathAttribute a : paths)
         {
             try
             {
                 if (path.equals(a.path) || Files.isSameFile(path,a.path))
                     return String.format("${%s}",a.key);
             }
             catch (IOException ignore)
             {
                 LOG.ignore(ignore);
             }

             if (path.startsWith(a.path))
                 return String.format("${%s}%c%s",a.key,File.separatorChar,a.path.relativize(path).toString());
         }

         return path.toString();
     }

     public String expand(String str)
     {
         return expand(str,new Stack<String>());
     }

     public String expand(String str, Stack<String> seenStack)
     {
         if (str == null)
         {
             return str;
         }

         if (str.indexOf("${") < 0)
         {
             // Contains no potential expressions.
             return str;
         }

         Matcher mat = __propertyPattern.matcher(str);
         StringBuilder expanded = new StringBuilder();
         int offset = 0;
         String property;
         String value;

         while (mat.find(offset))
         {
             property = mat.group(1);

             // Loop detection
             if (seenStack.contains(property))
             {
                 StringBuilder err = new StringBuilder();
                 err.append("Property expansion loop detected: ");
                 int idx = seenStack.lastIndexOf(property);
                 for (int i = idx; i < seenStack.size(); i++)
                 {
                     err.append(seenStack.get(i));
                     err.append(" -> ");
                 }
                 err.append(property);
                 throw new RuntimeException(err.toString());
             }

             seenStack.push(property);

             // find property name
             expanded.append(str.subSequence(offset,mat.start()));
             // get property value
             value = getString(property);
             if (value == null)
             {
                 if(LOG.isDebugEnabled())
                     LOG.debug("Unable to expand: {}",property);
                 expanded.append(mat.group());
             }
             else
             {
                 // recursively expand
                 value = expand(value,seenStack);
                 expanded.append(value);
             }
             // update offset
             offset = mat.end();
         }

         // leftover
         expanded.append(str.substring(offset));

         // special case for "$$"
         if (expanded.indexOf("$$") >= 0)
         {
             return expanded.toString().replaceAll("\\$\\$","\\$");
         }

         return expanded.toString();
     }

     private String getString(String property)
     {
         if(property==null)
         {
             return null;
         }

         Attribute a = attributes.get(property);
         if (a!=null)
             return a.value;

         // Use system properties next
         return System.getProperty(property);
     }
 }
	//
	// ========================================================================
	// Copyright (c) 1995-2017 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.quickstart;

	import java.io.File;
	import java.io.IOException;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.net.URL;
	import java.nio.file.FileSystems;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Stack;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;
	import java.util.stream.Stream;

	import org.eclipse.jetty.util.log.Log;
	import org.eclipse.jetty.util.log.Logger;
	import org.eclipse.jetty.util.resource.Resource;

	/**
	* Normalize Attribute to String.
	* <p>
	* Replaces and expands:
	* <ul>
	* <li>${WAR}</li>
	* <li>${WAR.path}</li>
	* <li>${WAR.uri}</li>
	* <li>${jetty.base}</li>
	* <li>${jetty.base.uri}</li>
	* <li>${jetty.home}</li>
	* <li>${jetty.home.uri}</li>
	* <li>${user.home}</li>
	* <li>${user.home.uri}</li>
	* <li>${user.dir}</li>
	* <li>${user.dir.uri}</li>
	* </ul>
	*/
	public class AttributeNormalizer
	{
	private static final Logger LOG = Log.getLogger(AttributeNormalizer.class);
	private static final Pattern __propertyPattern = Pattern.compile("(?<=[^$]\|^)\\$\\{([^}]*)\\}");

	private static class Attribute
	{
	final String key;
	final String value;
	final int weight;

	public Attribute(String key, String value, int weight)
	{
	this.key = key;
	this.value = value;
	this.weight = weight;
	}
	}

	private static URI toCanonicalURI(URI uri)
	{
	uri = uri.normalize();
	String ascii = uri.toASCIIString();
	if (ascii.endsWith("/"))
	{
	try
	{
	uri = new URI(ascii.substring(0,ascii.length()-1));
	}
	catch(URISyntaxException e)
	{
	throw new IllegalArgumentException(e);
	}
	}
	return uri;
	}

	private static Path toCanonicalPath(String path)
	{
	if (path == null)
	return null;
	if (path.length()>1 && path.endsWith("/"))
	path = path.substring(0,path.length()-1);
	return toCanonicalPath(FileSystems.getDefault().getPath(path));
	}

	private static Path toCanonicalPath(Path path)
	{
	if (path == null)
	{
	return null;
	}
	if (Files.exists(path))
	{
	try
	{
	return path.toRealPath();
	}
	catch (IOException e)
	{
	throw new IllegalArgumentException(e);
	}
	}
	return path.toAbsolutePath();
	}

	private static class PathAttribute extends Attribute
	{
	public final Path path;

	public PathAttribute(String key, Path path, int weight)
	{
	super(key,path.toString(),weight);
	this.path = path;
	}

	@Override
	public String toString()
	{
	return String.format("PathAttribute[%s=>%s]",key,path);
	}
	}

	private static class URIAttribute extends Attribute
	{
	public final URI uri;

	public URIAttribute(String key, URI uri, int weight)
	{
	super(key,uri.toASCIIString(),weight);
	this.uri = uri;
	}

	@Override
	public String toString()
	{
	return String.format("URIAttribute[%s=>%s]",key,uri);
	}
	}

	private static Comparator<Attribute> attrComparator = new Comparator<Attribute>()
	{
	@Override
	public int compare(Attribute o1, Attribute o2)
	{
	if( (o1.value == null) && (o2.value != null) )
	{
	return -1;
	}

	if( (o1.value != null) && (o2.value == null) )
	{
	return 1;
	}

	if( (o1.value == null) && (o2.value == null) )
	{
	return 0;
	}

	// Different lengths?
	int diff = o2.value.length() - o1.value.length();
	if(diff != 0)
	{
	return diff;
	}

	// Different names?
	diff = o2.value.compareTo(o1.value);
	if(diff != 0)
	{
	return diff;
	}

	// The paths are the same, base now on weight
	return o2.weight - o1.weight;
	}
	};

	private static void add(List<PathAttribute>paths,List<URIAttribute> uris,String key,int weight)
	{
	String value = System.getProperty(key);
	if (value!=null)
	{
	Path path = toCanonicalPath(value);
	paths.add(new PathAttribute(key,path,weight));
	uris.add(new URIAttribute(key+".uri",toCanonicalURI(path.toUri()),weight));
	}
	}

	private URI warURI;
	private Map<String,Attribute> attributes = new HashMap<>();
	private List<PathAttribute> paths = new ArrayList<>();
	private List<URIAttribute> uris = new ArrayList<>();

	public AttributeNormalizer(Resource baseResource)
	{
	if (baseResource==null)
	throw new IllegalArgumentException("No base resource!");

	warURI = toCanonicalURI(baseResource.getURI());
	if (!warURI.isAbsolute())
	throw new IllegalArgumentException("WAR URI is not absolute: " + warURI);

	add(paths,uris,"jetty.base",9);
	add(paths,uris,"jetty.home",8);
	add(paths,uris,"user.home",7);
	add(paths,uris,"user.dir",6);

	if (warURI.getScheme().equalsIgnoreCase("file"))
	paths.add(new PathAttribute("WAR.path",toCanonicalPath(new File(warURI).toString()),10));
	uris.add(new URIAttribute("WAR.uri", warURI,9)); // preferred encoding
	uris.add(new URIAttribute("WAR", warURI,8)); // legacy encoding

	Collections.sort(paths,attrComparator);
	Collections.sort(uris,attrComparator);

	Stream.concat(paths.stream(),uris.stream()).forEach(a->attributes.put(a.key,a));

	if (LOG.isDebugEnabled())
	{
	for (Attribute attr : attributes.values())
	{
	LOG.debug(attr.toString());
	}
	}
	}

	/**
	* Normalize a URI, URL, or File reference by replacing known attributes with ${key} attributes.
	*
	* @param o the object to normalize into a string
	* @return the string representation of the object, with expansion keys.
	*/
	public String normalize(Object o)
	{
	try
	{
	// Find a URI
	URI uri = null;
	Path path = null;
	if (o instanceof URI)
	uri = toCanonicalURI(((URI)o));
	else if (o instanceof Resource)
	uri = toCanonicalURI(((Resource)o).getURI());
	else if (o instanceof URL)
	uri = toCanonicalURI(((URL)o).toURI());
	else if (o instanceof File)
	path = ((File)o).getAbsoluteFile().getCanonicalFile().toPath();
	else if (o instanceof Path)
	path = (Path)o;
	else
	{
	String s = o.toString();
	try
	{
	uri = new URI(s);
	if (uri.getScheme() == null)
	{
	// Unknown scheme? not relevant to normalize
	return s;
	}
	}
	catch(URISyntaxException e)
	{
	// This path occurs for many reasons, but most common is when this
	// is executed on MS Windows, on a string like "D:\jetty"
	// and the new URI() fails for
	// java.net.URISyntaxException: Illegal character in opaque part at index 2: D:\jetty
	return s;
	}
	}

	if (uri!=null)
	{
	if ("jar".equalsIgnoreCase(uri.getScheme()))
	{
	String raw = uri.getRawSchemeSpecificPart();
	int bang = raw.indexOf("!/");
	String normal = normalize(raw.substring(0,bang));
	String suffix = raw.substring(bang);
	return "jar:" + normal + suffix;
	}
	else
	{
	if(uri.isAbsolute())
	{
	return normalizeUri(uri);
	}
	}
	}
	else if (path!=null)
	return normalizePath(path);
	}
	catch (Exception e)
	{
	LOG.warn(e);
	}
	return String.valueOf(o);
	}

	protected String normalizeUri(URI uri)
	{
	for (URIAttribute a : uris)
	{
	try
	{
	if (uri.compareTo(a.uri)==0)
	return String.format("${%s}",a.key);

	if (!a.uri.getScheme().equalsIgnoreCase(uri.getScheme()))
	continue;
	if (a.uri.getHost()==null && uri.getHost()!=null)
	continue;
	if (a.uri.getHost()!=null && !a.uri.getHost().equals(uri.getHost()))
	continue;

	if (a.uri.getPath().equals(uri.getPath()))
	return a.value;

	if (!uri.getPath().startsWith(a.uri.getPath()))
	continue;

	String s = uri.getPath().substring(a.uri.getPath().length());

	if (s.charAt(0)!='/')
	continue;

	return String.format("${%s}%s",a.key,new URI(s).toASCIIString());
	}
	catch(URISyntaxException e)
	{
	LOG.ignore(e);
	}
	}
	return uri.toASCIIString();
	}

	protected String normalizePath(Path path)
	{
	for (PathAttribute a : paths)
	{
	try
	{
	if (path.equals(a.path) \|\| Files.isSameFile(path,a.path))
	return String.format("${%s}",a.key);
	}
	catch (IOException ignore)
	{
	LOG.ignore(ignore);
	}

	if (path.startsWith(a.path))
	return String.format("${%s}%c%s",a.key,File.separatorChar,a.path.relativize(path).toString());
	}

	return path.toString();
	}

	public String expand(String str)
	{
	return expand(str,new Stack<String>());
	}

	public String expand(String str, Stack<String> seenStack)
	{
	if (str == null)
	{
	return str;
	}

	if (str.indexOf("${") < 0)
	{
	// Contains no potential expressions.
	return str;
	}

	Matcher mat = __propertyPattern.matcher(str);
	StringBuilder expanded = new StringBuilder();
	int offset = 0;
	String property;
	String value;

	while (mat.find(offset))
	{
	property = mat.group(1);

	// Loop detection
	if (seenStack.contains(property))
	{
	StringBuilder err = new StringBuilder();
	err.append("Property expansion loop detected: ");
	int idx = seenStack.lastIndexOf(property);
	for (int i = idx; i < seenStack.size(); i++)
	{
	err.append(seenStack.get(i));
	err.append(" -> ");
	}
	err.append(property);
	throw new RuntimeException(err.toString());
	}

	seenStack.push(property);

	// find property name
	expanded.append(str.subSequence(offset,mat.start()));
	// get property value
	value = getString(property);
	if (value == null)
	{
	if(LOG.isDebugEnabled())
	LOG.debug("Unable to expand: {}",property);
	expanded.append(mat.group());
	}
	else
	{
	// recursively expand
	value = expand(value,seenStack);
	expanded.append(value);
	}
	// update offset
	offset = mat.end();
	}

	// leftover
	expanded.append(str.substring(offset));

	// special case for "$$"
	if (expanded.indexOf("$$") >= 0)
	{
	return expanded.toString().replaceAll("\\$\\$","\\$");
	}

	return expanded.toString();
	}

	private String getString(String property)
	{
	if(property==null)
	{
	return null;
	}

	Attribute a = attributes.get(property);
	if (a!=null)
	return a.value;

	// Use system properties next
	return System.getProperty(property);
	}
	}