def delete_bridge(self, bot, update, user_data):
if update.message.text == 'yes':
if self.bridge_exists(update.message.chat.id):
dbc = DatabaseConnection()
bridge = self.bridges[update.message.chat_id]
dbc.delete_bridge(bridge)
bridge.irc_channel.irc_server.irc_connection_thread.disconnect_channel(
bridge.irc_channel.channel)
del self.bridges[update.message.chat_id]
update.message.reply_text('Done! The bridge is deleted.')
return ConversationHandler.END
elif self.secondary_bridge_exists(update.message.chat.id):
dbc = DatabaseConnection()
bridge = self.get_bridge_by_id(update.message.chat.id)
secondary_bridge = bridge.secondary_bridges[
update.message.chat.id]
bridge.remove_secondary_bridge(secondary_bridge)
dbc.delete_secondary_bridge(secondary_bridge, commit=True)
update.message.reply_text('Done! The bridge is deleted.')
return ConversationHandler.END
elif update.message.text == 'no':
update.message.reply_text('No? Ok...')
return ConversationHandler.END
else:
update.message.reply_text('Error. This code should be unreachable')
return ConversationHandler.END
def list_vnf_pkg_cps(vnf_pkg_id, internal=False):
"""Retrieve all connection points of a VNF Package stored in repository
If using an internal call directly to this function use the :param internal param as True.
In internal call it returns just an dict. However in external calls it returns an HTTP Response json dict.
:param vnf_pkg_id: VNF Package ID
:param internal=False used to distinguish internal (function) and external (HTTP) calls to the server
:return: a dict with all connection points
"""
database = DatabaseConnection()
_, data = database.list_catalog(vnf_pkg_id)
dir_id = data[0]['dir_id']
vnfd_path = 'repository/%s/vnfd.json' % dir_id
with open(vnfd_path) as vnfd_file:
vnfd_data = vnfd_file.read()
vnfd_data = json.loads(vnfd_data)
node_templates = vnfd_data['vnfd']['attributes']['vnfd']['topology_template']['node_templates']
cps = {}
for atr in node_templates.keys():
if 'tosca.nodes.nfv.CP' in node_templates[atr]['type']:
virtual_link = node_templates[atr]['requirements'][0]['virtualLink']['node']
network_name = node_templates[virtual_link]['properties']['network_name']
cps[atr] = {'virtual_link': virtual_link, 'network_name': network_name}
if not internal:
return jsonify(cps)
else:
return cps
def delete_package(pkg_id):
"""
Remove a VNF Package from the local catalog and its repository files
:param pkg_id: VNF Package identifier
:return: a JSON with status and error reason if it occurs
"""
database = DatabaseConnection()
_, data = database.list_vnf_instances(vnf_pkg_id=pkg_id)
if len(data) > 0:
return jsonify({'status': ERROR, 'reason': "A VNF Instance depends on this VNF Package!"})
resp, catalog = database.list_catalog(pkg_id)
pkg_dir_id = catalog[0]['dir_id']
if resp == OK:
result = database.remove_vnf_package(pkg_id)
if result == OK:
try:
rmtree('repository/' + pkg_dir_id)
except OSError as e:
logger.error("%s '%s'", e.strerror, e.filename)
return jsonify({'status': ERROR, 'reason': e.strerror})
return jsonify({'status': OK})
return jsonify({'status': ERROR, 'reason': status[404]})
def start(self, telegramBot, update):
if not update.message.chat.type == 'group':
telegramBot.sendMessage(chat_id=update.message.chat_id,
text='You can only use me in a group!')
return ConversationHandler.END
if update.message.chat.get_member(
update.message.from_user.id).status != ChatMember.CREATOR:
telegramBot.sendMessage(
chat_id=update.message.chat_id,
text="Only the creator is allowed to configure me!")
return ConversationHandler.END
if self.bridge_exists(
update.message.chat.id) or self.secondary_bridge_exists(
update.message.chat.id):
telegramBot.sendMessage(
chat_id=update.message.chat_id,
text="This Group is already part of a bridge. Abort!")
return ConversationHandler.END
servers = DatabaseConnection().get_all_irc_server_descriptions()
update.message.reply_text(
'Hi! I\'m BridgeBot. If you can, you should host your own BridgeBot. This way you can '
+
'change the config for e.g. preventing files from being deleted. You can get the code on github: https://github.com/PostalBlab/VectronBot. '
+
'If you want to use this Bot, i need some informations. You can cancel this dialogue with /cancel '
+
'Here is a list of all public supported irc servers. Please tell me which one you want to use. '
'If your prefered server is not in the list you can contact the maintainer @PostalDude. He can also add hidden servers where only you know '
'the needed description:\n' + '\n'.join('- {}'.format(k)
for k in servers))
return self.CHOOSING_SERVER
def irc_token_received(self, from_user, token):
if self.validated:
# if the primary bridge is validated we check all the secondary bridges
for key, secondary_bridge in self.secondary_bridges.items():
if not secondary_bridge.validated and secondary_bridge.token == token:
secondary_bridge.validated = True
dbc = DatabaseConnection()
dbc.set_secondary_bridge_validation(secondary_bridge)
self.send_to_irc('system',
'Secondary bridge is now validated!')
return
self.send_to_irc('system', 'Why? The Bridge is already validated')
return
if self.irc_channel.is_user_op(from_user) and self.token == token:
self.set_validation()
self.send_to_irc(
'system', 'Successfully registered the new bridge. Have fun!')
self.send_to_tg(
'system', 'Successfully registered the new bridge. Have fun!')
else:
self.send_to_irc(
'system',
'The token is invalid and/or the sender is no operator.')
def choosing_channel(self, bot, update, user_data):
if not update.message.text.startswith('#'):
update.message.reply_text(
'IRC channels have to begin with a #. Try again.')
return self.CHOOSING_CHANNEL
user_data['channel'] = update.message.text
if self.bridge_exists(update.message.chat.id):
telegramBot.sendMessage(
chat_id=update.message.chat_id,
text="This Group is already part of a bridge. Abort!")
return ConversationHandler.END
# test if the channel is already part of a bridge, if so offer a secondary bridge
# which is only one way, tg->irc
# this way you can post media without disturbing the whole primary group
dbc = DatabaseConnection()
if dbc.irc_channel_alredy_bridged(user_data['channel'],
user_data['irc_server_description']):
update.message.reply_text(
'This channel is already party of a bridge. Would you like to create a secondary bridge?'
' This way you can post stuff in the IRC without disturbing the primary TG Group.',
reply_markup=self.yes_no_keyboard())
return self.CREATE_SECONDARY_BRIDGE
update.message.reply_text(
'Thanks. Should i try to join %s on %s?' %
(user_data['channel'], user_data['irc_server_description']),
reply_markup=self.yes_no_keyboard())
return self.CONNECT_CHANNEL
def __init__(self, conffile=None):
self._db = DatabaseConnection(conffile)
# self check
ver = self._db.query('SELECT VERSION()')[0][0]
satt_log('Connected to database: MySQL version {0}'.format(ver))
self._rating_methods = RatingMethod(self._db.query)
def liveGames():
'''Display info about a single round itdentified by it's timestamp'''
db = DatabaseConnection(app.config["DB_PATH"])
rounds = db.getLiveGames()
return flask.render_template("livegames.html",
liveGameRounds=rounds,
noRounds=not bool(rounds))
def instantiate_vnf(vnf_pkg_id):
""" Instantiates a given VNF in NFVO
:param vnf_pkg_id:
:return: flask.Response: OK, vnfd_id, vnf_id and vnf_ip if success, or ERROR and its reason if not
"""
database = DatabaseConnection()
resp, catalog = database.list_catalog(vnf_pkg_id=vnf_pkg_id)
if resp != OK:
jsonify({'status': ERROR, 'reason': 'VNF Package not found!'})
dir_id = catalog[0]['dir_id']
vnfd_name = catalog[0]['vnfd_name']
vnf_type = catalog[0]['vnf_type']
vnfd_path = 'repository/%s/vnfd.json' % dir_id
with open(vnfd_path) as vnfd_file:
vnfd_data = vnfd_file.read()
vnfd_data = json.loads(vnfd_data)
vnfd_data['vnfd']['name'] = vnfd_name
if vnf_type == CLICK_VNF:
function_path = 'repository/%s/vnf.click' % dir_id
with open(function_path) as function_file:
function_data = function_file.read()
response = tacker_agent.vnf_create(vnfd_data, unique_id(), function_data)
else:
response = tacker_agent.vnf_create(vnfd_data, unique_id())
if response['status'] != OK:
return jsonify(response)
db_res, data = database.insert_vnf_instance(vnf_pkg_id, response['vnfd_id'], response['vnf_id'])
# Rollback actions if database inserting fails
if db_res != OK:
error_message = 'Database error: %s' % data
logger.error("Executing rollback actions...\n%s", error_message)
resp_delete = tacker_agent.vnf_delete(response['vnf_id'])
if resp_delete == OK:
logger.info("Rollback done!")
else:
error_message.join([' ', resp_delete['reason']])
logger.error(error_message)
return jsonify({'status': ERROR, 'reason': error_message})
# return instantiated vnf data
return jsonify(response)
def __init__(self):
# Create the QApplication first so that QThread, QTimer, etc. can be used
self.qt_app = QApplication()
self.qt_app.aboutToQuit.connect(self.quit)
self.database_connection = DatabaseConnection(self)
self.user_interface = UserInterface(self)
self.qt_app.exec_()
def destroy_vnffg(vnffg_id):
"""Destroy the VNFFG and its VNFs
This function destroys the VNFFG and its VNFFGDs, and also all the VNFs and its VNFDs
that are specified in the VNFFG
:param vnffg_id: the NFVO unique identifier of the VNFFG
:return: OK if succeed, or ERROR and its reason if not
"""
database = DatabaseConnection()
state, data = tacker_agent.vnffg_show(vnffg_id)
if state != OK:
return jsonify({'status': state, 'reason': data})
vnffgd_id = data['vnffgd_id']
vnf_mapping = data['vnf_mapping']
vnffg_vnfs = []
for vnf_id in vnf_mapping.values():
vnffg_vnfs.append(vnf_id)
# destroying VNFFG
resp, data = tacker_agent.vnffg_delete(vnffg_id)
if state != OK:
return jsonify({'status': resp, 'reason': data})
# remove SFC_Instance from database
resp, sfc_instance = database.list_sfc_instances(vnffg_id=vnffg_id)
if resp == OK:
if len(sfc_instance) > 0:
_id = sfc_instance[0]['_id']
database.remove_sfc_instance(_id)
# TODO: How many time we should wait before remove the VNFFGD?
time.sleep(2)
# destroying VNFFGD
resp, data = tacker_agent.vnffgd_delete(vnffgd_id)
if state != OK:
return jsonify({'status': resp, 'reason': data})
# destroying VNFs
message = ''
for vnf_id in vnffg_vnfs:
vnf_data = destroy_vnf(vnf_id) # returns a flask.Response object
vnf_data = json.loads(vnf_data.response[0]) # parsing from string do json
if vnf_data['status'] != OK:
message = ' '.join([message, '\nVNF id %s: ' % vnf_id, vnf_data['reason']])
if message:
return jsonify({'status': ERROR, 'reason': message})
return jsonify({'status': OK})
def create_bridge(self, tg_group_id, irc_server_description, channel, token, validated=False, save_to_db=False,
only_add_channel=False):
irc_connection = self.irc_connections.get_or_create_irc_server_by_description(irc_server_description)
irc_channel = irc_connection.join_channel(channel, only_add=only_add_channel)
bridge = Bridge(irc_channel, tg_group_id, validated, self, token)
self.bridges[tg_group_id] = bridge
if save_to_db:
dbc = DatabaseConnection()
dbc.add_bridge(bridge)
return True
def __init__(self, irc_channel, tg_group_id, validated, tg_bot, token):
self.irc_channel = irc_channel
self.irc_channel.bridge = self
self.tg_group_id = tg_group_id
self.validated = validated
self.tg_bot = tg_bot
self.token = token
self.secondary_bridges = {}
dbc = DatabaseConnection()
dbc.get_all_secondary_bridges(self)
def create_app(config_name):
"""FlaskAPI provides an implementation of browsable APIs"""
app = FlaskAPI(__name__)
APP_ROOT = os.path.dirname(app.instance_path)
app.config.from_object(application_config[config_name])
app.config.from_pyfile(APP_ROOT + '/config.py')
database_connection = DatabaseConnection()
database_connection.create_tables()
return app
def choosing_server(self, bot, update, user_data):
user_data['tg_group_id'] = update.message.chat.id
servers = DatabaseConnection().get_all_irc_server_descriptions(False)
logger.debug(servers)
if update.message.text in servers:
user_data['irc_server_description'] = update.message.text
update.message.reply_text(
'%s it is! To which channel should i connect? e.g. #telegram' % update.message.text)
return self.CHOOSING_CHANNEL
else:
update.message.reply_text('Invalid Server. Try again!')
return self.CHOOSING_SERVER
def add_weather_prediction_to_database():
weather = WeatherMaker(get_html(URL, HEADERS))
weathers = weather.get_content()
database = DatabaseConnection(DBNAME,
USER,
HOST1,
PORT,
PASSWORD,
new_data=weathers)
if database.check_if_table_exists() is False:
database.create_table()
database.insert_new_data()
def get_or_create_irc_server_by_description(self, description):
if description in self.connections:
return self.connections[description]
dbc = DatabaseConnection()
irc_server = dbc.get_irc_server_by_descripton(description)
irc_connection = IRCConnections.IRCConnection(irc_server, self._vectronconfig)
self.connections[irc_server.description] = irc_connection
irc_connection.start()
logging.debug('New IRC Connection to %s', irc_server.description)
return irc_connection
def include_package():
"""
Includes a VNF Package in the local catalog and in the file repository
:return: an 'OK' JSON status
"""
# TODO: consider also upload the VNF Image to the Openstack Tacker
database = DatabaseConnection()
vnfd = request.json['vnfd']
# vnf = request.json['vnf']
descriptor = json.loads(request.json['descriptor'])
category = descriptor['category']
vnf_type = descriptor['type']
vnf_description = descriptor['description']
vnfd_status, data = vnfd_json_yaml_parser(vnfd)
if vnfd_status == OK:
vnfd = data
else:
return jsonify({'status': vnfd_status, 'reason': data})
vnfd_name = vnfd['vnfd']['name']
if vnf_type not in [CLICK_VNF, GENERAL_VNF]:
return jsonify({'status': ERROR, 'reason': 'VNF Package unknown type: %s' % vnf_type})
dir_id = unique_id()
dir_name = 'repository/' + dir_id
os.makedirs(dir_name)
vnfd = json.dumps(vnfd, indent=2, sort_keys=True)
vnfd_file = open(dir_name + '/vnfd.json', 'w')
vnfd_file.write(vnfd)
vnfd_file.close()
if vnf_type == CLICK_VNF:
vnf = request.json['vnf']
vnf_file = open(dir_name + '/vnf.click', 'w')
vnf_file.write(vnf)
vnf_file.close()
# TODO: needs to add a function name
result = database.insert_vnf_package(category, vnfd_name, dir_id, vnf_type, vnf_description)
if result == OK:
return jsonify({'status': OK})
else:
return jsonify({'status': result[0], 'reason': result[1]})
def on_connection_close(self):
self._isClosed = True
DatabaseConnection()[BoardMessage.table_name].remove({
"id":
self.session.session_id,
'timestamp': {
'$lte': self.lastestTimestamp
}
})
id = self.session.session_id
for content in self.messagesBuffer:
BoardMessage.new(id, int(content['timestamp']), content)
self.channel.close()
def start_tg_bot():
parser = argparse.ArgumentParser(description='TG / IRC bridge bot')
parser.add_argument('--config',
metavar='path',
type=str,
required=True,
help='path to config file')
parser.add_argument('--debug',
dest='debug',
action='store_true',
required=False,
default=False,
help='Activate debugging output')
cliargs = parser.parse_args()
if cliargs.debug:
logger.setLevel(logging.DEBUG)
logger.info('Loglevel set to DEBUG')
vectronconfig = load_from_file(cliargs.config)
tg_bot = TGBot(vectronconfig)
dbc = DatabaseConnection()
dbc.create_tables()
# irc_server = IRCServer('Freenode', 'chat.freenode.net')
# dbc.add_irc_server(irc_server)
# irc_server = IRCServer('Quakenet', 'irc.quakenet.org', port=6667, ssl=False)
# dbc.add_irc_server(irc_server)
# irc_server = IRCServer('IRCNet', 'open.ircnet.org', port=6666)
# dbc.add_irc_server(irc_server)
# irc_server = IRCServer('Undernet', 'eu.undernet.org', port=6667)
# dbc.add_irc_server(irc_server)
bridges = dbc.get_all_bridges()
for bridge in bridges:
tg_bot.create_bridge(bridge['tg_id'],
bridge['irc_server_description'],
bridge['irc_channel'],
bridge['token'],
bridge['validated'],
only_add_channel=True)
# delete old files if the data retention is > 0
if vectronconfig['webserver_data_retention'] > 0:
cron_delete = CronDelete(vectronconfig)
cron_delete.start()
tg_bot.start_webhook()
def main():
# coin_name_array = util.read_subs_from_file(general["subreddit_file"])
# coin_name_array = util.read_subs_from_file(general["binance_file"])
coin_name_array = util.read_subs_from_file(general["poloniex_file"])
auth = util.get_postgres_auth()
db = DatabaseConnection(**auth)
# all_subreddits = db.get_all_subreddits()
all_subreddits = [coin[-1] for coin in coin_name_array]
start_time = datetime.datetime.utcnow() - datetime.timedelta(hours=12)
# end_time = datetime.datetime.utcnow() - datetime.timedelta(hours=24)
end_time = datetime.datetime.utcnow()
# growths = percentage_price_growths(db, all_subreddits, start_time, end_time)
growths = average_growth(db, all_subreddits, start_time, end_time)
print(growths)
# covariance(db, all_subreddits)
db.close()
def rounds():
'''Show rounds played on the server'''
start = flask.request.args.get("start")
end = flask.request.args.get("end")
if not start or not end:
start = datetime.datetime.now() - datetime.timedelta(days=7)
end = datetime.datetime.now()
else:
start = datetime.datetime.fromtimestamp(start)
end = datetime.datetime.fromtimestamp(end)
db = DatabaseConnection(app.config["DB_PATH"])
rounds = db.roundsBetweenDates(start, end)
return flask.render_template("rounds.html", rounds=rounds)
def main():
parser = argparse.ArgumentParser(description="Simple Query")
parser.add_argument('hours', metavar='h', type=float)
args = parser.parse_args()
auth = util.get_postgres_auth()
db = DatabaseConnection(**auth)
cur_utc = datetime.datetime.utcnow()
subreddits = db.get_subreddits_with_data(cur_utc - datetime.timedelta(
hours=args.hours))
growths = get_growths(db, subreddits, datetime.datetime.utcnow(),
args.hours)
for g in growths:
print(g)
db.close()
def __init__(self):
BenchmarkReport.__init__(self)
# use this to print out what is happening
self._stdout = StdoutReporter()
self.run_id = int(time())
self.tool_params = '{0}'.format(configs.configs['params'])
# replace apostrophes in tool_params
self.tool_params = self.tool_params.replace('\'', '\\\'')
from database import DatabaseConnection
self._db = DatabaseConnection()
ver = self._db.query('SELECT VERSION()')[0][0]
satt_log('Connected to database: MySQL version {0}'.format(ver))
self._rating_methods = RatingMethod(self._db.query)
def get_vnf_package(vnf_id):
"""Retrieves a VNF Package stored in Catalog from a given NFVO VNF ID
:param vnf_id:
:return:
"""
database = DatabaseConnection()
res, data = database.list_vnf_instances(vnf_id=vnf_id)
if res == OK:
if data:
return jsonify({'status': OK, 'package': data[0]})
else:
return jsonify({'status': ERROR, 'reason': 'VNF Package not found in Catalog!'})
# if happens a database error
return jsonify({'status': ERROR, 'reason': data})
def maps():
'''Show an overview of maps'''
db = DatabaseConnection(app.config["DB_PATH"])
start = datetime.datetime.now() - datetime.timedelta(days=4000)
end = datetime.datetime.now()
rounds = db.roundsBetweenDates(start, end)
distinctMaps = db.distinctMaps()
maps = []
for mapName in [tupel[0] for tupel in distinctMaps]:
roundsWithMap = list(filter(lambda r: r.mapName == mapName, rounds))
maps += [MapSummary.MapSummary(roundsWithMap)]
allMaps = MapSummary.MapSummary(rounds)
allMaps.mapName = "All Maps*"
maps += [allMaps]
mapsFiltered = filter(lambda x: x.mapName, maps)
return flask.render_template("maps.html", maps=mapsFiltered)
def insertToDatabase(self, tip_testa):
datum = str(datetime.datetime.now().strftime("%d.%m.%Y %H:%M:%S"))
st_plosce = "ni se"
koda = time.time()
database = DatabaseConnection()
database.insertGlobalRun(st_plosce, datum, tip_testa, str(koda))
for i in range(0, len(self.testResults)):
ime_testa = self.testResults[i]["path"]
elapsed = self.testResults[i]["end_time"] - self.testResults[i][
"start_time"]
cas_izvajanja = '({}s)'.format(round(elapsed, 2))
status = self.testResults[i]["status"]
if status != "OK":
opis_napake = self.testResults[i]["error"]
else:
opis_napake = "/"
database.insertIntoDatabase(ime_testa, cas_izvajanja, status,
opis_napake, str(koda))
def main():
global database
# Read area type definition from JSON file
area_type_groups = read_area_types()
# Connect to database
print(
f"Connecting to database \"{DATABASE_NAME}\" at \"{DATABASE_HOST}\" as user \"{DATABASE_USER}\"..."
)
database = DatabaseConnection(host=DATABASE_HOST,
database=DATABASE_NAME,
user=DATABASE_USER,
password=DATABASE_PASSWORD)
print("Successfully connected")
start_time = time.perf_counter()
# Iterate over all area type groups
for area_type_group in area_type_groups:
# Get group name
group_name = str(area_type_group[JSON_KEY_GROUP_NAME])
# Get area types that belong to this group
group_area_types = area_type_group[JSON_KEY_GROUP_TYPES]
print(f"Next group: \"{group_name}\"")
# Iterate over all area types of this group and invoke extraction
for area_type in group_area_types:
extract_area_type(area_type)
print(f"Finished group \"{group_name}\"")
elapsed_time = time.perf_counter() - start_time
print(
f"Simplification finished. Everything done. Took {elapsed_time:0.4} seconds"
)
database.disconnect()
def destroy_vnf(vnf_id):
"""Destroys a given VNF in NFVO
:param vnf_id: the NFVO VNF's ID
:return: OK if success, or ERROR and its reason if not
"""
database = DatabaseConnection()
response = tacker_agent.vnf_delete(vnf_id)
if response['status'] != OK:
return jsonify(response)
res, vnf_instance = database.list_vnf_instances(vnf_id=vnf_id)
if res != OK:
return jsonify(response)
if len(vnf_instance) > 0:
database.remove_vnf_instance(vnf_instance[0]['_id'])
return jsonify({'status': OK})
def secondary_bridge(self, bot, update, user_data):
if update.message.text == 'yes':
user_data['token'] = ''.join(
random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(6))
dbc = DatabaseConnection()
primary_tg_id = dbc.get_primary_group_id_by_irc_data(user_data['channel'],
user_data['irc_server_description'])
secondary_bridge = Bridge.SecondaryBridge(user_data['tg_group_id'], False, user_data['token'],
self.bridges[primary_tg_id])
dbc.add_secondary_bridge(secondary_bridge)
update.message.reply_text(
'To validate this secondary bridge, someone with +o has to paste this code into the channel: !token %s' %
user_data['token'])
return ConversationHandler.END
elif update.message.text == 'no':
update.message.reply_text('No? Ok... Abort!')
return ConversationHandler.END
else:
update.message.reply_text('Can\'t understand you.')
return self.CREATE_SECONDARY_BRIDGE
return ConversationHandler.END