def runTest(self):
(handle, self._target_path) = tempfile.mkstemp(prefix="testfile", text=True)
os.close(handle)
target_path = load.load_to_file(self._path, self._target_path)
self.assertEqual(target_path, self._target_path)
with open(self._target_path, 'r') as f:
self.assertEqual(self._content, f.read())
with self.assertRaises(KickstartError):
load.load_to_file("/tmp/foo", "/tmp/bar")
def runTest(self):
target_path = load.load_to_file(self._url, self._target_path)
self.assertEqual(target_path, self._target_path)
with open(self._target_path, 'r') as f:
self.assertEqual(self._content, f.read())
self.assertEqual(self._content, load.load_to_str(self._url))
self.assertRaises(KickstartError, load.load_to_file, self._url_https,
self._target_path)
def runTest(self):
target_path = load.load_to_file(self._url, self._target_path)
self.assertEqual(target_path, self._target_path)
with open(self._target_path, 'r') as f:
self.assertEqual(self._content, f.read())
self.assertEqual(self._content, load.load_to_str(self._url))
self.assertRaises(KickstartError,
load.load_to_file,
self._url_https,
self._target_path)
def runTest(self):
target_path = load.load_to_file(self._url, self._target_path)
self.assertEqual(target_path, self._target_path)
with open(self._target_path, 'r') as f:
self.assertEqual(self._content, f.read())
self.assertEqual(self._content, load.load_to_str(self._url))
# raises SSLError in _load_url()
with self.assertRaises(KickstartError):
load.load_to_file(self._url_https, self._target_path)
# raises RequestException in _load_url()
with self.assertRaises(KickstartError):
load.load_to_file('http://test.local/ks.cfg', self._target_path)
# raises IOError in load_file()
with self.assertRaises(KickstartError):
load.load_to_file(self._url, '/no/exist')
# request.status_code == 404 in _load_url()
with self.assertRaises(KickstartError):
load.load_to_file(self._url + '.TEST', '/tmp/foo')
def runTest(self):
target_path = load.load_to_file(self._url, self._target_path)
self.assertEqual(target_path, self._target_path)
with open(self._target_path, 'r') as f:
self.assertEqual(self._content, f.read())
self.assertEqual(self._content, load.load_to_str(self._url))
# raises SSLError in _load_url()
with self.assertRaises(KickstartError):
load.load_to_file(self._url_https, self._target_path)
# raises RequestException in _load_url()
with self.assertRaises(KickstartError):
load.load_to_file('http://test.local/ks.cfg', self._target_path)
# raises IOError in load_file()
with self.assertRaises(KickstartError):
load.load_to_file(self._url, '/no/exist')
# request.status_code == 404 in _load_url()
with self.assertRaises(KickstartError):
load.load_to_file(self._url+'.TEST', '/tmp/foo')
def main(argv):
op = argparse.ArgumentParser(usage="%(prog)s [options] ksfile", add_help=False)
op.add_argument("ksfile", nargs="?",
help=_("filename or URL to read from"))
op.add_argument("-e", "--firsterror", dest="firsterror", action="store_true",
default=False, help=_("halt after the first error or warning"))
op.add_argument("-i", "--followincludes", dest="followincludes",
action="store_true", default=False,
help=_("parse include files when %%include is seen"))
op.add_argument("-l", "--listversions", dest="listversions", action="store_true",
default=False,
help=_("list the available versions of kickstart syntax"))
op.add_argument("-v", "--version", dest="version", default=DEVEL,
help=_("version of kickstart syntax to validate against"))
op.add_argument("-h", "--help", dest="help", action="store_true", default=False,
help=_("show this help message and exit"))
opts = op.parse_args(argv)
# parse --help manually b/c we don't want to sys.exit before the
# tests have finished
if opts.help:
return (0, op.format_help().split("\n"))
if opts.listversions:
versions = []
for key in sorted(versionMap.keys()):
versions.append(key)
return (0, versions)
if not opts.ksfile:
return (1, op.format_usage().split("\n"))
destdir = tempfile.mkdtemp("", "ksvalidator-tmp-", "/tmp")
try:
f = load_to_file(opts.ksfile, "%s/ks.cfg" % destdir)
except KickstartError as e:
return (cleanup(destdir),
[_("Error reading %(filename)s:\n%(version)s") % {"filename": opts.ksfile, "version": e}])
try:
handler = makeVersion(opts.version)
except KickstartVersionError:
return (cleanup(destdir),
[_("The version %s is not supported by pykickstart") % opts.version])
ksparser = KickstartParser(handler, followIncludes=opts.followincludes,
errorsAreFatal=opts.firsterror)
# turn DeprecationWarnings into errors
warnings.filterwarnings("error")
processedFile = None
try:
processedFile = preprocessKickstart(f)
ksparser.readKickstart(processedFile)
return (cleanup(destdir, processedFile, exitval=ksparser.errorsCount), [])
except DeprecationWarning as err:
return (cleanup(destdir, processedFile),
[_("File uses a deprecated option or command.\n%s") % err])
except KickstartParseError as err:
return (cleanup(destdir, processedFile), [str(err)])
except KickstartError:
return (cleanup(destdir, processedFile),
[_("General kickstart error in input file")])
except Exception as e:
return (cleanup(destdir, processedFile),
[_("General error in input file: %s") % e])
def main(argv):
op = argparse.ArgumentParser(usage="%(prog)s [options] ksfile", add_help=False)
op.add_argument("ksfile", nargs="?",
help=_("filename or URL to read from"))
op.add_argument("-e", "--firsterror", dest="firsterror", action="store_true",
default=False, help=_("halt after the first error or warning"))
op.add_argument("-i", "--followincludes", dest="followincludes",
action="store_true", default=False,
help=_("parse include files when %%include is seen"))
op.add_argument("-l", "--listversions", dest="listversions", action="store_true",
default=False,
help=_("list the available versions of kickstart syntax"))
op.add_argument("-v", "--version", dest="version", default=DEVEL,
help=_("version of kickstart syntax to validate against"))
op.add_argument("-h", "--help", dest="help", action="store_true", default=False,
help=_("show this help message and exit"))
opts = op.parse_args(argv)
# parse --help manually b/c we don't want to sys.exit before the
# tests have finished
if opts.help:
return (0, op.format_help().split("\n"))
if opts.listversions:
versions = []
for key in sorted(versionMap.keys()):
versions.append(key)
return (0, versions)
if not opts.ksfile:
return (1, op.format_usage().split("\n"))
destdir = tempfile.mkdtemp("", "ksvalidator-tmp-", "/tmp")
try:
f = load_to_file(opts.ksfile, "%s/ks.cfg" % destdir)
except KickstartError as e:
return (cleanup(destdir),
[_("Error reading %(filename)s:\n%(version)s") % {"filename": opts.ksfile, "version": e}])
try:
handler = makeVersion(opts.version)
except KickstartVersionError:
return (cleanup(destdir),
[_("The version %s is not supported by pykickstart") % opts.version])
ksparser = KickstartParser(handler, followIncludes=opts.followincludes,
errorsAreFatal=opts.firsterror)
# turn kickstart parse warnings into errors
warnings.filterwarnings(action="error", category=KickstartParseWarning)
processedFile = None
try:
processedFile = preprocessKickstart(f)
ksparser.readKickstart(processedFile)
return (cleanup(destdir, processedFile, exitval=ksparser.errorsCount), [])
except KickstartDeprecationWarning as err:
return (cleanup(destdir, processedFile),
[_("File uses a deprecated option or command.\n%s") % err])
except KickstartParseError as err:
return (cleanup(destdir, processedFile), [str(err)])
except KickstartError:
return (cleanup(destdir, processedFile),
[_("General kickstart error in input file")])
except Exception as e:
return (cleanup(destdir, processedFile),
[_("General error in input file: %s") % e])
opts = op.parse_args(sys.argv[1:])
if opts.listversions:
for key in sorted(versionMap.keys()):
print(key)
sys.exit(1)
if not opts.ksfile:
op.print_usage()
sys.exit(1)
destdir = tempfile.mkdtemp("", "ksvalidator-tmp-", "/tmp")
try:
f = load_to_file(opts.ksfile, "%s/ks.cfg" % destdir)
except KickstartError as e:
print(
_("Error reading %(filename)s:\n%(version)s") % {
"filename": opts.ksfile,
"version": e
})
cleanup(destdir)
try:
handler = makeVersion(opts.version)
except KickstartVersionError:
print(_("The version %s is not supported by pykickstart") % opts.version)
cleanup(destdir)
ksparser = KickstartParser(handler,
opts = op.parse_args(sys.argv[1:])
if opts.listversions:
for key in sorted(versionMap.keys()):
print(key)
sys.exit(1)
if not opts.ksfile:
op.print_usage()
sys.exit(1)
destdir = tempfile.mkdtemp("", "ksvalidator-tmp-", "/tmp")
try:
f = load_to_file(opts.ksfile, "%s/ks.cfg" % destdir)
except KickstartError as e:
print(_("Error reading %(filename)s:\n%(version)s") % {"filename": opts.ksfile, "version": e})
cleanup(destdir)
try:
handler = makeVersion(opts.version)
except KickstartVersionError:
print(_("The version %s is not supported by pykickstart") % opts.version)
cleanup(destdir)
ksparser = KickstartParser(handler, followIncludes=opts.followincludes,
errorsAreFatal=opts.firsterror)
# turn DeprecationWarnings into errors
warnings.filterwarnings("error")
def main(argv):
op = argparse.ArgumentParser(usage="%(prog)s [options] ksfile [ksfile...]",
add_help=False)
op.add_argument("ksfile",
nargs="*",
help=_("filename or URL to read from"))
op.add_argument("-e",
"--firsterror",
dest="firsterror",
action="store_true",
default=False,
help=_("halt after the first error or warning"))
op.add_argument("-i",
"--followincludes",
dest="followincludes",
action="store_true",
default=False,
help=_("parse include files when %%include is seen"))
op.add_argument("-l",
"--listversions",
dest="listversions",
action="store_true",
default=False,
help=_("list the available versions of kickstart syntax"))
op.add_argument("-v",
"--version",
dest="version",
default=DEVEL,
help=_("version of kickstart syntax to validate against"))
op.add_argument("-h",
"--help",
dest="help",
action="store_true",
default=False,
help=_("show this help message and exit"))
opts = op.parse_args(argv)
# parse --help manually b/c we don't want to sys.exit before the
# tests have finished
if opts.help:
return (0, op.format_help().split("\n"))
if opts.listversions:
versions = []
for key in sorted(versionMap.keys()):
versions.append(key)
return (0, versions)
if not opts.ksfile:
return (1, op.format_usage().split("\n"))
rc = 0
retmsg = []
# unpack any globs
ksfiles = []
for inksfile in opts.ksfile:
if is_url(inksfile):
ksfiles.append(inksfile)
else:
ksfiles.extend(glob.glob(inksfile))
# check if there are any files to check
if not ksfiles:
return (1, ["No files match the patterns."])
# iterate over files to check them
with tempfile.TemporaryDirectory(prefix="ksvalidator-tmp-") as destdir:
for ksfile in ksfiles:
print(
_("\nChecking kickstart file %(filename)s\n" %
{"filename": ksfile}))
try:
f = load_to_file(ksfile, os.path.join(destdir, "ks.cfg"))
except KickstartError as e:
rc += 1
retmsg.append(
_("Error reading %(filename)s:\n%(version)s") % {
"filename": ksfile,
"version": e
})
try:
handler = makeVersion(opts.version)
except KickstartVersionError:
# return immediately because bad version is fatal for all files
return (1, [
_("The version %s is not supported by pykickstart") %
opts.version
])
# turn kickstart parse warnings into errors
warnings.filterwarnings(action="error",
category=KickstartParseWarning)
ksparser = KickstartParser(handler,
followIncludes=opts.followincludes,
errorsAreFatal=opts.firsterror)
try:
processedFile = preprocessKickstart(f)
if processedFile is None:
raise RuntimeError("Empty file")
ksparser.readKickstart(processedFile)
rc += ksparser.errorsCount
except KickstartDeprecationWarning as err:
rc += 1
retmsg.append(
_("File uses a deprecated option or command.\n%s") % err)
except KickstartParseError as err:
rc += 1
retmsg.append(str(err))
except KickstartError:
rc += 1
retmsg.append(_("General kickstart error in input file"))
except Exception as e: # pylint: disable=broad-except
rc += 1
retmsg.append(_("General error in input file: %s") % e)
return rc, retmsg
