org.browsermob.proxy.jetty.start.Main Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of browsermob-proxy Show documentation
Show all versions of browsermob-proxy Show documentation
A programmatic HTTP/S designed for performance and functional testing
The newest version!
// ========================================================================
// $Id: Main.java,v 1.37 2006/05/27 09:56:58 gregwilkins Exp $
// Copyright 2003-2004 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================
package org.browsermob.proxy.jetty.start;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.Policy;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.StringTokenizer;
/*-------------------------------------------*/
/**
* Main start class. This class is intended to be the main class listed in the MANIFEST.MF of the
* start.jar archive. It allows an application to be started with the command "java -jar
* start.jar". The behaviour of Main is controlled by the "org/browsermob/proxy/jetty/start/start.config" file
* obtained as a resource or file. This can be overridden with the START system property. The
* format of each line in this file is:
*
*
*
* SUBJECT [ [!] CONDITION [AND|OR] ]*
*
*
*
* where SUBJECT:
*
*
*
* ends with ".class" is the Main class to run. ends with ".xml" is a configuration file for the
* command line ends with "/" is a directory from which add all jar and zip files from. ends with
* "/*" is a directory from which add all unconsidered jar and zip files from. Containing = are
* used to assign system properties. all other subjects are treated as files to be added to the
* classpath.
*
*
*
* Subjects may include system properties with $(propertyname) syntax. File subjects starting with
* "/" are considered absolute, all others are relative to the home directory.
*
* CONDITION is one of:
*
*
*
* always never available package.class java OPERATOR n.n nargs OPERATOR n OPERATOR := one of "
* <",">"," <=",">=","==","!="
*
*
*
* CONTITIONS can be combined with AND OR or !, with AND being the assume operator for a list of
* CONDITIONS. Classpath operations are evaluated on the fly, so once a class or jar is added to
* the classpath, subsequent available conditions will see that class. The system parameter
* CLASSPATH, if set is given to the start classloader before any paths from the configuration
* file. Programs started with start.jar may be stopped with the stop.jar, which connects via a
* local port to stop the server. The default port can be set with the STOP.PORT system property (a
* port of < 0 disables the stop mechanism). If the STOP.KEY system property is set, then a random
* key is generated and written to stdout. This key must be passed to the stop.jar.
*
* @author Jan Hlavaty ([email protected])
* @author Greg Wilkins
* @version $Revision: 1.37 $
*/
public class Main
{
static boolean _debug=System.getProperty("DEBUG",null)!=null;
private String _classname=null;
private Classpath _classpath=new Classpath();
private String _config=System.getProperty("START","org/browsermob/proxy/jetty/start/start.config");
private ArrayList _xml=new ArrayList();
public static void main(String[] args)
{
try
{
new Main().start(args);
}
catch(Exception e)
{
e.printStackTrace();
}
}
static File getDirectory(String name)
{
try
{
if(name!=null)
{
File dir=new File(name).getCanonicalFile();
if(dir.isDirectory())
{
return dir;
}
}
}
catch(IOException e)
{}
return null;
}
boolean isAvailable(String classname)
{
try
{
Class.forName(classname);
return true;
}
catch(NoClassDefFoundError e) {}
catch(ClassNotFoundException e) {}
ClassLoader loader=_classpath.getClassLoader();
try
{
loader.loadClass(classname);
return true;
}
catch(NoClassDefFoundError e) {}
catch(ClassNotFoundException e) {}
return false;
}
public static void invokeMain(ClassLoader classloader,String classname,String[] args)
throws IllegalAccessException,InvocationTargetException,NoSuchMethodException,ClassNotFoundException
{
Class invoked_class=null;
invoked_class=classloader.loadClass(classname);
Class[] method_param_types=new Class[1];
method_param_types[0]=args.getClass();
Method main=null;
main=invoked_class.getDeclaredMethod("main",method_param_types);
Object[] method_params=new Object[1];
method_params[0]=args;
main.invoke(null,method_params);
}
/* ------------------------------------------------------------ */
String expand(String s)
{
int i1=0;
int i2=0;
while(s!=null)
{
i1=s.indexOf("$(",i2);
if(i1<0)
break;
i2=s.indexOf(")",i1+2);
if(i2<0)
break;
String property=System.getProperty(s.substring(i1+2,i2),"");
s=s.substring(0,i1)+property+s.substring(i2+1);
}
return s;
}
/* ------------------------------------------------------------ */
void configure(InputStream config,int nargs) throws Exception
{
BufferedReader cfg=new BufferedReader(new InputStreamReader(config,"ISO-8859-1"));
Version java_version=new Version(System.getProperty("java.version"));
Version ver=new Version();
// JAR's already processed
java.util.Hashtable done=new Hashtable();
// Initial classpath
String classpath=System.getProperty("CLASSPATH");
if(classpath!=null)
{
StringTokenizer tok=new StringTokenizer(classpath,File.pathSeparator);
while(tok.hasMoreTokens())
_classpath.addComponent(tok.nextToken());
}
// Handle line by line
String line=null;
while(true)
{
line=cfg.readLine();
if(line==null)
break;
if(line.length()==0||line.startsWith("#"))
continue;
try
{
StringTokenizer st=new StringTokenizer(line);
String subject=st.nextToken();
subject=expand(subject);
boolean expression=true;
boolean not=false;
String condition=null;
// Evaluate all conditions
while(st.hasMoreTokens())
{
condition=st.nextToken();
if(condition.equalsIgnoreCase("!"))
{
not=true;
continue;
}
if(condition.equalsIgnoreCase("OR"))
{
if(expression)
break;
expression=true;
continue;
}
if(condition.equalsIgnoreCase("AND"))
{
if(!expression)
break;
continue;
}
boolean eval=true;
if(condition.equals("true")||condition.equals("always"))
{
eval=true;
}
else if(condition.equals("false")||condition.equals("never"))
{
eval=false;
}
else if(condition.equals("available"))
{
String class_to_check=st.nextToken();
eval=isAvailable(class_to_check);
}
else if(condition.equals("exists"))
{
try
{
eval=false;
File file=new File(expand(st.nextToken()));
eval=file.exists();
}
catch(Exception e)
{
if(_debug)
e.printStackTrace();
}
}
else if(condition.equals("property"))
{
String property = System.getProperty(st.nextToken());
eval=property!=null && property.length()>0;
}
else if(condition.equals("java"))
{
String operator=st.nextToken();
String version=st.nextToken();
ver.parse(version);
eval=(operator.equals("<")&&java_version.compare(ver)<0)
||(operator.equals(">")&&java_version.compare(ver)>0)
||(operator.equals("<=")&&java_version.compare(ver)<=0)
||(operator.equals("=<")&&java_version.compare(ver)<=0)
||(operator.equals("=>")&&java_version.compare(ver)>=0)
||(operator.equals(">=")&&java_version.compare(ver)>=0)
||(operator.equals("==")&&java_version.compare(ver)==0)
||(operator.equals("!=")&&java_version.compare(ver)!=0);
}
else if(condition.equals("nargs"))
{
String operator=st.nextToken();
int number=Integer.parseInt(st.nextToken());
eval=(operator.equals("<")&&nargs")&&nargs>number)
||(operator.equals("<=")&&nargs<=number)||(operator.equals("=<")&&nargs<=number)
||(operator.equals("=>")&&nargs>=number)||(operator.equals(">=")&&nargs>=number)
||(operator.equals("==")&&nargs==number)||(operator.equals("!=")&&nargs!=number);
}
else
{
System.err.println("ERROR: Unknown condition: "+condition);
eval=false;
}
expression&=not?!eval:eval;
not=false;
}
String file=subject.replace('/',File.separatorChar);
if(_debug)
System.err.println((expression?"T ":"F ")+line+" subject="+subject);
if(!expression)
{
done.put(file,file);
continue;
}
// Handle the subject
if(subject.indexOf("=")>0)
{
int i=file.indexOf("=");
String property=file.substring(0,i);
String value=file.substring(i+1);
if(_debug)
System.err.println(" "+property+"="+value);
System.setProperty(property,value);
}
else if(subject.endsWith("/*"))
{
// directory of JAR files
File extdir=new File(file.substring(0,file.length()-1));
File[] jars=extdir.listFiles(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
String namelc=name.toLowerCase();
return namelc.endsWith(".jar")||name.endsWith(".zip");
}
});
for(int i=0;jars!=null&&i0)
{
if(_debug)
System.err.println(" CLASS="+cn);
_classname=cn;
}
}
else if (subject!=null && subject.length()>0)
{
// single JAR file
File f=new File(file);
String d=f.getCanonicalPath();
if(!done.containsKey(d))
{
done.put(d,d);
boolean added=_classpath.addComponent(d);
if(!added)
{
added=_classpath.addClasspath(expand(subject));
if(_debug)
System.err.println((added?" CLASSPATH+=":" !")+d);
}
else if(_debug)
System.err.println((added?" CLASSPATH+=":" !")+d);
}
}
}
catch(Exception e)
{
System.err.println("on line: '"+line+"'");
e.printStackTrace();
}
}
}
/* ------------------------------------------------------------ */
public void start(String[] args)
{
ArrayList al=new ArrayList();
for(int i=0;i-->