コード例 #1
0
  private void migrateUser(
      final long fromDirectoryId,
      final long toDirectoryId,
      final String remoteUser,
      final User user,
      final AtomicLong migratedCount)
      throws Exception {
    if (!user.getName().equalsIgnoreCase(remoteUser)) {
      UserWithAttributes userWithAttributes =
          directoryManager.findUserWithAttributesByName(fromDirectoryId, user.getName());
      try {
        final UserTemplate newUser = new UserTemplate(user);
        newUser.setDirectoryId(toDirectoryId);
        directoryManager.addUser(
            toDirectoryId, newUser, new PasswordCredential(generatePassword()));
      } catch (InvalidUserException e) {
        // That's fine just go on to the next user.  Don't copy the groups.
        return;
      }
      // Migrate attributes
      Set<String> keys = userWithAttributes.getKeys();
      Map<String, Set<String>> attributes = new HashMap<String, Set<String>>();
      for (String key : keys) {
        Set<String> values = userWithAttributes.getValues(key);
        attributes.put(key, values);
      }
      directoryManager.storeUserAttributes(toDirectoryId, user.getName(), attributes);

      MembershipQuery<Group> groupQuery =
          QueryBuilder.queryFor(Group.class, EntityDescriptor.group())
              .parentsOf(EntityDescriptor.user())
              .withName(user.getName())
              .returningAtMost(EntityQuery.ALL_RESULTS);
      List<Group> groups =
          directoryManager.searchDirectGroupRelationships(fromDirectoryId, groupQuery);
      for (Group group : groups) {
        // We may need to add the group first
        try {
          directoryManager.findGroupByName(toDirectoryId, group.getName());
        } catch (GroupNotFoundException ex) {
          final GroupTemplate newGroup = new GroupTemplate(group);
          newGroup.setDirectoryId(toDirectoryId);
          directoryManager.addGroup(toDirectoryId, newGroup);
        }
        directoryManager.addUserToGroup(toDirectoryId, user.getName(), group.getName());
        directoryManager.removeUserFromGroup(fromDirectoryId, user.getName(), group.getName());
      }
      directoryManager.removeUser(fromDirectoryId, user.getName());
      migratedCount.addAndGet(1);
    }
  }
コード例 #2
0
  private void migrateUsers(
      final long fromDirectoryId,
      final long toDirectoryId,
      final String remoteUser,
      final MigrateDirectoryUsersCommand migrateUsersCommand,
      final BindException errors) {
    // Check the to & from directories

    Directory from = validateDirectory(fromDirectoryId, errors, "fromDirectoryId");
    Directory to = validateDirectory(toDirectoryId, errors, "toDirectoryId");
    if (to != null && to.equals(from)) {
      errors.addError(
          new FieldError(
              "migration",
              "toDirectoryId",
              i18nResolver.getText("embedded.crowd.directory.migrate.users.field.directory.same")));
    }
    if (errors.hasErrors()) {
      return;
    }

    setDirectoryEnabled(from, false);
    setDirectoryEnabled(to, false);

    // Copy
    SearchRestriction restriction = NullRestrictionImpl.INSTANCE;
    UserQuery<User> query = new UserQuery<User>(User.class, restriction, 0, -1);
    try {
      // TODO: Sucking all users in like this may be problematic for Confluence.  If planning to
      // enable this
      // TODO: feature for other products make sure the performance impacts are understood.
      List<User> users = directoryManager.searchUsers(fromDirectoryId, query);
      final AtomicLong migratedCount = new AtomicLong(0);
      for (Iterator<User> iter = users.iterator(); iter.hasNext(); ) {
        final User user = iter.next();
        transactionTemplate.execute(
            new TransactionCallback() {
              public Object doInTransaction() {
                try {
                  migrateUser(fromDirectoryId, toDirectoryId, remoteUser, user, migratedCount);
                } catch (Exception e) {
                  throw new RuntimeException(e);
                }
                return null;
              }
            });
      }
      migrateUsersCommand.setTestSuccessful(true);
      migrateUsersCommand.setTotalCount(users.size());
      migrateUsersCommand.setMigratedCount(migratedCount.get());
    } catch (Exception e) {
      log.error("User migration failed", e);
      errors.addError(
          new ObjectError(
              "migration",
              i18nResolver.getText(
                  "embedded.crowd.directory.migrate.users.error",
                  htmlEncoder.encode(e.getMessage()))));
    }

    // Enable both directories
    setDirectoryEnabled(from, true);
    setDirectoryEnabled(to, true);
  }