def cluster_install_dcos_from_path(
cluster: Cluster,
cluster_representation: ClusterRepresentation,
ip_detect_path: Path,
dcos_config: Dict[str, Any],
files_to_copy_to_genconf_dir: Iterable[Tuple[Path, Path]],
dcos_installer: Path,
doctor_message: str,
enable_spinner: bool,
) -> None:
"""
Install DC/OS on a cluster.
Args:
cluster: The cluster to install DC/OS on.
cluster_representation: A representation of the cluster.
ip_detect_path: The ``ip-detect`` script to use for installing DC/OS.
files_to_copy_to_genconf_dir: Pairs of host paths to paths on the
installer node. These are files to copy from the host to the
installer node before upgrading DC/OS.
dcos_config: The DC/OS configuration to use.
dcos_installer: The ``Path`` to a local DC/OS installer.
doctor_message: A message which instructs the user on which command to
use if installation fails.
enable_spinner: Whether to enable the spinner animation.
"""
spinner = Halo(enabled=enable_spinner)
spinner.start('Installing DC/OS')
# We allow a cluster to be passed in rather than just inferring it from
# ``cluster_representation`` in case the ``cluster`` has a more efficient
# installation method than a ``Cluster.from_nodes``.
# However, if the cluster is a ``Cluster.from_nodes``, ``destroy`` will not
# work and therefore we use ``cluster_representation.destroy`` instead.
try:
cluster.install_dcos_from_path(
dcos_installer=dcos_installer,
dcos_config=dcos_config,
ip_detect_path=ip_detect_path,
files_to_copy_to_genconf_dir=files_to_copy_to_genconf_dir,
output=Output.LOG_AND_CAPTURE,
)
except subprocess.CalledProcessError as exc:
spinner.stop()
click.echo('Error installing DC/OS.', err=True)
show_calledprocess_error(exc=exc)
click.echo(doctor_message)
cluster_representation.destroy()
sys.exit(exc.returncode)
spinner.succeed()
def install_dcos_from_path(
cluster: Cluster,
ip_detect_path: Path,
dcos_config: Dict[str, Any],
files_to_copy_to_genconf_dir: Iterable[Tuple[Path, Path]],
installer: Path,
doctor_command: click.core.Command,
sibling_ctx: click.core.Context,
) -> None:
"""
Install DC/OS on a cluster.
Args:
cluster: The cluster to install DC/OS on.
ip_detect_path: The ``ip-detect`` script to use for installing DC/OS.
files_to_copy_to_genconf_dir: Pairs of host paths to paths on the
installer node. These are files to copy from the host to the
installer node before installing DC/OS.
dcos_config: The DC/OS configuration to use.
installer: The path to a DC/OS installer.
doctor_command: A doctor command to suggest if the installation fails.
sibling_ctx: A context associated with a call to a sibling of
``doctor_command``.
"""
doctor_path = command_path(
sibling_ctx=sibling_ctx,
command=doctor_command,
)
doctor_message = 'Try `{doctor_path}` for troubleshooting help.'.format(
doctor_path=doctor_path,
)
try:
with click_spinner.spinner():
cluster.install_dcos_from_path(
dcos_installer=installer,
dcos_config=dcos_config,
ip_detect_path=ip_detect_path,
files_to_copy_to_genconf_dir=files_to_copy_to_genconf_dir,
)
except subprocess.CalledProcessError as exc:
click.echo('Error installing DC/OS.', err=True)
click.echo(doctor_message)
cluster.destroy()
sys.exit(exc.returncode)
def create(
agents: int,
artifact: str,
extra_config: Dict[str, Any],
masters: int,
public_agents: int,
variant: str,
workspace_dir: Optional[Path],
license_key: Optional[str],
security_mode: Optional[str],
copy_to_master: List[Tuple[Path, Path]],
cluster_id: str,
) -> None:
"""
Create a DC/OS cluster.
DC/OS Enterprise
\b
DC/OS Enterprise clusters require different configuration variables to DC/OS OSS.
For example, enterprise clusters require the following configuration parameters:
``superuser_username``, ``superuser_password_hash``, ``fault_domain_enabled``, ``license_key_contents``
\b
These can all be set in ``--extra-config``.
However, some defaults are provided for all but the license key.
\b
The default superuser username is ``admin``.
The default superuser password is ``admin``.
The default ``fault_domain_enabled`` is ``false``.
\b
``license_key_contents`` must be set for DC/OS Enterprise 1.11 and above.
This is set to one of the following, in order:
\b
* The ``license_key_contents`` set in ``--extra-config``.
* The contents of the path given with ``--license-key``.
* The contents of the path set in the ``DCOS_LICENSE_KEY_PATH`` environment variable.
\b
If none of these are set, ``license_key_contents`` is not given.
""" # noqa: E501
base_workspace_dir = workspace_dir or Path(tempfile.gettempdir())
workspace_dir = base_workspace_dir / uuid.uuid4().hex
workspace_dir.mkdir(parents=True)
doctor_message = 'Try `dcos-vagrant doctor` for troubleshooting help.'
artifact_path = Path(artifact).resolve()
if variant == 'auto':
variant = get_variant(
artifact_path=artifact_path,
workspace_dir=workspace_dir,
doctor_message=doctor_message,
)
enterprise = bool(variant == 'enterprise')
description = {
CLUSTER_ID_DESCRIPTION_KEY: cluster_id,
WORKSPACE_DIR_DESCRIPTION_KEY: str(workspace_dir),
VARIANT_DESCRIPTION_KEY: 'ee' if enterprise else '',
}
cluster_backend = Vagrant(
workspace_dir=workspace_dir,
virtualbox_description=json.dumps(obj=description),
)
if enterprise:
superuser_username = '******'
superuser_password = '******'
enterprise_extra_config = {
'superuser_username': superuser_username,
'superuser_password_hash': sha512_crypt.hash(superuser_password),
'fault_domain_enabled': False,
}
if license_key is not None:
key_contents = Path(license_key).read_text()
enterprise_extra_config['license_key_contents'] = key_contents
extra_config = {**enterprise_extra_config, **extra_config}
if security_mode is not None:
extra_config['security'] = security_mode
try:
cluster = Cluster(
cluster_backend=cluster_backend,
masters=masters,
agents=agents,
public_agents=public_agents,
files_to_copy_to_installer=[],
)
except CalledProcessError as exc:
click.echo('Error creating cluster.', err=True)
click.echo(doctor_message)
sys.exit(exc.returncode)
for node in cluster.masters:
for path_pair in copy_to_master:
local_path, remote_path = path_pair
node.send_file(
local_path=local_path,
remote_path=remote_path,
)
try:
with click_spinner.spinner():
cluster.install_dcos_from_path(
build_artifact=artifact_path,
dcos_config={
**cluster.base_config,
**extra_config,
},
)
except CalledProcessError as exc:
click.echo('Error installing DC/OS.', err=True)
click.echo(doctor_message)
cluster.destroy()
sys.exit(exc.returncode)
def create(
ctx: click.core.Context,
agents: int,
artifact: str,
cluster_id: str,
docker_storage_driver: str,
docker_version: str,
extra_config: Dict[str, Any],
linux_distribution: str,
masters: int,
public_agents: int,
license_key: Optional[str],
security_mode: Optional[str],
copy_to_master: List[Tuple[Path, Path]],
genconf_dir: Optional[Path],
workspace_dir: Optional[Path],
custom_volume: List[Mount],
custom_master_volume: List[Mount],
custom_agent_volume: List[Mount],
custom_public_agent_volume: List[Mount],
variant: str,
transport: Transport,
wait_for_dcos: bool,
network: Network,
) -> None:
"""
Create a DC/OS cluster.
DC/OS Enterprise
\b
DC/OS Enterprise clusters require different configuration variables to DC/OS OSS.
For example, enterprise clusters require the following configuration parameters:
``superuser_username``, ``superuser_password_hash``, ``fault_domain_enabled``, ``license_key_contents``
\b
These can all be set in ``--extra-config``.
However, some defaults are provided for all but the license key.
\b
The default superuser username is ``admin``.
The default superuser password is ``admin``.
The default ``fault_domain_enabled`` is ``false``.
\b
``license_key_contents`` must be set for DC/OS Enterprise 1.11 and above.
This is set to one of the following, in order:
\b
* The ``license_key_contents`` set in ``--extra-config``.
* The contents of the path given with ``--license-key``.
* The contents of the path set in the ``DCOS_LICENSE_KEY_PATH`` environment variable.
\b
If none of these are set, ``license_key_contents`` is not given.
""" # noqa: E501
base_workspace_dir = workspace_dir or Path(tempfile.gettempdir())
workspace_dir = base_workspace_dir / uuid.uuid4().hex
doctor_message = 'Try `dcos-docker doctor` for troubleshooting help.'
ssh_keypair_dir = workspace_dir / 'ssh'
ssh_keypair_dir.mkdir(parents=True)
public_key_path = ssh_keypair_dir / 'id_rsa.pub'
private_key_path = ssh_keypair_dir / 'id_rsa'
_write_key_pair(
public_key_path=public_key_path,
private_key_path=private_key_path,
)
artifact_path = Path(artifact).resolve()
if variant == 'auto':
variant = get_variant(
artifact_path=artifact_path,
workspace_dir=workspace_dir,
doctor_message=doctor_message,
)
enterprise = bool(variant == 'enterprise')
if enterprise:
superuser_username = '******'
superuser_password = '******'
enterprise_extra_config = {
'superuser_username': superuser_username,
'superuser_password_hash': sha512_crypt.hash(superuser_password),
'fault_domain_enabled': False,
}
if license_key is not None:
key_contents = Path(license_key).read_text()
enterprise_extra_config['license_key_contents'] = key_contents
extra_config = {**enterprise_extra_config, **extra_config}
if security_mode is not None:
extra_config['security'] = security_mode
files_to_copy_to_installer = []
if genconf_dir is not None:
container_genconf_path = Path('/genconf')
for genconf_file in genconf_dir.glob('*'):
genconf_relative = genconf_file.relative_to(genconf_dir)
relative_path = container_genconf_path / genconf_relative
files_to_copy_to_installer.append((genconf_file, relative_path))
cluster_backend = Docker(
custom_container_mounts=custom_volume,
custom_master_mounts=custom_master_volume,
custom_agent_mounts=custom_agent_volume,
custom_public_agent_mounts=custom_public_agent_volume,
linux_distribution=LINUX_DISTRIBUTIONS[linux_distribution],
docker_version=DOCKER_VERSIONS[docker_version],
storage_driver=DOCKER_STORAGE_DRIVERS.get(docker_storage_driver),
docker_container_labels={
CLUSTER_ID_LABEL_KEY: cluster_id,
WORKSPACE_DIR_LABEL_KEY: str(workspace_dir),
VARIANT_LABEL_KEY: 'ee' if enterprise else '',
},
docker_master_labels={'node_type': 'master'},
docker_agent_labels={'node_type': 'agent'},
docker_public_agent_labels={'node_type': 'public_agent'},
workspace_dir=workspace_dir,
transport=transport,
network=network,
)
try:
cluster = Cluster(
cluster_backend=cluster_backend,
masters=masters,
agents=agents,
public_agents=public_agents,
files_to_copy_to_installer=files_to_copy_to_installer,
)
except CalledProcessError as exc:
click.echo('Error creating cluster.', err=True)
click.echo(doctor_message)
sys.exit(exc.returncode)
nodes = {
*cluster.masters,
*cluster.agents,
*cluster.public_agents,
}
for node in nodes:
node.run(
args=['echo', '', '>>', '/root/.ssh/authorized_keys'],
shell=True,
)
node.run(
args=[
'echo',
public_key_path.read_text(),
'>>',
'/root/.ssh/authorized_keys',
],
shell=True,
)
for node in cluster.masters:
for path_pair in copy_to_master:
local_path, remote_path = path_pair
node.send_file(
local_path=local_path,
remote_path=remote_path,
)
try:
with click_spinner.spinner():
cluster.install_dcos_from_path(
build_artifact=artifact_path,
dcos_config={
**cluster.base_config,
**extra_config,
},
)
except CalledProcessError as exc:
click.echo('Error installing DC/OS.', err=True)
click.echo(doctor_message)
cluster.destroy()
sys.exit(exc.returncode)
click.echo(cluster_id)
if wait_for_dcos:
ctx.invoke(
wait,
cluster_id=cluster_id,
transport=transport,
skip_http_checks=bool(transport == Transport.DOCKER_EXEC),
)
return
started_message = (
'Cluster "{cluster_id}" has started. '
'Run "dcos-docker wait --cluster-id {cluster_id}" to wait for DC/OS '
'to become ready.').format(cluster_id=cluster_id)
click.echo(started_message, err=True)
