def configure_lxc_root_tarball(self, rootfs):
""" Use a local copy of the cloud rootfs tarball """
host = self.machine.dns_name
cmds = "sudo mkdir -p /var/cache/lxc/cloud-trusty"
utils.remote_run(self.machine.machine_id, cmds=cmds)
utils.remote_cp(host, src=rootfs, dst="/var/cache/lxc/cloud-trusty")
self.lxc_root_tarball_configured = True
def get_started_machine(self):
started_machines = sorted([m for m in
self.juju_state.machines_allocated()
if m.agent_state == 'started'],
key=lambda m: int(m.machine_id))
if len(started_machines) > 0:
controller_id = started_machines[0].machine_id
utils.remote_cp(controller_id,
src="/usr/share/cloud-installer/tools/apt-go-fast",
dst="/tmp/apt-go-fast")
utils.remote_run(controller_id,
cmds="sudo sh /tmp/apt-go-fast")
self.info_message("Using machine {} as controller host.".format(
controller_id))
return started_machines[0]
machines_summary_items = self.juju_state.machines_summary().items()
if len(machines_summary_items) > 0:
status_string = ", ".join(["{} {}".format(v, k) for k, v in
machines_summary_items])
self.info_message("Waiting for a machine."
" Machines summary: {}".format(status_string))
else:
self.info_message("Waiting for a machine.")
return None
def run_apt_go_fast(self, machine_id):
utils.remote_cp(machine_id,
src=path.join(self.config.share_path,
"tools/apt-go-fast"),
dst="/tmp/apt-go-fast")
utils.remote_run(machine_id,
cmds="sudo sh /tmp/apt-go-fast")
def post_proc(self):
""" performs additional network configuration for charm """
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
if unit.machine_id == '-1':
return True
self.ui.status_info_message("Validating network parameters "
"for Neutron")
utils.remote_cp(
unit.machine_id,
src=os.path.join(self.config.tmpl_path, "neutron-network.sh"),
dst="/tmp/neutron-network.sh",
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(
unit.machine_id,
cmds="sudo chmod +x /tmp/neutron-network.sh",
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(
unit.machine_id,
cmds="sudo /tmp/neutron-network.sh {}".format(
self.config.getopt('install_type')),
juju_home=self.config.juju_home(use_expansion=True))
self.ui.status_info_message("Done.")
return False
def configure_lxc_root_tarball(self, rootfs):
""" Use a local copy of the cloud rootfs tarball """
host = self.machine.dns_name
cmds = "sudo mkdir -p /var/cache/lxc/cloud-trusty"
utils.remote_run(self.machine.machine_id, cmds=cmds)
utils.remote_cp(host, src=rootfs, dst="/var/cache/lxc/cloud-trusty")
self.lxc_root_tarball_configured = True
def post_proc(self):
""" performs additional network configuration for charm """
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
if unit.machine_id == '-1':
return True
self.ui.status_info_message("Validating network parameters "
"for Neutron")
utils.remote_cp(
unit.machine_id,
src=os.path.join(self.config.tmpl_path, "neutron-network.sh"),
dst="/tmp/neutron-network.sh",
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(
unit.machine_id,
cmds="sudo chmod +x /tmp/neutron-network.sh",
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(
unit.machine_id,
cmds="sudo /tmp/neutron-network.sh {}".format(
self.config.getopt('install_type')),
juju_home=self.config.juju_home(use_expansion=True))
self.ui.status_info_message("Done.")
return False
def get_started_machine(self):
started_machines = sorted([
m for m in self.juju_state.machines_allocated()
if m.agent_state == 'started'
],
key=lambda m: int(m.machine_id))
if len(started_machines) > 0:
controller_id = started_machines[0].machine_id
utils.remote_cp(controller_id,
src="/usr/share/cloud-installer/tools/apt-go-fast",
dst="/tmp/apt-go-fast")
utils.remote_run(controller_id, cmds="sudo sh /tmp/apt-go-fast")
self.info_message(
"Using machine {} as controller host.".format(controller_id))
return started_machines[0]
machines_summary_items = self.juju_state.machines_summary().items()
if len(machines_summary_items) > 0:
status_string = ", ".join(
["{} {}".format(v, k) for k, v in machines_summary_items])
self.info_message("Waiting for a machine."
" Machines summary: {}".format(status_string))
else:
self.info_message("Waiting for a machine.")
return None
def run_apt_go_fast(self, machine_id):
utils.remote_cp(machine_id,
src=path.join(self.config.share_path,
"tools/apt-go-fast"),
dst="/tmp/apt-go-fast",
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(machine_id,
cmds="sudo sh /tmp/apt-go-fast",
juju_home=self.config.juju_home(use_expansion=True))
def run_apt_go_fast(self, machine_id):
utils.remote_cp(machine_id,
src=path.join(self.config.share_path,
"tools/apt-go-fast"),
dst="/tmp/apt-go-fast",
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(machine_id,
cmds="sudo sh /tmp/apt-go-fast",
juju_home=self.config.juju_home(use_expansion=True))
def configure_lxc_network(self, machine_id):
# upload our lxc-host-only template and setup bridge
log.debug('Copying network specifications to machine')
srcpath = path.join(self.config.tmpl_path, 'lxc-host-only')
destpath = "/tmp/lxc-host-only"
utils.remote_cp(machine_id, src=srcpath, dst=destpath)
log.debug('Updating network configuration for machine')
utils.remote_run(machine_id,
cmds="sudo chmod +x /tmp/lxc-host-only")
utils.remote_run(machine_id,
cmds="sudo /tmp/lxc-host-only")
def post_proc(self):
""" post processing for nova-cloud-controller """
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
k_svc = self.juju_state.service('keystone')
keystone = k_svc.unit('keystone')
openstack_password = self.config.getopt('openstack_password')
public_address = keystone.public_address
if is_ipv6(public_address):
public_address = "[%s]".format(public_address)
log.debug("Found ipv6 address, {}".format(public_address))
if unit.machine_id == '-1':
return True
for u in ['admin', 'ubuntu']:
env = self._openstack_env(u,
openstack_password,
u, public_address)
self._openstack_env_save(u, env)
utils.remote_cp(
unit.machine_id,
src=self._openstack_env_path(u),
dst='/tmp/openstack-{u}-rc'.format(u=u),
juju_home=self.config.juju_home(use_expansion=True))
setup_script_path = self.render_setup_script()
remote_setup_script_path = "/tmp/nova-controller-setup.sh"
utils.remote_cp(
unit.machine_id,
src=setup_script_path,
dst=remote_setup_script_path,
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(
unit.machine_id,
cmds="chmod +x {}".format(remote_setup_script_path),
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_cp(
unit.machine_id,
src=utils.ssh_pubkey(),
dst="/tmp/id_rsa.pub",
juju_home=self.config.juju_home(use_expansion=True))
err = utils.remote_run(
unit.machine_id,
cmds="/tmp/nova-controller-setup.sh "
"\"{p}\" \"{install_type}\"".format(
p=openstack_password,
install_type=self.config.getopt('install_type')),
juju_home=self.config.juju_home(use_expansion=True))
if err['status'] != 0:
# something happened during nova setup, re-run
return True
return False
def post_proc(self):
""" post processing for nova-cloud-controller """
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
k_svc = self.juju_state.service('keystone')
keystone = k_svc.unit('keystone')
openstack_password = self.config.getopt('openstack_password')
public_address = keystone.public_address
if is_ipv6(public_address):
public_address = "[%s]".format(public_address)
log.debug("Found ipv6 address, {}".format(public_address))
if unit.machine_id == '-1':
return True
for u in ['admin', 'ubuntu']:
env = self._openstack_env(u,
openstack_password,
u, public_address)
self._openstack_env_save(u, env)
utils.remote_cp(
unit.machine_id,
src=self._openstack_env_path(u),
dst='/tmp/openstack-{u}-rc'.format(u=u),
juju_home=self.config.juju_home(use_expansion=True))
setup_script_path = self.render_setup_script()
remote_setup_script_path = "/tmp/nova-controller-setup.sh"
utils.remote_cp(
unit.machine_id,
src=setup_script_path,
dst=remote_setup_script_path,
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(
unit.machine_id,
cmds="chmod +x {}".format(remote_setup_script_path),
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_cp(
unit.machine_id,
src=utils.ssh_pubkey(),
dst="/tmp/id_rsa.pub",
juju_home=self.config.juju_home(use_expansion=True))
err = utils.remote_run(
unit.machine_id,
cmds="/tmp/nova-controller-setup.sh "
"\"{p}\" \"{install_type}\"".format(
p=openstack_password,
install_type=self.config.getopt('install_type')),
juju_home=self.config.juju_home(use_expansion=True))
if err['status'] != 0:
# something happened during nova setup, re-run
return True
return False
def configure_lxc_network(self):
# upload our lxc-host-only template and setup bridge
self.info_message('Copying network specifications to machine.')
utils.remote_cp(
self.machine.machine_id,
src="/usr/share/cloud-installer/templates/lxc-host-only",
dst="/tmp/lxc-host-only")
self.info_message('Updating network configuration for machine.')
utils.remote_run(self.machine.machine_id,
cmds="sudo chmod +x /tmp/lxc-host-only")
utils.remote_run(self.machine.machine_id,
cmds="sudo /tmp/lxc-host-only")
self.single_net_configured = True
def configure_lxc_network(self, machine_id):
# upload our lxc-host-only template and setup bridge
log.info("Copying network specifications to machine")
srcpath = path.join(self.config.tmpl_path, "lxc-host-only")
destpath = "/tmp/lxc-host-only"
utils.remote_cp(machine_id, src=srcpath, dst=destpath, juju_home=self.config.juju_home(use_expansion=True))
log.debug("Updating network configuration for machine")
utils.remote_run(
machine_id, cmds="sudo chmod +x /tmp/lxc-host-only", juju_home=self.config.juju_home(use_expansion=True)
)
utils.remote_run(
machine_id, cmds="sudo /tmp/lxc-host-only", juju_home=self.config.juju_home(use_expansion=True)
)
def configure_lxc_network(self):
# upload our lxc-host-only template and setup bridge
self.info_message('Copying network specifications to machine.')
utils.remote_cp(
self.machine.machine_id,
src="/usr/share/cloud-installer/templates/lxc-host-only",
dst="/tmp/lxc-host-only")
self.info_message('Updating network configuration for machine.')
utils.remote_run(self.machine.machine_id,
cmds="sudo chmod +x /tmp/lxc-host-only")
utils.remote_run(self.machine.machine_id,
cmds="sudo /tmp/lxc-host-only")
self.single_net_configured = True
def post_proc(self):
""" post processing for nova-cloud-controller """
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
k_svc = self.juju_state.service("keystone")
keystone = k_svc.unit("keystone")
openstack_password = self.config.getopt("openstack_password")
if unit.machine_id == "-1":
return True
for u in ["admin", "ubuntu"]:
env = self._openstack_env(u, openstack_password, u, keystone.public_address)
self._openstack_env_save(u, env)
utils.remote_cp(
unit.machine_id,
src=self._openstack_env_path(u),
dst="/tmp/openstack-{u}-rc".format(u=u),
juju_home=self.config.juju_home(use_expansion=True),
)
setup_script_path = self.render_setup_script()
remote_setup_script_path = "/tmp/nova-controller-setup.sh"
utils.remote_cp(
unit.machine_id,
src=setup_script_path,
dst=remote_setup_script_path,
juju_home=self.config.juju_home(use_expansion=True),
)
utils.remote_run(
unit.machine_id,
cmds="chmod +x {}".format(remote_setup_script_path),
juju_home=self.config.juju_home(use_expansion=True),
)
utils.remote_cp(
unit.machine_id,
src=utils.ssh_pubkey(),
dst="/tmp/id_rsa.pub",
juju_home=self.config.juju_home(use_expansion=True),
)
err = utils.remote_run(
unit.machine_id,
cmds="/tmp/nova-controller-setup.sh "
"{p} {install_type}".format(p=openstack_password, install_type=self.config.getopt("install_type")),
juju_home=self.config.juju_home(use_expansion=True),
)
if err["status"] != 0:
# something happened during nova setup, re-run
return True
return False
def configure_lxc_network(self, machine_id):
# upload our lxc-host-only template and setup bridge
log.info('Copying network specifications to machine')
srcpath = path.join(self.config.tmpl_path, 'lxc-host-only')
destpath = "/tmp/lxc-host-only"
utils.remote_cp(machine_id, src=srcpath, dst=destpath,
juju_home=self.config.juju_home(use_expansion=True))
log.debug('Updating network configuration for machine')
utils.remote_run(machine_id,
cmds="sudo chmod +x /tmp/lxc-host-only",
juju_home=self.config.juju_home(use_expansion=True))
utils.remote_run(machine_id,
cmds="sudo /tmp/lxc-host-only",
juju_home=self.config.juju_home(use_expansion=True))
def post_proc(self):
""" performs additional network configuration for charm """
super(CharmNeutron, self).post_proc()
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
if unit.machine_id == '-1':
raise CharmPostProcessException(
"Service not ready for workload.")
self.ui.status_info_message("Validating network parameters "
"for Neutron")
utils.remote_cp(
unit.machine_id,
src=os.path.join(self.config.tmpl_path, "neutron-network.sh"),
dst="/tmp/neutron-network.sh",
juju_home=self.config.juju_home(use_expansion=True))
out = utils.remote_run(
unit.machine_id,
cmds="sudo bash /tmp/neutron-network.sh {}".format(
self.config.getopt('install_type')),
juju_home=self.config.juju_home(use_expansion=True))
if out['status'] > 0:
log.error("Neutron error: {}".format(out))
raise CharmPostProcessException(out)
def post_proc(self):
""" post processing for nova-cloud-controller """
if not self.wait_for_agent(['keystone', self.charm_name]):
return True
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
k_svc = self.juju_state.service('keystone')
keystone = k_svc.unit('keystone')
if unit.machine_id == '-1':
return True
for u in ['admin', 'ubuntu']:
env = self._openstack_env(u, self.config.openstack_password, u,
keystone.public_address)
self._openstack_env_save(u, env)
utils.remote_cp(unit.machine_id,
src=self._openstack_env_path(u),
dst='/tmp/openstack-{u}-rc'.format(u=u))
utils.remote_cp(unit.machine_id,
src=os.path.join(self.config.tmpl_path,
"nova-controller-setup.sh"),
dst="/tmp/nova-controller-setup.sh")
utils.remote_cp(unit.machine_id,
src=self._pubkey(),
dst="/tmp/id_rsa.pub")
err = utils.remote_run(unit.machine_id,
cmds="/tmp/nova-controller-setup.sh "
"{p}".format(p=self.config.openstack_password))
if err['ret'] == 1:
# something happened during nova setup, re-run
return True
return False
def post_proc(self):
""" post processing for nova-cloud-controller """
unit = self.wait_for_agent()
if unit:
# We need to get keystone public_address for auth_url here
keystone = self.wait_for_agent('keystone')
if not keystone:
return True
for u in ['admin', 'ubuntu']:
env = self._openstack_env(u, self.openstack_password(),
u, keystone.public_address)
self._openstack_env_save(u, env)
utils.remote_cp(unit.machine_id,
src=self._openstack_env_path(u),
dst='/tmp/openstack-{u}-rc'.format(u=u))
utils.remote_cp(
unit.machine_id,
src=os.path.join(self.tmpl_path,
"nova-controller-setup.sh"),
dst="/tmp/nova-controller-setup.sh")
utils.remote_cp(
unit.machine_id,
src=self._pubkey(),
dst="/tmp/id_rsa.pub")
err = utils.remote_run(unit.machine_id,
cmds="/tmp/nova-controller-setup.sh "
"{p}".format(
p=self.openstack_password()))
if err['ret'] == 1:
# something happened during nova setup, re-run
return True
return False
return True
def set_unique_hostnames(self):
"""checks for and ensures unique hostnames, so e.g. ceph can assume
that.
FIXME: Remove once http://pad.lv/1326091 is fixed
"""
count = 0
for machine in self.juju_state.machines():
count += 1
hostname = machine.machine.get("InstanceId", "ubuntu-{}".format(count))
log.debug("Setting hostname of {} to {}".format(machine, hostname))
juju_home = self.config.juju_home(use_expansion=True)
utils.remote_run(
machine.machine_id, cmds="echo {} | sudo tee /etc/hostname".format(hostname), juju_home=juju_home
)
utils.remote_run(machine.machine_id, cmds="sudo hostname {}".format(hostname), juju_home=juju_home)
def set_unique_hostnames(self):
"""checks for and ensures unique hostnames, so e.g. ceph can assume
that.
FIXME: Remove once http://pad.lv/1326091 is fixed
"""
count = 0
for machine in self.juju_state.machines():
count += 1
hostname = machine.machine.get('InstanceId',
"ubuntu-{}".format(count))
log.debug("Setting hostname of {} to {}".format(machine, hostname))
juju_home = self.config.juju_home(use_expansion=True)
utils.remote_run(
machine.machine_id,
cmds="echo {} | sudo tee /etc/hostname".format(hostname),
juju_home=juju_home)
utils.remote_run(machine.machine_id,
cmds="sudo hostname {}".format(hostname),
juju_home=juju_home)
def post_proc(self):
""" performs additional network configuration for charm """
if not self.wait_for_agent():
return True
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
if unit.machine_id == '-1':
return True
self.ui.status_info_message("Updating network parameters "
"for Neutron")
utils.remote_cp(
unit.machine_id,
src=os.path.join(self.config.tmpl_path, "quantum-network.sh"),
dst="/tmp/quantum-network.sh")
utils.remote_run(unit.machine_id,
cmds="sudo chmod +x /tmp/quantum-network.sh")
utils.remote_run(unit.machine_id,
cmds="sudo /tmp/quantum-network.sh")
self.ui.status_info_message(
"Neutron deployed and configured")
return False
def post_proc(self):
""" performs additional network configuration for charm """
if not self.wait_for_agent():
return True
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
if unit.machine_id == '-1':
return True
self.ui.status_info_message("Updating network parameters "
"for Neutron")
utils.remote_cp(
unit.machine_id,
src=os.path.join(self.config.tmpl_path, "quantum-network.sh"),
dst="/tmp/quantum-network.sh")
utils.remote_run(unit.machine_id,
cmds="sudo chmod +x /tmp/quantum-network.sh")
utils.remote_run(unit.machine_id,
cmds="sudo /tmp/quantum-network.sh")
self.ui.status_info_message(
"Neutron deployed and configured, images will now be synced.")
return False
def post_proc(self):
""" performs additional network configuration for charm """
super(CharmNeutron, self).post_proc()
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
if unit.machine_id == '-1':
raise CharmPostProcessException("Service not ready for workload.")
self.ui.status_info_message("Validating network parameters "
"for Neutron")
utils.remote_cp(unit.machine_id,
src=os.path.join(self.config.tmpl_path,
"neutron-network.sh"),
dst="/tmp/neutron-network.sh",
juju_home=self.config.juju_home(use_expansion=True))
out = utils.remote_run(
unit.machine_id,
cmds="sudo bash /tmp/neutron-network.sh {}".format(
self.config.getopt('install_type')),
juju_home=self.config.juju_home(use_expansion=True))
if out['status'] > 0:
log.error("Neutron error: {}".format(out))
raise CharmPostProcessException(out)
def post_proc(self):
""" post processing for nova-cloud-controller """
if not self.wait_for_agent(['keystone', self.charm_name]):
return True
svc = self.juju_state.service(self.charm_name)
unit = svc.unit(self.charm_name)
k_svc = self.juju_state.service('keystone')
keystone = k_svc.unit('keystone')
if unit.machine_id == '-1':
return True
for u in ['admin', 'ubuntu']:
env = self._openstack_env(u, self.config.openstack_password,
u, keystone.public_address)
self._openstack_env_save(u, env)
utils.remote_cp(unit.machine_id,
src=self._openstack_env_path(u),
dst='/tmp/openstack-{u}-rc'.format(u=u))
utils.remote_cp(
unit.machine_id,
src=os.path.join(self.config.tmpl_path,
"nova-controller-setup.sh"),
dst="/tmp/nova-controller-setup.sh")
utils.remote_cp(
unit.machine_id,
src=self._pubkey(),
dst="/tmp/id_rsa.pub")
err = utils.remote_run(unit.machine_id,
cmds="/tmp/nova-controller-setup.sh "
"{p}".format(
p=self.config.openstack_password))
if err['status'] != 0:
# something happened during nova setup, re-run
return True
return False
def begin_deployment(self):
if self.config.is_multi():
# now all machines are added
self.maas.tag_fpi(self.maas.nodes)
self.maas.nodes_accept_all()
self.maas.tag_name(self.maas.nodes)
while not self.all_maas_machines_ready():
time.sleep(3)
self.add_machines_to_juju_multi()
elif self.config.is_single():
self.add_machines_to_juju_single()
# Quiet out some of the logging
_previous_summary = None
while not self.all_juju_machines_started():
sd = self.juju_state.machines_summary()
summary = ", ".join(["{} {}".format(v, k) for k, v
in sd.items()])
if summary != _previous_summary:
self.ui.status_info_message("Waiting for machines to "
"start: {}".format(summary))
_previous_summary = summary
async.sleep_until(1)
if len(self.juju_state.machines()) == 0:
raise Exception("Expected some juju machines started.")
self.config.setopt('current_state', ControllerState.SERVICES.value)
ppc = self.config.getopt("postproc_complete")
rc = self.config.getopt("relations_complete")
if not ppc or not rc:
if self.config.is_single():
controller_machine = self.juju_m_idmap['controller']
self.configure_lxc_network(controller_machine)
# Add second nic to VMS after lxc network
# is configured
if not self.config.getopt('attached_interfaces'):
for i in range(1, 4):
additional_iface_mac = utils.macgen()
cmd = ("virsh attach-interface --domain "
"ubuntu-local-machine-{} "
"--type bridge --source lxcbr0 --model virtio "
"--mac {} --config --live".format(
i,
additional_iface_mac))
log.debug("Adding second interface "
"to machine: {}".format(cmd))
out = utils.get_command_output(cmd)
log.debug("Result: {}".format(out))
utils.remote_run(
i,
cmds="sudo /sbin/sysctl -w net.ipv4.ip_forward=1",
juju_home=self.config.juju_home(
use_expansion=True))
self.config.setopt('attached_interfaces', True)
self.deploy_using_placement()
self.wait_for_deployed_services_ready()
self.enqueue_deployed_charms()
else:
self.ui.status_info_message("Ready")
