static {
   SNUrl =
       StringUtil.isEmpty(Env.get("SNUrl"))
           ? "http://g3.letv.com/stat/hosts?cdnid=999999"
           : Env.get("SNUrl");
   NPUrl =
       StringUtil.isEmpty(Env.get("NPUrl"))
           ? "http://g3.letv.com/stat/nodes?format=1"
           : Env.get("NPUrl");
 }
/**
 * 直播rttp业务流程控制
 *
 * @author kk
 */
public abstract class AbstractLiveRttpServlet extends BaseServlet implements IliveRttpReceiver {

  private static final Logger LOG = LoggerFactory.getLogger(AbstractLiveRttpServlet.class);
  public static final int KAFKA_POOL_SIZE_FOR_LIVE_RTTP =
      StringUtils.isEmpty(Env.get("kafkaPoolSizeForLiveRttp"))
          ? 1
          : Integer.parseInt(Env.get("kafkaPoolSizeForLiveRttp"));
  protected static final SequenceUtil sequence = new SequenceUtil();
  private ReceiverExceptionHandler exceptionHandler = new LiveExceptionHandler(); // 指定异常处理机制

  @Override
  protected void execute(HttpServletRequest request, HttpServletResponse response) {

    final JsonWapper wapper = new JsonWapper();
    String flag = Constants.RESULT_SUCCESS;
    String body = "";
    final String uri = request.getRequestURI();
    try {
      body = getParameters(request);
      addStormData(body);
    } catch (Throwable e) {
      flag = Constants.RESULT_FAILED;
      ReceiverExceptionData exceptionData = new ReceiverExceptionData();
      exceptionHandler.handleEventException(e, body, exceptionData, uri);
      JSONObject jsonObject = wapper.nextItem();
      jsonObject.put(body, exceptionData.getCode().value);
      wapper.endItem(jsonObject);
    } finally {
      try {
        wapper.writeStore(response, flag);
      } catch (Exception e) {
        LOG.error("writeResponse err: ", e);
      }
    }
  }

  private String getParameters(HttpServletRequest request) throws Exception {

    String p = "";
    String method = request.getMethod();
    if ("GET".equals(method)) {
      p = URLDecoder.decode(convertToUTF8(request.getQueryString()), "UTF-8");
    } else if ("POST".equals(method)) {
      p = getBodyString(request.getInputStream());
    }
    return p;
  }

  @Override
  public void addCacheData(Object param) throws Exception {

    // 暂时无操作
  }
}
/**
 * 直播flv服务端入口
 *
 * @author kk
 */
public class FlvSSServlet extends AbstractBaseLiveMultipleServlet {

  private static final Logger LOG = LoggerFactory.getLogger(FlvSSServlet.class);

  private static final String FLV_TOPIC = Env.get("liveFlvServerTopic");

  private static enum PARAM {
    timestamp,
    streamid,
    bw,
    cip,
    sip,
    uuid
  };

  private static final String KEY_PREFIX = "flv";
  private static final String intranetTag = "999";
  private static final PARAM[] params = PARAM.values();

  @Override
  public boolean validateParams(Map<String, String> paramMap) throws ValidateException {

    if (null == paramMap || paramMap.size() < 6) {
      throw new ValidateException("args miss");
    }
    for (int i = 0; i < params.length; i++) {
      if (StringUtils.isEmpty(paramMap.get(params[i].toString()))) {
        throw new ValidateException(params[i].toString() + " miss");
      }
    }
    return true;
  }

  @Override
  public String[] splitParams(String str) throws Exception {

    return str.split("\n");
  }

  @Override
  public void handleParams(Map<String, String> param) throws Exception {

    // 默认内网
    String pid = intranetTag;
    String type = "out";

    String slogtime = param.get(PARAM.timestamp.toString()); // 时间戳
    param.put(PARAM.timestamp.toString() + "_bak", slogtime);
    String clientip = param.get(PARAM.cip.toString()); // 客户端IP
    String serverip = param.get(PARAM.sip.toString()); // 服务端IP
    if (NodeMapping.SPMapping.containsKey(clientip)) { // 如果可以映射成功,代表是外网
      type = "in";
      if (NodeMapping.SPMapping.containsKey(serverip)) {
        pid = NodeMapping.SPMapping.get(serverip);
      } else {
        pid = "0";
      }
    }
    param.put(PARAM.timestamp.toString(), slogtime);
    param.put("pid", pid);
    // 带宽计算
    long flow = Long.valueOf(param.get(PARAM.bw.toString())); // 一分钟内的流量合
    long bw = flow * 8 / 60;
    param.put(PARAM.bw.toString(), String.valueOf(bw));
    // 码率截取
    String streamid = param.get(PARAM.streamid.toString());
    String sp = "-1";
    int index = streamid.lastIndexOf("_");
    if (-1 != index) {
      sp = streamid.substring(index + 1);
    }
    param.put("sp", sp);
    // 其他字段,为了storm统一
    param.put("type", type);
  }

  @Override
  public void addCacheData(Object param) throws Exception {

    Map<String, String> paramMap = (Map<String, String>) param;
    String pid = paramMap.get("pid");
    String keu_prefix =
        KEY_PREFIX
            + "_"
            + paramMap.get(PARAM.streamid.toString())
            + "_"
            + paramMap.get(PARAM.timestamp.toString());

    // 内网日志不会总到全国
    if (!StringUtils.equals(pid, intranetTag)) {
      String onlineKeyQ = keu_prefix + "_Q_online"; // 全国汇总
      long r2 = XMemcacheUtil.incrementToCache(onlineKeyQ, 1, 1, DEFAULT_EXPIRE_TIME);

      int bw = Math.round(Float.parseFloat(paramMap.get(PARAM.bw.toString())));
      String bwKeyQ = keu_prefix + "_Q_bw";
      long r4 = XMemcacheUtil.incrementToCache(bwKeyQ, bw, bw, DEFAULT_EXPIRE_TIME);
    }
  }

