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 2006-2008 Sun Microsystems, Inc.
026 */
027 package org.opends.server.admin.client.cli;
028
029 import static org.opends.messages.AdminMessages.*;
030 import static org.opends.messages.ToolMessages.*;
031 import static org.opends.server.tools.ToolConstants.*;
032
033 import java.io.IOException;
034 import java.io.OutputStream;
035 import java.util.ArrayList;
036 import java.util.HashMap;
037 import java.util.HashSet;
038 import java.util.List;
039 import java.util.Map;
040 import java.util.Set;
041
042 import javax.naming.NamingException;
043 import javax.naming.ldap.InitialLdapContext;
044 import javax.naming.ldap.Rdn;
045
046
047 import org.opends.admin.ads.ADSContext;
048 import org.opends.admin.ads.ADSContextException;
049 import org.opends.admin.ads.ADSContext.ServerGroupProperty;
050 import org.opends.admin.ads.ADSContext.ServerProperty;
051 import org.opends.admin.ads.ADSContextException.ErrorType;
052 import org.opends.server.util.args.ArgumentException;
053 import org.opends.server.util.args.BooleanArgument;
054 import org.opends.server.util.args.StringArgument;
055 import org.opends.server.util.args.SubCommand;
056
057 import static org.opends.server.admin.client.cli.DsFrameworkCliReturnCode.*;
058 /**
059 * This class is handling server group CLI.
060 */
061 public class DsFrameworkCliServerGroup implements DsFrameworkCliSubCommandGroup
062 {
063
064 /**
065 * End Of Line.
066 */
067 private String EOL = System.getProperty("line.separator");
068
069 /**
070 * The subcommand Parser.
071 */
072 DsFrameworkCliParser argParser ;
073
074 /**
075 * The verbose argument.
076 */
077 BooleanArgument verboseArg ;
078
079 /**
080 * The enumeration containing the different subCommand names.
081 */
082 private enum SubCommandNameEnum
083 {
084 /**
085 * The create-group subcommand.
086 */
087 CREATE_GROUP("create-group"),
088
089 /**
090 * The delete-group subcommand.
091 */
092 DELETE_GROUP("delete-group"),
093
094 /**
095 * The modify-group subcommand.
096 */
097 MODIFY_GROUP("modify-group"),
098
099 /**
100 * The list-groups subcommand.
101 */
102 LIST_GROUPS("list-groups"),
103
104 /**
105 * The list-members subcommand.
106 */
107 LIST_MEMBERS("list-members"),
108
109 /**
110 * The list-membership subcommand.
111 */
112 LIST_MEMBERSHIP("list-membership"),
113
114 /**
115 * The add-to-group subcommand.
116 */
117 ADD_TO_GROUP("add-to-group"),
118
119 /**
120 * The remove-from-group subcommand.
121 */
122 REMOVE_FROM_GROUP("remove-from-group");
123
124 // String representation of the value.
125 private final String name;
126
127 // Private constructor.
128 private SubCommandNameEnum(String name)
129 {
130 this.name = name;
131 }
132
133 /**
134 * {@inheritDoc}
135 */
136 public String toString()
137 {
138 return name;
139 }
140
141 // A lookup table for resolving a unit from its name.
142 private static final List<String> nameToSubCmdName ;
143 static
144 {
145 nameToSubCmdName = new ArrayList<String>();
146
147 for (SubCommandNameEnum subCmd : SubCommandNameEnum.values())
148 {
149 nameToSubCmdName.add(subCmd.toString());
150 }
151 }
152 public static boolean isSubCommand(String name)
153 {
154 return nameToSubCmdName.contains(name);
155 }
156 }
157
158 /**
159 * The 'create-group' subcommand.
160 */
161 public SubCommand createGroupSubCmd;
162
163 /**
164 * The 'description' argument of the 'create-group' subcommand.
165 */
166 private StringArgument createGroupDescriptionArg;
167
168 /**
169 * The 'group-name' argument of the 'create-group' subcommand.
170 */
171 private StringArgument createGroupGroupNameArg;
172
173 /**
174 * The 'modify-group' subcommand.
175 */
176 private SubCommand modifyGroupSubCmd;
177
178 /**
179 * The 'description' argument of the 'modify-group' subcommand.
180 */
181 private StringArgument modifyGroupDescriptionArg;
182
183 /**
184 * The 'group-id' argument of the 'modify-group' subcommand.
185 */
186 private StringArgument modifyGroupGroupIdArg;
187
188 /**
189 * The 'group-name' argument of the 'modify-group' subcommand.
190 */
191 private StringArgument modifyGroupGroupNameArg;
192
193 /**
194 * The 'delete-group' subcommand.
195 */
196 private SubCommand deleteGroupSubCmd;
197
198 /**
199 * The 'group-name' argument of the 'delete-group' subcommand.
200 */
201 private StringArgument deleteGroupGroupNameArg;
202
203 /**
204 * The 'list-group' subcommand.
205 */
206 private SubCommand listGroupSubCmd;
207
208 /**
209 * The 'add-to-group' subcommand.
210 */
211 private SubCommand addToGroupSubCmd;
212
213 /**
214 * The 'group-name' argument of the 'add-to-group' subcommand.
215 */
216 private StringArgument addToGroupGroupNameArg;
217
218 /**
219 * The 'member-id' argument of the 'add-to-group' subcommand.
220 */
221 private StringArgument addToGoupMemberNameArg;
222
223 /**
224 * The 'remove-from-group' subcommand.
225 */
226 private SubCommand removeFromGroupSubCmd;
227
228 /**
229 * The 'group-name' argument of the 'remove-from-group' subcommand.
230 */
231 private StringArgument removeFromGroupGroupNameArg;
232
233 /**
234 * The 'member-id' argument of the 'remove-from-group' subcommand.
235 */
236 private StringArgument removeFromGoupMemberNameArg;
237
238 /**
239 * The 'list-members' subcommand.
240 */
241 private SubCommand listMembersSubCmd;
242
243 /**
244 * The 'group-name' argument of the 'list-members' subcommand.
245 */
246 private StringArgument listMembersGroupNameArg;
247
248 /**
249 * The 'list-membership' subcommand.
250 */
251 private SubCommand listMembershipSubCmd;
252
253 /**
254 * The 'member-name' argument of the 'list-membership' subcommand.
255 */
256 private StringArgument listMembershipMemberNameArg;
257
258
259 /**
260 * Association between ADSContext enum and display field.
261 */
262 private HashMap<ServerGroupProperty, String> attributeDisplayName;
263
264 /**
265 * The subcommand list.
266 */
267 private HashSet<SubCommand> subCommands = new HashSet<SubCommand>();
268
269 /**
270 * Indicates whether this subCommand should be hidden in the usage
271 * information.
272 */
273 private boolean isHidden;
274
275 /**
276 * The subcommand group name.
277 */
278 private String groupName;
279
280 /**
281 * Get the display attribute name for a given attribute.
282 * @param prop The server property
283 * @return the display attribute name for a given attribute
284 */
285 public String getAttributeDisplayName(ServerGroupProperty prop)
286 {
287 return attributeDisplayName.get(prop);
288 }
289
290 /**
291 * {@inheritDoc}
292 */
293 public Set<SubCommand> getSubCommands()
294 {
295 return subCommands;
296 }
297
298 /**
299 * {@inheritDoc}
300 */
301 public boolean isHidden()
302 {
303 return isHidden;
304 }
305
306 /**
307 * {@inheritDoc}
308 */
309 public String getGroupName()
310 {
311 return groupName ;
312 }
313
314 /**
315 * {@inheritDoc}
316 */
317 public void initializeCliGroup(DsFrameworkCliParser argParser,
318 BooleanArgument verboseArg)
319 throws ArgumentException
320 {
321 this.verboseArg = verboseArg ;
322 isHidden = false ;
323 groupName = "server-group";
324 this.argParser = argParser;
325
326
327 // Create-group subcommand
328 createGroupSubCmd = new SubCommand(argParser,
329 SubCommandNameEnum.CREATE_GROUP.toString(),
330 INFO_ADMIN_SUBCMD_CREATE_GROUP_DESCRIPTION.get());
331 subCommands.add(createGroupSubCmd);
332
333 createGroupDescriptionArg = new StringArgument("description",
334 OPTION_SHORT_DESCRIPTION, OPTION_LONG_DESCRIPTION, false, false,
335 true, INFO_DESCRIPTION_PLACEHOLDER.get(), "", null,
336 INFO_ADMIN_ARG_DESCRIPTION_DESCRIPTION.get());
337 createGroupSubCmd.addArgument(createGroupDescriptionArg);
338
339 createGroupGroupNameArg = new StringArgument("groupName",
340 OPTION_SHORT_GROUPNAME, OPTION_LONG_GROUPNAME, true, true,
341 INFO_GROUPNAME_PLACEHOLDER.get(),
342 INFO_ADMIN_ARG_CREATE_GROUP_GROUPNAME_DESCRIPTION.get());
343 createGroupSubCmd.addArgument(createGroupGroupNameArg);
344
345 // modify-group
346 modifyGroupSubCmd = new SubCommand(argParser,
347 SubCommandNameEnum.MODIFY_GROUP.toString(),
348 INFO_ADMIN_SUBCMD_MODIFY_GROUP_DESCRIPTION.get());
349 subCommands.add(modifyGroupSubCmd);
350
351 modifyGroupDescriptionArg = new StringArgument("new-description",
352 OPTION_SHORT_DESCRIPTION, OPTION_LONG_DESCRIPTION, false, false,
353 true, INFO_DESCRIPTION_PLACEHOLDER.get(), "", null,
354 INFO_ADMIN_ARG_NEW_DESCRIPTION_DESCRIPTION.get());
355 modifyGroupSubCmd.addArgument(modifyGroupDescriptionArg);
356
357 modifyGroupGroupIdArg = new StringArgument("new-groupName",
358 OPTION_SHORT_NEWGROUPNAME, OPTION_LONG_NEWGROUPNAME, false, false, true,
359 INFO_GROUPNAME_PLACEHOLDER.get(), "", null,
360 INFO_ADMIN_ARG_NEW_GROUPNAME_DESCRIPTION.get());
361 modifyGroupSubCmd.addArgument(modifyGroupGroupIdArg);
362
363 modifyGroupGroupNameArg = new StringArgument("groupName",
364 OPTION_SHORT_GROUPNAME, OPTION_LONG_GROUPNAME, true, true,
365 INFO_GROUPNAME_PLACEHOLDER.get(),
366 INFO_ADMIN_ARG_GROUPNAME_DESCRIPTION.get());
367 modifyGroupSubCmd.addArgument(modifyGroupGroupNameArg);
368
369 // delete-group
370 deleteGroupSubCmd = new SubCommand(argParser,SubCommandNameEnum.DELETE_GROUP
371 .toString(), INFO_ADMIN_SUBCMD_DELETE_GROUP_DESCRIPTION.get());
372 subCommands.add(deleteGroupSubCmd);
373
374 deleteGroupGroupNameArg = new StringArgument("groupName",
375 OPTION_SHORT_GROUPNAME, OPTION_LONG_GROUPNAME, true, true,
376 INFO_GROUPNAME_PLACEHOLDER.get(),
377 INFO_ADMIN_ARG_GROUPNAME_DESCRIPTION.get());
378 deleteGroupSubCmd.addArgument(deleteGroupGroupNameArg);
379
380 // list-groups
381 listGroupSubCmd = new SubCommand(argParser, "list-groups",
382 INFO_ADMIN_SUBCMD_LIST_GROUPS_DESCRIPTION.get());
383 subCommands.add(listGroupSubCmd);
384
385 // add-to-group
386 addToGroupSubCmd = new SubCommand(argParser,
387 SubCommandNameEnum.ADD_TO_GROUP.toString(),
388 INFO_ADMIN_SUBCMD_ADD_TO_GROUP_DESCRIPTION.get());
389 subCommands.add(addToGroupSubCmd);
390
391 addToGoupMemberNameArg = new StringArgument("memberName",
392 OPTION_SHORT_MEMBERNAME, OPTION_LONG_MEMBERNAME, true, true,
393 INFO_MEMBERNAME_PLACEHOLDER.get(),
394 INFO_ADMIN_ARG_ADD_MEMBERNAME_DESCRIPTION.get());
395 addToGroupSubCmd.addArgument(addToGoupMemberNameArg);
396
397 addToGroupGroupNameArg = new StringArgument("groupName",
398 OPTION_SHORT_GROUPNAME, OPTION_LONG_GROUPNAME, true, true,
399 INFO_GROUPNAME_PLACEHOLDER.get(),
400 INFO_ADMIN_ARG_GROUPNAME_DESCRIPTION.get());
401 addToGroupSubCmd.addArgument(addToGroupGroupNameArg);
402
403 // remove-from-group
404 removeFromGroupSubCmd = new SubCommand(argParser,
405 SubCommandNameEnum.REMOVE_FROM_GROUP.toString(),
406 INFO_ADMIN_SUBCMD_REMOVE_FROM_GROUP_DESCRIPTION.get());
407 subCommands.add(removeFromGroupSubCmd);
408
409 removeFromGoupMemberNameArg = new StringArgument("memberName",
410 OPTION_SHORT_MEMBERNAME, OPTION_LONG_MEMBERNAME, true, true,
411 INFO_MEMBERNAME_PLACEHOLDER.get(),
412 INFO_ADMIN_ARG_REMOVE_MEMBERNAME_DESCRIPTION.get());
413 removeFromGroupSubCmd.addArgument(removeFromGoupMemberNameArg);
414
415 removeFromGroupGroupNameArg = new StringArgument("groupName",
416 OPTION_SHORT_GROUPNAME, OPTION_LONG_GROUPNAME, true, true,
417 INFO_GROUPNAME_PLACEHOLDER.get(),
418 INFO_ADMIN_ARG_GROUPNAME_DESCRIPTION.get());
419 removeFromGroupSubCmd.addArgument(removeFromGroupGroupNameArg);
420
421
422 // list-members
423 listMembersSubCmd = new SubCommand(argParser,SubCommandNameEnum.LIST_MEMBERS
424 .toString(), INFO_ADMIN_SUBCMD_LIST_MEMBERS_DESCRIPTION.get());
425 subCommands.add(listMembersSubCmd);
426
427 listMembersGroupNameArg = new StringArgument("groupName",
428 OPTION_SHORT_GROUPNAME, OPTION_LONG_GROUPNAME, true, true,
429 INFO_GROUPNAME_PLACEHOLDER.get(),
430 INFO_ADMIN_ARG_GROUPNAME_DESCRIPTION.get());
431 listMembersSubCmd.addArgument(listMembersGroupNameArg);
432
433 // list-membership
434 listMembershipSubCmd = new SubCommand(argParser,
435 SubCommandNameEnum.LIST_MEMBERSHIP.toString(),
436 INFO_ADMIN_SUBCMD_LIST_MEMBERSHIP_DESCRIPTION.get());
437 subCommands.add(listMembershipSubCmd);
438
439 listMembershipMemberNameArg = new StringArgument("memberName",
440 OPTION_SHORT_MEMBERNAME, OPTION_LONG_MEMBERNAME, true, true,
441 INFO_MEMBERNAME_PLACEHOLDER.get(),
442 INFO_ADMIN_ARG_MEMBERNAME_DESCRIPTION.get());
443 listMembershipSubCmd.addArgument(listMembershipMemberNameArg);
444
445 // Create association between ADSContext enum and display field
446 attributeDisplayName = new HashMap<ServerGroupProperty, String>();
447 attributeDisplayName.put(ServerGroupProperty.UID, OPTION_LONG_GROUPNAME);
448 attributeDisplayName.put(ServerGroupProperty.DESCRIPTION,
449 OPTION_LONG_DESCRIPTION);
450 attributeDisplayName.put(ServerGroupProperty.MEMBERS,
451 OPTION_LONG_MEMBERNAME);
452 }
453
454 /**
455 * {@inheritDoc}
456 */
457 public boolean isSubCommand(SubCommand subCmd)
458 {
459 return SubCommandNameEnum.isSubCommand(subCmd.getName());
460 }
461
462
463 /**
464 * {@inheritDoc}
465 */
466 public DsFrameworkCliReturnCode performSubCommand(SubCommand subCmd,
467 OutputStream outStream, OutputStream errStream)
468 throws ADSContextException, ArgumentException
469 {
470 ADSContext adsCtx = null ;
471 InitialLdapContext ctx = null ;
472
473 DsFrameworkCliReturnCode returnCode = ERROR_UNEXPECTED;
474 try
475 {
476 // -----------------------
477 // create-group subcommand
478 // -----------------------
479 if (subCmd.getName().equals(createGroupSubCmd.getName()))
480 {
481 String groupId = createGroupGroupNameArg.getValue();
482 HashMap<ServerGroupProperty, Object> serverGroupProperties =
483 new HashMap<ServerGroupProperty, Object>();
484
485 // get the GROUP_NAME
486 serverGroupProperties.put(ServerGroupProperty.UID, groupId);
487
488 // get the Description
489 if (createGroupDescriptionArg.isPresent())
490 {
491 serverGroupProperties.put(ServerGroupProperty.DESCRIPTION,
492 createGroupDescriptionArg.getValue());
493 }
494
495 // Create the group
496 ctx = argParser.getContext(outStream, errStream);
497 if (ctx == null)
498 {
499 return CANNOT_CONNECT_TO_ADS;
500 }
501 adsCtx = new ADSContext(ctx) ;
502 adsCtx.createServerGroup(serverGroupProperties);
503 returnCode = SUCCESSFUL;
504 }
505 // -----------------------
506 // delete-group subcommand
507 // -----------------------
508 else if (subCmd.getName().equals(deleteGroupSubCmd.getName()))
509 {
510 returnCode = SUCCESSFUL;
511 String groupId = deleteGroupGroupNameArg.getValue();
512 if (groupId.equals(ADSContext.ALL_SERVERGROUP_NAME))
513 {
514 return ACCESS_PERMISSION ;
515 }
516 HashMap<ServerGroupProperty, Object> serverGroupProperties =
517 new HashMap<ServerGroupProperty, Object>();
518
519 // Get ADS context
520 ctx = argParser.getContext(outStream, errStream);
521 if (ctx == null)
522 {
523 return CANNOT_CONNECT_TO_ADS;
524 }
525 adsCtx = new ADSContext(ctx) ;
526
527 // update server Property "GROUPS"
528 Set<String> serverList = adsCtx.getServerGroupMemberList(groupId);
529 for (String serverId : serverList)
530 {
531 // serverId contains "cn=" string, just remove it.
532 removeServerFromGroup(adsCtx, groupId,serverId.substring(3));
533 }
534
535 // Delete the group
536 serverGroupProperties.put(ServerGroupProperty.UID, groupId);
537 adsCtx.deleteServerGroup(serverGroupProperties);
538 }
539 // -----------------------
540 // list-groups subcommand
541 // -----------------------
542 else if (subCmd.getName().equals(listGroupSubCmd.getName()))
543 {
544 ctx = argParser.getContext(outStream, errStream);
545 if (ctx == null)
546 {
547 return CANNOT_CONNECT_TO_ADS;
548 }
549 adsCtx = new ADSContext(ctx) ;
550
551 Set<Map<ServerGroupProperty, Object>> result = adsCtx
552 .readServerGroupRegistry();
553 StringBuilder buffer = new StringBuilder();
554
555 // if not verbose mode, print group name (1 per line)
556 if (! verboseArg.isPresent())
557 {
558 for (Map<ServerGroupProperty, Object> groupProps : result)
559 {
560 // Get the group name
561 buffer.append(groupProps.get(ServerGroupProperty.UID));
562 buffer.append(EOL);
563 }
564 }
565 else
566 {
567 // Look for the max group identifier length
568 int uidLength = 0 ;
569 for (ServerGroupProperty sgp : ServerGroupProperty.values())
570 {
571 int cur = attributeDisplayName.get(sgp).toString().length();
572 if (cur > uidLength)
573 {
574 uidLength = cur;
575 }
576 }
577 uidLength++;
578
579 for (Map<ServerGroupProperty, Object> groupProps : result)
580 {
581 // Get the group name
582 buffer.append(attributeDisplayName.get(ServerGroupProperty.UID));
583 // add space
584 int curLen = attributeDisplayName.get(ServerGroupProperty.UID)
585 .length();
586 for (int i = curLen; i < uidLength; i++)
587 {
588 buffer.append(" ");
589 }
590 buffer.append(": ");
591 buffer.append(groupProps.get(ServerGroupProperty.UID));
592 buffer.append(EOL);
593
594 // Write other props
595 for (ServerGroupProperty propName : ServerGroupProperty.values())
596 {
597 if (propName.compareTo(ServerGroupProperty.UID) == 0)
598 {
599 // We have already displayed the group Id
600 continue;
601 }
602 buffer.append(attributeDisplayName.get(propName));
603 // add space
604 curLen = attributeDisplayName.get(propName).length();
605 for (int i = curLen; i < uidLength; i++)
606 {
607 buffer.append(" ");
608 }
609 buffer.append(": ");
610
611 if (propName.compareTo(ServerGroupProperty.MEMBERS) == 0)
612 {
613 Set atts = (Set) groupProps.get(propName);
614 if (atts != null)
615 {
616 boolean indent = false;
617 for (Object att : atts)
618 {
619 if (indent)
620 {
621 buffer.append(EOL);
622 for (int i = 0; i < uidLength + 2; i++)
623 {
624 buffer.append(" ");
625 }
626 }
627 else
628 {
629 indent = true;
630 }
631 buffer.append(att.toString().substring(3));
632 }
633 }
634 }
635 else
636 {
637 if (groupProps.get(propName) != null)
638 {
639 buffer.append(groupProps.get(propName));
640 }
641 }
642 buffer.append(EOL);
643 }
644 buffer.append(EOL);
645 }
646 }
647 try
648 {
649 outStream.write(buffer.toString().getBytes());
650 }
651 catch (IOException e)
652 {
653 }
654 returnCode = SUCCESSFUL;
655 }
656 // -----------------------
657 // modify-group subcommand
658 // -----------------------
659 else if (subCmd.getName().equals(modifyGroupSubCmd.getName()))
660 {
661 String groupId = modifyGroupGroupNameArg.getValue();
662 HashMap<ServerGroupProperty, Object> serverGroupProperties =
663 new HashMap<ServerGroupProperty, Object>();
664 HashSet<ServerGroupProperty> serverGroupPropertiesToRemove =
665 new HashSet<ServerGroupProperty>();
666
667 Boolean updateRequired = false;
668 Boolean removeRequired = false;
669 // get the GROUP_ID
670 if (modifyGroupGroupIdArg.isPresent())
671 {
672 // rename the entry !
673 serverGroupProperties.put(ServerGroupProperty.UID,
674 modifyGroupGroupIdArg.getValue());
675 updateRequired = true;
676 }
677 else
678 {
679 serverGroupProperties.put(ServerGroupProperty.UID, groupId) ;
680 }
681
682
683 // get the Description
684 if (modifyGroupDescriptionArg.isPresent())
685 {
686 String newDesc = modifyGroupDescriptionArg.getValue();
687 if (newDesc.length() == 0)
688 {
689 serverGroupPropertiesToRemove.add(ServerGroupProperty.DESCRIPTION);
690 removeRequired = true;
691 }
692 else
693 {
694 serverGroupProperties.put(ServerGroupProperty.DESCRIPTION,
695 modifyGroupDescriptionArg.getValue());
696 updateRequired = true;
697 }
698 }
699
700
701 // Update the server group
702 if ( ! (updateRequired || removeRequired ) )
703 {
704 returnCode = SUCCESSFUL_NOP;
705 }
706
707 // We need to perform an update
708 ctx = argParser.getContext(outStream, errStream);
709 if (ctx == null)
710 {
711 return CANNOT_CONNECT_TO_ADS;
712 }
713 adsCtx = new ADSContext(ctx) ;
714
715 if (updateRequired)
716 {
717 adsCtx.updateServerGroup(groupId, serverGroupProperties);
718 }
719 if (removeRequired)
720 {
721 adsCtx.removeServerGroupProp(groupId,
722 serverGroupPropertiesToRemove);
723 }
724
725 returnCode = SUCCESSFUL;
726 }
727 // -----------------------
728 // add-to-group subcommand
729 // -----------------------
730 else if (subCmd.getName().equals(addToGroupSubCmd.getName()))
731 {
732 String groupId = addToGroupGroupNameArg.getValue();
733
734 ctx = argParser.getContext(outStream, errStream);
735 if (ctx == null)
736 {
737 return CANNOT_CONNECT_TO_ADS;
738 }
739 adsCtx = new ADSContext(ctx) ;
740
741 // Check if the server is registered inside to ADS
742 Set<Map<ServerProperty, Object>> serverList = adsCtx
743 .readServerRegistry();
744 boolean found = false ;
745 Map<ServerProperty, Object> foundServerProperties = null ;
746 for (Map<ServerProperty, Object> serverProperties : serverList)
747 {
748 String serverId = ADSContext
749 .getServerIdFromServerProperties(serverProperties);
750 if (addToGoupMemberNameArg.getValue().equals(serverId))
751 {
752 found = true;
753 foundServerProperties = serverProperties ;
754 break;
755 }
756 }
757 if ( !found )
758 {
759 throw new ADSContextException (ErrorType.NOT_YET_REGISTERED) ;
760 }
761
762 // Add the server inside the group
763 returnCode = addServerTogroup(adsCtx, groupId, foundServerProperties);
764 }
765 // -----------------------
766 // remove-from-group subcommand
767 // -----------------------
768 else if (subCmd.getName().equals(removeFromGroupSubCmd.getName()))
769 {
770 ctx = argParser.getContext(outStream, errStream);
771 if (ctx == null)
772 {
773 return CANNOT_CONNECT_TO_ADS;
774 }
775 adsCtx = new ADSContext(ctx) ;
776
777 returnCode = removeServerFromGroup(adsCtx,
778 removeFromGroupGroupNameArg.getValue(),
779 removeFromGoupMemberNameArg.getValue());
780 }
781 // -----------------------
782 // list-members subcommand
783 // -----------------------
784 else if (subCmd.getName().equals(listMembersSubCmd.getName()))
785 {
786 String groupId = listMembersGroupNameArg.getValue();
787
788 ctx = argParser.getContext(outStream, errStream);
789 if (ctx == null)
790 {
791 return CANNOT_CONNECT_TO_ADS;
792 }
793 adsCtx = new ADSContext(ctx) ;
794
795 // get the current member list
796 Set<String> memberList = adsCtx.getServerGroupMemberList(groupId);
797 if (memberList == null)
798 {
799 returnCode = SUCCESSFUL;
800 }
801 StringBuilder buffer = new StringBuilder();
802 for (String member : memberList)
803 {
804 // We shouldn't print out the "cn="
805 buffer.append(member.substring(3));
806 buffer.append(EOL);
807 }
808 try
809 {
810 outStream.write(buffer.toString().getBytes());
811 }
812 catch (IOException e)
813 {
814 }
815
816 returnCode = SUCCESSFUL;
817 }
818 // -----------------------
819 // list-membership subcommand
820 // -----------------------
821 else if (subCmd.getName().equals(listMembershipSubCmd.getName()))
822 {
823
824 ctx = argParser.getContext(outStream, errStream);
825 if (ctx == null)
826 {
827 return CANNOT_CONNECT_TO_ADS;
828 }
829 adsCtx = new ADSContext(ctx) ;
830
831 Set<Map<ServerGroupProperty, Object>> result = adsCtx
832 .readServerGroupRegistry();
833 String MemberId = listMembershipMemberNameArg.getValue();
834
835 StringBuilder buffer = new StringBuilder();
836 for (Map<ServerGroupProperty, Object> groupProps : result)
837 {
838 // Get the group name;
839 String groupId = groupProps.get(ServerGroupProperty.UID).toString();
840
841 // look for member list attribute
842 for (ServerGroupProperty propName : groupProps.keySet())
843 {
844 if (propName.compareTo(ServerGroupProperty.MEMBERS) != 0)
845 {
846 continue;
847 }
848 // Check if the member list contains the member-id
849 Set atts = (Set) groupProps.get(propName);
850 for (Object att : atts)
851 {
852 if (att.toString().substring(3).toLowerCase().equals(
853 MemberId.toLowerCase()))
854 {
855 buffer.append(groupId);
856 buffer.append(EOL);
857 break;
858 }
859 }
860 break;
861 }
862 }
863 try
864 {
865 outStream.write(buffer.toString().getBytes());
866 }
867 catch (IOException e)
868 {
869 }
870 returnCode = SUCCESSFUL;
871 }
872 else
873 {
874 // Should never occurs: If we are here, it means that the code to
875 // handle to subcommand is not yet written.
876 returnCode = ERROR_UNEXPECTED;
877 }
878 }
879 catch (ADSContextException e)
880 {
881 if (ctx != null)
882 {
883 try
884 {
885 ctx.close();
886 }
887 catch (NamingException x)
888 {
889 }
890 }
891 throw e;
892 }
893
894 // Close the connection, if needed
895 if (ctx != null)
896 {
897 try
898 {
899 ctx.close();
900 }
901 catch (NamingException x)
902 {
903 }
904 }
905
906 // return part
907 return returnCode;
908
909 }
910
911 /**
912 * Remove a server from a group.
913 *
914 * @param adsCtx
915 * The ADS context to use.
916 * @param groupId
917 * The group identifier from which a server has to be
918 * remove.
919 * @param serverId
920 * The server identifier to be removed.
921 * @return The return code.
922 * @throws ADSContextException
923 * If there is a problem with any of the parameters used
924 * to create this argument.
925 */
926 static DsFrameworkCliReturnCode removeServerFromGroup(ADSContext adsCtx,
927 String groupId, String serverId)
928 throws ADSContextException
929 {
930 DsFrameworkCliReturnCode returnCode = SUCCESSFUL;
931
932 // get the current group member list
933 Set<String> memberList = adsCtx.getServerGroupMemberList(groupId);
934 if (memberList == null)
935 {
936 returnCode = NOT_YET_REGISTERED;
937 }
938 String memberToRemove = "cn="
939 + Rdn.escapeValue(serverId);
940 if (!memberList.contains(memberToRemove))
941 {
942 returnCode = NOT_YET_REGISTERED;
943 }
944
945 memberList.remove(memberToRemove);
946 HashMap<ServerGroupProperty, Object> serverGroupProperties =
947 new HashMap<ServerGroupProperty, Object>();
948 serverGroupProperties.put(ServerGroupProperty.MEMBERS, memberList);
949
950 // Update the server group
951 adsCtx.updateServerGroup(groupId, serverGroupProperties);
952
953 // Update the server property "GROUPS"
954 Set<Map<ServerProperty,Object>> serverList = adsCtx.readServerRegistry() ;
955 boolean found = false;
956 Map<ServerProperty,Object> serverProperties = null ;
957 for (Map<ServerProperty,Object> elm : serverList)
958 {
959 if (serverId.equals(elm.get(ServerProperty.ID)))
960 {
961 found = true ;
962 serverProperties = elm ;
963 break ;
964 }
965 }
966 if ( ! found )
967 {
968 return SERVER_NOT_REGISTERED ;
969 }
970
971 Set rawGroupList = (Set) serverProperties.get(ServerProperty.GROUPS);
972 Set<String> groupList = new HashSet<String>();
973 if (rawGroupList != null)
974 {
975 for (Object elm :rawGroupList.toArray() )
976 {
977 if (groupId.equals(elm))
978 {
979 continue ;
980 }
981 groupList.add(elm.toString());
982 }
983 }
984 serverProperties.put(ServerProperty.GROUPS, groupList);
985 adsCtx.updateServer(serverProperties, null);
986
987 return returnCode;
988 }
989
990 /**
991 * Add a server inside a group.
992 *
993 * @param adsCtx
994 * The ADS context to use.
995 * @param groupId
996 * The group identifier in which a server has to be added.
997 * @param map
998 * The properties of the server that have to be added to the
999 * group.
1000 * @return the return code.
1001 * @throws ADSContextException
1002 * If there is a problem with any of the parameters used
1003 * to create this argument.
1004 */
1005 static DsFrameworkCliReturnCode addServerTogroup(ADSContext adsCtx,
1006 String groupId, Map<ServerProperty, Object> map)
1007 throws ADSContextException
1008 {
1009 DsFrameworkCliReturnCode returnCode = SUCCESSFUL;
1010 String serverId = (String) map.get(ServerProperty.ID);
1011
1012 // Add the server inside the group
1013 HashMap<ServerGroupProperty, Object> serverGroupProperties =
1014 new HashMap<ServerGroupProperty, Object>();
1015 Set<String> memberList = adsCtx.getServerGroupMemberList(groupId);
1016 if (memberList == null)
1017 {
1018 memberList = new HashSet<String>();
1019 }
1020 String newMember = "cn="
1021 + Rdn.escapeValue(serverId);
1022 if (memberList.contains(newMember))
1023 {
1024 returnCode = ALREADY_REGISTERED;
1025 }
1026 memberList.add(newMember);
1027 serverGroupProperties.put(ServerGroupProperty.MEMBERS, memberList);
1028
1029 adsCtx.updateServerGroup(groupId, serverGroupProperties);
1030
1031
1032 // Update the server property "GROUPS"
1033 Set rawGroupList = (Set) map.get(ServerProperty.GROUPS);
1034 Set<String> groupList = new HashSet<String>();
1035 if (rawGroupList != null)
1036 {
1037 for (Object elm :rawGroupList.toArray() )
1038 {
1039 groupList.add(elm.toString());
1040 }
1041 }
1042 groupList.add(groupId) ;
1043 map.put(ServerProperty.GROUPS, groupList);
1044 adsCtx.updateServer(map, null);
1045
1046 return returnCode;
1047 }
1048 }