Пример #1
0
    def create_disks_and_attach(self, node):
        # Create a disk list
        disk_list = ""
        for i in range(0, self.disks):
            disk_list += "{0}-disk-{1} ".format(node, i)

        Log.info(
            "Creating and attaching disk(s) for node {0}. One moment...".
            format(node), True)

        result, status = self.invoke_gcloud(
            "compute disks create --size {0}GB --type pd-ssd --project {1} --zone {2} {3}"
            .format(self.block_disk_size, self.project, self.zone, disk_list))
        Log.info("Created {0} disk(s) for node {1}".format(self.disks, node))
        Log.debug(result)

        for i in range(0, self.disks):
            disk_name = "{0}-disk-{1} ".format(node, i)
            result, status = self.invoke_gcloud(
                "compute instances attach-disk {0} --disk {1} --project {2} --zone {3}"
                .format(node, disk_name, self.project, self.zone))
            Log.info("Added disk {0} to node {1}".format(disk_name, node))
            Log.debug(result)

            result, status = self.invoke_gcloud(
                "compute instances set-disk-auto-delete {0} --disk {1} --project {2} --zone {3}"
                .format(node, disk_name, self.project, self.zone))
            Log.info("Set set-disk-auto-delete on disk {0}".format(disk_name))
            Log.debug(result)

        Log.info("Created and attached disk(s) for node {0}".format(node),
                 True)
Пример #2
0
 def _create_update_resource_group(self):
     Log.info(
         "Creating or updating resource group: {0}...".format(
             self.context.resource_group), True)
     resource = ResourceGroup(location=self.context.location)
     self.resource_client.resource_groups.create_or_update(
         self.context.resource_group, resource)
Пример #3
0
    def __init__(self, mode, response_file):
        if mode != Prompts.PROMPT_MODE and mode != Prompts.RECORD_MODE and mode != Prompts.HEADLESS_MODE:
            raise InstallException('Invalid prompt mode %s' % str(mode))

        self.response_file = None
        self.mode = mode
        self.recorded_options = dict()
        self.headless_parser = None

        if mode == Prompts.HEADLESS_MODE:
            if response_file is None:
                raise InstallException(
                    'In order to run in headless mode, you must supply a response file.'
                )
            if not os.path.exists(response_file):
                raise InstallException(
                    'In order to run in headless mode, you must supply an existing response file. %s does not exist.'
                    % response_file)
            self.headless_parser = Parser.get_properties_parser(response_file)
            Log.info(
                'Installer prompts have been initialized in headless mode.')
        elif mode == Prompts.RECORD_MODE:
            if response_file is None:
                raise InstallException(
                    'In order to run in record mode, you must supply a response file destination.'
                )
            dirname = os.path.dirname(response_file)
            if not os.path.exists(dirname):
                raise InstallException(
                    'In order to run in record mode, the directory for the response file must exist.'
                )
            self.response_file = open(response_file, 'w')
            Log.info(
                'Installer prompts have been initialized in record mode. response file: {0}'
                .format(response_file))
    def complete_uninstallation():
        print(os.linesep)

        msg = "This Kubernetes environment"
        warnings = Log.get_warning_count()
        errors = Log.get_error_count()

        if errors > 0 and warnings > 0:
            msg = "{0} had {1} error(s) and {2} warning(s) during the uninstall process for MapR".format(
                msg, errors, warnings)
            Log.error(msg)
        elif errors > 0 and warnings == 0:
            msg = "{0} had {1} error(s) during the uninstall process for MapR".format(
                msg, errors)
            Log.error(msg)
        elif errors == 0 and warnings > 0:
            msg = "{0} had {1} warnings(s) during the uninstall process for MapR".format(
                msg, warnings)
            Log.warning(msg)
        else:
            msg = "{0} has had MapR successfully uninstalled".format(msg)
            Log.info(msg, True)

        if errors > 0 or warnings > 0:
            msg = "Please check the bootstrap log file for this session here: {0}".format(
                Log.get_log_filename())
            Log.warning(msg)

        Log.info("")
 def confirm_delete_installation(self):
     print(os.linesep)
     Log.info(
         "This will uninstall ALL MapR operators from your Kubernetes environment. This will cause all Compute Spaces to be destroyed. They cannot be recovered!",
         True)
     agree = self._prompts.prompt_boolean("Do you agree?",
                                          False,
                                          key_name="AGREEMENT")
     if not agree:
         Log.info("Very wise decision. Exiting uninstall...", True)
         BootstrapBase.exit_application(2)
