io.servicecomb.transport.highway.HighwayServerConnection Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2017 Huawei Technologies Co., Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.servicecomb.transport.highway;

import javax.ws.rs.core.Response.Status;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.protostuff.runtime.ProtobufFeature;
import io.servicecomb.foundation.vertx.server.TcpBufferHandler;
import io.servicecomb.foundation.vertx.server.TcpParser;
import io.servicecomb.foundation.vertx.server.TcpServerConnection;
import io.servicecomb.transport.highway.message.LoginRequest;
import io.servicecomb.transport.highway.message.LoginResponse;
import io.servicecomb.transport.highway.message.RequestHeader;
import io.servicecomb.transport.highway.message.ResponseHeader;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.net.NetSocket;

public class HighwayServerConnection extends TcpServerConnection implements TcpBufferHandler {
    private static final Logger LOGGER = LoggerFactory.getLogger(HighwayServerConnection.class);

    private ProtobufFeature protobufFeature = new ProtobufFeature();

    @Override
    public void init(NetSocket netSocket) {
        splitter = new TcpParser(this);
        super.init(netSocket);
    }

    @Override
    public void handle(long msgId, Buffer headerBuffer, Buffer bodyBuffer) {
        RequestHeader requestHeader = decodeRequestHeader(msgId, headerBuffer);
        if (requestHeader == null) {
            return;
        }

        switch (requestHeader.getMsgType()) {
            case MsgType.REQUEST:
                onRequest(msgId, requestHeader, bodyBuffer);
                break;
            case MsgType.LOGIN:
                onLogin(msgId, requestHeader, bodyBuffer);
                break;

            default:
                throw new Error("Unknown tcp msgType " + requestHeader.getMsgType());
        }
    }

    protected RequestHeader decodeRequestHeader(long msgId, Buffer headerBuffer) {
        RequestHeader requestHeader = null;
        try {
            requestHeader = HighwayCodec.readRequestHeader(headerBuffer, protobufFeature);
        } catch (Exception e) {
            String msg = String.format("decode request header error, msgId=%d",
                    msgId);
            LOGGER.error(msg, e);

            netSocket.close();
            return null;
        }

        return requestHeader;
    }

    protected void onLogin(long msgId, RequestHeader header, Buffer bodyBuffer) {
        LoginRequest request = null;
        try {
            request = LoginRequest.readObject(bodyBuffer);
        } catch (Exception e) {
            String msg = String.format("decode setParameter error, msgId=%d",
                    msgId);
            LOGGER.error(msg, e);
            netSocket.close();
            return;
        }

        if (request != null) {
            this.setProtocol(request.getProtocol());
            this.setZipName(request.getZipName());
            this.protobufFeature.setUseProtobufMapCodec(request.isUseProtobufMapCodec());
        }

        try (HighwayOutputStream os = new HighwayOutputStream(msgId, protobufFeature)) {
            ResponseHeader responseHeader = new ResponseHeader();
            responseHeader.setStatusCode(Status.OK.getStatusCode());

            LoginResponse response = new LoginResponse();
            response.setUseProtobufMapCodec(protobufFeature.isUseProtobufMapCodec());

            os.write(ResponseHeader.getResponseHeaderSchema(),
                    responseHeader,
                    LoginResponse.getLoginResponseSchema(),
                    response);
            netSocket.write(os.getBuffer());
        } catch (Exception e) {
            throw new Error("impossible.", e);
        }
    }

    protected void onRequest(long msgId, RequestHeader header, Buffer bodyBuffer) {
        HighwayServerInvoke invoke = new HighwayServerInvoke(protobufFeature);
        if (invoke.init(this, msgId, header, bodyBuffer)) {
            invoke.execute();
        }
    }
}