def download_image(self, image):
"""
Creates a stream for image data
:param image: Image object for downloading
:return: stream of image data
"""
LOG.debug("Download image enter")
stream = self.get_glance().images.data(image.id)
LOG.debug("Stream with size {0}".format(image.size))
return utils.ReSizeStream(stream, image.size, 1000000)
def restore_level(self, restore_resource, read_pipe, backup, except_queue):
try:
metadata = backup.metadata()
if (not self.encrypt_pass_file
and metadata.get("encryption", False)):
raise Exception("Cannot restore encrypted backup without key")
engine_metadata = backup.engine_metadata()
image_info = metadata.get('image', {})
container_format = image_info.get('container_format', 'bare')
disk_format = image_info.get('disk_format', 'raw')
length = int(engine_metadata.get('length'))
stream = self.stream_image(read_pipe)
data = utils.ReSizeStream(stream, length, 1)
image = self.client.create_image("Restore: {0}".format(
image_info.get('name', image_info.get('id', None))),
container_format,
disk_format,
data=data)
if self.encrypt_pass_file:
try:
tmpdir = tempfile.mkdtemp()
except Exception:
LOG.error("Unable to create a tmp directory")
raise
tar_engine = tar.TarEngine(self.compression_algo,
self.dereference_symlink,
self.exclude, self.storage,
self.max_segment_size,
self.encrypt_pass_file,
self.dry_run)
tar_engine.restore_level(tmpdir, read_pipe, backup,
except_queue)
utils.wait_for(
GlanceEngine.image_active,
1,
CONF.timeout,
message="Waiting for image to finish uploading {0} and become"
" active".format(image.id),
kwargs={
"glance_client": self.glance,
"image_id": image.id
})
return image
except Exception as e:
LOG.exception(e)
except_queue.put(e)
raise
def restore_level(self, restore_resource, read_pipe, backup, except_queue):
try:
metadata = backup.metadata()
engine_metadata = backup.engine_metadata()
server_info = metadata.get('server', {})
length = int(engine_metadata.get('length'))
available_networks = server_info.get('addresses')
nova_networks = self.nova.networks.findall()
net_names = [
network for network, _ in available_networks.iteritems()
]
match_networks = [{
"net-id": network.id
} for network in nova_networks
if network.to_dict().get('label') in net_names]
stream = self.stream_image(read_pipe)
data = utils.ReSizeStream(stream, length, 1)
image = self.client.create_image("Restore: {0}".format(
server_info.get('name', server_info.get('id', None))),
'bare',
'raw',
data=data)
utils.wait_for(
NovaEngine.image_active,
1,
CONF.timeout,
message="Waiting for image to finish uploading {0} and become"
" active".format(image.id),
kwargs={
"glance_client": self.glance,
"image_id": image.id
})
server = self.nova.servers.create(
name=server_info.get('name'),
flavor=server_info['flavor']['id'],
image=image.id,
nics=match_networks)
return server
except Exception as e:
LOG.exception(e)
except_queue.put(e)
raise
def _create_image(self, path, restore_from_timestamp):
"""
:param path:
:param restore_from_timestamp:
:type restore_from_timestamp: int
:return:
"""
swift = self.client_manager.get_swift()
glance = self.client_manager.get_glance()
backup = self._get_backups(path, restore_from_timestamp)
stream = swift.get_object(self.container,
"%s/%s" % (path, backup),
resp_chunk_size=10000000)
length = int(stream[0]["x-object-meta-length"])
logging.info("[*] Creation glance image")
image = glance.images.create(data=utils.ReSizeStream(
stream[1], length, 1),
container_format="bare",
disk_format="raw")
return stream[0], image
def _create_image(self, path, restore_from_timestamp):
"""
:param path:
:param restore_from_timestamp:
:type restore_from_timestamp: int
:return:
"""
swift = self.client_manager.get_swift()
glance = self.client_manager.get_glance()
backup = self._get_backups(path, restore_from_timestamp)
path = "{0}_segments/{1}/{2}".format(self.container, path, backup)
stream = swift.get_object(self.container,
"%s/%s" % (path, backup),
resp_chunk_size=10000000)
length = int(stream[0]["x-object-meta-length"])
LOG.info("Creation glance image")
image = glance.images.create(container_format="bare",
disk_format="raw")
glance.images.upload(image.id,
utils.ReSizeStream(stream[1], length, 1))
return stream[0], image
def _create_image(self, path, restore_from_timestamp):
"""
:param path:
:param restore_from_timestamp:
:type restore_from_timestamp: int
:return:
"""
backup = self._get_backups(path, restore_from_timestamp)
if self.storage.type == 'swift':
swift = self.client_manager.get_swift()
path = "{0}_segments/{1}/{2}".format(self.container, path, backup)
stream = swift.get_object(self.container,
"{}/{}".format(path, backup),
resp_chunk_size=10000000)
length = int(stream[0]["x-object-meta-length"])
data = utils.ReSizeStream(stream[1], length, 1)
info = stream[0]
image = self.client_manager.create_image(
name="restore_{}".format(path),
container_format="bare",
disk_format="raw",
data=data)
return info, image
elif self.storage.type == 's3':
if self.storage.get_object_prefix() != '':
base_path = "{0}/{1}/{2}".format(
self.storage.get_object_prefix(), path, backup)
else:
base_path = "{0}/{1}".format(path, backup)
image_file = "{0}/{1}".format(base_path, path)
s3_object = self.storage.get_object(
bucket_name=self.storage.get_bucket_name(), key=image_file)
stream = utils.S3ResponseStream(data=s3_object['Body'],
chunk_size=10000000)
data = utils.ReSizeStream(stream, s3_object['ContentLength'], 1)
metadata = "{0}/metadata".format(base_path)
metadata_object = self.storage.get_object(
bucket_name=self.storage.get_bucket_name(), key=metadata)
info = json.load(metadata_object['Body'])
image = self.client_manager.create_image(
name="restore_{}".format(path),
container_format="bare",
disk_format="raw",
data=data)
return info, image
elif self.storage.type == 'local':
image_file = "{0}/{1}/{2}/{3}".format(self.container, path, backup,
path)
metadata_file = "{0}/{1}/{2}/metadata".format(
self.container, path, backup)
try:
data = open(image_file, 'rb')
except Exception:
msg = "Failed to open image file {}".format(image_file)
LOG.error(msg)
raise BaseException(msg)
info = json.load(open(metadata_file, 'r'))
image = self.client_manager.create_image(
name="restore_{}".format(path),
container_format="bare",
disk_format="raw",
data=data)
return info, image
elif self.storage.type == 'ssh':
image_file = "{0}/{1}/{2}/{3}".format(self.container, path, backup,
path)
metadata_file = "{0}/{1}/{2}/metadata".format(
self.container, path, backup)
try:
data = self.storage.open(image_file, 'rb')
except Exception:
msg = "Failed to open remote image file {}".format(image_file)
LOG.error(msg)
raise BaseException(msg)
info = json.loads(self.storage.read_metadata_file(metadata_file))
image = self.client_manager.create_image(
name="restore_{}".format(path),
container_format="bare",
disk_format="raw",
data=data)
return info, image
elif self.storage.type in ['ftp', 'ftps']:
image_file = "{0}/{1}/{2}/{3}".format(self.container, path, backup,
path)
metadata_file = "{0}/{1}/{2}/metadata".format(
self.container, path, backup)
try:
tmpdir = tempfile.mkdtemp()
except Exception:
LOG.error("Unable to create a tmp directory")
raise
try:
data_image = utils.path_join(tmpdir, "data_image")
LOG.info('create image restore ftp storage')
self.storage.get_file(image_file, data_image)
data_meta = utils.path_join(tmpdir, "data_meta")
self.storage.get_file(metadata_file, data_meta)
data = open(data_image, 'rb')
info = json.load(open(data_meta, 'r'))
image = self.client_manager.create_image(
name="restore_{}".format(path),
container_format="bare",
disk_format="raw",
data=data)
return info, image
finally:
shutil.rmtree(tmpdir)
else:
return {}
def restore_level(self, restore_resource, read_pipe, backup, except_queue):
try:
metadata = backup.metadata()
if (not self.encrypt_pass_file
and metadata.get("encryption", False)):
raise Exception("Cannot restore encrypted backup without key")
engine_metadata = backup.engine_metadata()
server_info = metadata.get('server', {})
length = int(engine_metadata.get('length'))
available_networks = server_info.get('addresses')
nova_networks = self.neutron.list_networks()['networks']
net_names = [
network for network, _ in available_networks.iteritems()
]
match_networks = [{
"net-id": network.get('id')
} for network in nova_networks if network.get('name') in net_names]
stream = self.stream_image(read_pipe)
data = utils.ReSizeStream(stream, length, 1)
image = self.client.create_image("Restore: {0}".format(
server_info.get('name', server_info.get('id', None))),
'bare',
'raw',
data=data)
if self.encrypt_pass_file:
try:
tmpdir = tempfile.mkdtemp()
except Exception:
LOG.error("Unable to create a tmp directory")
raise
tar_engine = tar.TarEngine(self.compression_algo,
self.dereference_symlink,
self.exclude, self.storage,
self.max_segment_size,
self.encrypt_pass_file,
self.dry_run)
tar_engine.restore_level(tmpdir, read_pipe, backup,
except_queue)
utils.wait_for(
NovaEngine.image_active,
1,
CONF.timeout,
message="Waiting for image to finish uploading {0} and become"
" active".format(image.id),
kwargs={
"glance_client": self.glance,
"image_id": image.id
})
server = self.nova.servers.create(
name=server_info.get('name'),
flavor=server_info['flavor']['id'],
image=image.id,
nics=match_networks)
return server
except Exception as e:
LOG.exception(e)
except_queue.put(e)
raise
def _create_image(self, path, restore_from_timestamp):
"""
:param path:
:param restore_from_timestamp:
:type restore_from_timestamp: int
:return:
"""
swift = self.client_manager.get_swift()
backup = self._get_backups(path, restore_from_timestamp)
if self.storage.type == 'swift':
path = "{0}_segments/{1}/{2}".format(self.container, path, backup)
stream = swift.get_object(self.container,
"{}/{}".format(path, backup),
resp_chunk_size=10000000)
length = int(stream[0]["x-object-meta-length"])
data = utils.ReSizeStream(stream[1], length, 1)
info = stream[0]
image = self.client_manager.create_image(
name="restore_{}".format(path),
container_format="bare",
disk_format="raw",
data=data)
return info, image
elif self.storage.type == 'local':
image_file = "{0}/{1}/{2}/{3}".format(self.container, path, backup,
path)
metadata_file = "{0}/{1}/{2}/metadata".format(
self.container, path, backup)
try:
data = open(image_file, 'rb')
except Exception:
msg = "Failed to open image file {}".format(image_file)
LOG.error(msg)
raise BaseException(msg)
info = json.load(file(metadata_file))
image = self.client_manager.create_image(
name="restore_{}".format(path),
container_format="bare",
disk_format="raw",
data=data)
return info, image
elif self.storage.type == 'ssh':
image_file = "{0}/{1}/{2}/{3}".format(self.container, path, backup,
path)
metadata_file = "{0}/{1}/{2}/metadata".format(
self.container, path, backup)
try:
data = self.storage.open(image_file, 'rb')
except Exception:
msg = "Failed to open remote image file {}".format(image_file)
LOG.error(msg)
raise BaseException(msg)
info = json.loads(self.storage.read_metadata_file(metadata_file))
image = self.client_manager.create_image(
name="restore_{}".format(path),
container_format="bare",
disk_format="raw",
data=data)
return info, image
else:
return {}
