__init__.py 0000644 00000003131 14720535656 0006670 0 ustar 00 from base64 import b64encode
import functools
import random
import string
def b64str(s: str) -> str:
"""Return `s` base64-encoded.
:param s: string to encode
"""
return b64encode(s.encode()).decode()
def fmap(func, obj):
"Homomorphic mapping of a function"
# strings are specifically not fmap-able because that invites
# consideration as byte characters, not unicode
if isinstance(obj, tuple):
return tuple(map(functools.partial(fmap, func), obj))
iterableitems = isinstance(obj, (list, dict))
if not iterableitems:
try:
iterableitems = isinstance(obj, (filter, map, zip, range))
except TypeError: # pragma: nocover
# Python2 doesn't have objects like the above
# The corresponding operations just result in lists
# which is already covered
pass
if iterableitems:
if hasattr(obj, 'items'):
return dict(map(functools.partial(fmap, func), obj.items()))
return list(map(functools.partial(fmap, func), obj))
if hasattr(obj, 'fmap'):
return obj.fmap(func)
return func(obj)
def random_password(length: int = None) -> str:
"""Create a random password.
:param length: An int specifying password length
:returns: the password, in cleartext
"""
if not length:
length = random.randint(10, 23)
edited_punctuation = string.punctuation.replace('"', '').replace("'", "").replace("\\", "")
return ''.join([random.choice(string.digits + string.ascii_letters + edited_punctuation)
for X in range(length)])
execute.py 0000644 00000047007 14720535656 0006605 0 ustar 00 # -*- coding: utf-8 -*-
import logging
import os
import sys
import subprocess
import tempfile
from pathlib import Path
from typing import Any, Tuple, Union, List
from subprocess import list2cmdline
from primordial.sizes import ByteSize
from customer_local_ops.util import fmap
DEFAULT_MAX_SEGMENT_SIZE = ByteSize(KiBytes=32)
LOG = logging.getLogger(__name__)
MAX_COMMAND_RESPONSE_BUFFER_SIZE = 2 * DEFAULT_MAX_SEGMENT_SIZE
# Type aliases
RunCommandResult = Tuple[int, str, str]
# pylint: disable=import-error
if sys.platform == 'win32':
import win32con
from win32com.shell import shellcon
from win32com.shell import shell
HANDLE = int
HWND = int
HKEY = int
DWORD = int
def shell_start(file_name: str,
params: str = None,
verb: str = "open",
show: int = win32con.SW_SHOWNORMAL,
mask: int = shellcon.SEE_MASK_FLAG_DDEWAIT,
dir_name: str = None,
id_list: Any = None,
class_id: str = None,
class_key: HKEY = None,
hot_key: DWORD = None,
monitor: HANDLE = None,
window: HWND = None) -> bool:
"""
Wrapper for the Win32 API call ShellExecuteEx. This function can be used on Windows platforms any time Nydus
needs to restart itself for any reason because ShellExecuteEx allows the child process to survive after its
parent process stops. Initially added to resolve a DLL conflict issue, this could also be useful for
upgrading Nydus, for example.
Further information for ShellExecuteEx can be found at
https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shellexecuteexa
:param file_name: The name of the executable to be started. ShellExecuteEx also handles file associations,
so this could also be the name of a document, for example, to be opened with the
associated application, or a URL to be opened by the user's default browser.
:param params: Parameters to be passed to the application. Should not be specified if file_name
is NOT an executable file.
:param verb: Action to take. May be one of 'edit', 'explore', 'find', 'open', 'print', 'properties' or
'runas'. Defaults to 'open'
:param show: Specify how an application is to be shown
:param mask: Flags that indicate content and validity of other parameters
:param dir_name: Name of the working directory. If None, the current directory is used
:param id_list: See Microsoft documentation at the URL above
:param class_id: See Microsoft documentation at the URL above
:param class_key: See Microsoft documentation at the URL above
:param hot_key: See Microsoft documentation at the URL above
:param monitor: See Microsoft documentation at the URL above
:param window: See Microsoft documentation at the URL above
:return: True if the file/application is successfully launched; otherwise, False
"""
def add_field(key: str, val: Any) -> None:
"""
It is an error to include a field with a value of None in the structure passed to ShellExecuteEx, so this
function only adds a key to the dictionary if the value is not None.
:param key: The name of the SHELLEXECUTEINFO field
:param val: The value of the field
"""
if val is not None:
shell_execute_info[key] = val
shell_execute_info = {}
add_field('fMask', mask)
add_field('hwnd', window)
add_field('lpVerb', verb)
add_field('lpFile', file_name)
add_field('lpParameters', params)
add_field('lpDirectory', dir_name)
add_field('nShow', show)
add_field('lpIDList', id_list)
add_field('lpClass', class_id)
add_field('hkeyClass', class_key)
add_field('dwHotKey', hot_key)
add_field('hMonitor', monitor)
return shell.ShellExecuteEx(**shell_execute_info)
else:
def shell_start(**kwargs) -> bool:
return True
def pfx(line):
return '| ' + line
def pfxs(lines):
return list(map(pfx, lines))
def trim_visible_output_to_lines(inp, out):
"""Converts input blob to lines... but not too many"""
if inp is not None:
out = out.replace(inp, '<>', 1)
outl = out.strip().split('\n')
if not outl:
return outl
if len(outl) == 1 and not outl[0].strip():
return [] # no single blank lines please
if len(outl) < 11:
return pfxs(outl)
return pfxs(outl[:5] + ['...elided %d lines...' % (len(outl) - 10)] + outl[-5:])
def mark_error_output(errOut):
"Converts error blob into lines with prefix marks"
se = errOut.strip()
if se:
for L in se.split('\n'):
yield 'ERR: ' + L
class EndsBuffer:
"""String buffer that maintains two segments: a first segment and a
last segment (i.e. the two ends), where each has a maximum size
limit. Any extra output in between these is discarded. The
assumption is that if there is a huge amount of output that
some must be discarded to avoid memory overflows and that
generally the first and last stuff is the most relevant.
"""
def __init__(self, max_segment_size=None):
self._mss = ByteSize(max(0, max_segment_size or 0)) or DEFAULT_MAX_SEGMENT_SIZE
self._data = ''
self._elided = False
def add_str(self, data):
self._data += data
if len(self._data) > self._mss * 2:
self._data = self._data[:self._mss] + self._data[-int(self._mss):]
self._elided = True
def get_bufstr(self):
if self._elided:
return '\n'.join([
self._data[:self._mss],
'...[elided]...',
self._data[-int(self._mss):],
])
return self._data
def str_form(bytestr):
try:
return bytestr.decode('utf-8', errors='backslashreplace')
except UnicodeDecodeError:
try:
import chardet # pylint: disable=import-outside-toplevel
try:
return bytestr.decode(chardet.detect(bytestr)['encoding'])
except UnicodeDecodeError:
pass
except ImportError:
pass
except AttributeError:
return bytestr # already a string
class RunningCommand:
def __init__(self, popen_obj, tag, stdInput, errorOK, logger,
max_buffer_size=MAX_COMMAND_RESPONSE_BUFFER_SIZE):
self.p = popen_obj
self.tag = tag
self.stdInput = stdInput
self.logger = (lambda r, _l=logger or LOG, e=errorOK:
getattr(_l, "error" if r and not e else "info"))
self._bufsize = max_buffer_size
self._output = EndsBuffer(self._bufsize / 2)
self._errors = EndsBuffer(self._bufsize / 2)
self._partial = False
self._completed = False
def checkIfCompleted(self):
self._output.add_str(str_form(self.p.stdout.read()))
self._errors.add_str(str_form(self.p.stderr.read()))
return self.p.poll() is not None
def outputToDate(self):
o = self._output.get_bufstr()
e = self._errors.get_bufstr()
self._output = EndsBuffer(self._bufsize / 2)
self._errors = EndsBuffer(self._bufsize / 2)
self._partial = True
return o, e
def waitForCompletion(self):
# n.b. communicate returns byte strings, in an unknown encoding, although
# with older python, they could also be strings
o, e = fmap(str_form, self.p.communicate())
self._output.add_str(o)
self._errors.add_str(e)
self._completed = True
return self
def getResult(self, omitOutput=False):
if not self._completed:
self.waitForCompletion()
outs, errs = self._output.get_bufstr(), self._errors.get_bufstr()
output_lines = trim_visible_output_to_lines(self.stdInput, outs)
if omitOutput:
output_lines = [line if line.startswith("<>") else "<>" for line in output_lines]
for line in (output_lines
+ list(mark_error_output(errs))
+ ["ExitCode: %d" % self.p.returncode]):
lstr = self.tag + ' ' + line
self.logger(self.p.returncode)(lstr)
# NOTE This is not a Nydus Result; it must be converted
return self.p.returncode, outs.strip(), errs.strip()
def startCommand(cmd, tag, useShell=False, stdInput=None, errorOK=False,
logger=None, omitString=None, env=None):
"""Starts the specified command; no Shell. The cmd is expected to be an
array of strings, although it is also possible to specify
simply a string if there are no arguments to the command.
The tag value is only used to annotate log lines for
distinctive tagging in the logging output.
If errorOK is True then a non-zero return code is still only
logged as "info" instead of "error". The ProcOpResult will
accurately reflect the result of the operation regardless of
the errorOK argument.
If omitString is specified, it is removed from any logging output.
The command is run asynchronously in a separate process. The
return value is a RunningCommand object that supports a
.checkIfCompleted() method to test for subprocess completion
(non-blocking) and a .getResult() to get the ProcOpResult of a
completed process (will block until completion if not already
completed).
"""
# if cmd is a string, leave as is to correctly obfuscate omitString
# If cmd is a bytestring, make sure omitString and the replacement text are also bytestrings
log_cmd = ' '.join(cmd) if isinstance(cmd, list) else cmd
replace_text = "<>"
if isinstance(log_cmd, bytes):
if omitString is not None and isinstance(omitString, str):
omitString = omitString.encode('utf-8')
replace_text = b'<>'
if omitString:
log_cmd = log_cmd.replace(omitString, replace_text)
if logger is None:
logger = LOG
logger.info(tag + " RUN: " + str(log_cmd)) # pylint: disable=logging-not-lazy
# pylint: disable=consider-using-with
p = subprocess.Popen(cmd,
shell=useShell,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env)
if stdInput:
p.stdin.write(stdInput.encode())
return RunningCommand(p, tag, stdInput, errorOK, logger)
def runCommand(cmd, tag, useShell=False, stdInput=None, errorOK=False,
logger=None, omitString=None, omitOutput=False, env=None):
"""Runs the specified command and waits for completion; no Shell. The
cmd is expected to be an array of strings, although it is also
possible to specify simply a string if there are no arguments
to the command.
The tag value is only used to annotate log lines for
distinctive tagging in the logging output.
If errorOK is True then a non-zero return code is still only
logged as "info" instead of "error". The ProcOpResult will
accurately reflect the result of the operation regardless of
the errorOK argument.
If omitString is specified, it is removed from any logging output.
"""
return startCommand(cmd, tag,
useShell=useShell,
stdInput=stdInput,
errorOK=errorOK,
logger=logger,
omitString=omitString,
env=env) \
.waitForCompletion() \
.getResult(omitOutput=omitOutput)
def run_command_pipe(cmd, useShell=False):
"""Used to run commands that make use of | """
p = subprocess.Popen(cmd, shell=useShell, stdout=subprocess.PIPE)
with p:
o, e = p.communicate()
return p.returncode, o, e
def run_powershell(command: str, tag: str, quiet: bool = False) -> Tuple[int, str, str]:
"""Execute the code in ``command`` using PowerShell.
:param command: Code to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:return: Tuple containing (exit_code, stdout, stderr)
"""
# 1. Python 3.5 Windows: cannot use context manager - it does not unlink the file on exit.
# 2. Encode in UTF-8 with byte order mark (BOM) so PowerShell 5.1 (Windows 2016) sees the file is UTF-8. Without
# this, the file will be encoded with the default system encoding which can be changed by administrators and
# which, by default, cannot encode all Unicode characters properly. Encoding as UTF-8 without BOM does not work
# because standard output cannot be decoded as UTF-8.
# - Encoding PowerShell scripts:
# https://docs.microsoft.com/en-us/powershell/scripting/dev-cross-plat/
# vscode/understanding-file-encoding?view=powershell-7.1
# - utf-8-sig encoding: https://docs.python.org/3.5/library/codecs.html#encodings-and-unicode
# - Default encoding (locale.getpreferredencoding()): https://docs.python.org/3.5/library/functions.html#open
# pylint: disable=consider-using-with
temp = tempfile.NamedTemporaryFile(mode='w+t', encoding='utf-8-sig', suffix='.ps1', delete=False)
try:
temp.write(command)
temp.close()
if not quiet:
LOG.debug("Running PowerShell command: %s", command)
return run_powershell_file(temp.name, tag, quiet)
finally:
os.unlink(temp.name)
def run_shell_script_file(script_file: Union[str, Path], tag: str,
quiet: bool = False, script_file_args: List[str] = None,
stdin: str = None) -> Tuple[int, str, str]:
"""Invoke Shell script, passing just ``filename`` or ``filepath`` and a list of arguments for execution of the file
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:param stdin: string to pass through standard input
:return: Tuple containing (exit_code, stdout, stderr)
"""
command = ['bash', str(script_file)]
if script_file_args:
for arg in script_file_args:
command.append(str(arg))
return runCommand(command, tag, stdInput=stdin, omitOutput=quiet)
def run_powershell_file(script_file: Union[str, Path], tag: str,
quiet: bool = False, script_file_args: List[str] = None,
stdin: str = None) -> Tuple[int, str, str]:
"""Invoke PowerShell, passing just ``filename`` or ``filename`` and a list of arguments for execution of the file
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:param stdin: string to pass through standard input
:return: Tuple containing (exit_code, stdout, stderr)
"""
command = ['powershell.exe', '-ExecutionPolicy', 'Unrestricted', '-File', str(script_file)]
if script_file_args:
for arg in script_file_args:
command.append(str(arg))
return runCommand(command, tag, stdInput=stdin, omitOutput=quiet)
def run_uapi_command(cmd_list: Union[str, List[str]], description: str, op_name: str,
use_shell: bool = False, omit_string: str = None) -> Tuple[bool, str, str]:
"""Run a command on the target machine
:param cmd_list: string or list of strings that represents a command to be executed
:param description: short description of what the command is doing
:param op_name: name of the operation that is running the command
:param use_shell: indicator that the command should be executed in a shell
:param omit_string: a string to be removed from any logging output.
:return: Tuple containing (exit_code, stdout, stderr)
"""
cmd_list_str = str(cmd_list)
if omit_string:
cmd_list_str = cmd_list_str.replace(omit_string, "<>")
LOG.debug("run_uapi_command %s cmd_list: %s", op_name, cmd_list_str)
exit_code, outs, errs = runCommand(cmd_list, description, useShell=use_shell, omitString=omit_string)
LOG.debug("%s_result- %s - %s - %s", description, exit_code, outs, errs)
return exit_code, outs, errs
def run_multiple_uapi_commands(cmds_list: List[Tuple[str, Union[str, List[str]]]], op_name: str,
use_shell: bool = False, omit_string: str = None) -> Tuple[bool, str, str]:
"""Run a command on the target machine
:param cmds_list: List of tuples with description-command pairs
:param op_name: name of the operation that is running the command
:param use_shell: indicator that the command should be executed in a shell
:param omit_string: a string to be removed from any logging output.
:return: Tuple containing (exit_code, stdout, stderr)
"""
exit_code, outs, errs = 0, '', ''
for description, cmd in cmds_list:
exit_code, outs, errs = run_uapi_command(cmd, description, op_name, use_shell=use_shell,
omit_string=omit_string)
if exit_code != 0:
return exit_code, outs, errs
return exit_code, outs, errs
def start_powershell_file(script_file: Union[str, Path]) -> Tuple[int, str, str]:
"""
Invoke PowerShell, passing just ``filename`` or ``filename`` and a list of arguments for execution of the file.
Do not wait for the sub-process to complete. The exit code returned in the tuple only indicates whether or
not the process was successfully started.
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:return: Tuple containing (exit_code, stdout, stderr)
"""
params = list2cmdline(['-ExecutionPolicy', 'Unrestricted', '-File', str(script_file)])
LOG.info("Staring PowerShell: powershell.exe %s", params)
code = 0 if shell_start('powershell.exe', params=params) else 1
return code, '', ''
def start_powershell(command: str) -> Tuple[int, str, str]:
"""Execute the code in ``command`` using PowerShell.
:param command: Code to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:return: Tuple containing (exit_code, stdout, stderr)
"""
# Because the process started by this command could (and probably will) survive after this process has exited,
# we can't delete the temporary file, here.
# pylint: disable=consider-using-with
temp = tempfile.NamedTemporaryFile(mode='w+t', suffix='.ps1', delete=False)
temp.write(command)
temp.close()
LOG.debug("Running Powershell command: %s", command)
return start_powershell_file(temp.name)
helpers.py 0000644 00000004554 14720535656 0006605 0 ustar 00 # -*- coding: utf-8 -*-
"""\
© Copyright. All rights reserved.
"""
from __future__ import unicode_literals
from fileinput import FileInput
from functools import reduce
import sys
class HandledFailureException(Exception):
pass
def edit_file_lines(filename, editfunc):
"""Iterates through the lines of the named file, calling the editfunc
for each line, replacing the original file with the new
output.
"""
with FileInput(files=(filename,), inplace=True) as f:
for line in f:
sys.stdout.write(editfunc(line))
def replace_file_lines_multiple(filename, replace_dict, firstword=True):
"""Iterates through the lines of the named file, and through a
dictionary of match -> replace pairs, replacing all that apply for each line,
and replacing the original file with the new output.
"""
with FileInput(files=(filename,), inplace=True) as f:
for line in f:
updated_line = line
for match, replace in replace_dict.items():
updated_line = replace_line(updated_line, match, replace, firstword)
sys.stdout.write(updated_line)
def replace_line(line, match, replace, firstword=True):
"""Checks `line` to see if it starts with `match`; if yes, return
`replace`, otherwise return the original `line`. If
`firstword` is True, then the match must be followed by at
least one space or tab (unless it matches the entire line),
otherwise it is matched directly.
Suitable for use as an editfunc with `edit_file_lines`.
"""
# pylint: disable=too-many-boolean-expressions
if (
line.strip() == match
or (firstword and (line.startswith(match+' ') or line.startswith(match+'\t')))
or (not firstword and line.startswith(match))
):
return replace
return line
def append_line(filename, line):
"""Appends a line to to the specified file.
"""
with open(filename, 'a', encoding='UTF-8') as file:
file.write('\n')
file.write(line)
def create_file(filename, contents):
"""Creates the specified file, with the specified contents.
Overwrites any file already existing at that location.
"""
with open(filename, 'w', encoding='UTF-8') as wf:
wf.write(contents)
def compose(*funcs):
return reduce(lambda f, g: lambda x: f(g(x)), funcs, lambda x: x)
retry.py 0000644 00000004140 14720535656 0006277 0 ustar 00 # -*- coding: utf-8 -*-
"""\
© Copyright. All rights reserved.
"""
from __future__ import unicode_literals
from datetime import datetime, timedelta
from functools import wraps
import logging
LOG = logging.getLogger(__name__)
class Retry:
"""Ops decorated with @retry can return a Retry instance to request retry
with the interval and timeout as specified in the decorator. See also the
RETRY sentinel if there is no intermediate_result.
"""
def __init__(self, intermediate_result=None):
if not (intermediate_result is None or
isinstance(intermediate_result, dict)):
raise TypeError('Retry intermediate_result must be dictionary '
'but got %s' % type(intermediate_result))
self.intermediate_result = intermediate_result
def __str__(self):
return 'Retry ' + str(self.__dict__)
RETRY = Retry() # A Retry that can be returned from ops decorated with @retry
# when there is no intermediate_result.
def retry(interval=2, timeout=60):
"""Op decorator that returns a retry request to Nydus when the op returns
a Retry instance. Op will be retried by Nydus after `interval` seconds.
Returns failure at the specified timeout (seconds).
"""
def deco(original):
@wraps(original)
def wrapper(*args, **kw):
intermediate_result = kw.get('intermediate_result', None)
now = datetime.utcnow()
timeout_abs = (intermediate_result and
intermediate_result.get('timeout') or
now + timedelta(seconds=timeout))
if now >= timeout_abs:
msg = 'Timeout waiting for {} ({}s)'.format(getattr(original, '__name__', '?'), timeout)
LOG.error(msg)
return False, msg
result = original(*args, **kw)
if isinstance(result, Retry):
ir = result.intermediate_result or {}
ir.setdefault('timeout', timeout_abs)
return False, ir, interval
return result
return wrapper
return deco
__pycache__/__init__.cpython-38.pyc 0000644 00000003101 14720535656 0013153 0 ustar 00 U
afY @ sR d dl mZ d dlZd dlZd dlZeedddZdd Zd eedd d
Z dS ) ) b64encodeN)sreturnc C s t | S )z?Return `s` base64-encoded.
:param s: string to encode
)r encodedecode)r r Q/opt/nydus/tmp/pip-target-53d1vnqk/lib/python/customer_local_ops/util/__init__.pyb64str s r c C s t |tr tttt| |S t |ttf}|s^zt |ttt t
f}W n t k
r\ Y nX |rt |drtttt| |
S tttt| |S t |dr|| S | |S )z!Homomorphic mapping of a functionitemsfmap)
isinstancetuplemap functoolspartialr listdictfilterziprange TypeErrorhasattrr
)funcobjZ
iterableitemsr r r r s
r )lengthr c sJ | st dd} tjdddddd d fddt| D S ) z}Create a random password.
:param length: An int specifying password length
:returns: the password, in cleartext
" '\c s" g | ]}t tjtj qS r )randomchoicestringdigits
ascii_letters).0XZedited_punctuationr r
0 s z#random_password..)r! randintr# punctuationreplacejoinr )r r r( r random_password' s r. )N)
base64r r r! r# strr r intr. r r r r s __pycache__/execute.cpython-38.pyc 0000644 00000041503 14720535656 0013066 0 ustar 00 U
afN @ s d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlmZm Z m
Z
m Z d dlm Z d dl
mZ d dlmZ eddZe eZd e Ze eeef Zejd
krd dlZd d lm Z d d lm Z eZ eZ eZ eZ!dd
ej"e j#dddddddf eeeeeeeee e!e e e$d
ddZ%ne$dddZ%dd Z&dd Z'dd Z(dd Z)G dd d Z*d d Z+G d d d Z,dd&d'Z/d?eee$e eeef d(d)d*Z0d@e
eef ee$e e ee eeef d+d,d-Z1dAe
eef ee$e e ee eeef d+d.d/Z2dBe
ee e f eee$ee e$eef d0d1d2Z3dCe e ee
ee e f f ee$ee e$eef d3d4d5Z4e
eef e eeef d6d7d8Z5ee eeef d9d:d;Z6dS )D N)Path)AnyTupleUnionList) list2cmdline)ByteSize)fmap )ZKiBytes win32)shellcon)shellopen)
file_nameparamsverbshowmaskdir_nameid_listclass_id class_keyhot_keymonitorwindowreturnc
s t tdd fdd } i | d| | d| | d| | d| | d | | d
| | d | | d | | d
| | d| | d| | d|
tjf S )a
Wrapper for the Win32 API call ShellExecuteEx. This function can be used on Windows platforms any time Nydus
needs to restart itself for any reason because ShellExecuteEx allows the child process to survive after its
parent process stops. Initially added to resolve a DLL conflict issue, this could also be useful for
upgrading Nydus, for example.
Further information for ShellExecuteEx can be found at
https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shellexecuteexa
:param file_name: The name of the executable to be started. ShellExecuteEx also handles file associations,
so this could also be the name of a document, for example, to be opened with the
associated application, or a URL to be opened by the user's default browser.
:param params: Parameters to be passed to the application. Should not be specified if file_name
is NOT an executable file.
:param verb: Action to take. May be one of 'edit', 'explore', 'find', 'open', 'print', 'properties' or
'runas'. Defaults to 'open'
:param show: Specify how an application is to be shown
:param mask: Flags that indicate content and validity of other parameters
:param dir_name: Name of the working directory. If None, the current directory is used
:param id_list: See Microsoft documentation at the URL above
:param class_id: See Microsoft documentation at the URL above
:param class_key: See Microsoft documentation at the URL above
:param hot_key: See Microsoft documentation at the URL above
:param monitor: See Microsoft documentation at the URL above
:param window: See Microsoft documentation at the URL above
:return: True if the file/application is successfully launched; otherwise, False
N)keyvalr c s |dk r| | < dS )aC
It is an error to include a field with a value of None in the structure passed to ShellExecuteEx, so this
function only adds a key to the dictionary if the value is not None.
:param key: The name of the SHELLEXECUTEINFO field
:param val: The value of the field
N )r r Zshell_execute_infor P/opt/nydus/tmp/pip-target-53d1vnqk/lib/python/customer_local_ops/util/execute.py add_fieldK s z shell_start..add_fieldZfMaskZhwndZlpVerbZlpFileZ lpParametersZ lpDirectoryZnShowZlpIDListZlpClassZ hkeyClassZdwHotKeyZhMonitor)strr r ZShellExecuteEx)
r r r r r r r r r r r r r" r r r! shell_start$ s '
r$ )r c K s dS NTr )kwargsr r r! r$ f s c C s d| S )Nz| r )liner r r! pfxj s r( c C s t tt| S N)listmapr( )linesr r r! pfxsn s r- c C s | dk r| | dd}| d}|s,|S t|dkrH|d sHg S t|dk r\t|S t|dd dt|d g |d
d S ) z0Converts input blob to lines... but not too manyN <>
r z...elided %d lines...
)replacestripsplitlenr- )inpoutZoutlr r r! trim_visible_output_to_linesr s r; c c s* | }|r&|dD ]}d| V qdS )z0Converts error blob into lines with prefix marksr0 zERR: N)r6 r7 )ZerrOutseLr r r! mark_error_output s r> c @ s* e Zd ZdZd ddZdd Zdd ZdS )
EndsBuffera String buffer that maintains two segments: a first segment and a
last segment (i.e. the two ends), where each has a maximum size
limit. Any extra output in between these is discarded. The
assumption is that if there is a huge amount of output that
some must be discarded to avoid memory overflows and that
generally the first and last stuff is the most relevant.
Nc C s( t td|p dpt| _d| _d| _d S )Nr F)r maxDEFAULT_MAX_SEGMENT_SIZE_mss_data_elided)selfZmax_segment_sizer r r! __init__ s zEndsBuffer.__init__c C sT | j |7 _ t| j | jd krP| j d | j | j t| j d | _ d| _d S Nr T)rD r8 rC intrE )rF datar r r! add_str s (zEndsBuffer.add_strc C s: | j r4d| jd | j d| jt| j d gS | jS )Nr0 z...[elided]...)rE joinrD rC rI rF r r r!
get_bufstr s zEndsBuffer.get_bufstr)N)__name__
__module__ __qualname____doc__rG rK rN r r r r! r? s
r? c C s z| j dddW S tk
rx z>dd l}z | || d W W Y S tk
rZ Y nX W n tk
rr Y nX Y n tk
r | Y S X d S )Nutf-8backslashreplace)errorsr encoding)decodeUnicodeDecodeErrorchardetdetect ImportErrorAttributeError)ZbytestrrY r r r! str_form s
r] c @ s: e Zd ZefddZdd Zdd Zdd Zd
d
d Zd S )RunningCommandc C s\ || _ || _|| _|pt|fdd| _|| _t| jd | _t| jd | _d| _ d| _
d S )Nc S s t || r|sdndS )Nerrorinfo)getattr)rZ_ler r r! s z)RunningCommand.__init__..r F) ptagstdInputLOGlogger_bufsizer? _output_errors_partial
_completed)rF popen_objrf rg errorOKri max_buffer_sizer r r! rG s zRunningCommand.__init__c C s> | j t| jj | jt| jj | j d k S r) ) rk rK r] re stdoutreadrl stderrpollrM r r r! checkIfCompleted s z RunningCommand.checkIfCompletedc C sB | j }| j }t| jd | _ t| jd | _d| _||fS rH )rk rN rl r? rj rm rF orc r r r! outputToDate s
zRunningCommand.outputToDatec C s6 t t| j \}}| j| | j| d| _| S r% )r r] re communicaterk rK rl rn rw r r r! waitForCompletion s
z RunningCommand.waitForCompletionFc C s | j s| | j | j }}t| j|}|rBdd |D }|tt| d| j j
g D ]$}| j d | }| | j j
| q`| j j
|
|
fS )Nc S s g | ]}| d r|ndqS )r. <>)
startswith).0r' r r r!
s z,RunningCommand.getResult..z ExitCode: %d )rn r{ rk rN rl r; rg r* r> re
returncoderf ri r6 )rF
omitOutputoutserrsZ output_linesr' Zlstrr r r! getResult s
zRunningCommand.getResultN)F) rO rP rQ MAX_COMMAND_RESPONSE_BUFFER_SIZErG rv ry r{ r r r r r! r^ s
r^ Fc C s t | trd| n| }d} t |trF|dk rBt |trB|d}d} |rV||| }|dkrbt}||d t| t j
| |t j t j t j |d}
|r|
j
| t|
||||S )a Starts the specified command; no Shell. The cmd is expected to be an
array of strings, although it is also possible to specify
simply a string if there are no arguments to the command.
The tag value is only used to annotate log lines for
distinctive tagging in the logging output.
If errorOK is True then a non-zero return code is still only
logged as "info" instead of "error". The ProcOpResult will
accurately reflect the result of the operation regardless of
the errorOK argument.
If omitString is specified, it is removed from any logging output.
The command is run asynchronously in a separate process. The
return value is a RunningCommand object that supports a
.checkIfCompleted() method to test for subprocess completion
(non-blocking) and a .getResult() to get the ProcOpResult of a
completed process (will block until completion if not already
completed).
r r| NrS s <>z RUN: )r rr stdinrt env)
isinstancer* rL bytesr# encoder5 rh r`
subprocessPopenPIPEr writer^ ) cmdrf useShellrg rp ri
omitStringr Zlog_cmdZ replace_textre r r r! startCommand s*
r c
C s$ t | |||||||d j|dS )a Runs the specified command and waits for completion; no Shell. The
cmd is expected to be an array of strings, although it is also
possible to specify simply a string if there are no arguments
to the command.
The tag value is only used to annotate log lines for
distinctive tagging in the logging output.
If errorOK is True then a non-zero return code is still only
logged as "info" instead of "error". The ProcOpResult will
accurately reflect the result of the operation regardless of
the errorOK argument.
If omitString is specified, it is removed from any logging output.
)r rg rp ri r r )r )r r{ r ) r rf r rg rp ri r r r r r r!
runCommand s
r c
C sF t j| |t jd}|& | \}}|j||fW 5 Q R S Q R X dS )z(Used to run commands that make use of | )r rr N)r r r rz r )r r re rx rc r r r! run_command_pipe; s r )commandrf quietr c C sZ t jddddd}z4|| | |s6td| t |j||W S t|j X dS )) Execute the code in ``command`` using PowerShell.
:param command: Code to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:return: Tuple containing (exit_code, stdout, stderr)
w+tz utf-8-sig.ps1F)moderV suffixdeletez Running PowerShell command: %sN)
tempfileNamedTemporaryFileosunlinknamer closerh debugrun_powershell_file)r rf r tempr r r! run_powershellC s
r ) script_filerf r script_file_argsr r c C s8 dt | g}|r(|D ]}|t | qt||||dS )a Invoke Shell script, passing just ``filename`` or ``filepath`` and a list of arguments for execution of the file
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:param stdin: string to pass through standard input
:return: Tuple containing (exit_code, stdout, stderr)
Zbashrg r r# appendr r rf r r r r argr r r! run_shell_script_filea s
r c C s> ddddt | g}|r.|D ]}|t | qt||||dS )a Invoke PowerShell, passing just ``filename`` or ``filename`` and a list of arguments for execution of the file
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:param stdin: string to pass through standard input
:return: Tuple containing (exit_code, stdout, stderr)
powershell.exe-ExecutionPolicy Unrestricted-Filer r r r r r! r t s
r )cmd_list descriptionop_name use_shell omit_stringr c C sX t | }|r||d}td|| t| |||d\}}}td|||| |||fS )a Run a command on the target machine
:param cmd_list: string or list of strings that represents a command to be executed
:param description: short description of what the command is doing
:param op_name: name of the operation that is running the command
:param use_shell: indicator that the command should be executed in a shell
:param omit_string: a string to be removed from any logging output.
:return: Tuple containing (exit_code, stdout, stderr)
r| z run_uapi_command %s cmd_list: %s)r r z%s_result- %s - %s - %s)r# r5 rh r r ) r r r r r Z cmd_list_str exit_coder r r r r! run_uapi_command s r ) cmds_listr r r r c C sP d\}}}| D ]6\}}t |||||d\}}}|dkr|||f S q|||fS )a Run a command on the target machine
:param cmds_list: List of tuples with description-command pairs
:param op_name: name of the operation that is running the command
:param use_shell: indicator that the command should be executed in a shell
:param omit_string: a string to be removed from any logging output.
:return: Tuple containing (exit_code, stdout, stderr)
)r r@ r@ )r r r )r ) r r r r r r r r r r r r! run_multiple_uapi_commands s
r )r r c C s> t dddt| g}td| td|dr0dnd}|d d fS )
a
Invoke PowerShell, passing just ``filename`` or ``filename`` and a list of arguments for execution of the file.
Do not wait for the sub-process to complete. The exit code returned in the tuple only indicates whether or
not the process was successfully started.
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:return: Tuple containing (exit_code, stdout, stderr)
r r r z%Staring PowerShell: powershell.exe %sr )r r r/ r@ )r r# rh r` r$ )r r coder r r! start_powershell_file s
r )r r c C s8 t jdddd}|| | td| t|jS )r r r F)r r r z Running Powershell command: %s)r r r r rh r r r )r r r r r! start_powershell s
r )FNFNNN)FNFNNFN)F)F)FNN)FNN)FN)FN)7loggingr sysr r pathlibr typingr r r r r Zprimordial.sizesr Zcustomer_local_ops.utilr rB getLoggerrO rh r rI r# ZRunCommandResultplatformZwin32conwin32com.shellr
r ZHANDLEZHWNDZHKEYZDWORDZ
SW_SHOWNORMALZSEE_MASK_FLAG_DDEWAITboolr$ r( r- r; r> r? r] r^ r r r r r r r r r r r r r r! s
B 6
3
" __pycache__/helpers.cpython-38.pyc 0000644 00000006015 14720535656 0013065 0 ustar 00 U
afl @ sx d Z ddlmZ ddlmZ ddlmZ ddlZG dd deZ dd Z
dd d Z dd
dZ dd Z
dd Zdd ZdS )u$ © Copyright. All rights reserved.
)unicode_literals) FileInputreduceNc @ s e Zd ZdS )HandledFailureExceptionN)__name__
__module__ __qualname__ r
r
P/opt/nydus/tmp/pip-target-53d1vnqk/lib/python/customer_local_ops/util/helpers.pyr s r c C s8 t | fdd }|D ]}tj|| qW 5 Q R X dS )zIterates through the lines of the named file, calling the editfunc
for each line, replacing the original file with the new
output.
TfilesZinplaceN)r sysstdoutwrite)filenameZeditfuncfliner
r
r edit_file_lines s r Tc C sX t | fdd@}|D ]4}|}| D ]\}}t||||}q$tj| qW 5 Q R X dS )zIterates through the lines of the named file, and through a
dictionary of match -> replace pairs, replacing all that apply for each line,
and replacing the original file with the new output.
Tr N)r items replace_liner r r )r Z replace_dict firstwordr r Z updated_linematchreplacer
r
r replace_file_lines_multiple s r c C sB | |ks:|r,| |d s:| |d s:|s>| |r>|S | S )am Checks `line` to see if it starts with `match`; if yes, return
`replace`, otherwise return the original `line`. If
`firstword` is True, then the match must be followed by at
least one space or tab (unless it matches the entire line),
otherwise it is matched directly.
Suitable for use as an editfunc with `edit_file_lines`.
)strip
startswith)r r r r r
r
r r ) s
r c C s2 t | ddd}|d || W 5 Q R X dS )z-Appends a line to to the specified file.
aUTF-8encoding
Nopenr )r r filer
r
r append_line< s
r' c C s( t | ddd}|| W 5 Q R X dS )z{Creates the specified file, with the specified contents.
Overwrites any file already existing at that location.
wr r! Nr$ )r contentsZwfr
r
r create_fileD s r* c G s t dd | dd S )Nc s fddS )Nc s | S Nr
xr gr
r M z+compose....r
r. r
r. r r0 M r1 zcompose..c S s | S r+ r
r, r
r
r r0 M r1 r )funcsr
r
r composeL s r3 )T)T)__doc__
__future__r Z fileinputr functoolsr r Exceptionr r r r r' r* r3 r
r
r
r s
__pycache__/retry.cpython-38.pyc 0000644 00000004312 14720535656 0012566 0 ustar 00 U
af` @ s` d Z ddlmZ ddlmZmZ ddlmZ ddlZee Z
G dd dZ e Z d d
d Z
dS )
u$ © Copyright. All rights reserved.
)unicode_literals)datetime timedeltawrapsNc @ s" e Zd ZdZdddZdd ZdS )RetryzOps decorated with @retry can return a Retry instance to request retry
with the interval and timeout as specified in the decorator. See also the
RETRY sentinel if there is no intermediate_result.
Nc C s, |d ks"t |ts"tdt| || _d S )Nz7Retry intermediate_result must be dictionary but got %s)
isinstancedict TypeErrortypeintermediate_result)selfr r N/opt/nydus/tmp/pip-target-53d1vnqk/lib/python/customer_local_ops/util/retry.py__init__ s zRetry.__init__c C s dt | j S )NzRetry )str__dict__)r
r r r __str__ s z
Retry.__str__)N)__name__
__module__ __qualname____doc__r r r r r r r s
r < c s fdd}|S )zOp decorator that returns a retry request to Nydus when the op returns
a Retry instance. Op will be retried by Nydus after `interval` seconds.
Returns failure at the specified timeout (seconds).
c s t fdd}|S )Nc s | dd }t }|r"| dp.|td }||kr^dtdd}t| d|fS | |}t|t r|j
pzi }| d| d| fS |S )Nr timeout)secondsz Timeout waiting for {} ({}s)r ?F) getr utcnowr formatgetattrLOGerrorr r r
setdefault)argskwr nowZ timeout_absmsgresultZir)intervaloriginalr r r wrapper, s"
z$retry..deco..wrapperr )r* r+ r) r )r* r deco+ s zretry..decor )r) r r- r r, r retry% s r. )r r )r
__future__r r r functoolsr logging getLoggerr r! r RETRYr. r r r r s