def _run_setup_playbook(self, playbook, env):
cmd = '/usr/local/bin/setup-controller.sh ' + playbook
result = self._run_cmd(cmd, self.playbooks_path, 'root', env)
if result != 0:
raise cmerror.CMError('Playbook %s failed' % playbook)
def __call__(self, environ, start_response):
logging.debug('Handling request started, environ=%s', str(environ))
# for debug, print environment
# pprint.pprint(environ)
# For request and resonse data
rpc = cmhttprpc.HTTPRPC()
rpc.rep_status = CMHTTPErrors.get_ok_status()
# get the interesting fields
rpc.req_method = environ['REQUEST_METHOD']
path = environ['PATH_INFO']
try:
rpc.req_filter = urlparse.parse_qs(
urllib.unquote(environ['QUERY_STRING']))
except KeyError as exp:
rpc.req_filter = {}
content_type = environ['CONTENT_TYPE']
try:
content_size = environ['CONTENT_LENGTH']
except KeyError:
content_size = None
try:
# get the action to be done
action = ''
actions, _ = self.mapper.routematch(path)
if actions and isinstance(actions, dict):
action = actions.get('action', '')
for key, value in actions.iteritems():
if key != 'action':
rpc.req_params[key] = value
else:
rpc.rep_status = CMHTTPErrors.get_resource_not_found_status()
raise cmerror.CMError('The requested url is not found')
# get the body if available
if content_size and int(content_size):
size = int(content_size)
if content_type == 'application/json':
totalread = 0
while totalread < size:
data = environ['wsgi.input'].read()
totalread += len(data)
rpc.req_body += data
else:
rpc.rep_status = CMHTTPErrors.get_unsupported_content_type_status(
)
raise cmerror.CMError('Only json content is supported')
# check the action
try:
logging.info('Calling %s with rpc=%s', action, str(rpc))
actionfunc = getattr(self, action)
actionfunc(rpc)
except AttributeError as attrerror:
rpc.reply_status = CMHTTPErrors.get_resource_not_found_status()
raise cmerror.CMError('Action %s not found, error: %s' %
(action, str(attrerror)))
except cmerror.CMError as exp:
rpc.rep_status = CMHTTPErrors.get_internal_error_status()
rpc.rep_status += ','
rpc.rep_status += str(exp)
except Exception as exp: # pylint: disable=broad-except
rpc.rep_status = CMHTTPErrors.get_internal_error_status()
rpc.rep_status += ','
rpc.rep_status += str(exp)
finally:
logging.info('Replying with rpc=%s', str(rpc))
response_headers = [('Content-type', 'application/json')]
start_response(rpc.rep_status, response_headers)
yield rpc.rep_body
def _run_playbook(self, playbook, user, env):
cmd = '/usr/local/bin/openstack-ansible -b -u ' + user + ' ' + playbook
result = self._run_cmd(cmd, self.playbooks_path, user, env)
if result != 0:
raise cmerror.CMError('Playbook %s failed' % playbook)
def get_domains(self):
logging.debug('get_domains called')
try:
return self.client.get_domains()
except dss_error.Error as ex:
raise cmerror.CMError(str(ex))
def get(self, domain, name):
raise cmerror.CMError('No implemented')
def handle(self, confman):
try:
self._set_low_latency_options(confman)
except configerror.ConfigError as exp:
raise cmerror.CMError(str(exp))
def __call__(self, args):
raise cmerror.CMError('Not implemented')
def list_snapshots(self, rpc):
logging.error('list_snapshots not implemented')
rpc.rep_status = CMHTTPErrors.get_resource_not_found_status()
raise cmerror.CMError('Not implemented')
def reboot_node(self, rpc):
logging.error('reboot_node not implemented')
rpc.rep_status = CMHTTPErrors.get_resource_not_found_status()
raise cmerror.CMError('Not implemented')
def delete_domain(self, domain):
raise cmerror.CMError('Not implemented')
def delete_properties(self, rpc):
logging.error('delete_properties not implemented')
rpc.rep_status = CMHTTPErrors.get_resource_not_found_status()
raise cmerror.CMError('Not implemented')
def delete(self, domain, name):
raise cmerror.CMError('Not implemented')
def get_domains(self):
raise cmerror.CMError('Not implemented')
def set(self, domain, name, value):
raise cmerror.CMError('Not implemented')
def activate_full(self, target=None):
try:
properties = self.get_plugin_client().get_properties('.*')
if not properties:
return
propsjson = {}
for name, value in properties.iteritems():
try:
propsjson[name] = json.loads(value)
except Exception as exp:
continue
configman = configmanager.ConfigManager(propsjson)
hostsconfig = configman.get_hosts_config_handler()
installation_host = hostsconfig.get_installation_host()
installed = False
try:
configman.get_cloud_installation_date()
installed = True
except configerror.ConfigError as exp:
pass
if installed:
return
usersconf = configman.get_users_config_handler()
admin = usersconf.get_admin_user()
#generate high level playbooks
if self._run_cmd(self.playbooks_generate_cli, '/etc', 'root',
os.environ.copy()):
raise cmerror.CMError('Failed to run %s' %
self.playbooks_generate_cli)
caas_data = configman.get_caas_config_handler()
phase = self._get_installation_phase()
#first we run the setup
if not phase:
self._set_installation_phase('setup-started')
phase = 'setup-started'
env = os.environ.copy()
if phase == 'setup-started':
env['VNF_EMBEDDED_DEPLOYMENT'] = 'false'
env['CONFIG_PHASE'] = 'setup'
env['BOOTSTRAP_OPTS'] = 'installation_controller=%s' % (
installation_host)
self._run_setup_playbook(self.presetup_playbook, env)
env['BOOTSTRAP_OPTS'] = ''
if caas_data.get_vnf_flag():
env['VNF_EMBEDDED_DEPLOYMENT'] = 'true'
self._run_setup_playbook(self.setup_playbook, env)
self._set_installation_phase('setup-ended')
phase = 'setup-ended'
#second we run the aio
if phase == 'setup-ended':
self._set_installation_phase('bootstrapping-started')
phase = 'bootstrapping-started'
if phase == 'bootstrapping-started':
env['CONFIG_PHASE'] = 'bootstrapping'
self._run_playbook(self.bootstrapping_playbook, admin, env)
self._set_installation_phase('bootstrapping-ended')
phase = 'bootstrapping-ended'
#3rd we run the provisioning
if phase == 'bootstrapping-ended':
self._set_installation_phase('provisioning-started')
phase = 'provisioning-started'
if phase == 'provisioning-started':
env['CONFIG_PHASE'] = 'provisioning'
self._run_playbook(self.provisioning_playbook, admin, env)
self._set_installation_phase('provisioning-ended')
phase = 'provisioning-ended'
#4th we run the postconfig
if phase == 'provisioning-ended':
self._set_installation_phase('postconfig-started')
phase = 'postconfig-started'
if phase == 'postconfig-started':
env['CONFIG_PHASE'] = 'postconfig'
env['CAAS_ONLY_DEPLOYMENT'] = 'false'
if caas_data.get_caas_only():
env['CAAS_ONLY_DEPLOYMENT'] = 'true'
self._run_playbook(self.postconfig_playbook, admin, env)
self._set_installation_phase('postconfig-ended')
phase = 'postconfig-ended'
self._set_installation_date()
self._set_state('success')
except Exception as exp:
self._set_state('failure')
raise cmerror.CMError(str(exp))
def get_changes_states(self, rpc):
logging.error('get_changes_states not implemented')
rpc.rep_status = CMHTTPErrors.get_resource_not_found_status()
raise cmerror.CMError('Not implemented')
def handle(self, confman):
try:
self._set_default_type_for_provider_networks(confman)
except configerror.ConfigError as exp:
raise cmerror.CMError(str(exp))
def set_automatic_activation_state(self, rpc, state):
logging.error('set_automatic_activation_state not implemented')
rpc.rep_status = CMHTTPErrors.get_resource_not_found_status()
raise cmerror.CMError('Not implemented')
def init_subparser(self, subparsers):
raise cmerror.CMError('Not implemented')
def set_property(self, name, value):
raise cmerror.CMError('Not implemented')
def set(self, domain, name, value):
logging.debug('set called for setting %s %s=%s', domain, name, value)
try:
return self.client.set(domain, name, value)
except dss_error.Error as ex:
raise cmerror.CMError(str(ex))
def activate(self, work):
raise cmerror.CMError('Not implemented')
def consume(self, work):
raise cmerror.CMError('Not implemented')
def load_plugin(self):
raise cmerror.CMError('Not implemented')