  @Override
  public void addStormData(Object param) throws Exception {

    Map<String, String> paramMap = (Map<String, String>) param;
    String pid = paramMap.get("pid");
    KafkaProcessManager.getServerMsgProcessById(
            (Math.abs((int) sequence.next() % KAFKA_POOL_SIZE_FOR_LIVE_SERVER)))
        .sendObjectKafka(preprosBodyString(paramMap, pid), FLV_TOPIC);
  }

  @Override
  public String getFormat() {

    return "yyyyMMddHHmm";
  }

  private String preprosBodyString(Map<String, String> paramMap, String pid) {

    StringBuilder result = new StringBuilder();
    result.append(paramMap.get(PARAM.timestamp.toString())).append("\t");
    result.append(paramMap.get(PARAM.streamid.toString())).append("\t");
    result.append(paramMap.get("sp")).append("\t");
    String bw = null;
    try {
      bw = String.valueOf(Math.round(Float.parseFloat(paramMap.get(PARAM.bw.toString()))));
    } catch (NumberFormatException e) {
      bw = paramMap.get(PARAM.bw.toString());
    }
    result.append(bw).append("\t");
    result.append(paramMap.get(PARAM.sip.toString())).append("\t");
    result.append(paramMap.get(PARAM.cip.toString())).append("\t");
    result.append(paramMap.get("type")).append("\t");
    result.append(paramMap.get(PARAM.uuid.toString())).append("\t");
    result.append(pid);
    LOG.debug(result.toString());
    return result.toString();
  }
}
 @Scheduled(cron = "${cloudLivePresureCron}")
 public void insertBatch() {
   for (int i = 0; i < Integer.parseInt(Env.get("consumeThreadNum")); i++) {
     consumeExecutor.execute(new ConsumeTask());
   }
 }
/**
 * 消息处理服务
 *
 * @author kk
 */
public class MessageServer {

  private static final Logger log = LoggerFactory.getLogger(MessageServer.class);

  private static MessageServer server;
  private static final String MESSAGE_TOPIC =
      StringUtil.isEmpty(Env.get("messageTopic")) ? "messageTopic" : Env.get("messageTopic");
  private static final int NUM_PERSISTENCE_PROCESSORS = 6; //
  private static final int NUM_MESSAGE_PROCESSORS =
      StringUtil.isEmpty(Env.get("numSendProcessors"))
          ? Runtime.getRuntime().availableProcessors()
          : Integer.parseInt(Env.get("numSendProcessors"));
  // private ThreadPoolExecutor threadsPoolMessage;
  private ThreadPoolExecutor threadsPoolpersistence;
  private volatile boolean isRun = false;

  private MessageServer() {

    threadsPoolpersistence =
        new ThreadPoolExecutor(
            NUM_PERSISTENCE_PROCESSORS,
            NUM_PERSISTENCE_PROCESSORS,
            10l,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue(5));
    // threadsPoolMessage = new ThreadPoolExecutor(NUM_MESSAGE_PROCESSORS,
    // NUM_MESSAGE_PROCESSORS, 10l,
    // TimeUnit.SECONDS, new ArrayBlockingQueue(5));
  }

  public static synchronized void startMessageServer() throws Exception {

    if (server != null) return;
    server = new MessageServer();
    try {
      server.start();
    } catch (Exception ex) {
      log.error("MessageServer start error: " + ex.getMessage());
      throw ex;
    }
    log.info("============ MessageServer Is Running. ============");
  }

  public static synchronized void stopMessageServer() throws Exception {

    if (server == null) return;
    try {
      server.stop();
      server = null;
    } catch (Exception ex) {
      log.error("MessageServer stop error: " + ex.getMessage());
      throw ex;
    }
    log.info("============ MessageServer Has stopped. ============");
  }

  private void start() throws Exception {

    isRun = true;
    for (int i = 0; i < NUM_PERSISTENCE_PROCESSORS; i++) {
      threadsPoolpersistence.execute(new PersistenceThread());
    }
    // for (int i = 0; i < NUM_MESSAGE_PROCESSORS; i++) {
    // threadsPoolMessage.execute(new SendThread());
    // }
  }

  private void stop() throws Exception {

    if (null != server) {
      isRun = false;
      threadsPoolpersistence.shutdown();
      // threadsPoolMessage.shutdown();
    }
  }

  class PersistenceThread implements Runnable {

    public PersistenceThread() {}

    public void run() {

      while (isRun) {
        try {
          KafkaProcessManager.getPersistenceProcessById(0)
              .sendObjectKafka(MessageUtil.takePersistence());
        } catch (Throwable t) {
          log.error("PersistenceThread err:", t);
        }
      }
    }
  }

  /*
   * class SendThread implements Runnable{ KafkaUtil k = new
   * KafkaUtil(MESSAGE_TOPIC); public SendThread() { } public void run() { try
   * { while (isRun) { try { k.sendObjectKafka(MessageUtil.takeMessage()); }
   * catch (Throwable t) { log.error("SendThread err:", t); } } } finally {
   * k.close(); } } }
   */
}