Пример #6
0
 def exit_application(signum, _=None):
     if signum == 0:
         Log.info("Bootstrap terminated {0}".format(signum))
     else:
         print(os.linesep)
         Log.warning("Bootstrap terminated {0}".format(signum))
     if BootstrapBase._prompts is not None:
         BootstrapBase._prompts.write_response_file()
         BootstrapBase._prompts = None
     Log.close()
     exit(signum)
Пример #7
0
    def initialize(prompts):
        Cloud.prompts = prompts
        Cloud._clouds = list()
        Cloud._cloud_instances = dict()
        files = os.listdir(Cloud.DIR)

        Log.info("Initializing cloud support. One moment please...")

        for afile in files:
            full_file = os.path.join(Cloud.DIR, afile)
            if not full_file.endswith(".py"):
                Log.debug(
                    "Not inspecting: {0} because it is not a py file".format(
                        full_file))
                continue
            if not os.path.isfile(full_file):
                Log.debug(
                    "Not inspecting: {0} because it is not a file".format(
                        full_file))
                continue
            if afile == "cloud.py" or afile == "__init__.py":
                Log.debug(
                    "Not inspecting: {0} because it is not a file".format(
                        full_file))
                continue

            module_name = full_file[:full_file.index(".")]
            file_module = imp.load_source(module_name,
                                          os.path.join(Cloud.DIR, full_file))
            class_members = inspect.getmembers(file_module, inspect.isclass)
            Log.debug("class_members for file_module {0} is: {1}".format(
                str(file_module), str(class_members)))

            for clazz in class_members:
                # if the class is of the correct subclass add it to the list of tests
                if not issubclass(clazz[1], Cloud) or clazz[
                        1] == Cloud or clazz[1] in Cloud._clouds:
                    continue

                Cloud._clouds.append(clazz[1])
                instance = clazz[1]()
                name = instance.get_name()
                if instance.is_enabled():
                    Cloud._cloud_instances[name] = instance
                    Log.debug(
                        "Cloud {0} was added to list because it is enabled".
                        format(name))
                else:
                    Log.debug(
                        "Cloud {0} was not added to list because it is not enabled"
                        .format(name))

        Log.debug("There were {0} cloud providers found".format(
            len(Cloud._clouds)))
Пример #8
0
 def check_if_storage(self):
     print(os.linesep)
     agree = self._prompts.prompt_boolean("Install MapR Data Platform?",
                                          True,
                                          key_name="CREATE_STORAGE")
     Log.info(
         "Attention: MapR Data Platform on Kubernetes is PRE-ALPHA Software. Please DO NOT store critical data in clusters you create with this "
         "operator. You WILL lose data and these clusters WILL NOT be upgradable.",
         stdout=True)
     print("")
     return agree
Пример #9
0
 def collect(self):
     Log.debug('Checking kubectl is installed correctly...')
     response, status = OSCommand.run2("command -v kubectl")
     if status == 0:
         Log.info("Looking good... Found kubectl")
         self.operation = Validator.OPERATION_OK
     else:
         self.operation = Validator.OPERATION_INSTALL
         Log.error(
             "You will need to have kubectl installed on this machine.")
         Log.error(
             "To install kubectl please see: https://kubernetes.io/docs/tasks/tools/install-kubectl/"
         )
