def _CreateBotoConfig(self): gsutil_path = _FindGsutil() if not gsutil_path: log.debug('Unable to find [gsutil]. Not configuring default .boto ' 'file') return boto_path = platforms.ExpandHomePath(os.path.join('~', '.boto')) if os.path.exists(boto_path): log.debug('Not configuring default .boto file. File already ' 'exists at [{boto_path}].'.format(boto_path=boto_path)) return # 'gsutil config -n' creates a default .boto file that the user can read and # modify. command_args = ['config', '-n', '-o', boto_path] if platforms.OperatingSystem.Current() == platforms.OperatingSystem.WINDOWS: gsutil_args = execution_utils.ArgsForCMDTool(gsutil_path, *command_args) else: gsutil_args = execution_utils.ArgsForExecutableTool(gsutil_path, *command_args) return_code = execution_utils.Exec(gsutil_args, no_exit=True, out_func=log.file_only_logger.debug, err_func=log.file_only_logger.debug) if return_code == 0: log.status.write("""\ Created a default .boto configuration file at [{boto_path}]. See this file and [https://cloud.google.com/storage/docs/gsutil/commands/config] for more information about configuring Google Cloud Storage. """.format(boto_path=boto_path)) else: log.status.write('Error creating a default .boto configuration file. ' 'Please run [gsutil config -n] if you would like to ' 'create this file.\n')
def RunGsutilCommand(command_name, command_args=None, run_concurrent=False, out_func=log.file_only_logger.debug, err_func=log.file_only_logger.debug): """Runs the specified gsutil command and returns the command's exit code. This is more reliable than storage_api.StorageClient.CopyFilesToGcs especially for large files. Args: command_name: The gsutil command to run. command_args: List of arguments to pass to the command. run_concurrent: Whether concurrent uploads should be enabled while running the command. out_func: str->None, a function to call with the stdout of the gsutil command. err_func: str->None, a function to call with the stderr of the gsutil command. Returns: The exit code of the call to the gsutil command. """ command_path = _GetGsutilPath() args = ['-m', command_name] if run_concurrent else [command_name] if command_args is not None: args += command_args if platforms.OperatingSystem.Current() == platforms.OperatingSystem.WINDOWS: gsutil_args = execution_utils.ArgsForCMDTool(command_path + '.cmd', *args) else: gsutil_args = execution_utils.ArgsForExecutableTool(command_path, *args) log.debug('Running command: [{args}]]'.format(args=' '.join(gsutil_args))) return execution_utils.Exec(gsutil_args, no_exit=True, out_func=out_func, err_func=err_func)
def RunKubectlCommand(args, out_func=None, err_func=None): """Shells out a command to kubectl. This command should be called within the context of a TemporaryKubeconfig context manager in order for kubectl to be configured to access the correct cluster. Args: args: list of strings, command line arguments to pass to the kubectl command. Should omit the kubectl command itself. For example, to execute 'kubectl get pods', provide ['get', 'pods']. out_func: str->None, a function to call with the stdout of the kubectl command err_func: str->None, a function to call with the stderr of the kubectl command Raises: Error: if kubectl could not be called KubectlError: if the invocation of kubectl was unsuccessful """ kubectl_path = files.FindExecutableOnPath(_KUBECTL_COMPONENT_NAME, config.Paths().sdk_bin_path) if kubectl_path is None: raise Error(MISSING_KUBECTL_MSG) try: retval = execution_utils.Exec( execution_utils.ArgsForExecutableTool(kubectl_path, *args), no_exit=True, out_func=out_func, err_func=err_func, universal_newlines=True) except (execution_utils.PermissionError, execution_utils.InvalidCommandError) as e: raise KubectlError(six.text_type(e)) if retval: raise KubectlError('kubectl returned non-zero status code.')
def ExecuteJavaClass(java_bin, jar_dir, main_jar, main_class, java_flags=None, main_args=None): """Execute a given java class within a directory of jars. Args: java_bin: str, path to the system Java binary jar_dir: str, directory of jars to put on class path main_jar: str, main jar (placed first on class path) main_class: str, name of the main class in the jar java_flags: [str], flags for the java binary main_args: args for the command """ java_flags = java_flags or [] main_args = main_args or [] jar_dir_path = os.path.join(SDK_ROOT, jar_dir, '*') main_jar_path = os.path.join(SDK_ROOT, jar_dir, main_jar) classpath = main_jar_path + os.pathsep + jar_dir_path java_args = (['-cp', classpath] + list(java_flags) + [main_class] + list(main_args)) _ExecuteTool(execution_utils.ArgsForExecutableTool(java_bin, *java_args))
def GetArgsForLegacyScript(script_name, args, interpreter=None): """Returns a list of args for execution of the given script. Args: script_name: The name of the script to run. The extension determines which interpreter will be used for execution. Python will be used for .py. If there is no extension it is assumed it is just a binary file and is executed directly. .exe files are executed directly on Windows, or error raised if not on Windows. If it ends with a single dot, it sees what OS it is running on and either executes .cmd or .sh. args: The arguments for the script itself interpreter: an interpreter to use rather than trying to derive it from the extension name. The value is the same as an extension, right now only implemented for 'py'. Returns: a list of args for the process executor Raises: ValueError: if the script type cannot be determined or is invalid for OS """ (_, tail) = os.path.splitext(script_name) # No extension, just try to execute it if not tail and not interpreter: # In our tests, users generally just refer to 'gcloud'. But in windows, # there is no 'gcloud' file, there is gcloud.cmd. This isn't an issue on the # shell because the shell, given <name>, is smart enough to detect that # there is a file <name>.cmd. subprocess.Popen is not smart enough to know # this, however, unless shell=True is given. We'd like to avoid that if # possible, however. if _IsOnWindows() and script_name == 'gcloud': script_name = 'gcloud.cmd' return execution_utils.ArgsForExecutableTool(FullPath(script_name), *args) # Strip the '.' if interpreter: ext = interpreter else: ext = tail[1:] # Python, same across platforms if ext == 'py': return execution_utils.ArgsForPythonTool(FullPath(script_name), *args) # .exe, windows only if ext == 'exe': if not _IsOnWindows(): raise ValueError('Extention for {0} is only valid for WINDOWS'.format( script_name)) return execution_utils.ArgsForExecutableTool(FullPath(script_name), *args) # ending in a '.' if not ext: if _IsOnWindows(): return execution_utils.ArgsForCMDTool( FullPath(script_name + 'cmd'), *args) else: return execution_utils.ArgsForExecutableTool( FullPath(script_name + 'sh'), *args) else: raise ValueError('Unknown script type: {0}'.format(script_name))