Java Code Examples for org.fisco.bcos.channel.dto.ChannelResponse#setErrorCode()

@Override
public void onPush(ChannelPush push) {
	Integer resultCode = 0;
	
	String resultData = "";
	
	try {
		resultData = dbService.process(push.getContent());
	} catch (Exception e) {
		resultCode = -1;
		logger.error("Process request error", e);
	}
	
	//construct back to the package
	ChannelResponse response = new ChannelResponse();
	response.setMessageID(push.getMessageID());
	response.setErrorCode(resultCode);
	response.setErrorMessage("");
	response.setContent(resultData);
	
	logger.debug("Send response: {}", response.getContent());
	
	push.sendResponse(response);
}
 

public final void onTimeout() {
    logger.error("send message timeout:{}", message.getSeq());

    ChannelResponse response = new ChannelResponse();
    response.setErrorCode(ChannelMessageError.MESSAGE_TIMEOUT.getError());
    response.setMessageID(message.getSeq());
    response.setErrorMessage("send message timeout");
    response.setContent("");

    try {
        onResponseMessage(response);
    } catch (Exception e) {
        logger.error("timeout processing error:", e);
    }

    service.getSeq2Callback().remove(message.getSeq());
    timeout.cancel();
}
 

private static ChannelResponse toChannelResponse(ErrorCode errorCode, byte[] content) {
    ChannelResponse reply = new ChannelResponse();
    reply.setErrorCode(errorCode.getCode());
    reply.setErrorMessage(errorCode.getCodeDesc());
    reply.setContent(content);
    return reply;
}
 

private static ChannelResponse toChannelResponse(ErrorCode errorCode, byte[] content) {
    ChannelResponse reply = new ChannelResponse();
    reply.setErrorCode(errorCode.getCode());
    reply.setErrorMessage(errorCode.getCodeDesc());
    reply.setContent(content);
    return reply;
}
 

public void onReceiveRegisterEventResponse(ChannelHandlerContext ctx, ChannelMessage2 message) {

        ChannelResponseCallback2 callback =
                (ChannelResponseCallback2) seq2Callback.get(message.getSeq());
        String seq = message.getSeq();
        String content = new String(message.getData());
        if (callback == null) {
            logger.warn(
                    " register event filter response cannot find callback, seq: {}, content: {}",
                    seq,
                    content);
            return;
        }

        seq2Callback.remove(seq);

        ChannelResponse response = new ChannelResponse();

        response.setCtx(ctx);
        response.setErrorCode(message.getResult());
        response.setMessageID(message.getSeq());
        if (message.getData() != null) {
            response.setContent(message.getData());
        }

        callback.onResponse(response);

        logger.info(" register event filter response, seq: {}, content: {} ", seq, content);
    }
 

public void signForAmop(ChannelHandlerContext ctx, ChannelMessage2 message) throws IOException {
    SocketChannel socketChannel = (SocketChannel) ctx.channel();
    logger.info(
            "sign ChannelResponse seq:{} msgtype:{} address:{} port:{}",
            message.getSeq(),
            message.getType(),
            socketChannel.remoteAddress().getAddress().getHostAddress(),
            socketChannel.remoteAddress().getPort());
    logger.info(
            "sign request :{} length:{}",
            Arrays.toString(message.getData()),
            message.getLength());

    String content = topicVerify.parseDataFromPush(message.getLength(), message.getData());
    logger.info("content:{} content:{}", content, Arrays.toString(content.getBytes()));
    TopicVerifyReqProtocol topicVerifyProtocol =
            ObjectMapperFactory.getObjectMapper()
                    .readValue(content, TopicVerifyReqProtocol.class);
    String randValue = topicVerifyProtocol.getRandValue();
    String topic = topicVerifyProtocol.getTopic();
    logger.info("sign rand_value:{} sign topic:{}", randValue, topic);

    String signature = topicVerify.signatureForRandValue(topic, randValue);

    TopicVerifyRespProtocol topicVerifyRespProtocol = new TopicVerifyRespProtocol();
    topicVerifyRespProtocol.setSignature(signature);
    String jsonStr =
            ObjectMapperFactory.getObjectMapper().writeValueAsString(topicVerifyRespProtocol);
    logger.info("signature jsonStr result:{}", jsonStr);
    byte[] bytes = topicVerify.getByteBuffByString(message.getTopic(), jsonStr);

    ChannelResponse response = new ChannelResponse();
    response.setMessageID(message.getSeq());
    response.setErrorCode(0);
    response.setContent(bytes);
    sendResponseMessage2(response, ctx, message.getSeq(), message.getTopic());
}
 

@Override
public void onPush(ChannelPush push) {
    DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    logger.debug("push:" + push.getContent());
    System.out.println(df.format(LocalDateTime.now()) + "server:push:" + push.getContent());

    ChannelResponse response = new ChannelResponse();
    response.setContent("receive request seq:" + String.valueOf(push.getMessageID()));
    response.setErrorCode(0);

    push.sendResponse(response);
}
 

private static ChannelResponse toChannelResponse(BrokerException e) {
    ChannelResponse reply = new ChannelResponse();
    reply.setErrorCode(e.getCode());
    reply.setContent(e.getMessage());
    return reply;
}
 

private static ChannelResponse toChannelResponse(BrokerException e) {
    ChannelResponse reply = new ChannelResponse();
    reply.setErrorCode(e.getCode());
    reply.setContent(e.getMessage());
    return reply;
}
 

public void retrySendMessage() {
    Integer errorCode = 0;
    try {
        // 选取客户端节点
        logger.debug("Number of local nodes:{}", fromConnectionInfos.size());

        setFromConnection(null);
        if (fromConnectionInfos.size() > 0) {
            Random random = new SecureRandom();
            Integer index = random.nextInt(fromConnectionInfos.size());

            logger.debug("selected index: {}, peer: {}", index, fromConnectionInfos.get(index));

            setFromConnection(fromConnectionInfos.get(index));

            fromConnectionInfos.remove(fromConnectionInfos.get(index));
        }

        if (getFromConnection() == null) {
            // 所有节点已尝试，无法再重试了
            logger.error("Failed to send message,all retry failed");

            errorCode = ChannelMessageError.NODES_UNREACHABLE.getError();
            throw new Exception(" Failed to send message,all retry failed ");
        }

        ChannelHandlerContext ctx =
                fromChannelConnections.getNetworkConnectionByHost(
                        getFromConnection().getHost(), getFromConnection().getPort());

        if (ctx != null && ChannelHandlerContextHelper.isChannelAvailable(ctx)) {
            ByteBuf out = ctx.alloc().buffer();
            message.writeHeader(out);
            message.writeExtra(out);

            ctx.writeAndFlush(out);

            logger.debug(
                    "send message to  {}:{} success ",
                    fromConnection.getHost(),
                    fromConnection.getPort());
        } else {
            logger.debug("sending node unavailable");

            retrySendMessage();
        }
    } catch (Exception e) {
        logger.error("send message exception {}", e);

        ChannelResponse response = new ChannelResponse();
        response.setErrorCode(errorCode);
        response.setErrorMessage(e.getMessage());

        try {
            onResponseMessage(response);
        } catch (Exception ee) {
            logger.error("onResponseMessage error:{}", ee);
        }

        // 彻底失败后，删掉这个seq
        if (message.getSeq() != null) {
            service.getSeq2Callback().remove(message.getSeq());
        }

        if (timeout != null) {
            timeout.cancel();
        }

        return;
    }
}