class ImageSimpleCache(ImageCache):
"""Simple image cache."""
def __init__(self, app=None):
"""Initialize the cache."""
super(ImageSimpleCache, self).__init__(app=app)
self.cache = SimpleCache()
def get(self, key):
"""Return the key value.
:param key: the object's key
:return: the stored object
:rtype: `BytesIO` object
"""
return self.cache.get(key)
def set(self, key, value, timeout=None):
"""Cache the object.
:param key: the object's key
:param value: the stored object
:type value: `BytesIO` object
:param timeout: the cache timeout in seconds
"""
timeout = timeout or self.timeout
self.cache.set(key, value, timeout)
self.set_last_modification(key, timeout=timeout)
def get_last_modification(self, key):
"""Get last modification of cached file.
:param key: the file object's key
"""
return self.get(self._last_modification_key_name(key))
def set_last_modification(self, key, last_modification=None, timeout=None):
"""Set last modification of cached file.
:param key: the file object's key
:param last_modification: Last modification date of
file represented by the key
:type last_modification: datetime.datetime
:param timeout: the cache timeout in seconds
"""
if not last_modification:
last_modification = datetime.utcnow().replace(microsecond=0)
timeout = timeout or self.timeout
self.cache.set(self._last_modification_key_name(key),
last_modification, timeout)
def delete(self, key):
"""Delete the specific key."""
self.cache.delete(key)
self.cache.delete(self._last_modification_key_name(key))
def flush(self):
"""Flush the cache."""
self.cache.clear()
class UtilityTestCase(unittest.TestCase):
def setUp(self):
self.c = SimpleCache()
def test_werkzeug_cache_get_or_add_missing_key(self):
self.assertEquals('bar',
werkzeug_cache_get_or_add(self.c, 'foo', 'bar', 10))
def test_werkzeug_cache_get_or_add_existing_key(self):
self.c.set('foo', 'bar')
self.assertEquals('bar',
werkzeug_cache_get_or_add(self.c, 'foo', 'qux', 10))
class OpaqueValidator:
def __init__(self,
introspection_url,
client_id,
client_secret,
verify_ssl_server=True):
self.ctx = ssl.create_default_context()
if not verify_ssl_server:
self.ctx.check_hostname = False
self.ctx.verify_mode = ssl.CERT_NONE
self._introspection_url = introspection_url
self._client_id = client_id
self._client_secret = client_secret
self._token_cache = SimpleCache()
self.logger = logging.getLogger(__name__)
def introspect_token(self, token):
params = {'token': token}
headers = {
'content-type':
'application/x-www-form-urlencoded',
'accept':
'application/jwt, application/json;q=0.9, text/plain;q=0.8, text/html;q=0.7'
}
req = request("POST",
self._introspection_url,
allow_redirects=False,
auth=(self._client_id, self._client_secret),
verify=self.ctx.check_hostname,
data=params,
headers=headers)
response_content_type = req.headers.get("Content-Type",
"text/plain").split(";")[0]
result = {}
cache_duration_header_value = req.headers.get("Cache-Duration", None)
if cache_duration_header_value:
# Turn 'public, max-age=31536000' into {'public': None, 'max-age': '31536000'}
cache_duration_parts = dict(
(part_values[0],
None if len(part_values) == 1 else part_values[1])
for part_values in [
part.strip().split("=")
for part in cache_duration_header_value.split(",")
])
if "public" in cache_duration_parts:
result["cache_timeout"] = int(cache_duration_parts["max-age"])
if req.status_code == 200:
if response_content_type == "application/json":
result.update(json.loads(req.text))
elif response_content_type == "application/jwt":
jws = jwkest.jws.factory(req.text)
if jws is not None and len(jws.jwt.part) >= 2:
result["active"] = True
result.update(json.loads(jws.jwt.part[1]))
else:
self.logger.warning(
"Response type from introspection endpoint was unsupported, response_type = "
+ response_content_type)
raise Exception(
"Response type is from introspect endpoint is " +
response_content_type, req.text)
elif req.status_code == 204:
result.update(dict(active=False))
else:
raise Exception("HTTP POST error from introspection: %s" %
req.status_code)
return result
def validate(self, token):
now = calendar.timegm(datetime.utcnow().utctimetuple())
# Lookup in cache:
cached_response = self._token_cache.get(token)
if cached_response is not None:
if cached_response['active']:
if cached_response['exp'] >= now:
return cached_response
else:
return dict(active=False)
introspect_response = self.introspect_token(token)
cache_timeout = 0
if "cache_timeout" in introspect_response:
cache_timeout = introspect_response["cache_timeout"]
elif "exp" in introspect_response:
cache_timeout = introspect_response["exp"] - now
if "active" not in introspect_response:
# The token isn't know to be active, so we'll never introspect it again
introspect_response["active"] = False
self._token_cache.set(token,
introspect_response,
timeout=cache_timeout)
raise OpaqueValidatorException(
"No active field in introspection response")
self._token_cache.set(token,
introspect_response,
timeout=cache_timeout)
if not introspect_response['active']:
return {"active": False}
if 'sub' not in introspect_response:
raise OpaqueValidatorException(
"Missing sub field in introspection response")
if 'exp' not in introspect_response:
raise OpaqueValidatorException(
"Missing exp field in introspection response")
if 'scope' not in introspect_response:
raise OpaqueValidatorException(
"Missing scope field in introspection response")
return introspect_response
return success_handle(output)
#def app(environ, start_response):
# """Simplest possible application object"""
# data = b'Hello, World!\n'
# status = '200 OK'
# response_headers = [
# ('Content-type', 'text/plain'),
# ('Content-Length', str(len(data)))
# ]
# start_response(status, response_headers)
# return iter([data])
if __name__ == "__main__":
cache.set('global_obj_count', 0)
cache.set('global_value_time', 0)
# lock to control access to variable
dataLock = threading.Lock()
def test_job():
while True:
print("Run recurring task")
time.sleep(3)
def people_counter_job(camera):
net2 = cv2.dnn.readNetFromCaffe(prototxt_path, model_path)
obj_count = 0
while True:
time.sleep(5.0)
label = '{:%d.%m.%Y %H:%M:%S}'.format(datetime.datetime.now())
# return json.dumps({"api": info})
return json.dumps(info, default=customconverter)
def success_handle(output, status=200, mimetype='application/json'):
return Response(output, status=status, mimetype=mimetype)
@app.route('/api', methods=['GET'])
def homepage():
output = json.dumps({"api": '1.0'})
return success_handle(output)
if __name__ == "__main__":
cache.set('global_obj_count', 0)
def test_job():
while True:
print("Run recurring task")
time.sleep(3)
def people_counter_job(camera):
while True:
frame = camera.get_frame()
time.sleep(1.0)
frame = imutils.resize(frame, width=400)
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)),
0.007843, (300, 300), 127.5)
