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

Java tutorial

Introduction

Here is the source code for com.netcore.hsmart.smsconsumers.SmsConsumer557.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.net.URI;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
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 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.JSONArray;

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 SmsConsumer557 {

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

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

        private final static String GATEWAY_ID = "557";

        private final String GATEWAY_URL = "https://rest.nexmo.com/sms/json";
        private final String API_SUCCESS_CALL_STATUS_VAL = "0";

        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 SmsConsumer557Runnable(String str) {

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

            SSLContext sc;
            try {
                sc = SSLContext.getInstance("TLSv1");
                TrustManager[] trustAllCerts = { new InsecureTrustManager() };
                sc.init(null, trustAllCerts, new java.security.SecureRandom());
                System.setProperty("https.protocols", "TLSv1");// Java 8
                HostnameVerifier allHostsValid = new InsecureHostnameVerifier();
                CLIENT = ClientBuilder.newBuilder().sslContext(sc).hostnameVerifier(allHostsValid).build();
            } catch (NoSuchAlgorithmException | KeyManagementException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            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 + "?text=" + DATA_POSTED.get("message"));
                // WebTarget webTarget = CLIENT.target(GATEWAY_URL);

                WebTarget apiKeyParam = webTarget.queryParam("api_key", "6bcc2766");
                WebTarget apiSecretParam = apiKeyParam.queryParam("api_secret", "8d9792b11b6autp2L");
                WebTarget fromParam = apiSecretParam.queryParam("from", DATA_POSTED.get("sender_id"));
                WebTarget toParam = fromParam.queryParam("to", DATA_POSTED.get("msisdn"));
                // WebTarget msgParam = toParam.queryParam("text",
                // DATA_POSTED.get("message"));
                WebTarget dlrFlag = toParam.queryParam("status-report-req", "1");
                WebTarget textType = dlrFlag.queryParam("type",
                        ("1".equals(DATA_POSTED.get("message_type")) ? "text" : "unicode"));
                // double encoding for fixing '+' sign in return DLR

                WebTarget callbackParam = textType.queryParam("callback",
                        AppConstants.getHttpProtocol() + "://" + AppConstants.getDlrrecvServerHost() + ":"
                                + AppConstants.getDlrrecvServerPort() + "/DlrPingback/get?gid=JAVmqaNDB1");
                // WebTarget callbackParam = textType.queryParam("callback",
                // "https://requestb.in/17qm1q01"); // TODO:
                // update
                // this

                WebTarget intermediateDlr = callbackParam.queryParam("include-intermediate-dlrs", "0");

                URI u = intermediateDlr.getUri();

                Invocation.Builder invocationBuilder = intermediateDlr.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;
            }

        }

        /**
         * TODO: handle HTTP status other than 200
         *
         * @param responseStatus
         * @param responseText
         * @return
         */
        private boolean parseVendorApiResponse(Integer responseStatus, String responseText) {
            ThreadContext.put("gatewayId", GATEWAY_ID);

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

            JSONObject jsonObj = new JSONObject(responseText);
            JSONArray messagesJsonArray = jsonObj.getJSONArray("messages");
            JSONObject messageJsonObj = messagesJsonArray.getJSONObject(0);

            logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|MSG_COUNT:" + jsonObj.get("message-count"));
            logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_STATUS:"
                    + messageJsonObj.getString("status"));

            API_CALL_STATS.put("msg_count", jsonObj.getString("message-count"));
            API_CALL_STATS.put("api_call_status", messageJsonObj.getString("status"));

            /**
             * 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 ((messageJsonObj.getString("status") == null ? API_SUCCESS_CALL_STATUS_VAL != null
                    : !messageJsonObj.getString("status").equals(API_SUCCESS_CALL_STATUS_VAL))
                    || !"200".equals(responseStatus.toString())) {

                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);
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_ERROR_TEXT:"
                        + messageJsonObj.getString("error-text"));

                API_CALL_STATS.put("msg_id", NULLSTR);
                API_CALL_STATS.put("price", NULLSTR);
                API_CALL_STATS.put("balance", NULLSTR);
                API_CALL_STATS.put("api_call_error_text", messageJsonObj.getString("error-text"));

                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") + "|MSG_ID:" + messageJsonObj.get("message-id"));
                logger.info(
                        "REF_ID:" + DATA_POSTED.get("ref_id") + "|PRICE:" + messageJsonObj.get("message-price"));
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|BALANCE:"
                        + messageJsonObj.get("remaining-balance"));
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_STATUS:"
                        + messageJsonObj.getString("status"));
                logger.info("REF_ID:" + DATA_POSTED.get("ref_id") + "|API_CALL_ERROR_TEXT:" + NULLSTR);

                API_CALL_STATS.put("msg_id", messageJsonObj.getString("message-id"));
                API_CALL_STATS.put("price", messageJsonObj.getString("message-price"));
                API_CALL_STATS.put("balance", messageJsonObj.getString("remaining-balance"));
                API_CALL_STATS.put("api_call_error_text", NULLSTR);

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

                refIdMap.put(messageJsonObj.getString("message-id"), DATA_POSTED.get("ref_id"));

            }

            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;

        }

    }
}