Пример #10
0
 def collect(self):
     Log.debug('Checking for oc (OpenShift CLI) installation...')
     response, status = OSCommand.run2("command -v oc")
     if status == 0:
         Log.info("Looking good... Found oc (OpenShift CLI) installed",
                  True)
         self.operation = Validator.OPERATION_OK
     else:
         self.operation = Validator.OPERATION_NONE
         Log.error(
             "You will need to have oc (OpenShift CLI) installed on this machine."
         )
         Log.error(
             "To install oc please see: https://docs.openshift.com/container-platform/3.11/cli_reference/get_started_cli.html"
         )
Пример #11
0
    def process_labels(self):
        self._get_json()

        nodes_not_set = self.get_mapr_use_node_labels(NodeLabels.MAPR_LABEL)
        if nodes_not_set is not None and len(nodes_not_set) > 0:
            Log.info("Setting MapR usage tag {0} for {1} nodes...".format(NodeLabels.MAPR_LABEL, len(nodes_not_set)),
                     stdout=True)
            for node_not_set in nodes_not_set:
                self.k8s.run_label_mapr_node(node_not_set, NodeLabels.MAPR_LABEL, True)

        nodes_not_set = self.get_mapr_use_node_labels(NodeLabels.EXCLUSIVE_LABEL)
        if nodes_not_set is not None and len(nodes_not_set) > 0:
            Log.info("Setting MapR usage tag {0} for {1} nodes...".format(NodeLabels.EXCLUSIVE_LABEL, len(nodes_not_set)),
                     stdout=True)
            for node_not_set in nodes_not_set:
                self.k8s.run_label_mapr_node(node_not_set, NodeLabels.EXCLUSIVE_LABEL, "None")
Пример #12
0
    def _get_json(self):
        Log.info("Retrieving node information...", stdout=True)
        result, status = self.k8s.run_get("nodes -o=json")
        if status != 0:
            return None

        self._json = json.loads(result)
        if self._json is None:
            Log.error("No JSON was returned from get nodes command")
            return

        self._items = self._json.get("items")
        if self._items is None:
            Log.error("No items dictonary in get nodes JSON")
            return

        self._node_count = len(self._items)
Пример #13
0
    def build_cloud(self):
        self.cluster_name = self.prompts.prompt("Enter cluster name",
                                                self.cluster_name,
                                                key_name="GKE_CLUSTER_NAME")
        self.nodes = self.prompts.prompt_integer("Enter number of nodes",
                                                 self.nodes,
                                                 1,
                                                 key_name="GKE_NODE_COUNT")
        self.disks = self.prompts.prompt_integer(
            "Enter number of local SSD disks for MapR FS. Each disk will be a fixed 375GB",
            self.disks,
            1,
            key_name="GKE_NUM_DISKS")
        self.instance_type = self.prompts.prompt("GKE compute instance type?",
                                                 self.instance_type,
                                                 key_name="GKE_INSTANCE_TYPE")
        if self.alpha:
            self.k8s_version = self.prompts.prompt("Kubernetes version?",
                                                   self.k8s_alpha_version,
                                                   key_name="GKE_K8S_VERSION")
        else:
            self.k8s_version = self.prompts.prompt("Kubernetes version?",
                                                   self.k8s_version,
                                                   key_name="GKE_K8S_VERSION")
        self.zone = self.prompts.prompt("GCE Zone to deploy into?",
                                        self.zone,
                                        key_name="GKE_ZONE")
        self.project = self.prompts.prompt("GCE project id?",
                                           self.project,
                                           key_name="GKE_PROJECT_ID")
        self.user = self.prompts.prompt("GCE user id?",
                                        self.user,
                                        key_name="GKE_USER")
        # self.image_type = self.prompts.prompt("GKE image type?", self.image_type)
        Log.info("Using GKE compute image type: {0}".format(self.image_type),
                 True)
        if self.alpha:
            Log.info("Using alpha Kubernetes version", True)
        else:
            Log.info("Using non-alpha Kubernetes version", True)

        if not self.prompts.prompt_boolean(
                "Ready to create Google GKS cluster. Do you want to continue?",
                True,
                key_name="GKE_CREATE"):
            Log.error("Exiiting since user is not ready to continue")
            BootstrapBase.exit_application(100)

        before = time.time()
        self.create_k8s_cluster()
        after = time.time()
        diff = int(after - before)
        Log.info(
            "Cluster creation took {0}m {1}s".format(diff / 60, diff % 60),
            True)
