def __init__(self, pool_options=None, **kwargs):
self._configurations = kwargs
pool_options = pool_options or {}
self._pool = ConnectionPool(self._connect, **{
**self._defaults,
**pool_options
})
def create_pool(resource_name, max_size, max_usage, idle, ttl):
def create_resource_client():
resource = ResourceEnum[resource_name].value
return resource
return ConnectionPool(create=create_resource_client,
max_size=max_size,
max_usage=max_usage,
idle=idle,
ttl=ttl)
def create_pool(username, pw, host, database, max_size, max_usage, idle,
ttl):
def create_storage_client():
engine = create_engine("mysql+pymysql://{}:{}@{}/{}".format(
username, pw, host, database))
if not database_exists(engine.url):
create_database(engine.url)
Base.metadata.create_all(engine)
return engine
return ConnectionPool(create=create_storage_client,
max_size=max_size,
max_usage=max_usage,
idle=idle,
ttl=ttl)
class Autocomplete:
# create connection pool object
connection_pool = ConnectionPool()
def get_similar_titles(self, query):
print("similar titles called")
db_connection = self.connection_pool.get_pool_connection()
cursor = db_connection.cursor(buffered=True)
sql = """ SELECT title FROM full_movies_data WHERE title LIKE %s"""
search_query = f"%{query}%"
cursor.execute(sql, (search_query, ))
result = cursor.fetchall()
titles_list = []
for title in result:
titles_list.append(title[0])
# return result list to request
return titles_list
def create_pool(max_size, max_usage, idle, ttl):
def create_k8s_client():
try:
# Load configuration inside the Pod
config.load_incluster_config()
except ConfigException:
# Load configuration for testing
config.load_kube_config()
# Create the Apis
v1_core = client.CoreV1Api()
return v1_core
return ConnectionPool(create=create_k8s_client,
max_size=max_size,
max_usage=max_usage,
idle=idle,
ttl=ttl)
def setConnectionPool(self, create_connection, max_size, max_usage, idle, ttl):
try:
if not self.connection_pool.exists(self.connector_type_key):
print(
f'🟡 _Connector.setConnectionPool - New connection pool [{self.connector_type_key}]')
self.connection_pool.update(
connector_type=self.connector_type_key,
connection_pool=ConnectionPool(
create=create_connection,
max_size=max_size,
max_usage=max_usage,
idle=idle,
ttl=ttl
)
)
except:
print('_Connector.setConnectionPool - Failed to set connection pool')
traceback.print_exc()
def connection_pool(self):
"""set up a pool of re-usable active connections"""
# merge this object's values with those of its parent provider
args_to_use, kwargs_to_use = self.get_args_to_use()
# hashing connection pool on tuple of relevant arguments. There
# may be a better way to do this
conn_pool_label_tuple = (
type(self),
*args_to_use,
*[kwargs_to_use.get(k, None) for k in self.conn_keywords],
)
if conn_pool_label_tuple not in self.connection_pools:
create_callback = partial(
self.create_connection, *args_to_use, **kwargs_to_use
)
self.connection_pools[conn_pool_label_tuple] = ConnectionPool(
create_callback, close=self.close_connection, max_size=self.pool_size
)
return self.connection_pools[conn_pool_label_tuple]
from flask import request
from flask_cors import CORS
from flask_caching import Cache
from connection_pool import ConnectionPool
from autocomplete import Autocomplete
import engine
app = Flask(__name__)
CORS(app)
# tell Flask to use the above defined config
app.config['CACHE_TYPE'] = 'simple'
app.cache = Cache(app)
# creat connection pool object
connection_pool = ConnectionPool()
title_autocomplete = Autocomplete()
@app.cache.memoize(timeout=100)
def get_similar_titles(query):
return title_autocomplete.get_similar_titles(query)
def get_full_recommendations_data(recs):
result = []
# buffered=True allows to read the result as buffered
db_connection = connection_pool.get_pool_connection()
cursor = db_connection.cursor(buffered=True)
for movie in recs:
sql = """ SELECT * FROM full_movies_data WHERE title = %s """
from connection_pool import ConnectionPool
class Connection(object):
def __init__(self, **kwargs):
self.args = kwargs
self.state = 'Connected'
def close(self):
self.state = 'Closed'
def connect():
return Connection()
def close(connection):
connection.close()
pool = ConnectionPool(create=connect, close=close,
max_size=10, max_usage=10000, idle=60, ttl=120)
with pool.item() as connection:
assert connection.state == 'Connected'
