added experimantal branch

this branch is used for multiprocessing development

Author: konstantinpae

flask.py

@@ -0,0 +1,121 @@
+from flask import Flask
+try:
+    from PythonMiniProbe import probe
+except:
+    import probe
+
+import requests
+import json
+import gc
+import time
+import sys
+
+pyprtg = Flask(__name__)
+
+
+@pyprtg.route('/')
+def mini_probe_home():
+    return 'Python Mini Probe Home'
+
+if __name__ == '__main__':
+        pyprtg.debug = True
+        pyprtg.run(host='0.0.0.0', port=50000)
+
+        # mini_probe = probe.Probe()
+        # # Enable Garbage Collection
+        # gc.enable()
+        # # make sure the probe will not stop
+        # probe_stop = False
+        # # Create instance of Logger to provide logging
+        # log = Logger()
+        # # make sure probe is announced at every start
+        # announce = False
+        # # read configuration file (existence check done in probe_controller.py)
+        # config = mini_probe.read_config('./probe.conf')
+        # # create hash of probe access key
+        # key_sha1 = mini_probe.hash_access_key(config['key'])
+        # # get list of all sensors announced in __init__.py in package sensors
+        # sensor_list = mini_probe.get_import_sensors()
+        # sensor_announce = mini_probe.build_announce(sensor_list)
+        # announce_json = json.dumps(sensor_announce)
+        # url_announce = mini_probe.create_url(config, 'announce')
+        # data_announce = mini_probe.create_parameters(config, announce_json, 'announce')
+        #
+        # while not announce:
+        #     try:
+        #         # announcing the probe and all sensors
+        #         request_announce = requests.get(url_announce, params=data_announce, verify=False)
+        #         announce = True
+        #         log.log(True, None, config, "ANNOUNCE", None, None)
+        #         if config['debug']:
+        #             log.log_custom(config['server'])
+        #             log.log_custom(config['port'])
+        #             log.log_custom("Status Code: %s | Message: %s" % (request_announce.status_code, request_announce.text))
+        #         request_announce.close()
+        #     except Exception as e:
+        #         log.log_custom(e)
+        #         time.sleep(int(config['baseinterval']) / 2)
+        #
+        # while not probe_stop:
+        #     # creating some objects only needed in loop
+        #     url_task = mini_probe.create_url(config, 'tasks')
+        #     task_data = {'gid':config['gid'], 'protocol':config['protocol'], 'key':key_sha1}
+        #
+        #     task = False
+        #     while not task:
+        #         json_payload_data = []
+        #         try:
+        #             request_task = requests.get(url_task, params=task_data, verify=False)
+        #             json_response = request_task.json()
+        #             request_task.close()
+        #             gc.collect()
+        #             task = True
+        #             log.log(True, None, config, "TASK", None, None)
+        #             if config['debug']:
+        #                 log.log_custom(url_task)
+        #         except Exception as e:
+        #             log.log_custom(e)
+        #             time.sleep(int(config['baseinterval']) / 2)
+        #     gc.collect()
+        #     if str(json_response) != '[]':
+        #         json_response_chunks = [json_response[i:i+10] for i in range(0, len(json_response), 10)]
+        #         for element in json_response_chunks:
+        #             for part in element:
+        #                 if config['debug']:
+        #                     log.log_custom(part)
+        #                 for sensor in sensor_list:
+        #                     if part['kind'] == sensor.get_kind():
+        #                         json_payload_data.append(sensor.get_data(part))
+        #                     else:
+        #                         pass
+        #                 gc.collect()
+        #             url_data = mini_probe.create_url(config, 'data')
+        #             try:
+        #                 request_data = requests.post(url_data, data=json.dumps(json_payload_data), verify=False)
+        #                 log.log(True, None, config, "DATA", None, None)
+        #
+        #                 if config['debug']:
+        #                     log.log_custom(json_payload_data)
+        #                 request_data.close()
+        #                 json_payload_data = []
+        #             except Exception as e:
+        #                 log.log_custom(e)
+        #             if (len(json_response) > 10):
+        #                 time.sleep((int(config['baseinterval']) * (9 / len(json_response))))
+        #             else:
+        #                 time.sleep(int(config['baseinterval']) / 2)
+        #     else:
+        #         log.log(True, "Nothing", config, None, None, None)
+        #         time.sleep(int(config['baseinterval']) / 3)
+        #
+        #     # Delete some stuff used in the loop and run the garbage collector
+        #     del json_response
+        #     del json_payload_data
+        #     gc.collect()
+        #
+        #     if config['cleanmem']:
+        #         # checking if the clean memory option has been chosen during install then call the method to flush mem
+        #         from utils import Utils
+        #         Utils.clean_mem()
+        # sys.exit()
+