Пример #14
0
 def validate_nodes(self):
     print(os.linesep)
     Log.info(
         "We must validate and annotate your Kubernetes nodes. "
         "MapR node validation pods will be installed.",
         stdout=True)
     agree = self._prompts.prompt_boolean("Do you agree?",
                                          True,
                                          key_name="AGREEMENT_VALIDATE")
     if not agree:
         Log.error("Exiting due to non-agreement...")
         BootstrapBase.exit_application(2)
     # TODO: Add node exclusion code here
     # exclude = self._prompts.prompt_boolean("Do you want to exclude any nodes?", False, key_name="EXCLUDE_NODES")
     # if exclude:
     #    Log.error("Operation not currently supported...")
     #    BootstrapBase.exit_application(6)
     print("")
Пример #15
0
    def invoke_stable_cluster(self, args):
        cmd = "container --project {0} clusters create {1} {2}".format(
            self.project, self.cluster_name, args)

        Log.info("kubernetes version = {0}".format(self.k8s_version), True)
        Log.info(
            "Creating GKE environment via the following command: gcloud {0}".
            format(cmd), True)
        Log.info("Create log follows...")
        result, status = self.invoke_gcloud(cmd)
        Log.info(result, True)
Пример #16
0
    def run(self):
        logdir = os.path.join(self.script_dir, "logs")
        if os.path.exists(logdir):
            if not os.path.isdir(logdir):
                print(
                    "ERROR: {0} is not a directory and cannot be used as alog directory"
                    .format(logdir))
                BootstrapBase.exit_application(1)
        else:
            os.mkdir(logdir)

        logname = os.path.join(
            logdir, BootstrapBase.NOW.strftime("bootstrap-%m-%d_%H:%M:%S.log"))
        Log.initialize(self.log_config_file, logname)

        BootstrapBase._prompts = Prompts.initialize(self.prompt_mode,
                                                    self.prompt_response_file)
        Log.info("Prompt mode: {0}, response file: {1}".format(
            self.prompt_mode, self.prompt_response_file))
Пример #17
0
    def is_available(self):
        if not self.enabled:
            return False

        if self.available is None:
            Log.info("Checking Google cloud availability. One moment...", True)
            results, status = OSCommand.run2(
                ["command -v gcloud", "gcloud compute instances list"])
            self.available = True if status == 0 else False

            if not self.available:
                Log.warning(
                    "Google Cloud SDK not found or not configured correctly. Quit bootstrapper, install and "
                    "confgure Google Cloud SDK and restart bootstrapper. See: https://cloud.google.com/sdk/. "
                    "More information on the error in the bootstrapper log here: "
                    + Log.get_log_filename())
                Log.warning(results)

        return self.available
Пример #18
0
    def complete_installation():
        print(os.linesep)

        msg = "This Kubernetes environment"
        warnings = Log.get_warning_count()
        errors = Log.get_error_count()

        if errors > 0 and warnings > 0:
            msg = "{0} had {1} error(s) and {2} warning(s) during the bootstraping process for MapR".format(
                msg, errors, warnings)
            Log.error(msg)
        elif errors > 0 and warnings == 0:
            msg = "{0} had {1} error(s) during the bootstraping process for MapR".format(
                msg, errors)
            Log.error(msg)
        elif errors == 0 and warnings > 0:
            msg = "{0} had {1} warnings(s) during the bootstraping process for MapR".format(
                msg, warnings)
            Log.warning(msg)
        else:
            msg = "{0} has been successfully bootstrapped for MapR".format(msg)
            Log.info(msg, True)
            Log.info(
                "MapR components can now be created via the newly installed operators",
                True)

        if errors > 0 or warnings > 0:
            msg = "Please check the bootstrap log file for this session here: {0}".format(
                Log.get_log_filename())
            Log.warning(msg)

        Log.info("")
