Merge pull request #1 from arturgontijo/feature/basic-service

[Repo] SNET Example Service (gRPC)

Author: raamb

Dockerfile

@@ -0,0 +1,39 @@
+FROM ubuntu:18.04
+
+ENV SINGNET_REPOS=/opt/singnet
+
+RUN mkdir -p ${SINGNET_REPOS}
+
+RUN apt-get update && \
+    apt-get install -y \
+    apt-utils \
+    nano \
+    git \
+    wget \
+    curl \
+    zip \
+    libudev-dev \
+    libusb-1.0-0-dev
+
+RUN apt-get install -y nodejs npm
+RUN apt-get install -y python3 python3-pip
+
+RUN cd ${SINGNET_REPOS} && \
+    git clone https://github.com/singnet/snet-cli && \
+    cd snet-cli && \
+    ./scripts/blockchain install && \
+    pip3 install -e .
+
+RUN cd ${SINGNET_REPOS} && \
+    mkdir snet-daemon && \
+    cd snet-daemon && \
+    wget https://github.com/singnet/snet-daemon/releases/download/v0.1.3/snetd-0.1.3.tar.gz && \
+    tar -xvf snetd-0.1.3.tar.gz && \
+    mv linux-amd64/snetd /usr/bin/snetd
+
+RUN cd ${SINGNET_REPOS} && \
+    git clone https://github.com/singnet/example-service.git && \
+    cd example-service && \
+    sh buildproto.sh
+
+WORKDIR ${SINGNET_REPOS}/example-service

README.md

