# -*- coding: utf-8 -*-
from nameko_grpc.entrypoint import Grpc
import empty_pb2
import interop_pb2_grpc
import messages_pb2
grpc = Grpc.implementing(interop_pb2_grpc.TestServiceStub)
_INITIAL_METADATA_KEY = "x-grpc-test-echo-initial"
_TRAILING_METADATA_KEY = "x-grpc-test-echo-trailing-bin"
def _maybe_echo_metadata(servicer_context):
"""Copies metadata from request to response if it is present."""
invocation_metadata = dict(servicer_context.invocation_metadata())
if _INITIAL_METADATA_KEY in invocation_metadata:
initial_metadatum = (
_INITIAL_METADATA_KEY,
invocation_metadata[_INITIAL_METADATA_KEY],
)
servicer_context.send_initial_metadata((initial_metadatum, ))
if _TRAILING_METADATA_KEY in invocation_metadata:
trailing_metadatum = (
_TRAILING_METADATA_KEY,
invocation_metadata[_TRAILING_METADATA_KEY],
)
servicer_context.set_trailing_metadata((trailing_metadatum, ))
def _maybe_echo_status_and_message(request, servicer_context):
import logging
from nameko.events import event_handler
from nameko.rpc import rpc,RpcProxy
from nameko_grpc.entrypoint import Grpc
from products import dependencies, schemas
from .products_pb2 import GetProduct, Product
from .products_pb2_grpc import productsStub
from .products_pb2 import UpdateInventoryResponse, UpdateInventoryResponseDetails
logger = logging.getLogger(__name__)
grpc = Grpc.implementing(productsStub)
class ProductsService:
name = 'products'
storage = dependencies.Storage()
@grpc
def get_product(self, request, context):
logger.info("------- Get Products -------- %s", request)
product = self.storage.get(request.id)
return Product(**product)
@rpc
def list(self):
products = self.storage.list()
return schemas.Product(many=True).dump(products).data
from exemplo_pb2 import ExampleReply
from exemplo_pb2_grpc import exampleStub
from nameko_grpc.entrypoint import Grpc
grpc = Grpc.implementing(exampleStub)
class ExampleService:
name = "example"
@grpc
def unary_unary(self, request, context):
message = request.value * (request.multiplier or 1)
print(message)
return ExampleReply(message=message)
@grpc
def unary_stream(self, request, context):
message = request.value * (request.multiplier or 1)
yield ExampleReply(message=message, seqno=1)
yield ExampleReply(message=message, seqno=2)
@grpc
def stream_unary(self, request, context):
messages = []
for req in request:
message = req.value * (req.multiplier or 1)
messages.append(message)
return ExampleReply(message=",".join(messages))
from nameko_grpc.entrypoint import Grpc
from nameko_sqlalchemy import DatabaseSession
from nameko_grpc.dependency_provider import GrpcProxy
from nameko_grpc.client import Client
from orders.exceptions import NotFound
from orders.models import DeclarativeBase, Order, OrderDetail
from orders.schemas import OrderSchema
from .orders_pb2 import OrderDeletedResponse, OrderDetailResponse, OrderResponse
from .orders_pb2_grpc import ordersStub
from .products_pb2_grpc import productsStub
from .products_pb2 import UpdateInventoryRequest, UpdateInventoryResponse, UpdateInventoryResponseDetails, UpdateProductInventoryRequestDetails, GetProduct
from logging import getLogger
# import grpc
grpc = Grpc.implementing(ordersStub)
log = getLogger(__name__)
class OrdersService:
name = 'orders'
db = DatabaseSession(DeclarativeBase)
event_dispatcher = EventDispatcher()
products_grpc = GrpcProxy(
"http://products.examples.svc.cluster.local:50051", productsStub)
@grpc
def get_order(self, request, context):
log.debug("------- Get Order ------- %s", request)
# -*- coding: utf-8 -*-
from nameko_grpc.entrypoint import Grpc
from helpers import extract_metadata, instrumented, maybe_echo_metadata, maybe_sleep
import example_pb2_grpc
from example_pb2 import ExampleReply
class Error(Exception):
pass
grpc = Grpc.implementing(example_pb2_grpc.exampleStub)
class example:
name = "example"
@grpc
@instrumented
def unary_unary(self, request, context):
metadata = extract_metadata(context)
maybe_echo_metadata(context)
maybe_sleep(request)
message = request.value * (request.multiplier or 1)
return ExampleReply(message=message, metadata=metadata)
@grpc
@instrumented
def unary_stream(self, request, context):
# -*- coding: utf-8 -*-
"""
Usage: nameko run performance_nameko
"""
import grpc
from nameko_grpc.entrypoint import Grpc
example_pb2, example_pb2_grpc = grpc.protos_and_services("example.proto")
entrypoint = Grpc.implementing(example_pb2_grpc.exampleStub)
class example:
name = "example"
@entrypoint
def unary_unary(self, request, context):
message = request.value * (request.multiplier or 1)
return example_pb2.ExampleReply(message=message)
@entrypoint
def unary_stream(self, request, context):
message = request.value * (request.multiplier or 1)
for i in range(request.response_count):
yield example_pb2.ExampleReply(message=message, seqno=i + 1)
@entrypoint
def stream_unary(self, request, context):
messages = []
for index, req in enumerate(request):
message = req.value * (req.multiplier or 1)
# -*- coding: utf-8 -*-
import base64
import json
from nameko.extensions import DependencyProvider
from nameko_grpc.entrypoint import Grpc
import advanced_pb2_grpc
from advanced_pb2 import SimpleReply
grpc = Grpc.implementing(advanced_pb2_grpc.advancedStub)
class BytesEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, bytes):
return base64.b64encode(obj).decode("utf-8")
return json.JSONEncoder.default(self, obj)
class ContextData(DependencyProvider):
def get_dependency(self, worker_ctx):
return worker_ctx.context_data
class advanced:
name = "advanced"
context_data = ContextData()