Пример #19
0
 def prologue(self):
     title = os.linesep + "MapR for Kubernetes Bootstrap "
     title += "Installer" if self.is_install is True else "Uninstaller"
     title += " (Version {0})".format(BOOTSTRAP_BUILD_VERSION_NO)
     Log.info(title, True)
     Log.info("Copyright 2019 MapR Technologies, Inc., All Rights Reserved",
              True)
     Log.info("https://mapr.com/legal/eula/", True)
Пример #20
0
    def collect(self):
        Log.debug("Getting Python information...")

        python_major, python_version = self._get_python_version()
        Log.info("Python version: {0}".format(python_version))

        self.results[Validator.FOUND] = True
        self.results[Validator.VERSION] = python_version

        if python_major == 2:
            pmin = PythonValidator.PYTHON2_MIN
            pmax = PythonValidator.PYTHON2_MAX
        elif python_major == 3:
            pmin = PythonValidator.PYTHON3_MIN
            pmax = PythonValidator.PYTHON3_MAX

            if python_version <= PythonValidator.PYTHON3_ERROR_MAX:
                Log.error("The virtual environments created with your python version {0} are incompatible. "
                          "Please use Python 3.3 or greater".format(python_version))
                self.operation = Validator.OPERATION_INSTALL
                return
        else:
            Log.error("The major Python version '{0}' is not supported; Only version 2 and 3 supported".format(python_major))
            self.operation = Validator.OPERATION_TOO_NEW
            return

        expected = "Expected versions between {0} and {1} or between {2} and {3}"\
            .format(PythonValidator.PYTHON2_MIN, PythonValidator.PYTHON2_MAX,
                    PythonValidator.PYTHON3_MIN, PythonValidator.PYTHON3_MAX)

        if python_version > pmax or python_version < pmin:
            Log.warning("The Python version on this system is {0}. {1}"
                      .format(python_version, expected))
            self.operation = Validator.OPERATION_WARNING
        else:
            Log.debug("The Python version on this system is compatible")
            self.operation = Validator.OPERATION_OK
Пример #21
0
    def _create_aks(self):
        with open(os.path.join(self.base_path,
                               CreateAKS.PARAMETERS_JSON)) as in_file:
            parameters = json.load(in_file)

        parameters[u"resourceName"][u"value"] = self.context.aks_name
        parameters[u"agentCount"][u"value"] = self.context.node_count
        parameters[u"agentVMSize"][u'Value'] = self.context.vm_size
        parameters[u"osDiskSizeGB"][u'Value'] = int(self.context.os_disk_size)
        parameters[u"sshRSAPublicKey"][u'Value'] = self.context.public_key
        parameters[u"servicePrincipalClientId"][
            u'Value'] = self.context.client_id
        parameters[u"servicePrincipalClientSecret"][
            u'Value'] = self.context.secret
        parameters[u"kubernetesVersion"][u'Value'] = self.context.k8s_version
        parameters[u"dnsPrefix"][u'Value'] = "{0}-maprtech".format(
            self.context.aks_name)

        with open(os.path.join(self.base_path,
                               CreateAKS.ARM_TEMPLATE_JSON)) as in_file:
            template = json.load(in_file)

        deployment_properties = DeploymentProperties()
        deployment_properties.template = template
        deployment_properties.parameters = parameters
        deployment_properties.mode = DeploymentMode.incremental

        Log.info(
            "{0}: Run K8S deployment test with {1} Nodes OS Disk Size {2}...".
            format(self.context.resource_group, self.context.node_count,
                   self.context.os_disk_size), True)
        deployment_async_operation = self.resource_client.deployments.create_or_update(
            self.context.resource_group, "maprk8s.deployment",
            deployment_properties)
        deployment_async_operation.wait()
        Log.info("K8S cluster deployment complete", True)
