Changeset 707


Ignore:
Timestamp:
04/27/11 18:33:59 (8 years ago)
Author:
philsmart
Message:
 
Location:
raptor-client/trunk/src
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/event/expansion/AttributeAssociationDefinition.java

    r699 r707  
    33 */ 
    44package uk.ac.cardiff.raptor.event.expansion; 
     5 
     6import java.util.List; 
     7 
     8import uk.ac.cardiff.raptor.event.expansion.connector.AttributeAssociationException; 
    59 
    610/** 
     
    1216    /** The name of the field the subject's principal should be extracted from*/ 
    1317    private String subjectPrincipalField; 
     18 
     19    private List<AttributeLookup> lookupAttributes; 
     20 
     21    /** The class type that these attribute definitions are attached to*/ 
     22    private Class internalModelClass; 
     23 
     24 
     25    /** 
     26     * @return 
     27     */ 
     28    public String[] getSourceAttributesAsArray() { 
     29        String[] sourceAttributes = new String[lookupAttributes.size()]; 
     30        int i=0; 
     31        for (AttributeLookup lookupAttribute : lookupAttributes){ 
     32            sourceAttributes[i++] = lookupAttribute.getSourceAttributeName(); 
     33        } 
     34        return sourceAttributes; 
     35    } 
     36 
     37 
     38 
     39    /** 
     40     * @param attributeSourceName 
     41     * @return 
     42     */ 
     43    public String getInternalAttributeName(String attributeSourceName) throws AttributeAssociationException{ 
     44        for (AttributeLookup lookupAttribute : lookupAttributes){ 
     45               if (lookupAttribute.getSourceAttributeName().equals(attributeSourceName)) 
     46                   return lookupAttribute.getInternalAttributeName(); 
     47        } 
     48        throw new AttributeAssociationException("Source attribute "+attributeSourceName+" was not found in the attribute association mappings"); 
     49    } 
     50 
    1451 
    1552    /** 
     
    2764    } 
    2865 
     66    /** 
     67     * @param lookupAttributes the lookupAttributes to set 
     68     */ 
     69    public void setLookupAttributes(List<AttributeLookup> lookupAttributes) { 
     70        this.lookupAttributes = lookupAttributes; 
     71    } 
     72 
     73    /** 
     74     * @return the lookupAttributes 
     75     */ 
     76    public List<AttributeLookup> getLookupAttributes() { 
     77        return lookupAttributes; 
     78    } 
     79 
     80 
     81 
     82    /** 
     83     * @param internalModelClass the internalModelClass to set 
     84     */ 
     85    public void setInternalModelClass(Class internalModelClass) { 
     86        this.internalModelClass = internalModelClass; 
     87    } 
     88 
     89 
     90 
     91    /** 
     92     * @return the internalModelClass 
     93     */ 
     94    public Class getInternalModelClass() { 
     95        return internalModelClass; 
     96    } 
     97 
     98 
     99 
     100 
    29101 
    30102} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/event/expansion/AttributeAssociationEngine.java

    r699 r707  
    2020 
    2121import java.util.List; 
     22import java.util.Map; 
    2223 
    2324 
     
    7374            if (principal!=null){ 
    7475                try { 
    75                     dataConnector.lookup(principal); 
     76                    dataConnector.setReturnAttributes(attributeAssociationDefinition.getSourceAttributesAsArray()); 
     77                    Map<String, String> attributes = dataConnector.lookup(principal); 
     78                    populate(attributes,event); 
    7679                    attached++; 
    7780                } catch (AttributeAssociationException e) { 
    7881                    log.error("Association error for principal [{}]",principal,e); 
     82                } catch (InstantiationException e) { 
     83                    log.warn("Could not populate event [{}], {}",event,e.getMessage()); 
     84                } catch (IllegalAccessException e) { 
     85                    log.warn("Could not populate event [{}], {}",event,e.getMessage()); 
    7986                } 
    8087            } 
     
    8491        } 
    8592        log.info("Associated information to {} events, where {} events did not have a valid principal",attached,noPrincipal); 
     93    } 
     94 
     95    private void populate(Map<String,String> attributes, Event event) throws InstantiationException, IllegalAccessException{ 
     96 
     97        Object classToPopulate = attributeAssociationDefinition.getInternalModelClass().newInstance(); 
     98 
     99        for (Map.Entry<String,String> entry : attributes.entrySet()){ 
     100            String attributeSourceName = entry.getKey(); 
     101            String attributeValue = entry.getValue(); 
     102            log.trace("source [{}], value [{}]",attributeSourceName,attributeValue); 
     103            try{ 
     104                String internalFieldName = attributeAssociationDefinition.getInternalAttributeName(attributeSourceName); 
     105                ReflectionHelper.setValueOnObject(internalFieldName, attributeValue, classToPopulate); 
     106            } 
     107            catch(AttributeAssociationException e){ 
     108                log.warn("Error trying to populate internal model. {}",e.getMessage()); 
     109            } 
     110        } 
     111 
     112        //now attach the object where approppriate on the current <code>Event</code> object 
     113        ReflectionHelper.attachObjectTo(classToPopulate,event); 
     114 
     115        log.trace("{}",classToPopulate); 
    86116    } 
    87117 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/event/expansion/connector/DataConnector.java

    r699 r707  
    1616    public void initialise(); 
    1717 
     18    public void setReturnAttributes(String[] s); 
     19 
    1820} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/event/expansion/connector/LdapDataConnector.java

    r699 r707  
    105105    private boolean cacheResults; 
    106106 
    107  
    108     /** Name the filter template is registered under within the template engine. */ 
    109     private String filterTemplateName; 
    110  
    111     /** Template that produces the query to use. */ 
    112     private String filterTemplate; 
    113  
    114107    /** Attributes to return from ldap searches. */ 
    115108    private String[] returnAttributes; 
     
    128121 
    129122    /** Data cache. */ 
    130     private Map<String, Map<String, Map<String, Attribute<?>>>> cache; 
     123    private Map<String, Map<String, Map<String, String>>> cache; 
    131124 
    132125    /** Whether this data connector has been initialized. */ 
    133126    private boolean initialized; 
    134127 
    135  
    136     /** 
    137      * This creates a new ldap data connector with the supplied properties. 
    138      * 
    139      * @param id unique ID for this data connector 
    140      * @param ldapUrl <code>String</code> to connect to 
    141      * @param ldapBaseDn <code>String</code> to begin searching at 
    142      * @param startTls <code>boolean</code> whether connection should startTls 
    143      * @param maxIdle <code>int</code> maximum number of idle pool objects 
    144      * @param initIdleCapacity <code>int</code> initial capacity of the pool 
    145      */ 
    146     public LdapDataConnector(String ldapUrl, String ldapBaseDn, boolean startTls, int maxIdle, int initIdleCapacity) { 
    147         ldapConfig = new LdapConfig(ldapUrl, ldapBaseDn); 
    148         ldapConfig.useTls(startTls); 
    149         poolMaxIdle = maxIdle; 
    150         poolInitIdleCapacity = initIdleCapacity; 
     128    /** The ldap search filter template*/ 
     129    private String searchFilterTemplate; 
     130 
     131 
     132    /** 
     133     * This creates a new ldap data connector. 
     134     */ 
     135    public LdapDataConnector() { 
     136        ldapConfig = new LdapConfig(); 
    151137    } 
    152138 
     
    176162    protected void initializeCache() { 
    177163        if (cacheResults && initialized) { 
    178             cache = new HashMap<String, Map<String, Map<String, Attribute<?>>>>(); 
     164            cache = new HashMap<String, Map<String, Map<String, String>>>(); 
    179165        } 
    180166    } 
     
    255241    } 
    256242 
    257     /** 
    258      * Gets the template used to create queries. 
    259      * 
    260      * @return template used to create queries 
    261      */ 
    262     public String getFilterTemplate() { 
    263         return filterTemplate; 
    264     } 
    265  
    266     /** 
    267      * Sets the template used to create queries. 
    268      * 
    269      * @param template template used to create queries 
    270      */ 
    271     public void setFilterTemplate(String template) { 
    272         filterTemplate = template; 
    273         clearCache(); 
    274     } 
    275243 
    276244    /** 
     
    542510    public void setReturnAttributes(String[] s) { 
    543511        returnAttributes = s; 
    544         clearCache(); 
     512        //clearCache(); 
    545513    } 
    546514 
     
    667635    public void setPrincipal(String s) { 
    668636        ldapConfig.setServiceUser(s); 
    669         clearCache(); 
    670         initializeLdapPool(); 
    671637    } 
    672638 
     
    691657    public void setPrincipalCredential(String s) { 
    692658        ldapConfig.setServiceCredential(s); 
    693         clearCache(); 
    694         initializeLdapPool(); 
    695659    } 
    696660 
     
    715679    /** {@inheritDoc} */ 
    716680    public Map<String, String> lookup(String principal) throws AttributeAssociationException { 
    717         String searchFilter = "cn="+principal; 
     681        String searchFilter = searchFilterTemplate.replace("[principal]",principal); 
     682 
    718683        searchFilter = searchFilter.trim(); 
    719684        log.debug("Search filter: {}", searchFilter); 
     
    733698        // results not found in the cache 
    734699        if (attributes == null) { 
    735             log.debug("Retrieving attributes from LDAP"); 
     700            //log.debug("Retrieving attributes from LDAP"); 
    736701            Iterator<SearchResult> results = searchLdap(searchFilter); 
    737702            // check for empty result set 
     
    806771                throw new AttributeAssociationException("Error parsing LDAP attributes"); 
    807772            } 
    808             log.debug("Found {} attributes",newAttrsMap.size()); 
     773            //log.debug("Found {} attributes",newAttrsMap.size()); 
    809774            for (Map.Entry<String, List<String>> entry : newAttrsMap.entrySet()) { 
    810775                //log.debug("Found the following attribute: {}", entry); 
     
    812777                if(attribute == null){ 
    813778                    attribute = new String(entry.getKey()); 
    814                     attributes.put(entry.getKey(), attribute); 
     779 
    815780                } 
    816781 
    817782                List<String> values = entry.getValue(); 
     783                StringBuilder builder = new StringBuilder(); 
    818784                if(values != null && !values.isEmpty()){ 
     785                    int count=0; 
    819786                    for(String value : values){ 
    820787                        if(!DatatypeHelper.isEmpty(value)){ 
    821                            attribute = DatatypeHelper.safeTrimOrNullString(value); 
     788                            builder.append(DatatypeHelper.safeTrimOrNullString(value)); 
     789                            if (count < values.size()-1){ 
     790                                builder.append(","); 
     791                            } 
     792                            count++; 
    822793                        } 
    823794                    } 
    824795                } 
     796                attributes.put(entry.getKey(), builder.toString()); 
    825797            } 
    826798        }while (mergeMultipleResults && results.hasNext()); 
     
    828800        return attributes; 
    829801    } 
     802 
     803    /** 
     804     * @param ldapUrl the ldapUrl to set 
     805     */ 
     806    public void setLdapUrl(String ldapUrl) { 
     807        ldapConfig.setHost(ldapUrl); 
     808    } 
     809 
     810    /** 
     811     * @param ldapBaseDn the ldapBaseDn to set 
     812     */ 
     813    public void setLdapBaseDn(String ldapBaseDn) { 
     814        ldapConfig.setBase(ldapBaseDn); 
     815    } 
     816 
     817 
     818    /** 
     819     * @param startTls the startTls to set 
     820     */ 
     821    public void setStartTls(boolean startTls) { 
     822        ldapConfig.useTls(startTls); 
     823    } 
     824 
     825    /** 
     826     * @param poolMaxIdle the poolMaxIdle to set 
     827     */ 
     828    public void setPoolMaxIdle(int poolMaxIdle) { 
     829        this.poolMaxIdle = poolMaxIdle; 
     830    } 
     831 
     832    /** 
     833     * @return the poolMaxIdle 
     834     */ 
     835    public int getPoolMaxIdle() { 
     836        return poolMaxIdle; 
     837    } 
     838 
     839    /** 
     840     * @param poolInitIdleCapacity the poolInitIdleCapacity to set 
     841     */ 
     842    public void setPoolInitIdleCapacity(int poolInitIdleCapacity) { 
     843        this.poolInitIdleCapacity = poolInitIdleCapacity; 
     844    } 
     845 
     846    /** 
     847     * @return the poolInitIdleCapacity 
     848     */ 
     849    public int getPoolInitIdleCapacity() { 
     850        return poolInitIdleCapacity; 
     851    } 
     852 
     853    /** 
     854     * @param searchFilterTemplate the searchFilterTemplate to set 
     855     */ 
     856    public void setSearchFilterTemplate(String searchFilterTemplate) { 
     857        this.searchFilterTemplate = searchFilterTemplate; 
     858    } 
     859 
     860    /** 
     861     * @return the searchFilterTemplate 
     862     */ 
     863    public String getSearchFilterTemplate() { 
     864        return searchFilterTemplate; 
     865    } 
     866 
    830867 
    831868//    /** 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/runtimeutils/ReflectionHelper.java

    r699 r707  
    448448        public static Object getValueFromObject(String fieldname, Object object) { 
    449449                try { 
    450                         Class id = object.getClass(); 
     450                        Class<?> id = object.getClass(); 
    451451                        String fieldAsMethod = ReflectionHelper.prepareMethodNameGet(fieldname); 
    452452                        Method getter = id.getMethod(fieldAsMethod, new Class[] {}); 
     
    456456                        log.error("Field name '" + fieldname + "' does not match internal model attribute"); 
    457457                        e.printStackTrace(); 
    458                         // System.exit(1); 
    459458 
    460459                } 
     
    464463        public static void setValueOnObject(String fieldname, Object param, Object object) { 
    465464                try { 
    466                         Class id = object.getClass(); 
     465                        Class<?> id = object.getClass(); 
    467466                        String fieldAsMethod = ReflectionHelper.prepareMethodNameSet(fieldname); 
    468467                        Method setter = id.getMethod(fieldAsMethod, new Class[] { param.getClass() }); 
     
    470469                } catch (Throwable e) { 
    471470                        log.error("Field name '" + fieldname + "' does not match internal model attribute, or parameters are wrong"); 
    472                         // e.printStackTrace(); 
    473                         // System.exit(1); 
    474  
    475                 } 
    476         } 
     471 
     472                } 
     473        } 
     474 
     475    /** 
     476     * @param objectToAttach 
     477     * @param event 
     478     */ 
     479    public static void attachObjectTo(Object objectToAttach, Event event) { 
     480        Field[] fields = getInheritedPrivateFields(event.getClass()).toArray(new Field[0]); 
     481        Field fieldToSet = null; 
     482        for (Field field : fields){ 
     483            if (field.getType() == objectToAttach.getClass()){ 
     484                fieldToSet = field; 
     485            } 
     486        } 
     487        //now use the public accessor method to set it 
     488        String fieldName = fieldToSet.getName(); 
     489        setValueOnObject(fieldName, objectToAttach, event); 
     490    } 
     491 
     492    private static List<Field> getInheritedPrivateFields(Class<?> type) { 
     493        List<Field> result = new ArrayList<Field>(); 
     494 
     495        Class<?> i = type; 
     496        while (i != null && i != Object.class) { 
     497           for (Field field : i.getDeclaredFields()){ 
     498               result.add(field); 
     499           } 
     500           i = i.getSuperclass(); 
     501        } 
     502 
     503        return result; 
     504    } 
     505 
    477506 
    478507} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/EntryHandler.java

    r694 r707  
    3939         */ 
    4040        public void addEntries(List<Event> entries) throws StorageException; 
    41          
     41 
    4242        /** 
    43          *  
     43         * 
    4444         * @param event 
    4545         */ 
    4646        public void addEntry(Event event); 
    47          
     47 
    4848        /** 
    49          *  
     49         * 
    5050         * @return 
    5151         */ 
     
    5656         * @return 
    5757         */ 
    58         public Set<Event> getEntries(); 
     58        public List<Event> getEntries(); 
    5959 
    6060        /** 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/StoreEntriesPipelineTask.java

    r699 r707  
    2525import org.slf4j.LoggerFactory; 
    2626 
     27import uk.ac.cardiff.model.event.AuthenticationEvent; 
    2728import uk.ac.cardiff.model.event.Event; 
    2829import uk.ac.cardiff.raptor.event.expansion.AttributeAssociationEngine; 
     
    6869        } 
    6970        catch(StorageException e){ 
    70             log.error("Failed to store events asynchronously"); 
     71            log.error("Failed to store events asynchronously {}",e.getMessage(),e); 
    7172            storeCallback.storageResultCallback(new Boolean("false")); 
    7273            return false; 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/impl/MemoryEntryHandler.java

    r699 r707  
    154154         * @return the list of entries currently stored by the entry handler 
    155155         */ 
    156         public Set<Event> getEntries() { 
    157             return entries; 
     156        public List<Event> getEntries() { 
     157            return new ArrayList<Event>(entries); 
    158158 
    159159        } 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/impl/PersistantEntryHandler.java

    r699 r707  
    8282        public void initialise() { 
    8383                log.info("Persistant entry handler [{}] initialising", this); 
    84                 Integer rowCount = (Integer) dataConnection.runQueryUnique("select count(*) from Event", null); 
    85                 log.info("Persistent data store has {} entries", rowCount); 
     84                log.info("Persistent data store has {} entries for [{}]", this.getNumberOfEntries(),this); 
    8685                log.info("Persistant entry handler [{}] started", this); 
    8786        } 
     
    104103        /** 
    105104         * The <code>entries</code> are stored in the <code>persistQueue</code> until they are persisted. If an exception is thrown before 
    106          * they are persisted, they remain in the <code>persistQueue</code>.  
     105         * they are persisted, they remain in the <code>persistQueue</code>. 
    107106         * 
    108107         * @param entries the list of events that are to be stored 
     
    112111                log.info("Persistent Entry Handler has {} entries, with {} new entries inputted, and {} exist in the queue", 
    113112                                new Object[]{this.getNumberOfEntries(), entries.size(),persistQueue.size()}); 
    114                  
     113 
    115114                int duplicates = 0; 
    116115                persistQueue.addAll(entries); 
    117116                List<Event> persist = new ArrayList<Event>(); 
    118                  
     117 
    119118                for (Event event : persistQueue) { 
    120119                        int hashcode = 0; 
     
    136135                        } 
    137136                } 
    138                  
     137 
    139138                try{ 
    140139                    dataConnection.saveAll(persist); 
     
    169168        } 
    170169 
    171         public Set<Event> getEntries() { 
    172                 return (Set<Event>) dataConnection.runQuery("Select from Event",null); 
     170        public List<Event> getEntries() { 
     171                return  dataConnection.runQuery("from Event",null); 
    173172        } 
    174173 
     
    194193                return (Integer) dataConnection.runQueryUnique("select count(*) from Event", null); 
    195194        } 
    196          
     195 
    197196        public DateTime getLatestEntryTime(){ 
    198197                return (DateTime) dataConnection.runQueryUnique("select max(eventTime) from Event", null); 
  • raptor-client/trunk/src/test/java/uk/ac/cardiff/raptor/runtimeutils/ReflectionHelperTest.java

    r669 r707  
    2020import org.junit.Test; 
    2121 
     22import uk.ac.cardiff.model.event.Event; 
     23import uk.ac.cardiff.model.event.ShibbolethIdpAuthenticationEvent; 
     24import uk.ac.cardiff.model.event.auxiliary.PrincipalInformation; 
     25 
    2226public class ReflectionHelperTest { 
    23          
     27 
    2428        @Test 
    25         public void testFindClassForField(){             
     29        public void testFindClassForField(){ 
    2630                        String classForField = ReflectionHelper.findEntrySubclassForMethod("principalName"); 
    2731                        System.out.println("ShibbolethEntry = "+classForField); 
    2832                        equals(classForField.equals("ShibbolethIdpAuthenticationEvent")); 
    29                          
     33 
    3034                        classForField = ReflectionHelper.findEntrySubclassForMethod("serviceHost"); 
    3135                        System.out.println("Event = "+classForField); 
    3236                        equals(classForField.equals("Event")); 
    33                          
    34                          
     37 
     38 
     39        } 
     40 
     41        @Test 
     42        public void testAttachObjectToClass(){ 
     43            Event shibbotheIdpAuthenticationEvent = new ShibbolethIdpAuthenticationEvent(); 
     44            Object principalInformation = new PrincipalInformation(); 
     45            ReflectionHelper.attachObjectTo(principalInformation, shibbotheIdpAuthenticationEvent); 
    3546        } 
    3647 
Note: See TracChangeset for help on using the changeset viewer.