class SQLManager(object):
def __init__(self):
self.connect_to_database()
def connect_to_database(self):
DB_NAME = settings.get_database()
self.connpool = MySQLConnectionPool(user=settings.DatabaseConfig.USERNAME,
password=settings.DatabaseConfig.PASSWORD,
host=settings.DatabaseConfig.HOST,
pool_name="order_manager",
pool_size=5,
autocommit=True,
database=DB_NAME
)
self.cnx1 = self.connpool.get_connection()
self.cur1 = self.cnx1.cursor()
self.cnx2 = self.connpool.get_connection()
self.cur2 = self.cnx2.cursor()
self.cnx3 = self.connpool.get_connection()
self.cur3 = self.cnx3.cursor()
self.cnx4 = self.connpool.get_connection()
self.cur4 = self.cnx4.cursor()
self.cnx5 = self.connpool.get_connection()
self.cur5 = self.cnx5.cursor()
def __init__(self):
if self.INSTANCE is not None:
raise ValueError("An instantiation already exists!")
else:
db_config = read_db_config(filename='Config.ini', section='mysql')
print(type(db_config), db_config)
self.__cnxPool = MySQLConnectionPool(pool_name='myPool', pool_size=5, **db_config)
def __init__(self):
if self.INSTANCE is not None:
raise ValueError("An instantiation already exists!")
else:
self.__cnxPool = MySQLConnectionPool(pool_name='myPool',
pool_size=5,
option_files='db_config.conf')
def __init__(self):
"""Mysqldriver Constructor."""
self.config = {
"host":
"db-espresso-dev" if environ.get("APP_ENV") == "development" else
environ.get("MYSQL_HOST"),
"database":
environ.get("MYSQL_DATABASE", "espresso_db"),
"user":
environ.get("MYSQL_USER", "root"),
"password":
environ.get("MYSQL_ROOT_PASSWORD", "strawberry"),
"port":
int(environ.get("MYSQL_PORT", 3306)),
"pool_name":
"mysql_pool",
"pool_size":
5,
"pool_reset_session":
False, # MySQL version 5.7.2 and earlier does not support COM_RESET_CONNECTION.
}
try:
self.cnxpool = MySQLConnectionPool(**self.config)
except errors.Error as err:
print(err)
def _init_pool(self):
logger.info("Connecting pool to DB")
self.pool_mutex.acquire()
self.pool = MySQLConnectionPool(
pool_name="db_wrapper_pool",
pool_size=self.application_args.db_poolsize,
**self.dbconfig)
self.pool_mutex.release()
def __init__(self):
if self.INSTANCE is not None:
raise ValueError("An instantiation already exists!")
else:
db_config = read_db_config()
self.__cnxPool = MySQLConnectionPool(pool_name="myPool",
pool_size=5,
**db_config)
def __init__(self, filename='../resources/db_properties.ini'):
if self.INSTANCE is not None:
raise ValueError("An instantiation already exists!")
else:
db_config = read_db_config(filename)
self.__cnxPool = MySQLConnectionPool(pool_name="myPool",
pool_size=10,
**db_config)
def __init__(self, broker_cloud, mode, db_config, time_inactive_platform, time_update_conf, time_check_platform_active):
self.time_update_conf = time_update_conf
self.time_check_platform_active = time_check_platform_active
self.time_inactive_platform = time_inactive_platform
self.cnxpool = MySQLConnectionPool(pool_name="mypool", pool_size=32, **db_config)
self.mode = mode
self.producer_connection = Connection(broker_cloud)
self.consumer_connection = Connection(broker_cloud)
self.exchange = Exchange("IoT", type="direct")
def __init__(self, config):
"""Constructor to initialize the connection pool.
Args:
config (dict): Connection configuration for database.
"""
self._config = config
self._db_pool = MySQLConnectionPool(pool_name="disc_pool",
pool_size=_POOL_SIZE,
**config)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# self._conn_params['use_pure'] = True
self._conn_params['pool_name'] = 'test_pool'
self._conn_params['pool_size'] = 10
try:
self._pool = MySQLConnectionPool(**self._conn_params)
self._closed = False
except InterfaceError as e:
log.error('MysqlPooledDataSource connect error')
log.error(formatErrorMsg(e))
raise e
def _init_pool(self):
logger.info("Connecting to DB")
dbconfig = {
"host": self.host,
"port": self.port,
"user": self.user,
"password": self.password,
"database": self.database
}
with self._pool_mutex:
self._pool = MySQLConnectionPool(pool_name="db_wrapper_pool",
pool_size=self._poolsize,
**dbconfig)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._conn_params['use_pure'] = True
self._conn_params['pool_name'] = 'test_pool'
self._conn_params['pool_size'] = 10
# self._pool = MySQLConnectionPool(**{'user':self._user_name,'password':self._pass_word,\
# 'host':self._host,'port':self._port,'database':self._data_base,\
# 'use_pure':True,'pool_name':"test_pool",'pool_size':10})
try:
self._traceback = None
self._pool = MySQLConnectionPool(**self._conn_params)
except InterfaceError as e:
print('MysqlPooledDataSource connect error')
e.with_traceback(self._traceback)
raise e
def _init_pool(self):
logger.info("Connecting to DB")
dbconfig = {
"host": self.host,
"port": self.port,
"user": self.user,
"password": self.password,
"database": self.database,
"time_zone": "America/Los_Angeles"
}
self._pool_mutex.acquire()
self._pool = MySQLConnectionPool(pool_name="db_wrapper_pool",
pool_size=self._poolsize,
**dbconfig)
self._pool_mutex.release()
class DatabaseConnectionPool(object):
INSTANCE = None
def __init__(self, filename='../resources/db_properties.ini'):
if self.INSTANCE is not None:
raise ValueError("An instantiation already exists!")
else:
db_config = read_db_config(filename)
self.__cnxPool = MySQLConnectionPool(pool_name="myPool",
pool_size=10,
**db_config)
@classmethod
def get_instance(
cls,
filename='../resources/db_properties.ini',
):
print("get_instance() ------------", filename)
if cls.INSTANCE is None:
cls.INSTANCE = DatabaseConnectionPool(filename)
return cls.INSTANCE
def get_connection(self):
return self.__cnxPool.get_connection()
@classmethod
def pool_close(cls):
cls.INSTANCE = None
class DataSource:
def __init__(self,
host='127.0.0.1',
port='3306',
user='******',
password='',
database='jground',
_pool_name='remote_query',
_pool_size=10):
self.pool = MySQLConnectionPool(pool_size=_pool_size,
host=host,
port=port,
user=user,
password=password,
database=database,
pool_reset_session=True,
autocommit=True,
charset='utf8mb4')
def getConnection(self):
return self.pool.get_connection()
def returnConnection(self, con):
con.close()
class MySQLPooledConnection(MySQLConnectionABC):
""" MySQL Connection from connection-pool """
def __init__(self,
*args,
db_schema: DBSchema,
dictionary: bool = False,
named_tuple: bool = False,
pool_size: int = 16,
**kwargs):
print('MySQLPooledConnection: Init with pool_size=%d' % pool_size)
self.cnx_pool = MySQLConnectionPool(pool_size=pool_size,
*args,
**kwargs)
super().__init__(*args,
db_schema=db_schema,
dictionary=dictionary,
named_tuple=named_tuple,
**kwargs)
def new_cnx(self, *args, **kwargs):
return self.cnx_pool.get_connection()
def create_cursor(self, *args, **options) -> 'MySQLCursor':
self.close()
self.cnx = self.new_cnx()
return MySQLCursor(
self, self.cnx.cursor(*args, **self._cursor_options(**options)))
def __init__(self,
*args,
db_schema: DBSchema,
dictionary: bool = False,
named_tuple: bool = False,
pool_size: int = 16,
**kwargs):
print('MySQLPooledConnection: Init with pool_size=%d' % pool_size)
self.cnx_pool = MySQLConnectionPool(pool_size=pool_size,
*args,
**kwargs)
super().__init__(*args,
db_schema=db_schema,
dictionary=dictionary,
named_tuple=named_tuple,
**kwargs)
class MySQL(object):
def __init__(self):
self._cnxpool = MySQLConnectionPool(pool_name="mysqlPool",
pool_size=3,
**Config.dbconfig)
def _getConnection(self):
return self._cnxpool.get_connection()
def query(self, query, queryArgsTuple=None):
cnx = self._getConnection()
with closing(cnx.cursor()) as cursor:
cursor.execute(query, queryArgsTuple)
results = cursor.fetchall()
cnx.close()
return results
def modify(self, query, queryArgsTuple=None):
cnx = self._getConnection()
with closing(cnx.cursor()) as cursor:
cursor.execute(query, queryArgsTuple)
cnx.commit()
cnx.close()
def create_mysql(self, database=None):
global MYSQL, DATABASE, mysqlPool
config = self.configs[self.MYSQL]
hosts, port, user, password = self.get_params(config)
if not database:
database = config[self.DATABASE]
dbconfig = {
'database': database,
'user': user,
'password': password,
'host': hosts,
'port': port
}
self.mysqlPool = MySQLConnectionPool(pool_size=CNX_POOL_MAXSIZE,
pool_name='POOL',
**dbconfig)
def test():
from mysql.connector.pooling import MySQLConnectionPool
from config.db_config import mysql_config as db_conf
cnx_pool = MySQLConnectionPool(
pool_name='default_cnx_pool', **db_conf)
model = DbModel(cnx_pool)
def test():
from mysql.connector.pooling import MySQLConnectionPool
from config.db_config import mysql_config as db_conf
cnx_pool = MySQLConnectionPool(pool_name='default_cnx_pool', **db_conf)
model = ModelExchange(cnx_pool)
print(model.get_exchange_dict())
class Database:
dbconfig = {"database": "pythontest", "user": "******", "password": "******"}
conn = MySQLConnectionPool(pool_name="mypool", pool_size=2, **dbconfig)
def getConn(self):
return self.conn.get_connection()
def test():
from mysql.connector.pooling import MySQLConnectionPool
from config.db_config import mysql_config as db_conf
cnx_pool = MySQLConnectionPool(pool_name='default_cnx_pool', **db_conf)
model = ModelTrCoinone(cnx_pool)
#model.insert_tr(1, [{'price':355, 'qty':10, 'datetime':datetime.now() },{'price':355, 'qty':12, 'datetime':datetime.now() }] )
print(model.get_tr(1))
def dbconfigload(db_name, user_name, port, password, host_name, pool_name):
dbconfig = {}
dbconfig["database"] = db_name
dbconfig["user"] = user_name
dbconfig["port"] = port
dbconfig["password"] = password
dbconfig["host"] = host_name
return MySQLConnectionPool(pool_name=pool_name, pool_size=3, **dbconfig)
class Event(Flask):
def __init__(self, *args, **kwargs):
kwargs.update({
'template_folder': settings.STATIC_ASSETS_PATH,
'static_folder': settings.STATIC_ASSETS_PATH,
'static_url_path': '',
})
super(Event, self).__init__(__name__, *args, **kwargs)
self.connection_pool = None
self.enums = None
def create_connection_pool(self):
pool_config = {
"host": settings.EVENT_MYSQL_DATABASE_HOST,
"port": settings.EVENT_MYSQL_DATABASE_PORT,
"database": settings.EVENT_MYSQL_DATABASE_NAME,
"user": settings.EVENT_MYSQL_DATABASE_USER,
"password": settings.EVENT_MYSQL_DATABASE_PASSWORD,
"charset": settings.EVENT_MYSQL_DATABASE_CHARSET,
"use_unicode": True,
"get_warnings": True,
"ssl_verify_cert": False,
"pool_name": self.__class__.__name__,
"pool_reset_session":
settings.EVENT_MYSQL_DATABASE_POOL_RESET_SESSION,
"pool_size": settings.EVENT_MYSQL_DATABASE_POOL_SIZE,
"autocommit": True
}
if settings.EVENT_MYSQL_DATABASE_SSL_VERIFY_CERT:
pool_config["ssl_verify_cert"] = True
pool_config["ssl_ca"] = settings.EVENT_MYSQL_DATABASE_SSL_CA_PATH
self.connection_pool = MySQLConnectionPool(**pool_config)
def load_enums(self):
sql = 'SELECT * FROM c_enum'
cnx = self.connection_pool.get_connection()
enum_list = execute_sql_statement(sql, sql_cnx=cnx)
enum_map = defaultdict(list)
enum_obj_map = {}
for enum in enum_list:
enum_map[enum.get("enum_type_name")].append(enum)
value_tuple = namedtuple("VALUE", ["value", "name"])
for enum_name_code, enum_value_list in enum_map.items():
value_map = {
enum_value.get("enum_code"):
value_tuple(enum_value.get("enum_value"),
enum_value.get("enum_name"))
for enum_value in enum_value_list
}
temp_named_tuple = namedtuple(enum_name_code,
list(value_map.keys()))
enum_obj_map[enum_name_code.upper()] = temp_named_tuple(
**value_map)
enum_type_tuple = namedtuple("ENUM", enum_obj_map.keys())
self.enums = enum_type_tuple(**enum_obj_map)
cnx.close()
REGISTRATION_TYPE_LIST.extend(
self.enums.REGISTRATION_TYPE._asdict().keys())
def __init__(self,
host='127.0.0.1',
port='3306',
user='******',
password='',
database='jground',
_pool_name='remote_query',
_pool_size=10):
self.pool = MySQLConnectionPool(pool_size=_pool_size,
host=host,
port=port,
user=user,
password=password,
database=database,
pool_reset_session=True,
autocommit=True,
charset='utf8mb4')
def connectDbPool(self,POOLSIZE=1): try: if PRINTLEVEL>=INFO_PRINT: print "MySQLConnectionPool connectDbPool ..." cnxpool=MySQLConnectionPool(pool_name=self.config['host'],pool_size=POOLSIZE,**self.config) self.pool=cnxpool return 1 except Exception, e: print "! Failed connectDbPool !" if PRINTLEVEL>=ERROR_PRINT: print(e)
def init_connection_pool(user, password, database, host, port):
global CONNECTION_POOL
CONNECTION_POOL = MySQLConnectionPool(pool_name="opendcpool",
pool_size=5,
user=user,
password=password,
database=database,
host=host,
port=port)
def get_connection_pool():
MysqlDatabase.pool = MySQLConnectionPool(pool_name="connection_pool",
pool_size=32,
pool_reset_session=True,
host=HOST,
port=PORT,
database=DATABASE,
user=USER,
password=PASSWORD)
def connect_database(self, **kwargs) -> MySQLConnectionPool:
print("[DEBUG] set connection pool configuration configure: ", kwargs)
for key, value in kwargs.items():
# self.__MySQL_Stock_Data_Config[key] = value
self._Database_Config[key] = value
print("[DEBUG] database config: ", self._Database_Config)
connection_pool = MySQLConnectionPool(**self._Database_Config)
self._logger.debug(
f"MySQL_Connection_Pool at 'connection_strategy.init_connection_pool': {connection_pool}"
)
return connection_pool
class Database(object, metaclass=Singleton):
def __init__(self):
cfg = self.__get_cfg()
self.pool = MySQLConnectionPool(pool_name='dbpool',
pool_size=5,
**cfg)
def __get_cfg(self):
with open('database.yml') as f:
cfg = yaml.load(f.read())['production']
keys = ['username', 'password', 'host', 'port', 'database', 'ssl_ca',
'ssl_cert', 'ssl_key']
no_ = lambda s: s.replace('_', '')
cfg = { k: cfg.get(no_(k)) for k in keys if no_(k) in cfg }
cfg['ssl_verify_cert'] = True
# Mysql documentation incorrectly says 'username' is an alias of 'user'.
cfg['user'] = cfg.pop('username')
return cfg
@contextmanager
def get_connection(self):
def get_conn(attempt=0):
try:
return self.pool.get_connection()
except PoolError:
if 20 > attempt:
time.sleep(0.2)
return get_conn(attempt + 1)
else:
raise
connection = get_conn()
yield connection
# connection.close() will fail with an unread_result.
if connection._cnx.unread_result:
connection._cnx.get_rows()
connection.close()
def close_all(self):
self.pool.reset_session()
def __init__(self):
dbconfig = {
"database": "geoDev",
"user": "******",
"password": "******",
"host": "localhost",
#"raw": True,
"pool_name": "geo_pool",
"pool_size": 20,
"pool_reset_session": True
}
try:
self.__conn_pool = MySQLConnectionPool(**dbconfig)
#self.__conn_pool = mysql.connect(**dbconfig)
except Exception:
raise
class Db(object):
"""
Instantiate a db connection.
"""
def __init__(self):
dbconfig = {
"database": "geoDev",
"user": "******",
"password": "******",
"host": "localhost",
#"raw": True,
"pool_name": "geo_pool",
"pool_size": 20,
"pool_reset_session": True
}
try:
self.__conn_pool = MySQLConnectionPool(**dbconfig)
#self.__conn_pool = mysql.connect(**dbconfig)
except Exception:
raise
def __get_session(self):
"""
Returns the private session var.
"""
return self.__conn_pool.get_connection()
#return self.__conn_pool
def __cant_set(self):
"""Raises runtime error."""
raise RuntimeError("Private property cannot be set.")
def __cant_get(self):
"""Raises runtime error."""
raise RuntimeError("Cannot get protected property.")
db_conn = property(__cant_get, __cant_set)
session = property(__get_session, __cant_set)
def __init__(self, debug=False):
if debug:
logging.info('Initializing The Flash Server as debug mode')
else:
logging.info('Initializing The Flash Server as production mode')
self.debug = debug
self.app = Flask(__name__)
logging.info('Flask Initialized')
dbconfig = { "user" : settings.db_user_name,
"password" : settings.db_password,
"database" : settings.db_name,
"host" : settings.db_host
}
self.mysql_pool = MySQLConnectionPool(pool_name=None, pool_size=4, pool_reset_session=True, **dbconfig)
logging.info('Database Initialized')
self.redis_pool = redis.ConnectionPool(host=settings.redis_host, port=settings.redis_port, db=0)
logging.info('Redis Initialized')
self.application = tornado.web.Application([
(r"/auth", RequestAuth, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/get_users", RequestGetUsers, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/get_beacons", RequestGetBeacons, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/update_user_pos", RequestUpdateUserPosition, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/register_beacon", RequestRegisterBeacon, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/unregister_beacon", RequestUnregisterBeacon, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/", RequestPage, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool, page_name="index.html")),
(r"/manage", RequestPage, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool, page_name="manage.html")),
(r"/about", RequestPage, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool, page_name="about.html")),
],
debug=debug,
autoreload=debug,
static_path=settings.static_path
)
logging.info('Application Initialized')
self.init_cache()
def __init__(self):
cfg = self.__get_cfg()
self.pool = MySQLConnectionPool(pool_name='dbpool',
pool_size=5,
**cfg)
class TheFlashServer:
def __init__(self, debug=False):
if debug:
logging.info('Initializing The Flash Server as debug mode')
else:
logging.info('Initializing The Flash Server as production mode')
self.debug = debug
self.app = Flask(__name__)
logging.info('Flask Initialized')
dbconfig = { "user" : settings.db_user_name,
"password" : settings.db_password,
"database" : settings.db_name,
"host" : settings.db_host
}
self.mysql_pool = MySQLConnectionPool(pool_name=None, pool_size=4, pool_reset_session=True, **dbconfig)
logging.info('Database Initialized')
self.redis_pool = redis.ConnectionPool(host=settings.redis_host, port=settings.redis_port, db=0)
logging.info('Redis Initialized')
self.application = tornado.web.Application([
(r"/auth", RequestAuth, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/get_users", RequestGetUsers, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/get_beacons", RequestGetBeacons, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/update_user_pos", RequestUpdateUserPosition, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/register_beacon", RequestRegisterBeacon, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/unregister_beacon", RequestUnregisterBeacon, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool)),
(r"/", RequestPage, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool, page_name="index.html")),
(r"/manage", RequestPage, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool, page_name="manage.html")),
(r"/about", RequestPage, dict(mysql_pool=self.mysql_pool, redis_pool=self.redis_pool, page_name="about.html")),
],
debug=debug,
autoreload=debug,
static_path=settings.static_path
)
logging.info('Application Initialized')
self.init_cache()
def init_cache(self):
conn = None
cursor = None
try:
conn = self.mysql_pool.get_connection()
cursor = conn.cursor()
beacon_cache(conn, cursor, self.redis_pool)
user_cache(conn, cursor, self.redis_pool)
except Exception as e:
logging.error(str(e))
raise
finally:
if cursor is not None:
cursor.close()
if conn is not None:
conn.close()
def start(self):
logging.info('The Flash Server Start')
server = tornado.httpserver.HTTPServer(self.application)
if self.debug:
print '- Start as debug mode'
server.listen(settings.service_port)
else:
server.bind(settings.service_port)
server.start(0)
IOLoop.current().start()
def __init__(self, **kwargs):
self.pool = MySQLConnectionPool(**kwargs)
class MySQLStorage(object):
DoesNotExist = DoesNotExist
def __init__(self, **kwargs):
self.pool = MySQLConnectionPool(**kwargs)
def get_list_by_path(self, path):
con = None
cur = None
try:
con = self.pool.get_connection()
cur = con.cursor(cursor_class=MySQLCursorDict)
cur.execute('SELECT * FROM rules WHERE path=%s', (path,))
rows = cur.fetchall()
if not rows:
raise DoesNotExist(
'Rule with path={path} does not exist.'.format(path=path)
)
return [_rule_from_row(row) for row in rows]
finally:
if cur is not None:
cur.close()
if con is not None:
con.close()
def get_by_id(self, _id):
con = None
cur = None
try:
con = self.pool.get_connection()
cur = con.cursor(cursor_class=MySQLCursorDict)
cur.execute('SELECT * FROM rules WHERE id=%s', (_id,))
row = cur.fetchone()
if not row:
raise DoesNotExist(
'Rule with id={id} does not exist.'.format(id=_id)
)
return _rule_from_row(row)
finally:
if cur is not None:
cur.close()
if con is not None:
con.close()
def get_list(self):
con = None
cur = None
try:
con = self.pool.get_connection()
cur = con.cursor(cursor_class=MySQLCursorDict)
cur.execute('SELECT * FROM `rules`')
rows = cur.fetchall()
return [_rule_from_row(row) for row in rows]
finally:
if cur is not None:
cur.close()
if con is not None:
con.close()
def create(self, rule):
sql = 'INSERT INTO `rules` (`path`, `request`, `response`)' \
'VALUES (%s, %s, %s)'
con = None
cur = None
try:
con = self.pool.get_connection()
cur = con.cursor(cursor_class=MySQLCursorDict)
cur.execute(sql, _row_from_rule(rule))
rule['id'] = cur.lastrowid
con.commit()
return rule
except:
if con is not None:
con.rollback()
raise
finally:
if cur is not None:
cur.close()
if con is not None:
con.close()
def delete_by_id(self, _id):
con = None
cur = None
try:
con = self.pool.get_connection()
cur = con.cursor()
cur.execute('DELETE FROM rules WHERE id=%s', (_id,))
con.commit()
if cur.rowcount == 0:
raise DoesNotExist(
'Rule with id={id} does not exist.'.format(id=_id)
)
except:
if con is not None:
con.rollback()
raise
finally:
if cur is not None:
cur.close()
if con is not None:
con.close()
def clear(self):
con = None
cur = None
try:
con = self.pool.get_connection()
cur = con.cursor()
cur.execute('TRUNCATE TABLE `rules`')
con.commit()
except:
if con is not None:
con.rollback()
raise
finally:
if cur is not None:
cur.close()
if con is not None:
con.close()
