mirror of
https://github.com/saltstack/salt.git
synced 2025-04-17 10:10:20 +00:00
Debug version, running for PR tests wip
This commit is contained in:
David Murphy
Megan Wilhite
parent
e8441238e1
commit
41ad6c1922
4 changed files with 415 additions and 22 deletions
|
|
@ -1,3 +1,7 @@
|
|||
## [build-system]
|
||||
## requires = ["setuptools", "wheel", "packaging", "looseversion"]
|
||||
## build-backend = "setuptools.build_meta"
|
||||
|
||||
[tool.black]
|
||||
exclude= """
|
||||
/(
|
||||
|
|
|
|||
|
|
@ -18,16 +18,147 @@ import numbers
|
|||
import sys
|
||||
import warnings
|
||||
|
||||
# pylint: disable=blacklisted-module
|
||||
from distutils.version import LooseVersion as _LooseVersion
|
||||
from distutils.version import StrictVersion as _StrictVersion
|
||||
|
||||
# pylint: enable=blacklisted-module
|
||||
import salt.version
|
||||
|
||||
# DGM
|
||||
## import re
|
||||
|
||||
|
||||
# pylint: disable=blacklisted-module
|
||||
|
||||
## from distutils.version import StrictVersion as _StrictVersion
|
||||
## from distutils.version import LooseVersion as _LooseVersion
|
||||
|
||||
|
||||
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)
|
||||
|
|
|
|||
108
salt/version.py
108
salt/version.py
|
|
@ -6,6 +6,9 @@ import operator
|
|||
import platform
|
||||
import re
|
||||
import sys
|
||||
|
||||
# DGM
|
||||
import traceback
|
||||
from collections import namedtuple
|
||||
from functools import total_ordering
|
||||
|
||||
|
|
@ -193,15 +196,23 @@ 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
|
||||
|
|
@ -214,6 +225,9 @@ 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
|
||||
|
|
@ -225,6 +239,9 @@ 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
|
||||
|
||||
|
||||
|
|
@ -278,7 +295,10 @@ 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)
|
||||
|
||||
|
|
@ -288,10 +308,11 @@ class SaltStackVersion:
|
|||
minor = None
|
||||
else:
|
||||
minor = int(minor)
|
||||
|
||||
if self.can_have_dot_zero(major):
|
||||
minor = minor if minor else 0
|
||||
|
||||
if bugfix is None and not self.new_version(major=major):
|
||||
if bugfix is None and not self.new_version_scheme(major=major):
|
||||
bugfix = 0
|
||||
elif isinstance(bugfix, str):
|
||||
if not bugfix:
|
||||
|
|
@ -324,7 +345,7 @@ class SaltStackVersion:
|
|||
self.mbugfix = mbugfix
|
||||
self.pre_type = pre_type
|
||||
self.pre_num = pre_num
|
||||
if self.new_version(major):
|
||||
if self.new_version_scheme(major):
|
||||
vnames_key = (major,)
|
||||
else:
|
||||
vnames_key = (major, minor)
|
||||
|
|
@ -332,7 +353,7 @@ class SaltStackVersion:
|
|||
self.noc = noc
|
||||
self.sha = sha
|
||||
|
||||
def new_version(self, major):
|
||||
def new_version_scheme(self, major):
|
||||
"""
|
||||
determine if using new versioning scheme
|
||||
"""
|
||||
|
|
@ -393,7 +414,7 @@ class SaltStackVersion:
|
|||
|
||||
def min_info(self):
|
||||
info = [self.major]
|
||||
if self.new_version(self.major):
|
||||
if self.new_version_scheme(self.major):
|
||||
if self.minor:
|
||||
info.append(self.minor)
|
||||
elif self.can_have_dot_zero(self.major):
|
||||
|
|
@ -445,7 +466,7 @@ class SaltStackVersion:
|
|||
|
||||
@property
|
||||
def string(self):
|
||||
if self.new_version(self.major):
|
||||
if self.new_version_scheme(self.major):
|
||||
version_string = "{}".format(self.major)
|
||||
if self.minor:
|
||||
version_string = "{}.{}".format(self.major, self.minor)
|
||||
|
|
@ -481,7 +502,7 @@ class SaltStackVersion:
|
|||
|
||||
@property
|
||||
def pre_index(self):
|
||||
if self.new_version(self.major):
|
||||
if self.new_version_scheme(self.major):
|
||||
pre_type = 2
|
||||
if not isinstance(self.minor, int):
|
||||
pre_type = 1
|
||||
|
|
@ -507,7 +528,7 @@ class SaltStackVersion:
|
|||
other_noc_info = list(other.noc_info)
|
||||
noc_info = list(self.noc_info)
|
||||
|
||||
if self.new_version(self.major):
|
||||
if self.new_version_scheme(self.major):
|
||||
if self.minor and not other.minor:
|
||||
# We have minor information, the other side does not
|
||||
if self.minor > 0:
|
||||
|
|
@ -552,7 +573,7 @@ class SaltStackVersion:
|
|||
parts.append("name='{}'".format(self.name))
|
||||
parts.extend(["major={}".format(self.major), "minor={}".format(self.minor)])
|
||||
|
||||
if self.new_version(self.major):
|
||||
if self.new_version_scheme(self.major):
|
||||
if not self.minor:
|
||||
parts.remove("".join([x for x in parts if re.search("^minor*", x)]))
|
||||
else:
|
||||
|
|
@ -575,6 +596,9 @@ 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 ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
|
@ -585,16 +609,28 @@ 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:
|
||||
|
|
@ -614,7 +650,7 @@ def __discover_version(saltstack_version):
|
|||
"v[0-9]*",
|
||||
"--always",
|
||||
],
|
||||
**kwargs
|
||||
**kwargs,
|
||||
)
|
||||
|
||||
out, err = process.communicate()
|
||||
|
|
@ -623,22 +659,36 @@ 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
|
||||
|
||||
return SaltStackVersion.parse(out)
|
||||
## 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
|
||||
|
||||
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
|
||||
|
||||
|
||||
|
|
@ -647,28 +697,57 @@ def __get_version(saltstack_version):
|
|||
If we can get a version provided at installation time or from Git, use
|
||||
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:
|
||||
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()}'"
|
||||
)
|
||||
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()
|
||||
## 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 = 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
|
||||
|
|
@ -902,4 +981,5 @@ def versions_report(include_salt_cloud=False, include_extensions=True):
|
|||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print(f"DGM salt/version.py __version__ '{__version__}'")
|
||||
print(__version__)
|
||||
|
|
|
|||
186
setup.py
Normal file → Executable file
186
setup.py
Normal file → Executable file
|
|
@ -12,6 +12,9 @@ import glob
|
|||
import os
|
||||
import platform
|
||||
import sys
|
||||
|
||||
# DGM
|
||||
import traceback
|
||||
import warnings
|
||||
from ctypes.util import find_library
|
||||
from datetime import datetime
|
||||
|
|
@ -34,6 +37,7 @@ from setuptools.command.sdist import sdist
|
|||
|
||||
# pylint: enable=no-name-in-module
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
try:
|
||||
from urllib2 import urlopen
|
||||
|
|
@ -97,6 +101,8 @@ 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
|
||||
|
|
@ -170,7 +176,10 @@ PACKAGED_FOR_SALT_SSH = os.path.isfile(PACKAGED_FOR_SALT_SSH_FILE)
|
|||
|
||||
|
||||
# pylint: disable=W0122
|
||||
exec(compile(open(SALT_VERSION).read(), SALT_VERSION, "exec"))
|
||||
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
|
||||
# pylint: enable=W0122
|
||||
|
||||
|
||||
|
|
@ -178,6 +187,8 @@ exec(compile(open(SALT_VERSION).read(), SALT_VERSION, "exec"))
|
|||
|
||||
|
||||
def _parse_requirements_file(requirements_file):
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
parsed_requirements = []
|
||||
with open(requirements_file) as rfh:
|
||||
for line in rfh.readlines():
|
||||
|
|
@ -188,6 +199,8 @@ def _parse_requirements_file(requirements_file):
|
|||
if "libcloud" in line:
|
||||
continue
|
||||
parsed_requirements.append(line)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
return parsed_requirements
|
||||
|
||||
|
||||
|
|
@ -199,6 +212,11 @@ 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):
|
||||
"""
|
||||
|
|
@ -211,6 +229,12 @@ 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
|
||||
|
|
@ -228,30 +252,43 @@ class WriteSaltVersion(Command):
|
|||
## 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}'")
|
||||
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
|
||||
|
|
@ -260,6 +297,11 @@ 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")
|
||||
|
|
@ -289,12 +331,18 @@ 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):
|
||||
"""
|
||||
|
|
@ -307,6 +355,11 @@ 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:
|
||||
|
|
@ -318,9 +371,11 @@ 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",
|
||||
|
|
@ -349,6 +404,7 @@ class Develop(develop):
|
|||
"switched to True.",
|
||||
),
|
||||
]
|
||||
## DGM assert __version__ != '3006.0'
|
||||
boolean_options = develop.boolean_options + [
|
||||
"write-salt-version",
|
||||
"generate-salt-syspaths",
|
||||
|
|
@ -356,12 +412,17 @@ 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
|
||||
|
|
@ -373,8 +434,11 @@ 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
|
||||
|
|
@ -390,12 +454,22 @@ 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):
|
||||
|
|
@ -405,12 +479,19 @@ 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
|
||||
|
|
@ -421,12 +502,16 @@ 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
|
||||
@contextlib.contextmanager
|
||||
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}")
|
||||
|
|
@ -479,38 +564,54 @@ 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",
|
||||
|
|
@ -523,12 +624,17 @@ 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(
|
||||
|
|
@ -540,8 +646,10 @@ 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.
|
||||
|
|
@ -586,9 +694,12 @@ 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[:]:
|
||||
|
|
@ -596,10 +707,12 @@ 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")
|
||||
|
|
@ -617,7 +730,9 @@ 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]
|
||||
|
|
@ -625,6 +740,7 @@ 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,
|
||||
|
|
@ -632,26 +748,33 @@ 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 = """\
|
||||
|
|
@ -691,46 +814,63 @@ 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"
|
||||
|
|
@ -745,6 +885,7 @@ 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
|
||||
|
|
@ -754,10 +895,14 @@ 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):
|
||||
|
|
@ -770,9 +915,14 @@ 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)
|
||||
## return install._called_from_setup(run_frame)
|
||||
mydgm = install._called_from_setup(run_frame)
|
||||
## DGM assert __version__ != '3006.0'
|
||||
return mydgm
|
||||
|
||||
# Because Salt subclasses the setuptools install command, it needs to
|
||||
# override this static method to provide the right frame for the logic
|
||||
|
|
@ -780,12 +930,16 @@ 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
|
||||
|
|
@ -794,11 +948,14 @@ 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()
|
||||
|
|
@ -847,6 +1004,8 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
Under *nix, all scripts should be installed
|
||||
"""
|
||||
|
||||
## DGM assert __version__ != '3006.0'
|
||||
|
||||
global_options = (
|
||||
distutils.dist.Distribution.global_options
|
||||
+ [
|
||||
|
|
@ -915,8 +1074,15 @@ class SaltDistribution(distutils.dist.Distribution):
|
|||
)
|
||||
|
||||
def __init__(self, attrs=None):
|
||||
print(f"DGM setup __init__ attrs'{attrs}'")
|
||||
## 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
|
||||
|
|
@ -977,6 +1143,8 @@ 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,
|
||||
|
|
@ -991,6 +1159,8 @@ 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:
|
||||
|
|
@ -1008,6 +1178,10 @@ 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
|
||||
|
|
@ -1025,6 +1199,7 @@ 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:
|
||||
|
|
@ -1342,6 +1517,8 @@ 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)
|
||||
|
||||
if not self.ssh_packaging and PACKAGED_FOR_SALT_SSH:
|
||||
|
|
@ -1368,6 +1545,7 @@ 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
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue