Add statsd timers, fixed error response caching

Dockerfile

@@ -19,6 +19,8 @@ ENV JUSSI_SBDS_HTTP_URL https://sbds.steemitdev.com
 ENV JUSSI_REDIS_PORT 6379
 ENV ENVIRONMENT PROD
 
+
+
 RUN \
     apt-get update && \
     apt-get install -y \
@@ -35,7 +37,20 @@ RUN \
         libxml2-dev \
         libxslt-dev \
         runit \
-        nginx
+        nginx \
+        wget
+
+RUN wget -q https://www.scalyr.com/scalyr-repo/stable/latest/scalyr-repo-bootstrap_1.2.1_all.deb
+RUN dpkg -r scalyr-repo scalyr-repo-bootstrap  # Remove any previous repository definitions, if any.
+RUN dpkg -i ./scalyr-repo-bootstrap_1.2.1_all.deb
+
+#RUN rm scalyr-repo-bootstrap_1.2.1_all.deb
+
+RUN \
+    apt-get update && \
+    apt-get install -y \
+        scalyr-repo \
+        scalyr-agent-2
 
 
 RUN \
@@ -77,7 +92,8 @@ RUN \
         /var/tmp/* \
         /var/cache/* \
         /usr/include \
-        /usr/local/include
+        /usr/local/include \
+
 
 
 EXPOSE ${NGINX_SERVER_PORT}

Makefile

 SHELL := /bin/bash
 ROOT_DIR := $(shell pwd)
 
-PROJECT_NAME := jussi
+PROJECT_NAME := $(notdir $(ROOT_DIR))
 PROJECT_DOCKER_TAG := steemit/$(PROJECT_NAME)
 PROJECT_DOCKER_RUN_ARGS := -p8080:8080
 
+PIPENV_VENV_IN_PROJECT := 1
+export PIPENV_VENV_IN_PROJECT
+
 default: build
 
 .PHONY: init build run run-local test lint fmt
 
 init:
 	pip3 install pipenv
-	pipenv lock
 	pipenv install --three --dev
+	pipenv run python3 setup.py develop
 
 build:
 	docker build -t $(PROJECT_DOCKER_TAG) .
 
-run: build
+run:
 	docker run $(PROJECT_DOCKER_RUN_ARGS) $(PROJECT_DOCKER_TAG)
 
 run-local:
@@ -26,10 +29,9 @@ run-local:
 test:
 	pipenv run py.test tests
 
-
 lint:
-	pipenv run py.test --pylint -m pylint jussi
+	pipenv run py.test --pylint -m pylint $(PROJECT_NAME)
 
 fmt:
-	pipenv run yapf --recursive --in-place --style pep8 jussi
-	pipenv run autopep8 --recursive --in-place jussi
+	pipenv run yapf --recursive --in-place --style pep8 $(PROJECT_NAME)
+	pipenv run autopep8 --recursive --in-placedo $(PROJECT_NAME)
\ No newline at end of file

jussi/__about__.py

@@ -12,4 +12,3 @@ __summary__ = ""
 __uri__ = "https://github.com/steemit/jussi"
 __author__ = "John Gerlock"
 __email__ = "jg@steemit.com"
-

jussi/cache.py

@@ -3,6 +3,7 @@ import asyncio
 import hashlib
 import logging
 
+import ujson
 
 logger = logging.getLogger('sanic')
 
@@ -40,3 +41,34 @@ async def cache_set(app, value, jussi_attrs):
     cache = app.config.cache
     logger.debug('%s.set(%s, %s, ttl=%s)', cache, jussi_attrs.key, value, ttl)
     asyncio.ensure_future(cache.set(jussi_attrs.key, value, ttl=ttl))
+
+
+async def cache_json_response(app, value, jussi_attrs):
+    """Don't cache error responses
+
+    Args:
+        app: object
+        value: str || bytes
+        jussi_attrs: namedtuple
+
+    Returns:
+
+    """
+    try:
+        if isinstance(value, bytes):
+            parsed = ujson.loads(value.decode())
+        else:
+            parsed = ujson.loads(value)
+
+    except Exception as e:
+        logger.error(
+            'json parse error %s in response from upstream %s, skipping cache',
+            e, jussi_attrs.upstream_url)
+        return
+    if 'error' in parsed:
+        logger.error(
+            'jsonrpc error %s in response from upstream %s, skipping cache',
+            parsed['error'], jussi_attrs.upstream_url)
+        return
+    else:
+        asyncio.ensure_future(cache_set(app, value, jussi_attrs))

jussi/middlewares.py

 # coding=utf-8
+import time
 import logging
 
 from sanic import response
+from sanic.exceptions import InvalidUsage
 
 from .cache import cache_get
+from .utils import async_exclude_methods
 from .utils import jussi_attrs
 from .utils import replace_jsonrpc_id
 from .utils import sort_request
+from .timers import init_timers
+from .timers import log_timers
 
 logger = logging.getLogger('sanic')
 
 
+async def start_stats(request):
+    request['timers'] = init_timers(start_time=time.time())
+    request['statsd'] = request.app.config.statsd_client.pipeline()
+
+
+@async_exclude_methods(exclude_http_methods=('GET', ))
 async def add_jussi_attrs(request):
-    #request.parsed_json = replace_jsonrpc_id(request.json)
+    # request.json handles json parse errors, this handles empty json
+    if not request.json:
+        raise InvalidUsage('Bad jsonrpc request')
     request.parsed_json = sort_request(request.json)
     request = await jussi_attrs(request)
     logger.debug('request.jussi: %s', request['jussi'])
 
 
+@async_exclude_methods(exclude_http_methods=('GET', ))
 async def caching_middleware(request):
     if request['jussi_is_batch']:
         logger.debug('skipping cache for jsonrpc batch request')
         return
     jussi_attrs = request['jussi']
-    cached_response = await cache_get(request.app, jussi_attrs)
+    with request['timers']['caching_middleware']:
+        cached_response = await cache_get(request.app, jussi_attrs)
+
     if cached_response:
         return response.raw(
             cached_response,
             content_type='application/json',
             headers={'x-jussi-cache-hit': jussi_attrs.key})
+
+
+async def finalize_timers(request, response):
+    end = time.time()
+    if not request.get('timers'):
+        logger.info('skipped finalizing timers, no timers to finalize')
+        return
+    request['timers']['total_jussi_elapsed']
+    for name, timer in request['timers'].items():
+        timer.end(end)
+    log_timers(request.get('timers'), logger.debug)
+
+
+async def log_stats(request, response):
+    if not request.get('timers'):
+        logger.info('skipped logging timers, no timers to log')
+        return
+    log_timers(request.get('timers'), logger.info)
+
+    try:
+        pipe = request['statsd']
+        logger.info(pipe._stats)
+        for name, timer in request['timers'].items():
+            pipe.timing(name, timer.elapsed)
+        pipe.send()
+    except Exception as e:
+        logger.warning('Failed to send stats to statsd: %s', e)

jussi/serve.py

@@ -6,6 +6,7 @@ import functools
 import logging
 import os
 import ujson
+import datetime
 
 import aiocache
 import aiocache.plugins
@@ -13,20 +14,23 @@ import aiohttp
 import pygtrie
 import funcy
 import websockets
+from statsd import StatsClient
 from sanic import Sanic
 from sanic import response
 from sanic.exceptions import SanicException
 
 from jussi.cache import cache_get
-from jussi.cache import cache_set
+from jussi.cache import cache_json_response
 from jussi.serializers import CompressionSerializer
 from jussi.logging_config import LOGGING
 from jussi.middlewares import add_jussi_attrs
 from jussi.middlewares import caching_middleware
+from jussi.middlewares import start_stats
+from jussi.middlewares import finalize_timers
+from jussi.middlewares import log_stats
 from jussi.utils import websocket_conn
 from jussi.utils import return_bytes
 
-
 # init logging
 LOG_LEVEL = getattr(logging, os.environ.get('LOG_LEVEL', 'INFO'))
 LOGGING['loggers']['sanic']['level'] = LOG_LEVEL
@@ -41,10 +45,12 @@ NO_CACHE_TTL = -1
 NO_CACHE_EXPIRE_TTL = 0
 
 # add individual method cache settings here
-METHOD_CACHE_SETTINGS = (
-    ('get_block', 'steemd_websocket_url', NO_CACHE_EXPIRE_TTL),
-    ('get_block_header', 'steemd_websocket_url', NO_CACHE_EXPIRE_TTL),
-    ('get_global_dynamic_properties', 'steemd_websocket_url', 1))
+METHOD_CACHE_SETTINGS = (('get_block', 'steemd_websocket_url',
+                          NO_CACHE_EXPIRE_TTL),
+                         ('get_block_header', 'steemd_websocket_url',
+                          NO_CACHE_EXPIRE_TTL),
+                         ('get_global_dynamic_properties',
+                          'steemd_websocket_url', 1))
 
 
 @funcy.log_calls(logger.debug)
@@ -56,8 +62,9 @@ async def fetch_ws(app, jussi, jsonrpc_request):
     response = await ws.recv()
     return response
 
+
 @funcy.log_calls(logger.debug)
-async def http_post(app, jussi, jsonrpc_request):
+async def fetch_http(app, jussi, jsonrpc_request):
     session = app.config.aiohttp['session']
     async with session.post(jussi.upstream_url, json=jsonrpc_request) as resp:
         bytes_response = await resp.read()
@@ -72,26 +79,39 @@ async def dispatch_single(sanic_http_request, jsonrpc_request, jrpc_req_index):
     if sanic_http_request['jussi_is_batch']:
         jussi_attrs = jussi_attrs[jrpc_req_index]
 
+    # stats/logging
+    def prefix(name):
+        return '%s.%s' % (jussi_attrs.log_prefix, name)
+
+    sanic_http_request['statsd'].incr('%s.%s' % (jussi_attrs.namespace,
+                                                 jussi_attrs.method_name))
+
     # return cached response if possible
-    response = await cache_get(app, jussi_attrs)
+    with sanic_http_request['timers'][prefix('dispatch_single_caching_check')]:
+        response = await cache_get(app, jussi_attrs)
     if response:
         return response
 
     if jussi_attrs.is_ws:
-        bytes_response = await fetch_ws(app, jussi_attrs, jsonrpc_request)
+        with sanic_http_request['timers'][prefix('fetch_ws')]:
+            bytes_response = await fetch_ws(app, jussi_attrs, jsonrpc_request)
     else:
-        bytes_response = await http_post(app, jussi_attrs, jsonrpc_request)
+        with sanic_http_request['timers'][prefix('fetch_http')]:
+            bytes_response = await fetch_http(app, jussi_attrs,
+                                              jsonrpc_request)
 
     asyncio.ensure_future(
-        cache_set(app, bytes_response, jussi_attrs=jussi_attrs))
+        cache_json_response(app, bytes_response, jussi_attrs=jussi_attrs))
     return bytes_response
 
 
 async def dispatch_batch(sanic_http_request, jsonrpc_requests):
-    responses = await asyncio.gather(*[
-        dispatch_single(sanic_http_request, jsonrpc_request, jrpc_req_index)
-        for jrpc_req_index, jsonrpc_request  in enumerate(jsonrpc_requests)
-    ])
+    with sanic_http_request['timers']['batch_requests']:
+        responses = await asyncio.gather(* [
+            dispatch_single(sanic_http_request, jsonrpc_request,
+                            jrpc_req_index)
+            for jrpc_req_index, jsonrpc_request in enumerate(jsonrpc_requests)
+        ])
     json_responses = []
     for r in responses:
         if isinstance(r, bytes):
@@ -101,7 +121,7 @@ async def dispatch_batch(sanic_http_request, jsonrpc_requests):
     return ujson.dumps(json_responses).encode()
 
 
-@app.route('/', methods=['POST'])
+@app.post('/')
 async def handle(sanic_http_request):
     app = sanic_http_request.app
 
@@ -109,6 +129,7 @@ async def handle(sanic_http_request):
     jsonrpc_requests = sanic_http_request.json
 
     # make upstream requests
+
     if sanic_http_request['jussi_is_batch']:
         jsonrpc_response = await dispatch_batch(sanic_http_request,
                                                 jsonrpc_requests)
@@ -124,6 +145,23 @@ async def handle(sanic_http_request):
     return response.text(jsonrpc_response, content_type='application/json')
 
 
+# health check routes
+@app.get('/')
+async def handle(sanic_http_request):
+    return response.json({
+        'status': 'OK',
+        'datetime': datetime.datetime.utcnow().isoformat()
+    })
+
+
+@app.get('/health')
+async def handle(sanic_http_request):
+    return response.json({
+        'status': 'OK',
+        'datetime': datetime.datetime.utcnow().isoformat()
+    })
+
+
 @app.exception(SanicException)
 def handle_errors(request, exception):
     """all errors return HTTP 502
@@ -135,8 +173,14 @@ def handle_errors(request, exception):
     Returns:
 
     """
+    status_code = getattr(exception, 'status_code', 502)
+    message = str(exception) or 'Gateway Error'
     logger.error('%s-%s', request, exception)
-    return response.text(body='Gateway Error', status=502)
+    return response.json(
+        {
+            'error': message,
+            'status_code': status_code
+        }, status=status_code)
 
 
 # register listeners
@@ -150,28 +194,35 @@ def handle_errors(request, exception):
 def setup_statsd(app, loop):
     logger.info('before_server_start -> setup_statsd')
     args = app.config.args
-    if args.statsd_host:
-        app.config.statsd = {
-            'host': args.statsd_host,
-            'port': args.statsd_port,
-            'prefix': args.stats_prefix
-        }
+
+    config = {
+        'host': args.statsd_host,
+        'port': args.statsd_port,
+        'prefix': args.statsd_prefix
+    }
+    app.config.statsd_client = StatsClient(**config)
 
 
 @app.listener('before_server_start')
 def setup_middlewares(app, loop):
     logger.info('before_server_start -> setup_middlewares')
+    app.request_middleware.append(start_stats)
     app.request_middleware.append(add_jussi_attrs)
     app.request_middleware.append(caching_middleware)
 
+    app.response_middleware.append(finalize_timers)
+    app.response_middleware.append(log_stats)
+
 
 @app.listener('before_server_start')
 async def setup_cache(app, loop):
     logger.info('before_server_start -> setup_cache')
     args = app.config.args
     # only use redis if we can really talk to it
-    logger.info('before_server_start -> setup_cache redis_host:%s', args.redis_host)
-    logger.info('before_server_start -> setup_cache redis_port:%s', args.redis_port)
+    logger.info('before_server_start -> setup_cache redis_host:%s',
+                args.redis_host)
+    logger.info('before_server_start -> setup_cache redis_port:%s',
+                args.redis_port)
     try:
         if not args.redis_host:
             raise ValueError('no redis host specified')
@@ -189,7 +240,9 @@ async def setup_cache(app, loop):
         assert val == b'testval'
     except Exception as e:
         logger.exception(e)
-        logger.error('Unable to use redis (was a setting not defined?), using in-memory cache instead...')
+        logger.error(
+            'Unable to use redis (was a setting not defined?), using in-memory cache instead...'
+        )
         default_cache = aiocache.SimpleMemoryCache(
             serializer=CompressionSerializer(),
             plugins=[
@@ -239,10 +292,10 @@ async def setup_websocket_connection(app, loop):
     """
     logger.info('before_server_start -> setup_ws_client')
     args = app.config.args
-    app.config.websocket_kwargs = dict(uri=args.steemd_websocket_url,
-                                       max_size=int(2e6), max_queue=200)
-    app.config.websocket_client = await websockets.connect(**app.config.websocket_kwargs)
-
+    app.config.websocket_kwargs = dict(
+        uri=args.steemd_websocket_url, max_size=int(2e6), max_queue=200)
+    app.config.websocket_client = await websockets.connect(
+        **app.config.websocket_kwargs)
 
 
 @app.listener('before_server_start')
@@ -287,27 +340,28 @@ def main():
     parser.add_argument('--server_port', type=int, default=9000)
     parser.add_argument('--server_workers', type=int, default=os.cpu_count())
     parser.add_argument(
-            '--steemd_websocket_url', type=str,
-            default='wss://steemd.steemitdev.com')
-    parser.add_argument('--sbds_url', type=str,
-                        default='https://sbds.steemit.com')
+        '--steemd_websocket_url',
+        type=str,
+        default='wss://steemd.steemitdev.com')
+    parser.add_argument(
+        '--sbds_url', type=str, default='https://sbds.steemit.com')
     parser.add_argument('--redis_host', type=str, default=None)
     parser.add_argument('--redis_port', type=int, default=6379)
     parser.add_argument('--redis_namespace', type=str, default='jussi')
-    parser.add_argument('--statsd_host', type=str)
+    parser.add_argument('--statsd_host', type=str, default='localhost')
     parser.add_argument('--statsd_port', type=int, default=8125)
     parser.add_argument('--statsd_prefix', type=str, default='jussi')
     args = parser.parse_args()
     app.config.args = args
 
-
     # run app
     logger.info('app.run')
     app.run(
-            host=args.server_host,
-            port=args.server_port,
-            workers=args.server_workers,
-            log_config=LOGGING)
+        host=args.server_host,
+        port=args.server_port,
+        workers=args.server_workers,
+        log_config=LOGGING)
+
 
 if __name__ == '__main__':
-    main()
+    main()
\ No newline at end of file

jussi/timers.py

+# coding=utf-8
+import time
+from collections import defaultdict
+
+
+class Timer(object):
+    __slots__ = ('_start_time', '_end_time')
+
+    def __init__(self, start=None, end=None):
+        self._start_time = start or time.time()
+        self._end_time = end
+
+    def start(self, start=None):
+        if start:
+            self._start_time = start
+
+    def restart(self):
+        self._start_time = time.time()
+
+    def end(self, end=None):
+        self._end_time = self._end_time or end or time.time()
+
+    @property
+    def elapsed(self):
+        end = self._end_time or time.time()
+        return int((end - self._start_time) * 1000)
+
+    @property
+    def final(self):
+        self.end()
+        return self.elapsed
+
+    def __str__(self):
+        return str(self.elapsed)
+
+    def __repr__(self):
+        return self.elapsed
+
+    def __enter__(self, start=None):
+        if start:
+            self.start(start=start)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.end()
+
+
+def init_timers(start_time=None):
+    return defaultdict(lambda: Timer(start=start_time))
+
+
+def end_timers(timers, end=None):
+    for name, timer in timers.items():
+        if end:
+            timer.end(end)
+    return timers
+
+
+def display_timers(timers, end=None):
+    for name, timer in timers.items():
+        if end:
+            timer.end(end)
+        print('%s %s' % (name, timer))
+
+
+def log_timers(timers, log_func, end=None):
+    for name, timer in timers.items():
+        log_func('%s %s' % (name, timer))

jussi/utils.py

 # -*- coding: utf-8 -*-
 import functools
 import time
+import logging
 import websockets
+
 from collections import OrderedDict
 from collections import namedtuple
+from sanic.exceptions import InvalidUsage
 
+from jussi.cache import jsonrpc_cache_key
 
+logger = logging.getLogger('sanic')
 
 
-from jussi.cache import jsonrpc_cache_key
-
 # decorators
 def apply_single_or_batch(func):
     """Decorate func to apply func to single or batch jsonrpc_requests
@@ -32,7 +35,6 @@ def apply_single_or_batch(func):
     return wrapper
 
 
-
 def websocket_conn(func):
     """Decorate func to make sure func has an open websocket client
 
@@ -42,6 +44,7 @@ def websocket_conn(func):
     Returns:
 
     """
+
     @functools.wraps(func)
     async def wrapper(app, jussi, jsonrpc_request):
         ws = app.config.websocket_client
@@ -52,9 +55,45 @@ def websocket_conn(func):
             ws = await websockets.connect(**app.config.websocket_kwargs)
             app.config.websocket_client = ws
         return await func(app, jussi, jsonrpc_request)
+
     return wrapper
 
 
+def async_ignore_exceptions(func):
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except Exception as e:
+            logger.info('Ignored exception: %s', e)
+
+    return wrapper
+
+
+def async_exclude_methods(middleware_func=None, exclude_http_methods=None):
+    """Exclude specified HTTP methods from middleware
+
+    Args:
+        middleware_func:
+        exclude_http_methods:
+
+    Returns:
+
+    """
+    if middleware_func is None:
+        return functools.partial(
+            async_exclude_methods, exclude_http_methods=exclude_http_methods)
+
+    @functools.wraps(middleware_func)
+    async def f(request):
+        if request.method in exclude_http_methods:
+            return request
+        else:
+            return await middleware_func(request)
+
+    return f
+
+
 def return_bytes(func):
     """Decorate func to make sure func has an open websocket client
 
@@ -64,14 +103,15 @@ def return_bytes(func):
     Returns:
 
     """
+
     @functools.wraps(func)
     async def wrapper(*args, **kwargs):
         result = await func(*args, **kwargs)
         if isinstance(result, str):
             result = result.encode()
         return result
-    return wrapper
 
+    return wrapper
 
 
 def generate_int_id():
@@ -137,28 +177,38 @@ async def get_upstream(sanic_http_request, jsonrpc_request):
     return upstream['url'], upstream['ttl']
 
 
-JussiAttributes = namedtuple(
-    'JussiAttributes', ['key', 'upstream_url', 'ttl', 'cacheable', 'is_ws'])
+JussiAttributes = namedtuple('JussiAttributes', [
+    'key', 'upstream_url', 'ttl', 'cacheable', 'is_ws', 'namespace',
+    'method_name', 'log_prefix'
+])
 
 
 async def jussi_attrs(sanic_http_request):
     jsonrpc_requests = sanic_http_request.json
+
     app = sanic_http_request.app
 
     if isinstance(jsonrpc_requests, list):
         results = []
-        for r in jsonrpc_requests:
+        for i, r in enumerate(jsonrpc_requests):
+            if not r:
+                raise InvalidUsage('Bad jsonrpc request')
             key = jsonrpc_cache_key(r)
             url, ttl = await get_upstream(sanic_http_request, r)
             cacheable = ttl > app.config.cache_config['no_cache_ttl']
             is_ws = url.startswith('ws')
+            namespace, method_name = parse_namespaced_method(r['method'])
+            prefix = '.'.join([str(i), namespace, method_name])
             results.append(
                 JussiAttributes(
                     key=key,
                     upstream_url=url,
                     ttl=ttl,
                     cacheable=cacheable,
-                    is_ws=is_ws))
+                    is_ws=is_ws,
+                    namespace=namespace,
+                    method_name=method_name,
+                    log_prefix=prefix))
         sanic_http_request['jussi'] = results
         sanic_http_request['jussi_is_batch'] = True
     else:
@@ -166,12 +216,18 @@ async def jussi_attrs(sanic_http_request):
         url, ttl = await get_upstream(sanic_http_request, jsonrpc_requests)
         cacheable = ttl > app.config.cache_config['no_cache_ttl']
         is_ws = url.startswith('ws')
+        namespace, method_name = parse_namespaced_method(
+            jsonrpc_requests['method'])
+        prefix = '.'.join(['0', namespace, method_name])
         sanic_http_request['jussi'] = JussiAttributes(
             key=key,
             upstream_url=url,
             ttl=ttl,
             cacheable=cacheable,
-            is_ws=is_ws)
+            is_ws=is_ws,
+            namespace=namespace,
+            method_name=method_name,
+            log_prefix=prefix)
         sanic_http_request['jussi_is_batch'] = False
 
-    return sanic_http_request
+    return sanic_http_request
\ No newline at end of file

setup.py

@@ -5,7 +5,8 @@ try:
     from pipenv.project import Project
     from pipenv.utils import convert_deps_to_pip
 except ImportError:
-    raise Exception('setup requires pipenv. Run "pip3 install pipenv" then try again')
+    raise Exception(
+        'setup requires pipenv. Run "pip3 install pipenv" then try again')
 
 pfile = Project().parsed_pipfile
 requirements = convert_deps_to_pip(pfile['packages'], r=False)
@@ -21,24 +22,16 @@ with open(os.path.join(base_dir, "jussi", "__about__.py")) as f:
 with open(os.path.join(base_dir, "README.md")) as f:
     long_description = f.read()
 
-
 setup(
     name=about["__title__"],
     version=about["__version__"],
-
     description=about["__summary__"],
     long_description=long_description,
     url=about["__uri__"],
-
     author=about["__author__"],
     author_email=about["__email__"],
-
-    setup_requires=['pipenv','pytest-runner'],
+    setup_requires=['pipenv', 'pytest-runner'],
     tests_require=test_requirements,
     install_requires=requirements,
-
     packages=["jussi"],
-    entry_points={
-        'console_scripts': ['jussi=jussi.serve:main']
-    }
-)
+    entry_points={'console_scripts': ['jussi=jussi.serve:main']})
\ No newline at end of file