Changeset 49


Ignore:
Timestamp:
06/19/13 15:59:53 (11 years ago)
Author:
stoda
Message:

log4j added

Location:
trunk
Files:
2 added
1 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/pom.xml

    r45 r49  
    5656                        <version>4.11</version>
    5757                </dependency>
     58                <dependency>
     59                        <groupId>log4j</groupId>
     60                        <artifactId>log4j</artifactId>
     61                        <version>1.2.16</version>
     62                </dependency>
     63                <dependency>
     64                        <groupId>log4j</groupId>
     65                        <artifactId>apache-log4j-extras</artifactId>
     66                        <version>1.1</version>
     67                </dependency>
    5868        </dependencies>
    5969        <build>

  • trunk/src/main/java/omq/client/listener/ResponseListener.java

    r44 r49  
    66import java.util.Map;
    77import java.util.Properties;
     8
     9import org.apache.log4j.Logger;
    810
    911import omq.client.proxy.Proxymq;
    … …  
    2628 */
    2729public class ResponseListener extends Thread {
     30        private static final Logger logger = Logger.getLogger(ResponseListener.class.getName());
    2831        private static ResponseListener rListener;
    2932
    … …  
    7881                                }
    7982                        } catch (InterruptedException i) {
    80                                 i.printStackTrace();
     83                                logger.error(i.toString(), i);
    8184                        } catch (ShutdownSignalException e) {
    82                                 e.printStackTrace();
     85                                logger.error(e.toString(), e);
    8386                                try {
    8487                                        if (channel.isOpen()) {
    … …  
    9295                                                Thread.sleep(milis);
    9396                                        } catch (InterruptedException e2) {
    94                                                 e2.printStackTrace();
     97                                                logger.error(e2.toString(), e2);
    9598                                        }
    9699                                }
    97100                        } catch (ConsumerCancelledException e) {
    98                                 e.printStackTrace();
     101                                logger.error(e.toString(), e);
    99102                        } catch (Exception e) {
    100                                 e.printStackTrace();
     103                                logger.error(e.toString(), e);
    101104                        }
    102105                }
    … …  
    201204         */
    202205        public void kill() throws IOException {
     206                logger.warn("Killing ResponseListener");
    203207                interrupt();
    204208                killed = true;

  • trunk/src/main/java/omq/client/proxy/Proxymq.java

    r47 r49  
    1010import java.util.Map;
    1111import java.util.Properties;
     12
     13import org.apache.log4j.Logger;
    1214
    1315import omq.Remote;
    … …  
    4446         */
    4547        private static final long serialVersionUID = 1L;
     48        private static final Logger logger = Logger.getLogger(Proxymq.class.getName());
    4649        private static Map<String, Object> proxies = new Hashtable<String, Object>();
    4750
    … …  
    132135                // Publish the request
    133136                if (request.isAsync()) {
    134                         System.out.println("Publish async request -> " + request.getId());
     137                        logger.debug("Publish async request -> " + request.getId());
    135138                        publishAsyncRequest(request);
    136139                } else {
    137                         System.out.println("Publish sync request -> " + request.getId());
     140                        logger.debug("Publish sync request -> " + request.getId());
    138141                        response = publishSyncRequest(request, method.getReturnType());
    139142
    … …  
    186189                                return getResult(corrId, timeout, type);
    187190                        } catch (TimeoutException te) {
    188                                 System.out.println("Timeout exception catched " + te);
    189                                 te.printStackTrace();
     191                                logger.error(te);
    190192                        }
    191193                        i++;
    … …  
    292294        public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, Proxymq proxy) {
    293295                if (proxies.containsKey(proxy.getRef())) {
    294                         System.out.println("Proxy trobat");
    295296                        return proxies.get(proxy.getRef());
    296297                }

  • trunk/src/main/java/omq/common/broker/Broker.java

    r47 r49  
    22
    33import java.io.IOException;
     4import java.net.URL;
    45import java.util.HashMap;
    56import java.util.Map;
    … …  
    2021import omq.server.RemoteObject;
    2122
     23import org.apache.log4j.Logger;
     24import org.apache.log4j.xml.DOMConfigurator;
     25
    2226import com.rabbitmq.client.Channel;
    2327import com.rabbitmq.client.Connection;
    … …  
    2832
    2933public class Broker {
     34
     35        private static final Logger logger = Logger.getLogger(Broker.class.getName());
     36
    3037        private static Connection connection;
    3138        private static Channel channel;
    … …  
    4552        public static synchronized void initBroker(Properties env) throws Exception {
    4653                if (environment == null) {
     54
     55                        // Load log4j configuration
     56                        URL log4jResource = Broker.class.getResource("/log4j.xml");
     57                        DOMConfigurator.configure(log4jResource);
     58
    4759                        remoteObjs = new HashMap<String, RemoteObject>();
    4860                        environment = env;
    … …  
    5870                        }
    5971                } else {
    60                         throw new InitBrokerException("Broker already started");
     72                        logger.error("Broker is already started");
     73                        throw new InitBrokerException("Broker is already started");
    6174                }
    6275        }
    6376
    6477        public static void stopBroker() throws Exception {
     78                logger.warn("Stopping broker");
    6579                // Stop the client
    6680                if (clientStarted) {
    … …  
    93107
    94108        public static void closeConnection() throws IOException {
     109                logger.warn("Clossing connection");
    95110                connectionClosed = true;
    96111                connection.close();
    … …  
    241256                        @Override
    242257                        public void shutdownCompleted(ShutdownSignalException cause) {
     258                                logger.warn("Shutdown message received. Cause: " + cause.getMessage());
    243259                                if (!connectionClosed)
    244260                                        if (cause.isHardError()) {

  • trunk/src/main/java/omq/common/event/EventDispatcher.java

    r44 r49  
    99import omq.common.util.ParameterQueue;
    1010import omq.common.util.Serializer;
     11
     12import org.apache.log4j.Logger;
    1113
    1214import com.rabbitmq.client.Channel;
    … …  
    2628@SuppressWarnings("rawtypes")
    2729public class EventDispatcher extends Thread {
     30        private static final Logger logger = Logger.getLogger(EventDispatcher.class.getName());
    2831        private static EventDispatcher dispatcher;
    2932
    … …  
    6770
    6871        public static void stopEventDispatcher() throws Exception {
     72                logger.warn("Stopping EventDispatcher");
    6973                dispatcher.setListeners(null);
    7074                dispatcher.killed = true;
    … …  
    102106                                event = Serializer.deserializeEvent(delivery.getBody());
    103107
    104                                 System.out.println("Event received -> Topic: " + event.getTopic() + "CorrId: " + event.getCorrId());
     108                                logger.info("Event received -> Topic: " + event.getTopic() + "CorrId: " + event.getCorrId());
    105109                                // Log.saveLog("Client-Deserialize", delivery.getBody());
    106110
    … …  
    112116                                dispatch(event.getTopic(), event);
    113117                        } catch (InterruptedException i) {
    114                                 System.out.println("InterruptedException e: " + i);
    115                                 i.printStackTrace();
     118                                logger.error(i);
    116119                        } catch (ShutdownSignalException e) {
    117                                 System.out.println("ShutdownSignalException e: " + e);
    118                                 e.printStackTrace();
     120                                logger.error(e);
    119121                                try {
    120122                                        if (channel.isOpen()) {
    … …  
    127129                                                Thread.sleep(milis);
    128130                                        } catch (InterruptedException e2) {
    129                                                 e2.printStackTrace();
     131                                                logger.error(e2);
    130132                                        }
    131                                         e1.printStackTrace();
     133                                        logger.error(e1);
    132134                                }
    133135                        } catch (ConsumerCancelledException e) {
    134                                 System.out.println("ConsumerCancelledException e: " + e);
    135                                 e.printStackTrace();
     136                                logger.error(e);
    136137                        } catch (Exception e) {
    137                                 System.out.println("Exception e: " + e);
    138                                 e.printStackTrace();
     138                                logger.error(e);
    139139                        }
    140140                }
    … …  
    160160                        String reference = e.getTopic();
    161161
    162                         System.out.println("EventDispatcher declaring fanout -> " + reference + " Binding with: " + queueName);
     162                        logger.info("Declaring fanout -> " + reference + " Binding with: " + queueName);
    163163
    164164                        channel.exchangeDeclare(reference, "fanout");

  • trunk/src/main/java/omq/common/util/OmqConnectionFactory.java

    r44 r49  
    55import java.security.NoSuchAlgorithmException;
    66import java.util.Properties;
     7
     8import org.apache.log4j.Logger;
    79
    810import com.rabbitmq.client.Channel;
    … …  
    1618 */
    1719public class OmqConnectionFactory {
     20        private static final Logger logger = Logger.getLogger(OmqConnectionFactory.class.getName());
     21
    1822        private static Connection connection;
    1923        private static int connectionTimeout = 2 * 1000;
    … …  
    3438                                working = true;
    3539                        } catch (Exception e) {
    36                                 e.printStackTrace();
     40                                logger.error(e);
    3741                                long milis = Long.parseLong(env.getProperty(ParameterQueue.RETRY_TIME_CONNECTION, "2000"));
    3842                                Thread.sleep(milis);
    … …  
    6468                        factory.useSslProtocol();
    6569                }
    66                 return factory.newConnection();
     70
     71                Connection connection = factory.newConnection();
     72                logger.info("New connection created using: username: " + username + ", host: " + host + ", port: " + port + ", connection timeout: "
     73                                + connectionTimeout + " SSL enabled: " + ssl);
     74                return connection;
    6775        }
    6876
    6977        public static Channel getNewChannel() throws IOException {
    70                 return connection.createChannel();
     78                Channel channel = connection.createChannel();
     79                logger.info("New channel created using the default connection");
     80                return channel;
    7181        }
    7282}

  • trunk/src/main/java/omq/common/util/Serializer.java

    r47 r49  
    33import java.io.IOException;
    44import java.util.Properties;
     5
     6import org.apache.log4j.Logger;
    57
    68import omq.common.broker.Broker;
    … …  
    2123 */
    2224public class Serializer {
     25        private static final Logger logger = Logger.getLogger(Serializer.class.getName());
    2326        public static String kryo = "kryo";
    2427        public static String java = "java";
    … …  
    158161
    159162        public static void removeSerializers() {
     163                logger.warn("Removing serializers");
    160164                serializer = null;
    161165                kryoSerializer = null;

  • trunk/src/main/java/omq/common/util/Serializers/GsonImp.java

    r44 r49  
    2222        public byte[] serialize(Object obj) throws SerializerException {
    2323                String json = gson.toJson(obj);
    24                 System.out.println(json);
    2524                return json.getBytes();
    2625        }

  • trunk/src/main/java/omq/server/InvocationThread.java

    r47 r49  
    88import omq.common.util.Serializer;
    99import omq.exception.OmqException;
     10
     11import org.apache.log4j.Logger;
    1012
    1113import com.rabbitmq.client.AMQP.BasicProperties;
    … …  
    1921 */
    2022public class InvocationThread extends Thread {
     23        private static final Logger logger = Logger.getLogger(InvocationThread.class.getName());
    2124        private RemoteObject obj;
    2225        private BlockingQueue<Delivery> deliveryQueue;
    … …  
    4447                                String requestID = request.getId();
    4548
    46                                 System.out.println("Invoke method: " + methodName + " CorrID: " + requestID);
     49                                logger.debug("Object: " + obj.getRef() + ", method: " + methodName + " corrID: " + requestID);
    4750
    4851                                // Invoke the method
    … …  
    5356                                } catch (InvocationTargetException e) {
    5457                                        Throwable throwable = e.getTargetException();
     58                                        logger.error("Object: " + obj.getRef() + " at method: " + methodName + ", corrID" + requestID, throwable);
    5559                                        error = new OmqException(throwable.getClass().getCanonicalName(), throwable.getMessage());
    5660                                } catch (NoSuchMethodException e) {
     61                                        logger.error("Object: " + obj.getRef() + " cannot find method: " + methodName);
    5762                                        error = new OmqException(e.getClass().getCanonicalName(), e.getMessage());
    5863                                }
    … …  
    7580
    7681                        } catch (InterruptedException i) {
    77                                 i.printStackTrace();
     82                                logger.error(i);
    7883                                killed = true;
    7984                        } catch (Exception e) {
    80                                 System.out.println("Error a l'Invocation Thread \nException: " + e);
    81                                 e.printStackTrace();
     85                                logger.error("Object: " + obj.getRef(), e);
    8286                        }
    8387

  • trunk/src/main/java/omq/server/RemoteObject.java

    r44 r49  
    1010import java.util.Properties;
    1111
     12import org.apache.log4j.Logger;
     13
    1214import omq.Remote;
    1315import omq.common.broker.Broker;
    … …  
    3335
    3436        private static final long serialVersionUID = -1778953938739846450L;
     37        private static final Logger logger = Logger.getLogger(RemoteObject.class.getName());
    3538
    3639        private String UID;
    … …  
    8588                        try {
    8689                                Delivery delivery = consumer.nextDelivery();
    87                                 System.out.println("RemoteObject: " + UID + " has received a message");
     90
     91                                logger.debug(UID + " has received a message");
     92
    8893                                remoteWrapper.notifyDelivery(delivery);
    8994                        } catch (InterruptedException i) {
    90                                 i.printStackTrace();
     95                                logger.error(i);
    9196                        } catch (ShutdownSignalException e) {
    92                                 e.printStackTrace();
     97                                logger.error(e);
    9398                                try {
    9499                                        if (channel.isOpen()) {
    … …  
    101106                                                Thread.sleep(milis);
    102107                                        } catch (InterruptedException e2) {
    103                                                 e2.printStackTrace();
    104                                         }
    105                                         e1.printStackTrace();
     108                                                logger.error(e2);
     109                                        }
     110                                        logger.error(e1);
    106111                                }
    107112                        } catch (ConsumerCancelledException e) {
    108                                 e.printStackTrace();
     113                                logger.error(e);
    109114                        } catch (SerializerException e) {
    110                                 e.printStackTrace();
     115                                logger.error(e);
    111116                        } catch (Exception e) {
    112                                 e.printStackTrace();
     117                                logger.error(e);
    113118                        }
    114119                }
    … …  
    129134
    130135        public void kill() throws IOException {
     136                logger.warn("Killing objectmq: " + this.getRef());
    131137                killed = true;
    132138                interrupt();
    … …  
    218224
    219225                // Declares and bindings
    220                 System.out.println("RemoteObject: " + UID + " declaring direct exchange: " + exchange + ", Queue: " + queue);
     226                logger.info("RemoteObject: " + UID + " declaring direct exchange: " + exchange + ", Queue: " + queue);
    221227                channel.exchangeDeclare(exchange, "direct");
    222228                channel.queueDeclare(queue, durable, false, false, null);
    … …  
    224230
    225231                // Declare the event topic fanout
    226                 System.out.println("RemoteObject: " + UID + " declaring fanout exchange: " + UID);
     232                logger.info("RemoteObject: " + UID + " declaring fanout exchange: " + UID);
    227233                channel.exchangeDeclare(UID, "fanout");
    228234

  • trunk/src/main/java/omq/server/RemoteWrapper.java

    r44 r49  
    44import java.util.concurrent.BlockingQueue;
    55import java.util.concurrent.LinkedBlockingDeque;
     6
     7import org.apache.log4j.Logger;
    68
    79import com.rabbitmq.client.QueueingConsumer;
    … …  
    1416 */
    1517public class RemoteWrapper {
     18        private static final Logger logger = Logger.getLogger(RemoteWrapper.class.getName());
     19
    1620        private RemoteObject obj;
    1721        private int numThreads;
    … …  
    2529                deliveryQueue = new LinkedBlockingDeque<QueueingConsumer.Delivery>();
    2630
    27                 System.out.println("RemoteWrapper -> Object: " + obj.getRef() + ", numthreads listening = " + numThreads);
     31                logger.info("Object reference: " + obj.getRef() + ", numthreads listening = " + numThreads);
    2832
    2933                for (int i = 0; i < numThreads; i++) {
    … …  
    3943
    4044        public void stopRemoteWrapper() {
     45                logger.warn("Stopping Invocation threads vinculed to " + obj.getRef());
    4146                for (InvocationThread thread : invocationList) {
    4247                        thread.interrupt();
Note: See TracChangeset for help on using the changeset viewer.