def check_and_start_local_server(self, sid, pause, database_id, is_forced, add_server=False):
"""
Checks if voltdb server is running locally and
starts it if the server is not running.
If the server is running, this returns an error
"""
if sid == -1:
return create_response('A VoltDB Server not started wrong configuration', 500)
if self.is_voltserver_running(database_id):
return create_response('A VoltDB Server process is already running', 500)
return_code = self.initialize_local_config(sid, is_forced)
if return_code == 0:
retcode = self.start_local_server(sid, pause, add_server)
if (retcode == 0):
HTTPListener.Global.SERVERS[sid]['isAdded'] = True
HTTPListener.sync_configuration()
return create_response('Success', 200)
else:
return create_response('Error', 500)
else:
# return create_response('Error starting server', 500)
return create_response('Error', 500)
def check_and_start_local_server(self, sid, pause, database_id, is_forced, add_server=False):
"""
Checks if voltdb server is running locally and
starts it if the server is not running.
If the server is running, this returns an error
"""
if sid == -1:
return create_response('A VoltDB Server not started wrong configuration', 500)
if self.is_voltserver_running(database_id):
return create_response('A VoltDB Server process is already running', 500)
return_code = self.initialize_local_config(sid, is_forced)
if return_code == 0:
retcode = self.start_local_server(sid, pause, add_server)
if (retcode == 0):
HTTPListener.Global.SERVERS[sid]['isAdded'] = True
HTTPListener.sync_configuration()
return create_response('Success', 200)
else:
return create_response('Error', 500)
else:
# return create_response('Error starting server', 500)
return create_response('Error', 500)
def check_validation_deployment(req):
if 'systemsettings' in req.json and 'resourcemonitor' in req.json['systemsettings']:
if 'memorylimit' in req.json['systemsettings']['resourcemonitor'] and \
'size' in req.json['systemsettings']['resourcemonitor']['memorylimit']:
size = str(req.json['systemsettings']['resourcemonitor']['memorylimit']['size'])
response = json.loads(HTTPListener.check_size_value(size, 'memorylimit').data)
if 'error' in response:
return {'status': 'error', 'error': response['error']}
disk_limit_arr = []
if 'disklimit' in req.json['systemsettings']['resourcemonitor'] and \
'feature' in req.json['systemsettings']['resourcemonitor']['disklimit']:
for feature in req.json['systemsettings']['resourcemonitor']['disklimit']['feature']:
size = feature['size']
if feature['name'] in disk_limit_arr:
return {'status': 'error', 'error': 'Duplicate items are not allowed.'}
disk_limit_arr.append(feature['name'])
response = json.loads(HTTPListener.check_size_value(size, 'disklimit').data)
if 'error' in response:
return {'status': 'error', 'error': response['error']}
if 'snapshot' in req.json and 'frequency' in req.json['snapshot']:
frequency_unit = ['h', 'm', 's']
frequency = str(req.json['snapshot']['frequency'])
last_char = frequency[len(frequency)-1]
if last_char not in frequency_unit:
return {'status': 'error', 'error': 'Snapshot: Invalid frequency value.'}
frequency = frequency[:-1]
try:
int_frequency = int(frequency)
except Exception, exp:
return {'status': 'error', 'error': 'Snapshot: ' + str(exp)}
def start_database(self, is_pause, recover=False):
"""
Starts voltdb servers on all nodes configured for this database.
Returns reponse with HTTP status code and error details json.
"""
# sync deployment file first
HTTPListener.sync_configuration()
members = []
current_database = HTTPListener.Global.DATABASES.get(self.database_id)
if not current_database:
return create_response(
'No database found for id: %u' % self.database_id, 404)
else:
members = current_database['members']
if not members:
return create_response(
'No servers configured for the database: %u' %
self.database_id, 404)
result = self.check_other_database_status(self.database_id)
if not result:
return make_response(
jsonify({
'status': 404,
'statusString': 'Error'
}), 404)
# Check if there are valid servers configured for all ids
for server_id in members:
server = HTTPListener.Global.SERVERS.get(server_id)
if not server:
return create_response(
'Server details not found for id: %u' % server_id, 404)
# Now start each server
failed = False
server_status = {}
action = 'start'
if recover:
action = 'recover'
for server_id in members:
server = HTTPListener.Global.SERVERS.get(server_id)
curr = server
try:
url = ('http://%s:%u/api/1.0/databases/%u/servers/%s?id=%u&pause=%s') % \
(curr['hostname'], HTTPListener.__PORT__, self.database_id, action, server_id, is_pause)
response = requests.put(url)
if response.status_code != requests.codes.ok:
failed = True
server_status[curr['hostname']] = json.loads(
response.text)['statusString']
except Exception, err:
failed = True
print traceback.format_exc()
server_status[curr['hostname']] = str(err)
def start_database(self, is_pause, is_force):
"""
Starts voltdb servers on all nodes configured for this database.
Returns reponse with HTTP status code and error details json.
"""
# sync deployment file first
HTTPListener.sync_configuration()
members = []
current_database = HTTPListener.Global.DATABASES.get(self.database_id)
if not current_database:
return create_response('No database found for id: %u' % self.database_id, 404)
else:
members = current_database['members']
if not members:
return create_response('No servers configured for the database: %u' % self.database_id, 404)
result = self.check_other_database_status(self.database_id)
if not result:
return make_response(jsonify({'status': 404, 'statusString': 'Error'}), 404)
# Check if there are valid servers configured for all ids
for server_id in members:
server = HTTPListener.Global.SERVERS.get(server_id)
if not server:
return create_response('Server details not found for id: %u' % server_id, 404)
# Now start each server
server_unreachable = False
error_msg = ''
failed = False
server_status = {}
action = 'start'
for server_id in members:
server = HTTPListener.Global.SERVERS.get(server_id)
curr = server
try:
url = ('http://%s:%u/api/1.0/databases/%u/servers/%s?id=%u&pause=%s&force=%s') % \
(curr['hostname'], HTTPListener.__PORT__, self.database_id, action, server_id, is_pause, is_force)
response = requests.put(url)
if response.status_code != requests.codes.ok:
failed = True
db_status = json.loads(response.text)['statusString']
server_status[curr['hostname']] = db_status
except Exception, err:
if 'ConnectionError' in str(err):
error_msg = "Could not connect to the server " + curr['hostname'] + ". " \
"Please ensure that all servers are reachable."
server_unreachable = True
break
failed = True
print traceback.format_exc()
server_status[curr['hostname']] = str(err)
def set_deployment_for_upload(database_id, request):
dep_file = request.files['file']
if dep_file and HTTPListener.allowed_file(dep_file.filename):
try:
content = dep_file.read()
o = XML(content)
xml_final = json.loads(json.dumps(etree_to_dict(o)))
if 'deployment' in xml_final and type(xml_final['deployment']) is dict:
deployment_data = get_deployment_for_upload(xml_final['deployment'])
if type(deployment_data) is dict:
if 'error' in deployment_data:
return {'status': 'failure', 'error': deployment_data['error']}
else:
deployment_json = deployment_data[0]
req = HTTPListener.DictClass()
req.json = {}
req.json = deployment_json
inputs = JsonInputs(req)
if not inputs.validate():
return {'status': 'failure', 'errors': inputs.errors}
result = check_validation_deployment(req)
if 'status' in result and result['status'] == 'error':
return {'status': 'failure', 'error': result['error']}
HTTPListener.map_deployment(req, database_id)
HTTPListener.Global.DEPLOYMENT_USERS = {}
if 'users' in req.json and 'user' in req.json['users']:
for user in req.json['users']['user']:
HTTPListener.Global.DEPLOYMENT_USERS[int(user['userid'])]= {
'name': user['name'],
'roles': user['roles'],
'password': user['password'],
'plaintext': user['plaintext'],
'databaseid': database_id,
'userid': user['userid']
}
HTTPListener.sync_configuration()
write_configuration_file()
else:
return {'status': 'failure', 'error': 'Invalid file content.'}
except Exception as err:
return {'status': 'failure', 'error': 'Invalid file content.'}
else:
return {'status': 'failure', 'error': 'Invalid file type.'}
return {'status': 'success'}
def start_database(self, recover=False):
"""
Starts voltdb servers on all nodes configured for this database.
Returns reponse with HTTP status code and error details json.
"""
# sync deployment file first
HTTPListener.sync_configuration()
members = []
current_database = HTTPListener.Global.DATABASES.get(self.database_id)
if not current_database:
return create_response("No database found for id: %u" % self.database_id, 404)
else:
members = current_database["members"]
if not members:
return create_response("No servers configured for the database: %u" % self.database_id, 404)
# Check if there are valid servers configured for all ids
for server_id in members:
server = HTTPListener.Global.SERVERS.get(server_id)
if not server:
return create_response("Server details not found for id: %u" % server_id, 404)
# Now start each server
failed = False
server_status = {}
action = "start"
if recover:
action = "recover"
for server_id in members:
server = HTTPListener.Global.SERVERS.get(server_id)
curr = server
try:
url = ("http://%s:%u/api/1.0/databases/%u/servers/%s?id=%u") % (
curr["hostname"],
HTTPListener.__PORT__,
self.database_id,
action,
server_id,
)
response = requests.put(url)
if response.status_code != requests.codes.ok:
failed = True
server_status[curr["hostname"]] = json.loads(response.text)["statusString"]
except Exception, err:
failed = True
print traceback.format_exc()
server_status[curr["hostname"]] = str(err)
def start_database(self, recover=False):
"""
Starts voltdb servers on all nodes configured for this database.
Returns reponse with HTTP status code and error details json.
"""
# sync deployment file first
HTTPListener.sync_configuration()
members = []
current_database = [database for database in HTTPListener.Global.DATABASES if database['id'] == self.database_id]
if not current_database:
return create_response('No database found for id: %u' % self.database_id, 404)
else:
members = current_database[0]['members']
if not members:
return create_response('No servers configured for the database: %u' % self.database_id, 404)
# Check if there are valid servers configured for all ids
for server_id in members:
server = [server for server in HTTPListener.Global.SERVERS if server['id'] == server_id]
if not server:
return create_response('Server details not found for id: %u' % server_id, 404)
# Now start each server
failed = False
server_status = {}
action = 'start'
if recover:
action = 'recover'
for server_id in members:
server = [server for server in HTTPListener.Global.SERVERS if server['id'] == server_id]
curr = server[0]
try:
url = ('http://%s:%u/api/1.0/databases/%u/servers/%s?id=%u') % \
(curr['hostname'], HTTPListener.__PORT__, self.database_id, action, server_id)
response = requests.put(url)
if response.status_code != requests.codes.ok:
failed = True
server_status[curr['hostname']] = json.loads(response.text)['statusstring']
except Exception, err:
failed = True
print traceback.format_exc()
server_status[curr['hostname']] = str(err)
def start_database(self, recover=False):
"""
Starts voltdb servers on all nodes configured for this database.
Returns reponse with HTTP status code and error details json.
"""
# sync deployment file first
HTTPListener.sync_configuration()
members = []
current_database = [database for database in HTTPListener.Global.DATABASES if database['id'] == self.database_id]
if not current_database:
return create_response('No database found for id: %u' % self.database_id, 404)
else:
members = current_database[0]['members']
if not members:
return create_response('No servers configured for the database: %u' % self.database_id, 404)
# Check if there are valid servers configured for all ids
for server_id in members:
server = [server for server in HTTPListener.Global.SERVERS if server['id'] == server_id]
if not server:
return create_response('Server details not found for id: %u' % server_id, 404)
# Now start each server
failed = False
server_status = {}
action = 'start'
if recover:
action = 'recover'
for server_id in members:
server = [server for server in HTTPListener.Global.SERVERS if server['id'] == server_id]
curr = server[0]
try:
url = ('http://%s:%u/api/1.0/databases/%u/servers/%s') % \
(curr['hostname'], HTTPListener.__PORT__, self.database_id, action)
response = requests.put(url)
if (response.status_code != requests.codes.ok):
failed = True
server_status[curr['hostname']] = json.loads(response.text)['statusstring']
except Exception, err:
failed = True
print traceback.format_exc()
server_status[curr['hostname']] = str(err)
def check_validation_deployment(req):
if 'systemsettings' in req.json and 'resourcemonitor' in req.json[
'systemsettings']:
if 'memorylimit' in req.json['systemsettings']['resourcemonitor'] and \
'size' in req.json['systemsettings']['resourcemonitor']['memorylimit']:
size = str(req.json['systemsettings']['resourcemonitor']
['memorylimit']['size'])
response = json.loads(
HTTPListener.check_size_value(size, 'memorylimit').data)
if 'error' in response:
return {'status': 'error', 'error': response['error']}
disk_limit_arr = []
if 'disklimit' in req.json['systemsettings']['resourcemonitor'] and \
'feature' in req.json['systemsettings']['resourcemonitor']['disklimit']:
for feature in req.json['systemsettings']['resourcemonitor'][
'disklimit']['feature']:
size = feature['size']
if feature['name'] in disk_limit_arr:
return {
'status': 'error',
'error': 'Duplicate items are not allowed.'
}
disk_limit_arr.append(feature['name'])
response = json.loads(
HTTPListener.check_size_value(size, 'disklimit').data)
if 'error' in response:
return {'status': 'error', 'error': response['error']}
if 'snapshot' in req.json and 'frequency' in req.json['snapshot']:
frequency_unit = ['h', 'm', 's']
frequency = str(req.json['snapshot']['frequency'])
last_char = frequency[len(frequency) - 1]
if last_char not in frequency_unit:
return {
'status': 'error',
'error': 'Snapshot: Invalid frequency value.'
}
frequency = frequency[:-1]
try:
int_frequency = int(frequency)
except Exception, exp:
return {'status': 'error', 'error': 'Snapshot: ' + str(exp)}
def set_deployment_for_upload(database_id, request):
dep_file = request.files['file']
if dep_file and HTTPListener.allowed_file(dep_file.filename):
try:
content = dep_file.read()
o = XML(content)
xml_final = json.loads(json.dumps(etree_to_dict(o)))
if 'deployment' in xml_final and type(
xml_final['deployment']) is dict:
deployment_data = get_deployment_for_upload(
xml_final['deployment'])
if type(deployment_data) is dict:
if 'error' in deployment_data:
return {
'status': 'failure',
'error': deployment_data['error']
}
else:
deployment_json = deployment_data[0]
req = HTTPListener.DictClass()
req.json = {}
req.json = deployment_json
inputs = JsonInputs(req)
if not inputs.validate():
return {'status': 'failure', 'errors': inputs.errors}
result = check_validation_deployment(req)
if 'status' in result and result['status'] == 'error':
return {'status': 'failure', 'error': result['error']}
HTTPListener.map_deployment(req, database_id)
HTTPListener.Global.DEPLOYMENT_USERS = {}
if 'users' in req.json and 'user' in req.json['users']:
for user in req.json['users']['user']:
HTTPListener.Global.DEPLOYMENT_USERS[int(
user['userid'])] = {
'name': user['name'],
'roles': user['roles'],
'password': user['password'],
'plaintext': user['plaintext'],
'databaseid': database_id,
'userid': user['userid']
}
HTTPListener.sync_configuration()
write_configuration_file()
else:
return {'status': 'failure', 'error': 'Invalid file content.'}
except Exception as err:
return {'status': 'failure', 'error': 'Invalid file content.'}
else:
return {'status': 'failure', 'error': 'Invalid file type.'}
return {'status': 'success'}
