JavaAdminAPI/AdminTest.java

   1 import org.openafs.jafs.ErrorTable;
   2 import java.io.*;
   3 import java.util.*;
   4
   5 /**
   6  * A common error testing class for the native methods
   7  */
   8
   9 public class AdminTest
  10 {
  11   Properties properties;
  12   String cellName = null;
  13   String username = null;
  14   String password = null;
  15
  16   org.openafs.jafs.Cell   cellHandle;
  17   org.openafs.jafs.Token  token;
  18
  19   /*
  20     static
  21     {
  22     try {
  23     System.loadLibrary("pwd");
  24     } catch (Exception e) {
  25     // Ignore
  26     }
  27     }
  28   */
  29
  30   AdminTest() throws Exception
  31   {
  32     InputStream in = new FileInputStream("adminTest.properties");
  33     if (in == null) throw new FileNotFoundException("adminTest.properties");
  34     properties = new Properties();
  35     properties.load(in);
  36     cellName = getProperty("cellName", cellName);
  37     //username = getProperty("username", username);
  38     //password = getProperty("password", password);
  39   }
  40   private String getProperty(String name, String dflt)
  41   {
  42     String p = properties.getProperty(name);
  43     return (p == null) ? dflt : p;
  44   }
  45   private int getProperty(String name, int dflt)
  46   {
  47     String p = properties.getProperty(name);
  48     if (p == null) {
  49       return dflt;
  50     } else {
  51       try {
  52         return Integer.parseInt(p);
  53       } catch (Exception e) {
  54         return dflt;
  55       }
  56     }
  57   }
  58
  59   private void authenticate() throws IOException
  60   {
  61     try {
  62       System.out.println("  [user: " + username + "@" + cellName + "]");
  63       token = new org.openafs.jafs.Token( username, password, cellName );
  64       cellHandle = new org.openafs.jafs.Cell( token );
  65     } catch ( org.openafs.jafs.AFSException e ) {
  66       System.out.println( "Unexpected Exception\n  Error: " + ErrorTable.getMessage(e.getErrorCode()) +
  67                           "\n  Cell: " + cellName + "\n  Username: " + username);
  68       return;
  69     }
  70   }
  71
  72   private void listCell() throws Exception
  73   {
  74     try {
  75       System.out.println("======================================");
  76       System.out.println("LISTING CELL INFO");
  77       System.out.println("Total Number of Users: " + cellHandle.getUserCount());
  78       System.out.println("Total Number of Groups: " + cellHandle.getGroupCount());
  79       System.out.println("Total Number of Servers: " + cellHandle.getServerCount());
  80       System.out.println("======================================");
  81     } catch (Exception e) {
  82       e.printStackTrace();
  83     }
  84   }
  85
  86   private void listUser(String name) throws Exception
  87   {
  88     if (name == null) {
  89       System.out.println("Name is null!");
  90       return;
  91     }
  92     org.openafs.jafs.User[] users = cellHandle.getUsers();
  93     try {
  94       System.out.println("Searching for user: " + name + "...");
  95       for (int i = 0; i < users.length; i++) {
  96         if (name.equals(users[i].getName())) {
  97           System.out.println("User found!\n");
  98           //System.out.println(users[i].getInfo());
  99           System.out.println(users[i].toString());
 100           System.out.println("Membership: " + users[i].getGroupMembershipCount());
 101           System.out.println("Groups Owned: " + users[i].getGroupsOwnedCount());
 102           return;
 103         }
 104       }
 105       System.out.println("User '" + name + "' could not be found!");
 106     } catch (Exception e) {
 107       e.printStackTrace();
 108     }
 109   }
 110
 111   private void listUsers() throws Exception
 112   {
 113     org.openafs.jafs.User[] users = cellHandle.getUsers();
 114     try {
 115       System.out.println("======================================");
 116       System.out.println("LISTING USERS");
 117       for (int i = 0; i < users.length; i++) {
 118         System.out.println("User " + i + " = " + users[i].getName());
 119       }
 120       System.out.println("======================================");
 121       System.out.println("Total Number of Users: " + users.length);
 122     } catch (Exception e) {
 123       e.printStackTrace();
 124     }
 125   }
 126
 127   private void listGroup(String name) throws Exception
 128   {
 129     if (name == null) {
 130       System.out.println("Name is null!");
 131       return;
 132     }
 133     org.openafs.jafs.Group[] groups = cellHandle.getGroups();
 134     try {
 135       System.out.println("Searching for group: " + name + "...");
 136       for (int i = 0; i < groups.length; i++) {
 137         if (name.equals(groups[i].getName())) {
 138           System.out.println("Group found!\n");
 139           groups[i].refresh();
 140           //System.out.println(groups[i].getInfo());
 141           System.out.println(groups[i].toString());
 142           System.out.println("Membership: " + groups[i].getMembershipCount());
 143           return;
 144         }
 145       }
 146       System.out.println("Group '" + name + "' could not be found!");
 147     } catch (Exception e) {
 148       e.printStackTrace();
 149     }
 150   }
 151
 152   private void listGroups() throws Exception
 153   {
 154     org.openafs.jafs.Group[] groups = cellHandle.getGroups();
 155     try {
 156       System.out.println("======================================");
 157       System.out.println("LISTING GROUPS");
 158       for (int i = 0; i < groups.length; i++) {
 159         System.out.println("Group " + i + " = " + groups[i].getName());
 160       }
 161       System.out.println("======================================");
 162       System.out.println("Total Number of Groups: " + groups.length);
 163     } catch (Exception e) {
 164       e.printStackTrace();
 165     }
 166   }
 167
 168   private void listGroupsX() throws Exception
 169   {
 170     org.openafs.jafs.Group[] groups = cellHandle.getGroups();
 171     try {
 172       System.out.println("======================================");
 173       System.out.println("LISTING GROUPS");
 174       for (int i = 0; i < groups.length; i++) {
 175         System.out.println("Group " + i + " = " + groups[i].getName());
 176       }
 177       System.out.println("======================================");
 178       System.out.println("Total Number of Groups: " + groups.length);
 179     } catch (Exception e) {
 180       e.printStackTrace();
 181     }
 182   }
 183
 184   private void listServer(String name) throws Exception
 185   {
 186     if (name == null) {
 187       System.out.println("Name is null!");
 188       return;
 189     }
 190     org.openafs.jafs.Server[] servers = cellHandle.getServers();
 191     try {
 192       System.out.println("Searching for server: " + name + "...");
 193       for (int i = 0; i < servers.length; i++) {
 194         if (name.equals(servers[i].getName())) {
 195           System.out.println("Server found!\n");
 196           //System.out.println(servers[i].getInfo());
 197           System.out.println(servers[i].toString());
 198           System.out.println("# of Partition: " + servers[i].getPartitionCount());
 199           System.out.println("# of Admins: " + servers[i].getAdminCount());
 200           System.out.println("# of Keys: " + servers[i].getKeyCount());
 201           System.out.println("# of Processes: " + servers[i].getProcessCount());
 202           System.out.println("# of IP Addresses: " + servers[i].getIPAddresses().length);
 203           for (int x = 0; x < servers[i].getIPAddresses().length; x++) {
 204             System.out.println(" -> IP " + x + ": " + servers[i].getIPAddresses()[x]);
 205           }
 206           return;
 207         }
 208       }
 209       System.out.println("Server '" + name + "' could not be found!");
 210     } catch (org.openafs.jafs.AFSException e) {
 211       System.out.println("ERROR: " + ErrorTable.getMessage(e.getErrorCode()));
 212     } catch (Exception e) {
 213       e.printStackTrace();
 214     }
 215   }
 216
 217   private void listServers() throws Exception
 218   {
 219     org.openafs.jafs.Server[] servers = cellHandle.getServers();
 220     try {
 221       System.out.println("======================================");
 222       System.out.println("LISTING SERVERS");
 223       for (int i = 0; i < servers.length; i++) {
 224         System.out.println("Server " + i + " = " + servers[i].toString());
 225       }
 226       System.out.println("======================================");
 227       System.out.println("Total Number of Servers: " + servers.length);
 228     } catch (Exception e) {
 229       e.printStackTrace();
 230     }
 231   }
 232
 233
 234   private void listPartition(String name) throws Exception
 235   {
 236     if (name == null) {
 237       System.out.println("Name is null!");
 238       return;
 239     }
 240     org.openafs.jafs.Server[] servers = cellHandle.getServers();
 241     try {
 242       System.out.println("Searching for partition: " + name + "...");
 243       for (int i = 0; i < servers.length; i++) {
 244         System.out.println("  Server " + i + " = " + servers[i].getName());
 245         if (!servers[i].isFileServer() || servers[i].isBadFileServer()) {
 246           System.out.println("  (not a file server)");
 247         } else {
 248           org.openafs.jafs.Partition[] partitions = servers[i].getPartitions();
 249           for (int p = 0; p < partitions.length; p++) {
 250             if (name.equals(partitions[p].getName())) {
 251               System.out.println("Partition found!\n");
 252               //System.out.println(partitions[p].getInfo());
 253               System.out.println(partitions[p].toString());
 254               System.out.println("Volume count: " + partitions[i].getVolumeCount());
 255             }
 256           }
 257         }
 258       }
 259       System.out.println("Done");
 260     } catch (Exception e) {
 261       e.printStackTrace();
 262     }
 263   }
 264
 265   private void listPartitions() throws Exception
 266   {
 267     int n = 0;
 268     org.openafs.jafs.Server[] servers = cellHandle.getServers();
 269     try {
 270       System.out.println("======================================");
 271       System.out.println("LISTING PARTITIONS");
 272       for (int i = 0; i < servers.length; i++) {
 273         System.out.println("Server " + i + " = " + servers[i].getName());
 274         if (!servers[i].isFileServer() || servers[i].isBadFileServer()) {
 275           System.out.println("  (not a file server)");
 276         } else {
 277           org.openafs.jafs.Partition[] partitions = servers[i].getPartitions();
 278           n += partitions.length;
 279           for (int p = 0; p < partitions.length; p++) {
 280             System.out.println("  Partition " + p + " = " + partitions[p].toString());
 281           }
 282         }
 283       }
 284       System.out.println("======================================");
 285       System.out.println("Total Number of Servers: " + servers.length);
 286       System.out.println("Total Number of Partitions: " + n);
 287     } catch (Exception e) {
 288       e.printStackTrace();
 289     }
 290   }
 291
 292   /*
 293     private void enumeratePartitions(String serverName, int start, int end) throws Exception
 294     {
 295     int i = 1;
 296     org.openafs.jafs.Server server = cellHandle.getServer(serverName);
 297     try {
 298     System.out.println("======================================");
 299     System.out.println("ENUMERATING PARTITIONS FROM " + start + " to " + end);
 300     Enumeration e = server.getPartitionEnumeration();
 301
 302     i = start;
 303     while (e.hasMoreElements()) {
 304     System.out.println(" " + i + " -> " + e.nextElement());
 305     i++;
 306     //if (i >= end) break;
 307     }
 308
 309     System.out.println("======================================");
 310     } catch (Exception e) {
 311     e.printStackTrace();
 312     }
 313     }
 314   */
 315
 316   private void listVolume(String name) throws Exception
 317   {
 318     if (name == null) {
 319       System.out.println("Name is null!");
 320       return;
 321     }
 322     org.openafs.jafs.Server[] servers = cellHandle.getServers();
 323     try {
 324       System.out.println("Searching for volume: " + name + "...");
 325       for (int i = 0; i < servers.length; i++) {
 326         System.out.println("  Server " + i + " = " + servers[i].getName());
 327         if (!servers[i].isFileServer() || servers[i].isBadFileServer()) {
 328           System.out.println("  (not a file server)");
 329         } else {
 330           org.openafs.jafs.Partition[] partitions = servers[i].getPartitions();
 331           for (int p = 0; p < partitions.length; p++) {
 332             System.out.println("    Partition " + p + " = " + partitions[p].getName());
 333             org.openafs.jafs.Volume[] volumes = partitions[p].getVolumes();
 334             for (int v = 0; v < volumes.length; v++) {
 335               if (name.equals(volumes[v].getName())) {
 336                 System.out.println("        Volume found!\n");
 337                 //System.out.println(volumes[v].getInfo());
 338                 System.out.println(volumes[v].toString());
 339                 System.out.println("Quota: " + volumes[v].getQuota());
 340               }
 341             }
 342           }
 343         }
 344       }
 345       System.out.println("Done");
 346     } catch (Exception e) {
 347       e.printStackTrace();
 348     }
 349   }
 350
 351   private void listVolumes() throws Exception
 352   {
 353     int nP = 0;
 354     int nV = 0;
 355     org.openafs.jafs.Server[] servers = cellHandle.getServers();
 356     try {
 357       System.out.println("======================================");
 358       System.out.println("LISTING PARTITIONS");
 359       for (int i = 0; i < servers.length; i++) {
 360         System.out.println("Server " + i + " = " + servers[i].getName());
 361         if (!servers[i].isFileServer() || servers[i].isBadFileServer()) {
 362           System.out.println("  (not a file server)");
 363         } else {
 364           org.openafs.jafs.Partition[] partitions = servers[i].getPartitions();
 365           nP += partitions.length;
 366           for (int p = 0; p < partitions.length; p++) {
 367             System.out.println("  Partition " + p + " = " + partitions[p].getName());
 368             org.openafs.jafs.Volume[] volumes = partitions[p].getVolumes();
 369             nV += volumes.length;
 370             for (int v = 0; v < volumes.length; v++) {
 371               System.out.println("    Volume " + v + " = " + volumes[v].getName());
 372             }
 373           }
 374         }
 375       }
 376       System.out.println("======================================");
 377       System.out.println("Total Number of Servers: " + servers.length);
 378       System.out.println("Total Number of Partitions: " + nP);
 379       System.out.println("Total Number of Volumes: " + nV);
 380     } catch (Exception e) {
 381       e.printStackTrace();
 382     }
 383   }
 384
 385   /*
 386     private void enumerateVolumes(String serverName, String partitionName, int start, int length) throws Exception
 387     {
 388     int i = 1;
 389     int n = 0;
 390     org.openafs.jafs.Server server = cellHandle.getServer(serverName);
 391     org.openafs.jafs.Partition partition = server.getPartition(partitionName);
 392     try {
 393     System.out.println("======================================");
 394     System.out.println("ENUMERATING PARTITIONS FROM " + start + " to " + (start + length));
 395     Enumeration e = partition.getVolumeEnumeration(start);
 396
 397     i = start;
 398     while (e.hasMoreElements()) {
 399     System.out.println(" " + i + " -> " + e.nextElement());
 400     i++;
 401     n++;
 402     if (n >= length) break;
 403     }
 404
 405     System.out.println("======================================");
 406     } catch (Exception e) {
 407     e.printStackTrace();
 408     }
 409     }
 410   */
 411
 412   private void listProcess(String name) throws Exception
 413   {
 414     if (name == null) {
 415       System.out.println("Name is null!");
 416       return;
 417     }
 418     org.openafs.jafs.Server[] servers = cellHandle.getServers();
 419     try {
 420       System.out.println("Searching for process: " + name + "...");
 421       for (int i = 0; i < servers.length; i++) {
 422         System.out.println("  Server " + i + " = " + servers[i].getName());
 423         org.openafs.jafs.Process[] processes = servers[i].getProcesses();
 424         for (int p = 0; p < processes.length; p++) {
 425           if (name.equals(processes[p].getName())) {
 426             System.out.println("Process found!\n");
 427             //System.out.println(processes[p].getInfo());
 428             System.out.println(processes[p].toString());
 429           }
 430         }
 431       }
 432       System.out.println("Done");
 433     } catch (Exception e) {
 434       e.printStackTrace();
 435     }
 436   }
 437
 438   private void listProcesses() throws Exception
 439   {
 440     int n = 0;
 441     org.openafs.jafs.Server[] servers = cellHandle.getServers();
 442     try {
 443       System.out.println("======================================");
 444       System.out.println("LISTING PROCESSES");
 445       for (int i = 0; i < servers.length; i++) {
 446         System.out.println("Server " + i + " = " + servers[i].getName());
 447         org.openafs.jafs.Process[] processes = servers[i].getProcesses();
 448         n += processes.length;
 449         for (int p = 0; p < processes.length; p++) {
 450           System.out.println("  Process " + p + " = " + processes[p].getName());
 451         }
 452       }
 453       System.out.println("======================================");
 454       System.out.println("Total Number of Servers: " + servers.length);
 455       System.out.println("Total Number of Processes: " + n);
 456     } catch (Exception e) {
 457       e.printStackTrace();
 458     }
 459   }
 460
 461   private void listACL(String path) throws Exception
 462   {
 463     try {
 464       System.out.println("======================================");
 465       System.out.println("LISTING ACL for: \n\t" + path);
 466
 467       token.klog();
 468       org.openafs.jafs.ACL acl = new org.openafs.jafs.ACL(path);
 469       System.out.println(acl.toString());
 470
 471       System.out.println("======================================");
 472     } catch (org.openafs.jafs.AFSException e) {
 473       System.out.println("AFS Error: " + e.getMessage());
 474     } catch (Exception e) {
 475       e.printStackTrace();
 476     }
 477   }
 478
 479   private void setACL(String path) throws Exception
 480   {
 481     try {
 482       System.out.println("======================================");
 483       System.out.println("SETTING ACL for: \n\t" + path);
 484
 485       token.klog();
 486
 487       org.openafs.jafs.ACL acl = new org.openafs.jafs.ACL(path);
 488       System.out.println(acl.toString());
 489
 490       org.openafs.jafs.ACL.Entry entry = new org.openafs.jafs.ACL.Entry( username, 29 );
 491       acl.addPositiveEntry(entry);
 492
 493       System.out.println("Adding ACL entry: " + entry + "\n");
 494       System.out.println("ACL after modifications:");
 495       System.out.println(acl.toString());
 496
 497       System.out.println("======================================");
 498     } catch (org.openafs.jafs.AFSException e) {
 499       System.out.println("AFS Error: " + e.getMessage());
 500     } catch (Exception e) {
 501       e.printStackTrace();
 502     }
 503   }
 504
 505   private void listDir(String path) throws Exception
 506   {
 507     try {
 508       System.out.println("======================================");
 509       System.out.println("LISTING Directory for: \n\t" + path);
 510
 511       token.klog();
 512
 513       org.openafs.jafs.File file = new org.openafs.jafs.File(path);
 514       String[] e = file.list();
 515       if ( e == null ) {
 516         System.out.println( file.getErrorMessage() );
 517       } else {
 518         for (int i = 0; i < e.length; i++) {
 519           System.out.println(e[i]);
 520         }
 521       }
 522
 523       System.out.println("======================================");
 524     } catch (org.openafs.jafs.AFSSecurityException e) {
 525       System.out.println("AFS Security Error: " + e.getMessage());
 526     } catch (org.openafs.jafs.AFSException e) {
 527       System.out.println("AFS Error: " + e.getMessage());
 528     } catch (Exception e) {
 529       e.printStackTrace();
 530     }
 531   }
 532
 533   private void setUserGroupQuota() throws Exception
 534   {
 535     org.openafs.jafs.User user = cellHandle.getUser( username );
 536     try {
 537       System.out.println("======================================");
 538       System.out.println("SETTING GROUP QUOTA FOR " + user.getName());
 539       user.setGroupCreationQuota(-1);
 540       user.setGroupCreationQuota(20);
 541       user.setGroupCreationQuota(0);
 542       System.out.println("======================================");
 543     } catch (Exception e) {
 544       e.printStackTrace();
 545     }
 546   }
 547
 548   private void salvage(String name, String serverName, String partitionName) throws Exception
 549   {
 550     org.openafs.jafs.Server server = cellHandle.getServer(serverName);
 551     org.openafs.jafs.Partition partition = server.getPartition(partitionName);
 552     org.openafs.jafs.Volume volume = partition.getVolume(name);
 553     try {
 554       System.out.println("======================================");
 555       System.out.println("SALVAGING VOLUME " + volume.getName());
 556       volume.salvage();
 557       System.out.println("======================================");
 558     } catch (Exception e) {
 559       e.printStackTrace();
 560     }
 561   }
 562
 563   private void release(String name, String serverName, String partitionName) throws Exception
 564   {
 565     org.openafs.jafs.Server server = cellHandle.getServer(serverName);
 566     org.openafs.jafs.Partition partition = server.getPartition(partitionName);
 567     org.openafs.jafs.Volume volume = partition.getVolume(name);
 568     try {
 569       System.out.println("======================================");
 570       System.out.println("RELEASING VOLUME " + volume.getName());
 571       volume.release();
 572       System.out.println("======================================");
 573     } catch (Exception e) {
 574       e.printStackTrace();
 575     }
 576   }
 577
 578   private void createReadOnly(String name, String serverName, String partitionName) throws Exception
 579   {
 580     org.openafs.jafs.Server server = cellHandle.getServer(serverName);
 581     org.openafs.jafs.Partition partition = server.getPartition(partitionName);
 582     org.openafs.jafs.Volume volume = partition.getVolume(name);
 583     try {
 584       System.out.println("======================================");
 585       System.out.println("CREATING READ-ONLY REPLICA OF VOLUME " + volume.getName());
 586       //volume.createReadOnly(cellHandle.getServer(server), cellHandle.getPartition(server, partition));
 587       //volume.create( cellHandle, vosHandle, -1, newVolumeName, 0 );
 588       volume.createReadOnly(partition);
 589       System.out.println("======================================");
 590     } catch (Exception e) {
 591       e.printStackTrace();
 592     }
 593   }
 594
 595   private void createBackup(String name, String serverName, String partitionName) throws Exception
 596   {
 597     org.openafs.jafs.Server server = cellHandle.getServer(serverName);
 598     org.openafs.jafs.Partition partition = server.getPartition(partitionName);
 599     org.openafs.jafs.Volume volume = partition.getVolume(name);
 600     try {
 601       System.out.println("======================================");
 602       System.out.println("CREATING BACKUP REPLICA OF VOLUME " + volume.getName());
 603       volume.createBackup();
 604       System.out.println("======================================");
 605     } catch (Exception e) {
 606       e.printStackTrace();
 607     }
 608   }
 609
 610   /**
 611    * execute:
 612    * takes in String representing a system command, executes it,
 613    * and waits for it to finish.
 614    *
 615    * throws IOException
 616    */
 617   private void execute( String command ) throws IOException
 618   {
 619     //System.out.println( "Executing: " + command );
 620     java.lang.Process proc = Runtime.getRuntime().exec( command );
 621     //      System.out.println( command );
 622     try {
 623       proc.waitFor();
 624     } catch ( InterruptedException e ) {
 625       throw new IOException( "Interrupted system command: " + command );
 626     }
 627   }
 628
 629   private void printVersionInfo() throws Exception
 630   {
 631     System.out.println("JAFS native library build information:");
 632     System.out.println("\tDescription:    " + org.openafs.jafs.VersionInfo.getDescription());
 633     System.out.println("\tBuild Platform: " + org.openafs.jafs.VersionInfo.getBuildPlatform());
 634     System.out.println("\tBuild Time:     " + org.openafs.jafs.VersionInfo.getBuildDate());
 635     System.out.println("\tBuild Number:   " + org.openafs.jafs.VersionInfo.getBuildNumber());
 636     System.out.println("\tBuild Version:  " + org.openafs.jafs.VersionInfo.getVersion());
 637     System.out.println("\tFull Version:   " + org.openafs.jafs.VersionInfo.getFullVersion());
 638   }
 639
 640   /**
 641    * Get password from native library
 642    */
 643   //private static native String getNativePassword();
 644
 645   private static String getPassword() throws IOException
 646   {
 647     String pwd = "";
 648     MaskingThread mt = new MaskingThread( "Please enter your AFS password: " );
 649     Thread t = new Thread( mt );
 650     t.start();
 651
 652     while (true) {
 653       char c = (char)System.in.read();
 654       mt.stopMasking();
 655       if ( c == '\r' ) {
 656         c = (char) System.in.read();
 657         if ( c == '\n' ) {
 658           break;
 659         } else {
 660           continue;
 661         }
 662       } else if ( c == '\n' ) {
 663         break;
 664       } else {
 665         pwd += c;
 666       }
 667     }
 668     return pwd;
 669   }
 670
 671   private static String getUsername()
 672   {
 673     System.out.print("Please enter your AFS username: ");
 674     BufferedReader r = new BufferedReader( new InputStreamReader(System.in) );
 675     try {
 676       return r.readLine();
 677     } catch (Exception e) {
 678       System.out.println("Error trying to read your username.");
 679       System.exit(1);
 680     }
 681     return null;
 682   }
 683
 684   private static void printUsage()
 685   {
 686     System.out.println("Usage:");
 687     System.out.println("  AdminTest [auth] [cell] [user] [group] [server]");
 688     System.out.println("            [partition] [volume] [key] [process]");
 689     System.out.println("");
 690     System.out.println("  AdminTest [list users]      [list user <username>]");
 691     System.out.println("            [list groups]     [list group <group name>]");
 692     System.out.println("            [list servers]    [list server <server name>]");
 693     System.out.println("            [list partitions] [list partition <partition name>]");
 694     System.out.println("            [list volumes]    [list volume <volume name>]");
 695     System.out.println("            [list processes]  [list process <process name>]");
 696     System.out.println("            [list cell]");
 697     System.out.println("            [list dir <path>]");
 698     System.out.println("            [list acl <path>]");
 699     System.out.println("            [set  acl <path>]");
 700     System.out.println("            [enum partitions <server> <start> <length>]");
 701     System.out.println("            [enum volumes <server> <partition> <start> <length>]");
 702     System.out.println("            [vol salvage <volume name> <server> <partition>]");
 703     System.out.println("            [vol backup <volume name> <server> <partition>]");
 704     System.out.println("            [vol release <volume name> <server> <partition>]");
 705     System.out.println("            [vol replicate <volume name> <server> <partition>]");
 706     System.out.println("");
 707     System.out.println("            -v or -version     Display version of JAFS library");
 708     System.out.println("");
 709     System.out.println("            -u <username>");
 710     System.out.println("            -p <password>");
 711     System.out.println("");
 712     System.out.println("Example:");
 713     System.out.println("  AdminTest list users -u admin -p testpass");
 714     System.out.println("\nie: AdminTest cell\nThe above example will run the AdminTest program,\ntesting 'cell' functionality.");
 715   }
 716   public static void main(String[] args) throws Exception
 717   {
 718     AdminTest at = new AdminTest();
 719     try {
 720       for (int i = 0; i < args.length; i++) {
 721         if (args[i].startsWith("-h") || args[i].startsWith("h")) {
 722           printUsage();
 723           System.exit(0);
 724         } else if (args[i].equals("-u")) {
 725           i++;
 726           at.username = args[i];
 727         } else if (args[i].equals("-p")) {
 728           i++;
 729           at.password = args[i];
 730         } else if (args[i].equals("-g") || args[i].equals("--graphical")) {
 731           i++;
 732           PasswordPrompt p = new PasswordPrompt("AFS Admin Account");
 733
 734           String[] info = new String[2];
 735           while ( p.isShowing() ) {
 736             Thread.sleep( 500 );
 737           }
 738           try {
 739             p.setUserInfo( info );
 740             at.username = info[0];
 741             at.password = info[1];
 742           } catch (Exception e2) {
 743             // Ignore
 744           }
 745         } else if (args[i].equals("-v") || args[i].equals("-version")) {
 746           at.authenticate();
 747           at.printVersionInfo();
 748           return;
 749         }
 750       }
 751
 752       if ( at.username == null ) at.username = getUsername();
 753       if ( at.password == null ) at.password = getPassword();
 754
 755       at.authenticate();
 756
 757       if ( args.length > 0 ) run( at, args );
 758
 759       while( true )
 760         {
 761           System.out.print("Command: ");
 762           BufferedReader r = new BufferedReader( new InputStreamReader(System.in) );
 763           try {
 764             run( at, split( r.readLine() ) );
 765           } catch (Exception e) {
 766             System.out.println("Error trying to read command.");
 767           }
 768         }
 769
 770     } catch (ArrayIndexOutOfBoundsException e) {
 771       printUsage();
 772     }
 773   }
 774   private static void run( AdminTest at, String[] args ) throws Exception
 775   {
 776     try {
 777       for (int i = 0; i < args.length; i++) {
 778         if (args[i].equals("auth")) {
 779           System.out.println("not available");
 780           /*
 781             } else if (args[i].equals("enum")) {
 782             i++;
 783             if (args[i].equals("partitions")) {
 784             String serverName = args[i++];
 785             int start = Integer.parseInt(args[i++]);
 786             int end = Integer.parseInt(args[i++]);
 787             at.enumeratePartitions(serverName, start, end);
 788             } else if (args[i].equals("volumes")) {
 789             String serverName = args[++i];
 790             String partitionName = args[++i];
 791             int start = Integer.parseInt(args[++i]);
 792             int end = Integer.parseInt(args[++i]);
 793             at.enumerateVolumes(serverName, partitionName, start, end);
 794             }
 795           */
 796         } else if (args[i].equals("list")) {
 797           i++;
 798           if (args[i].equals("users")) {
 799             at.listUsers();
 800           } else if (args[i].equals("user")) {
 801             i++;
 802             at.listUser(args[i]);
 803           } else if (args[i].equals("groups")) {
 804             at.listGroups();
 805           } else if (args[i].equals("groupsx")) {
 806             at.listGroupsX();
 807           } else if (args[i].equals("group")) {
 808             i++;
 809             at.listGroup(args[i]);
 810           } else if (args[i].equals("servers")) {
 811             at.listServers();
 812           } else if (args[i].equals("server")) {
 813             i++;
 814             at.listServer(args[i]);
 815           } else if (args[i].equals("partitions")) {
 816             at.listPartitions();
 817           } else if (args[i].equals("partition")) {
 818             i++;
 819             at.listPartition(args[i]);
 820           } else if (args[i].equals("volumes")) {
 821             at.listVolumes();
 822           } else if (args[i].equals("volume")) {
 823             i++;
 824             at.listVolume(args[i]);
 825           } else if (args[i].equals("processes")) {
 826             at.listProcesses();
 827           } else if (args[i].equals("process")) {
 828             i++;
 829             at.listProcess(args[i]);
 830           } else if (args[i].equals("cell")) {
 831             at.listCell();
 832           } else if (args[i].equals("acl")) {
 833             i++;
 834             at.listACL(args[i]);
 835           } else if (args[i].equals("dir")) {
 836             i++;
 837             at.listDir(args[i]);
 838           }
 839         } else if (args[i].equals("set")) {
 840           i++;
 841           if (args[i].equals("user")) {
 842             i++;
 843             if (args[i].equals("group-quota")) {
 844               at.setUserGroupQuota();
 845             }
 846           } else if (args[i].equals("group")) {
 847           } else if (args[i].equals("acl")) {
 848             i++;
 849             at.setACL(args[i]);
 850           }
 851         } else if (args[i].equals("vol")) {
 852           i++;
 853           if (args[i].equals("salvage")) {
 854             i++;
 855             String name = args[i];
 856             i++;
 857             String server = args[i];
 858             i++;
 859             String partition = args[i];
 860             at.salvage(name, server, partition);
 861           } else if (args[i].equals("backup")) {
 862             i++;
 863             String name = args[i];
 864             i++;
 865             String server = args[i];
 866             i++;
 867             String partition = args[i];
 868             at.createBackup(name, server, partition);
 869           } else if (args[i].equals("release")) {
 870             i++;
 871             String name = args[i];
 872             i++;
 873             String server = args[i];
 874             i++;
 875             String partition = args[i];
 876             at.release(name, server, partition);
 877           } else if (args[i].equals("replicate")) {
 878             i++;
 879             String name = args[i];
 880             i++;
 881             String server = args[i];
 882             i++;
 883             String partition = args[i];
 884             at.createReadOnly(name, server, partition);
 885           }
 886         } else if (args[i].equals("cell")) {
 887           //at.testCell();
 888           System.out.println("Not Available");
 889         } else if (args[i].equals("user")) {
 890           //at.testUser();
 891           System.out.println("Not Available");
 892         } else if (args[i].equals("group")) {
 893           //at.testGroup();
 894           System.out.println("Not Available");
 895         } else if (args[i].equals("server")) {
 896           //at.testServer();
 897           System.out.println("Not Available");
 898         } else if (args[i].equals("partition") || args[i].equals("part")) {
 899           //at.testPartition();
 900           System.out.println("Not Available");
 901         } else if (args[i].equals("volume")) {
 902           //at.testVolume();
 903           System.out.println("Not Available");
 904         } else if (args[i].equals("key")) {
 905           //at.testKey();
 906           System.out.println("Not Available");
 907         } else if (args[i].equals("process") || args[i].equals("proc")) {
 908           //at.testProcess();
 909           System.out.println("Not Available");
 910         } else if (args[i].equals("h") || args[i].equals("help")) {
 911           printUsage();
 912         } else if (args[i].equals("q") || args[i].equals("quit")) {
 913           System.exit(0);
 914         } else if (args[i].equals("-u") || args[i].equals("-p")) {
 915           i++;
 916         } else if (args[i].equals("-g") || args[i].equals("--graphical")) {
 917           i++;
 918         } else {
 919           System.out.println("Invalid Argument: " + args[i]);
 920         }
 921       }
 922     } catch (ArrayIndexOutOfBoundsException e) {
 923       printUsage();
 924     }
 925   }
 926
 927   private static String[] split( String str )
 928   {
 929     int i = 0;
 930     StringTokenizer st = new StringTokenizer(str);
 931     String[] tokens = new String[st.countTokens()];
 932     while (st.hasMoreTokens())  {
 933       tokens[i++] = st.nextToken().trim();
 934     }
 935     return tokens;
 936   }
 937
 938   private static class MaskingThread extends Thread
 939   {
 940     private boolean stop = false;
 941     private int index;
 942     private String prompt;
 943
 944     public MaskingThread( String prompt )
 945     {
 946       this.prompt = prompt;
 947     }
 948     public void run()
 949     {
 950       while ( !stop )
 951         {
 952           try {
 953             MaskingThread.sleep(1);
 954           } catch (InterruptedException e ) {
 955             e.printStackTrace();
 956           }
 957           if ( !stop ) {
 958             System.out.print("\r" + prompt );
 959           }
 960           System.out.flush();
 961         }
 962     }
 963     public void stopMasking()
 964     {
 965       this.stop = true;
 966     }
 967   }
 968
 969 }