def create_output(url):
workdir = mkdtemp()
results = {}
results = {}
result = StringIO()
# Trickery to capture stderr from the xym tools for later use
stderr_ = sys.stderr
sys.stderr = result
extracted_models = xym.xym(source_id=url, dstdir=workdir, srcdir="", strict=True, strict_examples=False,
debug_level=0)
sys.stderr = stderr_
xym_stderr = result.getvalue()
for em in extracted_models:
file_name = em.split("@")[0].replace(".", "_")
pyang_stderr, pyang_output, confdc_stderr, yanglint_stderr = validate_yangfile(em, workdir)
results[em] = {"pyang_stderr": cgi.escape(pyang_stderr),
"pyang_output": cgi.escape(pyang_output),
"xym_stderr": cgi.escape(xym_stderr),
"confdc_stderr": cgi.escape(confdc_stderr),
"yanglint_stderr": cgi.escape(yanglint_stderr),
"name_split": file_name}
rmtree(workdir)
return results
def create_output(url):
workdir = mkdtemp()
results = {}
result = StringIO()
# Trickery to capture stderr from the xym tools for later use
stderr_ = sys.stderr
sys.stderr = result
extracted_models = xym.xym(source_id=url,
dstdir=workdir,
srcdir="",
strict=True,
strict_examples=False,
debug_level=0)
sys.stderr = stderr_
xym_stderr = result.getvalue()
for em in extracted_models:
pyang_stderr, pyang_output, confdc_stderr, yanglint_stderr = validate_yangfile(
em, workdir)
results[em] = {
"pyang_stderr": cgi.escape(pyang_stderr),
"pyang_output": cgi.escape(pyang_output),
"xym_stderr": cgi.escape(xym_stderr),
"confdc_stderr": cgi.escape(confdc_stderr),
"yanglint_stderr": cgi.escape(yanglint_stderr)
}
rmtree(workdir)
return results
def extract_from(file, dir, strict=True):
saved_stdout = sys.stdout
saved_stderr = sys.stderr
xymerr = StringIO()
xymout = StringIO()
sys.stderr = xymerr
sys.stdout = xymout
model_list = []
try:
model_list = xym.xym(str(file),
str(file.parent),
str(dir),
strict=strict,
debug_level=verbosity - 2)
for name in model_list:
modfile = moddir / name
mtime = file.stat().st_mtime
os.utime(str(modfile), (mtime, mtime))
if '"' in name:
name = name.replace('"', '')
modfile.rename(str(moddir / name))
model_list = [n.replace('"', '') for n in model_list]
except Exception as e:
print("** Error when extracting from %s: %s" % (file, str(e)))
sys.stdout = saved_stdout
sys.stderr = saved_stderr
#
if verbosity > 1:
outmsg = xymout.getvalue()
self.stdout.write(outmsg)
if verbosity > 2:
errmsg = xymerr.getvalue()
self.stderr.write(errmsg)
return model_list
def runTest(self):
"""Run a test that is the equivalent of:
xym.py test-file.txt
"""
extracted_modules = xym.xym('test-file.txt', './', './', False, False, 0)
self.assertTrue(len(extracted_modules)==5)
module_check = ['example-no-error.yang', 'ex-error.yang', 'ex-no-error.yang', 'example-error.yang', 'test-valid.yang']
for y in module_check:
self.assertTrue(y in extracted_modules)
def extract_from_rfc_file(self, rfc_file: str):
return xym.xym(rfc_file,
self.rfc_path,
self.rfc_yang_path,
strict=True,
strict_examples=False,
debug_level=self.debug_level,
add_line_refs=False,
force_revision_pyang=False,
force_revision_regexp=True)
def runTest(self):
"""Run a test that is the equivalent of:
xym.py --strict --strict-examples test-file.txt
"""
extracted_modules = xym.xym('test-file.txt', './', './', True, True, 0)
self.assertTrue(len(extracted_modules) == 1)
module_check = ['example-no-error.yang']
for y in module_check:
self.assertTrue(y in extracted_modules)
def runTest(self):
"""Run a test that is the equivalent of:
xym.py --strict --strict-examples test-file.txt
"""
extracted_modules = xym.xym('test-file.txt', './', './', True, True, 0)
self.assertTrue(len(extracted_modules)==1)
module_check = ['example-no-error.yang']
for y in module_check:
self.assertTrue(y in extracted_modules)
def create_output(url):
workdir = mkdtemp()
results = {}
result = StringIO()
# Trickery to capture stderr from the xym tools for later use
stderr_ = sys.stderr
sys.stderr = result
#url = "c:\\users\\hwx180~1\\appdata\\local\\temp\\tmpwh8emt\\draft-kumar-lime-yang-connectionless-oam-03.txt"
extracted_models = xym.xym(source_id=url, dstdir=workdir, srcdir="", strict=True, strict_examples=False,
debug_level=0)
sys.stderr = stderr_
xym_stderr = result.getvalue()
emsave = ""
for em in extracted_models:
pyang_stderr, pyang_output = validate_yangfile(em, workdir)
pyOutput = cgi.escape(pyang_output)
splitStr = ""
if ("\n" in pyOutput):
splitStr = "}\n<"
else:
splitStr = "}<"
outputList = pyOutput.split(splitStr)
jsonOutputTmp = outputList[0] + "}"
outputJson = json.loads(jsonOutputTmp)
jsonOutputTmp = json.dumps(outputJson, indent=2)
xmlOutputTmp = "<" + outputList[1]
xmlOutputTmp = xmlOutputTmp.replace("<", "<")
xmlOutputTmp = xmlOutputTmp.replace(">", ">")
outputXmlET_tmp = ET.fromstring(xmlOutputTmp)
outputXmlET = xml_indent(outputXmlET_tmp, 0)
xmlOutputTmp = ET.tostring(outputXmlET)
xmlOutputTmp = xmlOutputTmp.replace("<", "<")
xmlOutputTmp = xmlOutputTmp.replace(">", ">")
results[em] = {"pyang_stderr": cgi.escape(pyang_stderr),
"pyang_output": jsonOutputTmp,
"pyang_output1": xmlOutputTmp}
emsave = em
# "pyang_output": cgi.escape(pyang_output),
# "pyang_output1":cgi.escape(pyang_output)
rmtree(workdir)
return results, emsave
def runTest(self):
"""Run a test that is the equivalent of:
xym.py test-file.txt
"""
extracted_modules = xym.xym('test-file.txt', './', './', False, False,
0)
self.assertTrue(len(extracted_modules) == 5)
module_check = [
'example-no-error.yang', 'ex-error.yang', 'ex-no-error.yang',
'example-error.yang', 'test-valid.yang'
]
for y in module_check:
self.assertTrue(y in extracted_modules)
def extract_from_draft_file(self,
draft_file: str,
srcdir: str,
dstdir: str,
strict: bool = False,
strict_examples: bool = False):
return xym.xym(draft_file,
srcdir,
dstdir,
strict=strict,
strict_examples=strict_examples,
debug_level=self.debug_level,
add_line_refs=False,
force_revision_pyang=False,
force_revision_regexp=True)
def runTest(self):
"""Run a test that is the equivalent of:
xym.py --strict --strict-examples test-file.txt
"""
extracted_modules = xym.xym('resources/test-file-with-symbol',
'./',
'./',
strict=True,
strict_examples=False,
debug_level=0,
force_revision_regexp=True)
self.assertTrue(len(extracted_modules) == 1)
module_check = ['*****@*****.**']
for y in module_check:
self.assertTrue(y in extracted_modules)
def runTest(self):
"""Run a test that is the equivalent of:
xym.py --strict test-file.txt
"""
extracted_modules = xym.xym('resources/test-file.txt',
'./',
'./',
strict=True,
strict_examples=False,
debug_level=0)
self.assertTrue(len(extracted_modules) == 3)
module_check = [
'ex-no-error.yang', 'example-error.yang', 'test-valid.yang'
]
for y in module_check:
self.assertTrue(y in extracted_modules)
def runTest(self):
"""Run a test that is the equivalent of:
xym.py --force_revision_regexp https://tools.ietf.org/rfc/rfc7223.txt
"""
print('start force_revision_regexp')
extracted_modules = xym.xym("https://tools.ietf.org/rfc/rfc7223.txt",
'./',
'./',
debug_level=0,
force_revision_regexp=True)
self.assertTrue(len(extracted_modules) == 4)
module_check = [
'*****@*****.**', 'ex-ethernet.yang',
'ex-ethernet-bonding.yang', 'ex-vlan.yang'
]
for y in module_check:
self.assertTrue(y in extracted_modules)
def parse_and_extract(self):
extracted_models = xym.xym(source_id=self.__source,
dstdir=self.__working_directory,
srcdir="",
strict=True,
strict_examples=False,
debug_level=0,
force_revision_regexp=True)
xym_res = {'time': datetime.now(timezone.utc).isoformat()}
sys.stderr = self.__stderr_
sys.stdout = self.__stdout_
xym_res['stdout'] = self.__stdout.getvalue()
xym_res['stderr'] = self.__result.getvalue()
xym_res['name'] = 'xym'
xym_res['version'] = self.VERSION
xym_res['command'] = 'xym.xym(source_id="{}", dstdir="{}", srcdir="", strict=True, strict_examples=False,' \
' debug_level=0, force_revision_regexp=True)'.format(self.__source,
self.__working_directory)
return extracted_models, xym_res
def runTest(self):
"""Run a test that is the equivalent of:
xym.py --strict --strict-examples test-file.txt
"""
print('startig test')
extracted_modules = xym.xym(
'resources/test-file-no-file-after-code-begins',
'./',
'./',
strict=True,
strict_examples=False,
debug_level=0,
force_revision_regexp=True)
print(extracted_modules)
self.assertTrue(len(extracted_modules) == 1)
module_check = ['*****@*****.**']
for y in module_check:
self.assertTrue(y in extracted_modules)
def create_output(url):
workdir = mkdtemp()
results = {}
result = StringIO()
# Trickery to capture stderr from the xym tools for later use
stderr_ = sys.stderr
sys.stderr = result
extracted_models = xym.xym(source_id = url, dstdir = workdir, srcdir = "", strict = True, strict_examples = False, debug_level = 0)
sys.stderr = stderr_
xym_stderr = result.getvalue()
for em in extracted_models:
pyang_stderr, pyang_output = validate_yangfile(em, workdir)
results[em] = { "pyang_stderr": cgi.escape(pyang_stderr),
"pyang_output": cgi.escape(pyang_output),
"xym_stderr": cgi.escape(xym_stderr) }
rmtree(workdir)
return results
def create_output(url, for_datatracker=False):
workdir = mkdtemp()
results = {}
xym_res = {}
result = StringIO()
stdout = StringIO()
# Trickery to capture stderr from the xym tools for later use
stderr_ = sys.stderr
stdout_ = sys.stdout
sys.stderr = result
sys.stdout = stdout
try:
extracted_models = xym.xym(source_id=url,
dstdir=workdir,
srcdir="",
strict=True,
strict_examples=False,
debug_level=0)
xym_res['time'] = datetime.now(timezone.utc).isoformat()
sys.stderr = stderr_
sys.stdout = stdout_
xym_stderr = result.getvalue()
xym_res['stdout'] = stdout.getvalue()
xym_res['stderr'] = xym_stderr
xym_res['name'] = 'xym'
xym_res['version'] = versions['xym_version']
xym_res['code'] = None
workdir_split = workdir.split('/')
workdir_split[-1] = 'workdir-{}'.format(workdir_split[-1])
workdir_to_json = '/'.join(workdir_split)
xym_res[
'command'] = 'xym.xym(source_id="{}", dstdir="{}", srcdir="", strict=True, strict_examples=False, debug_level=0)'.format(
url, workdir_to_json)
modules = []
if for_datatracker:
results: dict[str, t.Any] = {'extraction': xym_res}
for em in extracted_models:
file_name = em.split("@")[0].replace(".", "_")
pyang_res, confdc_res, yanglint_res, yangdump_res = validate_yangfile(
em, workdir)
if for_datatracker:
modules.append({
'name':
em,
'checks':
[pyang_res, confdc_res, yanglint_res, yangdump_res]
})
else:
results[em] = {
"pyang_stderr": escape(pyang_res['stderr']),
"pyang_output": escape(pyang_res['stdout']),
"xym_stderr": escape(xym_res['stderr']),
"confdc_stderr": escape(confdc_res['stderr']),
"yanglint_stderr": escape(yanglint_res['stderr']),
"yangdump_stderr": escape(yangdump_res['stderr']),
"name_split": file_name
}
if for_datatracker:
results['modules'] = modules
except Exception as e:
logger.error('Error: {}'.format(e))
finally:
if os.path.exists(workdir):
shutil.rmtree(workdir)
return results
