com.netcore.hsmart.smsconsumers.SmsConsumer559.java Source code

Java tutorial

Introduction

Here is the source code for com.netcore.hsmart.smsconsumers.SmsConsumer559.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
    
mvn exec:java@HSMART_SMS_CONSUMERS_1000 -Dhsmart-config-path=/home/vibhor/installs/HSMART2/config
 */
package com.netcore.hsmart.smsconsumers;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.hazelcast.core.IMap;
import com.netcore.hsmart.AppConstants;
import com.netcore.hsmart.InsecureHostnameVerifier;
import com.netcore.hsmart.InsecureTrustManager;
import com.netcore.hsmart.Utilities;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.Method;
import com.rabbitmq.client.ShutdownListener;
import com.rabbitmq.client.ShutdownSignalException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLDecoder;
import java.net.URLEncoder;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Invocation;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Response;
import org.glassfish.jersey.client.ClientConfig;
import org.glassfish.jersey.client.ClientProperties;

import javax.ws.rs.ProcessingException;
import java.util.logging.Level;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedHashMap;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import org.apache.commons.configuration2.ex.ConfigurationException;
import org.apache.logging.log4j.ThreadContext;

import org.json.JSONObject;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.glassfish.jersey.grizzly.connector.GrizzlyConnectorProvider;

/**
 *
 * @author root
 */
public class SmsConsumer559 {

    private static final int COUNTERS = ((System.getProperty("thread-count") != null)
            ? Integer.parseInt(System.getProperty("thread-count"))
            : 1);

    public static void main(String args[]) throws Exception {

        ExecutorService executor = Executors.newCachedThreadPool();

        for (int i = 1; i <= COUNTERS; i++) {
            Runnable worker = new SmsConsumer559Runnable(Integer.toString(i));
            executor.execute(worker);
        }
    }

    /**
     * *******worker class********
     */
    public static class SmsConsumer559Runnable implements Runnable {

        private final static String GATEWAY_ID = "559";
        private final String GATEWAY_URL = "http://netcore.jatismobile.com/NetCoreJumper/Receive.ashx";

        private final String API_SUCCESS_CALL_STATUS_VAL = "1";

        private Map<String, String> API_CALL_STATS = new HashMap<>();
        private Map<String, String> DATA_POSTED = new HashMap<>();

        private final String threadId;
        private final static String NULLSTR = "null";

        private final ClientConfig CLIENT_CONFIG = new ClientConfig()
                .connectorProvider(new GrizzlyConnectorProvider());
        private Client CLIENT = ClientBuilder.newClient(CLIENT_CONFIG);
        private static IMap<String, String> refIdMap = null;

        public SmsConsumer559Runnable(String str) {

            CLIENT_CONFIG.property(ClientProperties.CONNECT_TIMEOUT, 10000);
            CLIENT_CONFIG.property(ClientProperties.READ_TIMEOUT, 10000);
            CLIENT = ClientBuilder.newClient(CLIENT_CONFIG);
            threadId = str;
        }

        /**
         * @param args the command line arguments
         * @throws java.lang.Exception
         */
        @Override
        public void run() {

            ThreadContext.put("gatewayId", GATEWAY_ID);
            try {
                AppConstants.loadAppConfig();
            } catch (ConfigurationException ex) {
                java.util.logging.Logger.getLogger(this.getClass().getSimpleName()).log(Level.SEVERE, null, ex);
            }

            Logger logger = LoggerFactory.getLogger(this.getClass());
            refIdMap = AppConstants.getHazelcastClient().getMap(GATEWAY_ID + "_REF_ID_MAP");

            try {

                // Connection connection =
                // AppConstants.getRabbitMqObject().newConnection();

                AppConstants.getRabbitMqConnection().addShutdownListener(new ShutdownListener() {
                    @Override
                    public void shutdownCompleted(ShutdownSignalException cause) {
                        // throw new UnsupportedOperationException("Not
                        // supported yet.");
                        if (cause.isHardError()) {
                            Connection conn;
                            conn = (Connection) cause.getReference();
                            if (!cause.isInitiatedByApplication()) {
                                Method reason = cause.getReason();
                                logger.info("REASON:" + reason.toString());
                            }

                        } else {
                            Channel ch = (Channel) cause.getReference();
                            logger.info("NO HARDSHUTDOWN");
                        }
                    }
                });

                Channel channel = AppConstants.getRabbitMqConnection().createChannel();

                channel.exchangeDeclare(AppConstants.getSmsReceiverExchangeName(), "direct");
                channel.queueDeclare(AppConstants.getSmsReceiverQueuePrefix() + GATEWAY_ID, true, false, false,
                        null);
                channel.queueBind(AppConstants.getSmsReceiverQueuePrefix() + GATEWAY_ID,
                        AppConstants.getSmsReceiverExchangeName(), GATEWAY_ID);
                channel.basicQos(1000);
                // channel.addShutdownListener(listener);
                logger.info(" [*] Waiting for messages from gateway " + GATEWAY_ID + ". To exit press CTRL+C");

                Consumer consumer;

                consumer = new DefaultConsumer(channel) {

                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope,
                            AMQP.BasicProperties properties, byte[] body) throws IOException {

                        ThreadContext.put("gatewayId", GATEWAY_ID);

                        String payload = new String(body, "UTF-8");

                        String payloadParts[] = payload.split(AppConstants.getPayloadGroupSeparator());

                        for (String payloadPart : payloadParts) {
                            String s[] = payloadPart.split(AppConstants.getPayloadKVSeparator());
                            DATA_POSTED.put(s[0], s[1]);
                        }
                        logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|START+++++++++++++++");
                        logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|PAYLOAD:" + payload);

                        long deliveryTag = envelope.getDeliveryTag();

                        if (invokeApiCall()) {
                            if (saveRequestData()) {
                                channel.basicAck(deliveryTag, false);
                            } else {
                                channel.basicNack(deliveryTag, false, true);
                            }

                        } else {
                            channel.basicNack(deliveryTag, false, true);
                        }

                        /**
                         * release memory
                         */
                        logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|END-----------------");
                        API_CALL_STATS.clear();
                        DATA_POSTED.clear();
                        payloadParts = null;

                    }
                };

                String cTag = channel.basicConsume(AppConstants.getSmsReceiverQueuePrefix() + GATEWAY_ID, false,
                        consumer);
                logger.info("CONSUMER TAG : " + cTag);

            } catch (IOException e) {
                logger.error("RMQ_ERROR:" + e.getMessage());
            }
        }

