def _setup_chefserver(self):
"""
execute uploaded scripts to install chef, config knife, upload
cookbooks, roles, and environments
"""
for command in self.chefserver_commands:
cmd.ssh(self.user + "@" + self._chefserver_ip,
command, screen_output=True)
def _setup_chefserver(self):
"""
execute uploaded scripts to install chef, config knife, upload
cookbooks, roles, and environments
"""
for command in self.chefserver_commands:
cmd.ssh(self.user + "@" + self._chefserver_ip,
command,
screen_output=True)
def _setup_chefserver(self):
"""
execute uploaded scripts to install chef, config knife, upload
cookbooks, roles, and environments
"""
for key in self.chefserver_files:
out, error = cmd.ssh(self.user + '@' + self._chefserver_ip,
'/bin/bash ' + key,
screen_output=True)
print 'out=', out, 'error=', error
def _checkin_chefserver(self):
"""
check-in all VMs into chefserver (knife bootstrap), via eth0
"""
ips = ([self._chefserver_ip, self._gateway_ip, self._controller_ip]
+ self._worker_ips)
for ip in ips:
out, error = cmd.ssh(
self.user + '@' + self._chefserver_ip,
'/usr/bin/knife bootstrap %s -x %s --sudo' % (ip, self.user),
screen_output=True,
agent_forwarding=True)
print 'out=', out, 'error=', error
def _create_servers(self):
"""
start all VM servers: gateway, chefserver, controller, and workers, via
calling Nova client API
"""
# map image name to ID
image_id = None
chefserver_image_id = None
for image in self.client.images.list():
if image.name == self.image:
image_id = image.id
if image.name == self.chefserver_image:
chefserver_image_id = image.id
if image_id is None:
raise ValueError('Not found image=%s' % self.image)
if chefserver_image_id is None:
raise ValueError('Not found image=%s' % self.chefserver_image)
# map flavor name to ID
flavor_id = None
gateway_flavor_id = None
for flavor in self.client.flavors.list():
if flavor.name == self.flavor:
flavor_id = flavor.id
if flavor.name == self.gateway_flavor:
gateway_flavor_id = flavor.id
if flavor_id is None:
raise ValueError('Not found flavor=%s' % self.flavor)
if gateway_flavor_id is None:
raise ValueError('Not found flavor=%s' % self.gateway_flavor)
# launch gateway
gateway = self.client.servers.create(
name=self.prefix + CONCAT_CHAR + 'gateway',
image=image_id,
flavor=gateway_flavor_id,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._gateway_id = gateway.id
LOG.info("Creating %s", gateway)
# launch chefserver
chefserver = self.client.servers.create(
name=self.prefix + CONCAT_CHAR + 'chefserver',
image=chefserver_image_id,
flavor=flavor_id,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata,
files=self.chefserver_files)
self._chefserver_id = chefserver.id
LOG.info("Creating %s", chefserver)
# launch controller
controller = self.client.servers.create(
name=self.prefix + CONCAT_CHAR + 'controller',
image=image_id,
flavor=flavor_id,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._controller_id = controller.id
LOG.info("Creating %s", controller)
# launch workers
for i in xrange(self.num_workers):
worker = self.client.servers.create(
name=self.prefix + CONCAT_CHAR + 'worker%s' % (i + 1),
image=image_id,
flavor=flavor_id,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._worker_ids.append(worker.id)
LOG.info("Creating %s", worker)
LOG.info('wait at most %s seconds for servers to be ready'
' (ssh-able + userdata done)', self.timeout)
servers_ready = False
begin_time = time.time()
while time.time() - begin_time <= self.timeout:
try:
# get IP addr of servers
(self._gateway_ip, self._gateway_name) = self._get_server_info(
self._gateway_id)
(self._chefserver_ip, self._chefserver_name) = (
self._get_server_info(self._chefserver_id))
(self._controller_ip, self._controller_name) = (
self._get_server_info(self._controller_id))
# clear content upon each time retry
self._worker_ips = []
self._worker_names = []
for _id in self._worker_ids:
(ipaddr, name) = self._get_server_info(_id)
self._worker_ips.append(ipaddr)
self._worker_names.append(name)
# test ssh-able
command = '[ -d /etc/inception ]'
cmd.ssh(self.user + "@" + self._gateway_ip, command)
cmd.ssh(self.user + "@" + self._chefserver_ip, command)
cmd.ssh(self.user + "@" + self._controller_ip, command)
for worker_ip in self._worker_ips:
cmd.ssh(self.user + "@" + worker_ip, command)
# indicate that servers are ready
servers_ready = True
break
except (UnboundLocalError, subprocess.CalledProcessError) as error:
LOG.info('servers are not all ready, error=%s,'
' sleep %s seconds', error, self.poll_interval)
time.sleep(self.poll_interval)
continue
if not servers_ready:
raise RuntimeError("No all servers can be brought up")
# create a public IP and associate it to gateway
floating_ip = self.client.floating_ips.create(pool=self.pool)
self.client.servers.add_floating_ip(self._gateway_id, floating_ip)
self._gateway_floating_ip = floating_ip
LOG.info("Creating and associating %s", floating_ip)
def _create_servers(self):
"""
start all VM servers: gateway, chefserver, controller, and workers, via
calling Nova client API
"""
# launch gateway
gateway = self.client.servers.create(
name=self.prefix + '-gateway',
image=self.image,
flavor=self.gateway_flavor,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._gateway_id = gateway.id
print "%s is being created" % gateway.name
# launch chefserver
chefserver = self.client.servers.create(
name=self.prefix + '-chefserver',
image=self.image,
flavor=self.flavor,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata,
files=self.chefserver_files)
self._chefserver_id = chefserver.id
print "%s is being created" % chefserver.name
# launch controller
controller = self.client.servers.create(
name=self.prefix + '-controller',
image=self.image,
flavor=self.flavor,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._controller_id = controller.id
print "%s is being created" % controller.name
# launch workers
for i in xrange(self.num_workers):
worker = self.client.servers.create(
name=self.prefix + '-worker%s' % (i + 1),
image=self.image,
flavor=self.flavor,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._worker_ids.append(worker.id)
print 'name %s is being created' % worker.name
print ('wait at most %s seconds for servers to be ready (ssh-able)' %
self.timeout)
servers_ready = False
begin_time = time.time()
while time.time() - begin_time <= self.timeout:
try:
# get IP addr of servers
self._gateway_ip = self._get_server_ip(self._gateway_id)
self._chefserver_ip = self._get_server_ip(self._chefserver_id)
self._controller_ip = self._get_server_ip(self._controller_id)
self._worker_ips = [self._get_server_ip(_id)
for _id in self._worker_ids]
# test ssh-able
cmd.ssh(self.user + "@" + self._gateway_ip, 'true')
cmd.ssh(self.user + "@" + self._chefserver_ip, 'true')
cmd.ssh(self.user + "@" + self._controller_ip, 'true')
for worker_ip in self._worker_ips:
cmd.ssh(self.user + "@" + worker_ip, 'true')
# indicate that servers are ready
servers_ready = True
break
except (cmd.SshConnectionError, UnboundLocalError) as error:
print ('servers are not all ready, error=%s, sleep %s seconds'
% (error, self.poll_interval))
time.sleep(self.poll_interval)
continue
if not servers_ready:
raise RuntimeError("No all servers can be brought up")
# create a public IP and associate it to gateway
floating_ip = self.client.floating_ips.create()
self.client.servers.add_floating_ip(self._gateway_id, floating_ip)
self._gateway_floating_ip = floating_ip
def _create_servers(self):
"""
start all VM servers: gateway, chefserver, controller, and workers, via
calling Nova client API
"""
# map image name to ID
image_id = None
chefserver_image_id = None
for image in self.client.images.list():
if image.name == self.image:
image_id = image.id
if image.name == self.chefserver_image:
chefserver_image_id = image.id
if image_id is None:
raise ValueError('Not found image=%s' % self.image)
if chefserver_image_id is None:
raise ValueError('Not found image=%s' % self.chefserver_image)
# map flavor name to ID
flavor_id = None
gateway_flavor_id = None
for flavor in self.client.flavors.list():
if flavor.name == self.flavor:
flavor_id = flavor.id
if flavor.name == self.gateway_flavor:
gateway_flavor_id = flavor.id
if flavor_id is None:
raise ValueError('Not found flavor=%s' % self.flavor)
if gateway_flavor_id is None:
raise ValueError('Not found flavor=%s' % self.gateway_flavor)
# launch gateway
gateway = self.client.servers.create(
name=self.prefix + CONCAT_CHAR + 'gateway',
image=image_id,
flavor=gateway_flavor_id,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._gateway_id = gateway.id
LOG.info("Creating %s", gateway)
# launch chefserver
chefserver = self.client.servers.create(
name=self.prefix + CONCAT_CHAR + 'chefserver',
image=chefserver_image_id,
flavor=flavor_id,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata,
files=self.chefserver_files)
self._chefserver_id = chefserver.id
LOG.info("Creating %s", chefserver)
# launch controller
controller = self.client.servers.create(
name=self.prefix + CONCAT_CHAR + 'controller',
image=image_id,
flavor=flavor_id,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._controller_id = controller.id
LOG.info("Creating %s", controller)
# launch workers
for i in xrange(self.num_workers):
worker = self.client.servers.create(
name=self.prefix + CONCAT_CHAR + 'worker%s' % (i + 1),
image=image_id,
flavor=flavor_id,
key_name=self.key_name,
security_groups=self.security_groups,
userdata=self.userdata)
self._worker_ids.append(worker.id)
LOG.info("Creating %s", worker)
LOG.info(
'wait at most %s seconds for servers to be ready'
' (ssh-able + userdata done)', self.timeout)
servers_ready = False
begin_time = time.time()
while time.time() - begin_time <= self.timeout:
try:
# get IP addr of servers
(self._gateway_ip,
self._gateway_name) = self._get_server_info(self._gateway_id)
(self._chefserver_ip,
self._chefserver_name) = (self._get_server_info(
self._chefserver_id))
(self._controller_ip,
self._controller_name) = (self._get_server_info(
self._controller_id))
# clear content upon each time retry
self._worker_ips = []
self._worker_names = []
for _id in self._worker_ids:
(ipaddr, name) = self._get_server_info(_id)
self._worker_ips.append(ipaddr)
self._worker_names.append(name)
# test ssh-able
command = '[ -d /etc/inception ]'
cmd.ssh(self.user + "@" + self._gateway_ip, command)
cmd.ssh(self.user + "@" + self._chefserver_ip, command)
cmd.ssh(self.user + "@" + self._controller_ip, command)
for worker_ip in self._worker_ips:
cmd.ssh(self.user + "@" + worker_ip, command)
# indicate that servers are ready
servers_ready = True
break
except (UnboundLocalError, subprocess.CalledProcessError) as error:
LOG.info(
'servers are not all ready, error=%s,'
' sleep %s seconds', error, self.poll_interval)
time.sleep(self.poll_interval)
continue
if not servers_ready:
raise RuntimeError("No all servers can be brought up")
# create a public IP and associate it to gateway
floating_ip = self.client.floating_ips.create(pool=self.pool)
self.client.servers.add_floating_ip(self._gateway_id, floating_ip)
self._gateway_floating_ip = floating_ip
LOG.info("Creating and associating %s", floating_ip)
