Source code: org/vrspace/client/VrmlUploader.java

   package org.vrspace.client;
   
   import org.vrspace.util.*;
   
   import java.io.*;
   import java.net.*;
   import java.util.*;
   
   /** 
   * Recursively uploads files to the server.<p>
   *
   * The uploader recursively searches the files that have .wrl extensions, looking 
   * for url lists in url tags, and in EXTERNPROTOs.  Each list found is searched for
   * for files existing on the local file system.  If a discovered file has a .wrl extension, 
   * then it will be searched as well.  This recursion continues up to the level maxRecursion 
   * ( defaults to zero ).<p>
   *  
   * After a VrmlUploader is instantiated, various options
   * can be set for the transfer (see below).  The upload method is used to initiate the
   * transfer.  Files sent to this method with a .wrl extension will be uploaded as
   * VrmlFiles, unless uploadAllAsFile is false.  In that case, all .wrl files are uploaded
   * as Files.  If includeNonWrl is false, then all non-vrml files encountered while 
   * searching (see below) are not uploaded.<p>
   *
   * Example 1: upload( "sample.wrl" ) with maxRecursion level 0, and 
   * includeNonWrl set to false.  In this case, only sample.wrl is uploaded.<p>
   *
   * Example 2: now includeNonWrl is set to true.  This causes sample.wrl to be searched for 
   * all url list.  Every non .wrl file found will be uploaded.<p>
   *
   * Example 3: includeNonWrl false, maxRecusion 1.  Sample.wrl and every .wrl file discovered within
   * it is uploaded.<p>
   * 
   * Various options are available for the upload:<p>
   *
   * inputStream - an InputStream for providing upload parameters, used in conjunction
   * with useInputStream.  Defaults to System.in.<p>
   * outputStream - a PrintStream, defaulting to System.out, that writes the responses to the
   * upload commands sent to the server.<p>
   * silent - turns outputStream off.<p>
   * uploadAllAsFile - files normally uploaded as VrmlFile are uploaded as File.<p>
   * logger - turns the logger on and off<p>
   *
   * Warning: All files uploaded with .wrl extensions are expected to be uncompresssed.<p>
   *
   */
  public class VrmlUploader implements Observer {
    protected Connection connection = null;
    protected boolean stopLoggerOnCompletion = false;
    protected PrintStream outputStream = new PrintStream ( System.out, true );
    protected InputStream inputStream = System.in;
    
    protected String       host;
    protected int          port;
    protected String       login;
    protected String       password;
    protected int          maxRecursion       = 0;
    protected boolean      includeNonWrl     = false;
    protected boolean      excludeExternProto = false;
    protected boolean      silent             = false;
    protected int          numberLeftToUpload = Integer.MAX_VALUE;
    protected boolean      uploadAllAsFile    = false;
    protected boolean      useInputStream     = false;
    
    // Files to be uploaded as VrmlFile
    protected Collection uploadAsVrmlFile;
    
    // Files to upload that are cached as parsing takes place.
    protected HashMap cachedFiles;
    
    // Files to upload that are not cached.
    protected HashMap files;
    
    public VrmlUploader() {
      uploadAsVrmlFile   = new ArrayList();
      cachedFiles        = new HashMap();
      files              = new HashMap();
      
      // Loggers may have been stopped on previous completion of 
      // an uploader.
      Logger.startStaticLogger();
    } // Console
    
    /**
     * 
     */
    public VrmlUploader( String host, int port, String login, String password ) {
      this();
      
      this.host = host;
      this.port = port;
      this.login = login;
      this.password = password;
    }
    
    /**
     * 
     */
    public VrmlUploader( Connection connection, String login, String password ) {
     this( connection.getHostName(), connection.getHostPort(), login, password );
     
     this.connection = connection;
     connection.addObserver( this );
   }
  
   public void setMaxRecursion( int maxRecursion ) {
     this.maxRecursion = maxRecursion;
   }
   
   public void setIncludeNonWrl( boolean includeNonWrl ) {
     this.includeNonWrl = includeNonWrl;
   }
   
   public void setExcludeExternProto( boolean excludeExternProto ) {
     this.excludeExternProto = excludeExternProto;
   }
   
   public void setSilent( boolean silent ) {
     this.silent = silent;
   }
   
   public void setStopLoggerOnCompletion( boolean stopLoggerOnCompletion ) {
     this.stopLoggerOnCompletion = stopLoggerOnCompletion;
   }
   
   public void setUploadAllAsFile( boolean uploadAllAsFile ) {
     this.uploadAllAsFile = uploadAllAsFile;
   }
   
   public void setLogging( boolean logging ) {
     Logger.logInfo(     logging );
     Logger.logWarning(  logging );
     Logger.logHeader(   logging );
     Logger.logDebug(    logging );
     Logger.logError(    logging );
     
     Logger.stopOnError( false   );
   } // setLogging
   
   public void setUseInputStream( boolean useInputStream ) {
     this.useInputStream = useInputStream;
   } // setUseInputStream
   
   public void setInputStream( InputStream inputStream ) {
     this.inputStream = inputStream;
   } // setInputStream
   
   public OutputStream getOutputStream() {
     return outputStream;
   } // getOutputStream
  
   public void setOutputStream( OutputStream outputStream ) {
     outputStream = new PrintStream( outputStream, true );
   } // setOutputStream
   
   /**
    * Uploads the file specified.  The file is parsed
    * for the urls it contains, and then each of these files are recursively
    * searched.  Once parsing is completed, the server is sent requests for file
    * upload.  The update method handles the actual uploading.
    * Note that File.getAbsolutePath() is called on the file to determine the path
    * to upload.
    */
   public void upload( String path ) throws ConnectionException {
     ArrayList toUpload = new ArrayList();
     toUpload.add( path );
     upload( toUpload );
   } // upload
   
   /**
    * Uploads the list of files specified.  Each individual file is parsed
    * for the urls they contain, and then each of these files are recursively
    * searched.  Once parsing is completed, the server is sent requests for file
    * upload.  The update method handles the actual uploading.
    * Note that File.getAbsolutePath() is called on each file to determine the path
    * to upload.
    */
   public void upload( List paths ) throws ConnectionException {
     Logger.logDebug( "upload() called" );
     
     // Login
     try {
       if ( useInputStream ) {
         consoleLogin();
       } else {
         if ( connection != null ) {
           connection.addObserver( this );
         } else {
           connection = new Connection();
           connection.addObserver( this );
           connection.setMaxTries( 1 );
           connection.login( host, port, login, password );
         }
       }
     } catch ( ConnectionException e ) {
       println( e.getMessage() );
       shutdown();
       throw e;
     }
     
     URLParser urlParser = new URLParser( cachedFiles, files, maxRecursion );
     Iterator i = paths.iterator();
     while ( i.hasNext() ) {
       String absolutePath = new File( (String) i.next() ).getAbsolutePath();
       
       if ( hasVrmlExtension( absolutePath ) && ! uploadAllAsFile )
         uploadAsVrmlFile.add( Util.checkPath( login + "/" + absolutePath ) );
       
       urlParser.parseFile( absolutePath );
     }
     
     // Check the paths and add login name as a prefix
     HashMap oldCachedFiles = cachedFiles;
     HashMap oldFiles = files;
     cachedFiles = new HashMap();
     files = new HashMap();
     
     i = oldCachedFiles.keySet().iterator();
     while ( i.hasNext() ) {
       String key = (String) i.next();
       cachedFiles.put( Util.checkPath( login + "/" + key ),
                        oldCachedFiles.get( key ) );
     }
     
     i = oldFiles.keySet().iterator();
     while ( i.hasNext() ) {
       String key = (String) i.next();
       files.put( Util.checkPath( login + "/" + key ),
                  oldFiles.get( key ) );
     }
     
     // Request that files in cachedFiles and files be uploaded to the server.
     requestUploads();
   } // upload
   
   /**
    * true if the file has the extension .wrl (not e.g. .wrl.gz)
    */
   public static boolean hasVrmlExtension( String path ) {
     String fileName = new File( path ).getName();
     int pos = fileName.lastIndexOf(".");
  
     if ( ( pos >= 0 ) && 
          ( fileName.substring( pos + 1, fileName.length() ).equals( "wrl" ) ) )
       return true;
     else
       return false;
   }
   
   /**
    * Retrieves all upload information from input via a Console
    * (except for the file name).  A console is created, but its thread is 
    * not started.  The console retrieves host, port, username, password 
    * if they haven't already been set in the System properties.
    */
   protected void consoleLogin() throws ConnectionException {
     Console con = new Console();
     
     connection = con.connection;
     connection.setMaxTries( 1 );
     con.input = new BufferedReader( new InputStreamReader( inputStream ) );
     try {
       con.attemptLogin();
     } catch ( IOException e ) {
       throw new ConnectionException( e.getMessage() );
     }
       
     host       = con.host;
     login      = con.login;
     password   = con.password;
        
     connection.addObserver( this );
     connection.deleteObserver( con );
   } // consoleLogin
   
   /**
    * Request that the cachedFiles and files be uploaded to the server.
    * Exits if these lists are both empty.
    */ 
   protected void requestUploads() { 
     Logger.logDebug( "requestUploads()" );
     
     // ensure that there exist files to upload, 
     // i.e. it is possible, for example, that all files were suppressed.
     if ( cachedFiles.size() + files.size() == 0 ) {
       shutdown();
       return;
     }
     
     String path;
     Iterator i = cachedFiles.keySet().iterator();
     while ( i.hasNext() ) {
       path = (String) i.next();
       
       try {
         if ( ! requestUpload( path ) )
           i.remove();
       } catch ( IOException e ) {
         Logger.logWarning( "An error occurred while requesting upload " + path );
         i.remove();
       }
     }
     i = files.keySet().iterator();
     while ( i.hasNext() ) {
       path = (String) i.next();
       
       try {
         if ( ! requestUpload( path  ) )
           i.remove();
       } catch ( IOException e ) {
         Logger.logWarning( "An error occurred while requestion upload " + path );
         i.remove();
       }
     }
     
      // Store the number of files to be uploaded
     numberLeftToUpload = files.size() + cachedFiles.size();
   } // requestUploads
   
   /**
    * Request for the given file to be uploaded.  If the file has a wrl 
    * extension, request as a VrmlFile, otherwise request File.
    * VrmlFile upload is overidden by uploadAllAsFile.
    */ 
   protected boolean requestUpload( String checkedPath ) throws IOException {
     Logger.logDebug( "requestUpload( " + checkedPath + " )" );
     
     boolean uploadRequested = true;
     
     // Check to see if the file is in the uploadAsVrmlFile list
     boolean foundPath = false;
     Iterator i = uploadAsVrmlFile.iterator();
     while ( i.hasNext() ) {
       if ( ( (String) i.next() ).equals( checkedPath ) )
         foundPath = true;
     }
     
     if ( foundPath ) {
       connection.send( "upload VrmlFile " + checkedPath );
     } else if ( VrmlUploader.hasVrmlExtension( checkedPath) ) {
       connection.send( "upload File " + checkedPath );
     } else if ( includeNonWrl ) {
       connection.send( "upload File " + checkedPath );
     } else {
       uploadRequested = false;
     }
     
     return uploadRequested;
   } // requestUpload
   
   /**
    * Implements the observer interface.  The VrmlUploader has been 
    * added as an observer of its Connection.  The purpose of this 
    * observing is to ignore all messages sent except upload commands
    * and responses.  Those messages implement the actual uploading.
    * The responses are printed to outputStream.
    */
   public void update( Observable conn, Object cmd ) {
     //Logger.logDebug( "Message: "+cmd );
     
     if ( cmd instanceof String ) {
       Message msg = new Message( (String) cmd );
       String className = msg.getClassName();
       
       // Upload message
       if ( className.equals( "upload" ) ) { 
            
         // Received the upload command from the server.
         // Message format:
         //     upload <port> <blocksize> <filename>
         if ( ! msg.isResponse()) {
           // Retrieve the file name and port to upload to
           int port = new Long( msg.getId() ).intValue();
           String destFile = msg.getEventValue();
           
           // Initiate file transfer.
           Logger.logInfo( "Uploading "+destFile+" to "+host+":"+port+
                           " - "+( cachedFiles.size() + files.size()-1 )+
                           " left");
           try {
             BinaryConnection dest = new BinaryConnection( host, port, login, password );
             
             // attempt to retrieve the file from the cached files listing.
             String file = (String) cachedFiles.get( destFile );
        
             // The file is cached.
             if ( file != null ) {
               dest.write( file.getBytes( "UTF8" ) );
               cachedFiles.remove( destFile );
               System.gc();
               Logger.logInfo( "Wrote "+destFile+" "+file.length() );
              
             // The file is not cached.
             } else {
               String sourceFile = (String) files.get( destFile );
                 
               if ( sourceFile == null ) {
                 Logger.logError( "Unable to find requested file: "+destFile );
               } else {
                 copyURL( sourceFile, destFile, dest.getOutputStream() );
                 Logger.logInfo( "Wrote "+destFile );
                 files.remove( destFile );
               }
             }
             
             // Close the binary connection.
             try {
               dest.close();
             } catch ( Exception e ) {}
   
           } catch ( IOException ioe ) {
             Logger.logError( ioe );
           } catch ( ConnectionException e ) {
             Logger.logError( e );
           } catch ( Throwable t ) {
             Logger.logError( t );
           }
         }
         
       } else if ( ( className.equals( "File" ) || 
                     className.equals( "VrmlFile" ) ) 
                   && msg.getEventName().equals( "upload" ) ) {
         if ( msg.isResponse() ) {
           // Display response to user
           // Note: cannot use msg.toString() because it is only 
           // designed for non-command responses.
           println( (String) cmd );
           
           numberLeftToUpload--;
           if ( numberLeftToUpload == 0 ) {
             Logger.logDebug("All uploaded");
             
             //setChanged();
             //notifyObservers();
             
             shutdown();
           }
         }
       }  
     }
   } // update
   
   /**
    * Copy file/url <i>path</i> to <i>destpath</i>
   */
   protected void copyURL( String path, String destPath, OutputStream out ) {
     Logger.logDebug( "copyURL("+path+","+destPath+","+out+")" );
     try {
       File file = new File( path );
       InputStream fIn = null;
       fIn = new FileInputStream( file );
       //fIn = url.openStream();
       // copy file to new location
       OutputStream fOut=null;
       if ( out == null ) {
         fOut = Util.createFileOutputStream( destPath );
       } else {
         fOut = out;
       }
       byte[] buffer = new byte [4096];
       int len=0;
       int pos=0;
       while ( (pos=fIn.read(buffer)) != -1 ) {
         fOut.write(buffer, 0, pos);
         len+=pos;
       }
       fIn.close();
       fOut.close();
       Logger.logDebug( "Wrote "+path+" /"+len );
     } catch ( IOException e ) {
       Logger.logError( e );
     }
   }
   
   /**
    * Shutdown the connection, and turn the Logger thread off if 
    * shutdownOnCompletion is true.
    */
   public void shutdown() {
     Logger.logDebug( "shutdown()" );
     try {
       connection.close();
     } catch ( Exception e ) {
     }
     if ( stopLoggerOnCompletion ) {
       Logger.stopStaticLogger();
     }
   } // shutdown
   
   /**
    * Printlns the string to outputStream if silent is false.
    */
   public void println( String string ) {
     if ( ! silent )
       outputStream.println( string );
   } // println
   
   /**
    * Recursively parses given files, searching for url lists, in particular,
    * other files on the local files system.
    */
   public class URLParser extends VrmlParser {
     // Files to upload that are cached as parsing takes place.
     protected HashMap cachedFiles;
   
     // Files to upload that are not cached.
     protected HashMap files;
     
     protected int maxRecursion;
     
     public URLParser( int maxRecursion ) {
       this.maxRecursion = maxRecursion;
       cachedFiles = new HashMap();
       files = new HashMap();
     }
     
     /**
      * Constructor designed for the recursive creation of this parser.  
      */ 
     protected URLParser( HashMap cachedFiles, HashMap files, int maxRecursion ) { 
       this.cachedFiles      = cachedFiles;
       this.files            = files;
       this.maxRecursion     = maxRecursion;
     }
   
     public HashMap getCachedFiles() {
       return cachedFiles;
     }
     
     public HashMap getFiles() {
       return files;
     }
     
     /**
      * Parses the given file for all instances of urls.  When these are found,
      * if they reference .wrl files, then those files are recursively parsed.  This
      * recursion occurs up to the level set by maxRecursion.  If the file is 
      * non-vrml, it is simply added to the list of uncached files.<p>
      *
      * VRML97 spec url is not java url - TODO
      */
     public void parseFile( String path ) {
       parseFile( path, 0 );
     } // parseFile
   
     /**
      * Resolves path against relRefPath and calls parseFile on the result.
      */
     protected void parseFile( String path, String relRefPath, int recursionLevel ) {
       String absolutePath = resolvePath( path, relRefPath );
       parseFile( absolutePath, recursionLevel );
     } // parseFile
   
     /**
      * Resolves the given path against relRefPath and returns the result.
      */
     protected String resolvePath( String path, String relRefPath ) {
       // Determine the location of the file.
       // If the path isn't absolute, then use the path of relRefFile for 
       // relative addressing.
       if ( ! new File( path ).isAbsolute() ) {
         Logger.logDebug( "Relative path detected: " + path );
         return new File( relRefPath ).getParent() + File.separator + path;
       } else {
         return path;
       }
     } // resolvePath
   
     /**
      * The actual file parsing workhorse.  ParseFile is called recursively
      * on each file found in the url tags. Then the file being parsed is cached.
      * If the file specified does not have a vrml extension, it simply stores 
      * the file reference in files.  If recursionLevel > maxRecursion the method
      * returns.  
      */
     protected void parseFile( String path, int recursionLevel ) {
       boolean processingURLList     = false;
       boolean processingExternProto = false;
       boolean processingMFString    = false;
     
       // Non Vrml File
       if ( ! VrmlUploader.hasVrmlExtension( path ) ) {
         if ( includeNonWrl ) 
           storeFileReference( path );
         return;
       }
     
       if ( recursionLevel > maxRecursion ) {
         return;
       }
     
       try {
         // Obtain a buffered reader for the file to upload.
         File destFile = new File( path );
         BufferedReader reader = new BufferedReader( new FileReader( path ));
       
         // Parse the contents of the file, looking for instances of the url tag.
         String line;
         while ( (line = reader.readLine()) != null ) {
           //Logger.logDebug( line );
           output.append( line );
           output.append( "\n" );
         
           // Parse the line
           StringTokenizer st = new StringTokenizer( line, " {}[],", true );
           while ( st.hasMoreTokens() ) {
             String token = st.nextToken();
             //Logger.logDebug( token );
              
             // Process the url SFString / MFString
             if ( processingURLList ) { 
               char firstChar = token.charAt(0);
             
               if ( firstChar == '[' ) {
                 processingMFString = true;
               } else if ( firstChar == ']' ) {
                 processingMFString = false;
                 processingURLList  = false;
               } else if ( firstChar == '"' ) {
                 //Logger.logDebug( token );
                 parseURL( token, path, recursionLevel );
               
                 if ( ! processingMFString )
                   processingURLList = false;
               }  
             }
           
             // ExternProto [] URLList.  Must loop until the final ]
             // is found, then beging parsing SF/MFString.
             if ( processingExternProto ) {
               if ( token.charAt(0) == ']' ) {
                 processingURLList = true;
                 processingExternProto = false;
               }
             }
           
             // url URLList, ExternProto [...] URLList
             // immediately process after url, wait after EXTERNPROTO
             if ( token.equals( "url" ) ) {
               processingURLList = true;
             } else if ( token.equals( "EXTERNPROTO" ) &&
                         ! excludeExternProto ) {
               processingExternProto = true;
             }
           } // while
         } // while
       
         // Cache the file
         cacheFile( path );
     
       } catch ( Exception e ) {
         Logger.logError( e );
       }
   
     } // parseFile
   
     /**
      * Determines if the given urlString is a .wrl file, and continues recursive
      * search if it is.
      */
     protected void parseURL( String urlString, String path, int recursionLevel ) {
       // Retrieve the url 
       int quoteStart = urlString.indexOf( "\"" );
       int quoteEnd   = urlString.lastIndexOf( "\"" );
     
     
       // If vrmlfile is well-formed, attempt to determine if the 
       // the specified url is a network object or a local file.
       if ( quoteStart >= 0 && quoteEnd > 0 ) {
         urlString = urlString.substring( quoteStart + 1, quoteEnd );
       
         // This could contain an anchor.  Remove that part.
         int hashIndex = urlString.indexOf('#');
         if ( hashIndex > 0 )
           urlString = urlString.substring( 0, hashIndex );
               
         // If the construction of  a java.net.URL object passes 
         // then the url is a network object.
               
         try {
           URL url = new URL( urlString );
         } catch ( MalformedURLException protoExc ) {
                 
           // otherwise it is a local file
           try {
             URL url = new URL( "file", "", urlString );
                   
             // Given that the url is a file, resolve against the 
             // current path and parse its contents.
             new URLParser( cachedFiles, files, maxRecursion ).parseFile( 
               urlString, path, recursionLevel + 1
             );
           } catch ( MalformedURLException urlExc ) {
             Logger.logError( urlExc.getMessage() );
           }
         }
       } // if
     } // parseURL
   
     /**
      * Stores an entry in cachedFiles with key = path, and
      * value = output.toString(), and resets the parser.  The path is
      * expected to be absolute.
      */
     protected void cacheFile( String path ) {
       cachedFiles.put( path, output.toString() );
     
       // Reset the VrmlParser member variables (in particular, output)
       reset();
     } // cacheFile
   
     /**
      * Checks to see if the absolute path exists and if so,
      * stores an entry in files with key = path, and 
      * value = path.
      */
     protected void storeFileReference( String path ) {
       if ( ! new File( path ).exists() ) {
         Logger.logInfo( "File does not exist: " + path );
       
       // otherwise schedule the file for upload
       } else {
         files.put( path, path );
       }    
     } // storeFileReference
     
   } // URLParser
   
   /**
    * Command Line Usage: java VrmlUploader [options] file
    * <pre>
    * options:
    * -h=<i>host</i>
    * -p=<i>port</i> 
    * -l=<i>username</i>
    * -pw=<i>password</i>
    * -r=<i>max recursion level</i>   Default: 0
    * -Files                          Upload all as File
    * -includeNonWrl                  Upload non .wrl files (including .wrl.gz)
    * -excludeExternProto             Do not upload EXTERNPROTO urls
    * -silent                         Silence output
    * -logger                         Debug
    * </pre>
    */
   public static void main ( String[] args ) {
     // command line options
     boolean paramParseFile          = false;
     boolean paramSilent             = false;
     boolean paramLogger             = false;
     int     paramMaxRecursion       = 0;
     boolean paramIncludeNonWrl      = false;
     boolean paramExcludeExternProto = false;
     boolean paramUploadAllAsFile    = false;
     
     // the file to upload
     ArrayList filesToUpload = new ArrayList();
     
     // record succesful command parsing
     boolean parseError = false;
     
     if ( args.length == 0 ) {
       parseError = true;
     
     // Parse the command line
     } else {
       try {
         for (int i = 0; i < args.length; i++) {
           if ( parseError ) 
             break;
           
           // A file to upload
           if ( args[ i ].charAt( 0 ) != '-' ) {
             filesToUpload.add( args[ i ] );
             
           // An option
           } else {
             // Remove preceding -
             StringTokenizer optionTokens = new StringTokenizer( args[ i ], "=" );
             String option = optionTokens.nextToken();
         
             // Host
             if        ( option.equals( "-h" ) ) {
               System.setProperty( "vrspace.host", optionTokens.nextToken() );
             // Port
             } else if ( option.equals( "-p" ) ) {
               System.setProperty( "vrspace.port", optionTokens.nextToken() );
             // Username
             } else if ( option.equals( "-l" ) ) {
               System.setProperty( "vrspace.login", optionTokens.nextToken() );
             // Password
             } else if ( option.equals( "-pw" ) ) {
               System.setProperty( "vrspace.password", optionTokens.nextToken() );
             } else if ( option.equals( "-r" ) ) {
               paramMaxRecursion = Integer.parseInt( (String) optionTokens.nextToken() );
             } else if ( option.equals( "-Files" ) ) {
               paramUploadAllAsFile = true;
             } else if ( option.equals( "-includeNonWrl" ) ) {
               paramIncludeNonWrl = true;
             } else if ( option.equals( "-excludeExternProto" ) ) {
               paramExcludeExternProto = true;
             } else if ( option.equals( "-silent" ) ) {
               paramSilent = true;
             } else if ( option.equals( "-logger" ) ) {
               paramLogger = true;
             } else {
               parseError = true;
             }
           }
         }
       } catch ( Exception e ) {
         parseError = true;
       }
     }
     
     // Display usage if an error occurred while parsing
     if ( parseError ) {
       System.out.println( "Usage: java VrmlUploader [options] <file>" );
       System.out.println( "Options:" );
       System.out.println( "  -h=<host>" );
       System.out.println( "  -p=<port>" );
       System.out.println( "  -l=<username>" );
       System.out.println( "  -pw=<password>" );
       System.out.println( "  -r=<recursion-level>   recursively upload vrml files Default: 0" );
       System.out.println( "  -includeNonWrl         include non .wrl files in upload" );
       System.out.println( "  -excludeExternProto    do not upload EXTERNPROTO urls" );
       System.out.println( "  -Files                 upload all as File " );
       System.out.println( "  -silent                silence output" );
       System.out.println( "  -logger                debug" );
       System.out.println( "Warning: All files uploaded with .wrl extensions are expected to" );
       System.out.println( "be uncompressed." );
 
       System.exit(-1);
     } 
     
     // Ensure that all of the files specified actually exist
     Iterator i = filesToUpload.iterator();
     while ( i.hasNext() ) {
       String path = (String) i.next();
       if ( ! new File( path ).exists() ) { 
         System.out.println( "File " + path + " does not exist." );
         System.exit(-1);
       }
     } 
     
     VrmlUploader uploader = new VrmlUploader();
     uploader.setStopLoggerOnCompletion( true );
     
     // Process command line options:
     // Information Display 
     uploader.setLogging( paramLogger );
     uploader.setSilent( paramSilent );
     
     uploader.setMaxRecursion( paramMaxRecursion );
     uploader.setIncludeNonWrl( paramIncludeNonWrl );
     uploader.setExcludeExternProto( paramExcludeExternProto );
     uploader.setUploadAllAsFile( paramUploadAllAsFile );
     uploader.setUseInputStream( true );
     
     try {
       uploader.upload( filesToUpload ); 
     } catch ( ConnectionException e ) {
     }
   } // main
   
 } // VrmlUploader