def testDefaultPath_MultiPathsInEnv(self):
env_path1 = os.path.join(file_utils.GetHomeDir(), 'one_kubeconfig')
os.environ['KUBECONFIG'] = env_path1
self.assertEqual(kconfig.Kubeconfig.DefaultPath(), env_path1)
env_path2 = os.path.join(file_utils.GetHomeDir(), 'another_kubeconfig')
os.environ['KUBECONFIG'] = os.pathsep.join([env_path2, env_path1])
self.assertEqual(kconfig.Kubeconfig.DefaultPath(), env_path2)
def _GetUserHomeDir():
if platforms.OperatingSystem.Current(
) == platforms.OperatingSystem.WINDOWS:
# %HOME% has precedence over %USERPROFILE% for files.GetHomeDir().
# The Docker config resides under %USERPROFILE% on Windows
return encoding.Decode(os.path.expandvars('%USERPROFILE%'))
else:
return files.GetHomeDir()
def _get_docker_config(*unused_args, **kwargs):
force_new = kwargs.get('force_new', False)
home = files.GetHomeDir()
new_path = os.path.join(home, '.docker', 'config.json')
old_path = os.path.join(home, '.dockercfg')
if os.path.exists(new_path) or force_new:
return new_path, True
return old_path, False
def _HandleFileWriteImpl(self,
is_binary,
path,
private=False,
append=False,
create_path=False):
"""Intercept calls to write files."""
abs_path = os.path.abspath(path)
cwd = os.path.abspath(os.getcwd())
config_dir = os.path.abspath(config.Paths().global_config_dir)
home_dir = os.path.abspath(files.GetHomeDir())
is_known_location = (abs_path.startswith(cwd)
or abs_path.startswith(home_dir)
or abs_path.startswith(config_dir))
# We have to do this because under tests, all the above are actually under
# the temp directory because they are mocked out.
temp_dir = os.path.abspath(tempfile.gettempdir())
is_temp = abs_path.startswith(temp_dir) and not is_known_location
is_compute_ssh_hosts_file = path.endswith(
os.path.join('.ssh', 'google_compute_known_hosts'))
if not (is_known_location or is_temp or is_compute_ssh_hosts_file):
raise Error(
'Command is attempting to write file outside of current '
'working directory: [{}]'.format(abs_path))
# Pass through the write like normal
if is_binary:
with self._orig_binary_file_writer(path,
private=private,
create_path=create_path) as fw:
yield fw
else:
with self._orig_file_writer(path,
private=private,
append=append,
create_path=create_path) as fw:
yield fw
# After they close it, capture what happened.
if abs_path.startswith(config_dir) or is_temp:
# Ignore any files written to config or tmp for assertion purposes.
return
current_event = self._GetOrCreateNextEvent(
events_lib.EventType.FILE_WRITTEN)
if is_binary:
contents = files.ReadBinaryFileContents(path)
else:
contents = files.ReadFileContents(path)
if abs_path.startswith(home_dir):
path = '~' + abs_path[len(home_dir):]
self._Handle(current_event, path, contents, private)
def __init__(self):
cfg_paths = config.Paths()
# Ordered list of replacements. First match wins, more specific paths should
# be placed before more general ones.
self._replacements = [
(re.escape(os.path.normpath(cfg_paths.global_config_dir)),
'${CLOUDSDK_CONFIG}'),
(re.escape(file_utils.GetHomeDir()), '${HOME}'),
(re.escape(getpass.getuser()), '${USER}')
]
if cfg_paths.sdk_root:
self._replacements.append(
(re.escape(os.path.normpath(cfg_paths.sdk_root)),
'${SDK_ROOT}'))
def testKubeconfigEnvvar(self):
default_path = kconfig.Kubeconfig.DefaultPath()
env_path = os.path.join(file_utils.GetHomeDir(), 'other_kubeconfig')
file_utils.MakeDir(os.path.dirname(default_path))
with open(default_path, 'w') as fp:
fp.write(_EXISTING_KUBECONFIG)
kubeconfig = kconfig.Kubeconfig.Default()
self.assertEqual(kubeconfig.current_context, 'existing-context')
# We overwrite $HOME in base.UnitTestBase.SetUp
os.environ['KUBECONFIG'] = env_path
kubeconfig = kconfig.Kubeconfig.Default()
self.assertEqual(kubeconfig.current_context, '')
with open(default_path, 'r') as fp:
self.assertEqual(fp.read(), _EXISTING_KUBECONFIG)
with open(env_path, 'r') as fp:
self.assertEqual(fp.read(), _EMPTY_KUBECONFIG)
def _GetGlobalConfigDir():
"""Returns the path to the user's global config area.
Returns:
str: The path to the user's global config area.
"""
# Name of the directory that roots a cloud SDK workspace.
global_config_dir = encoding.GetEncodedValue(os.environ, CLOUDSDK_CONFIG)
if global_config_dir:
return global_config_dir
if platforms.OperatingSystem.Current() != platforms.OperatingSystem.WINDOWS:
return os.path.join(file_utils.GetHomeDir(), '.config',
_CLOUDSDK_GLOBAL_CONFIG_DIR_NAME)
appdata = encoding.GetEncodedValue(os.environ, 'APPDATA')
if appdata:
return os.path.join(appdata, _CLOUDSDK_GLOBAL_CONFIG_DIR_NAME)
# This shouldn't happen unless someone is really messing with things.
drive = encoding.GetEncodedValue(os.environ, 'SystemDrive', 'C:')
return os.path.join(drive, os.path.sep, _CLOUDSDK_GLOBAL_CONFIG_DIR_NAME)
def _GetAndUpdateRcPath(completion_update, path_update, rc_path, host_os):
"""Returns an rc path based on the default rc path or user input.
Gets default rc path based on environment. If prompts are enabled,
allows user to update to preferred file path. Otherwise, prints a warning
that the default rc path will be updated.
Args:
completion_update: bool, Whether or not to do command completion.
path_update: bool, Whether or not to update PATH.
rc_path: str, the rc path given by the user, from --rc-path arg.
host_os: str, The host os identification string.
Returns:
str, A path to the rc file to update.
"""
# If we aren't updating the RC file for either completions or PATH, there's
# no point.
if not (completion_update or path_update):
return None
if rc_path:
return rc_path
# A first guess at user preferred shell.
preferred_shell = _GetPreferredShell(
encoding.GetEncodedValue(os.environ, 'SHELL', '/bin/sh'))
default_rc_path = os.path.join(
files.GetHomeDir(), _GetShellRcFileName(preferred_shell, host_os))
# If in quiet mode, we'll use default path.
if not console_io.CanPrompt():
_TraceAction(
'You specified that you wanted to update your rc file. The '
'default file will be updated: [{rc_path}]'.format(
rc_path=default_rc_path))
return default_rc_path
rc_path_update = console_io.PromptResponse(
('The Google Cloud SDK installer will now prompt you to update an rc '
'file to bring the Google Cloud CLIs into your environment.\n\n'
'Enter a path to an rc file to update, or leave blank to use '
'[{rc_path}]: ').format(rc_path=default_rc_path))
return (files.ExpandHomeDir(rc_path_update)
if rc_path_update else default_rc_path)
def _DockerRunOptions(enable_gpu=False,
container_home_to_mount=None,
extra_run_opts=None):
"""Returns a list of 'docker run' options.
Args:
enable_gpu: (bool) using GPU or not
container_home_to_mount: (str) $HOME directory in the container
extra_run_opts: (List[str]) other custom docker run options
"""
if extra_run_opts is None:
extra_run_opts = []
runtime = ["--runtime", "nvidia"] if enable_gpu else []
mount = []
if container_home_to_mount is not None:
mount = [
"-v", "{}:{}".format(files.GetHomeDir(), container_home_to_mount)
]
return ["--rm"] + runtime + mount + ["--ipc", "host"] + extra_run_opts
def testProcessHomeFileURI(self):
self.assertEqual(
'file://${HOME}',
self.anonymizer.ProcessURL('file://' + file_utils.GetHomeDir()))
def _ParameterizePath(path):
"""Return path with $HOME prefix replaced by ~."""
home = files.GetHomeDir() + os.path.sep
if path.startswith(home):
return '~' + os.path.sep + path[len(home):]
return path
CONTEXT_AWARE_ACCESS_DENIED_ERROR = 'access_denied'
CONTEXT_AWARE_ACCESS_DENIED_ERROR_DESCRIPTION = 'Account restricted'
CONTEXT_AWARE_ACCESS_HELP_MSG = (
'Access was blocked due to an organization policy, please contact your '
'admin to gain access.'
)
def IsContextAwareAccessDeniedError(exc):
exc_text = six.text_type(exc)
return (CONTEXT_AWARE_ACCESS_DENIED_ERROR in exc_text and
CONTEXT_AWARE_ACCESS_DENIED_ERROR_DESCRIPTION in exc_text)
DEFAULT_AUTO_DISCOVERY_FILE_PATH = os.path.join(
files.GetHomeDir(), '.secureConnect', 'context_aware_metadata.json')
def _AutoDiscoveryFilePath():
"""Return the file path of the context aware configuration file."""
# auto_discovery_file_path is an override used for testing purposes.
cfg_file = properties.VALUES.context_aware.auto_discovery_file_path.Get()
if cfg_file is not None:
return cfg_file
return DEFAULT_AUTO_DISCOVERY_FILE_PATH
class ConfigException(exceptions.Error):
def __init__(self):
super(ConfigException, self).__init__(
from __future__ import division
from __future__ import unicode_literals
import atexit
import io
import json
import os
from googlecloudsdk.core import config
from googlecloudsdk.core import exceptions
from googlecloudsdk.core import execution_utils
from googlecloudsdk.core import log
from googlecloudsdk.core import properties
from googlecloudsdk.core.util import files
DEFAULT_AUTO_DISCOVERY_FILE_PATH = os.path.join(files.GetHomeDir(),
'.secureConnect',
'context_aware_metadata.json')
def _AutoDiscoveryFilePath():
"""Return the file path of the context aware configuration file."""
# auto_discovery_file_path is an override used for testing purposes.
cfg_file = properties.VALUES.context_aware.auto_discovery_file_path.Get()
if cfg_file is not None:
return cfg_file
return DEFAULT_AUTO_DISCOVERY_FILE_PATH
def _SplitPemIntoSections(contents):
"""Returns dict with {name: section} by parsing contents in PEM format.
def testProcessFakeHomePath(self):
home_path = file_utils.GetHomeDir() + '_other'
self.assertEqual('${HOME}_other', self.anonymizer.ProcessPath(home_path))
def testProcessHomePath(self):
self.assertEqual(
'${HOME}',
self.anonymizer.ProcessPath(file_utils.GetHomeDir()))
def testProcessFakeHomeFileURI(self):
home_uri = 'file://' + file_utils.GetHomeDir() + '_other'
self.assertEqual(
'file://${HOME}_other',
self.anonymizer.ProcessURL(home_uri))
def testProcessHomePath_NonNormalized(self):
self.assertEqual(
'${HOME}',
self.anonymizer.ProcessPath(
os.path.join(file_utils.GetHomeDir(), 'tmp', '..')))
def testProcessHomeFileURI_NonNormalized(self):
self.assertEqual(
'file://${HOME}',
self.anonymizer.ProcessURL(
os.path.join('file://' + file_utils.GetHomeDir(), 'tmp', '..')))
def SetUp(self):
self.boto_path = os.path.join(files.GetHomeDir(), '.boto')
self._CleanupBotoConfig()
