forrest-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From brond...@apache.org
Subject cvs commit: xml-forrest/scratchpad/forrestbot2/webapp/images dir.gif file.gif
Date Thu, 20 Nov 2003 20:25:14 GMT
brondsem    2003/11/20 12:25:14

  Added:       scratchpad/forrestbot2/webapp/WEB-INF .cvsignore README.txt
                        logic.jsp settings.jsp settings.properties
                        users.properties utils.jsp web.xml
               scratchpad/forrestbot2/webapp/WEB-INF/classes/forrestbot
                        IOUtil.class IOUtil.java
               scratchpad/forrestbot2/webapp controlpanel.jsp index.jsp
                        refresh_controlpanel.jsp refresh_frame.jsp
                        tail_refreshlog.jsp viewsite.jsp welcome.html
               scratchpad/forrestbot2/webapp/images dir.gif file.gif
  Log:
  initial import of my modifications to the old forrestbot webapp
  changes include:
  - settings.properties
     - allow 'sites' and 'logs' to be anywhere in the filesystem and anywhere in URI-space
  - users.properties
     - '*' to denote all sites
  - automatically get list of sites from 'sites' dir
     - means you must do it successfully manually once
  
  Revision  Changes    Path
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/.cvsignore
  
  Index: .cvsignore
  ===================================================================
  commands
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/README.txt
  
  Index: README.txt
  ===================================================================
                              Forrestbot web interface
  
                                  jefft@apache.org
                                 dave@brondsema.net
                   $Revision: 1.1 $ $Date: 2003/11/20 20:25:13 $
                              ------------------------
  
  This webapp implements a website staging application for sites built with
  Apache Forrest. The webapp hosts HTML for a number of managed websites.  The
  user can regenerate these sites at will.  Once the user is satisfied with the
  site, they may 'deploy' the site, making it live.
  
  This webapp has the loosest of couplings with the backend engine which is
  expected to do the real build/deploy work: instructions are simply written to
  the WEB-INF/commands file.  It is expected that an external app will be polling
  this file for input.  See ../../scripts/README.txt for more info.
  
  Installation
  ------------
  
  Set up WEB-INF/settings.properties and WEB-INF/users.properties.  These files are self-documented.
  
  Simply point Tomcat (or another servlet container) at this directory. Eg in
  server.xml:
  
  <Context path="/forrestbot" docBase="/home/jeff/apache/xml/xml-forrest/src/resources/forrestbot/webapp" debug="0" reloadable="true"/>
  
  Note: this webapp will not work with a standard Apache/Tomcat mod_jk
  connection.  If you look at web.xml you will see why: a number of virtual paths
  (/site/*, /refresh/*, /logs/refresh) are used, and mod_jk does not forwards
  requests for these paths on to Tomcat.  These need to be added by hand to
  httpd.conf.  Alternatively, use a more intelligent connector like mod_webapp.
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/logic.jsp
  
  Index: logic.jsp
  ===================================================================
  <%@include file="utils.jsp"%>
  <%@include file="settings.jsp"%>
  <%@page import="java.util.ArrayList"%>
  <% 
  
  // build list of sites
  File f = new File(sites_dir);
  if (!f.exists()) {
  	%> <h2> sites-dir in settings.properties is not valid </h2> <%
  	out.println(sites_dir);
  	return;
  }
  File[] possibleSites = f.listFiles();
  ArrayList sites = new ArrayList();
  for(int i=0; i<possibleSites.length; i++) {
  	if (possibleSites[i].isDirectory()) {
  		sites.add(possibleSites[i].getName());
  	}
  }
  
  String username = request.getParameter("username");
  if (username != null) { session.setAttribute("username", username); }
  else { username = (String)session.getAttribute("username"); }
  if (username != null && username.equals("")) username = null;
  
  // Note: Moz 1.2 doesn't like password fields called 'password'
  String password = request.getParameter("passwd");
  if (password != null) { session.setAttribute("password", password); }
  else { password = (String)session.getAttribute("password"); }
  if (password != null && password.equals("")) password = null;
  
  // Try to authenticate the user and determine what privs they have
  ArrayList privs = null;
  String errMsg = null;
  if (username != null) {
    java.util.Properties users = new java.util.Properties();
    users.load(
        getServletConfig().getServletContext().getResourceAsStream("/WEB-INF/users.properties")
        );
    String reqPassword = users.getProperty(username+".password");
    if (reqPassword == null) {
      errMsg = "No user '"+username+"'. Please contact the admins to have your name added";
    } else {
      if (password != null && password.equals(reqPassword)) {
  		privs = new ArrayList();
  		StringTokenizer stPrivs = new StringTokenizer(users.getProperty(username), ",");
  		while (stPrivs.hasMoreTokens()) {
  			String currentPriv = stPrivs.nextToken();
  			if (currentPriv.equals("*"))
  				privs.addAll(sites);
  			else
  				privs.add(currentPriv);
  		}
      } else {
        errMsg = "Incorrect password for user '"+username+"', please try again";
      }
    }
  }
  
  // Write commands to COMMANDS_FILE, where hopefully they will get picked up by
  // a shell script
  
  String action = request.getParameter("action");
  String module = request.getParameter("module");
  String command = null;
  if (privs != null && action != null && module!= null) {
    if (privs.contains(module) && privs.contains(action)) {
      PrintStream ps = new PrintStream(new FileOutputStream(new File(commands_file)));
      command = action+" "+module;
      ps.println(command);
      ps.close();
    } else {
      errMsg = "User "+username+" cannot "+action+" module "+module;
    }
  }
  %>
  <%-- vim: set ft=java: --%>
  
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/settings.jsp
  
  Index: settings.jsp
  ===================================================================
  <%@page import="java.util.ArrayList"%>
  <% 
  
  // settings.properties
  java.util.Properties settings = new java.util.Properties();
  settings.load(
    getServletConfig().getServletContext().getResourceAsStream("/WEB-INF/settings.properties")
    );
  
  //getServletConfig().getServletContext().getRealPath(xxx);
  String commands_file = settings.getProperty("commands-file");
  String sites_dir = settings.getProperty("sites-dir");
  String logs_dir = settings.getProperty("logs-dir");
  String sites_url = settings.getProperty("sites-url");
  String logs_url = settings.getProperty("logs-url");
  
  %>
  <%-- vim: set ft=java: --%>
  
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/settings.properties
  
  Index: settings.properties
  ===================================================================
  # settings.properties is used to configure the webapp to look
  # in certain locations for files and directories
  #
  # all of the following must be absolute
  #
  # this file is created by the webapp and used by the 'overseer' script
  #commands-file=/path/to/somewhere/commands
  # directory that contains the configuration files for each site
  #config-dir=/path/to/somewhere/conf
  #
  # filesystem paths
  #sites-dir=/path/to/somewhere/sites
  #logs-dir=/path/to/somewhere/logs
  #
  # URLs (for HTML links)
  #sites-url=/forrestbot/sites
  #logs-url=/forrestbot/logs
  
  commands-file=d:/sandbox/javadev/forrestbot2/commands
  config-dir=d:/sandbox/javadev/forrestbot2
  
  sites-dir=d:/sandbox/javadev/forrest/build/site/projects
  logs-dir=d:/sandbox/javadev/forrest/build/site/projects-logs
  sites-url=/projects
  logs-url=/projects-logs
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/users.properties
  
  Index: users.properties
  ===================================================================
  # This file lists users known to the system, and associated 'privileges'.
  # The format is:
  #
  # <username>=<permitted actions>,<modules>
  # <username>.password=<password for 'username'>
  #
  # Where:
  #   <username> is something like 'admin', 'joe', 'forrest-dev'
  #   <permitted actions> is 'build' and/or 'deploy', separated by commas.
  #     - 'build' means "able to generate a local build of a site"
  #     - 'deploy' means "able to commit the generated output to
  #       the site's final destination
  #   <modules> is a comma-separated list of sites
  #     - '^' will allow the user to do his actions on all sites
  
  forrest-dev=refresh,xml-forrest,xml-forrest-krysalis,xml-forrest-template,xml-site,incubator-site,xml-xindice,xml-fop.xml,avalon-site,avalon-phoenix,krysalis-centipede,ws-site
  forrest-dev.password=forrest-dev
  
  javadev=build,deploy,*
  javadev.password=javadev
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/utils.jsp
  
  Index: utils.jsp
  ===================================================================
  <%!
  private String getTimestamp(File file, Locale loc) {
    if (!file.exists()) return "";
    long tstamp = file.lastModified();
    long t0 = System.currentTimeMillis();
    long dt = t0 - tstamp;
    long secs=dt/1000;
    long mins=secs/60;
    long hours=mins/60;
    long days=hours/24;
  
    StringBuffer ret = new StringBuffer();
  
    if (days != 0) ret.append(days+" day"+(days==1?" ":"s "));
    hours -= days*24;
    if (hours != 0) ret.append(hours+" hour"+(hours==1?" ":"s "));
    mins -= (days*24 + hours)*60;
    if (mins != 0) ret.append(mins+" min"+(mins==1?" ":"s "));
    secs -= ((days*24 + hours)*60 + mins)*60;
    if (secs != 0) ret.append(secs+" sec"+(secs==1?" ":"s "));
    ret.append(" ago");
    return ret.toString();
  }
  
  %>
  
  <%-- vim: set ft=java: --%>
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/web.xml
  
  Index: web.xml
  ===================================================================
  <?xml version="1.0" encoding="ISO-8859-1"?>
  
  <!DOCTYPE web-app
  PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
  "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">
  
  <web-app>
    <servlet>
      <servlet-name>siteviewer</servlet-name>
      <jsp-file>/viewsite.jsp</jsp-file>
    </servlet>
    <servlet>
      <servlet-name>refresher</servlet-name>
      <jsp-file>/refresh_frame.jsp</jsp-file>
    </servlet>
  
    <servlet>
      <servlet-name>refreshlogger</servlet-name>
      <jsp-file>/tail_refreshlog.jsp</jsp-file>
    </servlet>
  
    <servlet-mapping>
      <servlet-name>siteviewer</servlet-name>
      <url-pattern>/site/*</url-pattern>
    </servlet-mapping>
  
    <servlet-mapping>
      <servlet-name>refresher</servlet-name>
      <url-pattern>/refresh/*</url-pattern>
    </servlet-mapping>
  
  
    <servlet-mapping>
      <servlet-name>refreshlogger</servlet-name>
      <url-pattern>/logs/refresh</url-pattern>
    </servlet-mapping>
  
  </web-app>
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/classes/forrestbot/IOUtil.class
  
  	<<Binary file>>
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/WEB-INF/classes/forrestbot/IOUtil.java
  
  Index: IOUtil.java
  ===================================================================
  /*
   * Copyright (C) The Apache Software Foundation. All rights reserved.
   *
   * This software is published under the terms of the Apache Software License
   * version 1.1, a copy of which has been included with this distribution in
   * the LICENSE.txt file.
   */
  
  package forrestbot;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Reader;
  import java.io.StringReader;
  import java.io.StringWriter;
  import java.io.Writer;
  
  /**
   * General IO Stream manipulation.
   * <p>
   * This class provides static utility methods for input/output operations, particularly buffered
   * copying between sources (<code>InputStream</code>, <code>Reader</code>, <code>String</code> and
   * <code>byte[]</code>) and destinations (<code>OutputStream</code>, <code>Writer</code>,
   * <code>String</code> and <code>byte[]</code>).
   * </p>
   *
   * <p>Unless otherwise noted, these <code>copy</code> methods do <em>not</em> flush or close the
   * streams. Often, doing so would require making non-portable assumptions about the streams' origin
   * and further use. This means that both streams' <code>close()</code> methods must be called after
   * copying. if one omits this step, then the stream resources (sockets, file descriptors) are
   * released when the associated Stream is garbage-collected. It is not a good idea to rely on this
   * mechanism. For a good overview of the distinction between "memory management" and "resource
   * management", see <a href="http://www.unixreview.com/articles/1998/9804/9804ja/ja.htm">this
   * UnixReview article</a></p>
   *
   * <p>For each <code>copy</code> method, a variant is provided that allows the caller to specify the
   * buffer size (the default is 4k). As the buffer size can have a fairly large impact on speed, this
   * may be worth tweaking. Often "large buffer -&gt; faster" does not hold, even for large data
   * transfers.</p>
   *
   * <p>For byte-to-char methods, a <code>copy</code> variant allows the encoding to be selected
   * (otherwise the platform default is used).</p>
   *
   * <p>The <code>copy</code> methods use an internal buffer when copying. It is therefore advisable
   * <em>not</em> to deliberately wrap the stream arguments to the <code>copy</code> methods in
   * <code>Buffered*</code> streams. For example, don't do the
   * following:</p>
   *
   * <code>copy( new BufferedInputStream( in ), new BufferedOutputStream( out ) );</code>
   *
   * <p>The rationale is as follows:</p>
   *
   * <p>Imagine that an InputStream's read() is a very expensive operation, which would usually suggest
   * wrapping in a BufferedInputStream. The BufferedInputStream works by issuing infrequent
   * {@link java.io.InputStream#read(byte[] b, int off, int len)} requests on the underlying InputStream, to
   * fill an internal buffer, from which further <code>read</code> requests can inexpensively get
   * their data (until the buffer runs out).</p>
   * <p>However, the <code>copy</code> methods do the same thing, keeping an internal buffer,
   * populated by {@link InputStream#read(byte[] b, int off, int len)} requests. Having two buffers
   * (or three if the destination stream is also buffered) is pointless, and the unnecessary buffer
   * management hurts performance slightly (about 3%, according to some simple experiments).</p>
   *
   * @author <a href="mailto:peter at apache.org">Peter Donald</a>
   * @author <a href="mailto:jefft@apache.org">Jeff Turner</a>
   * @version CVS $Revision: 1.1 $ $Date: 2003/11/20 20:25:13 $
   * @since 4.0
   */
  
  /*
   * Behold, intrepid explorers; a map of this class:
   *
   *       Method      Input               Output          Dependency
   *       ------      -----               ------          -------
   * 1     copy        InputStream         OutputStream    (primitive)
   * 2     copy        Reader              Writer          (primitive)
   *
   * 3     copy        InputStream         Writer          2
   * 4     toString    InputStream         String          3
   * 5     toByteArray InputStream         byte[]          1
   *
   * 6     copy        Reader              OutputStream    2
   * 7     toString    Reader              String          2
   * 8     toByteArray Reader              byte[]          6
   *
   * 9     copy        String              OutputStream    2
   * 10    copy        String              Writer          (trivial)
   * 11    toByteArray String              byte[]          9
   *
   * 12    copy        byte[]              Writer          3
   * 13    toString    byte[]              String          12
   * 14    copy        byte[]              OutputStream    (trivial)
   *
   *
   * Note that only the first two methods shuffle bytes; the rest use these two, or (if possible) copy
   * using native Java copy methods. As there are method variants to specify buffer size and encoding,
   * each row may correspond to up to 4 methods.
   *
   */
  
  public final class IOUtil
  {
      private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
  
      /**
       * Private constructor to prevent instantiation.
       */
      private IOUtil()
      {
      }
  
      /**
       * Unconditionally close an <code>Reader</code>.
       * Equivalent to {@link Reader#close()}, except any exceptions will be ignored.
       *
       * @param input A (possibly null) Reader
       */
      public static void shutdownReader( final Reader input )
      {
          if( null == input )
          {
              return;
          }
  
          try
          {
              input.close();
          }
          catch( final IOException ioe )
          {
          }
      }
  
      /**
       * Unconditionally close an <code>Writer</code>.
       * Equivalent to {@link Writer#close()}, except any exceptions will be ignored.
       *
       * @param output A (possibly null) Writer
       */
      public static void shutdownWriter( final Writer output )
      {
          if( null == output )
          {
              return;
          }
  
          try
          {
              output.close();
          }
          catch( final IOException ioe )
          {
          }
      }
  
      /**
       * Unconditionally close an <code>OutputStream</code>.
       * Equivalent to {@link OutputStream#close()}, except any exceptions will be ignored.
       * @param output A (possibly null) OutputStream
       */
      public static void shutdownStream( final OutputStream output )
      {
          if( null == output )
          {
              return;
          }
  
          try
          {
              output.close();
          }
          catch( final IOException ioe )
          {
          }
      }
  
      /**
       * Unconditionally close an <code>InputStream</code>.
       * Equivalent to {@link InputStream#close()}, except any exceptions will be ignored.
       * @param input A (possibly null) InputStream
       */
      public static void shutdownStream( final InputStream input )
      {
          if( null == input )
          {
              return;
          }
  
          try
          {
              input.close();
          }
          catch( final IOException ioe )
          {
          }
      }
  
      ///////////////////////////////////////////////////////////////
      // Core copy methods
      ///////////////////////////////////////////////////////////////
  
      /**
       * Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>.
       */
      public static void copy( final InputStream input, final OutputStream output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final InputStream input,
                               final OutputStream output,
                               final int bufferSize )
          throws IOException
      {
          final byte[] buffer = new byte[ bufferSize ];
          int n = 0;
          while( -1 != ( n = input.read( buffer ) ) )
          {
              output.write( buffer, 0, n );
          }
      }
  
      /**
       * Copy chars from a <code>Reader</code> to a <code>Writer</code>.
       */
      public static void copy( final Reader input, final Writer output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy chars from a <code>Reader</code> to a <code>Writer</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final Reader input, final Writer output, final int bufferSize )
          throws IOException
      {
          final char[] buffer = new char[ bufferSize ];
          int n = 0;
          while( -1 != ( n = input.read( buffer ) ) )
          {
              output.write( buffer, 0, n );
          }
      }
  
      ///////////////////////////////////////////////////////////////
      // Derived copy methods
      // InputStream -> *
      ///////////////////////////////////////////////////////////////
  
  
      ///////////////////////////////////////////////////////////////
      // InputStream -> Writer
  
      /**
       * Copy and convert bytes from an <code>InputStream</code> to chars on a
       * <code>Writer</code>.
       * The platform's default encoding is used for the byte-to-char conversion.
       */
      public static void copy( final InputStream input, final Writer output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy and convert bytes from an <code>InputStream</code> to chars on a
       * <code>Writer</code>.
       * The platform's default encoding is used for the byte-to-char conversion.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final InputStream input, final Writer output, final int bufferSize )
          throws IOException
      {
          final InputStreamReader in = new InputStreamReader( input );
          copy( in, output, bufferSize );
      }
  
      /**
       * Copy and convert bytes from an <code>InputStream</code> to chars on a
       * <code>Writer</code>, using the specified encoding.
       * @param encoding The name of a supported character encoding. See the
       * <a href="http://www.iana.org/assignments/character-sets">IANA
       * Charset Registry</a> for a list of valid encoding types.
       */
      public static void copy( final InputStream input, final Writer output, final String encoding )
          throws IOException
      {
          final InputStreamReader in = new InputStreamReader( input, encoding );
          copy( in, output );
      }
  
      /**
       * Copy and convert bytes from an <code>InputStream</code> to chars on a
       * <code>Writer</code>, using the specified encoding.
       * @param encoding The name of a supported character encoding. See the
       *        <a href="http://www.iana.org/assignments/character-sets">IANA
       *        Charset Registry</a> for a list of valid encoding types.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final InputStream input,
                               final Writer output,
                               final String encoding,
                               final int bufferSize )
          throws IOException
      {
          final InputStreamReader in = new InputStreamReader( input, encoding );
          copy( in, output, bufferSize );
      }
  
  
      ///////////////////////////////////////////////////////////////
      // InputStream -> String
  
      /**
       * Get the contents of an <code>InputStream</code> as a String.
       * The platform's default encoding is used for the byte-to-char conversion.
       */
      public static String toString( final InputStream input )
          throws IOException
      {
          return toString( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of an <code>InputStream</code> as a String.
       * The platform's default encoding is used for the byte-to-char conversion.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final InputStream input, final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, bufferSize );
          return sw.toString();
      }
  
      /**
       * Get the contents of an <code>InputStream</code> as a String.
       * @param encoding The name of a supported character encoding. See the
       *    <a href="http://www.iana.org/assignments/character-sets">IANA
       *    Charset Registry</a> for a list of valid encoding types.
       */
      public static String toString( final InputStream input, final String encoding )
          throws IOException
      {
          return toString( input, encoding, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of an <code>InputStream</code> as a String.
       * @param encoding The name of a supported character encoding. See the
       *   <a href="http://www.iana.org/assignments/character-sets">IANA
       *   Charset Registry</a> for a list of valid encoding types.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final InputStream input,
                                     final String encoding,
                                     final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, encoding, bufferSize );
          return sw.toString();
      }
  
      ///////////////////////////////////////////////////////////////
      // InputStream -> byte[]
  
      /**
       * Get the contents of an <code>InputStream</code> as a <code>byte[]</code>.
       */
      public static byte[] toByteArray( final InputStream input )
          throws IOException
      {
          return toByteArray( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of an <code>InputStream</code> as a <code>byte[]</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static byte[] toByteArray( final InputStream input, final int bufferSize )
          throws IOException
      {
          final ByteArrayOutputStream output = new ByteArrayOutputStream();
          copy( input, output, bufferSize );
          return output.toByteArray();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // Derived copy methods
      // Reader -> *
      ///////////////////////////////////////////////////////////////
  
      ///////////////////////////////////////////////////////////////
      // Reader -> OutputStream
      /**
       * Serialize chars from a <code>Reader</code> to bytes on an <code>OutputStream</code>, and
       * flush the <code>OutputStream</code>.
       */
      public static void copy( final Reader input, final OutputStream output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Serialize chars from a <code>Reader</code> to bytes on an <code>OutputStream</code>, and
       * flush the <code>OutputStream</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final Reader input, final OutputStream output, final int bufferSize )
          throws IOException
      {
          final OutputStreamWriter out = new OutputStreamWriter( output );
          copy( input, out, bufferSize );
          // NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush
          // here.
          out.flush();
      }
  
      ///////////////////////////////////////////////////////////////
      // Reader -> String
      /**
       * Get the contents of a <code>Reader</code> as a String.
       */
      public static String toString( final Reader input )
          throws IOException
      {
          return toString( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>Reader</code> as a String.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final Reader input, final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, bufferSize );
          return sw.toString();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // Reader -> byte[]
      /**
       * Get the contents of a <code>Reader</code> as a <code>byte[]</code>.
       */
      public static byte[] toByteArray( final Reader input )
          throws IOException
      {
          return toByteArray( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>Reader</code> as a <code>byte[]</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static byte[] toByteArray( final Reader input, final int bufferSize )
          throws IOException
      {
          ByteArrayOutputStream output = new ByteArrayOutputStream();
          copy( input, output, bufferSize );
          return output.toByteArray();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // Derived copy methods
      // String -> *
      ///////////////////////////////////////////////////////////////
  
  
      ///////////////////////////////////////////////////////////////
      // String -> OutputStream
  
      /**
       * Serialize chars from a <code>String</code> to bytes on an <code>OutputStream</code>, and
       * flush the <code>OutputStream</code>.
       */
      public static void copy( final String input, final OutputStream output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Serialize chars from a <code>String</code> to bytes on an <code>OutputStream</code>, and
       * flush the <code>OutputStream</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final String input, final OutputStream output, final int bufferSize )
          throws IOException
      {
          final StringReader in = new StringReader( input );
          final OutputStreamWriter out = new OutputStreamWriter( output );
          copy( in, out, bufferSize );
          // NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush
          // here.
          out.flush();
      }
  
  
  
      ///////////////////////////////////////////////////////////////
      // String -> Writer
  
      /**
       * Copy chars from a <code>String</code> to a <code>Writer</code>.
       */
      public static void copy( final String input, final Writer output )
          throws IOException
      {
          output.write( input );
      }
  
      /**
       * Copy bytes from an <code>InputStream</code> to an
       * <code>OutputStream</code>, with buffering.
       * This is equivalent to passing a
       * {@link java.io.BufferedInputStream} and
       * {@link java.io.BufferedOutputStream} to {@link #copy(InputStream, OutputStream)},
       * and flushing the output stream afterwards. The streams are not closed
       * after the copy.
       * @deprecated Buffering streams is actively harmful! See the class description as to why. Use
       * {@link #copy(InputStream, OutputStream)} instead.
       */
      public static void bufferedCopy( final InputStream input, final OutputStream output )
          throws IOException
      {
          final BufferedInputStream in = new BufferedInputStream( input );
          final BufferedOutputStream out = new BufferedOutputStream( output );
          copy( in, out );
          out.flush();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // String -> byte[]
      /**
       * Get the contents of a <code>String</code> as a <code>byte[]</code>.
       */
      public static byte[] toByteArray( final String input )
          throws IOException
      {
          return toByteArray( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>String</code> as a <code>byte[]</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static byte[] toByteArray( final String input, final int bufferSize )
          throws IOException
      {
          ByteArrayOutputStream output = new ByteArrayOutputStream();
          copy( input, output, bufferSize );
          return output.toByteArray();
      }
  
  
  
      ///////////////////////////////////////////////////////////////
      // Derived copy methods
      // byte[] -> *
      ///////////////////////////////////////////////////////////////
  
  
      ///////////////////////////////////////////////////////////////
      // byte[] -> Writer
  
      /**
       * Copy and convert bytes from a <code>byte[]</code> to chars on a
       * <code>Writer</code>.
       * The platform's default encoding is used for the byte-to-char conversion.
       */
      public static void copy( final byte[] input, final Writer output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy and convert bytes from a <code>byte[]</code> to chars on a
       * <code>Writer</code>.
       * The platform's default encoding is used for the byte-to-char conversion.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final byte[] input, final Writer output, final int bufferSize )
          throws IOException
      {
          final ByteArrayInputStream in = new ByteArrayInputStream( input );
          copy( in, output, bufferSize );
      }
  
      /**
       * Copy and convert bytes from a <code>byte[]</code> to chars on a
       * <code>Writer</code>, using the specified encoding.
       * @param encoding The name of a supported character encoding. See the
       * <a href="http://www.iana.org/assignments/character-sets">IANA
       * Charset Registry</a> for a list of valid encoding types.
       */
      public static void copy( final byte[] input, final Writer output, final String encoding )
          throws IOException
      {
          final ByteArrayInputStream in = new ByteArrayInputStream( input );
          copy( in, output, encoding );
      }
  
      /**
       * Copy and convert bytes from a <code>byte[]</code> to chars on a
       * <code>Writer</code>, using the specified encoding.
       * @param encoding The name of a supported character encoding. See the
       *        <a href="http://www.iana.org/assignments/character-sets">IANA
       *        Charset Registry</a> for a list of valid encoding types.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final byte[] input,
                               final Writer output,
                               final String encoding,
                               final int bufferSize )
          throws IOException
      {
          final ByteArrayInputStream in = new ByteArrayInputStream( input );
          copy( in, output, encoding, bufferSize );
      }
  
  
      ///////////////////////////////////////////////////////////////
      // byte[] -> String
  
      /**
       * Get the contents of a <code>byte[]</code> as a String.
       * The platform's default encoding is used for the byte-to-char conversion.
       */
      public static String toString( final byte[] input )
          throws IOException
      {
          return toString( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>byte[]</code> as a String.
       * The platform's default encoding is used for the byte-to-char conversion.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final byte[] input, final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, bufferSize );
          return sw.toString();
      }
  
      /**
       * Get the contents of a <code>byte[]</code> as a String.
       * @param encoding The name of a supported character encoding. See the
       *    <a href="http://www.iana.org/assignments/character-sets">IANA
       *    Charset Registry</a> for a list of valid encoding types.
       */
      public static String toString( final byte[] input, final String encoding )
          throws IOException
      {
          return toString( input, encoding, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>byte[]</code> as a String.
       * @param encoding The name of a supported character encoding. See the
       *   <a href="http://www.iana.org/assignments/character-sets">IANA
       *   Charset Registry</a> for a list of valid encoding types.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final byte[] input,
                                     final String encoding,
                                     final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, encoding, bufferSize );
          return sw.toString();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // byte[] -> OutputStream
  
      /**
       * Copy bytes from a <code>byte[]</code> to an <code>OutputStream</code>.
       */
      public static void copy( final byte[] input, final OutputStream output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy bytes from a <code>byte[]</code> to an <code>OutputStream</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final byte[] input,
                               final OutputStream output,
                               final int bufferSize )
          throws IOException
      {
          output.write( input );
      }
  
      /**
       * Compare the contents of two Streams to determine if they are equal or not.
       *
       * @param input1 the first stream
       * @param input2 the second stream
       * @return true if the content of the streams are equal or they both don't exist, false otherwise
       */
      public static boolean contentEquals( final InputStream input1,
                                           final InputStream input2 )
          throws IOException
      {
          final InputStream bufferedInput1 = new BufferedInputStream( input1 );
          final InputStream bufferedInput2 = new BufferedInputStream( input2 );
  
          int ch = bufferedInput1.read();
          while( -1 != ch )
          {
              final int ch2 = bufferedInput2.read();
              if( ch != ch2 )
              {
                  return false;
              }
              ch = bufferedInput1.read();
          }
  
          final int ch2 = bufferedInput2.read();
          if( -1 != ch2 )
          {
              return false;
          }
          else
          {
              return true;
          }
      }
  }
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/controlpanel.jsp
  
  Index: controlpanel.jsp
  ===================================================================
  <%@page import="java.io.*,java.util.*,java.text.*"%>
  
  <%@include file="WEB-INF/logic.jsp"%>
  
  <html>
    <head>
      <title>Forrestbot Web Interface</title>
    </head>
  
    <body>
      <% if (request.getParameter("intro") != null) { %>
        <jsp:include page="welcome.html" flush="true"/>
        <hr>
      <% } %>
  
      <% if (command != null) { %>
      Processing <b><%= command %></b> - <a target="_top" href="<%=request.getContextPath()+"/refresh/"+module%>">View progress</a>
      <% } %>
  
      <table>
        <tr><td width="40%">
      <p>
      <ul style="list-style-image: url(images/dir.gif)">
        <li><a target="_top" href="<%= sites_url %>">View sites</a>:
        <ul style="list-style-image: url(images/file.gif)">
          <%
          for (int i=0; i<sites.size(); i++) {
            String sitename = (String)sites.get(i);
            boolean exists = new File(sites_dir + "/"+sitename).exists();
            out.println("<li>");
            if (exists) out.println("<a target='_top' href='"+sites_url+"/"+sitename+"'>");
              out.println(sitename);
            if (exists) out.println("</a>");
          if (exists) out.println("&nbsp;&nbsp;<a href='" + logs_url + "/"+sitename+".log'><small>[log]</small></a>");
          if (exists) out.println("&nbsp;&nbsp;"+getTimestamp(new File(logs_dir + "/"+sitename+".log"), request.getLocale()));
          }
          %>
        </ul>
        <li><a target="_top" href="<%= logs_url %>">Logs</a>
      </ul>
      </p>
    </td>
    <td width="10%">
    </td>
    <td>
    <div style="color: red"><% if (errMsg != null) { out.println(errMsg); } %></div>
    <form method="POST">
      Username: <input type="text" name="username" value="<%= (username!=null?username:"")%>"> <br>
      Password: <input type="password" name="passwd" value="<%=(password!=null?password:"")%>"> <br>
      <% if (privs != null) { %>
        Select a module:
        <select name="module">
          <%
          for (int i=0; i<sites.size(); i++) {
  			String sitename = (String)sites.get(i);
            if (privs.contains(sitename)) {
              out.println("<option value='"+sitename+"'>"+sitename);
            }
          }
          %>
        </select>
        <br>
        Select an action:
        <% if (privs.contains("build")) { %>
          <input type="submit" name="action" value="build">
        <% } %>
        <% if (privs.contains("deploy")) { %>
          <input type="submit" name="action" value="deploy"/>
        <% } %>
        <% } else { %>
          <input type="submit" value="login">
        <% } %>
    </form>
    </td></tr>
    </table>
    </body>
  </html>
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/index.jsp
  
  Index: index.jsp
  ===================================================================
  <jsp:include page="controlpanel.jsp?intro=true" flush="true"/>
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/refresh_controlpanel.jsp
  
  Index: refresh_controlpanel.jsp
  ===================================================================
  <% String site = request.getParameter("site"); %>
  <html>
    <head>
      <title>Forrestbot Web Interface - Refreshing site <%= site %></title>
    </head>
    <body>
      <h1>Refreshing site <%= site %></h1>
      <p>
      The lower pane prints the last page or so of the build log file,
      refreshed every 5 seconds. When it looks like stuff has finished
      happening, you can view the regenerated site.
      </p>
      <ul>
        <li><a target="_top" href="<%= request.getContextPath()%>">Return to menu</a>
        <li><a target="_top" href="<%= request.getContextPath()%>/site<%=request.getParameter("site")%>">View site <%= site %></a>
      </ul>
    </body>
  </html>
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/refresh_frame.jsp
  
  Index: refresh_frame.jsp
  ===================================================================
  <html>
    <head>
      <title>Forrestbot Web Interface</title>
      <meta http-equiv="Refresh" CONTENT="5">
    </head>
    <% String ctx = request.getContextPath();%>
    <frameset ROWS="20%,*">
      <frame SRC="<%=ctx%>/refresh_controlpanel.jsp?site=<%=request.getPathInfo()%>" NAME="frame2">
      <frame SRC="<%=ctx%>/logs/refresh" NAME="frame2">
      <noframes>
        <body>
          Sorry, you need frames to view this site.
        </body>
      </noframes>
    </frameset>
  </html>
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/tail_refreshlog.jsp
  
  Index: tail_refreshlog.jsp
  ===================================================================
  <%@page import="java.io.*" contentType="text/plain"%>
  <%!
  private static final String LOG_FILE="/WEB-INF/refresh_log.txt";
  /** Number of bytes to print on each refresh */
  private static final int TAIL_SIZE=1000;
  %>
  
  <%
  File f = new File(getServletConfig().getServletContext().getRealPath(LOG_FILE));
  if (f.exists()) {
  try {
    String logs = forrestbot.IOUtil.toString(new FileReader(f));
    int len = logs.length();
    out.println( ((len < TAIL_SIZE) ? logs : logs.substring(logs.length()-TAIL_SIZE)) );
    } catch (Throwable t) { out.println(t); }
  } else { %>
  
  Log file <%=LOG_FILE%> not found.
  
  Please start the forrestbot backend script (overseer) and ensure it is logging
  to the right place.
  
  <% } %>
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/viewsite.jsp
  
  Index: viewsite.jsp
  ===================================================================
  <%@include file="WEB-INF/settings.jsp"%>
  <html>
    <head>
      <title>Forrestbot Web Interface</title>
    </head>
    <% String ctx = request.getContextPath();%>
    <frameset ROWS="20%,*">
      <frame SRC="<%=ctx%>/controlpanel.jsp" NAME="index">
      <frame SRC="<%=sites_url%>/<%=request.getPathInfo()%>/index.html" NAME="frame2">
      <noframes>
        <body>
          Sorry, you need frames to view this site.
        </body>
      </noframes>
    </frameset>
  </html>
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/welcome.html
  
  Index: welcome.html
  ===================================================================
  <h1>Forrestbot's Web Interface</h1>
  <p>
  This site contains automatically updated and built versions of websites built
  with the latest <a href="http://xml.apache.org/forrest/">Forrest</a>. It aims
  to provide a service similar to <a
    href="http://jakarta.apache.org/gump/">Gump</a>, but for websites.  Host
  projects' XML is automatically checked out and the HTML rebuilt every 4 hours.
  </p>
  <p>
  In addition, if you have just made a site update and are itching to see the
  result, site builds can be triggered manually.
  </p>
  <p>
  Certain users can also trigger an automatic build of the generated HTML/PDFs
  to Apache's site CVS module (xml-site, avalon-site, etc).
  </p>
  <p>
  To request a username/password that allows you to build and/or deploy your
  project's site, please mail <a href="mailto:jefft.at.apache.org">Jeff
    Turner</a>.
  </p>
  <p>
  To set up the Forrestbot Web Inteface for your own collection of projects, checkout the source and read WEB-INF/README.txt
  
  <p>
  If you have any questions, please mail <a
    href="mailto:jefft.at.apache.org">Jeff Turner</a>, or <a
    href="mailto:forrest-dev.at.xml.apache.org">forrest-dev</a>
  </p>
  
  
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/images/dir.gif
  
  	<<Binary file>>
  
  
  1.1                  xml-forrest/scratchpad/forrestbot2/webapp/images/file.gif
  
  	<<Binary file>>
  
  

Mime
View raw message