django-grpc-bus 1.0.2
Django rest gRPC framework
Requires Python: >=3.6
Keywords: grpc framework django rest micro service message bus

Django gRPC Framework
=====================

Django gRPC framework is a advanced toolkit for building gRPC services.

# Requirements

* Python (3.6, 3.7, 3.8, 3.9)
* Django (2.2, 3.0, 3.1)
* Django Rest Framework (3.10, 3.11)
* grpcio (1.34x)
* grpcio-health (1.34x)
* grpcio-reflection (1.34x)
* grpcio-tools (1.34x)
* isort


Installation
------------

    $ pip install django-grpc-bus 


Add ``django_grpc_bus`` to ``INSTALLED_APPS`` setting:

    INSTALLED_APPS = [
        ...
        'django_grpc_bus',
    ]

Add ``MESSAGE_BUS`` to settings:
    
    MESSAGE_BUS = {
        'ROOT_HANDLERS_HOOK': 'path.to.handler',
        'SERVICE_META': os.path.join(BASE_DIR, 'service_meta.yaml'),
        'PRODUCER_ROOT': os.path.join(settings.BASE_DIR, 'generated_grpc'),
        'SERVICE_TEMPLATE': os.path.join(Path(__file__).resolve().parent, 'service_template'),
        'HANDLER_TEMPLATE': os.path.join(Path(__file__).resolve().parent, 'handler_template'),
        'SERVLETS': {
            'service1': {
                'host': localhost,
                'port': 50051,
            },
            'service2': {
                'host': localhost,
                'port': 50052,
            },
            'service3': {
                'host': localhost,
                'port': 50053,
            },
        }
    }

# Example

Let's take a look at a quick example of using gRPC framework to serve and consume gRPC services.

Define ``service_meta.yml`` in the project root

```yaml
apps:
  - name: app_1
    models:
      - name: model_1
        exclude:
          - exclude_field_1
          - exclude_field_2
  - name: app_2
    models:
      - name: model_2
        fields:
          - field_1
          - field_2
      - name: model_3
```
By default all apps will be used as service, or to generate default service meta yaml for all apps using:

    ./manage.py generatemetayaml --file path.to.save.file

Update the path of ``service_meta.yaml`` in MESSAGE_BUS settings.

Generate default proto files (defined in ``service_meta.yaml``) to ``PRODUCER_ROOT`` path, using:

    ./manage.py generateproto

Once the proto files are updated, generate the gRPC python out files to ``PRODUCER_ROOT`` path, using:

    ./manage.py generategrpc

Define the components ``serializers.py``, ``services.py`` and ``handlers.py``

* ``serializers.py`` are the similar to django rest serializers, example:

```python
from django_grpc_bus import serializers as proto_serializers

from path.to.generated_grpc.grpc import ModelName_pb2
from app_name import models


class ModelNameSerializer(proto_serializers.ModelProtoSerializer):

    class Meta:
        model = models.ModelName
        proto_class = ModelName_pb2.ModelNameData
```

* ``services.py`` contains the gRPC producer services, inherited from class ModelService containing predefined mixins
 ``create``, ``retrieve``, ``update``, ``destroy`` and ``list``, example to define services.py:

```python
from django_grpc_bus.generics import ModelService

from app_name import models, serializers


class ModelNameService(ModelService):
    queryset = models.ModelName.objects.all()
    serializer_class = serializers.ModelNameSerializer
```

* ``handlers.py`` are the routers for services, that register the services, example:

```python
from django_grpc_bus.handlers import BasicHandler


handler = BasicHandler()

handler.register('app_name.services.ModelNameService')

```

To start with above components simply run the following command:

    ./manage.py generateservices -hd

Predefined templates will be generated in the app directories and ``handlers.py`` will be get appended with service 
registry.

Start the server using:

    ./manage.py rungrpcserver --dev

Server will get started at 50051 port.

To consume the services, for now we are using gRPC reflection that lists all the registered services and its methods. 
Use the client as:

```python
from django_grpc_bus.client.registry import registry

list_data = registry.servlet_name.service_name.list()  # Generator object will be returned as its stream response
get_data = registry.servlet_name.service_name.retrieve({'id': 1})
```