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

Java tutorial

Introduction

Here is the source code for com.netcore.hsmart.smsconsumers.SmsConsumer556.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.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.math.BigInteger;
import java.net.URI;

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 org.apache.commons.configuration2.ex.ConfigurationException;
import org.apache.logging.log4j.ThreadContext;

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

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

    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 SmsConsumer556Runnable(Integer.toString(i));
            executor.execute(worker);
        }
    }

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

        private final static String GATEWAY_ID = "556";

        private final static String GATEWAY_URL = "http://203.90.117.146/SMSAPI/SMS_PUSH.asp";
        private final static String API_SUCCESS_CALL_STATUS_VAL = "SUCCESS";

        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;

        // Thread runner;
        public SmsConsumer556Runnable(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
         */
        // public static void main(String[] args) throws 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 {

                String lang = "U";
                String msg = null;
                switch (DATA_POSTED.get("message_type")) {
                case "1":

                    lang = "E";
                    msg = DATA_POSTED.get("message");
                    break;
                case "2":

                    lang = "U";

                    byte[] msgBytes = URLDecoder.decode(DATA_POSTED.get("message"), "UTF-8").getBytes("UTF-16BE");
                    BigInteger bigInt = new BigInteger(msgBytes);
                    String hexString = bigInt.toString(16); // 16 is the radix
                    StringBuilder buffer = new StringBuilder();

                    while ((buffer.length() + hexString.length()) < (2 * msgBytes.length)) {
                        buffer.append("0");
                    }
                    buffer.append(hexString);
                    msg = buffer.toString();

                    break;

                }

                WebTarget webTarget = CLIENT.target(GATEWAY_URL + "?msg=" + msg);
                WebTarget msisdnParam = webTarget.queryParam("MSISDN", DATA_POSTED.get("msisdn"));
                WebTarget senderParam = msisdnParam.queryParam("s", DATA_POSTED.get("sender_id"));
                WebTarget langParam = senderParam.queryParam("lang", lang);

                URI u = langParam.getUri();
                //logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|URI:" + u.toString() + "|LENGTH:" + u.getQuery().length());

                Invocation.Builder invocationBuilder = langParam.request();
                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") + "|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);

                response.close();
                // CLIENT.close();

                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) {
            ThreadContext.put("gatewayId", GATEWAY_ID);
            Logger logger = LoggerFactory.getLogger(this.getClass());

            // String nullStr = "NULL";

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

            API_CALL_STATS.put("msg_count", NULLSTR);
            API_CALL_STATS.put("api_call_status", responseText);
            API_CALL_STATS.put("msg_id", NULLSTR);
            API_CALL_STATS.put("price", NULLSTR);
            API_CALL_STATS.put("balance", 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 ? API_SUCCESS_CALL_STATUS_VAL != null
                    : !responseText.equals(API_SUCCESS_CALL_STATUS_VAL))
                    || !"200".equals(responseStatus.toString())) {

                //logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_ERROR_TEXT:" + responseText);

                API_CALL_STATS.put("api_call_error_text", responseText);

                //logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_FAIL");

            } else {

                //logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_ERROR_TEXT:" + NULLSTR);

                API_CALL_STATS.put("api_call_error_text", NULLSTR);

                //logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_SUCCESS");
            }

            refIdMap.put(DATA_POSTED.get("ref_id"), DATA_POSTED.get("ref_id"));

            callDlrApi();
            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"));
            //NOTE: dlr_type set as DLR intead of API
            //NEVER DO this for other gateway
            INSTANT_DLR_STATS.put("dlr_type", "DLR");
            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;

        }

    }

}