Merge spurious changes in master and ignore them.

Author: adobeDan

README.md

@@ -40,6 +40,22 @@ Requirements:
 
 To build, run `make pex` from the command line in the main repo directory.
 
+## Build Instructions for local execution and debugging on Windows
+
+First, there are several projects that do not have good 64 bit builds for Windows platforms.  These are enum34, python_ldap, and pyYaml.  Acceptable builds are in the misc/build/Win64 folder and these can be used directly.  You can also check http://www.lfd.uci.edu/~gohlke/pythonlibs/
+
+Load dependencies into interpreter directory:
+    
+	pip install -r misc\build\Win64\python-ldap-requirements.txt
+  pip install -r misc\build\requirements.txt
+
+The requirements will usually be loaded into C:\Python27\lib\site-packages if C:\Python27 is your install directory and you aren't specifying any options that send things elsewhere.
+
+To set up PyCharm for debugging, 
+1. Make sure you are using 64 bit python interpreter.  File Settings Project Interpreter
+2. Make sure interprter isn't overridden in run configuration
+3. Set up a run configuration based on Python that references the user_sync\app.py file as the script, and has the command line parameters you want to test with (e.g. --users file test.csv).  Working directory works best as the folder with your config files.
+
 # Basic Usage
 
 ```

user_sync/config.py

@@ -205,10 +205,15 @@ def get_directory_groups(self):
 
             dashboard_groups_config = item.get_list_config('dashboard_groups')
             for dashboard_group in dashboard_groups_config.iter_values(types.StringTypes):
-                group = self.create_dashboard_group(dashboard_group)
-                if (group is None):
+                parts = dashboard_group.split(GROUP_NAME_DELIMITER)
+                group_name = parts.pop()
+                organization_name = GROUP_NAME_DELIMITER.join(parts)
+                if (len(organization_name) == 0):
+                    organization_name = user_sync.rules.OWNING_ORGANIZATION_NAME
+                if (len(group_name) == 0):
                     validation_message = 'Bad dashboard group: "%s" in directory group: "%s"' % (dashboard_group, directory_group)
-                    raise user_sync.error.AssertionException(validation_message)
+                    raise user_sync.error.AssertionException(validation_message)                    
+                group = user_sync.rules.Group(group_name, organization_name)
                 groups.append(group)
 
         return adobe_groups_by_directory_group

user_sync/connector/directory.py

@@ -40,11 +40,10 @@ def initialize(self, options = {}):
         '''
         self.state = self.implementation.connector_initialize(options)
 
-    def load_users_and_groups(self, groups, extended_attributes=None):
+    def load_users_and_groups(self, groups):
         '''
         :type groups: list(str)
-        :type extended_attributes: list(str)
         :rtype (bool, iterable(dict))
         '''
-        return self.implementation.connector_load_users_and_groups(self.state, groups, extended_attributes)
+        return self.implementation.connector_load_users_and_groups(self.state, groups)        
 

user_sync/connector/directory_csv.py

@@ -37,16 +37,12 @@ def connector_initialize(options):
     state = CSVDirectoryConnector(options)
     return state
 
-def connector_load_users_and_groups(state, groups, extended_attributes):
+def connector_load_users_and_groups(state, groups):
     '''
     :type state: CSVDirectoryConnector
     :type groups: list(str)
-    :type extended_attributes: list(str)
     :rtype (bool, iterable(dict))
     '''
-
-    # CSV supports arbitrary aka "extended" attrs by default, so the value of extended_attributes has no impact on this particular connector
-
     return state.load_users_and_groups(groups)
 
 class CSVDirectoryConnector(object):

user_sync/connector/directory_ldap.py

@@ -39,14 +39,13 @@ def connector_initialize(options):
     connector = LDAPDirectoryConnector(options)
     return connector
 
-def connector_load_users_and_groups(state, groups, extended_attributes):
+def connector_load_users_and_groups(state, groups):
     '''
     :type state: LDAPDirectoryConnector
     :type groups: list(str)
-    :type extended_attributes: list(str)
     :rtype (bool, iterable(dict))
     '''
-    return state.load_users_and_groups(groups, extended_attributes)
+    return state.load_users_and_groups(groups)
 
 class LDAPDirectoryConnector(object):
     name = 'ldap'
@@ -104,10 +103,9 @@ def __init__(self, caller_options):
         self.connection = connection
         logger.info('Connected')            
 
-    def load_users_and_groups(self, groups, extended_attributes):
+    def load_users_and_groups(self, groups):
         '''
         :type groups: list(str)
-        :type extended_attributes: list(str)
         :rtype (bool, iterable(dict))
         '''
         options = self.options
@@ -127,12 +125,12 @@ def load_users_and_groups(self, groups, extended_attributes):
 
         self.user_by_dn = user_by_dn = {}
         self.user_by_uid = user_by_uid = {}
-        for user_dn, user in self.iter_users(users_filter, extended_attributes):
+        for user_dn, user in self.iter_users(users_filter):
             uid = user.get('uid')
             if (uid != None):
                 user_by_uid[uid] = user
             user_by_dn[user_dn] = user
-
+        
         self.logger.info('Total users loaded: %d', len(user_by_dn))
 
         for group in groups:
@@ -252,11 +250,11 @@ def iter_ldap_group_members(self, group):
                 for attribute_value in attribute_values:
                     yield (attribute, attribute_value)
 
-    def iter_users(self, users_filter, extended_attributes):
+    def iter_users(self, users_filter):
         options = self.options
         base_dn = options['base_dn']
-
-        user_attribute_names = ["givenName", "sn", "c", "uid"]
+        
+        user_attribute_names = ["givenName", "sn", "c", "uid"]    
         user_attribute_names.extend(self.user_email_formatter.get_attribute_names())
         user_attribute_names.extend(self.user_username_formatter.get_attribute_names())
         user_attribute_names.extend(self.user_domain_formatter.get_attribute_names())
@@ -274,53 +272,35 @@ def iter_users(self, users_filter, extended_attributes):
                 if (last_attribute_name != None):
                     self.logger.warn('No email attribute: %s for dn: %s', last_attribute_name, dn)
                 continue
-
-            source_attributes = {}
 
             user = user_sync.connector.helper.create_blank_user()
-            source_attributes['email'] = email
             user['email'] = email
-
+                
             username, last_attribute_name = self.user_username_formatter.generate_value(record)
-            source_attributes['username'] = username
             if (username == None and last_attribute_name != None):
                 self.logger.info('No username attribute: %s for dn: %s', last_attribute_name, dn)    
             user['username'] = username if username != None else email
-
+                    
             domain, last_attribute_name = self.user_domain_formatter.generate_value(record)
-            source_attributes['domain'] = domain
             if (domain != None):
                 user['domain'] = domain
             elif (last_attribute_name != None):
                 self.logger.info('No domain attribute: %s for dn: %s', last_attribute_name, dn)    
 
             given_name_value = LDAPValueFormatter.get_attribute_value(record, 'givenName')
-            source_attributes['givenName'] = given_name_value
-            if (given_name_value != None):
+            if (given_name_value != None):   
                 user['firstname'] = given_name_value
             sn_value = LDAPValueFormatter.get_attribute_value(record, 'sn')
-            source_attributes['sn'] = sn_value
             if sn_value != None:
                 user['lastname'] = sn_value
             c_value = LDAPValueFormatter.get_attribute_value(record, 'c')
-            source_attributes['c'] = c_value
             if c_value != None:
                 user['country'] = c_value
-
+                
             uid = LDAPValueFormatter.get_attribute_value(record, 'uid')
-            source_attributes['uid'] = uid
             if (uid != None):
                 user['uid'] = uid
-
-            if extended_attributes is not None:
-                for extended_attribute in extended_attributes:
-                    extended_attribute_value = LDAPValueFormatter.get_attribute_value(record, extended_attribute)
-                    source_attributes[extended_attribute] = extended_attribute_value
-
-            # [TODO morr 2017-02-26]: Could be omitted if no hook; worth considering?
-            # [TODO morr 2017-02-28]: Is the copy necessary? Could just assign I think
-            user['source_attributes'] = source_attributes.copy()
-
+            
             yield (dn, user)
 
     def iter_search_result(self, base_dn, scope, filter_string, attributes):

user_sync/rules.py

@@ -57,19 +57,6 @@ def __init__(self, caller_options):
         self.filtered_directory_user_by_user_key = {}
         self.organization_info_by_organization = {}
         self.adding_dashboard_user_key = set()
-
-        # in/out variables for per-user after-mapping-hook code
-        self.after_mapping_hook_scope = {
-            'hook_storage': None,           # for exclusive use by hook code; persists across calls
-            'source_attributes': None,      # in: attributes retrieved from customer directory system (eg 'c', 'givenName')
-                                            # out: N/A
-            'source_groups': None,          # in: customer-side directory groups found for user
-                                            # out: N/A
-            'target_attributes': None,      # in: user's attributes for UMAPI calls as defined by usual rules (eg 'country', 'firstname')
-                                            # out: user's attributes for UMAPI calls as potentially changed by hook code
-            'target_groups': None,          # in: Adobe-side dashboard groups mapped for user by usual rules
-                                            # out: Adobe-side dashboard groups as potentially changed by hook code
-        }
 
         remove_user_key_list = options['remove_user_key_list']
         remove_user_key_list = set(remove_user_key_list) if (remove_user_key_list != None) else set()
@@ -144,7 +131,6 @@ def read_desired_user_groups(self, mappings, directory_connector):
         directory_group_filter = options['directory_group_filter']
         if (directory_group_filter != None):
             directory_group_filter = set(directory_group_filter)
-        extended_attributes = options.get('extended_attributes')
 
         directory_user_by_user_key = self.directory_user_by_user_key        
         filtered_directory_user_by_user_key = self.filtered_directory_user_by_user_key
@@ -153,7 +139,7 @@ def read_desired_user_groups(self, mappings, directory_connector):
         directory_groups = set(mappings.iterkeys())
         if (directory_group_filter != None):
             directory_groups.update(directory_group_filter)
-        all_loaded, directory_users = directory_connector.load_users_and_groups(directory_groups, extended_attributes)
+        all_loaded, directory_users = directory_connector.load_users_and_groups(directory_groups) 
         if (not all_loaded and self.need_to_process_orphaned_dashboard_users):
             self.logger.warn('Not all users loaded.  Cannot check orphaned users...')
             self.need_to_process_orphaned_dashboard_users = False
@@ -171,12 +157,7 @@ def read_desired_user_groups(self, mappings, directory_connector):
 
             filtered_directory_user_by_user_key[user_key] = directory_user
             self.get_organization_info(OWNING_ORGANIZATION_NAME).add_desired_group_for(user_key, None)
-
-            # set up groups in hook scope; the target groups will be used whether or not there's customer hook code
-            self.after_mapping_hook_scope['source_groups'] = set()
-            self.after_mapping_hook_scope['target_groups'] = set()
             for group in directory_user['groups']:
-                self.after_mapping_hook_scope['source_groups'].add(group) # this is a directory group name
                 dashboard_groups = mappings.get(group)
                 if (dashboard_groups != None):
                     for dashboard_group in dashboard_groups:
@@ -708,21 +689,7 @@ def read_remove_list(file_path, delimiter = None, logger = None):
             if (user_key != None):
                 result.append(user_key)
         return result
-
-    def make_dashboard_group_qualified_name(self, group_name, organization_name):
-        prefix = ""
-        if (organization_name is not None and organization_name != OWNING_ORGANIZATION_NAME):
-            prefix = organization_name + user_sync.config.GROUP_NAME_DELIMITER
-        return prefix + group_name
-
-    def parse_dashboard_group_qualified_name(self, qualified_name):
-        parts = qualified_name.split(user_sync.config.GROUP_NAME_DELIMITER)
-        group_name = parts.pop()
-        organization_name = user_sync.config.GROUP_NAME_DELIMITER.join(parts)
-        if (len(organization_name) == 0):
-            organization_name = user_sync.rules.OWNING_ORGANIZATION_NAME
-        return group_name, organization_name
-
+    
     def write_remove_list(self, file_path, dashboard_users):
         total_users = 0
         with open(file_path, 'wb') as output_file:
@@ -735,18 +702,8 @@ def write_remove_list(self, file_path, dashboard_users):
                 writer.writerow({'user': username, 'domain': domain})
                 total_users += 1
         self.logger.info('Total users in remove list: %d', total_users)
-
-    def log_after_mapping_hook_scope(self, before_call=None, after_call=None):
-        if ((before_call is None and after_call is None) or (before_call is not None and after_call is not None)):
-            raise ValueError("Exactly one of 'before_call', 'after_call' must be passed (and not None)")
-        when = 'before' if before_call is not None else 'after'
-        if (before_call is not None):
-            self.logger.debug('.')
-            self.logger.debug('Source attrs, %s: %s', when, self.after_mapping_hook_scope['source_attributes'])
-            self.logger.debug('Source groups, %s: %s', when, self.after_mapping_hook_scope['source_groups'])
-        self.logger.debug('Target attrs, %s: %s', when, self.after_mapping_hook_scope['target_attributes'])
-        self.logger.debug('Target groups, %s: %s', when, self.after_mapping_hook_scope['target_groups'])
-
+                
+        
 class DashboardConnectors(object):
     def __init__(self, owning_connector, accessor_connectors):
         '''
@@ -778,17 +735,13 @@ def execute_actions(self):
                 break
 
 class Group(object):
-
-    dashboard_groups = {}
-
     def __init__(self, group_name, organization_name):
         '''
         :type group_name: str
         :type organization_name: str        
         '''
         self.group_name = group_name
         self.organization_name = organization_name
-        Group.dashboard_groups[(group_name, organization_name)] = self
 
     def __eq__(self, other):
         return self.__dict__ == other.__dict__
@@ -801,15 +754,7 @@ def __hash__(self):
 
     def __str__(self):
         return str(self.__dict__)
-
-    @classmethod
-    def get_dashboard_group(cls, group_name, organization_name):
-        '''
-        :type group_name: str
-        :type organization_name: str
-        '''
-        return Group.dashboard_groups.get((group_name, organization_name))
-
+        
 class OrganizationInfo(object):
     def __init__(self, name):
         '''