Subversion Repositories SmartDukaan

package in.shop2020.thrift.clients;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import in.shop2020.config.ConfigException;
import in.shop2020.thrift.clients.config.ConfigClient;
import in.shop2020.utils.Logger;

import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;

public abstract class GenericClient {
        /**
         * Socket timeout to be set for thrift
         */
        private final int SOCKET_TIMEOUT = 1000 * 60 * 5;
        protected TSocket socket = null;
        protected TTransport transport = null;
        protected TProtocol protocol = null;
        
        /**
         * Max attempts on one instance of service to be tried before falling on next instance of service
         */
        protected static final int MAX_ATTEMPTS = 3;
        protected static final int FIRST_ATTEMPT = 1;
        /**
         * Max instances of service to be tried before dying
         */
        protected static final int TOTAL_SERVICES = 2;
        /**
         * Current service instance being used
         */
        protected int serviceNumber = 0;
        protected String hostname = "localhost";
        protected int port = 8080;
        
        protected String hostConfigKey;
        protected String portConfigKey;

                
        
        /**
         * Constructor
         * @param hostConfigKey
         * @param portConfigKey
         * @throws TTransportException
         */
        public GenericClient(String hostConfigKey, String portConfigKey) throws TTransportException{
                this.hostConfigKey = hostConfigKey; 
                this.portConfigKey = portConfigKey;
                loadConfigParameters(hostConfigKey, portConfigKey);
                connectToService(FIRST_ATTEMPT);
        }
        
        /**
         * Load config parameters for the given key set
         * @param hostConfigKey
         * @param portConfigKey
         */
        private void loadConfigParameters(String hostConfigKey, String  portConfigKey){
                this.hostname = getHost(hostConfigKey);
                this.port = getPort(portConfigKey);
        }
        

        /**
         * get the Host name from given key
         * @param key
         * @return
         */
        private String getHost(String key){
                try {
                        String host = ConfigClient.getClient().get(key);
                        return host;
                } catch (ConfigException e) {
                        Logger.log("Error while fetching hostname for key "+ key+" using localhost:"+ e, this);
                        return "localhost";
                }
        }
        
        /**
         * get the Port from given key
         * @param key
         * @return
         */
        private int getPort(String key){
                try {
                        String port = ConfigClient.getClient().get(key);
                        return Integer.parseInt(port);
                }catch (NumberFormatException ne){
                        Logger.log("Could not convert string to int for key "+ key+" using 8080 as port"+ ne, this);
                        return 8080;
                }
                catch (ConfigException e) {
                        Logger.log("Error while fetching port for key "+ key+" using 8080:"+ e, this);
                        return 8080;
                }
        }

        /**
         * Connect to the service. It also have mechanism to handle multiple service instances.
         * Connect to default service:
         *     If fails: Connect to another services instances till have tried all services.
         * Tries the default service at MAX_ATTEMPTS times  
         * @param attemptNumber
         * @throws TTransportException
         */
        private void connectToService(int attemptNumber) throws TTransportException{
                try{
                        openTransport();
                }catch (TTransportException e) {
                        if(attemptNumber < MAX_ATTEMPTS){
                                connectToService(attemptNumber+1);
                        }else{
                                if(serviceNumber < TOTAL_SERVICES){
                                        serviceNumber += 1;
                                        Logger.log("Maximum attempts have reached. Failing over to another service", null);
                                        loadConfigParameters(this.hostConfigKey + serviceNumber, this.portConfigKey + serviceNumber);
                                        connectToService(FIRST_ATTEMPT);
                                        updateConfigParameters(this.hostConfigKey, this.portConfigKey);
                                }else{
                                        Logger.log("Have tried enough services. Giving up.....", null);
                                        throw e;
                                }
                        }
                }
        }
        
        /**
         * Update the config parameters for the current service being used, so that next time these parameters can be used.
         * @param hostConfigKey
         * @param portConfigKey
         */
        private void updateConfigParameters(String hostConfigKey, String portConfigKey){
                try {
                        ConfigClient.getClient().set(hostConfigKey, this.hostname);
                        ConfigClient.getClient().set(portConfigKey, this.port+"");
                } catch (ConfigException e) {
                        Logger.log("Unable to update the keys in the section", null);
                }       
        }

        /**
         * Open the transport to connect to service.
         * @throws TTransportException
         */
        @PostConstruct
        protected void openTransport() throws TTransportException {
                Logger.log("Initializing socket infra ", this);
                socket = new TSocket(hostname, port);
                socket.setTimeout(SOCKET_TIMEOUT);
                transport = new TFramedTransport(socket);
                protocol = new TBinaryProtocol(transport);

                if(!transport.isOpen()){
                        transport.open();
                }else{
                        Logger.log("Transport was already open", this);
                }
        }


        /**
         * Close the transport
         */
        @PreDestroy
        protected void closeTransport(){
                if(transport != null && transport.isOpen()){
                        Logger.log("Closing transport :", this);
                        transport.close();
                }
        }

        /**
         * Close the connection.
         */
        public void closeConnection(){
                if(transport != null && transport.isOpen()){
                        Logger.log("Closing transport :", this);
                        transport.close();
                }
        }
        
        
        /**
         * Closing connection in finalize.
         */
        protected void finalize() throws Throwable{
                super.finalize();
                this.closeConnection();
        }
        
        public abstract void closeSession();
        
}