python grpc 05

# header session 的传输
#传输的解压与压缩
#客户端发送大小不能超过2M

#hello_bilibili.proto

syntax = "proto3";

package test;



service Bibili {
    rpc HelloDewei(HelloDeweiReq) returns (HelloDeweiReply){}
    rpc HelloTest(stream HelloTestReq) returns (stream HelloTestReply){}
    rpc TestClientRecvStream(TestClientRecvStreamRequest)  returns (stream TestClientRecvStreamResponse){}
    rpc TestClientSendStream(stream TestClientSendStreamRequest)  returns (TestClientSendStreamResponse){}
    rpc TestTwoWayStream(stream TestTwoWayStreamRequest)  returns (stream TestTwoWayStreamResponse){}
}



message HelloDeweiReq {
    string name = 1;
    int32 age = 2;
}


message HelloDeweiReply {
    string result =1;
}

message HelloTestReq {
    string name = 1;
    int64 age = 2;
    repeated string data = 3;
    map<string,HelloTestReqnumbervalue> number = 4;
}



message HelloTestReqnumbervalue {
    string name = 1;
    int64 age = 2;
    bool is_active = 3;
}



message HelloTestReply {
    string result =1;
}



message TestClientRecvStreamRequest {
    string data =1;
}



message TestClientRecvStreamResponse {
    string result =1;
}





message TestClientSendStreamRequest {
    string data =1;
}




message TestClientSendStreamResponse {
    string result =1;
}





message TestTwoWayStreamRequest {
    string data =1;
}




message TestTwoWayStreamResponse {
    string result =1;
}

#client.py

#coding:utf-8


import time
import random
import grpc
import hello_bilibili_pb2 as pb2
import hello_bilibili_pb2_grpc as pb2_grpc




def test():
    while 1:
        time.sleep(1)
        data = str(random.random())
        yield pb2.TestClientSendStreamRequest(data=data)




def run():
    conn = grpc.insecure_channel("127.0.0.1:5000")
    client = pb2_grpc.BibiliStub(channel=conn)
    try:
        # header session 的传输
        #传输的解压与压缩
        #客户端发送大小不能超过2M

        response,call= client.HelloDewei.with_call(pb2.HelloDeweiReq(
            name='dewei',
            age = 28
        ),
            compression=grpc.Compression.Gzip,
            metadata=(("client_key","client_value"),),
            wait_for_ready=True
        )
        print(response.result)
        print(call.trailing_metadata())
        header = call.trailing_metadata()
        print(header[0])
    except Exception as e:
        print(e)

    # response = client.TestClientRecvStream(pb2.TestClientRecvStreamRequest(
    #     data='dewei',
    #
    # ))
    # for item in response:
    #     print(item.result)

    # response = client.TestClientSendStream(test())
    # print(response.result)



    # response = client.TestTwoWayStream(test(),timeout=10)
    # for res in response:
    #     print(res.result)



if __name__ == '__main__':
    run()

#service.py

#coding:utf-8

import time

import grpc
import hello_bilibili_pb2 as pb2
import hello_bilibili_pb2_grpc as pb2_grpc

from concurrent import futures

class Bibili(pb2_grpc.BibiliServicer):
    def HelloDewei(self, request, context):
        name = request.name
        age = request.age
        #header   session    的传输
        context.set_trailing_metadata(('name','zjk'),('header','header_value'))
        client_session=context.invocation_metadata()
        print(client_session)


        if name == "error":
            context.set_details("tianjia error")
            context.set_code(grpc.StatusCode.DATA_LOSS)
            raise context

        result = f'my name is {name}, iam {age} years old'
        #压缩与解压    局部
        context.set_compression(grpc.Compression.Gzip)
        return pb2.HelloDeweiReply(result=result)



    def TestClientRecvStream(self,request,context):
        index = 1
        while context.is_active():

            data = request.data
            if data == "close":
                context.cancel()

            time.sleep(1)
            index += 1
            yield pb2.TestClientRecvStreamResponse(
                result = "send  %d %s"%(index,data)
            )



    def TestClientSendStream(self, request_iterator, context):
        for request in request_iterator:
            print(request)
        return  pb2.TestClientRecvStreamResponse(result='ok')




    def TestTwoWayStream(self, request_iterator, context):
        for request in request_iterator:
            data = request.data
            yield pb2.TestTwoWayStreamResponse(result="service send client %s"%data)





def run():
    grpc_server = grpc.server(
        # header session 的传输
        # 传输的解压与压缩
        # 客户端发送大小不能超过2M
        futures.ThreadPoolExecutor(max_workers=4),
        compression=grpc.Compression.Gzip,#全局压缩
        options=[
            ('grpc.max_send_message_length',50*1024*1024),#接受大小
            ('grpc.max_receive_message_length',50*1024*1024 )]#接受大小
    )
    pb2_grpc.add_BibiliServicer_to_server(Bibili(),grpc_server)
    grpc_server.add_insecure_port('0.0.0.0:5000')
    print("server will start at 0.0.0.0:5000")
    grpc_server.start()

    try:
        while 1:
            time.sleep(3600)
    except KeyboardInterrupt:
        grpc_server.stop(0)


if __name__ == '__main__':
    run()