health = self.grpc_client.Health(self.health_ping)

# to

health = self.grpc_client.Health(self.health_ping, timeout=my_timeout_in_seconds)

python -m grpc_tools.protoc -I proto --python_out=. --grpc_python_out=. proto/protos/hello.proto

import json
import logging

import pika
import tornado.ioloop
from tornado.web import Application
from tornado.websocket import WebSocketHandler

LOG_FORMAT = ('%(levelname) -10s %(asctime)s %(name) -30s %(funcName) '
              '-35s %(lineno) -5d: %(message)s')
LOGGER = logging.Logger(__name__)


class Publisher(object):
    EXCHANGE = 'logs'
    EXCHANGE_TYPE = 'fanout'
    ROUTING_KEY = ''

    def __init__(self, amqp_url):
        self._connection = None
        self._channel = None
        self._stopping = False
        self._url = amqp_url
        self._closing = False

    def connect(self):
        LOGGER.info('Connecting to %s', self._url)
        self._connection = pika.adapters.TornadoConnection(pika.URLParameters(self._url),
                                                           self.on_connection_open)

    def on_connection_open(self, unused_connection):
        LOGGER.info('Connection opened')
        self.open_channel()

    def open_channel(self):
        LOGGER.info('Creating a new channel')
        self._connection.channel(on_open_callback=self.on_channel_open)

    def on_channel_open(self, channel):
        LOGGER.info('Channel opened')
        self._channel = channel
        self.setup_exchange(self.EXCHANGE)

    def setup_exchange(self, exchange_name):
        LOGGER.info('Declaring exchange %s', exchange_name)
        self._channel.exchange_declare(self.on_exchange_declareok,
                                       exchange_name,
                                       self.EXCHANGE_TYPE)

    def on_exchange_declareok(self, unused_frame):
        LOGGER.info('Exchange declared')

    def publish_message(self, message):
        properties = pika.BasicProperties(delivery_mode=2, )

        self._channel.basic_publish(self.EXCHANGE, self.ROUTING_KEY,
                                    json.dumps(message, ensure_ascii=False),
                                    properties)

        LOGGER.info('Published message')


class IndexHandler(WebSocketHandler):
    links = []

    def open(self):
        self.links.append(self)

    def on_message(self, message):
        app.pika.publish_message(message)


app = Application([
    (r'/', IndexHandler)
])

url = "amqp://zy:123456@192.168.1.158:5672/%2F?connection_attempts=3&heartbeat_interval=3600"
app.pika = Publisher(url)
app.listen(80)
ioloop = tornado.ioloop.IOLoop.current()
ioloop.add_timeout(500, app.pika.connect)
ioloop.start()

from datetime import timedelta
from flask import make_response, request, current_app, jsonify
from functools import update_wrapper

from flask import Flask

"""


关于flask 允许跨域....

"""

def crossdomain(origin=None, methods=None, headers=None,
                max_age=21600, attach_to_all=True,
                automatic_options=True):
    """
        See: http://flask.pocoo.org/snippets/56/
        """
    if methods is not None:
        methods = ', '.join(sorted(x.upper() for x in methods))
    if headers is not None and not isinstance(headers, str):
        headers = ', '.join(x.upper() for x in headers)
    if not isinstance(origin, str):
        origin = ', '.join(origin)
    if isinstance(max_age, timedelta):
        max_age = max_age.total_seconds()

    def get_methods():
        if methods is not None:
            return methods

        options_resp = current_app.make_default_options_response()
        return options_resp.headers['allow']

    def decorator(f):
        def wrapped_function(*args, **kwargs):
            if automatic_options and request.method == 'OPTIONS':
                resp = current_app.make_default_options_response()
            else:
                resp = make_response(f(*args, **kwargs))
            if not attach_to_all and request.method != 'OPTIONS':
                return resp

            h = resp.headers

            h['Access-Control-Allow-Origin'] = origin
            h['Access-Control-Allow-Methods'] = get_methods()
            h['Access-Control-Max-Age'] = str(max_age)
            if headers is not None:
                h['Access-Control-Allow-Headers'] = headers
            return resp

        f.provide_automatic_options = False
        return update_wrapper(wrapped_function, f)

    return decorator


app = Flask(__name__)


@app.route('/', methods=['POST'])
@crossdomain(origin='*')
def index():
    form = request.form
    json = request.json
    print(form, json)

    return jsonify('error=0')


app.run(port=8080)

import click


@click.command()
@click.option('-n', '--name', default='zy', help='名字')
@click.option('-a', '--age', default=22, help='年龄')
def sayhi(name, age):
    print(name, age)


def main():
    sayhi()


if __name__ == "__main__":
    main()

import logging
import zipfile

import click

from kguo import create_app
from kguo.core.db import redis_db

app = create_app()

if app.config.get("LOGGER_ENABLED"):
    logging.basicConfig(
        level=getattr(logging, app.config.get("LOGGER_LEVEL", "DEBUG")),
        format=app.config.get(
            "LOGGER_FORMAT",
            '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'),
        datefmt=app.config.get("LOGGER_DATE_FORMAT", '%d.%m %H:%M:%S')
    )


@click.group()
def core_cmd():
    """ Core Commands """
    pass


@core_cmd.command()
def check():
    """Prints app status"""
    from pprint import pprint
    print("Extensions.")
    pprint(app.extensions)
    print("Modules.")
    pprint(app.blueprints)
    print("App.")
    return app


@core_cmd.command()
def showconfig():
    """Print all config variables"""
    from pprint import pprint
    print("Config.")
    pprint(dict(app.config.store()))


@core_cmd.command()
@click.option('--reloader/--no-reloader', default=True)
@click.option('--debug/--no-debug', default=True)
@click.option('--host', default='127.0.0.1')
@click.option('--port', default=5000)
def runserver(reloader, debug, host, port):
    """Run the Flask development server i.e. app.run()"""
    app.run(use_reloader=reloader, debug=debug, host=host, port=port)


@core_cmd.command()
@click.option('--path', default='captchas.zip')
def loadcap(path):
    """Load captcha from zip file

    ZIP文件应该在根目录包含全部文件，并不含后缀
    """
    f = zipfile.ZipFile(path, 'r')
    redis_db.delete('captcha')
    for idx, name in enumerate(f.namelist()):
        with f.open(name, 'r') as img:
            redis_db.hset('captcha', 'p%d' % idx, img.read())
            redis_db.hset('captcha', 'w%d' % idx, name)
    redis_db.hset('captcha', 'count', idx + 1)
    f.close()

help_text = """
    Kguo App Manager

"""

manager = click.CommandCollection(help=help_text)
manager.add_source(core_cmd)


if __name__ == '__main__':
    with app.app_context():
        manager()