def do_command()

in ebcli/controllers/migrate.py [0:0]

• 120 lines of code
• 19 McCabe index (conditional complexity)

    def do_command(self):
        if not sys.platform.startswith("win"):
            raise NotSupportedError("'eb migrate' is only supported on Windows")
        validate_iis_version_greater_than_7_0()
        verbose = self.app.pargs.verbose

        site_names = self.app.pargs.sites
        env_name = self.app.pargs.environment_name
        app_name = self.app.pargs.application_name
        platform = self.app.pargs.platform
        instance_type = self.app.pargs.instance_type
        instance_profile = self.app.pargs.instance_profile
        service_role = self.app.pargs.service_role
        ebs_snapshots = self.app.pargs.ebs_snapshots
        keyname = self.app.pargs.keyname
        interactive = self.app.pargs.interactive
        cname = self.app.pargs.cname
        region = self.app.pargs.region
        archive_only = self.app.pargs.archive_only
        on_prem_mode = self.app.pargs.on_prem_mode
        tags = self.app.pargs.tags
        tags = tagops.get_and_validate_tags(tags)
        copy_firewall_config = self.app.pargs.copy_firewall_config
        encrypt_ebs_volumes = self.app.pargs.encrypt_ebs_volumes
        ssl_certificate = self.app.pargs.ssl_certificates
        archive = self.app.pargs.archive
        if archive and archive_only:
            raise ValueError("Cannot use --archive-only with --archive-dir together.")
        vpc_config = self.app.pargs.vpc_config

        sites = establish_candidate_sites(site_names, interactive)
        on_an_ec2_instance = True
        try:
            environment_vpc, _region, instance_id, instance_tags = (
                construct_environment_vpc_config(on_prem_mode, verbose)
            )
            on_an_ec2_instance = not not instance_id
        except NotAnEC2Instance:
            environment_vpc, _region, instance_id, instance_tags = (
                dict(),
                None,
                list(),
                None,
            )
            on_an_ec2_instance = False
        if vpc_config:
            environment_vpc = load_environment_vpc_from_vpc_config(vpc_config)
        region = _region or establish_region(region, interactive, app_name, platform)
        LOG.debug("Writing region_name to .elasticbeanstalk/config")
        fileoperations.write_config_setting("global", "region_name", region)
        tags = tags or instance_tags
        snapshots_string = generate_snapshots_string(ebs_snapshots)

        app_name = establish_app_name(app_name, interactive, sites)
        env_name = establish_env_name(env_name, app_name, interactive, sites)
        platform = establish_platform(platform, interactive)
        process_keyname(keyname)

        listener_configs = []
        if not _arr_enabled():
            listener_configs = get_listener_configs(sites, ssl_certificate)
        all_ports = get_all_ports(sites)
        ec2_security_group = None
        load_balancer_security_group = None
        if on_an_ec2_instance and copy_firewall_config:
            load_balancer_security_group, ec2_security_group = (
                ec2.establish_security_group(all_ports, env_name, environment_vpc["id"])
            )

        source_bundle_zip = None
        upload_target_dir = None
        latest_migration_run_path = None
        if not archive:
            latest_migration_run_path = setup_migrations_dir(verbose)
            upload_target_dir = os.path.join(latest_migration_run_path, "upload_target")
            os.makedirs(upload_target_dir, exist_ok=True)
            self.package_sites(
                sites, latest_migration_run_path, upload_target_dir, verbose
            )
            write_ebdeploy_utility_script(upload_target_dir)
            if _arr_enabled():
                export_arr_config(upload_target_dir, verbose)
            if copy_firewall_config:
                write_copy_firewall_config_script(upload_target_dir, sites)
            fileoperations.zip_up_folder(upload_target_dir, upload_target_zip_path())
        else:
            if zipfile.is_zipfile(archive):
                source_bundle_zip = archive
            else:
                upload_target_dir = archive
                latest_migration_run_path = os.path.dirname(upload_target_dir)
                self.package_sites(
                    sites, latest_migration_run_path, upload_target_dir, verbose
                )
                fileoperations.zip_up_folder(
                    upload_target_dir, upload_target_zip_path()
                )
        if listener_configs and latest_migration_run_path:
            with open(
                os.path.join(latest_migration_run_path, "listener_configs.json"), "w"
            ) as file:
                listener_configs_json = {"listener_configs": listener_configs}
                json.dump(listener_configs_json, file, indent=2)
        if archive_only and upload_target_dir:
            generate_upload_target_archive(upload_target_dir, env_name, region)
            return

        self.create_app_version_and_environment(
            app_name=app_name,
            source_bundle_zip=source_bundle_zip,
            instance_profile=instance_profile,
            service_role=service_role,
            instance_type=instance_type,
            cname=cname,
            env_name=env_name,
            encrypt_ebs_volumes=encrypt_ebs_volumes,
            environment_vpc=environment_vpc,
            ec2_security_group=ec2_security_group,
            platform=platform,
            keyname=keyname,
            tags=tags,
            snapshots_string=snapshots_string,
            listener_configs=listener_configs,
            load_balancer_security_group=load_balancer_security_group,
            interactive=interactive,
        )