        private boolean invokeApiCall() {
            ThreadContext.put("gatewayId", GATEWAY_ID);

            Logger logger = LoggerFactory.getLogger(this.getClass());

            try {

                WebTarget webTarget = CLIENT.target(GATEWAY_URL + "?message=" + DATA_POSTED.get("message"));

                WebTarget apiKeyParam = webTarget.queryParam("userid", "NETCORE");
                WebTarget apiSecretParam = apiKeyParam.queryParam("password", "NETCORE789");

                WebTarget fromParam = apiKeyParam.queryParam("sender", DATA_POSTED.get("sender_id"));
                WebTarget toParam = fromParam.queryParam("msisdn", DATA_POSTED.get("msisdn"));
                //WebTarget msgParam = toParam.queryParam("message", URLEncoder.encode(DATA_POSTED.get("message"),"UTF-8"));
                WebTarget divParam = toParam.queryParam("division", "Marketing");
                WebTarget batchParam = divParam.queryParam("batchname", "Netcore");
                WebTarget uploadParam = batchParam.queryParam("uploadby", "Netcore");
                WebTarget channelParam = uploadParam.queryParam("channel", "1");

                URI u = channelParam.getUri();

                Invocation.Builder invocationBuilder = channelParam.request().header("Content-Length",
                        u.getQuery().length());
                long startTime = System.currentTimeMillis();
                Response response = invocationBuilder.get();
                long elapsedTime = System.currentTimeMillis() - startTime;
                String responseText = response.readEntity(String.class);
                Integer responseStatus = response.getStatus();

                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|URI:" + u.toString() + "|LENGTH:"
                        + u.getQuery().length());
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|LATENCY:" + elapsedTime + "ms");

                API_CALL_STATS.put("ref_id", DATA_POSTED.get("ref_id"));
                API_CALL_STATS.put("gateway_id", DATA_POSTED.get("gateway_id"));
                API_CALL_STATS.put("uri", u.toString());
                API_CALL_STATS.put("latency", String.valueOf(elapsedTime));

                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|HTTP_STATUS:" + responseStatus);
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|RESPONSE_TEXT:" + responseText);

                API_CALL_STATS.put("http_status", responseStatus.toString());
                API_CALL_STATS.put("response_text", responseText);

                return parseVendorApiResponse(responseStatus, responseText);

            } catch (ProcessingException e) {
                logger.error("REF_ID: " + DATA_POSTED.get("ref_id") + "|VENDOR_API_CALL_ERROR:" + e.getMessage()
                        + Arrays.toString(e.getStackTrace()));
                return false;

            } catch (Exception ex) {
                logger.error("REF_ID: " + DATA_POSTED.get("ref_id") + "|INVOKE_FUN_ERROR: " + ex.getMessage()
                        + Arrays.toString(ex.getStackTrace()));
                return false;
            }

        }

        private boolean parseVendorApiResponse(Integer responseStatus, String responseText)
                throws UnsupportedEncodingException {

            ThreadContext.put("gatewayId", GATEWAY_ID);

            Logger logger = LoggerFactory.getLogger(this.getClass());

            Map<String, String> queryPairs = new LinkedHashMap<>();

            String[] pairs = responseText.split("&");
            for (String pair : pairs) {
                int idx = pair.indexOf("=");
                queryPairs.put(URLDecoder.decode(pair.substring(0, idx), "UTF-8"),
                        URLDecoder.decode(pair.substring(idx + 1), "UTF-8"));
            }

            logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|BALANCE:" + NULLSTR);
            logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|MSG_COUNT:" + NULLSTR);
            logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|PRICE:" + NULLSTR);

            API_CALL_STATS.put("balance", NULLSTR);
            API_CALL_STATS.put("msg_count", NULLSTR);
            API_CALL_STATS.put("price", NULLSTR);

            /**
             * If http status other than 200 - fail if response status string
             * not equal to success status - fail Action: build DLR API url with
             * instant_dlr=true param and post to DLR receiver server
             */
            if ((responseText == null || !queryPairs.get("Status").equals(API_SUCCESS_CALL_STATUS_VAL))
                    || !"200".equals(responseStatus.toString())) {

                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_STATUS:" + queryPairs.get("Status"));
                logger.info(
                        "REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_ERROR_TEXT:" + queryPairs.get("Status"));
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|MSG_ID:" + NULLSTR);

                API_CALL_STATS.put("api_call_status", queryPairs.get("Status"));
                API_CALL_STATS.put("api_call_error_text", queryPairs.get("Status"));
                API_CALL_STATS.put("msg_id", NULLSTR);

                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_FAIL");
                refIdMap.put(DATA_POSTED.get("ref_id"), DATA_POSTED.get("ref_id"));

                callDlrApi();

            } else {

                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_STATUS:" + queryPairs.get("Status"));
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_ERROR_TEXT:" + NULLSTR);
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|MSG_ID:" + queryPairs.get("MessageId"));

                API_CALL_STATS.put("api_call_status", queryPairs.get("Status"));
                API_CALL_STATS.put("api_call_error_text", NULLSTR);
                API_CALL_STATS.put("msg_id", queryPairs.get("MessageId"));

                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_SUCCESS");
                refIdMap.put(queryPairs.get("MessageId"), DATA_POSTED.get("ref_id"));

            }
            queryPairs = null;
            pairs = null;
            return true;

        }

        private void callDlrApi() {
            ThreadContext.put("gatewayId", GATEWAY_ID);
            Logger logger = LoggerFactory.getLogger(this.getClass());

            Map<String, String> INSTANT_DLR_STATS = new HashMap<>();
            logger.info("REF_ID:" + API_CALL_STATS.get("ref_id") + "|SENDING_INSTANT_DLR");

            INSTANT_DLR_STATS.put("status", API_CALL_STATS.get("api_call_status"));
            INSTANT_DLR_STATS.put("gateway_id", GATEWAY_ID);
            INSTANT_DLR_STATS.put("ref_id", API_CALL_STATS.get("ref_id"));
            INSTANT_DLR_STATS.put("error_code", API_CALL_STATS.get("api_call_status"));
            INSTANT_DLR_STATS.put("dlr_type", "API");
            INSTANT_DLR_STATS.put("delivery_time", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

            try {
                JSONObject jobj = new JSONObject(INSTANT_DLR_STATS);
                String g = Utilities.encrypt(jobj.toString());

                Channel channel = AppConstants.getRabbitMqConnection().createChannel();

                channel.exchangeDeclare(AppConstants.getDlrReceiverExchangeName(), "direct");
                channel.queueDeclare(AppConstants.getDlrReceiverQueuePrefix() + GATEWAY_ID, true, false, false,
                        null);
                channel.queueBind(AppConstants.getDlrReceiverQueuePrefix() + GATEWAY_ID,
                        AppConstants.getDlrReceiverExchangeName(), GATEWAY_ID);
                channel.basicPublish(AppConstants.getDlrReceiverExchangeName(), GATEWAY_ID, null, g.getBytes());
                channel.close();
                logger.info("REF_ID:" + API_CALL_STATS.get("ref_id") + "|INSTANT_DLR_DATA:" + g);
                g = null;
            } catch (Exception ex) {
                logger.info("REF_ID:" + API_CALL_STATS.get("ref_id") + "|ERROR_PUBLISHING_INSTANT_DLR_DATA:"
                        + ex.getMessage());
            }

        }

        private boolean saveRequestData() {
            ThreadContext.put("gatewayId", GATEWAY_ID);
            Logger logger = LoggerFactory.getLogger(this.getClass());

            try {
                JSONObject jobj = new JSONObject(API_CALL_STATS);
                String g = Utilities.encrypt(jobj.toString());

                Channel channel = AppConstants.getRabbitMqConnection().createChannel();

                channel.exchangeDeclare(AppConstants.getSmsDataExchangeName(), "direct");
                channel.queueDeclare(AppConstants.getSmsDataQueuePrefix() + GATEWAY_ID, true, false, false, null);
                channel.queueBind(AppConstants.getSmsDataQueuePrefix() + GATEWAY_ID,
                        AppConstants.getSmsDataExchangeName(), GATEWAY_ID);
                channel.basicPublish(AppConstants.getSmsDataExchangeName(), GATEWAY_ID, null, g.getBytes());
                channel.close();
                logger.info("REF_ID:" + API_CALL_STATS.get("ref_id") + "|DB_DATA:" + g);
                g = null;
            } catch (Exception ex) {
                logger.info(
                        "REF_ID:" + API_CALL_STATS.get("ref_id") + "|ERROR_PUBLISHING_SMS_DATA:" + ex.getMessage());
            }

            return true;

        }
    }

}