flask/__init__.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""
+    flask
+    ~~~~~
+
+    A microframework based on Werkzeug.  It's extensively documented
+    and follows best practice patterns.
+
+    :copyright: (c) 2014 by Armin Ronacher.
+    :license: BSD, see LICENSE for more details.
+"""
+
+__version__ = '0.11-dev'
+
+# utilities we import from Werkzeug and Jinja2 that are unused
+# in the module but are exported as public interface.
+from werkzeug.exceptions import abort
+from werkzeug.utils import redirect
+from jinja2 import Markup, escape
+
+from .app import Flask, Request, Response
+from .config import Config
+from .helpers import url_for, flash, send_file, send_from_directory, \
+     get_flashed_messages, get_template_attribute, make_response, safe_join, \
+     stream_with_context
+from .globals import current_app, g, request, session, _request_ctx_stack, \
+     _app_ctx_stack
+from .ctx import has_request_context, has_app_context, \
+     after_this_request, copy_current_request_context
+from .module import Module
+from .blueprints import Blueprint
+from .templating import render_template, render_template_string
+
+# the signals
+from .signals import signals_available, template_rendered, request_started, \
+     request_finished, got_request_exception, request_tearing_down, \
+     appcontext_tearing_down, appcontext_pushed, \
+     appcontext_popped, message_flashed
+
+# We're not exposing the actual json module but a convenient wrapper around
+# it.
+from . import json
+
+# This was the only thing that flask used to export at one point and it had
+# a more generic name.
+jsonify = json.jsonify
+
+# backwards compat, goes away in 1.0
+from .sessions import SecureCookieSession as Session
+json_available = True

flask/__main__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+"""
+    flask.__main__
+    ~~~~~~~~~~~~~~
+
+    Alias for flask.run for the command line.
+
+    :copyright: (c) 2014 by Armin Ronacher.
+    :license: BSD, see LICENSE for more details.
+"""
+
+
+if __name__ == '__main__':
+    from .cli import main
+    main(as_module=True)

flask/_compat.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+"""
+    flask._compat
+    ~~~~~~~~~~~~~
+
+    Some py2/py3 compatibility support based on a stripped down
+    version of six so we don't have to depend on a specific version
+    of it.
+
+    :copyright: (c) 2014 by Armin Ronacher.
+    :license: BSD, see LICENSE for more details.
+"""
+import sys
+
+PY2 = sys.version_info[0] == 2
+_identity = lambda x: x
+
+
+if not PY2:
+    text_type = str
+    string_types = (str,)
+    integer_types = (int,)
+
+    iterkeys = lambda d: iter(d.keys())
+    itervalues = lambda d: iter(d.values())
+    iteritems = lambda d: iter(d.items())
+
+    from io import StringIO
+
+    def reraise(tp, value, tb=None):
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+    implements_to_string = _identity
+
+else:
+    text_type = unicode
+    string_types = (str, unicode)
+    integer_types = (int, long)
+
+    iterkeys = lambda d: d.iterkeys()
+    itervalues = lambda d: d.itervalues()
+    iteritems = lambda d: d.iteritems()
+
+    from cStringIO import StringIO
+
+    exec('def reraise(tp, value, tb=None):\n raise tp, value, tb')
+
+    def implements_to_string(cls):
+        cls.__unicode__ = cls.__str__
+        cls.__str__ = lambda x: x.__unicode__().encode('utf-8')
+        return cls
+
+
+def with_metaclass(meta, *bases):
+    # This requires a bit of explanation: the basic idea is to make a
+    # dummy metaclass for one level of class instantiation that replaces
+    # itself with the actual metaclass.  Because of internal type checks
+    # we also need to make sure that we downgrade the custom metaclass
+    # for one level to something closer to type (that's why __call__ and
+    # __init__ comes back from type etc.).
+    #
+    # This has the advantage over six.with_metaclass in that it does not
+    # introduce dummy classes into the final MRO.
+    class metaclass(meta):
+        __call__ = type.__call__
+        __init__ = type.__init__
+        def __new__(cls, name, this_bases, d):
+            if this_bases is None:
+                return type.__new__(cls, name, (), d)
+            return meta(name, bases, d)
+    return metaclass('temporary_class', None, {})
+
+
+# Certain versions of pypy have a bug where clearing the exception stack
+# breaks the __exit__ function in a very peculiar way.  This is currently
+# true for pypy 2.2.1 for instance.  The second level of exception blocks
+# is necessary because pypy seems to forget to check if an exception
+# happened until the next bytecode instruction?
+BROKEN_PYPY_CTXMGR_EXIT = False
+if hasattr(sys, 'pypy_version_info'):
+    class _Mgr(object):
+        def __enter__(self):
+            return self
+        def __exit__(self, *args):
+            sys.exc_clear()
+    try:
+        try:
+            with _Mgr():
+                raise AssertionError()
+        except:
+            raise
+    except TypeError:
+        BROKEN_PYPY_CTXMGR_EXIT = True
+    except AssertionError:
+        pass