Example #1
0
 public AsyncInvokerHandle() {
   try {
     httpThreadLocal = HttpThreadLocal.getInstance();
     int workerCount = Global.getSingleton().getServiceConfig().getInt("gaea.async.worker.count");
     if (workerCount > 0) {
       asyncInvoker = AsyncInvoker.getInstance(workerCount);
     } else {
       asyncInvoker = AsyncInvoker.getInstance();
     }
     String sTaskTimeOut =
         Global.getSingleton().getServiceConfig().getString("gaea.server.tcp.task.timeout");
     if (sTaskTimeOut != null && !"".equals(sTaskTimeOut)) {
       taskTimeOut = Integer.parseInt(sTaskTimeOut);
     }
     logger.info("async worker count:" + workerCount);
   } catch (Exception e) {
     logger.error("init AsyncInvokerHandle error", e);
   }
 }
Example #2
0
  @Override
  public void invoke(final GaeaContext context) throws Exception {
    logger.debug("-------------------begin async invoke-------------------");
    asyncInvoker.run(
        taskTimeOut,
        new IAsyncHandler() {
          @Override
          public Object run() throws Throwable {
            logger.debug("begin request filter");
            // request filter
            for (IFilter f : Global.getSingleton().getGlobalRequestFilterList()) {
              if (context.getExecFilter() == ExecFilterType.All
                  || context.getExecFilter() == ExecFilterType.RequestOnly) {
                f.filter(context);
              }
            }

            if (context.isDoInvoke()) {
              if (context.getServerType() == ServerType.HTTP) {
                httpThreadLocal.set(context.getHttpContext());
              }
              doInvoke(context);
            }

            logger.debug("begin response filter");
            // response filter
            for (IFilter f : Global.getSingleton().getGlobalResponseFilterList()) {
              if (context.getExecFilter() == ExecFilterType.All
                  || context.getExecFilter() == ExecFilterType.ResponseOnly) {
                f.filter(context);
              }
            }
            return context;
          }

          @Override
          public void messageReceived(Object obj) {
            if (context.getServerType() == ServerType.HTTP) {
              httpThreadLocal.remove();
            }
            if (obj != null) {
              GaeaContext ctx = (GaeaContext) obj;
              ctx.getServerHandler().writeResponse(ctx);
            } else {
              logger.error("context is null!");
            }
          }

          @Override
          public void exceptionCaught(Throwable e) {
            if (context.getServerType() == ServerType.HTTP) {
              httpThreadLocal.remove();
            }

            if (context.getGaeaResponse() == null) {
              GaeaResponse respone = new GaeaResponse();
              context.setGaeaResponse(respone);
            }

            try {
              byte[] desKeyByte = null;
              String desKeyStr = null;
              boolean bool = false;

              Global global = Global.getSingleton();
              if (global != null) {
                // 判断当前服务启用权限认证
                if (global.getGlobalSecureIsRights()) {
                  SecureContext securecontext =
                      global.getGlobalSecureContext(context.getChannel().getNettyChannel());
                  bool = securecontext.isRights();
                  if (bool) {
                    desKeyStr = securecontext.getDesKey();
                  }
                }
              }

              if (desKeyStr != null) {
                desKeyByte = desKeyStr.getBytes("utf-8");
              }

              Protocol protocol = context.getGaeaRequest().getProtocol();
              if (protocol == null) {
                protocol =
                    Protocol.fromBytes(
                        context.getGaeaRequest().getRequestBuffer(),
                        global.getGlobalSecureIsRights(),
                        desKeyByte);
                context.getGaeaRequest().setProtocol(protocol);
              }
              protocol.setSdpEntity(ExceptionHelper.createError(e));
              context
                  .getGaeaResponse()
                  .setResponseBuffer(
                      protocol.toBytes(
                          Global.getSingleton().getGlobalSecureIsRights(), desKeyByte));
            } catch (Exception ex) {
              context.getGaeaResponse().setResponseBuffer(new byte[] {0});
              logger.error("AsyncInvokerHandle invoke-exceptionCaught error", ex);
            }

            context.getServerHandler().writeResponse(context);
            logger.error("AsyncInvokerHandle invoke error", e);
          }
        });
  }