001 /* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2007-2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.admin.client.cli; 028 import org.opends.messages.Message; 029 import org.opends.messages.MessageBuilder; 030 031 import static org.opends.messages.AdminMessages.*; 032 import static org.opends.messages.DSConfigMessages.*; 033 import static org.opends.messages.ToolMessages.*; 034 import static org.opends.server.tools.ToolConstants.*; 035 036 import java.io.OutputStream; 037 import java.io.PrintStream; 038 import java.util.ArrayList; 039 import java.util.HashMap; 040 import java.util.HashSet; 041 import java.util.LinkedList; 042 import java.util.List; 043 import java.util.Map; 044 import java.util.Set; 045 046 import javax.naming.NamingException; 047 import javax.naming.ldap.InitialLdapContext; 048 049 import org.opends.admin.ads.ADSContext; 050 import org.opends.admin.ads.ADSContextException; 051 import org.opends.admin.ads.ADSContext.AdministratorProperty; 052 import org.opends.admin.ads.ADSContextException.ErrorType; 053 import org.opends.server.tools.dsconfig.ArgumentExceptionFactory; 054 import org.opends.server.types.Privilege; 055 import org.opends.server.util.args.Argument; 056 import org.opends.server.util.args.ArgumentException; 057 import org.opends.server.util.args.BooleanArgument; 058 import org.opends.server.util.args.StringArgument; 059 import org.opends.server.util.args.SubCommand; 060 import org.opends.server.util.table.TableBuilder; 061 import org.opends.server.util.table.TextTablePrinter; 062 063 import static org.opends.server.admin.client.cli.DsFrameworkCliReturnCode.*; 064 /** 065 * This class is handling user Admin CLI. 066 */ 067 public class DsFrameworkCliGlobalAdmin implements DsFrameworkCliSubCommandGroup 068 { 069 // Strings used in property help. 070 private final static Message DESCRIPTION_OPTIONS_TITLE = 071 INFO_DSCFG_HELP_DESCRIPTION_OPTION.get(); 072 073 private final static Message DESCRIPTION_OPTIONS_READ = 074 INFO_DSCFG_HELP_DESCRIPTION_READ.get(); 075 076 private final static Message DESCRIPTION_OPTIONS_WRITE = 077 INFO_DSCFG_HELP_DESCRIPTION_WRITE.get(); 078 079 private final static Message DESCRIPTION_OPTIONS_MANDATORY = 080 INFO_DSCFG_HELP_DESCRIPTION_MANDATORY.get(); 081 082 private final static Message DESCRIPTION_OPTIONS_SINGLE = 083 INFO_DSCFG_HELP_DESCRIPTION_SINGLE_VALUED.get(); 084 085 /** 086 * The subcommand Parser. 087 */ 088 private DsFrameworkCliParser argParser; 089 090 /** 091 * The verbose argument. 092 */ 093 private BooleanArgument verboseArg; 094 095 /** 096 * The enumeration containing the different subCommand names. 097 */ 098 private enum SubCommandNameEnum 099 { 100 /** 101 * The create-admin-user subcommand. 102 */ 103 CREATE_ADMIN_USER("create-admin-user"), 104 105 /** 106 * The delete-admin-user subcommand. 107 */ 108 DELETE_ADMIN_USER("delete-admin-user"), 109 110 /** 111 * The list-admin-user subcommand. 112 */ 113 LIST_ADMIN_USER("list-admin-user"), 114 115 /** 116 * The list-admin-user-properties subcommand. 117 */ 118 LIST_ADMIN_USER_PROPERTIES("list-admin-user-properties"), 119 120 /** 121 * The get-admin-user-properties subcommand. 122 */ 123 GET_ADMIN_USER_PROPERTIES("get-admin-user-properties"), 124 125 /** 126 * The set-admin-user-properties subcommand. 127 */ 128 SET_ADMIN_USER_PROPERTIES("set-admin-user-properties"); 129 130 131 // String representation of the value. 132 private final String name; 133 134 // Private constructor. 135 private SubCommandNameEnum(String name) 136 { 137 this.name = name; 138 } 139 140 /** 141 * {@inheritDoc} 142 */ 143 public String toString() 144 { 145 return name; 146 } 147 148 // A lookup table for resolving a unit from its name. 149 private static final List<String> nameToSubCmdName; 150 static 151 { 152 nameToSubCmdName = new ArrayList<String>(); 153 154 for (SubCommandNameEnum subCmd : SubCommandNameEnum.values()) 155 { 156 nameToSubCmdName.add(subCmd.toString()); 157 } 158 } 159 160 public static boolean isSubCommand(String name) 161 { 162 return nameToSubCmdName.contains(name); 163 } 164 } 165 166 /** 167 * The create-admin-user subcommand. 168 */ 169 private SubCommand createAdminUserSubCmd; 170 171 /** 172 * The 'userID' argument of the 'create-admin-user' subcommand. 173 */ 174 private StringArgument createAdminUserUserIdArg; 175 176 /** 177 * The 'set' argument of the 'create-admin-user' subcommand. 178 */ 179 private StringArgument createAdminUserSetArg ; 180 181 /** 182 * The delete-admin-user subcommand. 183 */ 184 private SubCommand deleteAdminUserSubCmd; 185 186 /** 187 * The 'userID' argument of the 'delete-admin-user' subcommand. 188 */ 189 private StringArgument deleteAdminUserUserIdArg; 190 191 /** 192 * The list-admin-user subcommand. 193 */ 194 private SubCommand listAdminUserSubCmd; 195 196 /** 197 * The get-admin-user-properties subcommand. 198 */ 199 private SubCommand getAdminUserPropertiesSubCmd; 200 201 /** 202 * The 'userID' argument of the 'get-admin-user-properties' subcommand. 203 */ 204 private StringArgument getAdminUserPropertiesUserIdArg; 205 206 /** 207 * The set-admin-user-properties subcommand. 208 */ 209 private SubCommand setAdminUserPropertiesSubCmd; 210 211 /** 212 * The 'userID' argument of the 'set-admin-user-properties' subcommand. 213 */ 214 private StringArgument setAdminUserPropertiesUserIdArg; 215 216 /** 217 * The 'set' argument of the 'set-admin-user-properties' subcommand. 218 */ 219 private StringArgument setAdminUserPropertiesSetArg; 220 221 222 /** 223 * The list-admin-user-properties subcommand. 224 */ 225 private SubCommand listAdminUserPropertiesSubCmd; 226 227 /** 228 * Association between ADSContext enum and properties. 229 */ 230 private HashMap<AdministratorProperty, Argument> userAdminProperties; 231 232 /** 233 * List of read-only server properties. 234 */ 235 private HashSet<AdministratorProperty> readonlyadminUserProperties; 236 237 238 /** 239 * The subcommand list. 240 */ 241 private HashSet<SubCommand> subCommands = new HashSet<SubCommand>(); 242 243 /** 244 * Indicates whether this subCommand should be hidden in the usage 245 * information. 246 */ 247 private boolean isHidden; 248 249 /** 250 * The subcommand group name. 251 */ 252 private String groupName; 253 254 /** 255 * {@inheritDoc} 256 */ 257 public Set<SubCommand> getSubCommands() 258 { 259 return subCommands; 260 } 261 262 /** 263 * {@inheritDoc} 264 */ 265 public boolean isHidden() 266 { 267 return isHidden; 268 } 269 270 /** 271 * {@inheritDoc} 272 */ 273 public String getGroupName() 274 { 275 return groupName; 276 } 277 278 /** 279 * {@inheritDoc} 280 */ 281 public void initializeCliGroup(DsFrameworkCliParser argParser, 282 BooleanArgument verboseArg) throws ArgumentException 283 { 284 this.verboseArg = verboseArg; 285 isHidden = false; 286 groupName = "admin-user"; 287 this.argParser = argParser; 288 289 // create-admin-user subcommand. 290 createAdminUserSubCmd = new SubCommand(argParser, 291 SubCommandNameEnum.CREATE_ADMIN_USER.toString(), 292 INFO_ADMIN_SUBCMD_CREATE_ADMIN_USER_DESCRIPTION.get()); 293 subCommands.add(createAdminUserSubCmd); 294 295 createAdminUserUserIdArg = new StringArgument("userID", null, 296 OPTION_LONG_USERID, false, true, INFO_USERID_PLACEHOLDER.get(), 297 INFO_ADMIN_ARG_USERID_DESCRIPTION.get()); 298 createAdminUserSubCmd.addArgument(createAdminUserUserIdArg); 299 300 createAdminUserSetArg = new StringArgument(OPTION_LONG_SET, 301 OPTION_SHORT_SET, OPTION_LONG_SET, false, true, true, 302 INFO_VALUE_SET_PLACEHOLDER.get(), null, null, 303 INFO_DSCFG_DESCRIPTION_PROP_VAL.get()); 304 createAdminUserSubCmd.addArgument(createAdminUserSetArg); 305 306 // delete-admin-user subcommand. 307 deleteAdminUserSubCmd = new SubCommand(argParser, 308 SubCommandNameEnum.DELETE_ADMIN_USER.toString(), 309 INFO_ADMIN_SUBCMD_DELETE_ADMIN_USER_DESCRIPTION.get()); 310 subCommands.add(deleteAdminUserSubCmd); 311 312 deleteAdminUserUserIdArg = new StringArgument("userID", null, 313 OPTION_LONG_USERID, false, true, INFO_USERID_PLACEHOLDER.get(), 314 INFO_ADMIN_ARG_USERID_DESCRIPTION.get()); 315 deleteAdminUserSubCmd.addArgument(deleteAdminUserUserIdArg); 316 317 // list-admin-user subcommand. 318 listAdminUserSubCmd = new SubCommand(argParser, 319 SubCommandNameEnum.LIST_ADMIN_USER.toString(), 320 INFO_ADMIN_SUBCMD_LIST_ADMIN_USER_DESCRIPTION.get()); 321 subCommands.add(listAdminUserSubCmd); 322 323 // get-admin-user-properties subcommand. 324 getAdminUserPropertiesSubCmd = new SubCommand(argParser, 325 SubCommandNameEnum.GET_ADMIN_USER_PROPERTIES.toString(), 326 INFO_ADMIN_SUBCMD_GET_ADMIN_USER_PROPERTIES_DESCRIPTION.get()); 327 subCommands.add(getAdminUserPropertiesSubCmd); 328 329 getAdminUserPropertiesUserIdArg = new StringArgument("userID", null, 330 OPTION_LONG_USERID, false, true, INFO_USERID_PLACEHOLDER.get(), 331 INFO_ADMIN_ARG_USERID_DESCRIPTION.get()); 332 getAdminUserPropertiesUserIdArg.setMultiValued(true); 333 getAdminUserPropertiesSubCmd.addArgument(getAdminUserPropertiesUserIdArg); 334 335 // set-admin-user-properties subcommand. 336 setAdminUserPropertiesSubCmd = new SubCommand(argParser, 337 SubCommandNameEnum.SET_ADMIN_USER_PROPERTIES.toString(), 338 INFO_ADMIN_SUBCMD_SET_ADMIN_USER_PROPERTIES_DESCRIPTION.get()); 339 subCommands.add(setAdminUserPropertiesSubCmd); 340 341 setAdminUserPropertiesUserIdArg = new StringArgument("userID", null, 342 OPTION_LONG_USERID, false, true, INFO_USERID_PLACEHOLDER.get(), 343 INFO_ADMIN_ARG_USERID_DESCRIPTION.get()); 344 setAdminUserPropertiesSubCmd.addArgument(setAdminUserPropertiesUserIdArg); 345 346 setAdminUserPropertiesSetArg = new StringArgument(OPTION_LONG_SET, 347 OPTION_SHORT_SET, OPTION_LONG_SET, false, true, true, 348 INFO_VALUE_SET_PLACEHOLDER.get(), null, null, 349 INFO_DSCFG_DESCRIPTION_PROP_VAL.get()); 350 setAdminUserPropertiesSubCmd.addArgument(setAdminUserPropertiesSetArg); 351 352 // list-admin-user-properties subcommand. 353 listAdminUserPropertiesSubCmd = new SubCommand(argParser, 354 SubCommandNameEnum.LIST_ADMIN_USER_PROPERTIES.toString(), 355 INFO_ADMIN_SUBCMD_LIST_ADMIN_USER_PROPERTIES_DESCRIPTION.get()); 356 subCommands.add(listAdminUserPropertiesSubCmd); 357 358 // Create association between ADSContext enum and server 359 // properties 360 // Server properties are mapped to Argument. 361 userAdminProperties = new HashMap<AdministratorProperty, Argument>(); 362 readonlyadminUserProperties = new HashSet<AdministratorProperty>(); 363 364 /** 365 * The ID used to identify the user. 366 */ 367 { 368 AdministratorProperty prop = AdministratorProperty.UID; 369 String attName = prop.getAttributeName(); 370 StringArgument arg = new StringArgument(attName, null, 371 attName, false, false, true, Message.raw(""), null, null, null); 372 userAdminProperties.put(prop, arg); 373 } 374 375 /** 376 * The PASSWORD used to identify the user. 377 */ 378 { 379 // TODO : Allow file based password 380 AdministratorProperty prop = AdministratorProperty.PASSWORD; 381 String attName = prop.getAttributeName(); 382 StringArgument arg = new StringArgument(attName, null, 383 attName, false, false, true, Message.raw(""), null, null, null); 384 userAdminProperties.put(prop, arg); 385 } 386 387 /** 388 * The DESCRIPTION used to identify the user. 389 */ 390 { 391 AdministratorProperty prop = AdministratorProperty.DESCRIPTION; 392 String attName = prop.getAttributeName(); 393 StringArgument arg = new StringArgument(attName, null, 394 attName, false, false, true, Message.raw(""), null, null, null); 395 userAdminProperties.put(prop, arg); 396 } 397 398 /** 399 * The ADMINISTRATOR_DN used to identify the user. 400 */ 401 { 402 AdministratorProperty prop = AdministratorProperty.ADMINISTRATOR_DN; 403 String attName = prop.getAttributeName(); 404 StringArgument arg = new StringArgument(attName, null, 405 attName, false, false, true, Message.raw(""), null, null, null); 406 userAdminProperties.put(prop, arg); 407 readonlyadminUserProperties.add(prop); 408 } 409 410 /** 411 * The PRIVILEGE associated to the user. 412 */ 413 { 414 AdministratorProperty prop = AdministratorProperty.PRIVILEGE; 415 String attName = prop.getAttributeName(); 416 StringArgument arg = new StringArgument(attName, null, 417 attName, true, true, true, Message.raw(""), "root", null, null); 418 userAdminProperties.put(prop, arg); 419 } 420 } 421 422 /** 423 * {@inheritDoc} 424 */ 425 public boolean isSubCommand(SubCommand subCmd) 426 { 427 return SubCommandNameEnum.isSubCommand(subCmd.getName()); 428 } 429 430 /** 431 * {@inheritDoc} 432 */ 433 public DsFrameworkCliReturnCode performSubCommand(SubCommand subCmd, 434 OutputStream outStream, OutputStream errStream) 435 throws ADSContextException, ArgumentException 436 { 437 438 ADSContext adsCtx = null; 439 InitialLdapContext ctx = null; 440 DsFrameworkCliReturnCode returnCode = ERROR_UNEXPECTED; 441 442 try 443 { 444 // ----------------------- 445 // create-admin-user subcommand. 446 // ----------------------- 447 if (subCmd.getName().equals(createAdminUserSubCmd.getName())) 448 { 449 String userId = createAdminUserUserIdArg.getValue(); 450 Map<AdministratorProperty, Object> map = 451 mapSetOptionsToMap(createAdminUserSetArg,true); 452 map.put(AdministratorProperty.UID, userId); 453 454 ctx = argParser.getContext(outStream, errStream); 455 if (ctx == null) 456 { 457 return CANNOT_CONNECT_TO_ADS; 458 } 459 adsCtx = new ADSContext(ctx); 460 adsCtx.createAdministrator(map); 461 462 returnCode = SUCCESSFUL; 463 } 464 else 465 // ----------------------- 466 // delete-admin-user subcommand. 467 // ----------------------- 468 if (subCmd.getName().equals(deleteAdminUserSubCmd.getName())) 469 { 470 String userId = deleteAdminUserUserIdArg.getValue(); 471 Map<AdministratorProperty, Object> map = 472 new HashMap<AdministratorProperty, Object>(); 473 map.put(AdministratorProperty.UID, userId); 474 475 ctx = argParser.getContext(outStream, errStream); 476 if (ctx == null) 477 { 478 return CANNOT_CONNECT_TO_ADS; 479 } 480 adsCtx = new ADSContext(ctx); 481 adsCtx.deleteAdministrator(map); 482 483 returnCode = SUCCESSFUL; 484 } 485 else 486 // ----------------------- 487 // list-admin-user subcommand. 488 // ----------------------- 489 if (subCmd.getName().equals(listAdminUserSubCmd.getName())) 490 { 491 ctx = argParser.getContext(outStream, errStream); 492 if (ctx == null) 493 { 494 return CANNOT_CONNECT_TO_ADS; 495 } 496 adsCtx = new ADSContext(ctx); 497 Set<Map<AdministratorProperty, Object>> adminUserList = adsCtx 498 .readAdministratorRegistry(); 499 500 PrintStream out = new PrintStream(outStream); 501 for (Map<AdministratorProperty, Object> user : adminUserList) 502 { 503 // print out server ID 504 out.println(AdministratorProperty.UID.getAttributeName() + ": " 505 + user.get(AdministratorProperty.UID)); 506 } 507 returnCode = SUCCESSFUL; 508 } 509 else 510 // ----------------------- 511 // get-admin-user-properties subcommand. 512 // ----------------------- 513 if (subCmd.getName().equals(getAdminUserPropertiesSubCmd.getName())) 514 { 515 ctx = argParser.getContext(outStream, errStream); 516 if (ctx == null) 517 { 518 return CANNOT_CONNECT_TO_ADS; 519 } 520 adsCtx = new ADSContext(ctx); 521 Set<Map<AdministratorProperty, Object>> adsAdminUserList = adsCtx 522 .readAdministratorRegistry(); 523 524 LinkedList<String> userAdminUserList = getAdminUserPropertiesUserIdArg 525 .getValues(); 526 PrintStream out = new PrintStream(outStream); 527 for (Map<AdministratorProperty, Object> adminUser : adsAdminUserList) 528 { 529 String adminUserID = (String) adminUser 530 .get(AdministratorProperty.UID); 531 if (!userAdminUserList.contains(adminUserID)) 532 { 533 continue; 534 } 535 // print out the Admin User ID 536 out.println(AdministratorProperty.UID.getAttributeName() + ": " 537 + adminUser.get(AdministratorProperty.UID)); 538 for (AdministratorProperty ap : adminUser.keySet()) 539 { 540 if (ap.equals(AdministratorProperty.UID)) 541 { 542 continue; 543 } 544 out.println(ap.getAttributeName() + ": " + adminUser.get(ap)); 545 } 546 out.println(); 547 } 548 returnCode = SUCCESSFUL; 549 } 550 else 551 // ----------------------- 552 // set-admin-user-properties subcommand. 553 // ----------------------- 554 if (subCmd.getName().equals(setAdminUserPropertiesSubCmd.getName())) 555 { 556 Map<AdministratorProperty, Object> map = 557 mapSetOptionsToMap(setAdminUserPropertiesSetArg,false); 558 559 // if the ID is specify in the --set list, it may mean that 560 // the user wants to rename the serverID 561 String newServerId = (String) map.get(AdministratorProperty.UID) ; 562 563 // replace the serverID in the map 564 map.put(AdministratorProperty.UID, setAdminUserPropertiesUserIdArg 565 .getValue()); 566 567 ctx = argParser.getContext(outStream, errStream); 568 if (ctx == null) 569 { 570 return CANNOT_CONNECT_TO_ADS; 571 } 572 adsCtx = new ADSContext(ctx); 573 adsCtx.updateAdministrator(map, newServerId); 574 returnCode = SUCCESSFUL; 575 } 576 else 577 // ----------------------- 578 // list-admin-user-properties subcommand. 579 // ----------------------- 580 if (subCmd.getName().equals(listAdminUserPropertiesSubCmd.getName())) 581 { 582 PrintStream out = new PrintStream(outStream); 583 out.println(DESCRIPTION_OPTIONS_TITLE); 584 out.println(); 585 out.print(" r -- "); 586 out.println(DESCRIPTION_OPTIONS_READ); 587 out.print(" w -- "); 588 out.println(DESCRIPTION_OPTIONS_WRITE); 589 out.print(" m -- "); 590 out.println(DESCRIPTION_OPTIONS_MANDATORY); 591 out.print(" s -- "); 592 out.println(DESCRIPTION_OPTIONS_SINGLE); 593 out.println(); 594 595 TableBuilder table = new TableBuilder(); 596 table.appendHeading(INFO_DSCFG_HEADING_PROPERTY_NAME.get()); 597 table.appendHeading(INFO_DSCFG_HEADING_PROPERTY_OPTIONS.get()); 598 table.appendHeading(INFO_DSCFG_HEADING_PROPERTY_SYNTAX.get()); 599 table.appendHeading(INFO_CLI_HEADING_PROPERTY_DEFAULT_VALUE.get()); 600 for (AdministratorProperty adminUserProp : userAdminProperties.keySet()) 601 { 602 if (userAdminProperties.get(adminUserProp).isHidden()) 603 { 604 continue; 605 } 606 table.startRow(); 607 table.appendCell(adminUserProp.getAttributeName()); 608 table.appendCell(getPropertyOptionSummary(userAdminProperties 609 .get(adminUserProp))); 610 table.appendCell(adminUserProp.getAttributeSyntax()); 611 if (userAdminProperties.get(adminUserProp).getDefaultValue() != null) 612 { 613 table.appendCell(userAdminProperties.get(adminUserProp) 614 .getDefaultValue()); 615 } 616 else 617 { 618 table.appendCell("-"); 619 } 620 } 621 TextTablePrinter printer = new TextTablePrinter(outStream); 622 table.print(printer); 623 returnCode = SUCCESSFUL; 624 } 625 // ----------------------- 626 // ERROR 627 // ----------------------- 628 else 629 { 630 // Should never occurs: If we are here, it means that the code 631 // to handle to subcommand is not yet written. 632 throw new ADSContextException(ErrorType.ERROR_UNEXPECTED); 633 } 634 } 635 catch (ADSContextException e) 636 { 637 if (ctx != null) 638 { 639 try 640 { 641 ctx.close(); 642 } 643 catch (NamingException x) 644 { 645 } 646 } 647 throw e; 648 } 649 650 // Close the connection, if needed 651 if (ctx != null) 652 { 653 try 654 { 655 ctx.close(); 656 } 657 catch (NamingException x) 658 { 659 } 660 } 661 662 // return part 663 return returnCode; 664 } 665 666 /** 667 * Translate a Set properties a to a MAP. 668 * 669 * @param propertySetArgument 670 * The input set argument. 671 * @param createCall 672 * Indicates if we should check the presence of mandatory 673 * properties and add root privileges. 674 * @return The created map. 675 * @throws ArgumentException 676 * If error error occurs during set parsing. 677 */ 678 private Map<AdministratorProperty, Object> mapSetOptionsToMap( 679 StringArgument propertySetArgument, boolean createCall) 680 throws ArgumentException 681 { 682 HashMap<AdministratorProperty, Object> map = 683 new HashMap<AdministratorProperty, Object>(); 684 boolean rootPrivileges = false ; 685 for (String m : propertySetArgument.getValues()) 686 { 687 // Parse the property "property:value". 688 int sep = m.indexOf(':'); 689 690 if (sep < 0) 691 { 692 throw ArgumentExceptionFactory.missingSeparatorInPropertyArgument(m); 693 } 694 695 if (sep == 0) 696 { 697 throw ArgumentExceptionFactory.missingNameInPropertyArgument(m); 698 } 699 700 String propertyName = m.substring(0, sep); 701 String value = m.substring(sep + 1, m.length()); 702 if (value.length() == 0) 703 { 704 throw ArgumentExceptionFactory.missingValueInPropertyArgument(m); 705 } 706 707 // Check that propName is a known prop. 708 AdministratorProperty adminUserProperty = ADSContext 709 .getAdminUserPropFromName(propertyName); 710 if (adminUserProperty == null) 711 { 712 Message message = ERR_CLI_ERROR_PROPERTY_UNRECOGNIZED.get(propertyName); 713 throw new ArgumentException(message); 714 } 715 716 // Check that propName is not hidden. 717 if (userAdminProperties.get(adminUserProperty).isHidden()) 718 { 719 Message message = ERR_CLI_ERROR_PROPERTY_UNRECOGNIZED.get(propertyName); 720 throw new ArgumentException(message); 721 } 722 723 // Check the property Syntax. 724 MessageBuilder invalidReason = new MessageBuilder(); 725 Argument arg = userAdminProperties.get(adminUserProperty) ; 726 if ( ! arg.valueIsAcceptable(value, invalidReason)) 727 { 728 Message message = 729 ERR_CLI_ERROR_INVALID_PROPERTY_VALUE.get(propertyName, value); 730 throw new ArgumentException(message); 731 } 732 if (adminUserProperty.equals(AdministratorProperty.PRIVILEGE)) 733 { 734 // Check if 'root' privilege is requested, or 735 // if it's a valid privilege 736 if (value.equals(arg.getDefaultValue())) 737 { 738 rootPrivileges = true ; 739 } 740 else 741 { 742 String valueToCheck = value ; 743 if (value.startsWith("-")) 744 { 745 valueToCheck = value.substring(1); 746 } 747 if (Privilege.privilegeForName(valueToCheck) == null) 748 { 749 Message message = ERR_CLI_ERROR_INVALID_PROPERTY_VALUE.get( 750 AdministratorProperty.PRIVILEGE.getAttributeName(), 751 valueToCheck); 752 throw new ArgumentException(message); 753 } 754 } 755 } 756 757 // Add the value to the argument. 758 arg.addValue(value); 759 760 // add to the map. 761 if (arg.isMultiValued()) 762 { 763 map.put(adminUserProperty, arg.getValues()); 764 } 765 else 766 { 767 map.put(adminUserProperty, value); 768 } 769 } 770 771 // If we are not in the create admin user, just return the 772 // provided atributes. 773 if (! createCall) 774 { 775 return map ; 776 } 777 778 // Here, we are in the create case. 779 // If privileges was not provided by the user, set the default value 780 if (! map.containsKey(AdministratorProperty.PRIVILEGE)) 781 { 782 rootPrivileges = true ; 783 } 784 785 // If we have root privilege, translate it to the corresponding 786 // list of privileges associated to 'root' user. 787 if (rootPrivileges) 788 { 789 LinkedList<String> privilegesList = new LinkedList<String>(); 790 for (Privilege p : Privilege.getDefaultRootPrivileges()) 791 { 792 privilegesList.add(p.getName()); 793 } 794 map.put(AdministratorProperty.PRIVILEGE,privilegesList); 795 } 796 797 for (AdministratorProperty s : AdministratorProperty.values()) 798 { 799 Argument arg = userAdminProperties.get(s); 800 if (arg.isHidden()) 801 { 802 continue; 803 } 804 if (map.containsKey(s)) 805 { 806 continue ; 807 } 808 if ( ! arg.isRequired()) 809 { 810 continue ; 811 } 812 813 // If we are here, it means that the argument is required 814 // but not yet is the map. Check if we have a default value. 815 if (arg.getDefaultValue() == null) 816 { 817 Message message = 818 ERR_CLI_ERROR_MISSING_PROPERTY.get(s.getAttributeName()); 819 throw new ArgumentException(message); 820 } 821 else 822 { 823 map.put(s, arg.getDefaultValue()); 824 } 825 } 826 return map; 827 } 828 829 //Compute the options field. 830 private String getPropertyOptionSummary(Argument arg) 831 { 832 StringBuilder b = new StringBuilder(); 833 834 if (readonlyadminUserProperties.contains( 835 ADSContext.getServerPropFromName(arg.getName()))) 836 { 837 b.append("r-"); //$NON-NLS-1$ 838 } 839 else 840 { 841 b.append("rw"); //$NON-NLS-1$ 842 } 843 844 if (arg.isRequired()) 845 { 846 b.append('m'); 847 } 848 else 849 { 850 b.append('-'); 851 } 852 853 if (arg.isMultiValued()) 854 { 855 b.append('-'); 856 } 857 else 858 { 859 b.append('s'); 860 } 861 return b.toString(); 862 } 863 864 }