| #!/usr/bin/env python3 | |
| # | |
| # Doing anything in Alibaba Cloud is unnecessarily difficult and | |
| # tedious due to a combination of poor and inconsistent API design, | |
| # high API call failure rates, and Chinese state censorship laws. | |
| # | |
| # We resort to a mixture of strategies to get images imported to all | |
| # regions: | |
| # | |
| # - For regions with working OSS that are not blocked by Chinese | |
| # state censorship laws, upload the image files to an OSS bucket | |
| # and then import the images. | |
| # | |
| # - For regions with working OSS that are blocked by Chinese state | |
| # censorship laws but that have working FC, use a temporary FC | |
| # function to copy the image files from the uncensored OSS buckets | |
| # and then import the images. Attempt downloads from a variety of | |
| # uncensored buckets, since cross-region OSS traffic tends to | |
| # experience a failure rate of around 10% of requests. | |
| # | |
| # - For regions that have working OSS but are blocked by Chinese | |
| # state censorship laws and do not have working FC, or for regions | |
| # that don't even have working OSS, resort to using CopyImage to | |
| # copy the previously imported images from another region. Spread | |
| # the imports across as many source regions as possible to | |
| # minimise the effect of the CopyImage rate limiting. | |
| import argparse | |
| import base64 | |
| from collections import namedtuple | |
| from concurrent.futures import ThreadPoolExecutor, as_completed | |
| import datetime | |
| import http | |
| import io | |
| from itertools import cycle, groupby | |
| import json | |
| import logging | |
| from operator import itemgetter | |
| from pathlib import Path | |
| import random | |
| import subprocess | |
| import tempfile | |
| import time | |
| from uuid import uuid4 | |
| import zipfile | |
| import alibabacloud_credentials as credentials | |
| import alibabacloud_credentials.client | |
| import alibabacloud_credentials.models | |
| import alibabacloud_ecs20140526 as ecs | |
| import alibabacloud_ecs20140526.client | |
| import alibabacloud_ecs20140526.models | |
| import alibabacloud_fc20230330 as fc | |
| import alibabacloud_fc20230330.client | |
| import alibabacloud_fc20230330.models | |
| import alibabacloud_oss_v2 as oss | |
| import alibabacloud_ram20150501 as ram | |
| import alibabacloud_ram20150501.client | |
| import alibabacloud_ram20150501.models | |
| import alibabacloud_sts20150401 as sts | |
| import alibabacloud_sts20150401.client | |
| import alibabacloud_sts20150401.models | |
| import alibabacloud_tea_openapi as openapi | |
| import alibabacloud_tea_openapi.client | |
| import alibabacloud_tea_openapi.models | |
| import alibabacloud_tea_util as util | |
| import alibabacloud_tea_util.client | |
| import alibabacloud_tea_util.models | |
| logger = logging.getLogger('ali-import') | |
| ECS_ENDPOINT = 'ecs.aliyuncs.com' | |
| RAM_ENDPOINT = 'ram.aliyuncs.com' | |
| STS_ENDPOINT = 'sts.aliyuncs.com' | |
| FC_NODE_RUNTIME = 'nodejs20' | |
| FC_TIMEOUT_SEC = 120 | |
| FC_MEMORY_SIZE_MB = 128 | |
| FC_SOURCE_COUNT = 10 | |
| OSS_FORBIDDEN_REGION_CODE = 'ForbidCreateNewBucket' | |
| OSS_BUCKET_NAME_LEN = 63 | |
| IPXE_STORAGE_PREFIX = 'ipxe-upload-temp-' | |
| IPXE_SNAPSHOT_DELETE_TAG = 'ipxe-snapshot-delete' | |
| POLL_INTERVAL_SEC = 5 | |
| POLL_MAX_RETRIES = 100 | |
| # Experimentation suggests Alibaba Cloud API calls are extremely | |
| # unreliable, with a failure rate around 1%. It is therefore | |
| # necessary to allow for retrying basically every API call. | |
| # | |
| # Some API calls (e.g. DescribeImages or ModifyImageAttribute) are | |
| # naturally idempotent and so safe to retry. Some non-idempotent API | |
| # calls (e.g. CopyImage) support explicit idempotence tokens. The | |
| # remaining API calls may simply fail on a retry, if the original | |
| # request happened to succeed but failed to return a response. | |
| # | |
| # We could write convoluted retry logic around the non-idempotent | |
| # calls, but this would substantially increase the complexity of the | |
| # already unnecessarily complex code. For now, we assume that | |
| # retrying non-idempotent requests is probably more likely to fix | |
| # transient failures than to cause additional problems. | |
| # | |
| RUNTIME_OPTS = util.models.RuntimeOptions( | |
| autoretry=True, | |
| max_attempts=5, | |
| connect_timeout=10000, | |
| read_timeout=120000, | |
| ) | |
| # For regions in mainland China, the Chinese state censorship laws | |
| # prohibit direct access to OSS bucket contents. | |
| # | |
| # We work around this restriction by creating a temporary Function | |
| # Compute function in each region to access OSS via the internal OSS | |
| # endpoints, which are not subject to these restrictions. Yes, this | |
| # is somewhat absurd. | |
| # | |
| IPXE_CENSORSHIP_BYPASS_FUNCTION = f''' | |
| const prefix = "{IPXE_STORAGE_PREFIX}"; | |
| ''' + ''' | |
| const assert = require("node:assert"); | |
| const OSS = require("ali-oss"); | |
| exports.handler = async (event, context) => { | |
| const payload = JSON.parse(event.toString()); | |
| console.log(JSON.stringify(payload)); | |
| const sources = payload.sources || {}; | |
| const dest = new OSS({ | |
| region: "oss-" + context.region, | |
| internal: true, | |
| bucket: payload.bucket, | |
| accessKeyId: context.credentials.accessKeyId, | |
| accessKeySecret: context.credentials.accessKeySecret, | |
| stsToken: context.credentials.securityToken, | |
| }); | |
| const current = ((await dest.listV2({prefix: prefix})).objects || []) | |
| .map(x => x.name); | |
| const wanted = Object.keys(sources); | |
| const add = wanted.filter(x => ! current.includes(x)); | |
| const del = current.filter(x => ! wanted.includes(x)); | |
| assert(add.every(x => x.startsWith(prefix))); | |
| assert(del.every(x => x.startsWith(prefix))); | |
| if (add.length) | |
| console.log("Creating: " + add.sort().join(", ")); | |
| if (del.length) | |
| console.log("Deleting: " + del.sort().join(", ")); | |
| const copy = async (key) => { | |
| for (const url of sources[key]) { | |
| console.log("Downloading " + key + " from " + url); | |
| try { | |
| const download = await fetch(url, {signal: AbortSignal.timeout(15000)}); | |
| if (! download.ok) | |
| throw new Error(download.status); | |
| const content = await download.arrayBuffer(); | |
| console.log("Downloaded " + key); | |
| console.log("Uploading " + key); | |
| await dest.put(key, Buffer.from(content)); | |
| console.log("Uploaded " + key); | |
| return; | |
| } catch (err) { | |
| console.error("Download failed", err); | |
| } | |
| } | |
| throw new Error("All downloads failed for " + key); | |
| }; | |
| await Promise.all([ | |
| ...add.map(copy), | |
| ...(del.length ? [dest.deleteMulti(del)] : []), | |
| ]); | |
| console.log("Finished"); | |
| }; | |
| ''' | |
| Clients = namedtuple('Clients', ['region', 'censored', 'ecs', 'fc', 'oss']) | |
| Image = namedtuple('Image', | |
| ['path', 'family', 'name', 'arch', 'mode', 'key', 'public']) | |
| def image(filename, basefamily, basename, public): | |
| """Construct image description""" | |
| with tempfile.NamedTemporaryFile(mode='w+t') as mtoolsrc: | |
| mtoolsrc.writelines([ | |
| 'drive D:', f'file="{filename}"', | |
| 'drive P:', f'file="{filename}"', 'partition=4', | |
| ]) | |
| mtoolsrc.flush() | |
| mdir = subprocess.run(['mdir', '-b', 'D:/EFI/BOOT', 'P:/EFI/BOOT'], | |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE, | |
| check=False, env={'MTOOLSRC': mtoolsrc.name}) | |
| mapping = { | |
| b'BOOTX64.EFI': 'x86_64', | |
| b'BOOTAA64.EFI': 'arm64', | |
| } | |
| uefi = [v for k, v in mapping.items() if k in mdir.stdout] | |
| suffix = ('-uefi-%s' % uefi[0].replace('_', '-') if len(uefi) == 1 else | |
| '-uefi-multi' if uefi else '') | |
| path = Path(filename) | |
| family = '%s%s' % (basefamily, suffix) | |
| name = '%s%s' % (basename, suffix) | |
| arch = uefi[0] if len(uefi) == 1 else None if uefi else 'x86_64' | |
| mode = 'UEFI' if uefi else 'BIOS' | |
| key = '%s%s' % (IPXE_STORAGE_PREFIX, uuid4()) | |
| return Image(path, family, name, arch, mode, key, public) | |
| def all_regions(): | |
| """Get list of all regions""" | |
| cred = credentials.client.Client() | |
| conf = openapi.models.Config(credential=cred, endpoint=ECS_ENDPOINT) | |
| client = ecs.client.Client(conf) | |
| req = ecs.models.DescribeRegionsRequest() | |
| rsp = client.describe_regions(req) | |
| regions = sorted(x.region_id for x in rsp.body.regions.region) | |
| return regions | |
| def account_id(): | |
| """Get account ID""" | |
| cred = credentials.client.Client() | |
| conf = openapi.models.Config(credential=cred, endpoint=STS_ENDPOINT) | |
| client = sts.client.Client(conf) | |
| rsp = client.get_caller_identity() | |
| return rsp.body.account_id | |
| def role_arn(name): | |
| """Get role resource name""" | |
| cred = credentials.client.Client() | |
| conf = openapi.models.Config(credential=cred, endpoint=RAM_ENDPOINT) | |
| client = ram.client.Client(conf) | |
| req = ram.models.GetRoleRequest(role_name=name) | |
| rsp = client.get_role(req) | |
| return rsp.body.role.arn | |
| def all_clients(region, account): | |
| """Construct all per-region clients""" | |
| cred = credentials.client.Client() | |
| ecsconf = openapi.models.Config(credential=cred, region_id=region) | |
| fcep = '%s.%s.fc.aliyuncs.com' % (account, region) | |
| fcconf = openapi.models.Config(credential=cred, endpoint=fcep) | |
| osscred = oss.credentials.EnvironmentVariableCredentialsProvider() | |
| ossconf = oss.config.Config(credentials_provider=osscred, region=region) | |
| clients = Clients( | |
| region=region, | |
| censored=region.startswith('cn-'), | |
| ecs=ecs.client.Client(ecsconf), | |
| fc=fc.client.Client(fcconf), | |
| oss=oss.client.Client(ossconf), | |
| ) | |
| return clients | |
| def delete_temp_function(clients, func): | |
| """Remove temporary function""" | |
| logger.info("delete function %s %s" % (clients.region, func)) | |
| assert func.startswith(IPXE_STORAGE_PREFIX) | |
| clients.fc.delete_function_with_options(func, {}, RUNTIME_OPTS) | |
| def create_temp_function(clients, role): | |
| """Create temporary function (and remove any stale temporary functions)""" | |
| req = fc.models.ListFunctionsRequest(prefix=IPXE_STORAGE_PREFIX) | |
| try: | |
| rsp = clients.fc.list_functions_with_options(req, {}, RUNTIME_OPTS) | |
| except openapi.client.UnretryableException: | |
| # AliCloud provides no other way to detect non-working regions | |
| return None | |
| funcs = [x.function_name for x in rsp.body.functions or ()] | |
| for func in funcs: | |
| delete_temp_function(clients, func) | |
| if not clients.censored: | |
| # Functions are not required in uncensored regions | |
| return None | |
| buf = io.BytesIO() | |
| with zipfile.ZipFile(buf, 'w') as zfh: | |
| zfh.writestr('index.js', IPXE_CENSORSHIP_BYPASS_FUNCTION) | |
| zf = base64.b64encode(buf.getvalue()).decode() | |
| code = fc.models.InputCodeLocation(zip_file=zf) | |
| func = '%s%s' % (IPXE_STORAGE_PREFIX, uuid4()) | |
| body = fc.models.CreateFunctionInput( | |
| code=code, | |
| function_name=func, | |
| handler='index.handler', | |
| memory_size=FC_MEMORY_SIZE_MB, | |
| role=role, | |
| runtime=FC_NODE_RUNTIME, | |
| timeout=FC_TIMEOUT_SEC, | |
| ) | |
| req = fc.models.CreateFunctionRequest(body=body) | |
| rsp = clients.fc.create_function_with_options(req, {}, RUNTIME_OPTS) | |
| logger.info("create function %s %s" % (clients.region, func)) | |
| return func | |
| def call_temp_function(clients, func, payload): | |
| """Call temporary function""" | |
| hdr = fc.models.InvokeFunctionHeaders( | |
| x_fc_invocation_type='Sync', | |
| x_fc_log_type='Tail', | |
| ) | |
| body = json.dumps(payload) | |
| req = fc.models.InvokeFunctionRequest(body=body) | |
| rsp = clients.fc.invoke_function_with_options(func, req, hdr, RUNTIME_OPTS) | |
| log = base64.b64decode(rsp.headers.get('x-fc-log-result', b'')).decode() | |
| if rsp.status_code != http.HTTPStatus.OK: | |
| raise RuntimeError(rsp) | |
| if 'x-fc-error-type' in rsp.headers: | |
| raise RuntimeError(log) | |
| def delete_temp_bucket(clients, func, bucket): | |
| """Remove temporary bucket""" | |
| logger.info("delete bucket %s %s" % (clients.region, bucket)) | |
| assert bucket.startswith(IPXE_STORAGE_PREFIX) | |
| # Delete bucket contents | |
| if not clients.censored: | |
| # Uncensored region: use OSS API calls to delete contents | |
| req = oss.models.ListObjectsV2Request( | |
| bucket=bucket, | |
| prefix=IPXE_STORAGE_PREFIX, | |
| ) | |
| rsp = clients.oss.list_objects_v2(req) | |
| delete = [x.key for x in rsp.contents or ()] | |
| if delete: | |
| req = oss.models.DeleteMultipleObjectsRequest( | |
| bucket=bucket, | |
| objects=[oss.models.DeleteObject(x) for x in delete], | |
| ) | |
| rsp = clients.oss.delete_multiple_objects(req) | |
| elif func: | |
| # Censored region with FC: use function to delete contents | |
| payload = {'bucket': bucket} | |
| call_temp_function(clients, func, payload) | |
| else: | |
| # Censored region without FC: assume bucket must be empty, | |
| # since we could not have uploaded to it in the first place | |
| pass | |
| # Delete the now-empty bucket | |
| req = oss.models.DeleteBucketRequest(bucket=bucket) | |
| rsp = clients.oss.delete_bucket(req) | |
| def create_temp_bucket(clients, func): | |
| """Create temporary bucket (and remove any stale temporary buckets)""" | |
| prefix = '%s%s-' % (IPXE_STORAGE_PREFIX, clients.region) | |
| req = oss.models.ListBucketsRequest(prefix=prefix) | |
| rsp = clients.oss.list_buckets(req) | |
| buckets = [x.name for x in rsp.buckets or ()] | |
| for bucket in buckets: | |
| delete_temp_bucket(clients, func, bucket) | |
| if clients.censored and not func: | |
| # We cannot use OSS in censored regions with no Function Compute | |
| return None | |
| bucket = ('%s%s' % (prefix, uuid4()))[:OSS_BUCKET_NAME_LEN] | |
| req = oss.models.PutBucketRequest(bucket=bucket) | |
| try: | |
| rsp = clients.oss.put_bucket(req) | |
| except oss.exceptions.OperationError as exc: | |
| # AliCloud provides no other way to detect non-working regions | |
| if exc.unwrap().code == OSS_FORBIDDEN_REGION_CODE: | |
| return None | |
| raise exc | |
| logger.info("create bucket %s %s" % (clients.region, bucket)) | |
| return bucket | |
| def upload_object(clients, bucket, image): | |
| """Upload disk image object to uncensored bucket""" | |
| logger.info("upload %s %s" % (clients.region, image.name)) | |
| req = oss.models.PutObjectRequest(bucket=bucket, key=image.key) | |
| rsp = clients.oss.put_object_from_file(req, image.path) | |
| req = oss.models.GetObjectRequest(bucket=bucket, key=image.key) | |
| rsp = clients.oss.presign(req) | |
| return rsp.url | |
| def copy_objects(clients, bucket, func, uploads): | |
| """Copy disk image objects to censored bucket from uncensored bucket""" | |
| logger.info("upload %s (censored)" % clients.region) | |
| payload = { | |
| 'bucket': bucket, | |
| 'sources': { | |
| key: random.choices([url for key, url in urls], k=FC_SOURCE_COUNT) | |
| for key, urls in groupby(sorted( | |
| ((image.key, url) for (region, image), url in uploads.items()) | |
| ), key=itemgetter(0)) | |
| } | |
| } | |
| call_temp_function(clients, func, payload) | |
| def delete_image(clients, name): | |
| """Remove existing image (if applicable)""" | |
| req = ecs.models.DescribeImagesRequest( | |
| region_id=clients.region, | |
| image_name=name, | |
| image_owner_alias='self', | |
| ) | |
| rsp = clients.ecs.describe_images_with_options(req, RUNTIME_OPTS) | |
| for image in rsp.body.images.image or (): | |
| logger.info("delete image %s %s (%s)" % | |
| (clients.region, image.image_name, image.image_id)) | |
| # Unpublish image | |
| if image.is_public: | |
| req = ecs.models.ModifyImageSharePermissionRequest( | |
| region_id=clients.region, | |
| image_id=image.image_id, | |
| is_public=False, | |
| ) | |
| rsp = clients.ecs.modify_image_share_permission_with_options( | |
| req, RUNTIME_OPTS | |
| ) | |
| # Tag associated snapshots for deletion | |
| for disk in image.disk_device_mappings.disk_device_mapping or (): | |
| snapshot_id = disk.snapshot_id | |
| tag = ecs.models.TagResourcesRequestTag( | |
| key=IPXE_SNAPSHOT_DELETE_TAG, | |
| value=IPXE_SNAPSHOT_DELETE_TAG, | |
| ) | |
| req = ecs.models.TagResourcesRequest( | |
| region_id=clients.region, | |
| resource_type='snapshot', | |
| resource_id=[snapshot_id], | |
| tag=[tag], | |
| ) | |
| rsp = clients.ecs.tag_resources_with_options(req, RUNTIME_OPTS) | |
| # Delete image | |
| req = ecs.models.DeleteImageRequest( | |
| region_id=clients.region, | |
| image_id=image.image_id | |
| ) | |
| rsp = clients.ecs.delete_image_with_options(req, RUNTIME_OPTS) | |
| def delete_snapshots(clients): | |
| """Remove stale snapshots left behind by deleted images""" | |
| tag = ecs.models.ListTagResourcesRequestTag( | |
| key=IPXE_SNAPSHOT_DELETE_TAG, | |
| value=IPXE_SNAPSHOT_DELETE_TAG, | |
| ) | |
| req = ecs.models.ListTagResourcesRequest( | |
| region_id=clients.region, | |
| resource_type='snapshot', | |
| tag=[tag], | |
| ) | |
| rsp = clients.ecs.list_tag_resources_with_options(req, RUNTIME_OPTS) | |
| for snapshot in rsp.body.tag_resources.tag_resource or (): | |
| logger.info("delete snapshot %s %s" % | |
| (clients.region, snapshot.resource_id)) | |
| req = ecs.models.DeleteSnapshotRequest( | |
| snapshot_id=snapshot.resource_id, | |
| force=True, | |
| ) | |
| rsp = clients.ecs.delete_snapshot_with_options(req, RUNTIME_OPTS) | |
| def wait_for_task(clients, task_id): | |
| """Wait for task to complete""" | |
| status = 'Unknowable' | |
| for i in range(POLL_MAX_RETRIES): | |
| time.sleep(POLL_INTERVAL_SEC) | |
| req = ecs.models.DescribeTasksRequest( | |
| region_id=clients.region, | |
| task_ids=task_id, | |
| ) | |
| try: | |
| rsp = clients.ecs.describe_tasks_with_options(req, RUNTIME_OPTS) | |
| except openapi.client.UnretryableException: | |
| continue | |
| assert len(rsp.body.task_set.task) == 1 | |
| assert rsp.body.task_set.task[0].task_id == task_id | |
| status = rsp.body.task_set.task[0].task_status | |
| if status not in ('Waiting', 'Processing'): | |
| break | |
| if status != 'Finished': | |
| raise RuntimeError(status) | |
| def wait_for_image(clients, image_id): | |
| """Wait for image to become available""" | |
| status = 'Unknowable' | |
| for i in range(POLL_MAX_RETRIES): | |
| time.sleep(POLL_INTERVAL_SEC) | |
| req = ecs.models.DescribeImagesRequest( | |
| region_id=clients.region, | |
| image_id=image_id, | |
| ) | |
| try: | |
| rsp = clients.ecs.describe_images_with_options(req, RUNTIME_OPTS) | |
| except openapi.client.UnretryableException: | |
| continue | |
| if len(rsp.body.images.image): | |
| assert len(rsp.body.images.image) == 1 | |
| assert rsp.body.images.image[0].image_id == image_id | |
| status = rsp.body.images.image[0].status | |
| if status != 'Creating': | |
| break | |
| if status != 'Available': | |
| raise RuntimeError(status) | |
| def import_image(clients, image, bucket): | |
| """Import image""" | |
| logger.info("import %s %s" % (clients.region, image.name)) | |
| disk = ecs.models.ImportImageRequestDiskDeviceMapping( | |
| disk_image_size = 1, | |
| format = 'RAW', | |
| ossbucket = bucket, | |
| ossobject = image.key, | |
| ) | |
| features = ecs.models.ImportImageRequestFeatures( | |
| imds_support='v1', | |
| nvme_support='supported', | |
| ) | |
| req = ecs.models.ImportImageRequest( | |
| region_id=clients.region, | |
| image_name=image.name, | |
| architecture=image.arch, | |
| boot_mode=image.mode, | |
| disk_device_mapping=[disk], | |
| features=features, | |
| client_token=str(uuid4()), | |
| ) | |
| rsp = clients.ecs.import_image_with_options(req, RUNTIME_OPTS) | |
| image_id = rsp.body.image_id | |
| task_id = rsp.body.task_id | |
| wait_for_task(clients, task_id) | |
| wait_for_image(clients, image_id) | |
| logger.info("image %s %s (%s)" % | |
| (clients.region, image.name, image_id)) | |
| return image_id | |
| def copy_image(clients, image, image_id, censored): | |
| """Copy imported image to censored region""" | |
| logger.info("import %s %s via %s" % | |
| (censored.region, image.name, clients.region)) | |
| req = ecs.models.CopyImageRequest( | |
| region_id=clients.region, | |
| image_id=image_id, | |
| destination_region_id=censored.region, | |
| destination_image_name=image.name, | |
| client_token=str(uuid4()), | |
| ) | |
| rsp = clients.ecs.copy_image_with_options(req, RUNTIME_OPTS) | |
| copy_id = rsp.body.image_id | |
| wait_for_image(censored, copy_id) | |
| logger.info("image %s %s (%s)" % (censored.region, image.name, copy_id)) | |
| return copy_id | |
| def finalise_image(clients, image, image_id): | |
| """Finalise image attributes and permissions""" | |
| logger.info("finalise %s %s (%s)" % (clients.region, image.name, image_id)) | |
| req = ecs.models.ModifyImageAttributeRequest( | |
| region_id=clients.region, | |
| image_id=image_id, | |
| image_family=image.family, | |
| ) | |
| rsp = clients.ecs.modify_image_attribute_with_options(req, RUNTIME_OPTS) | |
| if image.public: | |
| req = ecs.models.ModifyImageSharePermissionRequest( | |
| region_id=clients.region, | |
| image_id=image_id, | |
| is_public=True, | |
| ) | |
| rsp = clients.ecs.modify_image_share_permission_with_options( | |
| req, RUNTIME_OPTS | |
| ) | |
| # Parse command-line arguments | |
| parser = argparse.ArgumentParser(description="Import Alibaba Cloud image") | |
| parser.add_argument('--verbose', '-v', action='count', default=0) | |
| parser.add_argument('--name', '-n', | |
| help="Base image name") | |
| parser.add_argument('--family', '-f', default='ipxe', | |
| help="Base family name") | |
| parser.add_argument('--public', '-p', action='store_true', | |
| help="Make image(s) public") | |
| parser.add_argument('--overwrite', action='store_true', | |
| help="Overwrite any existing image with same name") | |
| parser.add_argument('--region', '-r', action='append', | |
| help="AliCloud region(s)") | |
| parser.add_argument('--role', '-R', default="AliyunFcDefaultRole", | |
| help="AliCloud role for censorship bypass function") | |
| parser.add_argument('image', nargs='+', help="iPXE disk image") | |
| args = parser.parse_args() | |
| # Configure logging | |
| loglevels = [logging.WARNING, logging.INFO, logging.DEBUG] | |
| verbosity = min(args.verbose, (len(loglevels) - 1)) | |
| logging.basicConfig(level=loglevels[verbosity]) | |
| logging.getLogger('apscheduler').setLevel(logging.WARNING) | |
| # Use default name if none specified | |
| if not args.name: | |
| args.name = '%s-%s' % (args.family, | |
| datetime.date.today().strftime('%Y%m%d')) | |
| # Use all regions if none specified | |
| regions = args.region or all_regions() | |
| # Construct image list | |
| images = [image(x, args.family, args.name, args.public) for x in args.image] | |
| imports = [(region, image) for region in regions for image in images] | |
| workers = len(imports) | |
| # Look up resource names | |
| fcrole = role_arn(args.role) | |
| # Construct per-region clients | |
| account = account_id() | |
| clients = {region: all_clients(region, account) for region in regions} | |
| # Delete existing images from all regions, if applicable | |
| if args.overwrite: | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(delete_image, | |
| clients=clients[region], | |
| name=image.name): (region, image) | |
| for region, image in imports} | |
| done = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Delete any stale snapshots from all regions | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(delete_snapshots, | |
| clients=clients[region]): region | |
| for region in regions} | |
| done = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Create temporary function in each censored region with usable FC | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(create_temp_function, | |
| clients=clients[region], | |
| role=fcrole): region | |
| for region in regions} | |
| funcs = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Create temporary bucket in each region with usable OSS | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(create_temp_bucket, | |
| clients=clients[region], | |
| func=funcs[region]): region | |
| for region in regions} | |
| buckets = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Upload image objects directly to each uncensored region with usable OSS | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(upload_object, | |
| clients=clients[region], | |
| bucket=buckets[region], | |
| image=image): (region, image) | |
| for region, image in imports | |
| if buckets[region] and not funcs[region]} | |
| uploads = {futures[x]: x.result() for x in as_completed(futures)} | |
| if not uploads: | |
| parser.error("At least one working non-Chinese region is required") | |
| # Copy image objects to each censored region with usable OSS and usable FC | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(copy_objects, | |
| clients=clients[region], | |
| bucket=buckets[region], | |
| func=funcs[region], | |
| uploads=uploads): region | |
| for region in regions | |
| if buckets[region] and funcs[region]} | |
| done = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Import images in each region with usable OSS | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(import_image, | |
| clients=clients[region], | |
| image=image, | |
| bucket=buckets[region]): (region, image) | |
| for region, image in imports if buckets[region]} | |
| results = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Copy images to regions without usable OSS | |
| # | |
| # Copies are rate-limited by source region, so spread the copies | |
| # across all available regions with imported images. | |
| # | |
| copies = [(region, censored, image) for region, (censored, image) in zip( | |
| cycle(region for region in regions if buckets[region]), | |
| ((region, image) for region, image in imports if not buckets[region]), | |
| )] | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(copy_image, | |
| clients=clients[region], | |
| censored=clients[censored], | |
| image=image, | |
| image_id=results[(region, image)]): | |
| (censored, image) | |
| for region, censored, image in copies} | |
| copied = {futures[x]: x.result() for x in as_completed(futures)} | |
| results.update(copied) | |
| # Finalise images | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(finalise_image, | |
| clients=clients[region], | |
| image=image, | |
| image_id=results[(region, image)]): | |
| (region, image) | |
| for region, image in imports} | |
| done = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Remove temporary buckets | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(delete_temp_bucket, | |
| clients=clients[region], | |
| func=funcs[region], | |
| bucket=buckets[region]): region | |
| for region in regions if buckets[region]} | |
| done = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Remove temporary functions | |
| with ThreadPoolExecutor(max_workers=workers) as executor: | |
| futures = {executor.submit(delete_temp_function, | |
| clients=clients[region], | |
| func=funcs[region]): region | |
| for region in regions if funcs[region]} | |
| done = {futures[x]: x.result() for x in as_completed(futures)} | |
| # Show created images | |
| for region, image in imports: | |
| image_id = results[(region, image)] | |
| print("%s %s (%s) %s" % (region, image.name, image.family, image_id)) |