Changeset 796


Ignore:
Timestamp:
05/12/11 23:10:39 (8 years ago)
Author:
philsmart
Message:
 
Location:
raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor
Files:
9 edited
1 moved

Legend:

Unmodified
Added
Removed
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/registry/ReleaseInformation.java

    r790 r796  
    7777                                lastReleasedEventTime = event.getEventTime(); 
    7878                                latestEqualEntries.clear(); 
    79                                 int hashcode = 0; 
    80                                 try { 
    81                                         hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)).intValue(); 
    82                                 } catch (Exception e) { 
    83                                     log.error("Could not get hashcode for event {}", event); 
    84                                 } 
    85                                 latestEqualEntries.add(hashcode); 
     79                                latestEqualEntries.add(event.getEventId()); 
    8680                        } 
    8781                        else if (event.getEventTime().isEqual(lastReleasedEventTime)){ 
    88                             int hashcode = 0; 
    89                             try { 
    90                                     hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)).intValue(); 
    91                             } catch (Exception e) { 
    92                                 log.error("Could not get hashcode for event {}", event); 
    93                             } 
    94                             latestEqualEntries.add(hashcode); 
     82                            latestEqualEntries.add(event.getEventId()); 
    9583                        } 
    9684                } 
     
    118106 
    119107        else if (event.getEventTime().isEqual(getLastReleasedEventTime())){ 
    120             int hashcode = 0; 
    121             try { 
    122                     hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)).intValue(); 
    123             } catch (Exception e) { 
    124                 log.error("Could not get hashcode for event {}, event not stored", event); 
    125             } 
    126             return !latestEqualEntries.contains(hashcode); 
     108            return !latestEqualEntries.contains(event.getEventId()); 
    127109        } 
    128110 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/remoting/client/EventReleaseClient.java

    r790 r796  
    2525import uk.ac.cardiff.raptor.registry.Endpoint; 
    2626import uk.ac.cardiff.raptor.registry.EndpointRegistry; 
    27 import uk.ac.cardiff.raptor.registry.EventReleaseEngine; 
    2827 
    2928/** 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/remoting/client/EventReleaseEngine.java

    r792 r796  
    1717 * 
    1818 */ 
    19 package uk.ac.cardiff.raptor.registry; 
     19package uk.ac.cardiff.raptor.remoting.client; 
    2020 
    2121import java.util.ArrayList; 
     
    2424 
    2525import uk.ac.cardiff.raptor.attribute.filtering.AttrributeFilterEngine; 
     26import uk.ac.cardiff.raptor.registry.Endpoint; 
     27import uk.ac.cardiff.raptor.registry.EndpointRegistry; 
    2628import uk.ac.cardiff.raptor.remoting.client.sei.ServiceEndpointClient; 
    2729import uk.ac.cardiff.raptor.remoting.policy.PushPolicy; 
     
    105107        ArrayList<Event> applicableEvents = new ArrayList<Event>(); 
    106108 
    107         return applicableEvents; 
     109        return events; 
    108110    } 
    109111 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/remoting/client/impl/EventReleaseClientImpl.java

    r790 r796  
    2525import uk.ac.cardiff.raptor.registry.Endpoint; 
    2626import uk.ac.cardiff.raptor.registry.EndpointRegistry; 
    27 import uk.ac.cardiff.raptor.registry.EventReleaseEngine; 
    2827import uk.ac.cardiff.raptor.remoting.client.EventReleaseClient; 
     28import uk.ac.cardiff.raptor.remoting.client.EventReleaseEngine; 
    2929import uk.ac.cardiff.raptor.remoting.client.ReleaseFailureException; 
    3030 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/remoting/policy/ElapsedTimePushPolicy.java

    r672 r796  
    2222 
    2323import uk.ac.cardiff.model.event.Event; 
    24 import uk.ac.cardiff.raptor.registry.EventReleaseEngine; 
     24import uk.ac.cardiff.raptor.remoting.client.EventReleaseEngine; 
    2525 
    2626public class ElapsedTimePushPolicy extends PushPolicy{ 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/remoting/policy/EntryNoElapsedTimePushPolicy.java

    r775 r796  
    2222 
    2323import uk.ac.cardiff.model.event.Event; 
    24 import uk.ac.cardiff.raptor.registry.EventReleaseEngine; 
     24import uk.ac.cardiff.raptor.remoting.client.EventReleaseEngine; 
    2525 
    2626/** 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/runtimeutils/ReflectionHelper.java

    r790 r796  
    535535     * @param event 
    536536     */ 
    537     public static Integer getHashCodeFromEventOrNull(Event event) { 
     537    public static int getHashCodeFromEventOrNull(Event event) { 
    538538        try { 
    539                 int hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)).intValue(); 
     539                int hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)); 
    540540                return hashcode; 
    541541        } catch (Exception e) { 
    542             return null; 
     542            return 0; 
    543543        } 
    544544 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/impl/LogFileMemoryEntryHandler.java

    r790 r796  
    3131 
    3232import uk.ac.cardiff.model.event.Event; 
     33import uk.ac.cardiff.model.event.ShibbolethIdpAuthenticationEvent; 
    3334import uk.ac.cardiff.raptor.runtimeutils.ReflectionHelper; 
    3435import uk.ac.cardiff.raptor.store.EntryHandler; 
     
    7374 
    7475        /** 
    75          * If newer entry, just add to the set. If equal, first check the 
    76          * <code>latestEqualEntries</code> set, if contained in this set, then it 
    77          * has already been added. If not add. Importantly, we do not just add to 
    78          * the entries set (which would not allow duplicates) because the set is 
    79          * cleared when information is sent to the UA. 
    80          * 
    81          * @return true if this event was added to the entry handler, false otherwise 
     76         * First copy the hash of this entry into the <code>eventId</code> column if 
     77         * its empty. Then, add to the entry set iff its a newer entry. If equal, 
     78         * first check the <code>latestEqualEntries</code> set, if contained in this 
     79         * set, then it has already been added, if not add. 
     80         *  
     81         * @return true if this event was added to the entry handler, false 
     82         *         otherwise 
    8283         */ 
    8384        public boolean addEntry(Event event) { 
     85                addEventIdIfNull(event); 
    8486                boolean isAfter = isAfter(event); 
    8587                boolean isEqual = isEqual(event); 
     
    104106        } 
    105107 
     108        /** 
     109         * Stores the hashcode of the event as the <code>eventId</code> iff there is 
     110         * no existing eventId (defined as 0), and the event has a valid hashcode. 
     111         *  
     112         * @param event 
     113         */ 
     114        private void addEventIdIfNull(Event event) { 
     115                if (event.getEventId() != 0) { 
     116                        return; 
     117                } 
     118                int hashCode = ReflectionHelper.getHashCodeFromEventOrNull(event); 
     119                if (hashCode != 0) { 
     120                        event.setEventId(hashCode); 
     121                } 
     122        } 
     123 
    106124        public void removeEventsBefore(DateTime earliestReleaseTime, Set<Integer> latestEqualEntries) { 
    107                         log.debug("Removing events earlier than {}, or in the set of last equal events sent (from {} events)",earliestReleaseTime, 
    108                                 latestEqualEntries.size()); 
    109                         ArrayList<Event> toRemove = new ArrayList<Event>(); 
    110                         for (Event event : entries){ 
    111                                 if (event.getEventTime().isBefore(earliestReleaseTime)) 
    112                                                 toRemove.add(event); 
    113                                 if (event.getEventTime().isEqual(earliestReleaseTime)){ 
    114                                     int hashcode = 0; 
    115                                     try { 
    116                                             hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)).intValue(); 
    117                                     } catch (Exception e) { 
    118                                         log.error("Could not get hashcode for event {}", event); 
    119                                     } 
    120                                     if (latestEqualEntries.contains(hashcode)){ 
    121                                         toRemove.add(event); 
    122                                     } 
     125                log.debug("Removing events earlier than {}, or in the set of last equal events sent (from {} events)", earliestReleaseTime, latestEqualEntries.size()); 
     126                ArrayList<Event> toRemove = new ArrayList<Event>(); 
     127                for (Event event : entries) { 
     128                        if (event.getEventTime().isBefore(earliestReleaseTime)) 
     129                                toRemove.add(event); 
     130                        if (event.getEventTime().isEqual(earliestReleaseTime)) { 
     131                                if (latestEqualEntries.contains(event.getEventId())) { 
     132                                        toRemove.add(event); 
    123133                                } 
    124134                        } 
    125                         entries.removeAll(toRemove); 
     135                } 
     136                entries.removeAll(toRemove); 
    126137 
    127138        } 
     
    242253        } 
    243254 
    244    /** 
    245     * This is a no-op method for all in-memory entry handlers 
    246     */ 
    247     public List query(String query, Object[] parameters, int maxNoResults) { 
    248         return null; 
    249     } 
    250  
    251  
     255        /** 
     256         * This is a no-op method for all in-memory entry handlers 
     257         */ 
     258        public List query(String query, Object[] parameters, int maxNoResults) { 
     259                return null; 
     260        } 
    252261 
    253262} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/impl/MemoryEntryHandler.java

    r790 r796  
    3939import org.slf4j.LoggerFactory; 
    4040 
    41  
    42 public class MemoryEntryHandler implements EntryHandler{ 
    43  
    44         /** Class logger */ 
     41public class MemoryEntryHandler implements EntryHandler { 
     42 
     43        /** Class logger */ 
    4544        private final Logger log = LoggerFactory.getLogger(MemoryEntryHandler.class); 
    4645 
    47         /** pointer to the last recorded entry, for incremental update*/ 
     46        /** pointer to the last recorded entry, for incremental update */ 
    4847        private DateTime latestEntryTime; 
    4948 
    50         /** record of the last entry that was sent over SOAP*/ 
     49        /** record of the last entry that was sent over SOAP */ 
    5150        private DateTime lastPublishedEntryTime; 
    5251 
     
    5453        private Set<Event> entries; 
    5554 
    56  
    57         public MemoryEntryHandler(){ 
     55        public MemoryEntryHandler() { 
    5856                entries = new LinkedHashSet<Event>(); 
    5957        } 
    6058 
    61         public void addEntries(List<Event> entries){ 
    62                 log.debug("Current: "+this.entries.size()+" in: "+entries.size()); 
     59        public void addEntries(List<Event> entries) { 
     60                log.debug("Current: " + this.entries.size() + " in: " + entries.size()); 
    6361                int notAdded = 0; 
    64                 for (Event event: entries){ 
    65                     boolean didAdd = addEntry(event); 
    66                     if (didAdd==false) 
    67                         notAdded++; 
    68  
    69                 } 
    70                 log.debug("Total No. of Entries {}, Lastest Entry at: {}, with {} duplicates",new Object[]{this.entries.size(),getLatestEntryTime(),notAdded}); 
    71         } 
    72  
    73  
    74  
    75         /** 
    76          * Checks whether this event is already stored, if not, then it 
    77          * adds the <code>event</code> to the <code>entries<code> set. 
    78          * 
    79          * @param event the event to store 
    80          */ 
    81         public boolean addEntry(Event event){ 
    82             if (!entries.contains(event)){ 
    83                 entries.add(event); 
    84                 updateLastEntry(event); 
    85                 return true; 
    86             } 
    87             else{ 
    88                 return false; 
    89             } 
    90  
    91         } 
    92  
    93         private void updateLastEntry(Event event){ 
     62                for (Event event : entries) { 
     63                        boolean didAdd = addEntry(event); 
     64                        if (didAdd == false) 
     65                                notAdded++; 
     66 
     67                } 
     68                log.debug("Total No. of Entries {}, Lastest Entry at: {}, with {} duplicates", new Object[] { this.entries.size(), getLatestEntryTime(), notAdded }); 
     69        } 
     70 
     71        /** 
     72         * Checks whether this event is already stored, if not, then it adds the 
     73         * <code>event</code> to the <code>entries<code> set. 
     74         *  
     75         * @param event 
     76         *            the event to store 
     77         */ 
     78        public boolean addEntry(Event event) { 
     79                addEventIdIfNull(event); 
     80                if (!entries.contains(event)) { 
     81                        entries.add(event); 
     82                        updateLastEntry(event); 
     83                        return true; 
     84                } else { 
     85                        return false; 
     86                } 
     87 
     88        } 
     89 
     90        /** 
     91         * Stores the hashcode of the event as the <code>eventId</code> iff there is 
     92         * no existing eventId (defined as 0), and the event has a valid hashcode. 
     93         *  
     94         * @param event 
     95         */ 
     96        private void addEventIdIfNull(Event event) { 
     97                if (event.getEventId() != 0) { 
     98                        return; 
     99                } 
     100                int hashCode = ReflectionHelper.getHashCodeFromEventOrNull(event); 
     101                if (hashCode != 0) { 
     102                        event.setEventId(hashCode); 
     103                } 
     104        } 
     105 
     106        private void updateLastEntry(Event event) { 
    94107                DateTime entryTime = event.getEventTime(); 
    95                 if (getLatestEntryTime()==null)setLatestEntryTime(entryTime); 
    96                 if (entryTime.isAfter(getLatestEntryTime())){ 
    97                     setLatestEntryTime(entryTime); 
     108                if (getLatestEntryTime() == null) 
     109                        setLatestEntryTime(entryTime); 
     110                if (entryTime.isAfter(getLatestEntryTime())) { 
     111                        setLatestEntryTime(entryTime); 
    98112 
    99113                } 
     
    101115 
    102116        public void removeEventsBefore(DateTime earliestReleaseTime, Set<Integer> latestEqualEntries) { 
    103             log.debug("Removing events earlier than {}, or in the set of last equal events sent (from {} events)",earliestReleaseTime, 
    104                     latestEqualEntries.size()); 
    105             ArrayList<Event> toRemove = new ArrayList<Event>(); 
    106             for (Event event : entries){ 
    107                     if (event.getEventTime().isBefore(earliestReleaseTime)) 
    108                                     toRemove.add(event); 
    109                     if (event.getEventTime().isEqual(earliestReleaseTime)){ 
    110                         int hashcode = 0; 
    111                         try { 
    112                                 hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)).intValue(); 
    113                         } catch (Exception e) { 
    114                             log.error("Could not get hashcode for event {}, event not stored", event); 
    115                         } 
    116                         if (latestEqualEntries.contains(hashcode)){ 
    117                             toRemove.add(event); 
    118                         } 
    119                     } 
    120             } 
    121             entries.removeAll(toRemove); 
    122  
    123 } 
    124  
     117                log.debug("Removing events earlier than {}, or in the set of last equal events sent (from {} events)", earliestReleaseTime, latestEqualEntries.size()); 
     118                ArrayList<Event> toRemove = new ArrayList<Event>(); 
     119                for (Event event : entries) { 
     120                        if (event.getEventTime().isBefore(earliestReleaseTime)) 
     121                                toRemove.add(event); 
     122                        if (event.getEventTime().isEqual(earliestReleaseTime)) { 
     123                                if (latestEqualEntries.contains(event.getEventId())) { 
     124                                        toRemove.add(event); 
     125                                } 
     126                        } 
     127                } 
     128                entries.removeAll(toRemove); 
     129 
     130        } 
    125131 
    126132        public void setLatestEntryTime(DateTime latestEntryTime) { 
     
    132138        } 
    133139 
    134  
    135  
    136         /** 
    137          * pushes the latestEntryTime by 1 millisecond (see LogFileParser.java for explanation) 
     140        /** 
     141         * pushes the latestEntryTime by 1 millisecond (see LogFileParser.java for 
     142         * explanation) 
    138143         */ 
    139144        public void endTransaction() { 
    140                 latestEntryTime = new DateTime(latestEntryTime.getMillis()+1); 
     145                latestEntryTime = new DateTime(latestEntryTime.getMillis() + 1); 
    141146 
    142147        } 
     
    146151         */ 
    147152        public List<Event> getEntries() { 
    148             return new ArrayList<Event>(entries); 
    149  
    150         } 
    151  
    152         /** 
    153          * Removes all entries, but does not reset last entry, as this is still 
    154          * used so as not to add previously parsed entries. 
     153                return new ArrayList<Event>(entries); 
     154 
     155        } 
     156 
     157        /** 
     158         * Removes all entries, but does not reset last entry, as this is still used 
     159         * so as not to add previously parsed entries. 
    155160         */ 
    156161        public void removeAllEntries() { 
    157             entries.clear(); 
     162                entries.clear(); 
    158163        } 
    159164 
    160165        public void setLastPublishedEntryTime(DateTime lastPublishedEntryTime) { 
    161             this.lastPublishedEntryTime = lastPublishedEntryTime; 
     166                this.lastPublishedEntryTime = lastPublishedEntryTime; 
    162167        } 
    163168 
    164169        public DateTime getLastPublishedEntryTime() { 
    165             return lastPublishedEntryTime; 
    166         } 
    167  
    168         /** 
    169          *  This is a no-op method for all in-memory entry handlers 
     170                return lastPublishedEntryTime; 
     171        } 
     172 
     173        /** 
     174         * This is a no-op method for all in-memory entry handlers 
    170175         */ 
    171176        public void initialise() { 
     
    173178        } 
    174179 
    175  
    176     public int getNumberOfEntries() { 
    177         return entries.size(); 
    178     } 
    179  
    180     /** 
    181      *  This is a no-op method for all in-memory entry handlers 
    182      */ 
    183     public List query(String query) { 
    184         return null; 
    185     } 
    186  
    187     /** 
    188      * T This is a no-op method for all in-memory entry handlers 
    189      */ 
    190     public Object queryUnique(String query) { 
    191         return null; 
    192     } 
    193  
    194     /** 
    195      *  This is a no-op method for all in-memory entry handlers 
    196      */ 
    197     public Object queryUnique(String query, Object[] parameters) { 
    198         return null; 
    199     } 
    200  
    201     public void setEntries(Set<Event> entries) { 
    202        this.entries = entries; 
    203  
    204     } 
    205  
    206     /** 
    207      *  This is a no-op method for all in-memory entry handlers 
    208      */ 
     180        public int getNumberOfEntries() { 
     181                return entries.size(); 
     182        } 
     183 
     184        /** 
     185         * This is a no-op method for all in-memory entry handlers 
     186         */ 
     187        public List query(String query) { 
     188                return null; 
     189        } 
     190 
     191        /** 
     192         * T This is a no-op method for all in-memory entry handlers 
     193         */ 
     194        public Object queryUnique(String query) { 
     195                return null; 
     196        } 
     197 
     198        /** 
     199         * This is a no-op method for all in-memory entry handlers 
     200         */ 
     201        public Object queryUnique(String query, Object[] parameters) { 
     202                return null; 
     203        } 
     204 
     205        public void setEntries(Set<Event> entries) { 
     206                this.entries = entries; 
     207 
     208        } 
     209 
     210        /** 
     211         * This is a no-op method for all in-memory entry handlers 
     212         */ 
    209213        public List query(String query, Object[] parameters) { 
    210214                return null; 
     
    212216 
    213217        /** 
    214          *  This is a no-op method for all in-memory entry handlers 
    215          */ 
    216     public List query(String query, Object[] parameters, int maxNoResults) { 
    217         return null; 
    218     } 
    219  
    220  
    221  
    222  
    223  
    224  
    225  
    226  
    227  
    228  
     218         * This is a no-op method for all in-memory entry handlers 
     219         */ 
     220        public List query(String query, Object[] parameters, int maxNoResults) { 
     221                return null; 
     222        } 
    229223 
    230224} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/impl/PersistantEntryHandler.java

    r790 r796  
    131131 
    132132                for (Event event : persistQueue) { 
    133                         Integer hashcodeInteger =  ReflectionHelper.getHashCodeFromEventOrNull(event); 
    134                         if (hashcodeInteger==null){ 
    135                             log.error("Could not get hashcode for event {}, event not stored", event); 
    136                             continue; 
    137                         } 
    138                         int hashcode = hashcodeInteger.intValue(); 
    139                         String query ="select count(*) from "+event.getClass().getSimpleName()+" where eventTime = ? and hashCode =?"; 
    140                         Object[] parameters= new Object[]{event.getEventTime().toDate(),hashcode}; 
     133                        String query ="select count(*) from "+event.getClass().getSimpleName()+" where eventTime = ? and eventId =?"; 
     134                        Object[] parameters= new Object[]{event.getEventTime().toDate(),event.getEventId()}; 
    141135                        int numberOfDuplicates = ((Integer) dataConnection.runQueryUnique(query, parameters)).intValue(); 
    142136//                      int numberOfDuplicates = ((Integer) dataConnection.runQueryUnique("select count(*) from " + event.getClass().getSimpleName() 
     
    169163 
    170164        public boolean addEntry(Event event) { 
    171                 int hashcode = 0; 
    172                 try { 
    173                         hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)).intValue(); 
    174                 } catch (Exception e) { 
    175                     log.error("Could not get hashcode for event {}, event not stored"); 
    176                     return false; 
    177                 } 
    178                 String query ="select count(*) from "+event.getClass().getSimpleName()+" where eventTime = ? and hashCode =?"; 
    179                 Object[] parameters= new Object[]{event.getEventTime().toDate(),hashcode}; 
     165                 
     166                String query ="select count(*) from "+event.getClass().getSimpleName()+" where eventTime = ? and eventId =?"; 
     167                Object[] parameters= new Object[]{event.getEventTime().toDate(),event.getEventId()}; 
    180168                int numberOfDuplicates = ((Integer) dataConnection.runQueryUnique(query, parameters)).intValue(); 
    181169 
Note: See TracChangeset for help on using the changeset viewer.