def session_draft_pdf(request, num, session):
drafts = session_draft_list(num, session);
curr_page = 1
pmh, pmn = mkstemp()
os.close(pmh)
pdfmarks = open(pmn, "w")
pdf_list = ""
for draft in drafts:
pdf_path = os.path.join(settings.INTERNET_DRAFT_PDF_PATH, draft + ".pdf")
if not os.path.exists(pdf_path):
convert_draft_to_pdf(draft)
if os.path.exists(pdf_path):
pages = pdf_pages(pdf_path)
pdfmarks.write("[/Page "+str(curr_page)+" /View [/XYZ 0 792 1.0] /Title (" + draft + ") /OUT pdfmark\n")
pdf_list = pdf_list + " " + pdf_path
curr_page = curr_page + pages
pdfmarks.close()
pdfh, pdfn = mkstemp()
os.close(pdfh)
pipe("gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile=" + pdfn + " " + pdf_list + " " + pmn)
pdf = open(pdfn,"r")
pdf_contents = pdf.read()
pdf.close()
os.unlink(pmn)
os.unlink(pdfn)
return HttpResponse(pdf_contents, content_type="application/pdf")
def session_draft_pdf(request, num, session):
drafts = session_draft_list(num, session)
curr_page = 1
pmh, pmn = mkstemp()
pdfmarks = open(pmn, "w")
pdf_list = ""
for draft in drafts:
pdf_path = os.path.join(settings.INTERNET_DRAFT_PDF_PATH,
draft + ".pdf")
if (not os.path.exists(pdf_path)):
convert_to_pdf(draft)
if (os.path.exists(pdf_path)):
pages = pdf_pages(pdf_path)
pdfmarks.write("[/Page " + str(curr_page) +
" /View [/XYZ 0 792 1.0] /Title (" + draft +
") /OUT pdfmark\n")
pdf_list = pdf_list + " " + pdf_path
curr_page = curr_page + pages
pdfmarks.close()
pdfh, pdfn = mkstemp()
pipe("gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile=" + pdfn +
" " + pdf_list + " " + pmn)
pdf = open(pdfn, "r")
pdf_contents = pdf.read()
pdf.close()
os.unlink(pmn)
os.unlink(pdfn)
return HttpResponse(pdf_contents, mimetype="application/pdf")
def check_idnits(path):
#p = subprocess.Popen([self.idnits, '--submitcheck', '--nitcount', path], stdout=subprocess.PIPE)
cmd = "%s --submitcheck --nitcount %s" % (settings.IDSUBMIT_IDNITS_BINARY, path)
code, out, err = pipe(cmd)
if code != 0:
log("idnits error: %s:\n Error %s: %s" %( cmd, code, err))
return out
def convert_to_pdf(doc_name):
inpath = os.path.join(settings.IDSUBMIT_REPOSITORY_PATH, doc_name + ".txt")
outpath = os.path.join(settings.INTERNET_DRAFT_PDF_PATH, doc_name + ".pdf")
try:
infile = open(inpath, "r")
except IOError:
return
t, tempname = mkstemp()
tempfile = open(tempname, "w")
pageend = 0
newpage = 0
formfeed = 0
for line in infile:
line = re.sub("\r", "", line)
line = re.sub("[ \t]+$", "", line)
if re.search("\[?[Pp]age [0-9ivx]+\]?[ \t]*$", line):
pageend = 1
tempfile.write(line)
continue
if re.search("^[ \t]*\f", line):
formfeed = 1
tempfile.write(line)
continue
if re.search("^ *INTERNET.DRAFT.+[0-9]+ *$", line) or re.search(
"^ *Internet.Draft.+[0-9]+ *$", line) or re.search(
"^draft-[-a-z0-9_.]+.*[0-9][0-9][0-9][0-9]$",
line) or re.search("^RFC.+[0-9]+$", line):
newpage = 1
if re.search("^[ \t]*$", line) and pageend and not newpage:
continue
if pageend and newpage and not formfeed:
tempfile.write("\f")
pageend = 0
formfeed = 0
newpage = 0
tempfile.write(line)
infile.close()
tempfile.close()
t, psname = mkstemp()
pipe("enscript --margins 76::76: -B -q -p " + psname + " " + tempname)
os.unlink(tempname)
pipe("ps2pdf " + psname + " " + outpath)
os.unlink(psname)
def check_file_txt(self, path):
"""
Run an idnits check, and return a passed/failed indication, a message,
and error and warning messages.
Error and warning list items are tuples:
(line_number, line_text, message)
"""
filename = os.path.basename(path)
result = {}
items = []
errors = 0
warnings = 0
errstart = [' ** ', ' ~~ ']
warnstart = [' == ', ' -- ']
cmd = "%s %s %s" % (settings.IDSUBMIT_IDNITS_BINARY, self.options, path)
code, out, err = pipe(cmd)
if code != 0 or out == "":
message = "idnits error: %s:\n Error %s: %s" %( cmd, code, err)
log(message)
passed = False
else:
message = out
if re.search("\s+Summary:\s+0\s+|No nits found", out):
passed = True
else:
passed = False
item = ""
for line in message.splitlines():
if line[:5] in (errstart + warnstart):
item = line.rstrip()
elif line.strip() == "" and item:
tuple = (None, None, item)
items.append(tuple)
if item[:5] in errstart:
errors += 1
elif item[:5] in warnstart:
warnings += 1
else:
raise RuntimeError("Unexpected state in idnits checker: item: %s, line: %s" % (item, line))
item = ""
elif item and line.strip() != "":
item += " " + line.strip()
else:
pass
result[filename] = {
"passed": passed,
"message": message,
"errors": errors,
"warnings":warnings,
"items": items,
}
return passed, message, errors, warnings, result
def check_idnits(self):
filepath = os.path.join(self.staging_path, '%s-%s.txt' % (self.draft.filename, self.draft.revision))
#p = subprocess.Popen([self.idnits, '--submitcheck', '--nitcount', filepath], stdout=subprocess.PIPE)
cmd = "%s --submitcheck --nitcount %s" % (self.idnits, filepath)
code, out, err = pipe(cmd)
if code != 0:
log("idnits error: %s:\n Error %s: %s" %(cmd, code, err))
self.idnits_message = out
def convert_to_pdf(doc_name):
inpath = os.path.join(settings.IDSUBMIT_REPOSITORY_PATH, doc_name + ".txt")
outpath = os.path.join(settings.INTERNET_DRAFT_PDF_PATH, doc_name + ".pdf")
try:
infile = open(inpath, "r")
except IOError:
return
t,tempname = mkstemp()
os.close(t)
tempfile = open(tempname, "w")
pageend = 0;
newpage = 0;
formfeed = 0;
for line in infile:
line = re.sub("\r","",line)
line = re.sub("[ \t]+$","",line)
if re.search("\[?[Pp]age [0-9ivx]+\]?[ \t]*$",line):
pageend=1
tempfile.write(line)
continue
if re.search("^[ \t]*\f",line):
formfeed=1
tempfile.write(line)
continue
if re.search("^ *INTERNET.DRAFT.+[0-9]+ *$",line) or re.search("^ *Internet.Draft.+[0-9]+ *$",line) or re.search("^draft-[-a-z0-9_.]+.*[0-9][0-9][0-9][0-9]$",line) or re.search("^RFC.+[0-9]+$",line):
newpage=1
if re.search("^[ \t]*$",line) and pageend and not newpage:
continue
if pageend and newpage and not formfeed:
tempfile.write("\f")
pageend=0
formfeed=0
newpage=0
tempfile.write(line)
infile.close()
tempfile.close()
t,psname = mkstemp()
os.close(t)
pipe("enscript --margins 76::76: -B -q -p "+psname + " " +tempname)
os.unlink(tempname)
pipe("ps2pdf "+psname+" "+outpath)
os.unlink(psname)
def check_idnits(self):
filepath = os.path.join(
self.staging_path,
'%s-%s.txt' % (self.draft.filename, self.draft.revision))
#p = subprocess.Popen([self.idnits, '--submitcheck', '--nitcount', filepath], stdout=subprocess.PIPE)
cmd = "%s --submitcheck --nitcount %s" % (self.idnits, filepath)
code, out, err = pipe(cmd)
if code != 0:
log("idnits error: %s:\n Error %s: %s" % (cmd, code, err))
self.idnits_message = out
def store_nomcom_private_key(request, year, private_key):
if not private_key:
request.session['NOMCOM_PRIVATE_KEY_%s' % year] = ''
else:
command = "%s bf -e -in /dev/stdin -k \"%s\" -a"
code, out, error = pipe(command % (settings.OPENSSL_COMMAND,
settings.SECRET_KEY), private_key)
if code != 0:
log("openssl error: %s:\n Error %s: %s" %(command, code, error))
if error:
out = ''
request.session['NOMCOM_PRIVATE_KEY_%s' % year] = out
def retrieve_nomcom_private_key(request, year):
private_key = request.session.get('NOMCOM_PRIVATE_KEY_%s' % year, None)
if not private_key:
return private_key
command = "%s bf -d -in /dev/stdin -k \"%s\" -a"
code, out, error = pipe(command % (settings.OPENSSL_COMMAND,
settings.SECRET_KEY), private_key)
if code != 0:
log("openssl error: %s:\n Error %s: %s" %(command, code, error))
return out
def retrieve_nomcom_private_key(request, year):
private_key = request.session.get('NOMCOM_PRIVATE_KEY_%s' % year, None)
if not private_key:
return private_key
command = "%s bf -d -in /dev/stdin -k \"%s\" -a"
code, out, error = pipe(
command % (settings.OPENSSL_COMMAND, settings.SECRET_KEY), private_key)
if code != 0:
log("openssl error: %s:\n Error %s: %s" % (command, code, error))
return out
def dependencies_pdf(request, acronym, group_type=None):
group = get_group_or_404(acronym, group_type)
if not group.features.has_documents:
raise Http404
dothandle,dotname = mkstemp()
os.close(dothandle)
dotfile = open(dotname,"w")
dotfile.write(make_dot(group))
dotfile.close()
unflathandle,unflatname = mkstemp()
os.close(unflathandle)
pshandle,psname = mkstemp()
os.close(pshandle)
pdfhandle,pdfname = mkstemp()
os.close(pdfhandle)
pipe("%s -f -l 10 -o %s %s" % (settings.UNFLATTEN_BINARY,unflatname,dotname))
pipe("%s -Tps -Gsize=10.5,8.0 -Gmargin=0.25 -Gratio=auto -Grotate=90 -o %s %s" % (settings.DOT_BINARY,psname,unflatname))
pipe("%s %s %s" % (settings.PS2PDF_BINARY,psname,pdfname))
pdfhandle = open(pdfname,"r")
pdf = pdfhandle.read()
pdfhandle.close()
os.unlink(pdfname)
os.unlink(psname)
os.unlink(unflatname)
os.unlink(dotname)
return HttpResponse(pdf, content_type='application/pdf')
def store_nomcom_private_key(request, year, private_key):
if not private_key:
request.session['NOMCOM_PRIVATE_KEY_%s' % year] = ''
else:
command = "%s bf -e -in /dev/stdin -k \"%s\" -a"
code, out, error = pipe(
command % (settings.OPENSSL_COMMAND, settings.SECRET_KEY),
private_key)
if code != 0:
log("openssl error: %s:\n Error %s: %s" % (command, code, error))
if error:
out = ''
request.session['NOMCOM_PRIVATE_KEY_%s' % year] = out
def validate_private_key(key):
key_file = tempfile.NamedTemporaryFile(delete=False)
key_file.write(key)
key_file.close()
command = "%s rsa -in %s -check -noout"
code, out, error = pipe(command % (settings.OPENSSL_COMMAND,
key_file.name))
if code != 0:
log("openssl error: %s:\n Error %s: %s" %(command, code, error))
os.unlink(key_file.name)
return (not error, error)
def handle(self, *filenames, **options):
for c in VersionInfo.objects.filter(used=True):
cmd = "%s %s" % (c.command, c.switch)
code, out, err = pipe(cmd)
if code != 0:
sys.stderr.write("Command '%s' retuned %s: \n%s\n%s\n" %
(cmd, code, out, err))
else:
c.version = (out.strip() + '\n' + err.strip()).strip()
if options.get('verbosity', 1) > 1:
sys.stdout.write("Command: %s\n"
" Version: %s\n" % (cmd, c.version))
c.save()
def validate_private_key(key):
key_file = tempfile.NamedTemporaryFile(delete=False)
key_file.write(key)
key_file.close()
command = "%s rsa -in %s -check -noout"
code, out, error = pipe(command %
(settings.OPENSSL_COMMAND, key_file.name))
if code != 0:
log("openssl error: %s:\n Error %s: %s" % (command, code, error))
os.unlink(key_file.name)
return (not error, error)
def validate_public_key(public_key):
key_file = tempfile.NamedTemporaryFile(delete=False)
for chunk in public_key.chunks():
key_file.write(chunk)
key_file.close()
command = "%s x509 -in %s -noout"
code, out, error = pipe(command % (settings.OPENSSL_COMMAND,
key_file.name))
if code != 0:
log("openssl error: %s:\n Error %s: %s" %(command, code, error))
os.unlink(key_file.name)
return (not error, error)
def validate_public_key(public_key):
key_file = tempfile.NamedTemporaryFile(delete=False)
for chunk in public_key.chunks():
key_file.write(chunk)
key_file.close()
command = "%s x509 -in %s -noout"
code, out, error = pipe(command %
(settings.OPENSSL_COMMAND, key_file.name))
if code != 0:
log("openssl error: %s:\n Error %s: %s" % (command, code, error))
os.unlink(key_file.name)
return (not error, error)
def dependencies(request, acronym, group_type=None, output_type="pdf"):
group = get_group_or_404(acronym, group_type)
if not group.features.has_documents:
raise Http404
dothandle, dotname = mkstemp()
os.close(dothandle)
dotfile = open(dotname, "w")
dotfile.write(make_dot(group))
dotfile.close()
if (output_type == "dot"):
return HttpResponse(make_dot(group),
content_type='text/plain; charset=UTF-8'
)
unflathandle, unflatname = mkstemp()
os.close(unflathandle)
outhandle, outname = mkstemp()
os.close(outhandle)
pipe("%s -f -l 10 -o %s %s" % (settings.UNFLATTEN_BINARY, unflatname, dotname))
pipe("%s -T%s -o %s %s" % (settings.DOT_BINARY, output_type, outname, unflatname))
outhandle = open(outname, "r")
out = outhandle.read()
outhandle.close()
os.unlink(outname)
os.unlink(unflatname)
os.unlink(dotname)
if (output_type == "pdf"):
output_type = "application/pdf"
elif (output_type == "svg"):
output_type = "image/svg+xml"
return HttpResponse(out, content_type=output_type)
def do_cmd(self, cmd, *args):
quoted_args = ['"%s"' % a if ' ' in a else a for a in args]
if self.dummy_run:
self.note("Would run %s %s ..." %
(os.path.basename(cmd), " ".join(quoted_args)))
else:
self.note("Running %s %s ..." %
(os.path.basename(cmd), " ".join(quoted_args)))
command = [
cmd,
] + list(args)
code, out, err = pipe(command)
msg = None
if code != 0:
msg = "Error %s: %s when executing '%s'" % (code, err,
" ".join(command))
self.log(msg)
return msg, out
def check_comments(encryped, plain, privatekey_file):
encrypted_file = tempfile.NamedTemporaryFile(delete=False)
encrypted_file.write(encryped)
encrypted_file.close()
# to decrypt comments was encryped and check they are equal to the plain comments
decrypted_file = tempfile.NamedTemporaryFile(delete=False)
command = "%s smime -decrypt -in %s -out %s -inkey %s"
code, out, error = pipe(command %
(settings.OPENSSL_COMMAND, encrypted_file.name,
decrypted_file.name, privatekey_file.name))
decrypted_file.close()
encrypted_file.close()
decrypted_comments = open(decrypted_file.name, 'r').read().decode('utf8')
os.unlink(encrypted_file.name)
os.unlink(decrypted_file.name)
return decrypted_comments == plain
def pre_save(self, instance, add):
if add:
comments = smart_str(getattr(instance, 'comments'))
nomcom = getattr(instance, 'nomcom')
cert_file = nomcom.public_key.path
code, out, error = pipe(
"%s smime -encrypt -in /dev/stdin %s" %
(settings.OPENSSL_COMMAND, cert_file), comments)
if code != 0:
log("openssl error: %s:\n Error %s: %s" %
(command, code, error))
if not error:
instance.comments = out
return out
else:
raise EncryptedException(error)
else:
return instance.comments
def pre_save(self, instance, add):
if add:
comments = smart_str(getattr(instance, 'comments'))
nomcom = getattr(instance, 'nomcom')
try:
cert_file = nomcom.public_key.path
except ValueError as e:
raise ValueError("Trying to read the NomCom public key: " + str(e))
command = "%s smime -encrypt -in /dev/stdin %s" % (settings.OPENSSL_COMMAND, cert_file)
code, out, error = pipe(command, comments)
if code != 0:
log("openssl error: %s:\n Error %s: %s" %(command, code, error))
if not error:
instance.comments = out
return out
else:
raise EncryptedException(error)
else:
return instance.comments
def check_comments(encryped, plain, privatekey_file):
encrypted_file = tempfile.NamedTemporaryFile(delete=False)
encrypted_file.write(encryped)
encrypted_file.close()
# to decrypt comments was encryped and check they are equal to the plain comments
decrypted_file = tempfile.NamedTemporaryFile(delete=False)
command = "%s smime -decrypt -in %s -out %s -inkey %s"
code, out, error = pipe(command % (settings.OPENSSL_COMMAND,
encrypted_file.name,
decrypted_file.name,
privatekey_file.name))
decrypted_file.close()
encrypted_file.close()
decrypted_comments = open(decrypted_file.name, 'r').read().decode('utf8')
os.unlink(encrypted_file.name)
os.unlink(decrypted_file.name)
return decrypted_comments == plain
def decrypt(string, request, year, plain=False):
key = retrieve_nomcom_private_key(request, year)
if not key:
return '-*- Encrypted text [No private key provided] -*-'
encrypted_file = tempfile.NamedTemporaryFile(delete=False)
encrypted_file.write(string)
encrypted_file.close()
command = "%s smime -decrypt -in %s -inkey /dev/stdin"
code, out, error = pipe(command % (settings.OPENSSL_COMMAND,
encrypted_file.name), key)
if code != 0:
log("openssl error: %s:\n Error %s: %s" %(command, code, error))
os.unlink(encrypted_file.name)
if error:
return '-*- Encrypted text [Your private key is invalid] -*-'
if not plain:
return force_escape(linebreaksbr(out))
return wrap_text(force_escape(out))
def decrypt(string, request, year, plain=False):
key = retrieve_nomcom_private_key(request, year)
if not key:
return '-*- Encrypted text [No private key provided] -*-'
encrypted_file = tempfile.NamedTemporaryFile(delete=False)
encrypted_file.write(string)
encrypted_file.close()
command = "%s smime -decrypt -in %s -inkey /dev/stdin"
code, out, error = pipe(
command % (settings.OPENSSL_COMMAND, encrypted_file.name), key)
if code != 0:
log("openssl error: %s:\n Error %s: %s" % (command, code, error))
os.unlink(encrypted_file.name)
if error:
return '-*- Encrypted text [Your private key is invalid] -*-'
if not plain:
return force_escape(linebreaksbr(out))
return mark_safe(wordwrap(force_escape(out)))
def generate_cert():
"""Function to generate cert"""
config = """
[ req ]
distinguished_name = req_distinguished_name
string_mask = utf8only
x509_extensions = ss_v3_ca
[ req_distinguished_name ]
commonName = Common Name (e.g., NomComYY)
commonName_default = NomCom12
[ ss_v3_ca ]
subjectKeyIdentifier = hash
keyUsage = critical, digitalSignature, keyEncipherment, dataEncipherment
basicConstraints = critical, CA:true
subjectAltName = email:[email protected]
extendedKeyUsage= emailProtection"""
config_file = tempfile.NamedTemporaryFile(delete=False)
privatekey_file = tempfile.NamedTemporaryFile(delete=False)
cert_file = tempfile.NamedTemporaryFile(delete=False)
config_file.write(config)
config_file.close()
command = "%s req -config %s -x509 -new -newkey rsa:2048 -sha256 -days 730 -nodes \
-keyout %s -out %s -batch"
code, out, error = pipe(command % (settings.OPENSSL_COMMAND,
config_file.name,
privatekey_file.name,
cert_file.name))
privatekey_file.close()
cert_file.close()
return cert_file, privatekey_file
def generate_cert():
"""Function to generate cert"""
config = """
[ req ]
distinguished_name = req_distinguished_name
string_mask = utf8only
x509_extensions = ss_v3_ca
[ req_distinguished_name ]
commonName = Common Name (e.g., NomComYY)
commonName_default = NomCom12
[ ss_v3_ca ]
subjectKeyIdentifier = hash
keyUsage = critical, digitalSignature, keyEncipherment, dataEncipherment
basicConstraints = critical, CA:true
subjectAltName = email:[email protected]
extendedKeyUsage= emailProtection"""
config_file = tempfile.NamedTemporaryFile(delete=False)
privatekey_file = tempfile.NamedTemporaryFile(delete=False)
cert_file = tempfile.NamedTemporaryFile(delete=False)
config_file.write(config)
config_file.close()
command = "%s req -config %s -x509 -new -newkey rsa:2048 -sha256 -days 730 -nodes \
-keyout %s -out %s -batch"
code, out, error = pipe(command % (settings.OPENSSL_COMMAND,
config_file.name,
privatekey_file.name,
cert_file.name))
privatekey_file.close()
cert_file.close()
return cert_file, privatekey_file
from ietf.utils.test_runner import set_coverage_checking
from ietf.utils.pipe import pipe
from ietf import settings
skip_selenium = getattr(settings, 'SKIP_SELENIUM', None)
skip_message = ""
if skip_selenium:
skip_message = "settings.SKIP_SELENIUM = %s" % skip_selenium
else:
try:
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
except ImportError as e:
skip_selenium = True
skip_message = "Skipping selenium tests: %s" % e
code, out, err = pipe('phantomjs -v')
if not code == 0:
skip_selenium = True
skip_message = "Skipping selenium tests: 'phantomjs' executable not found."
if skip_selenium:
sys.stderr.write(" " + skip_message + '\n')
def condition_data():
make_meeting_test_data()
colors.fg_group_colors['FARFUT'] = 'blue'
colors.bg_group_colors['FARFUT'] = 'white'
@skipIf(skip_selenium, skip_message)
class ScheduleEditTests(StaticLiveServerTestCase):
def check_file_txt(self, path):
name = os.path.basename(path)
workdir = tempfile.mkdtemp()
model_name_re = r'^[A-Za-z_][A-Za-z0-9_.-]*(@\d\d\d\d-\d\d-\d\d)?\.yang$'
errors = 0
warnings = 0
message = ""
results = []
passed = True # Used by the submission tool. Yang checks always pass.
model_list = []
extractor = xym.YangModuleExtractor(path, workdir, strict=True, strict_examples=False, debug_level=0)
if not os.path.exists(path):
return None, "%s: No such file or directory: '%s'"%(name.capitalize(), path), errors, warnings, results
with open(path) as file:
out = ""
err = ""
code = 0
try:
# This places the yang models as files in workdir
saved_stdout = sys.stdout
saved_stderr = sys.stderr
sys.stdout = StringIO.StringIO()
sys.stderr = StringIO.StringIO()
extractor.extract_yang_model(file.readlines())
out = sys.stdout.getvalue()
err = sys.stderr.getvalue()
sys.stdout = saved_stdout
sys.stderr = saved_stderr
# signature change in xym:
model_list = extractor.get_extracted_models(False, True)
except Exception as exc:
msg = "Exception when running xym on %s: %s" % (name, exc)
log(msg)
return None, msg, 0, 0, []
if not model_list:
# Found no yang modules, don't deliver any YangChecker result
return None, "", 0, 0, []
for m in model_list:
if not re.search(model_name_re, m):
code += 1
err += "Error: Bad extracted model name: '%s'\n" % m
if len(set(model_list)) != len(model_list):
code += 1
err += "Error: Multiple models with the same name:\n %s\n" % ("\n ".join(model_list))
command = "xym"
cmd_version = VersionInfo.objects.get(command=command).version
message = "%s:\n%s\n\n" % (cmd_version, out.replace('\n\n','\n').strip() if code == 0 else err)
results.append({
"name": name,
"passed": passed,
"message": message,
"warnings": 0,
"errors": code,
"items": [],
})
for model in set(model_list):
path = os.path.join(workdir, model)
message = ""
modpath = ':'.join([
workdir,
settings.SUBMIT_YANG_RFC_MODEL_DIR,
settings.SUBMIT_YANG_DRAFT_MODEL_DIR,
settings.SUBMIT_YANG_INVAL_MODEL_DIR,
])
if os.path.exists(path):
with open(path) as file:
text = file.readlines()
# pyang
cmd_template = settings.SUBMIT_PYANG_COMMAND
command = [ w for w in cmd_template.split() if not '=' in w ][0]
cmd_version = VersionInfo.objects.get(command=command).version
cmd = cmd_template.format(libs=modpath, model=path)
code, out, err = pipe(cmd)
items = []
if code > 0 or len(err.strip()) > 0 :
error_lines = err.splitlines()
for line in error_lines:
if line.strip():
try:
fn, lnum, msg = line.split(':', 2)
lnum = int(lnum)
if fn == model and (lnum-1) in range(len(text)):
line = text[lnum-1].rstrip()
else:
line = None
items.append((lnum, line, msg))
if 'error: ' in msg:
errors += 1
if 'warning: ' in msg:
warnings += 1
except ValueError:
pass
#passed = passed and code == 0 # For the submission tool. Yang checks always pass
message += "%s: %s:\n%s\n" % (cmd_version, cmd_template, out+"No validation errors\n" if (code == 0 and len(err) == 0) else out+err)
# yanglint
if settings.SUBMIT_YANGLINT_COMMAND:
cmd_template = settings.SUBMIT_YANGLINT_COMMAND
command = [ w for w in cmd_template.split() if not '=' in w ][0]
cmd_version = VersionInfo.objects.get(command=command).version
cmd = cmd_template.format(model=path, rfclib=settings.SUBMIT_YANG_RFC_MODEL_DIR, draftlib=settings.SUBMIT_YANG_DRAFT_MODEL_DIR, tmplib=workdir)
code, out, err = pipe(cmd)
if code > 0 or len(err.strip()) > 0:
error_lines = err.splitlines()
for line in error_lines:
if line.strip():
try:
if 'err : ' in line:
errors += 1
if 'warn: ' in line:
warnings += 1
except ValueError:
pass
#passed = passed and code == 0 # For the submission tool. Yang checks always pass
message += "%s: %s:\n%s\n" % (cmd_version, cmd_template, out+"No validation errors\n" if (code == 0 and len(err) == 0) else out+err)
else:
errors += 1
message += "No such file: %s\nPossible mismatch between extracted xym file name and returned module name?\n" % (path)
if errors==0 and warnings==0:
dest = os.path.join(settings.SUBMIT_YANG_DRAFT_MODEL_DIR, model)
shutil.move(path, dest)
else:
dest = os.path.join(settings.SUBMIT_YANG_INVAL_MODEL_DIR, model)
shutil.move(path, dest)
# summary result
results.append({
"name": model,
"passed": passed,
"message": message,
"warnings": warnings,
"errors": errors,
"items": items,
})
shutil.rmtree(workdir)
passed = all( res["passed"] for res in results )
message = "\n".join([ "\n".join([res['name']+':', res["message"]]) for res in results ])
errors = sum(res["errors"] for res in results )
warnings = sum(res["warnings"] for res in results )
items = [ e for res in results for e in res["items"] ]
return passed, message, errors, warnings, items
