src/JAVA/classes/org/openafs/jafs/Process.java

   1 /*
   2  * @(#)Process.java     1.0 6/29/2001
   3  *
   4  * Copyright (c) 2001 International Business Machines Corp.
   5  * All rights reserved.
   6  *
   7  * This software has been released under the terms of the IBM Public
   8  * License.  For details, see the LICENSE file in the top-level source
   9  * directory or online at http://www.openafs.org/dl/license10.html
  10  *
  11  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  12  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  13  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  14  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR
  15  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  16  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  17  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  18  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  19  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  20  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  21  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  22  */
  23
  24 package org.openafs.jafs;
  25
  26 import java.util.GregorianCalendar;
  27 import java.util.Date;
  28 import java.io.Serializable;
  29
  30 /**
  31  * An abstract representation of an AFS process.  It holds information about
  32  * the server, such as what its state is.
  33  * <BR><BR>
  34  *
  35  * Constructing an instance of a <code>Process</code> does not mean an actual
  36  * AFS process is created on a server -- usually a <code>Process</code>
  37  * object is a representation of an already existing AFS process.  If,
  38  * however, the <code>Process</code> is constructed with the name of a
  39  * process that does not exist in the server represented by the provided
  40  * <code>Server</code>, a new process with that name can be
  41  * created on that server by calling one of the {@link #createSimple(String)},
  42  * {@link #createFS(String)}, or {@link #createCron(String,String)} methods. If
  43  * such a process does already exist when one of these methods are called,
  44  * an exception will be thrown.<BR><BR>
  45  *
  46  * <!--Information on how member values are set-->
  47  *
  48  * <!--Example of how to use class-->
  49  * The following is a simple example of how to construct and use a
  50  * <code>Process</code> object.  This example obtains the list of all
  51  * <code>Process</code> objects on a particular server and prints out the
  52  * name of each one along with its start time.<BR><BR>
  53  *
  54  * <PRE>
  55  * import org.openafs.jafs.Cell;
  56  * import org.openafs.jafs.AFSException;
  57  * import org.openafs.jafs.Process;
  58  * import org.openafs.jafs.Server;
  59  * ...
  60  * public class ...
  61  * {
  62  *   ...
  63  *   private Cell cell;
  64  *   private Server server;
  65  *   ...
  66  *   public static void main(String[] args) throws Exception
  67  *   {
  68  *     String username   = arg[0];
  69  *     String password   = arg[1];
  70  *     String cellName   = arg[2];
  71  *     String serverName = arg[3];
  72  *
  73  *     token = new Token(username, password, cellName);
  74  *     cell   = new Cell(token);
  75  *     server = new Server(serverName, cell);
  76  *
  77  *     System.out.println("Processes in Server " + server.getName() + ":");
  78  *     Process[] processes = server.getProcesss();
  79  *     for (int i = 0; i < processes.length; i++) {
  80  *       System.out.print("Process " + processes[i].getName());
  81  *       System.out.print("was started: " +
  82  *                        processes[i].getStartTimeDate().getTime() + "\n");
  83  *     }
  84  *   }
  85  *   ...
  86  * }
  87  * </PRE>
  88  *
  89  */
  90 public class Process implements Serializable, Comparable
  91 {
  92   /**
  93    * Any standard type of process except for fs (such as kaserver,
  94    * upclientbin, etc.)
  95    */
  96   public static final int SIMPLE_PROCESS = 0;
  97
  98   /**
  99    * Combination of File Server, Volume Server, and Salvager processes
 100    */
 101   public static final int FS_PROCESS = 1;
 102
 103   /**
 104    * A process that should be restarted at a specific time either daily
 105    * or weekly.
 106    */
 107   public static final int CRON_PROCESS = 2;
 108
 109   /**
 110    * Process execution state stopped
 111    */
 112   public static final int STOPPED = 0;
 113
 114   /**
 115    * Process execution state running
 116    */
 117   public static final int RUNNING = 1;
 118
 119   /**
 120    * Process execution state stopping
 121    */
 122   public static final int STOPPING = 2;
 123
 124   /**
 125    * Process execution state starting
 126    */
 127   public static final int STARTING = 3;
 128
 129   protected String name;
 130   protected Server server;
 131   protected long serverHandle;
 132
 133   protected int type;
 134   protected int state;
 135   protected int goal;
 136
 137   protected long startTime;
 138   protected long numberStarts;
 139   protected long exitTime;
 140   protected long exitErrorTime;
 141   protected long errorCode;
 142   protected long errorSignal;
 143
 144   protected boolean stateOk;
 145   protected boolean stateTooManyErrors;
 146   protected boolean stateBadFileAccess;
 147
 148   protected GregorianCalendar startTimeDate;
 149   protected GregorianCalendar exitTimeDate;
 150   protected GregorianCalendar exitErrorTimeDate;
 151
 152   protected boolean cachedInfo;
 153
 154   /**
 155    * Constructs a new <code>Process</code> object instance given the name
 156    * of the AFS process and the AFS server, represented by
 157    * <CODE>server</CODE>, to which it belongs.   This does not actually
 158    * create a new AFS process, it just represents one.
 159    * If <code>name</code> is not an actual AFS process, exceptions
 160    * will be thrown during subsequent method invocations on this
 161    * object, unless one of the {@link #createSimple(String)},
 162    * {@link #createFS(String)}, or {@link #createCron(String,String)}
 163    * methods are explicitly called to create it.
 164    *
 165    * @param name      the name of the server to represent
 166    * @param server    the server on which the process resides
 167    * @exception AFSException      If an error occurs in the native code
 168    */
 169   public Process( String name, Server server ) throws AFSException
 170   {
 171     this.name = name;
 172     this.server = server;
 173     serverHandle = server.getBosHandle();
 174
 175     startTimeDate = null;
 176     exitTimeDate = null;
 177     exitErrorTimeDate = null;
 178
 179     cachedInfo = false;
 180   }
 181
 182   /**
 183    * Constructs a new <CODE>Process</CODE> object instance given the name
 184    * of the AFS process and the AFS server, represented by
 185    * <CODE>server</CODE>, to which it belongs.  This does not actually
 186    * create a new AFS process, it just represents one.
 187    * If <code>name</code> is not an actual AFS process, exceptions
 188    * will be thrown during subsequent method invocations on this
 189    * object, unless one of the {@link #createSimple(String)},
 190    * {@link #createFS(String)}, or {@link #createCron(String,String)}
 191    * methods are explicitly called to create it.  Note that if he process
 192    * doesn't exist and <code>preloadAllMembers</code> is true, an exception
 193    * will be thrown.
 194    *
 195    * <P> This constructor is ideal for point-in-time representation and
 196    * transient applications. It ensures all data member values are set and
 197    * available without calling back to the filesystem at the first request
 198    * for them.  Use the {@link #refresh()} method to address any coherency
 199    * concerns.
 200    *
 201    * @param name               the name of the process to represent
 202    * @param server             the server to which the process belongs.
 203    * @param preloadAllMembers  true will ensure all object members are
 204    *                           set upon construction; otherwise members will
 205    *                           be set upon access, which is the default
 206    *                           behavior.
 207    * @exception AFSException      If an error occurs in the native code
 208    * @see #refresh
 209    */
 210   public Process( String name, Server server, boolean preloadAllMembers )
 211       throws AFSException
 212   {
 213     this(name, server);
 214     if (preloadAllMembers) refresh(true);
 215   }
 216
 217   /**
 218    * Creates a blank <code>Process</code> given the server to which the process
 219    * belongs.  This blank object can then be passed into other methods to fill
 220    * out its properties.
 221    *
 222    * @param server       the server to which the process belongs.
 223    * @exception AFSException      If an error occurs in the native code
 224    */
 225   Process( Server server ) throws AFSException
 226   {
 227     this( null, server );
 228   }
 229
 230   /*-------------------------------------------------------------------------*/
 231
 232   /**
 233    * Refreshes the properties of this Process object instance with values
 234    * from the AFS process it represents.  All properties that have been
 235    * initialized and/or accessed will be renewed according to the values of
 236    * the AFS process this Process object instance represents.
 237    *
 238    * <P>Since in most environments administrative changes can be administered
 239    * from an AFS command-line program or an alternate GUI application, this
 240    * method provides a means to refresh the Java object representation and
 241    * thereby ascertain any possible modifications that may have been made
 242    * from such alternate administrative programs.  Using this method before
 243    * an associated instance accessor will ensure the highest level of
 244    * representative accuracy, accommodating changes made external to the
 245    * Java application space.  If administrative changes to the underlying AFS
 246    * system are only allowed via this API, then the use of this method is
 247    * unnecessary.
 248    *
 249    * @exception AFSException  If an error occurs in the native code
 250    */
 251   public void refresh() throws AFSException
 252   {
 253     refresh(false);
 254   }
 255
 256   /**
 257    * Refreshes the properties of this Process object instance with values from
 258    * the AFS process it represents.  If <CODE>all</CODE> is <CODE>true</CODE>
 259    * then <U>all</U> of the properties of this Process object instance will be
 260    * set, or renewed, according to the values of the AFS process it represents,
 261    * disregarding any previously set properties.
 262    *
 263    * <P> Thus, if <CODE>all</CODE> is <CODE>false</CODE> then properties that
 264    * are currently set will be refreshed and properties that are not set will
 265    * remain uninitialized. See {@link #refresh()} for more information.
 266    *
 267    * @param all   if true set or renew all object properties; otherwise renew
 268    *              all set properties
 269    * @exception AFSException  If an error occurs in the native code
 270    * @see #refresh()
 271    */
 272   protected void refresh(boolean all) throws AFSException
 273   {
 274     if (all || cachedInfo) refreshInfo();
 275   }
 276
 277   /**
 278    * Refreshes the information fields of this <code>Process</code> to reflect
 279    * the current state of the AFS process, such as the start time, the state,
 280    * etc.
 281    *
 282    * @exception AFSException      If an error occurs in the native code
 283    */
 284   protected void refreshInfo() throws AFSException
 285   {
 286     getProcessInfo( server.getBosHandle(), name, this );
 287     cachedInfo = true;
 288     startTimeDate = null;
 289     exitTimeDate = null;
 290     exitErrorTimeDate = null;
 291   }
 292
 293   /**
 294    * Creates this process as a simple process on the server.
 295    *
 296    * @param executionPath   the path to the process's executable
 297    * @exception AFSException      If an error occurs in the native code
 298    */
 299   public void createSimple( String executionPath ) throws AFSException
 300   {
 301     create( server.getBosHandle(), name, SIMPLE_PROCESS, executionPath, null,
 302             null );
 303   }
 304
 305   /**
 306    * Creates this process as a file server process on the server.
 307    *
 308    * @param executionPath   the path to the process's executable
 309    * @exception AFSException      If an error occurs in the native code
 310    */
 311   public void createFS( String executionPath ) throws AFSException
 312   {
 313     create( server.getBosHandle(), name, FS_PROCESS, executionPath, null,
 314             null );
 315   }
 316
 317   /**
 318    * Creates this process as a cron process on the server.
 319    *
 320    * @param executionPath   the path to the process's executable
 321    * @param cronTime   a String representing the time a cron process is
 322    *                   to be run.  Acceptable formats are:<ul>
 323    *                   <li>for daily restarts: "23:10" or "11:10 pm"</li>
 324    *                   <li>for weekly restarts: "sunday 11:10pm" or
 325    *                       "sun 11:10pm"</li>
 326    *                   </ul>
 327    * @exception AFSException      If an error occurs in the native code
 328    */
 329   public void createCron( String executionPath, String cronTime )
 330       throws AFSException
 331   {
 332     create( server.getBosHandle(), name, CRON_PROCESS, executionPath,
 333             cronTime, null );
 334   }
 335
 336   /**
 337    * Removes this process from the bos server
 338    *
 339    * @exception AFSException      If an error occurs in the native code
 340    */
 341   public void delete() throws AFSException
 342   {
 343     delete( server.getBosHandle(), name );
 344   }
 345
 346   /**
 347    * Stops this process.
 348    *
 349    * @exception AFSException      If an error occurs in the native code
 350    */
 351   public void stop() throws AFSException
 352   {
 353     state = STOPPING;
 354     goal = STOPPED;
 355     stop( server.getBosHandle(), name );
 356   }
 357
 358   /**
 359    * Starts this process
 360    *
 361    * @exception AFSException      If an error occurs in the native code
 362    */
 363   public void start() throws AFSException
 364   {
 365     state = STARTING;
 366     start( server.getBosHandle(), name );
 367   }
 368
 369   /**
 370    * Restarts this process
 371    *
 372    * @exception AFSException      If an error occurs in the native code
 373    */
 374   public void restart() throws AFSException
 375   {
 376     state = STARTING;
 377     restart( server.getBosHandle(), name );
 378   }
 379
 380   //////////////// accessors:  ////////////////////////
 381
 382   /**
 383    * Returns the name of this process.
 384    *
 385    * @return the name of this process
 386    */
 387   public String getName()
 388   {
 389     return name;
 390   }
 391
 392   /**
 393    * Returns the server hosting this process.
 394    *
 395    * @return this process' server
 396    */
 397   public Server getServer()
 398   {
 399     return server;
 400   }
 401
 402   /**
 403    * Returns the process type.  Possible values are:<ul>
 404    *      <li>{@link #SIMPLE_PROCESS}</li>
 405    *      <li>{@link #FS_PROCESS}</li>
 406    *      <li>{@link #CRON_PROCESS}</li></ul>
 407    *
 408    * @return the process type
 409    * @exception AFSException      If an error occurs in the native code
 410    */
 411   public int getType() throws AFSException
 412   {
 413     if (!cachedInfo) refreshInfo();
 414     return type;
 415   }
 416
 417   /**
 418    * Returns the process goal.  Possible values are:<ul>
 419    *      <li>{@link #STOPPED}</li>
 420    *      <li>{@link #RUNNING}</li>
 421    *      <li>{@link #STARTING}</li>
 422    *      <li>{@link #STOPPING}</li></ul>
 423    * After this method is called once, it saves the value
 424    * and returns that value on subsequent calls,
 425    * until the {@link #refresh()} method is called and a more current
 426    * value is obtained.
 427    *
 428    * @return the process goal
 429    * @exception AFSException      If an error occurs in the native code
 430    */
 431   public int getGoal() throws AFSException
 432   {
 433     if (!cachedInfo) refreshInfo();
 434     return goal;
 435   }
 436
 437   /**
 438    * Returns the process execution state.  Possible values are:<ul>
 439    *      <li>{@link #STOPPED}</li>
 440    *      <li>{@link #RUNNING}</li>
 441    *      <li>{@link #STARTING}</li>
 442    *      <li>{@link #STOPPING}</li></ul>
 443    * After this method is called once, it saves the value
 444    * and returns that value on subsequent calls,
 445    * until the {@link #refresh()} method is called and a more current
 446    * value is obtained.
 447    *
 448    * @return the process execution state
 449    * @exception AFSException      If an error occurs in the native code
 450    */
 451   public int getState() throws AFSException
 452   {
 453     if (!cachedInfo) refreshInfo();
 454     return state;
 455   }
 456
 457   /**
 458    * Returns the most recent start time of this process.  A
 459    * <code>null</code> value
 460    * indicates no start time.
 461    * After this method is called once, it saves the value
 462    * and returns that value on subsequent calls,
 463    * until the {@link #refresh()} method is called and a more current
 464    * value is obtained.
 465    *
 466    * @return the start time
 467    * @exception AFSException      If an error occurs in the native code
 468    */
 469   public long getStartTime() throws AFSException
 470   {
 471     if (!cachedInfo) refreshInfo();
 472     return startTime;
 473   }
 474
 475   /**
 476    * Returns the most recent start time of this process.  A <code>null</code>
 477    * value indicates no start time.
 478    * After this method is called once, it saves the value
 479    * and returns that value on subsequent calls,
 480    * until the {@link #refresh()} method is called and a more current
 481    * value is obtained.
 482    *
 483    * @return the start time
 484    * @exception AFSException      If an error occurs in the native code
 485    */
 486   public GregorianCalendar getStartTimeDate() throws AFSException
 487   {
 488     if (!cachedInfo) {
 489         refreshInfo();
 490     }
 491     if( startTimeDate == null && startTime != 0 ) {
 492         // make it into a date . . .
 493         startTimeDate = new GregorianCalendar();
 494         long longTime = startTime * 1000;
 495         Date d = new Date( longTime );
 496         startTimeDate.setTime( d );
 497     }
 498     return startTimeDate;
 499   }
 500
 501   /**
 502    * Returns the number of starts of the process.
 503    * After this method is called once, it saves the value
 504    * and returns that value on subsequent calls,
 505    * until the {@link #refresh()} method is called and a more current
 506    * value is obtained.
 507    *
 508    * @return the number of starts
 509    * @exception AFSException      If an error occurs in the native code
 510    */
 511   public long getNumberOfStarts() throws AFSException
 512   {
 513     if (!cachedInfo) refreshInfo();
 514     return numberStarts;
 515   }
 516
 517   /**
 518    * Returns the most recent exit time of this process.  A <code>null</code>
 519    * value indicates no exit time.
 520    * After this method is called once, it saves the value
 521    * and returns that value on subsequent calls,
 522    * until the {@link #refresh()} method is called and a more current
 523    * value is obtained.
 524    *
 525    * @return the exit time
 526    * @exception AFSException      If an error occurs in the native code
 527    */
 528   public long getExitTime() throws AFSException
 529   {
 530     if (!cachedInfo) refreshInfo();
 531     return exitTime;
 532   }
 533
 534   /**
 535    * Returns the most recent exit time of this process.  A <code>null</code>
 536    * value indicates no exit time
 537    * After this method is called once, it saves the value
 538    * and returns that value on subsequent calls,
 539    * until the {@link #refresh()} method is called and a more current
 540    * value is obtained.
 541    *
 542    * @return the exit time
 543    * @exception AFSException      If an error occurs in the native code
 544    */
 545   public GregorianCalendar getExitTimeDate() throws AFSException
 546   {
 547     if (!cachedInfo) refreshInfo();
 548     if( exitTimeDate == null && exitTime != 0 ) {
 549         // make it into a date . . .
 550         exitTimeDate = new GregorianCalendar();
 551         long longTime = exitTime*1000;
 552         Date d = new Date( longTime );
 553         exitTimeDate.setTime( d );
 554     }
 555     return exitTimeDate;
 556   }
 557
 558   /**
 559    * Returns the most recent time this process exited with an error.  A
 560    * <code>null</code> value indicates no exit w/ error time.
 561    * After this method is called once, it saves the value
 562    * and returns that value on subsequent calls,
 563    * until the {@link #refresh()} method is called and a more current
 564    * value is obtained.
 565    *
 566    * @return the exit w/ error time
 567    * @exception AFSException      If an error occurs in the native code
 568    */
 569   public long getExitErrorTime() throws AFSException
 570   {
 571     if (!cachedInfo) refreshInfo();
 572     return exitErrorTime;
 573   }
 574
 575   /**
 576    * Returns the most recent time this process exited with an error.  A <
 577    * code>null</code> value indicates no exit w/ error time.
 578    * After this method is called once, it saves the value
 579    * and returns that value on subsequent calls,
 580    * until the {@link #refresh()} method is called and a more current
 581    * value is obtained.
 582    *
 583    * @return the exit w/ error time
 584    * @exception AFSException      If an error occurs in the native code
 585    */
 586   public GregorianCalendar getExitErrorTimeDate() throws AFSException
 587   {
 588     if (!cachedInfo) refreshInfo();
 589     if (exitErrorTimeDate == null && exitErrorTime != 0) {
 590         // make it into a date . . .
 591         exitErrorTimeDate = new GregorianCalendar();
 592         long longTime = exitErrorTime*1000;
 593         Date d = new Date( longTime );
 594         exitErrorTimeDate.setTime( d );
 595     }
 596     return exitErrorTimeDate;
 597   }
 598
 599   /**
 600    * Returns the error code of the process.  A value of 0 indicates
 601    * no error code.
 602    * After this method is called once, it saves the value
 603    * and returns that value on subsequent calls,
 604    * until the {@link #refresh()} method is called and a more current
 605    * value is obtained.
 606    *
 607    * @return the error code
 608    * @exception AFSException      If an error occurs in the native code
 609    */
 610   public long getErrorCode() throws AFSException
 611   {
 612     if (!cachedInfo) refreshInfo();
 613     return errorCode;
 614   }
 615
 616   /**
 617    * Returns the error signal of the process.  A value of 0 indicates no
 618    * error signal.
 619    * After this method is called once, it saves the value
 620    * and returns that value on subsequent calls,
 621    * until the {@link #refresh()} method is called and a more current
 622    * value is obtained.
 623    *
 624    * @return the error signal
 625    * @exception AFSException      If an error occurs in the native code
 626    */
 627   public long getErrorSignal() throws AFSException
 628   {
 629     if (!cachedInfo) refreshInfo();
 630     return errorSignal;
 631   }
 632
 633   /**
 634    * Returns whether or not the state of the process is ok.  A value of
 635    * <code>false</code> indicates there has been a core dump.
 636    * After this method is called once, it saves the value
 637    * and returns that value on subsequent calls,
 638    * until the {@link #refresh()} method is called and a more current
 639    * value is obtained.
 640    *
 641    * @return whether or not the state is ok
 642    * @exception AFSException      If an error occurs in the native code
 643    */
 644   public boolean getStateOk() throws AFSException
 645   {
 646     if (!cachedInfo) refreshInfo();
 647     return stateOk;
 648   }
 649
 650   /**
 651    * Returns whether or not the state of the process indicates too many errors.
 652    * After this method is called once, it saves the value
 653    * and returns that value on subsequent calls,
 654    * until the {@link #refresh()} method is called and a more current
 655    * value is obtained.
 656    *
 657    * @return whether or not the state indicates too many errors
 658    * @exception AFSException      If an error occurs in the native code
 659    */
 660   public boolean getStateTooManyErrors() throws AFSException
 661   {
 662     if (!cachedInfo) refreshInfo();
 663     return stateTooManyErrors;
 664   }
 665
 666   /**
 667    * Returns whether or not the state of the process indicates bad file access.
 668    * After this method is called once, it saves the value
 669    * and returns that value on subsequent calls,
 670    * until the {@link #refresh()} method is called and a more current
 671    * value is obtained.
 672    *
 673    * @return whether or not the state indicates bad file access
 674    * @exception AFSException      If an error occurs in the native code
 675    */
 676   public boolean getStateBadFileAccess() throws AFSException
 677   {
 678     if (!cachedInfo) refreshInfo();
 679     return stateBadFileAccess;
 680   }
 681
 682   /////////////// custom information methods ////////////////////
 683
 684   /**
 685    * Returns a <code>String</code> representation of this <code>Process</code>.
 686    * Contains the information fields.
 687    *
 688    * @return a <code>String</code> representation of the <code>Process</code>
 689    */
 690   public String getInfo()
 691   {
 692     String r;
 693     try {
 694
 695         r = "Process: " + name + "\n";
 696
 697         r += "\ttype: ";
 698         switch( getType() ) {
 699         case SIMPLE_PROCESS:
 700           r += "simple";
 701           break;
 702         case FS_PROCESS:
 703           r += "fs";
 704           break;
 705         case CRON_PROCESS:
 706           r += "cron";
 707           break;
 708         default:
 709           r += "other - " + getType();
 710         }
 711         r += "\n";
 712
 713         r += "\tstate: ";
 714         switch( getState() ) {
 715         case STOPPED:
 716           r += "stopped";
 717           break;
 718         case RUNNING:
 719           r += "running";
 720           break;
 721         case STOPPING:
 722           r += "stopping";
 723           break;
 724         case STARTING:
 725           r += "starting";
 726           break;
 727         default:
 728           r += "other - " + getState();
 729         }
 730         r += "\n";
 731
 732         r += "\tgoal: ";
 733         switch( getGoal() ) {
 734         case STOPPED:
 735           r += "stopped";
 736           break;
 737         case RUNNING:
 738           r += "running";
 739           break;
 740         case STOPPING:
 741           r += "stopping";
 742           break;
 743         case STARTING:
 744           r += "starting";
 745           break;
 746         default:
 747           r += "other - " + getGoal();
 748         }
 749         r += "\n";
 750
 751         r += "\tstartTime: ";
 752         if( getStartTime() == 0) {
 753           r += "0";
 754         } else {
 755           r += getStartTimeDate().getTime();
 756         }
 757       r += "\n";
 758
 759         r += "\tnumberStarts: " + getNumberOfStarts() + "\n";
 760
 761         r += "\texitTime: ";
 762         if( getExitTime() == 0 ) {
 763           r += "0";
 764         } else {
 765           r += getExitTimeDate().getTime();
 766         }
 767       r += "\n";
 768
 769         r += "\texitErrorTime: ";
 770         if( getExitErrorTimeDate() == null ) {
 771           r += "0";
 772         } else {
 773           r += getExitErrorTimeDate().getTime();
 774         }
 775       r += "\n";
 776
 777         r += "\terrorCode: " + getErrorCode() + "\n";
 778         r += "\terrorSignal: " + getErrorSignal() + "\n";
 779         r += "\tstateOk: " + getStateOk() + "\n";
 780         r += "\tstateTooManyErrors: " + getStateTooManyErrors() + "\n";
 781         r += "\tstateBadFileAccess: " + getStateBadFileAccess() + "\n";
 782
 783     } catch( Exception e ) {
 784         return e.toString();
 785     }
 786     return r;
 787   }
 788
 789   /////////////// custom override methods ////////////////////
 790
 791   /**
 792    * Compares two Process objects respective to their names and does not
 793    * factor any other attribute.    Alphabetic case is significant in
 794    * comparing names.
 795    *
 796    * @param     process    The Process object to be compared to this Process
 797    *                       instance
 798    *
 799    * @return    Zero if the argument is equal to this Process' name, a
 800    *            value less than zero if this Process' name is
 801    *            lexicographically less than the argument, or a value greater
 802    *            than zero if this Process' name is lexicographically
 803    *            greater than the argument
 804    */
 805   public int compareTo(Process process)
 806   {
 807     return this.getName().compareTo(process.getName());
 808   }
 809
 810   /**
 811    * Comparable interface method.
 812    *
 813    * @see #compareTo(Process)
 814    */
 815   public int compareTo(Object obj)
 816   {
 817     return compareTo((Process)obj);
 818   }
 819
 820   /**
 821    * Tests whether two <code>Process</code> objects are equal, based on their
 822    * names and hosting server.
 823    *
 824    * @param otherProcess   the Process to test
 825    * @return whether the specifed Process is the same as this Process
 826    */
 827   public boolean equals( Process otherProcess )
 828   {
 829     return ( name.equals(otherProcess.getName()) ) &&
 830            ( this.getServer().equals(otherProcess.getServer()) );
 831   }
 832
 833   /**
 834    * Returns the name of this <CODE>Process</CODE>
 835    *
 836    * @return the name of this <CODE>Process</CODE>
 837    */
 838   public String toString()
 839   {
 840     return getName();
 841   }
 842
 843   /////////////// native methods ////////////////////
 844
 845   /**
 846    * Fills in the information fields of the provided <code>Process</code>.
 847    *
 848    * @param cellHandle    the handle of the cell to which the process belongs
 849    * @see Cell#getCellHandle
 850    * @param processName     the instance name of the process  for which to get
 851    *                        the information
 852    * @param theProcess     the {@link Process Process} object in which to fill
 853    *                       in the information
 854    * @exception AFSException   If an error occurs in the native code
 855    */
 856   protected static native void getProcessInfo( long cellHandle,
 857                                                String processName,
 858                                                Process theProcess )
 859         throws AFSException;
 860
 861   /**
 862    * Creates a processes on a server.
 863    *
 864    * @param serverHandle  the bos handle of the server to which the key will
 865    *                      belong
 866    * @see Server#getBosServerHandle
 867    * @param processName  the instance name to give the process.  See AFS
 868    *                     documentation for a standard list of instance names
 869    * @param processType  the type of process this will be.
 870    *                     Acceptable values are:<ul>
 871    *                     <li>{@link #SIMPLE_PROCESS}</li>
 872    *                     <li>{@link #FS_PROCESS}</li>
 873    *                     <li>{@link #CRON_PROCESS}</li></ul>
 874    * @param executionPath  the execution path process to create
 875    * @param cronTime   a String representing the time a cron process is to
 876    *                   be run.  Acceptable formats are:<ul>
 877    *                   <li>for daily restarts: "23:10" or "11:10 pm"</li>
 878    *                   <li>for weekly restarts: "sunday 11:10pm" or
 879    *                       "sun 11:10pm"</li>
 880    *                   </ul>
 881    *                   Can be <code>null</code> for non-cron processes.
 882    * @param notifier   the execution path to a notifier program that should
 883    *                   be called when the process terminates.  Can be
 884    *                   <code>null</code>
 885    * @exception AFSException  If an error occurs in the native code
 886    */
 887   protected static native void create( long serverHandle, String processName,
 888                                        int processType, String executionPath,
 889                                        String cronTime, String notifier )
 890     throws AFSException;
 891
 892   /**
 893    * Removes a process from a server.
 894    *
 895    * @param serverHandle  the bos handle of the server to which the process
 896    *                      belongs
 897    * @see Server#getBosServerHandle
 898    * @param processName   the name of the process to remove
 899    * @exception AFSException  If an error occurs in the native code
 900    */
 901   protected static native void delete( long serverHandle, String processName )
 902     throws AFSException;
 903
 904   /**
 905    * Start this process.
 906    *
 907    * @param serverHandle  the bos handle of the server to which the process
 908    *                      belongs
 909    * @see Server#getBosServerHandle
 910    * @param processName   the name of the process to start
 911    * @exception AFSException  If an error occurs in the native code
 912    */
 913   protected static native void start( long serverHandle, String processName )
 914     throws AFSException;
 915
 916   /**
 917    * Retart this process.
 918    *
 919    * @param serverHandle  the bos handle of the server to which the process
 920    *                      belongs
 921    * @see Server#getBosServerHandle
 922    * @param processName   the name of the process to restart
 923    * @exception AFSException  If an error occurs in the native code
 924    */
 925   protected static native void restart( long serverHandle, String processName )
 926     throws AFSException;
 927
 928   /**
 929    * Stop this process.
 930    *
 931    * @param serverHandle  the bos handle of the server to which the process
 932    *                      belongs
 933    * @see Server#getBosServerHandle
 934    * @param processName   the name of the process to stop
 935    * @exception AFSException  If an error occurs in the native code
 936    */
 937   protected static native void stop( long serverHandle, String processName )
 938     throws AFSException;
 939
 940   /**
 941    * Reclaims all memory being saved by the process portion of the native
 942    * library. This method should be called when no more <code>Process</code>
 943    * objects are expected to be used.
 944    */
 945   protected static native void reclaimProcessMemory();
 946 }
 947
 948
 949
 950
 951
 952
 953