Added logging for empty group sync.

Alfred Schmid

2014-02-03 03c0191b65c68dc6be3da0e0056bcb3cbc6e9cef

 src/main/java/com/gitblit/auth/LdapAuthProvider.java

@@ -23,6 +23,8 @@
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

@@ -32,6 +34,7 @@
import com.gitblit.auth.AuthenticationProvider.UsernamePasswordAuthenticationProvider;
import com.gitblit.models.TeamModel;
import com.gitblit.models.UserModel;
import com.gitblit.service.LdapSyncService;
import com.gitblit.utils.ArrayUtils;
import com.gitblit.utils.StringUtils;
import com.unboundid.ldap.sdk.Attribute;
@@ -57,33 +60,38 @@
 */
public class LdapAuthProvider extends UsernamePasswordAuthenticationProvider {

    private AtomicLong lastLdapUserSync = new AtomicLong(0L);
    private final AtomicLong lastLdapUserSync = new AtomicLong(0L);

   public LdapAuthProvider() {
      super("ldap");
   }

    private long getSynchronizationPeriod() {
        final String cacheDuration = settings.getString(Keys.realm.ldap.ldapCachePeriod, "2 MINUTES");
    private long getSynchronizationPeriodInMilliseconds(String name) {
        final String cacheDuration = settings.getString(name, "2 MINUTES");
        try {
            final String[] s = cacheDuration.split(" ", 2);
            long duration = Long.parseLong(s[0]);
            long duration = Math.abs(Long.parseLong(s[0]));
            TimeUnit timeUnit = TimeUnit.valueOf(s[1]);
            return timeUnit.toMillis(duration);
        } catch (RuntimeException ex) {
            throw new IllegalArgumentException(Keys.realm.ldap.ldapCachePeriod + " must have format '<long> <TimeUnit>' where <TimeUnit> is one of 'MILLISECONDS', 'SECONDS', 'MINUTES', 'HOURS', 'DAYS'");
            throw new IllegalArgumentException(name + " must have format '<long> <TimeUnit>' where <TimeUnit> is one of 'MILLISECONDS', 'SECONDS', 'MINUTES', 'HOURS', 'DAYS'");
        }
    }

   @Override
   public void setup() {
      synchronizeLdapUsers();
      configureLdapSyncService();
   }
	
   public void synchronizeWithLdapService() {
      synchronizeLdapUsers();
   }

   protected synchronized void synchronizeLdapUsers() {
        final boolean enabled = settings.getBoolean(Keys.realm.ldap.synchronizeUsers.enable, false);
        if (enabled) {
            if (System.currentTimeMillis() > (lastLdapUserSync.get() + getSynchronizationPeriod())) {
            if (System.currentTimeMillis() > (lastLdapUserSync.get() + getSynchronizationPeriodInMilliseconds(Keys.realm.ldap.ldapCachePeriod))) {
               logger.info("Synchronizing with LDAP @ " + settings.getRequiredString(Keys.realm.ldap.server));
                final boolean deleteRemovedLdapUsers = settings.getBoolean(Keys.realm.ldap.synchronizeUsers.removeDeleted, true);
                LDAPConnection ldapConnection = getLdapConnection();
@@ -144,6 +152,9 @@
                                userManager.updateTeamModels(userTeams.values());
                            }
                        }
                        if (!supportsTeamMembershipChanges()) {
                           getEmptyTeamsFromLdap(ldapConnection);
                        }
                        lastLdapUserSync.set(System.currentTimeMillis());
                    } finally {
                        ldapConnection.close();
@@ -162,15 +173,20 @@
         String bindUserName = settings.getString(Keys.realm.ldap.username, "");
         String bindPassword = settings.getString(Keys.realm.ldap.password, "");


         LDAPConnection conn;
         if (ldapUrl.getScheme().equalsIgnoreCase("ldaps")) {
            // SSL
            SSLUtil sslUtil = new SSLUtil(new TrustAllTrustManager());
            conn = new LDAPConnection(sslUtil.createSSLSocketFactory());
            if (ldapPort == -1) {
               ldapPort = 636;
            }
         } else if (ldapUrl.getScheme().equalsIgnoreCase("ldap") || ldapUrl.getScheme().equalsIgnoreCase("ldap+tls")) {
            // no encryption or StartTLS
            conn = new LDAPConnection();
             if (ldapPort == -1) {
                ldapPort = 389;
             }
         } else {
            logger.error("Unsupported LDAP URL scheme: " + ldapUrl.getScheme());
            return null;
@@ -187,7 +203,11 @@
            }
         }

         if (!StringUtils.isEmpty(bindUserName) || !StringUtils.isEmpty(bindPassword)) {
         if (StringUtils.isEmpty(bindUserName) && StringUtils.isEmpty(bindPassword)) {
            // anonymous bind
            conn.bind(new SimpleBindRequest());
         } else {
            // authenticated bind
            conn.bind(new SimpleBindRequest(bindUserName, bindPassword));
         }

@@ -280,16 +300,17 @@
                  UserModel user = null;
                  synchronized (this) {
                     user = userManager.getUserModel(simpleUsername);
                     if (user == null)   // create user object for new authenticated user
                     if (user == null) {
                        // create user object for new authenticated user
                        user = new UserModel(simpleUsername);

                     // create a user cookie
                     if (StringUtils.isEmpty(user.cookie) && !ArrayUtils.isEmpty(password)) {
                        user.cookie = StringUtils.getSHA1(user.username + new String(password));
                     }

                     if (!supportsTeamMembershipChanges())
                     // create a user cookie
                     setCookie(user, password);

                     if (!supportsTeamMembershipChanges()) {
                        getTeamsFromLdap(ldapConnection, simpleUsername, loggingInUser, user);
                     }

                     // Get User Attributes
                     setUserAttributes(user, loggingInUser);
@@ -298,8 +319,9 @@
                     updateUser(user);

                     if (!supportsTeamMembershipChanges()) {
                        for (TeamModel userTeam : user.teams)
                        for (TeamModel userTeam : user.teams) {
                           updateTeam(userTeam);
                        }
                     }
                  }

@@ -328,12 +350,13 @@
         if (!ArrayUtils.isEmpty(admins)) {
            user.canAdmin = false;
            for (String admin : admins) {
               if (admin.startsWith("@")) { // Team
                  if (user.getTeam(admin.substring(1)) != null)
                     user.canAdmin = true;
               } else
                  if (user.getName().equalsIgnoreCase(admin))
                     user.canAdmin = true;
               if (admin.startsWith("@") && user.isTeamMember(admin.substring(1))) {
                  // admin team
                  user.canAdmin = true;
               } else if (user.getName().equalsIgnoreCase(admin)) {
                  // admin user
                  user.canAdmin = true;
               }
            }
         }
      }
@@ -352,9 +375,9 @@
      if (!StringUtils.isEmpty(displayName)) {
         // Replace embedded ${} with attributes
         if (displayName.contains("${")) {
            for (Attribute userAttribute : userEntry.getAttributes())
            for (Attribute userAttribute : userEntry.getAttributes()) {
               displayName = StringUtils.replace(displayName, "${" + userAttribute.getName() + "}", userAttribute.getValue());

            }
            user.displayName = displayName;
         } else {
            Attribute attribute = userEntry.getAttribute(displayName);
@@ -368,9 +391,9 @@
      String email = settings.getString(Keys.realm.ldap.email, "");
      if (!StringUtils.isEmpty(email)) {
         if (email.contains("${")) {
            for (Attribute userAttribute : userEntry.getAttributes())
            for (Attribute userAttribute : userEntry.getAttributes()) {
               email = StringUtils.replace(email, "${" + userAttribute.getName() + "}", userAttribute.getValue());

            }
            user.emailAddress = email;
         } else {
            Attribute attribute = userEntry.getAttribute(email);
@@ -384,7 +407,9 @@
   private void getTeamsFromLdap(LDAPConnection ldapConnection, String simpleUsername, SearchResultEntry loggingInUser, UserModel user) {
      String loggingInUserDN = loggingInUser.getDN();

      user.teams.clear();      // Clear the users team memberships - we're going to get them from LDAP
      // Clear the users team memberships - we're going to get them from LDAP
      user.teams.clear();

      String groupBase = settings.getString(Keys.realm.ldap.groupBase, "");
      String groupMemberPattern = settings.getString(Keys.realm.ldap.groupMemberPattern, "(&(objectClass=group)(member=${dn}))");

@@ -411,6 +436,29 @@
            teamModel.addUser(user.getName());
         }
      }
   }

   private void getEmptyTeamsFromLdap(LDAPConnection ldapConnection) {
      logger.info("Start fetching empty teams form ldap.");
      String groupBase = settings.getString(Keys.realm.ldap.groupBase, "");
      String groupMemberPattern = settings.getString(Keys.realm.ldap.groupEmptyMemberPattern, "(&(objectClass=group)(!(member=*)))");

      SearchResult teamMembershipResult = doSearch(ldapConnection, groupBase, true, groupMemberPattern, null);
      if (teamMembershipResult != null && teamMembershipResult.getEntryCount() > 0) {
         for (int i = 0; i < teamMembershipResult.getEntryCount(); i++) {
            SearchResultEntry teamEntry = teamMembershipResult.getSearchEntries().get(i);
            if (!teamEntry.hasAttribute("member")) {
               String teamName = teamEntry.getAttribute("cn").getValue();
	
               TeamModel teamModel = userManager.getTeamModel(teamName);
               if (teamModel == null) {
                  teamModel = createTeamFromLdap(teamEntry);
                  userManager.updateTeamModel(teamModel);
               }
            }
         }
      }
      logger.info("Finished fetching empty teams form ldap.");
   }

   private TeamModel createTeamFromLdap(SearchResultEntry teamEntry) {
@@ -505,4 +553,25 @@
      }
      return sb.toString();
   }

   private void configureLdapSyncService() {
      logger.info("Start configuring ldap sync service");
      LdapSyncService ldapSyncService = new LdapSyncService(settings, this);
      if (ldapSyncService.isReady()) {
         long ldapSyncPeriod = getSynchronizationPeriodInMilliseconds(Keys.realm.ldap.synchronizeUsers.ldapSyncPeriod);
         long ldapCachePeriod = getSynchronizationPeriodInMilliseconds(Keys.realm.ldap.synchronizeUsers.ldapSyncPeriod);
         if (ldapSyncPeriod < ldapCachePeriod) {
            ldapSyncPeriod = ldapCachePeriod;
         }
         int delay = 1;
         ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
         scheduledExecutorService.scheduleAtFixedRate(ldapSyncService, delay, ldapSyncPeriod,  TimeUnit.MILLISECONDS);
         logger.info("Ldap sync service will update user and groups every {} minutes.", ldapSyncPeriod);
         logger.info("Next scheduled ldap sync is in {} minutes", delay);
      } else {
         logger.info("Ldap sync service is disabled.");
      }
      logger.info("Finished configuring ldap sync service");
   }

}