Пример #22
0
 def configure_cloud(self):
     cmd = GoogleCloud.CMD_ROLE_BINDING.format(self.user)
     Log.info("Now we will configure RBAC for your kubernetes env...", True)
     Log.info(
         "Binding cluster-admin role to GCE user: {0}...".format(self.user),
         True)
     response, status = OSCommand.run2(cmd)
     if status != 0:
         Log.error("Could not bind cluster-admin role: {0}:{1}", status,
                   response)
     Log.info("Configured GKE permissions", True)
Пример #23
0
    def configure_kubernetes(self):
        print(os.linesep)
        Log.info("Ensuring proper kubernetes configuration...", True)
        Log.info("Checking kubectl can connect to your kubernetes cluster...",
                 True)
        response, status = OSCommand.run2("kubectl get nodes")
        if status != 0:
            Log.error(
                "Cannot connect to Kubernetes. Make sure kubectl is pre-configured to communicate with a Kubernetes cluster."
            )
            BootstrapBase.exit_application(4)

        Log.info("Looking good... Connected to Kubernetes", True)
        if self.cloud_instance is not None:
            self.cloud_instance.configure_cloud()
Пример #24
0
    def get_mapr_use_node_labels(self, label):
        nodes_set = 0
        nodes_not_set = set()

        for node in self._items:
            node_name = node["metadata"]["name"]
            mapr_usenode = node["metadata"]["labels"].get(label)

            if mapr_usenode is not None:
                nodes_set += 1
                Log.info("Node: {0} has {1} label set to: {2}".format(node_name, label, mapr_usenode))
            else:
                nodes_not_set.add(node_name)
                Log.info("Node: {0} does not have {1} label set".format(node_name, label))

        Log.info("{0} node(s) found, {1} node(s) tagged with the MapR usage tag {2} while {3} node(s) not"
                 .format(self._node_count, nodes_set, label, len(nodes_not_set)), stdout=True)
        return nodes_not_set
Пример #25
0
    def run(self):
        # vms = self.compute_client.virtual_machines.list(self.resource_group)
        # for vm in vms:
        #     nic = vm.network_profile.network_interfaces
        #     pass

        nics = self.network_client.network_interfaces.list(self.resource_group)
        for nic in nics:
            ipconfig = nic.ip_configurations[0]

            public_ip_name = "{0}-publicip".format(nic.name)
            public_ip = {
                'location': self.location,
                'public_ip_allocation_method': 'Dynamic'
            }

            if ipconfig.public_ip_address is not None:
                Log.info(
                    "{0} NIC already has a public ip address".format(nic.name),
                    True)
                continue

            Log.info(
                "Creating or updating public ip address {0}...".format(
                    public_ip_name), True)
            ip_rslt = self.network_client.public_ip_addresses.create_or_update(
                self.resource_group, public_ip_name, public_ip)
            ip_rslt.wait()

            public_ip = self.network_client.public_ip_addresses.get(
                self.resource_group, public_ip_name)
            ipconfig.public_ip_address = public_ip

            params = {
                'location': self.location,
                'ip_configurations': [ipconfig]
            }

            Log.info(
                "Associate public ip address {0} with NIC {1}".format(
                    public_ip_name, nic.name), True)
            ip_rslt = self.network_client.network_interfaces.create_or_update(
                self.resource_group, nic.name, params)
            ip_rslt.wait()
Пример #26
0
    def __init__(self, env, compute_client):
        self.env = env
        self.compute_client = compute_client

        self.aks_rg = self.env.get("RESOURCE_GROUP")
        self.aks_name = self.env.get("AKS_NAME")
        self.location = self.env.get("LOCATION")
        self.data_disk_count = self.env.get_int("DATA_DISK_COUNT")
        self.data_disk_size = self.env.get_int("DATA_DISK_SIZE")
        self.data_disk_type = self.env.get("DATA_DISK_TYPE")

        self.resource_group = "MC_{0}_{1}_{2}".format(self.aks_rg, self.aks_name, self.location)

        if self.data_disk_type is None:
            Log.info("DATA_DISK_TYPE not supplied, using Standard_LRS", True)
            self.data_disk_type = StorageAccountTypes.standard_lrs
        elif (self.data_disk_type != "Standard_LRS") and \
             (self.data_disk_type != "StandardSSD_LRS") and \
             (self.data_disk_type != "Premium_LRS"):
            Log.info("Invalid disk type {0}, using Standard_LRS".format(self.data_disk_type), True)
            self.data_disk_type = StorageAccountTypes.standard_lrs
        else:
            Log.info("Creating data disks of type; {0}".format(self.data_disk_type), True)