@@ -0,0 +1,120 @@
+# example-service
+
+[![CircleCI](https://circleci.com/gh/singnet/example-service.svg?style=svg)](https://circleci.com/gh/singnet/example-service)
+
+Simple arithmetic service compatible with SingularityNET
+
+## Getting Started
+
+### Prerequisites
+
+* [Python 3.6.5](https://www.python.org/downloads/release/python-365/)
+
+### Installing
+
+* Clone the git repository:
+
+```
+$ git clone git@github.com:singnet/example-service.git
+$ cd example-service
+```
+
+* Install the dependencies and compile the protobuf file:
+
+```
+$ pip3 install -r requirements.txt
+$ sh buildproto.sh
+```
+
+### Running
+
+#### Standalone
+
+* Run the example service directly (without `SNET Daemon`):
+
+```
+$ python3 run_example_service.py --no-daemon
+```
+
+* To test it run the script:
+
+```
+$ python3 test_example_service.py
+```
+
+#### With SingularityNET Daemon
+
+##### SingularityNET Daemon Configuration
+
+Now you must follow the [howToPublishService](https://github.com/singnet/wiki/tree/master/tutorials/howToPublishService)
+tutorial to publish this service and set the `snetd.config.json` file.
+
+Then, be sure that you have the `snetd` in your PATH.
+
+Create the `snetd.config.json` file using this template:
+
+```
+{
+   "DAEMON_END_POINT": "http://DAEMON_HOST:DAEMON_PORT",
+   "ETHEREUM_JSON_RPC_ENDPOINT": "https://kovan.infura.io",
+   "IPFS_END_POINT": "http://ipfs.singularitynet.io:80",
+   "REGISTRY_ADDRESS_KEY": "0x2e4b2f2b72402b9b2d6a7851e37c856c329afe38",
+   "PASSTHROUGH_ENABLED": true,
+   "PASSTHROUGH_ENDPOINT": "http://SERVICE_GRPC_HOST:SERVICE_GRPC_PORT",  
+   "ORGANIZATION_NAME": "ORGANIZATION_NAME",
+   "SERVICE_NAME": "SERVICE_NAME",
+   "LOG": {
+       "LEVEL": "debug",
+       "OUTPUT": {
+            "TYPE": "stdout"
+           }
+   }
+}
+```
+
+For example, replace tags with:
+
+- `http://DAEMON_HOST:DAEMON_PORT`: http://localhost:7000
+- `http://SERVICE_GRPC_HOST:SERVICE_GRPC_PORT`: http://localhost:7003
+- `ORGANIZATION_NAME`: example-organization
+- `SERVICE_NAME`: example-service
+
+See [SingularityNet daemon configuration](https://github.com/singnet/snet-daemon/blob/master/README.md#configuration) for detailed configuration description.
+
+##### Running Service + Daemon on Host
+
+* Run the script without flag to launch both `SNET Daemon` and the service
+
+```
+$ python3 run_example_service.py
+```
+
+##### Running Service + Daemon in Docker Container
+
+* Build the docker image and run a Container from it:
+
+```
+$ docker build -t snet_example_service https://github.com/singnet/example-service.git#master
+$ docker run -p 7000:7000 -ti snet_example_service bash
+```
+
+From this point we follow the tutorial in the Docker Container's prompt.
+
+After this, run the service (with `SNET Daemon`):
+
+```
+# python3 run_example_service.py &
+```
+
+### Testing
+
+* Invoke the test script (from the same Docker Container):
+
+```
+# python3 test_example_service.py
+```
+
+## License
+
+This project is licensed under the MIT License - see the
+[LICENSE](https://github.com/singnet/example-service/blob/master/LICENSE) file for details.

buildproto.sh

@@ -0,0 +1,2 @@
+#! /bin/bash
+python3.6 -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. service/service_spec/example_service.proto

requirements.txt

@@ -0,0 +1,2 @@
+grpcio>=1.14.2
+grpcio-tools>=1.14.1

run_example_service.py

@@ -0,0 +1,72 @@
+import sys
+import subprocess
+import logging
+import pathlib
+import argparse
+
+from service import registry
+
+logging.basicConfig(level=10, format="%(asctime)s - [%(levelname)8s] - %(name)s - %(message)s")
+log = logging.getLogger("run_example_service")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run services")
+    parser.add_argument("--no-daemon", action="store_false", dest="run_daemon", help="do not start the daemon")
+    args = parser.parse_args()
+    root_path = pathlib.Path(__file__).absolute().parent
+
+    # All services modules go here
+    service_modules = ["service.example_service"]
+
+    # Call for all the services listed in service_modules
+    all_p = start_all_services(root_path, service_modules, args.run_daemon)
+
+    # Wait for all subprocesses
+    try:
+        for p in all_p:
+            p.wait()
+    except Exception as e:
+        log.error(e)
+        raise
+
+
+def start_all_services(cwd, service_modules, run_daemon):
+    """
+    Loop through all service_modules and start them.
+    For each one, an instance of Daemon "snetd" is created.
+    snetd will start with configs from "snetd.config.json"
+    """
+    all_p = []
+    for i, service_module in enumerate(service_modules):
+        service_name = service_module.split(".")[-1]
+        log.info("Launching {} on port {}".format(str(registry[service_name]), service_module))
+        all_p += start_service(cwd, service_module, run_daemon)
+    return all_p
+
+
+def start_service(cwd, service_module, run_daemon):
+    """
+    Starts SNET Daemon ("snetd") and the python module of the service
+    at the passed gRPC port.
+    """
+    all_p = []
+    if run_daemon:
+        all_p.append(start_snetd(str(cwd)))
+    service_name = service_module.split(".")[-1]
+    grpc_port = registry[service_name]["grpc"]
+    p = subprocess.Popen([sys.executable, "-m", service_module, "--grpc-port", str(grpc_port)], cwd=str(cwd))
+    all_p.append(p)
+    return all_p
+
+
+def start_snetd(cwd):
+    """
+    Starts the Daemon "snetd":
+    """
+    cmd = ["snetd", "serve"]
+    return subprocess.Popen(cmd, cwd=str(cwd))
+
+
+if __name__ == "__main__":
+    main()

service/__init__.py

@@ -0,0 +1,5 @@
+registry = {
+    "example_service": {
+        "grpc": 7003,
+    },
+}

service/common.py

@@ -0,0 +1,29 @@
+import argparse
+import os.path
+import time
+
+from service import registry
+
+
+def common_parser(script_name):
+    parser = argparse.ArgumentParser(prog=script_name)
+    service_name = os.path.splitext(os.path.basename(script_name))[0]
+    parser.add_argument("--grpc-port",
+                        help="port to bind gRPC service to",
+                        default=registry[service_name]['grpc'],
+                        type=int,
+                        required=False)
+    return parser
+
+
+# From gRPC docs:
+# Because start() does not block you may need to sleep-loop if there is nothing
+# else for your code to do while serving.
+def main_loop(grpc_handler, args):
+    server = grpc_handler(port=args.grpc_port)
+    server.start()
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        server.stop(0)

service/example_service.py

@@ -0,0 +1,119 @@
+import sys
+import logging
+
+import grpc
+import concurrent.futures as futures
+
+import service.common
+
+# Importing the generated codes from buildproto.sh
+import service.service_spec.example_service_pb2_grpc as grpc_bt_grpc
+from service.service_spec.example_service_pb2 import Result
+
+logging.basicConfig(level=10, format="%(asctime)s - [%(levelname)8s] - %(name)s - %(message)s")
+log = logging.getLogger("example_service")
+
+
+"""
+Simple arithmetic service to test the Snet Daemon (gRPC), dApp and/or Snet-CLI.
+The user must provide the method (arithmetic operation) and
+two numeric inputs: "a" and "b".
+
+e.g:
+With dApp:  'method': mul
+            'params': {"a": 12.0, "b": 77.0}
+Resulting:  response:
+                value: 924.0
+
+
+Full snet-cli cmd:
+$ snet client call mul '{"a":12.0, "b":77.0}'
+
+Result:
+(Transaction info)
+Signing job...
+
+Read call params from cmdline...
+
+Calling service...
+
+    response:
+        value: 924.0
+"""
+
+
+# Create a class to be added to the gRPC server
+# derived from the protobuf codes.
+class CalculatorServicer(grpc_bt_grpc.CalculatorServicer):
+    def __init__(self):
+        self.a = 0
+        self.b = 0
+        self.result = 0
+        # Just for debugging purpose.
+        log.debug("CalculatorServicer created")
+
+    # The method that will be exposed to the snet-cli call command.
+    # request: incoming data
+    # context: object that provides RPC-specific information (timeout, etc).
+    def add(self, request, context):
+        # In our case, request is a Numbers() object (from .proto file)
+        self.a = request.a
+        self.b = request.b
+
+        # To respond we need to create a Result() object (from .proto file)
+        self.result = Result()
+
+        self.result.value = self.a + self.b
+        log.debug("add({},{})={}".format(self.a, self.b, self.result.value))
+        return self.result
+
+    def sub(self, request, context):
+        self.a = request.a
+        self.b = request.b
+
+        self.result = Result()
+        self.result.value = self.a - self.b
+        log.debug("sub({},{})={}".format(self.a, self.b, self.result.value))
+        return self.result
+
+    def mul(self, request, context):
+        self.a = request.a
+        self.b = request.b
+
+        self.result = Result()
+        self.result.value = self.a * self.b
+        log.debug("mul({},{})={}".format(self.a, self.b, self.result.value))
+        return self.result
+
+    def div(self, request, context):
+        self.a = request.a
+        self.b = request.b
+
+        self.result = Result()
+        self.result.value = self.a / self.b
+        log.debug("div({},{})={}".format(self.a, self.b, self.result.value))
+        return self.result
+
+
+# The gRPC serve function.
+#
+# Params:
+# max_workers: pool of threads to execute calls asynchronously
+# port: gRPC server port
+#
+# Add all your classes to the server here.
+# (from generated .py files by protobuf compiler)
+def serve(max_workers=10, port=7777):
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=max_workers))
+    grpc_bt_grpc.add_CalculatorServicer_to_server(CalculatorServicer(), server)
+    server.add_insecure_port("[::]:{}".format(port))
+    return server
+
+
+if __name__ == "__main__":
+    """
+    Runs the gRPC server to communicate with the Snet Daemon.
+    """
+    parser = service.common.common_parser(__file__)
+    args = parser.parse_args(sys.argv[1:])
+    service.common.main_loop(serve, args)