def get_software(self):
"""
performs OCP 4.3 software bits download from the base urls
specified in the class __init__
"""
logging.info('downloading OCP 4.3 software bits into {}'.format(self.software_dir))
for url_key in self.ocp_urls.keys():
url = self.ocp_urls[url_key]
dest_name = url.split('/')[-1]
dest_path = self.software_dir + '/' + dest_name
dest_path_exist = check_path(dest_path, isfile=True)
url_check = ''
if dest_path_exist:
logging.info('file {} already exists in {}'.format(dest_name, self.software_dir))
self.inventory_dict['csah']['vars'][url_key] = dest_name
else:
url_check = validate_url(url)
if url_check == '':
logging.error('file {} in {} is not available'.format(dest_name, url_key))
self.inventory_dict['csah']['vars'][url_key] = ''
if url_check != '' and url_check.code == 200:
logging.info('downloading {}'.format(dest_name))
urlretrieve('{}'.format(url),'{}/{}'.format(self.software_dir, dest_name))
self.inventory_dict['csah']['vars'][url_key] = dest_name
def shorten_url():
#Access only if authenticated
if user_logged_in():
if request.method=='POST':
url = request.form['url']
if validate_url(url) is None:
return redirect(url_for('dashboard',url_not_valid=True))
requests.post('http://www.nanourl.xyz/api/link',json={'url':url},headers={'Authorization':get_user_api_token()})
update_cache_on_insert_or_delete_or_use(session['user'])
return redirect('/')
#On getting a GET request
return redirect('/')
return redirect('/login')
def get_software(self):
"""
performs OCP software bits download from the base urls
specified in the class __init__
"""
logging.info('downloading OCP {} software bits into {}'.format(self.software_dir, self.version))
urlretrieve('{}/sha256sum.txt'.format(self.ocp_client_base_url),'{}/client.txt'.format(self.software_dir))
urlretrieve('{}/sha256sum.txt'.format(self.ocp_rhcos_base_url),'{}/rhcos.txt'.format(self.software_dir))
shasum = False
for url_key in self.ocp_urls.keys():
url = self.ocp_urls[url_key]
dest_name = url.split('/')[-1]
dest_path = self.software_dir + '/' + dest_name
dest_path_exist = check_path(dest_path, isfile=True)
url_check = ''
if dest_path_exist:
logging.info('file {} already exists in {}'.format(dest_name, self.software_dir))
shasum = validate_file(self.software_dir, dest_name, self.ocp_rhcos_base_url)
self.inventory_dict['all']['vars'][url_key] = dest_name
else:
url_check = validate_url(url)
if url_check == '':
logging.error('file {} in {} is not available'.format(dest_name, url_key))
self.inventory_dict['all']['vars'][url_key] = ''
if not shasum:
url_check = validate_url(url)
if url_check == '':
logging.error('file {} in {} is not available'.format(dest_name, url_key))
self.inventory_dict['all']['vars'][url_key] = ''
if url_check != '' and url_check.code == 200 and not shasum:
logging.info('downloading {}'.format(dest_name))
urlretrieve('{}'.format(url),'{}/{}'.format(self.software_dir, dest_name))
self.inventory_dict['all']['vars'][url_key] = dest_name
def post(self):
if self.multipart_streamer:
try:
self.multipart_streamer.data_complete()
form_data = self.multipart_streamer.get_values([
'description', 'email', 'allowForAnalysis', 'obfuscated',
'source', 'type', 'feedback', 'windSpeed', 'rating',
'videoUrl', 'public', 'vehicleName'
])
description = cgi.escape(
form_data['description'].decode("utf-8"))
email = form_data['email'].decode("utf-8")
upload_type = 'personal'
if 'type' in form_data:
upload_type = form_data['type'].decode("utf-8")
source = 'webui'
title = '' # may be used in future...
if 'source' in form_data:
source = form_data['source'].decode("utf-8")
obfuscated = 0
if 'obfuscated' in form_data:
if form_data['obfuscated'].decode("utf-8") == 'true':
obfuscated = 1
allow_for_analysis = 0
if 'allowForAnalysis' in form_data:
if form_data['allowForAnalysis'].decode("utf-8") == 'true':
allow_for_analysis = 1
feedback = ''
if 'feedback' in form_data:
feedback = cgi.escape(
form_data['feedback'].decode("utf-8"))
wind_speed = -1
rating = ''
stored_email = ''
video_url = ''
is_public = 0
vehicle_name = ''
if upload_type == 'flightreport':
try:
wind_speed = int(
cgi.escape(form_data['windSpeed'].decode("utf-8")))
except ValueError:
wind_speed = -1
rating = cgi.escape(form_data['rating'].decode("utf-8"))
if rating == 'notset': rating = ''
stored_email = email
# get video url & check if valid
video_url = cgi.escape(
form_data['videoUrl'].decode("utf-8"), quote=True)
if not validate_url(video_url):
video_url = ''
if 'vehicleName' in form_data:
vehicle_name = cgi.escape(
form_data['vehicleName'].decode("utf-8"))
# always allow for statistical analysis
allow_for_analysis = 1
if 'public' in form_data:
if form_data['public'].decode("utf-8") == 'true':
is_public = 1
file_obj = self.multipart_streamer.get_parts_by_name(
'filearg')[0]
upload_file_name = file_obj.get_filename()
while True:
log_id = str(uuid.uuid4())
new_file_name = get_log_filename(log_id)
if not os.path.exists(new_file_name):
break
# read file header & check if really an ULog file
header_len = len(ULog.HEADER_BYTES)
if (file_obj.get_payload_partial(header_len) !=
ULog.HEADER_BYTES):
if upload_file_name[-7:].lower() == '.px4log':
raise CustomHTTPError(
400,
'Invalid File. This seems to be a px4log file. '
'Upload it to <a href="http://logs.uaventure.com" '
'target="_blank">logs.uaventure.com</a>.')
raise CustomHTTPError(400, 'Invalid File')
print('Moving uploaded file to', new_file_name)
file_obj.move(new_file_name)
if obfuscated == 1:
# TODO: randomize gps data, ...
pass
# generate a token: secure random string (url-safe)
token = str(binascii.hexlify(os.urandom(16)), 'ascii')
# Load the ulog file but only if not uploaded via CI.
# Then we open the DB connection.
ulog = None
if source != 'CI':
ulog_file_name = get_log_filename(log_id)
ulog = load_ulog_file(ulog_file_name)
# put additional data into a DB
con = sqlite3.connect(get_db_filename())
cur = con.cursor()
cur.execute(
'insert into Logs (Id, Title, Description, '
'OriginalFilename, Date, AllowForAnalysis, Obfuscated, '
'Source, Email, WindSpeed, Rating, Feedback, Type, '
'videoUrl, Public, Token) values '
'(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [
log_id, title, description, upload_file_name,
datetime.datetime.now(), allow_for_analysis,
obfuscated, source, stored_email, wind_speed, rating,
feedback, upload_type, video_url, is_public, token
])
if ulog is not None:
update_vehicle_db_entry(cur, ulog, log_id, vehicle_name)
con.commit()
url = '/plot_app?log=' + log_id
full_plot_url = 'http://' + get_domain_name() + url
delete_url = 'http://'+get_domain_name()+ \
'/edit_entry?action=delete&log='+log_id+'&token='+token
if upload_type == 'flightreport' and is_public:
send_flightreport_email(
email_notifications_config['public_flightreport'],
full_plot_url, description, feedback,
DBData.rating_str_static(rating),
DBData.wind_speed_str_static(wind_speed), delete_url,
stored_email)
# also generate the additional DB entry
# (we may have the log already loaded in 'ulog', however the
# lru cache will make it very quick to load it again)
generate_db_data_from_log_file(log_id, con)
con.commit()
cur.close()
con.close()
# TODO: now that we have loaded the ulog already, add more
# information to the notification email (airframe, ...)
# send notification emails
send_notification_email(email, full_plot_url, description,
delete_url)
# do not redirect for QGC
if source != 'QGroundControl':
self.redirect(url)
except CustomHTTPError:
raise
except:
print('Error when handling POST data',
sys.exc_info()[0],
sys.exc_info()[1])
raise CustomHTTPError(500)
finally:
self.multipart_streamer.release_parts()
def create_or_render_link():
token = request.headers['Authorization']
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
if db_user.find({'_id': ObjectId(payload['identity'])}).count() == 0:
return jsonify({'message': 'No such registered user'}), 401
except:
return jsonify({'message': 'Please Pass in a valid token'}), 401
if request.method == 'POST':
#Checking if the data in the body is json
if not request.is_json:
return jsonify(
{'message': 'Please pass-in the data in the JSON format'}), 400
content = request.get_json()
#checking if 'url' is key is present in the json data
if 'url' not in content or content['url'] is None:
return jsonify(
{'message': '"url" parameter not found in the json data'}), 400
if validate_url(content['url']) is None:
return jsonify({'message':
'Please pass-in a proper valid URL'}), 400
short_code = generate_short_code()
insert_by_key_value('link',
url=content['url'],
short_code=short_code,
count=0,
user=payload['identity'])
update_cache_on_insert_or_delete_or_use(payload['identity'])
return jsonify({
'message': 'Resource successfully created',
'data': {
'url': content['url'],
'short_url': 'http://www.nanourl.xyz/' + short_code
}
}), 201
elif request.method == 'GET':
# Checking if short_code parameter has been passed or not
if 'short_code' not in request.args or request.args['short_code'] == '':
return jsonify({
'message':
'short_code parameter either is not passed or is Null'
}), 400
# Checking if entry already exists
data = db_links.find_one({
'user':
payload['identity'],
'short_code':
request.args['short_code'].upper()
})
if data is None:
return jsonify(
{'message': 'No such shorted URL exists for this user'}), 404
return jsonify({
'url':
data['url'],
'short_url':
'http://www.nanourl.xyz/' + data['short_code'],
'usage_count':
data['count']
})
elif request.method == 'DELETE':
# Checking if short_code parameter has been passed or not
if 'short_code' not in request.args or request.args['short_code'] == '':
return jsonify({
'message':
'short_code parameter either is not passed or is Null'
}), 400
if db_links.find({
'user': payload['identity'],
'short_code': request.args['short_code'].upper()
}).count() > 0:
db_links.delete_one(
{'short_code': request.args['short_code'].upper()})
update_cache_on_insert_or_delete_or_use(payload['identity'])
return jsonify({'message': 'Entry Successfully deleted'})
return jsonify(
{'message': 'No such shorted link for this user in the database'})
def post(self, *args, **kwargs):
""" POST request callback """
if self.multipart_streamer:
try:
self.multipart_streamer.data_complete()
form_data = self.multipart_streamer.get_values(
['description', 'email',
'allowForAnalysis', 'obfuscated', 'source', 'type',
'feedback', 'windSpeed', 'rating', 'videoUrl', 'public',
'vehicleName'])
description = escape(form_data['description'].decode("utf-8"))
email = form_data['email'].decode("utf-8")
upload_type = 'personal'
if 'type' in form_data:
upload_type = form_data['type'].decode("utf-8")
source = 'webui'
title = '' # may be used in future...
if 'source' in form_data:
source = form_data['source'].decode("utf-8")
obfuscated = 0
if 'obfuscated' in form_data:
if form_data['obfuscated'].decode("utf-8") == 'true':
obfuscated = 1
allow_for_analysis = 0
if 'allowForAnalysis' in form_data:
if form_data['allowForAnalysis'].decode("utf-8") == 'true':
allow_for_analysis = 1
feedback = ''
if 'feedback' in form_data:
feedback = escape(form_data['feedback'].decode("utf-8"))
wind_speed = -1
rating = ''
stored_email = ''
video_url = ''
is_public = 0
vehicle_name = ''
error_labels = ''
if upload_type == 'flightreport':
try:
wind_speed = int(escape(form_data['windSpeed'].decode("utf-8")))
except ValueError:
wind_speed = -1
rating = escape(form_data['rating'].decode("utf-8"))
if rating == 'notset': rating = ''
stored_email = email
# get video url & check if valid
video_url = escape(form_data['videoUrl'].decode("utf-8"), quote=True)
if not validate_url(video_url):
video_url = ''
if 'vehicleName' in form_data:
vehicle_name = escape(form_data['vehicleName'].decode("utf-8"))
# always allow for statistical analysis
allow_for_analysis = 1
if 'public' in form_data:
if form_data['public'].decode("utf-8") == 'true':
is_public = 1
file_obj = self.multipart_streamer.get_parts_by_name('filearg')[0]
upload_file_name = file_obj.get_filename()
while True:
log_id = str(uuid.uuid4())
new_file_name = get_log_filename(log_id)
if not os.path.exists(new_file_name):
break
# read file header & check if really an ULog file
header_len = len(ULog.HEADER_BYTES)
if (file_obj.get_payload_partial(header_len) !=
ULog.HEADER_BYTES):
if upload_file_name[-7:].lower() == '.px4log':
raise CustomHTTPError(
400,
'Invalid File. This seems to be a px4log file. '
'Upload it to <a href="http://logs.uaventure.com" '
'target="_blank">logs.uaventure.com</a>.')
raise CustomHTTPError(400, 'Invalid File')
print('Moving uploaded file to', new_file_name)
file_obj.move(new_file_name)
if obfuscated == 1:
# TODO: randomize gps data, ...
pass
# generate a token: secure random string (url-safe)
token = str(binascii.hexlify(os.urandom(16)), 'ascii')
# Load the ulog file but only if not uploaded via CI.
# Then we open the DB connection.
ulog = None
if source != 'CI':
ulog_file_name = get_log_filename(log_id)
ulog = load_ulog_file(ulog_file_name)
# put additional data into a DB
con = sqlite3.connect(get_db_filename())
cur = con.cursor()
cur.execute(
'insert into Logs (Id, Title, Description, '
'OriginalFilename, Date, AllowForAnalysis, Obfuscated, '
'Source, Email, WindSpeed, Rating, Feedback, Type, '
'videoUrl, ErrorLabels, Public, Token) values '
'(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
[log_id, title, description, upload_file_name,
datetime.datetime.now(), allow_for_analysis,
obfuscated, source, stored_email, wind_speed, rating,
feedback, upload_type, video_url, error_labels, is_public, token])
if ulog is not None:
vehicle_data = update_vehicle_db_entry(cur, ulog, log_id, vehicle_name)
vehicle_name = vehicle_data.name
con.commit()
url = '/plot_app?log='+log_id
full_plot_url = get_http_protocol()+'://'+get_domain_name()+url
print(full_plot_url)
delete_url = get_http_protocol()+'://'+get_domain_name()+ \
'/edit_entry?action=delete&log='+log_id+'&token='+token
# information for the notification email
info = {}
info['description'] = description
info['feedback'] = feedback
info['upload_filename'] = upload_file_name
info['type'] = ''
info['airframe'] = ''
info['hardware'] = ''
info['uuid'] = ''
info['software'] = ''
info['rating'] = rating
if len(vehicle_name) > 0:
info['vehicle_name'] = vehicle_name
if ulog is not None:
px4_ulog = PX4ULog(ulog)
info['type'] = px4_ulog.get_mav_type()
airframe_name_tuple = get_airframe_name(ulog)
if airframe_name_tuple is not None:
airframe_name, airframe_id = airframe_name_tuple
if len(airframe_name) == 0:
info['airframe'] = airframe_id
else:
info['airframe'] = airframe_name
sys_hardware = ''
if 'ver_hw' in ulog.msg_info_dict:
sys_hardware = escape(ulog.msg_info_dict['ver_hw'])
info['hardware'] = sys_hardware
if 'sys_uuid' in ulog.msg_info_dict and sys_hardware != 'SITL':
info['uuid'] = escape(ulog.msg_info_dict['sys_uuid'])
branch_info = ''
if 'ver_sw_branch' in ulog.msg_info_dict:
branch_info = ' (branch: '+ulog.msg_info_dict['ver_sw_branch']+')'
if 'ver_sw' in ulog.msg_info_dict:
ver_sw = escape(ulog.msg_info_dict['ver_sw'])
info['software'] = ver_sw + branch_info
if upload_type == 'flightreport' and is_public:
destinations = set(email_notifications_config['public_flightreport'])
if rating in ['unsatisfactory', 'crash_sw_hw', 'crash_pilot']:
destinations = destinations | \
set(email_notifications_config['public_flightreport_bad'])
send_flightreport_email(
list(destinations),
full_plot_url,
DBData.rating_str_static(rating),
DBData.wind_speed_str_static(wind_speed), delete_url,
stored_email, info)
# also generate the additional DB entry
# (we may have the log already loaded in 'ulog', however the
# lru cache will make it very quick to load it again)
generate_db_data_from_log_file(log_id, con)
# also generate the preview image
IOLoop.instance().add_callback(generate_overview_img_from_id, log_id)
con.commit()
cur.close()
con.close()
# send notification emails
send_notification_email(email, full_plot_url, delete_url, info)
# do not redirect for QGC
if source != 'QGroundControl':
self.redirect(url)
except CustomHTTPError:
raise
except ULogException:
raise CustomHTTPError(
400,
'Failed to parse the file. It is most likely corrupt.')
except:
print('Error when handling POST data', sys.exc_info()[0],
sys.exc_info()[1])
raise CustomHTTPError(500)
finally:
self.multipart_streamer.release_parts()
