zerocs 2.5
zerocs
License: MIT License
Requires Python: >=3.7

zerocs Description Document
============================

zerocs: zero config service
+++++++++++++++++++++++++++

1. introduction

    1. zerocs is a distributed task framework with extremely simple configuration.
    Enable users to quickly build distributed task systems with minimal
    configuration and learning costs

    2. The framework has functions such as service management, work management,
    and task management, which can meet most usage scenarios

    3. Note: Version 1.9 is not compatible with version 1.3.
    It is recommended to upgrade to version 1.9 and above

    4. Decentralization starting from version 1.9,
    no longer distinguishing between master and slave nodes

2. start using

    1. Please install RabbitMQ before use,
    rabbitmq official website : https://www.rabbitmq.com,
    It is recommended to use Docker installation during testing::

            docker run -d --hostname my-rabbit --name rabbit \
            -e RABBITMQ_DEFAULT_USER=user \
            -e RABBITMQ_DEFAULT_PASS=password \
            -p 15672:15672 -p 5672:5672 rabbitmq:management

    2. Please install MongoDB before use,
    Installation steps reference : https://docs.mongoing.com/install-mongodb

    3. To use the framework, it is very simple, just refer to zerocs
    in the first line of your startup script
    Please create the corresponding directory and files before starting::

          ├─logs //log directory
          ├─service_list //Directory of microservice codes
          │  │─test
          │  │  ├─test.py
          │  │  ├─test1.py
          ├─main.py  //main
          └─zerocs_test.py //Test Script

    4. main.py ::

        # -*- encoding: utf-8 -*-
        # Master startup file, please refer to zerocs first
        # Flask API is not mandatory and can be connected to other management systems

        import os
        import logging
        from flask_cors import CORS
        from flask import Flask, request

        from zerocs import Main, Interface
        from service_list.test import test, test1

        app = Flask(__name__)
        CORS(app, supports_credentials=True)

        logging.basicConfig(level=logging.ERROR)
        script_path = os.path.dirname(os.path.realpath(__file__))


        class Master:

            def __init__(self):
                config = {
                    "PATH": script_path,
                    "RABBITMQ_CONFIG": "amqp://admin:Rabbit*ads12@127.0.0.1:5672",
                    "MONGODB_CONFIG": "mongodb://admin:123456@127.0.0.1:27017"
                }
                Main.run_master(
                    configs=config,
                    services=[test, test1]
                )

            @staticmethod
            def get_service_list(query: dict, field: dict, limit: int, page: int) -> dict:
                count, data = Interface.get_service_list(query, field, limit, page)
                return {"count": count, "data": data}

            @staticmethod
            def stop_tasks(task_id: str):
                Interface.insert_stop_tasks(task_id)

            @staticmethod
            def remote_call(service_name: str, service_ip: str, method_name: str, **params):
                rpc_proxy = Interface.remote_call_by_name_and_ip(service_name, service_ip)
                return rpc_proxy.remote_call(service_name, method_name, **params)

            @staticmethod
            def send_message(service_name: str, message: dict):
                if 'task_id' in message:
                    Interface.send_message(service_name, message)

            @staticmethod
            def restart_service(service_name: str):
                Interface.restart_service(service_name)


        @app.route("/")
        def index():
            data = _main.get_service_list({}, {"_id": 0}, 10, 0)
            return data


        @app.route("/get_service_list")
        def get_service_list():
            request_json = request.get_json()
            query = request_json['query']
            field = request_json['field']
            limit = request_json['limit']
            page = request_json['page']

            data = _main.get_service_list(query, field, limit, page)
            return data


        @app.route("/restart_service")
        def restart_service():
            request_json = request.get_json()
            service_name = request_json['service_name']
            _main.restart_service(service_name)
            return {"code": 0}


        if __name__ == '__main__':
            _main = Master()
            app.run(host='0.0.0.0', port=5002)

    5. test.py ::

        import time

        class RpcFunction:
            """
            Class Name Not modifiable, Define RPC functions
            """
            service_name = 'test'

            def get_service_name(self, xxx):
                return {"service_name": self.service_name, "param": xxx}


        class WorkFunction:
            """
            Class Name Not modifiable, Work Code
            """

            def __init__(self, task_data):
                """
                :param task_data: Task data JSON format
                """
                logger = self.__getattribute__('logger')
                rpc_proxy = self.__getattribute__('rpc_proxy')

                """
                Call the rpc interface

                data = rpc_proxy.remote_call(service_name, method_name, **params)
                """

    6. zerocs_test.py ::

        # -*- encoding: utf-8 -*-
        import os

        from zerocs import Interface

        script_path = os.path.dirname(os.path.realpath(__file__))

        if __name__ == '__main__':
            config = {
                "PATH": os.path.join(script_path, 'logs'),
                "RABBITMQ_CONFIG": "amqp://admin:Rabbit*ads12@127.0.0.1:5672",
                "MONGODB_CONFIG": "mongodb://admin:123456@127.0.0.1:27017"
            }

            # initialization
            Interface.init_proxy(config)

            # Stop the task
            Interface.insert_stop_tasks('1001')

            # Call the RPC interface
            obj = Interface.remote_call_by_name_and_ip('test', '192.168.0.101')
            print(obj.remote_call('test' ,'get_service_name', param='1111111111'))

            # Issue task message
            Interface.send_message('test', {"task_id": "100", "msg": "xxxxxxxxxxxxxxxx"})


A distributed task scheduling system was completed in just a few steps
======================================================================

Disclaimers
================


+   Before using the zerocs framework, please carefully read and fully understand this statement.
    You can choose not to use the zerocs framework, but once you use the zerocs framework,
    Your usage behavior is deemed to be recognition and acceptance of the entire content of this statement.

+   You promise to use the zerocs framework in a legal and reasonable manner,
    Do not use the zerocs board framework to engage in any illegal or malicious behavior that infringes
    on the legitimate interests of others,
    We will not apply the zerocs framework to any platform that violates Chinese laws and regulations.

+   Any accident, negligence, contract damage, defamation
    This project does not assume any legal responsibility for copyright or intellectual property
    infringement and any losses caused (including but not limited to direct,
    indirect, incidental or derivative losses).

+   The user clearly and agrees to all the contents listed in the terms of this statement,
    The potential risks and related consequences of using the zerocs framework will be entirely borne by the user,
    and this project will not bear any legal responsibility.

+   After reading this disclaimer, any unit or individual should obtain the MIT Open Source License
    Conduct legitimate publishing, dissemination, and use of the zerocs framework within the permitted scope,
    If the breach of this disclaimer clause or the violation of laws and regulations results in legal
    liability (including but not limited to civil compensation and criminal liability),
    the defaulter shall bear the responsibility on their own.

+   The author owns intellectual property rights (including but not limited to trademark rights, patents, Copyrights,
    trade secrets, etc.) of zerocs framework, and the above products are protected by relevant laws and regulations

+   No entity or individual shall apply for intellectual property rights related to
    the zerocs Framework itself without the written authorization of the Author.

+   If any part of this statement is deemed invalid or unenforceable,
    the remaining parts shall remain in full force and effect.
    An unenforceable partial declaration does not constitute a waiver of our
    right to enforce the declaration.

+   This project has the right to make unilateral changes to the terms and attachments of this statement at any time,
    and publish them through message push, webpage announcement, and other means. Once published,
    it will automatically take effect without the need for separate notice;
    If you continue to use this statement after the announcement of changes,
    it means that you have fully read, understood, and accepted the revised statement.