mirror of
https://github.com/saltstack/salt.git
synced 2025-04-15 09:10:20 +00:00
Removed up debug code
This commit is contained in:
David Murphy
Megan Wilhite
parent
fa5f3ec73e
commit
0bc4a359a6
7 changed files with 14 additions and 443 deletions
|
|
@ -350,7 +350,6 @@ def get_site_packages(venv):
|
|||
# note: platlib and purelib could differ
|
||||
ret = __salt__["cmd.exec_code_all"](
|
||||
bin_path,
|
||||
## DGM "from distutils import sysconfig; print(sysconfig.get_python_lib())",
|
||||
'import sysconfig; print(sysconfig.get_path("purelib"))',
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -75,8 +75,9 @@ except ImportError:
|
|||
try:
|
||||
from salt.utils.versions import LooseVersion
|
||||
except ImportError:
|
||||
## DGM from distutils.version import LooseVersion # pylint: disable=blacklisted-module
|
||||
from looseversion import LooseVersion
|
||||
from setuptools._distutils.version import (
|
||||
LooseVersion, # pylint: disable=blacklisted-module
|
||||
)
|
||||
|
||||
# pylint: disable=too-many-instance-attributes
|
||||
|
||||
|
|
|
|||
|
|
@ -21,10 +21,6 @@ import warnings
|
|||
# pylint: enable=blacklisted-module
|
||||
import salt.version
|
||||
|
||||
# DGM
|
||||
## import re
|
||||
|
||||
|
||||
# pylint: disable=blacklisted-module
|
||||
|
||||
## from distutils.version import StrictVersion as _StrictVersion
|
||||
|
|
@ -33,132 +29,10 @@ import salt.version
|
|||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
## DGM from distutils.version import StrictVersion as _StrictVersion
|
||||
## DGM from distutils.version import StrictVersion as _StrictVersion
|
||||
# basically distutils.version.Looseversion with deps handled, uses setuptools
|
||||
## DGM from distutils.version import LooseVersion as _LooseVersion
|
||||
from setuptools._distutils.version import LooseVersion as _LooseVersion
|
||||
from setuptools._distutils.version import StrictVersion as _StrictVersion
|
||||
|
||||
## try:
|
||||
## from looseversion import LooseVersion as _LooseVersion
|
||||
## except ImportError:
|
||||
## log.debug("unable to import LooseVersion from looseversion")
|
||||
## raise ImportError()
|
||||
|
||||
|
||||
## try:
|
||||
## from packaging.version import InvalidVersion
|
||||
## from packaging.version import Version as pkg_version
|
||||
## except ImportError:
|
||||
## log.debug("unable to import from packaging.version")
|
||||
## raise ImportError()
|
||||
|
||||
|
||||
## class StrictVersion(pkg_version):
|
||||
## def __init__(self, vstring):
|
||||
## print(f"DGM StrictVersion __init__ vstring '{vstring}'")
|
||||
## try:
|
||||
## if "." not in vstring:
|
||||
## raise ValueError(f"invalid version number '{vstring}'")
|
||||
##
|
||||
## super().__init__(vstring)
|
||||
## if len(self.release) == 2:
|
||||
## self.version = self.release + (0,)
|
||||
## else:
|
||||
## self.version = self.release
|
||||
## self.prerelease = self.pre
|
||||
## except InvalidVersion:
|
||||
## raise ValueError(f"invalid version number '{vstring}'")
|
||||
##
|
||||
## def __str__(self):
|
||||
## if 0 == self.micro:
|
||||
## tver = self.release
|
||||
## vstring = "."
|
||||
## tvershort = str(tver[0])
|
||||
## if len(tver) >= 2:
|
||||
## tvershort = (str(tver[0]), str(tver[1]))
|
||||
##
|
||||
## vstring = vstring.join(tvershort)
|
||||
## else:
|
||||
## vstring = super().__str__()
|
||||
## print(f"DGM StrictVersion __str__ vstring '{vstring}'")
|
||||
## return vstring
|
||||
## ## return vstring
|
||||
## ## else:
|
||||
## ## return super().__str__()
|
||||
##
|
||||
##
|
||||
##
|
||||
## ## def parse(self, vstring):
|
||||
## ## try:
|
||||
## ## self.__init__(vstring)
|
||||
## ##
|
||||
## ## except InvalidVersion:
|
||||
## ## raise ValueError(f"invalid version number '{vstring}'")
|
||||
## ## ## raise ValueError("invalid version number '%s'" % vstring)
|
||||
## version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$', re.VERBOSE | re.ASCII)
|
||||
##
|
||||
## def parse (self, vstring):
|
||||
## print(f"DGM StrictVersion parse vstring '{vstring}'")
|
||||
##
|
||||
## match = self.version_re.match(vstring)
|
||||
## if not match:
|
||||
## raise ValueError("invalid version number '%s'" % vstring)
|
||||
##
|
||||
## (major, minor, patch, prerelease, prerelease_num) = match.group(1, 2, 4, 5, 6)
|
||||
##
|
||||
## if patch:
|
||||
## self.version = tuple(map(int, [major, minor, patch]))
|
||||
## else:
|
||||
## self.version = tuple(map(int, [major, minor])) + (0,)
|
||||
##
|
||||
## if prerelease:
|
||||
## self.prerelease = (prerelease[0], int(prerelease_num))
|
||||
## else:
|
||||
## self.prerelease = None
|
||||
##
|
||||
##
|
||||
## def _cmp(self, other):
|
||||
## if isinstance(other, str):
|
||||
## other = StrictVersion(other)
|
||||
## elif not isinstance(other, StrictVersion):
|
||||
## return NotImplemented
|
||||
##
|
||||
## print(f"DGM StrictVersion _cmd self.version '{self.version}', other.version '{other.version}'")
|
||||
##
|
||||
## if self.version != other.version:
|
||||
## # numeric versions don't match
|
||||
## # prerelease stuff doesn't matter
|
||||
## if self.version < other.version:
|
||||
## return -1
|
||||
## else:
|
||||
## return 1
|
||||
##
|
||||
## # have to compare prerelease
|
||||
## # case 1: neither has prerelease; they're equal
|
||||
## # case 2: self has prerelease, other doesn't; other is greater
|
||||
## # case 3: self doesn't have prerelease, other does: self is greater
|
||||
## # case 4: both have prerelease: must compare them!
|
||||
##
|
||||
## if (not self.prerelease and not other.prerelease):
|
||||
## return 0
|
||||
## elif (self.prerelease and not other.prerelease):
|
||||
## return -1
|
||||
## elif (not self.prerelease and other.prerelease):
|
||||
## return 1
|
||||
## elif (self.prerelease and other.prerelease):
|
||||
## if self.prerelease == other.prerelease:
|
||||
## return 0
|
||||
## elif self.prerelease < other.prerelease:
|
||||
## return -1
|
||||
## else:
|
||||
## return 1
|
||||
## else:
|
||||
## assert False, "never get here"
|
||||
|
||||
|
||||
## DGM old StrictVerson usage
|
||||
class StrictVersion(_StrictVersion):
|
||||
def parse(self, vstring):
|
||||
_StrictVersion.parse(self, vstring)
|
||||
|
|
|
|||
|
|
@ -6,9 +6,6 @@ import operator
|
|||
import platform
|
||||
import re
|
||||
import sys
|
||||
|
||||
# DGM
|
||||
import traceback
|
||||
from collections import namedtuple
|
||||
from functools import total_ordering
|
||||
|
||||
|
|
@ -196,23 +193,15 @@ class SaltVersionsInfo(type):
|
|||
(getattr(cls, name) for name in dir(cls) if name.isupper()),
|
||||
key=operator.attrgetter("info"),
|
||||
)
|
||||
## print(f"DGM salt version SaltVersionsInfo cls versions '{cls._sorted_versions}'")
|
||||
return cls._sorted_versions
|
||||
|
||||
@classmethod
|
||||
def current_release(cls):
|
||||
tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
print(
|
||||
f"DGM salt version saltversionsinfo cls current_release chk cls._current_release, '{cls._current_release}', backtrace_ '{tbsummary}'"
|
||||
)
|
||||
if cls._current_release is None:
|
||||
for version in cls.versions():
|
||||
if version.released is False:
|
||||
cls._current_release = version
|
||||
break
|
||||
print(
|
||||
f"DGM salt version saltversionsinfo cls current_release '{cls._current_release}'"
|
||||
)
|
||||
return cls._current_release
|
||||
|
||||
@classmethod
|
||||
|
|
@ -225,9 +214,6 @@ class SaltVersionsInfo(type):
|
|||
break
|
||||
if version == cls.current_release():
|
||||
next_release_ahead = True
|
||||
print(
|
||||
f"DGM salt version saltversionsinfo cls next_release '{cls._next_release}'"
|
||||
)
|
||||
return cls._next_release
|
||||
|
||||
@classmethod
|
||||
|
|
@ -239,9 +225,6 @@ class SaltVersionsInfo(type):
|
|||
break
|
||||
previous = version
|
||||
cls._previous_release = previous
|
||||
print(
|
||||
f"DGM salt version saltversionsinfo cls previous_release '{cls._previous_release}'"
|
||||
)
|
||||
return cls._previous_release
|
||||
|
||||
|
||||
|
|
@ -295,10 +278,6 @@ class SaltStackVersion:
|
|||
noc=0,
|
||||
sha=None,
|
||||
):
|
||||
tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
print(
|
||||
f"DGM salt version entry, major '{major}', minor '{minor}', pre_type '{pre_type}', sha '{sha}', backtrace_ '{tbsummary}'"
|
||||
)
|
||||
if isinstance(major, str):
|
||||
major = int(major)
|
||||
|
||||
|
|
@ -596,9 +575,6 @@ class SaltStackVersion:
|
|||
# There's no need to do anything here. The last released codename will be picked up
|
||||
# --------------------------------------------------------------------------------------------------------------------
|
||||
__saltstack_version__ = SaltStackVersion.current_release()
|
||||
print(
|
||||
f"DGM salt version current_release returned __saltstack_version__ '{__saltstack_version__}'"
|
||||
)
|
||||
# <---- Hardcoded Salt Version Information ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
|
@ -609,28 +585,16 @@ def __discover_version(saltstack_version):
|
|||
import os
|
||||
import subprocess
|
||||
|
||||
my_sver = dir(saltstack_version)
|
||||
tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
print(
|
||||
f"DGM salt version __discover_version '{my_sver}', saltstack_version '{saltstack_version}', backtrace_ '{tbsummary}'"
|
||||
)
|
||||
|
||||
if "SETUP_DIRNAME" in globals():
|
||||
# This is from the exec() call in Salt's setup.py
|
||||
cwd = SETUP_DIRNAME # pylint: disable=E0602
|
||||
if not os.path.exists(os.path.join(cwd, ".git")):
|
||||
# This is not a Salt git checkout!!! Don't even try to parse...
|
||||
print(
|
||||
f"DGM salt version __get_discover A saltstack_version '{saltstack_version}', cwd '{cwd}"
|
||||
)
|
||||
return saltstack_version
|
||||
else:
|
||||
cwd = os.path.abspath(os.path.dirname(__file__))
|
||||
if not os.path.exists(os.path.join(os.path.dirname(cwd), ".git")):
|
||||
# This is not a Salt git checkout!!! Don't even try to parse...
|
||||
print(
|
||||
f"DGM salt version __get_discover B saltstack_version '{saltstack_version}'"
|
||||
)
|
||||
return saltstack_version
|
||||
|
||||
try:
|
||||
|
|
@ -659,36 +623,23 @@ def __discover_version(saltstack_version):
|
|||
err = err.decode().strip()
|
||||
|
||||
if not out or err:
|
||||
print(
|
||||
f"DGM salt version __get_discover C saltstack_version '{saltstack_version}'"
|
||||
)
|
||||
return saltstack_version
|
||||
|
||||
if SaltStackVersion.git_sha_regex.match(out):
|
||||
# We only define the parsed SHA and set NOC as ??? (unknown)
|
||||
saltstack_version.sha = out.strip()
|
||||
saltstack_version.noc = -1
|
||||
print(
|
||||
f"DGM salt version __get_discover D saltstack_version '{saltstack_version}'"
|
||||
)
|
||||
return saltstack_version
|
||||
|
||||
## DGM return SaltStackVersion.parse(out)
|
||||
mydver = SaltStackVersion.parse(out)
|
||||
print(
|
||||
f"DGM salt version __get_discover out '{out}' produced parsed saltstack_version '{mydver}'"
|
||||
)
|
||||
return mydver
|
||||
return SaltStackVersion.parse(out)
|
||||
|
||||
except OSError as os_err:
|
||||
print(f"DGM salt version __get_discover OSError '{os_err}'")
|
||||
if os_err.errno != 2:
|
||||
# If the errno is not 2(The system cannot find the file
|
||||
# specified), raise the exception so it can be catch by the
|
||||
# developers
|
||||
raise
|
||||
|
||||
print(f"DGM salt version __get_discover E saltstack_version '{saltstack_version}'")
|
||||
return saltstack_version
|
||||
|
||||
|
||||
|
|
@ -698,56 +649,30 @@ def __get_version(saltstack_version):
|
|||
that instead, otherwise we carry on.
|
||||
"""
|
||||
|
||||
my_sver = dir(saltstack_version)
|
||||
print(
|
||||
f"DGM salt version __get_version '{my_sver}', saltstack_version '{saltstack_version}'"
|
||||
)
|
||||
|
||||
try:
|
||||
# Try to import the version information provided at install time
|
||||
print("DGM salt version __get_version attempt to import from salt._version")
|
||||
|
||||
from salt._version import __saltstack_version__ # pylint: disable=E0611,F0401
|
||||
|
||||
print(f"DGM salt version __get_version imported '{__saltstack_version__}'")
|
||||
|
||||
return __saltstack_version__
|
||||
|
||||
## except ImportError:
|
||||
except ImportError as exc:
|
||||
## exc_type, exc_Value, exc_traceback = sys.exc_info()
|
||||
## traceback_in_var = exc_traceback.format_tb(exc_traceback)
|
||||
print(
|
||||
f"DGM salt version __get_version import error try discover version for saltstack_version '{saltstack_version}', import error traceback '{traceback.format_exc()}'"
|
||||
)
|
||||
except ImportError:
|
||||
## except ImportError as exc:
|
||||
return __discover_version(saltstack_version)
|
||||
|
||||
|
||||
# Get additional version information if available
|
||||
__saltstack_version__ = __get_version(__saltstack_version__)
|
||||
print(
|
||||
f"DGM salt version check _get_version returned __saltstack_version__ '{__saltstack_version__}'"
|
||||
)
|
||||
|
||||
if __saltstack_version__.name:
|
||||
# Set SaltVersionsInfo._current_release to avoid lookups when finding previous and next releases
|
||||
## SaltVersionsInfo._current_release = getattr(
|
||||
## SaltVersionsInfo, __saltstack_version__.name.upper()
|
||||
## )
|
||||
dgm_attr = getattr(SaltVersionsInfo, __saltstack_version__.name.upper())
|
||||
print(
|
||||
f"DGM salt version name check __saltstack_version__ '{__saltstack_version__}', getattr returned '{dgm_attr}'"
|
||||
SaltVersionsInfo._current_release = getattr(
|
||||
SaltVersionsInfo, __saltstack_version__.name.upper()
|
||||
)
|
||||
SaltVersionsInfo._current_release = dgm_attr
|
||||
|
||||
# This function has executed once, we're done with it. Delete it!
|
||||
del __get_version
|
||||
# <---- Dynamic/Runtime Salt Version Information ---------------------------------------------------------------------
|
||||
|
||||
|
||||
print(
|
||||
f"DGM salt/version.py __saltstack_version__ '{__saltstack_version__}', info '{__saltstack_version__.info}', string '{__saltstack_version__.string}'"
|
||||
)
|
||||
# ----- Common version related attributes - NO NEED TO CHANGE ------------------------------------------------------->
|
||||
__version_info__ = __saltstack_version__.info
|
||||
__version__ = __saltstack_version__.string
|
||||
|
|
@ -981,5 +906,4 @@ def versions_report(include_salt_cloud=False, include_extensions=True):
|
|||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print(f"DGM salt/version.py __version__ '{__version__}'")
|
||||
print(__version__)
|
||||
|
|
|
|||
188
setup.py
188
setup.py
|
|
@ -12,9 +12,6 @@ import glob
|
|||
import os
|
||||
import platform
|
||||
import sys
|
||||
|
||||
# DGM
|
||||
import traceback
|
||||
import warnings
|
||||
from ctypes.util import find_library
|
||||
from datetime import datetime
|
||||
|
|
@ -37,8 +34,6 @@ from setuptools.command.sdist import sdist
|
|||
|
||||
# pylint: enable=no-name-in-module
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
try:
|
||||
from urllib2 import urlopen
|
||||
except ImportError:
|
||||
|
|
@ -101,8 +96,6 @@ USE_STATIC_REQUIREMENTS = os.environ.get("USE_STATIC_REQUIREMENTS")
|
|||
if USE_STATIC_REQUIREMENTS is not None:
|
||||
USE_STATIC_REQUIREMENTS = USE_STATIC_REQUIREMENTS == "1"
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
try:
|
||||
# Add the esky bdist target if the module is available
|
||||
# may require additional modules depending on platform
|
||||
|
|
@ -176,10 +169,7 @@ PACKAGED_FOR_SALT_SSH = os.path.isfile(PACKAGED_FOR_SALT_SSH_FILE)
|
|||
|
||||
|
||||
# pylint: disable=W0122
|
||||
print(f"DGM setup open read, compile, exec of file '{SALT_VERSION}'")
|
||||
exec(
|
||||
compile(open(SALT_VERSION).read(), SALT_VERSION, "exec")
|
||||
) # DGM this is were _get_version is being called from
|
||||
exec(compile(open(SALT_VERSION).read(), SALT_VERSION, "exec"))
|
||||
# pylint: enable=W0122
|
||||
|
||||
|
||||
|
|
@ -187,7 +177,6 @@ exec(
|
|||
|
||||
|
||||
def _parse_requirements_file(requirements_file):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
parsed_requirements = []
|
||||
with open(requirements_file) as rfh:
|
||||
|
|
@ -199,7 +188,6 @@ def _parse_requirements_file(requirements_file):
|
|||
if "libcloud" in line:
|
||||
continue
|
||||
parsed_requirements.append(line)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
return parsed_requirements
|
||||
|
||||
|
|
@ -212,11 +200,6 @@ class WriteSaltVersion(Command):
|
|||
|
||||
description = "Write salt's hardcoded version file"
|
||||
user_options = []
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup WriteSaltVersion, __version__ '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def initialize_options(self):
|
||||
"""
|
||||
|
|
@ -229,12 +212,6 @@ class WriteSaltVersion(Command):
|
|||
"""
|
||||
|
||||
def run(self):
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup WriteSaltVersion, run with version '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
if (
|
||||
not os.path.exists(SALT_VERSION_HARDCODED)
|
||||
or self.distribution.with_salt_version
|
||||
|
|
@ -249,46 +226,26 @@ class WriteSaltVersion(Command):
|
|||
salt_version = (
|
||||
__saltstack_version__ # pylint: disable=undefined-variable
|
||||
)
|
||||
## print(
|
||||
## f"DGM setup write_salt_version a salt_version '{salt_version}', __saltstack_version__ '{__saltstack_version__}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
else:
|
||||
from salt.version import SaltStackVersion
|
||||
|
||||
salt_version = SaltStackVersion.parse(
|
||||
self.distribution.with_salt_version
|
||||
)
|
||||
print(f"DGM setup write_salt_version b salt_version '{salt_version}'")
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
# pylint: disable=E0602
|
||||
print(
|
||||
f"DGM setup write_salt_version all versions '{salt_version.full_info_all_versions}'"
|
||||
)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
open(self.distribution.salt_version_hardcoded_path, "w").write(
|
||||
INSTALL_VERSION_TEMPLATE.format(
|
||||
date=DATE, full_version_info=salt_version.full_info_all_versions
|
||||
)
|
||||
)
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
# pylint: enable=E0602
|
||||
|
||||
|
||||
class GenerateSaltSyspaths(Command):
|
||||
|
||||
description = "Generate salt's hardcoded syspaths file"
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup GenerateSaltSyspaths, __version__ '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def initialize_options(self):
|
||||
pass
|
||||
|
|
@ -297,11 +254,6 @@ class GenerateSaltSyspaths(Command):
|
|||
pass
|
||||
|
||||
def run(self):
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup GenerateSaltSyspaths, run with version '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
# Write the syspaths file
|
||||
if getattr(self.distribution, "salt_syspaths_hardcoded_path", None) is None:
|
||||
print("This command is not meant to be called on it's own")
|
||||
|
|
@ -331,18 +283,12 @@ class GenerateSaltSyspaths(Command):
|
|||
home_dir=self.distribution.salt_home_dir,
|
||||
)
|
||||
)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
class WriteSaltSshPackagingFile(Command):
|
||||
|
||||
description = "Write salt's ssh packaging file"
|
||||
user_options = []
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup WriteSaltSshPackagingFile, __version__ '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def initialize_options(self):
|
||||
"""
|
||||
|
|
@ -355,11 +301,6 @@ class WriteSaltSshPackagingFile(Command):
|
|||
"""
|
||||
|
||||
def run(self):
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup WriteSaltSshPackagingFile, run with version '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
if not os.path.exists(PACKAGED_FOR_SALT_SSH_FILE):
|
||||
# Write the salt-ssh packaging file
|
||||
if getattr(self.distribution, "salt_ssh_packaging_file", None) is None:
|
||||
|
|
@ -371,11 +312,9 @@ class WriteSaltSshPackagingFile(Command):
|
|||
"Packaged for Salt-SSH\n"
|
||||
)
|
||||
# pylint: enable=E0602
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
class Develop(develop):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
user_options = develop.user_options + [
|
||||
(
|
||||
"write-salt-version",
|
||||
|
|
@ -404,7 +343,6 @@ class Develop(develop):
|
|||
"switched to True.",
|
||||
),
|
||||
]
|
||||
## DGM assert __version__ != '3006.0'
|
||||
boolean_options = develop.boolean_options + [
|
||||
"write-salt-version",
|
||||
"generate-salt-syspaths",
|
||||
|
|
@ -412,17 +350,12 @@ class Develop(develop):
|
|||
]
|
||||
|
||||
def initialize_options(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
develop.initialize_options(self)
|
||||
self.write_salt_version = False
|
||||
self.generate_salt_syspaths = False
|
||||
self.mimic_salt_install = False
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def finalize_options(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
develop.finalize_options(self)
|
||||
if "WRITE_SALT_VERSION" in os.environ:
|
||||
self.write_salt_version = True
|
||||
|
|
@ -434,11 +367,8 @@ class Develop(develop):
|
|||
if self.mimic_salt_install:
|
||||
self.write_salt_version = True
|
||||
self.generate_salt_syspaths = True
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def run(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
if IS_WINDOWS_PLATFORM:
|
||||
# Download the required DLLs
|
||||
self.distribution.salt_download_windows_dlls = True
|
||||
|
|
@ -454,22 +384,12 @@ class Develop(develop):
|
|||
self.distribution.salt_syspaths_hardcoded_path = SALT_SYSPATHS_HARDCODED
|
||||
self.run_command("generate_salt_syspaths")
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
# Resume normal execution
|
||||
develop.run(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
class DownloadWindowsDlls(Command):
|
||||
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup DownloadWindowsDlls, __version__ '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
description = "Download required DLL's for windows"
|
||||
|
||||
def initialize_options(self):
|
||||
|
|
@ -479,19 +399,12 @@ class DownloadWindowsDlls(Command):
|
|||
pass
|
||||
|
||||
def run(self):
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup DownloadWindowsDlls, run with version '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
if getattr(self.distribution, "salt_download_windows_dlls", None) is None:
|
||||
print("This command is not meant to be called on it's own")
|
||||
exit(1)
|
||||
try:
|
||||
import pip
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
# pip has moved many things to `_internal` starting with pip 10
|
||||
if LooseVersion(pip.__version__) < LooseVersion("10.0"):
|
||||
# pylint: disable=no-name-in-module
|
||||
|
|
@ -502,7 +415,6 @@ class DownloadWindowsDlls(Command):
|
|||
from pip._internal.utils.logging import ( # pylint: disable=no-name-in-module
|
||||
indent_log,
|
||||
)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
except ImportError:
|
||||
# TODO: Impliment indent_log here so we don't require pip
|
||||
|
|
@ -510,8 +422,6 @@ class DownloadWindowsDlls(Command):
|
|||
def indent_log():
|
||||
yield
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
platform_bits, _ = platform.architecture()
|
||||
url = "https://repo.saltproject.io/windows/dependencies/{bits}/{fname}"
|
||||
dest = os.path.join(os.path.dirname(sys.executable), "{fname}")
|
||||
|
|
@ -564,54 +474,38 @@ class DownloadWindowsDlls(Command):
|
|||
)
|
||||
)
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
class Sdist(sdist):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
def make_release_tree(self, base_dir, files):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
if self.distribution.ssh_packaging:
|
||||
self.distribution.salt_ssh_packaging_file = PACKAGED_FOR_SALT_SSH_FILE
|
||||
self.run_command("write_salt_ssh_packaging_file")
|
||||
self.filelist.files.append(os.path.basename(PACKAGED_FOR_SALT_SSH_FILE))
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
sdist.make_release_tree(self, base_dir, files)
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
# Let's generate salt/_version.py to include in the sdist tarball
|
||||
self.distribution.running_salt_sdist = True
|
||||
self.distribution.salt_version_hardcoded_path = os.path.join(
|
||||
base_dir, "salt", "_version.py"
|
||||
)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("write_salt_version")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def make_distribution(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
sdist.make_distribution(self)
|
||||
if self.distribution.ssh_packaging:
|
||||
os.unlink(PACKAGED_FOR_SALT_SSH_FILE)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
class BDistEgg(bdist_egg):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
def finalize_options(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
bdist_egg.finalize_options(self)
|
||||
self.distribution.build_egg = True
|
||||
if not self.skip_build:
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("build")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
class CloudSdist(Sdist): # pylint: disable=too-many-ancestors
|
||||
## DGM assert __version__ != '3006.0'
|
||||
user_options = Sdist.user_options + [
|
||||
(
|
||||
"download-bootstrap-script",
|
||||
|
|
@ -624,17 +518,12 @@ class CloudSdist(Sdist): # pylint: disable=too-many-ancestors
|
|||
boolean_options = Sdist.boolean_options + ["download-bootstrap-script"]
|
||||
|
||||
def initialize_options(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
Sdist.initialize_options(self)
|
||||
self.skip_bootstrap_download = True
|
||||
self.download_bootstrap_script = False
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def finalize_options(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
Sdist.finalize_options(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
if "SKIP_BOOTSTRAP_DOWNLOAD" in os.environ:
|
||||
# pylint: disable=not-callable
|
||||
log(
|
||||
|
|
@ -646,10 +535,8 @@ class CloudSdist(Sdist): # pylint: disable=too-many-ancestors
|
|||
if "DOWNLOAD_BOOTSTRAP_SCRIPT" in os.environ:
|
||||
download_bootstrap_script = os.environ.get("DOWNLOAD_BOOTSTRAP_SCRIPT", "0")
|
||||
self.download_bootstrap_script = download_bootstrap_script == "1"
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def run(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
if self.download_bootstrap_script is True:
|
||||
# Let's update the bootstrap-script to the version defined to be
|
||||
# distributed. See BOOTSTRAP_SCRIPT_DISTRIBUTED_VERSION above.
|
||||
|
|
@ -694,12 +581,9 @@ class CloudSdist(Sdist): # pylint: disable=too-many-ancestors
|
|||
log.error("Failed to write the updated script: {}".format(err))
|
||||
|
||||
# Let's the rest of the build command
|
||||
## DGM assert __version__ != '3006.0'
|
||||
Sdist.run(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def write_manifest(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
# We only need to ship the scripts which are supposed to be installed
|
||||
dist_scripts = self.distribution.scripts
|
||||
for script in self.filelist.files[:]:
|
||||
|
|
@ -707,12 +591,10 @@ class CloudSdist(Sdist): # pylint: disable=too-many-ancestors
|
|||
continue
|
||||
if script not in dist_scripts:
|
||||
self.filelist.files.remove(script)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
return Sdist.write_manifest(self)
|
||||
|
||||
|
||||
class TestCommand(Command):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
description = "Run tests"
|
||||
user_options = [
|
||||
("runtests-opts=", "R", "Command line options to pass to runtests.py")
|
||||
|
|
@ -730,9 +612,7 @@ class TestCommand(Command):
|
|||
# This should either be removed or migrated to use nox
|
||||
import subprocess
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("build")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
build_cmd = self.get_finalized_command("build_ext")
|
||||
runner = os.path.abspath("tests/runtests.py")
|
||||
test_cmd = [sys.executable, runner]
|
||||
|
|
@ -740,7 +620,6 @@ class TestCommand(Command):
|
|||
test_cmd.extend(self.runtests_opts.split())
|
||||
|
||||
print("running test")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
ret = subprocess.run(
|
||||
test_cmd,
|
||||
stdout=sys.stdout,
|
||||
|
|
@ -748,33 +627,26 @@ class TestCommand(Command):
|
|||
cwd=build_cmd.build_lib,
|
||||
check=False,
|
||||
)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
sys.exit(ret.returncode)
|
||||
|
||||
|
||||
class Clean(clean):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
def run(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
clean.run(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
# Let's clean compiled *.py[c,o]
|
||||
for subdir in ("salt", "tests", "doc"):
|
||||
root = os.path.join(os.path.dirname(__file__), subdir)
|
||||
for dirname, _, _ in os.walk(root):
|
||||
for to_remove_filename in glob.glob("{}/*.py[oc]".format(dirname)):
|
||||
os.remove(to_remove_filename)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
if HAS_BDIST_WHEEL:
|
||||
|
||||
class BDistWheel(bdist_wheel):
|
||||
def finalize_options(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
bdist_wheel.finalize_options(self)
|
||||
self.distribution.build_wheel = True
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
INSTALL_VERSION_TEMPLATE = """\
|
||||
|
|
@ -814,63 +686,46 @@ HOME_DIR = {home_dir!r}
|
|||
class Build(build):
|
||||
def run(self):
|
||||
# Run build.run function
|
||||
## DGM assert __version__ != '3006.0'
|
||||
build.run(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
salt_build_ver_file = os.path.join(self.build_lib, "salt", "_version.py")
|
||||
|
||||
if getattr(self.distribution, "with_salt_version", False):
|
||||
# Write the hardcoded salt version module salt/_version.py
|
||||
self.distribution.salt_version_hardcoded_path = salt_build_ver_file
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("write_salt_version")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
if getattr(self.distribution, "build_egg", False):
|
||||
# we are building an egg package. need to include _version.py
|
||||
self.distribution.salt_version_hardcoded_path = salt_build_ver_file
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("write_salt_version")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
if getattr(self.distribution, "build_wheel", False):
|
||||
# we are building a wheel package. need to include _version.py
|
||||
self.distribution.salt_version_hardcoded_path = salt_build_ver_file
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("write_salt_version")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
if getattr(self.distribution, "running_salt_install", False):
|
||||
# If our install attribute is present and set to True, we'll go
|
||||
# ahead and write our install time python modules.
|
||||
|
||||
# Write the hardcoded salt version module salt/_version.py
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("write_salt_version")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
# Write the system paths file
|
||||
self.distribution.salt_syspaths_hardcoded_path = os.path.join(
|
||||
self.build_lib, "salt", "_syspaths.py"
|
||||
)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("generate_salt_syspaths")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
|
||||
class Install(install):
|
||||
def initialize_options(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
install.initialize_options(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def finalize_options(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
install.finalize_options(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
def run(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
if LooseVersion(setuptools.__version__) < LooseVersion("9.1"):
|
||||
sys.stderr.write(
|
||||
"\n\nInstalling Salt requires setuptools >= 9.1\n"
|
||||
|
|
@ -885,7 +740,6 @@ class Install(install):
|
|||
self.distribution.salt_version_hardcoded_path = os.path.join(
|
||||
self.build_lib, "salt", "_version.py"
|
||||
)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
if IS_WINDOWS_PLATFORM:
|
||||
# Download the required DLLs
|
||||
self.distribution.salt_download_windows_dlls = True
|
||||
|
|
@ -895,14 +749,10 @@ class Install(install):
|
|||
if not os.path.exists(os.path.join(self.build_lib)):
|
||||
if not self.skip_build:
|
||||
self.run_command("build")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
else:
|
||||
## DGM assert __version__ != '3006.0'
|
||||
self.run_command("write_salt_version")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
# Run install.run
|
||||
install.run(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
@staticmethod
|
||||
def _called_from_setup(run_frame):
|
||||
|
|
@ -915,14 +765,9 @@ class Install(install):
|
|||
called by 'run_commands'. Return True in that case or if a call stack
|
||||
is unavailable. Return False otherwise.
|
||||
"""
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
if run_frame is None:
|
||||
# If run_frame is None, just call the parent class logic
|
||||
## return install._called_from_setup(run_frame)
|
||||
mydgm = install._called_from_setup(run_frame)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
return mydgm
|
||||
return install._called_from_setup(run_frame)
|
||||
|
||||
# Because Salt subclasses the setuptools install command, it needs to
|
||||
# override this static method to provide the right frame for the logic
|
||||
|
|
@ -930,16 +775,12 @@ class Install(install):
|
|||
|
||||
# We first try the current run_frame in case the issue
|
||||
# https://github.com/pypa/setuptools/issues/456 is fixed.
|
||||
## DGM assert __version__ != '3006.0'
|
||||
first_call = install._called_from_setup(run_frame)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
if first_call:
|
||||
return True
|
||||
|
||||
# Fallback to providing the parent frame to have the right logic kick in
|
||||
## DGM assert __version__ != '3006.0'
|
||||
second_call = install._called_from_setup(run_frame.f_back)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
if second_call is None:
|
||||
# There was no parent frame?!
|
||||
return first_call
|
||||
|
|
@ -948,14 +789,11 @@ class Install(install):
|
|||
|
||||
class InstallLib(install_lib):
|
||||
def run(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
executables = [
|
||||
"salt/templates/git/ssh-id-wrapper",
|
||||
"salt/templates/lxc/salt_tarball",
|
||||
]
|
||||
install_lib.run(self)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
# input and outputs match 1-1
|
||||
inp = self.get_inputs()
|
||||
|
|
@ -1004,8 +842,6 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
Under *nix, all scripts should be installed
|
||||
"""
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
global_options = (
|
||||
distutils.dist.Distribution.global_options
|
||||
+ [
|
||||
|
|
@ -1074,15 +910,7 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
)
|
||||
|
||||
def __init__(self, attrs=None):
|
||||
## print(f"DGM setup __init__ attrs'{attrs}'")
|
||||
## print(f"DGM setup __init__ initial __version__ '{__version__}'")
|
||||
## tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
## print(
|
||||
## f"DGM setup __init__ __version__ '{__version__}', backtrace_ '{tbsummary}'"
|
||||
## )
|
||||
## DGM assert __version__ != '3006.0'
|
||||
distutils.dist.Distribution.__init__(self, attrs)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
self.ssh_packaging = PACKAGED_FOR_SALT_SSH
|
||||
self.salt_transport = None
|
||||
|
|
@ -1111,7 +939,6 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
self.with_salt_version = None
|
||||
|
||||
self.name = "salt-ssh" if PACKAGED_FOR_SALT_SSH else "salt"
|
||||
## print(f"DGM setup __init__ __version__ '{__version__}'")
|
||||
self.salt_version = __version__ # pylint: disable=undefined-variable
|
||||
self.description = (
|
||||
"Portable, distributed, remote execution and configuration management"
|
||||
|
|
@ -1143,8 +970,6 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
self.author = "Thomas S Hatch"
|
||||
self.author_email = "thatch45@gmail.com"
|
||||
self.url = "https://saltproject.io"
|
||||
## DGM assert __version__ != '3006.0'
|
||||
## print(f"DGM setup __init__ pre cmdclass.update, __version__ '{__version__}'")
|
||||
self.cmdclass.update(
|
||||
{
|
||||
"test": TestCommand,
|
||||
|
|
@ -1159,8 +984,6 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
"write_salt_ssh_packaging_file": WriteSaltSshPackagingFile,
|
||||
}
|
||||
)
|
||||
## print(f"DGM setup __init__ post cmdclass.update, __version__ '{__version__}'")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
if not IS_WINDOWS_PLATFORM:
|
||||
self.cmdclass.update({"sdist": CloudSdist, "install_lib": InstallLib})
|
||||
if IS_WINDOWS_PLATFORM:
|
||||
|
|
@ -1178,10 +1001,6 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
self.update_metadata()
|
||||
|
||||
def update_metadata(self):
|
||||
tbsummary = traceback.StackSummary.extract(traceback.walk_stack(None))
|
||||
print(f"DGM setup update_metadata, backtrace_ '{tbsummary}'")
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
for attrname in dir(self):
|
||||
if attrname.startswith("__"):
|
||||
continue
|
||||
|
|
@ -1199,7 +1018,6 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
pass
|
||||
|
||||
def discover_packages(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
modules = []
|
||||
for root, _, files in os.walk(os.path.join(SETUP_DIRNAME, "salt")):
|
||||
if "__init__.py" not in files:
|
||||
|
|
@ -1517,7 +1335,6 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
|
||||
# ----- Overridden Methods -------------------------------------------------------------------------------------->
|
||||
def parse_command_line(self):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
args = distutils.dist.Distribution.parse_command_line(self)
|
||||
|
||||
|
|
@ -1545,7 +1362,6 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
continue
|
||||
property_name = funcname.split("_property_", 1)[-1]
|
||||
setattr(self, property_name, getattr(self, funcname))
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
return args
|
||||
|
||||
|
|
|
|||
|
|
@ -273,7 +273,6 @@ def test_sdist(virtualenv, cache_dir, use_static_requirements, src_dir):
|
|||
|
||||
# Setuptools installs pre-release packages if we don't pin to an exact version
|
||||
# Let's download and install requirements before, running salt's install test
|
||||
print(f"DGM test_sdist cache_dir '{cache_dir}', src_dir '{src_dir}'")
|
||||
venv.run(
|
||||
venv.venv_python,
|
||||
"-m",
|
||||
|
|
@ -297,7 +296,6 @@ def test_sdist(virtualenv, cache_dir, use_static_requirements, src_dir):
|
|||
fname.unlink()
|
||||
continue
|
||||
packages.append(fname)
|
||||
print(f"DGM test_sdist packages '{packages}'")
|
||||
venv.install(*[str(pkg) for pkg in packages])
|
||||
for package in packages:
|
||||
package.unlink()
|
||||
|
|
@ -309,7 +307,6 @@ def test_sdist(virtualenv, cache_dir, use_static_requirements, src_dir):
|
|||
# pre-installed before installing salt
|
||||
venv.install("pycurl==7.43.0.5")
|
||||
|
||||
print(f"DGM test_sdist for sdist cache_dir '{cache_dir}', src_dir '{src_dir}'")
|
||||
venv.run(
|
||||
venv.venv_python,
|
||||
"setup.py",
|
||||
|
|
@ -319,20 +316,9 @@ def test_sdist(virtualenv, cache_dir, use_static_requirements, src_dir):
|
|||
cwd=src_dir,
|
||||
)
|
||||
|
||||
## dgm_dir = "/home/david/tmp_salt_gen"
|
||||
## print(f"DGM test_sdist for sdist dgm_dir '{dgm_dir}', src_dir '{src_dir}'")
|
||||
## venv.run(
|
||||
## venv.venv_python,
|
||||
## "setup.py",
|
||||
## "sdist",
|
||||
## "--dist-dir",
|
||||
## dgm_dir,
|
||||
## cwd=src_dir,
|
||||
## )
|
||||
venv.run(venv.venv_python, "setup.py", "clean", cwd=src_dir)
|
||||
|
||||
salt_generated_package = list(cache_dir.glob("*.tar.gz"))
|
||||
print(f"DGM test_sdist salt_generated_package '{salt_generated_package}'")
|
||||
if not salt_generated_package:
|
||||
pytest.fail("Could not find the generated sdist file")
|
||||
salt_generated_package = salt_generated_package[0]
|
||||
|
|
@ -342,24 +328,15 @@ def test_sdist(virtualenv, cache_dir, use_static_requirements, src_dir):
|
|||
sdist_ver_cmp = salt_generated_package.name.split(".tar.gz")[0].split("salt-")[
|
||||
-1
|
||||
]
|
||||
dgm_version = dir(salt.version)
|
||||
print(
|
||||
f"DGM test_sdist dgm_version '{dgm_version}', sdist_ver_cmp '{sdist_ver_cmp}', salt.version.__version__ '{salt.version.__version__}'"
|
||||
)
|
||||
|
||||
assert sdist_ver_cmp == salt.version.__version__, "{} != {}".format(
|
||||
sdist_ver_cmp, salt.version.__version__
|
||||
)
|
||||
|
||||
print(
|
||||
f"DGM test_sdist venv.install salt_generated_package '{salt_generated_package}'"
|
||||
)
|
||||
cmd = venv.run(venv.venv_python, "-m", "pip", "list", "--format", "json")
|
||||
print(f"DGM test_sdist pre-install pip3 list output '{cmd}'")
|
||||
venv.install(str(salt_generated_package))
|
||||
|
||||
## dgm_abspath = "/home/david/tmp_salt_manual/salt-3005.1+1561.g7e544dd3bd.tar.gz"
|
||||
## print(f"DGM test_sdist attempting install with dgm_abspath '{dgm_abspath}'")
|
||||
## venv.install(dgm_abspath)
|
||||
# Let's ensure the version is correct
|
||||
cmd = venv.run(venv.venv_python, "-m", "pip", "list", "--format", "json")
|
||||
|
||||
# Let's also ensure we have a salt/_version.py from the installed salt wheel
|
||||
subdir = [
|
||||
|
|
@ -375,17 +352,12 @@ def test_sdist(virtualenv, cache_dir, use_static_requirements, src_dir):
|
|||
installed_salt_path = installed_salt_path.joinpath(*subdir)
|
||||
assert installed_salt_path.is_dir()
|
||||
salt_generated_version_file_path = installed_salt_path / "_version.py"
|
||||
print(
|
||||
f"DGM test_sdist salt_generated_version_file_path '{salt_generated_version_file_path}'"
|
||||
)
|
||||
assert salt_generated_version_file_path.is_file()
|
||||
with salt_generated_version_file_path.open() as rfh:
|
||||
print("DGM _version.py contents to follow:")
|
||||
log.debug("_version.py contents:\n >>>>>>\n%s\n <<<<<<", rfh.read())
|
||||
|
||||
# Let's ensure the version is correct
|
||||
cmd = venv.run(venv.venv_python, "-m", "pip", "list", "--format", "json")
|
||||
print(f"DGM test_sdist pip3 list output '{cmd.stdout}'")
|
||||
for details in json.loads(cmd.stdout):
|
||||
if details["name"] != "salt":
|
||||
continue
|
||||
|
|
@ -395,10 +367,6 @@ def test_sdist(virtualenv, cache_dir, use_static_requirements, src_dir):
|
|||
pytest.fail("Salt was not found installed")
|
||||
|
||||
# Let's compare the installed version with the version salt reports
|
||||
dgm_version = dir(salt.version)
|
||||
print(
|
||||
f"DGM test_sdist dgm_version '{dgm_version}', installed_version '{installed_version}', salt.version.__version__ '{salt.version.__version__}'"
|
||||
)
|
||||
assert installed_version == salt.version.__version__, "{} != {}".format(
|
||||
installed_version, salt.version.__version__
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1643,18 +1643,7 @@ class VirtualEnv:
|
|||
shutil.rmtree(str(self.venv_dir), ignore_errors=True)
|
||||
|
||||
def install(self, *args, **kwargs):
|
||||
print(f"DGM helper install args '{args}, kwargs '{kwargs}'")
|
||||
return self.run(
|
||||
self.venv_python,
|
||||
"-m",
|
||||
"pip",
|
||||
"-vvv",
|
||||
"install",
|
||||
"--ignore-installed",
|
||||
"--force-reinstall",
|
||||
*args,
|
||||
**kwargs,
|
||||
)
|
||||
return self.run(self.venv_python, "-m", "pip", "install", *args, **kwargs)
|
||||
|
||||
def uninstall(self, *args, **kwargs):
|
||||
return self.run(
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue