Changeset 774


Ignore:
Timestamp:
05/09/11 22:40:51 (8 years ago)
Author:
philsmart
Message:
 
Location:
raptor-client/trunk
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • raptor-client/trunk/pom.xml

    r730 r774  
    257257 
    258258    <build> 
     259        <resources> 
     260            <resource> 
     261                <directory>src/main/java/</directory> 
     262                <includes> 
     263                    <include>uk/ac/cardiff/raptor/registry/releaseInformation.hbm.xml</include> 
     264                </includes> 
     265            </resource> 
     266            <!--  DONE --> 
     267        </resources> 
    259268        <pluginManagement> 
    260269            <plugins> 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/registry/Endpoint.java

    r767 r774  
    2222import java.util.Set; 
    2323 
     24import org.slf4j.Logger; 
     25import org.slf4j.LoggerFactory; 
     26 
     27import uk.ac.cardiff.model.event.Event; 
    2428import uk.ac.cardiff.raptor.attribute.filtering.AttributeFilterPolicy; 
    2529import uk.ac.cardiff.raptor.remoting.policy.PushPolicy; 
     30import uk.ac.cardiff.raptor.store.dao.RaptorDataConnection; 
    2631 
    2732/** 
     
    3742 */ 
    3843public class Endpoint { 
     44         
     45        /** class logger */ 
     46        private final Logger log = LoggerFactory.getLogger(Endpoint.class); 
     47 
    3948 
    4049        /** The URL of the service endpoint */ 
     
    4958        /** Information about what information has been released to this endpoint */ 
    5059        private ReleaseInformation releaseInformation; 
     60 
    5161         
    5262        /** 
     
    5464         */ 
    5565        public Endpoint(){ 
    56                 releaseInformation = new ReleaseInformation(); 
     66                releaseInformation = new ReleaseInformation(serviceEndpoint); 
    5767        } 
     68         
    5869 
     70        /**  
     71         * Actions the <code>releasedPerformed</code> on the <code>releaseInformation</code> object. 
     72         *  
     73         * @param filteredEntries 
     74         */ 
     75        public void releasePerformed(List<Event> filteredEntries) { 
     76                releaseInformation.releasePerformed(filteredEntries); 
     77        } 
     78         
    5979        public void setServiceEndpoint(String serviceEndpoint) { 
    6080                this.serviceEndpoint = serviceEndpoint; 
     
    87107                return releaseInformation; 
    88108        } 
     109         
     110 
     111        /** 
     112         * Sets the releaseInformation 
     113         *  
     114         * @param releaseInformation 
     115         */ 
     116        public void setReleaseInformation(ReleaseInformation releaseInformation) { 
     117                this.releaseInformation = releaseInformation; 
     118        } 
     119 
     120 
    89121 
    90122} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/registry/EndpointRegistry.java

    r767 r774  
    2323import org.slf4j.LoggerFactory; 
    2424 
     25import uk.ac.cardiff.raptor.store.dao.RaptorDataConnection; 
     26 
    2527/** 
    2628 * @author philsmart handles the list of attached ICAs as injected by Spring 
     
    3335        /** List of endpoints for invoking methods on */ 
    3436        private List<Endpoint> endpoints; 
     37         
     38        /** Whether release information should be persisted. */ 
     39        private boolean persistReleaseInformation; 
     40         
     41        /** The data connection class to use for persisting 
     42         * release information 
     43         */ 
     44        private RaptorDataConnection dataConnection; 
    3545 
    3646        public EndpointRegistry() { 
     
    3949 
    4050        public void setEndpoints(List<Endpoint> endpoints) { 
    41                 for (Endpoint entry : endpoints) 
    42                         log.info("Registering Service Endpoint: {}", entry.getServiceEndpoint()); 
     51                for (Endpoint endpoint : endpoints){ 
     52                        log.info("Registering Service Endpoint: {}, persisting event release information {}", endpoint.getServiceEndpoint(),isPersistReleaseInformation()); 
     53                        if (isPersistReleaseInformation()){ 
     54                                ReleaseInformation releaseInformation = loadReleaseInformation(endpoint); 
     55                                if (releaseInformation!=null){ 
     56                                        endpoint.setReleaseInformation(releaseInformation); 
     57                                } 
     58                        } 
     59                         
     60                } 
    4361                this.endpoints = endpoints; 
    4462        } 
     
    4765                return endpoints; 
    4866        } 
     67         
     68 
     69        public void storeReleaseInformationIfEnabled() { 
     70                if (!isPersistReleaseInformation()) 
     71                        return; 
     72                         
     73                for (Endpoint entry : endpoints){ 
     74                        dataConnection.save(entry.getReleaseInformation()); 
     75                } 
     76                 
     77        } 
     78         
     79         
     80        public ReleaseInformation loadReleaseInformation(Endpoint endpoint){ 
     81                List releaseInfoResults = dataConnection.runQuery("from ReleaseInformation where serviceEndpoint=?",new Object[]{endpoint.getServiceEndpoint()}); 
     82                if (releaseInfoResults==null){ 
     83                        log.error("Loading error...no release information found, blank release information used"); 
     84                } 
     85                if (releaseInfoResults.size()>1){ 
     86                        log.error("Loading error...ambiguity in the persisted release information, too many results"); 
     87                } 
     88                if (releaseInfoResults.size()==1){ 
     89                        return (ReleaseInformation) releaseInfoResults.get(0); 
     90                } 
     91                return null; 
     92                 
     93        } 
     94         
     95 
     96        /** 
     97         * @param persistReleaseInformation the persistReleaseInformation to set 
     98         */ 
     99        public void setPersistReleaseInformation(boolean persistReleaseInformation) { 
     100                this.persistReleaseInformation = persistReleaseInformation; 
     101        } 
     102 
     103        /** 
     104         * @return the persistReleaseInformation 
     105         */ 
     106        public boolean isPersistReleaseInformation() { 
     107                return persistReleaseInformation; 
     108        } 
     109 
     110        /** 
     111         * @param dataConnection the dataConnection to set 
     112         */ 
     113        public void setDataConnection(RaptorDataConnection dataConnection) { 
     114                this.dataConnection = dataConnection; 
     115        } 
     116 
     117        /** 
     118         * @return the dataConnection 
     119         */ 
     120        public RaptorDataConnection getDataConnection() { 
     121                return dataConnection; 
     122        } 
     123 
    49124} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/registry/EventReleaseEngine.java

    r772 r774  
    7676                                else if (releaseSuccess ==true){ 
    7777                                        releaseCount++; 
    78                                         endpoint.getReleaseInformation().releasePerformed(filteredEntries); 
     78                                        endpoint.releasePerformed(filteredEntries); 
    7979                                        log.debug("Endpoint [{}] has been sent events up to and including {}",endpoint.getServiceEndpoint(), 
    8080                                                        endpoint.getReleaseInformation().getLastReleasedEventTime()); 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/registry/ReleaseInformation.java

    r772 r774  
    1515    /** Class logger */ 
    1616    private final Logger log = LoggerFactory.getLogger(ReleaseInformation.class); 
     17     
     18    /** Unique identifier for the persistance layer*/ 
     19    private long persistantId; 
    1720 
    1821        /** The date and time of the last entry sent to this client */ 
     
    2427         */ 
    2528        private Set<Event> latestEqualEntries; 
     29         
     30        /** 
     31         * This field is the primary key of this releaseInformation instance 
     32         * that is used to store and retrieve this object. 
     33         */ 
     34        private String serviceEndpoint; 
    2635 
    2736 
     
    3039         * Default constructor. Instantiate <code>latestEqualEntries</code> 
    3140         */ 
    32         public ReleaseInformation(){ 
     41        public ReleaseInformation(String forServiceEndpoint){ 
    3342            latestEqualEntries = new HashSet<Event>(); 
     43            this.setServiceEndpoint(forServiceEndpoint); 
    3444        } 
    3545 
     
    118128    } 
    119129 
     130        /** 
     131         * @param serviceEndpoint the serviceEndpoint to set 
     132         */ 
     133        public void setServiceEndpoint(String serviceEndpoint) { 
     134                this.serviceEndpoint = serviceEndpoint; 
     135        } 
     136 
     137        /** 
     138         * @return the serviceEndpoint 
     139         */ 
     140        public String getServiceEndpoint() { 
     141                return serviceEndpoint; 
     142        } 
     143 
     144        /** 
     145         * @param persistantId the persistantId to set 
     146         */ 
     147        public void setPersistantId(long persistantId) { 
     148                this.persistantId = persistantId; 
     149        } 
     150 
     151        /** 
     152         * @return the persistantId 
     153         */ 
     154        public long getPersistantId() { 
     155                return persistantId; 
     156        } 
     157 
    120158} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/remoting/client/impl/EventReleaseClientImpl.java

    r772 r774  
    2222 
    2323import uk.ac.cardiff.model.ServiceMetadata; 
    24 import uk.ac.cardiff.model.ServiceMetadata; 
    2524import uk.ac.cardiff.model.event.Event; 
    2625import uk.ac.cardiff.raptor.registry.Endpoint; 
     
    3029import uk.ac.cardiff.raptor.remoting.client.ReleaseFailureException; 
    3130 
     31public class EventReleaseClientImpl implements EventReleaseClient { 
    3232 
    33 public class EventReleaseClientImpl implements EventReleaseClient{ 
     33        /** Class logger. */ 
     34        private final Logger log = LoggerFactory.getLogger(EventReleaseClientImpl.class); 
    3435 
    35         /** Class logger. */ 
    36         private final Logger log = LoggerFactory.getLogger(EventReleaseClientImpl.class); 
    37  
    38         /** Encapsulation of all endpoints this client can communication with*/ 
     36        /** Encapsulation of all endpoints this client can communication with */ 
    3937        private EndpointRegistry endpointRegistry; 
    4038 
     
    4543        private boolean enableEventRelease; 
    4644 
    47         public EventReleaseClientImpl(){ 
     45        public EventReleaseClientImpl() { 
    4846                eventReleaseEngine = new EventReleaseEngine(); 
    4947                enableEventRelease = true; 
    5048        } 
    5149 
    52  
    5350        @Override 
    54         public boolean release(List<Event> events, ServiceMetadata serviceMetadata) throws ReleaseFailureException{ 
    55                 boolean success =false; 
    56                 if (enableEventRelease){ 
    57                     log.info("[Event Release Called]"); 
    58                     success = eventReleaseEngine.release(endpointRegistry, events, serviceMetadata); 
    59                     log.info("[--Events released to all listening endpoints {}--]", success); 
    60                 } 
     51        public boolean release(List<Event> events, ServiceMetadata serviceMetadata) throws ReleaseFailureException { 
     52                boolean success = false; 
     53                if (enableEventRelease) { 
     54                        log.info("[Event Release Called]"); 
     55                        success = eventReleaseEngine.release(endpointRegistry, events, serviceMetadata); 
     56                        endpointRegistry.storeReleaseInformationIfEnabled(); 
     57                        log.info("[--Events released to all listening endpoints {}--]", success); 
     58                } 
    6159 
    6260                return success; 
    6361        } 
    64  
    6562 
    6663        public List<Endpoint> getEndpoints() { 
     
    6865        } 
    6966 
    70  
    7167        public void setEndpointRegistry(EndpointRegistry endpointRegistry) { 
    7268                this.endpointRegistry = endpointRegistry; 
    7369        } 
    74  
    7570 
    7671        public EndpointRegistry getEndpointRegistry() { 
     
    7873        } 
    7974 
    80  
    8175        public void setEventReleaseEngine(EventReleaseEngine eventReleaseEngine) { 
    8276                this.eventReleaseEngine = eventReleaseEngine; 
    8377        } 
    84  
    8578 
    8679        public EventReleaseEngine getEventReleaseEngine() { 
     
    8881        } 
    8982 
     83        /** 
     84         * @param enableEventRelease 
     85         *            the enableEventRelease to set 
     86         */ 
     87        public void setEnableEventRelease(boolean enableEventRelease) { 
     88                this.enableEventRelease = enableEventRelease; 
     89        } 
    9090 
    91     /** 
    92      * @param enableEventRelease the enableEventRelease to set 
    93      */ 
    94     public void setEnableEventRelease(boolean enableEventRelease) { 
    95         this.enableEventRelease = enableEventRelease; 
    96     } 
    97  
    98  
    99     /** 
    100      * @return the enableEventRelease 
    101      */ 
    102     public boolean isEnableEventRelease() { 
    103         return enableEventRelease; 
    104     } 
    105  
    106  
     91        /** 
     92         * @return the enableEventRelease 
     93         */ 
     94        public boolean isEnableEventRelease() { 
     95                return enableEventRelease; 
     96        } 
    10797 
    10898} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/impl/PersistantEntryHandler.java

    r772 r774  
    175175 
    176176        public List<Event> getEntries() { 
    177                 return  dataConnection.runQuery("from Event",null); 
     177                List runQuery = dataConnection.runQuery("from Event",null); 
     178                return runQuery; 
    178179        } 
    179180 
    180181        public void removeAllEntries() { 
    181 //              log.debug("Removing all entries from this entry handler"); 
    182 //              dataConnection.deleteAllEntries(entries); 
    183 //              entries.clear(); 
     182                log.error("Method removeAllEntries not yet implemented"); 
    184183        } 
    185184 
Note: See TracChangeset for help on using the changeset viewer.