def _create(self, volume, snapshot, snap_lv, tranzit_path, complete_cb):
try:
chunk_prefix = '%s.data' % snapshot.id
snapshot.path = None
snap_mpoint = mkdtemp()
try:
opts = []
if volume.fstype == 'xfs':
opts += ['-o', 'nouuid,ro']
mount(snap_lv, snap_mpoint, opts)
tar_cmd = ['tar', 'cp', '-C', snap_mpoint, '.']
pigz_bins = whereis('pigz')
compress_cmd = [pigz_bins[0] if pigz_bins else 'gzip', '-5']
self._logger.debug("Creating and compressing snapshot data.")
tar = subprocess.Popen(tar_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
compress = subprocess.Popen(compress_cmd, stdin=tar.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
tar.stdout.close() # Allow tar to receive a SIGPIPE if compress exits.
split = threading.Thread(target=self._split, name='split',
args=(compress.stdout, tranzit_path, chunk_prefix, snapshot))
split.start()
uploaders = []
for i in range(2):
uploader = threading.Thread(name="Uploader-%s" % i, target=self._uploader,
args=(volume.snap_backend['path'], snapshot))
self._logger.debug("Starting uploader '%s'", uploader.getName())
uploader.start()
uploaders.append(uploader)
self._logger.debug('uploaders started. waiting compress')
compress.wait()
self._logger.debug('compress completed (code: %s). waiting split', compress.returncode)
if compress.returncode:
raise StorageError('Compress process terminated with exit code %s. <err>: %s' % (compress.returncode, compress.stderr.read()))
split.join()
self._logger.debug('split completed. waiting uploaders')
for uploader in uploaders:
uploader.join()
self._logger.debug('uploaders completed')
if self._inner_exc_info:
t, e, s = self._inner_exc_info
raise t, e, s
finally:
self._return_ev.set()
umount(snap_mpoint, options=('-f',))
os.rmdir(snap_mpoint)
self._lvm.remove_lv(snap_lv)
self._inner_exc_info = None
self._state_map[snapshot.id] = Snapshot.COMPLETED
except (Exception, BaseException), e:
self._state_map[snapshot.id] = Snapshot.FAILED
self._logger.exception('Snapshot creation failed. %s' % e)
def on_init(self, *args, **kwargs):
bus.on("before_hello", self.on_before_hello)
bus.on("before_host_init", self.on_before_host_init)
bus.on("before_restart", self.on_before_restart)
msg_service = bus.messaging_service
producer = msg_service.get_producer()
producer.on("before_send", self.on_before_message_send)
# Set the hostname to this instance's public hostname
cnf = bus.cnf
try:
hostname_as_pubdns = int(cnf.rawini.get('ec2', 'hostname_as_pubdns'))
except ConfigParser.Error:
hostname_as_pubdns = True
if hostname_as_pubdns:
system2("hostname " + self._platform.get_public_hostname(), shell=True)
if disttool.is_ubuntu():
# Ubuntu cloud-init scripts may disable root ssh login
for path in ('/etc/ec2-init/ec2-config.cfg', '/etc/cloud/cloud.cfg'):
if os.path.exists(path):
c = filetool.read_file(path)
c = re.sub(re.compile(r'^disable_root[^:=]*([:=]).*', re.M), r'disable_root\1 0', c)
filetool.write_file(path, c)
# Add server ssh public key to authorized_keys
authorized_keys_path = "/root/.ssh/authorized_keys"
if os.path.exists(authorized_keys_path):
c = filetool.read_file(authorized_keys_path)
ssh_key = self._platform.get_ssh_pub_key()
idx = c.find(ssh_key)
if idx == -1:
if c and c[-1] != '\n':
c += '\n'
c += ssh_key + "\n"
self._logger.debug("Add server ssh public key to authorized_keys")
filetool.write_file(authorized_keys_path, c)
elif idx > 0 and c[idx-1] != '\n':
c = c[0:idx] + '\n' + c[idx:]
self._logger.warn('Adding new-line character before server SSH key in authorized_keys file')
filetool.write_file(authorized_keys_path, c)
# Mount ephemeral devices
# Seen on eucalyptus:
# - fstab contains invalid fstype and `mount -a` fails
mtab = Mtab()
fstab = Fstab()
for device in self._platform.instance_store_devices:
if os.path.exists(device) and fstab.contains(device) and not mtab.contains(device):
entry = fstab.find(device)[0]
try:
mount(device, entry.mpoint, ('-o', entry.options))
except:
self._logger.warn(sys.exc_info()[1])
def _create_attach_mount_volume(self, size=None, auto_mount=False, snapshot=None, mpoint=None, mkfs=True): pl = cassandra.platform ec2_conn = pl.new_ec2_conn() # Create volume vol = ebstool.create_volume(ec2_conn, size, pl.get_avail_zone(), snapshot, self._logger) # Attach devname = get_free_devname() devname = ebstool.attach_volume(ec2_conn, vol, pl.get_instance_id(), devname, to_me=True, logger=self._logger)[1] # Mount fstool.mount(devname, mpoint, make_fs=mkfs, auto_mount=auto_mount) del(ec2_conn) return devname, vol
def post_handle_request(self): if self.umounted: fstool.mount(self.device_name, cassandra.storage_path) cassandra.start_service()
def _mount_image(self, options=None):
LOG.info("Mounting image")
if self._mtab.contains(mpoint=self.mpoint):
raise HandlerError("Image already mounted")
fstool.mount(self.devname, self.mpoint, options)
def rebundle(self):
rebundle_dir = tempfile.mkdtemp()
try:
pl = bus.platform
proj_id = pl.get_numeric_project_id()
proj_name = pl.get_project_id()
cloudstorage = pl.new_storage_client()
tmp_mount_dir = os.path.join(rebundle_dir, 'root')
os.makedirs(tmp_mount_dir)
image_name = 'disk.raw'
image_path = os.path.join(rebundle_dir, image_name)
root = filter(lambda x: x.mpoint == '/', filetool.df())[0]
LOG.debug('Creating image file %s' % image_path)
with open(image_path, 'w') as f:
f.truncate(root.size*1024 + 1*1024)
try:
LOG.debug('Creating partition table on image')
system2(('parted', image_path, 'mklabel', 'msdos'))
system2(('parted', image_path, 'mkpart', 'primary', 'ext2', 1, str(root.size/1024)))
# Map disk image
out = system2(('kpartx', '-av', image_path))[0]
try:
loop = re.search('(/dev/loop\d+)', out).group(1)
root_dev_name = '/dev/mapper/%sp1' % loop.split('/')[-1]
LOG.info('Creating filesystem')
fstool.mkfs(root_dev_name, 'ext4')
dev_uuid = uuid.uuid4()
system2(('tune2fs', '-U', str(dev_uuid), root_dev_name))
fstool.mount(root_dev_name, tmp_mount_dir)
try:
lines = system2(('/bin/mount', '-l'))[0].splitlines()
exclude_dirs = set()
for line in lines:
mpoint = line.split()[2]
if mpoint != '/':
exclude_dirs.add(mpoint)
exclude_dirs.update(self.exclude_dirs)
rsync = filetool.Rsync()
rsync.source('/').dest(tmp_mount_dir).sparse()
rsync.hardlinks().archive().times()
rsync.exclude([os.path.join(ex, '**') for ex in exclude_dirs])
rsync.exclude(self.exclude_files)
rsync.exclude(self._excludes)
LOG.info('Copying root filesystem to image')
rsync.execute()
LOG.info('Cleanup image')
self._create_spec_devices(tmp_mount_dir)
LOG.debug('Removing roles-builder user')
sh = pexpect.spawn('/bin/sh')
try:
sh.sendline('chroot %s' % tmp_mount_dir)
sh.expect('#')
sh.sendline('userdel -rf %s' % ROLEBUILDER_USER)
sh.expect('#')
finally:
sh.close()
""" Patch fstab"""
fstab_path = os.path.join(tmp_mount_dir, 'etc/fstab')
if os.path.exists(fstab_path):
with open(fstab_path) as f:
fstab = f.read()
new_fstab = re.sub('UUID=\S+\s+/\s+(.*)', 'UUID=%s / \\1' % dev_uuid, fstab)
with open(fstab_path, 'w') as f:
f.write(new_fstab)
finally:
fstool.umount(device=root_dev_name)
finally:
system2(('kpartx', '-d', image_path))
LOG.info('Compressing image.')
arch_name = '%s.tar.gz' % self._role_name.lower()
arch_path = os.path.join(rebundle_dir, arch_name)
tar = filetool.Tar()
tar.create().gzip().sparse()
tar.archive(arch_path)
tar.add(image_name, rebundle_dir)
system2(str(tar), shell=True)
finally:
os.unlink(image_path)
try:
LOG.info('Uploading compressed image to cloud storage')
uploader = transfer.Transfer(logger=LOG)
tmp_bucket_name = 'scalr-images-%s-%s' % (
random.randint(1,1000000), int(time.time()))
try:
remote_path = 'gcs://%s/' % tmp_bucket_name
uploader.upload((arch_path,), remote_path)
except:
try:
objs = cloudstorage.objects()
objs.delete(bucket=tmp_bucket_name, object=arch_name).execute()
except:
pass
cloudstorage.buckets().delete(bucket=tmp_bucket_name).execute()
raise
finally:
os.unlink(arch_path)
finally:
shutil.rmtree(rebundle_dir)
try:
goog_image_name = self._role_name.lower().replace('_', '-')
LOG.info('Registering new image %s' % goog_image_name)
# TODO: check duplicate names
compute = pl.new_compute_client()
image_url = 'http://storage.googleapis.com/%s/%s' % (
tmp_bucket_name, arch_name)
req_body = dict(
name=goog_image_name,
sourceType='RAW',
rawDisk=dict(
containerType='TAR',
source=image_url
)
)
req = compute.images().insert(project=proj_id, body=req_body)
operation = req.execute()['name']
LOG.info('Waiting for image to register')
def image_is_ready():
req = compute.operations().get(project=proj_id, operation=operation)
res = req.execute()
if res['status'] == 'DONE':
if res.get('error'):
errors = []
for e in res['error']['errors']:
err_text = '%s: %s' % (e['code'], e['message'])
errors.append(err_text)
raise Exception('\n'.join(errors))
return True
return False
wait_until(image_is_ready, logger=LOG, timeout=600)
finally:
objs = cloudstorage.objects()
objs.delete(bucket=tmp_bucket_name, object=arch_name).execute()
cloudstorage.buckets().delete(bucket=tmp_bucket_name).execute()
return '%s/images/%s' % (proj_name, goog_image_name)