Пример #27
0
 def get_clients(self):
     Log.info("Getting Azure clients...", True)
     self.resource_client = ResourceManagementClient(self.credentials, self.context.subscription_id)
     self.compute_client = ComputeManagementClient(self.credentials, self.context.subscription_id)
     self.network_client = NetworkManagementClient(self.credentials, self.context.subscription_id)
     self.monitor_client = MonitorClient(self.credentials, self.context.subscription_id)
Пример #28
0
    def run(self):
        Log.info("Checking disks in resource group: {0}...".format(self.resource_group), True)

        existing_disks = self.compute_client.disks.list_by_resource_group(self.resource_group)
        for disk in existing_disks:
            Log.info("Found managed disk: {0}".format(disk.name), True)

        vms = self.compute_client.virtual_machines.list(self.resource_group)
        for vm in vms:
            Log.info("Checking VM: {0} for data disks".format(vm.name), True)
            attached_disks = vm.storage_profile.data_disks
            Log.info("Found {0} data disk(s) attached to the VM".format(len(attached_disks)), True)

            if len(attached_disks) >= self.data_disk_count:
                Log.info("There are already {0} data disk(s) attached when only {1} were required".format(len(attached_disks),
                                                                                                          self.data_disk_count), True)
                continue

            disks = list()
            for i in range(len(attached_disks), self.data_disk_count):
                data_disk_name = "{0}_DataDisk_{1}".format(vm.name, i)
                Log.info("Creating or updating data disk: {0}...".format(data_disk_name), True)

                disk = self.create_disk(data_disk_name)
                disks.append(disk)
                Log.info("The data disk is: {0}".format(disk.name), True)

            Log.info("Attaching the data disks to the vm...", True)
            self.attach_disks(vm, disks, len(attached_disks))
Пример #29
0
 def pas_complete_installation():
     Log.info("PAS Installation complete")
Пример #30
0
    def install_cloud(self):
        print("")
        Cloud.initialize(self._prompts)
        cloud_names = Cloud.get_cloud_names()

        if len(cloud_names) == 0:
            Log.warning(
                "There are no supported cloud providers found in this bootstrapper application"
            )
            return False

        Log.info(
            "If you are installing in a cloud provider, we can help you create your kubernetes environment.",
            True)
        Log.info(
            "ATTENTION: Cloud Environment installation is provided AS IS with no support.",
            True)
        Log.info(
            "Work with your IT Team to help create kubernetes environments with the security and reliability features that suit your enterprise needs.",
            True)

        create = self._prompts.prompt_boolean(
            "Do you want to create a kubernetes environment in the Cloud?",
            False,
            key_name="CLOUD_ENV")
        if not create:
            Log.info("Not building cloud environment")
            return False

        # Check the availability of each enabled cloud provider
        Cloud.check_available()
        cloud_names = Cloud.get_cloud_names()
        if len(cloud_names) == 0:
            Log.warning(
                "Some clouds were enabled but necessary modules that support these clouds are not available"
            )
            BootstrapBase.exit_application(7)

        choice = self._prompts.prompt_choices("Choose a cloud provider",
                                              Cloud.get_cloud_names(),
                                              key_name="CLOUD_PROVIDER")
        Log.info("Using cloud provider {0}".format(choice))
        self.cloud_instance = Cloud.get_instance(choice)
        Log.debug("Using cloud instance {0}".format(str(self.cloud_instance)))

        Log.info("Building {0} cloud k8s...".format(choice))
        self.cloud_instance.build_cloud()
        Log.info("Created {0} cloud k8s".format(choice))
        self.cloud_created = True
        return True