def jama_representation(jama_count): if jama_count > 1080: return red('●●●●●●') small = jama_count % 6 big = (jama_count % 30) // 6 gem = (jama_count % 180) // 30 return red('●'* gem) + '◎'* big + 'o' * small
def copmare_2_texts(actual, expected, self): color.green ("actual") print(actual) color.green ("expected") print(expected) actualLines = actual.split('\n') expectedLines = expected.split('\n') color.green("actualLines") print(actualLines) color.green("expectedLines") print(expectedLines) zipped = zip(actualLines, expectedLines) color.green ("zipped") print(zipped) color.green ("compare zipped") color.blue("comparing") for i,j in zipped: color.green (i) color.red (j) self.assertEqual(i.strip(),j.strip())
def test_testName(self): color.blue("test here baby") inputText = """if inlist: print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') color.red('inlist') print(inlist) print('*****************************************************************') currentIndex = allList.index(current) #todo: make test to test when current item not in list chooseNumber = currentIndex + 1 if chooseNumber >= len(allList):""" filename = os.path.join(currentFolder, 'files/printColor.poligon') filer.write(filename, inputText) clear.pyFile(filename) result = filer.read(filename) expected = """if inlist: currentIndex = allList.index(current) #todo: make test to test when current item not in list chooseNumber = currentIndex + 1 if chooseNumber >= len(allList):""" print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') color.red('expected') print(expected) print('*****************************************************************') self.assertEqual(result, expected)
def test_testName(self): color.blue("test here baby") inputText = """ def test_testName(self): color.blue("test here baby") intpuText = beatyModel.py(inputText) def test_testName(self): color.blue("test here baby") intpuText = beatyModel.py(inputText)""" filename = os.path.join(currentFolder, 'files/poligon') filer.write(filename, inputText) expected = """\tdef test_testName(self): color.blue("test here baby") intpuText = beatyModel.py(inputText) def test_testName(self): color.blue("test here baby") intpuText = beatyModel.py(inputText) """ beatyModel.pyFile(filename) result = filer.read(filename) color.red("inputText") print(repr(inputText)) print(inputText) assertMy.stringDiffByLines(result, expected)
def splitArgs(commaStringArgs): commaStringArgs = commaStringArgs.strip() if len(commaStringArgs)==0: return [] else: color.red("commaStringArgs") print(commaStringArgs) ### comma split - split for different args### args = commaStringArgs.split(",") print("args") print(args) varTypeStructureList = [] ### reversing for args like (arg1, arg2 string) - to get first args with type ### argsReversed = reversed(args) for arg in argsReversed: arg = arg.strip() print("arg") print(arg) ### space split - split for arg name and type ### argParts = arg.split(" ") color.red("argParts") print(argParts) ### first - it is var name, second = var type ### thereIsType = len(argParts)==2 if thereIsType: (var, varType) = argParts lastOkType = varType else: var = argParts[0] varType = lastOkType varTypeStructure=generateVarTypeStructure(var, varType) varTypeStructureList.append(varTypeStructure) ### reverse back ### return varTypeStructureList[::-1]
def do(str1, str2): if str1 is None: str1 = "" len1 = len(str1) len2 = len(str2) splited1 = list(str1) splited2 = list(str2) short = splited1 if len1 < len2 else splited2 if len1 != len2: add = range(0,abs(len2-len1)) for i in add: short += "_" zipped = zip(splited1, splited2) colorStr1 = colorStr2 = '' for (i, j) in zipped: iRepr = util.goodRepr(i) jRepr = util.goodRepr(j) if i == j: colorStr1 += color.color(iRepr, 'green') colorStr2 += color.color(jRepr, 'green') else: colorStr1 += color.color(iRepr, 'red') colorStr2 += color.color(jRepr, 'yellow') color.red('diff:') print(colorStr1) print(colorStr2)
def cvsCO(projectName,tagName='',dirName=''): #TODO check is there is CVSROOT variable - if no, ask user #do cvs check out print color.yellow('Checking project from cvs ...') command = 'cvs co ' if(dirName != ''): command = command + '-d ' + dirName if(tagName != ''): command = command + ' -r ' + tagName + ' ' + projectName else: command = command + ' ' + projectName if(debug): print color.blue('Command is: ') print color.blue(command) timeStart = time.time() os.system(command) timeEnd = time.time() print color.yellow('Check out finished, elapsed time [s]: ' + str(timeEnd - timeStart)) #check if check out was OK - look if the directory is created print color.yellow('Now checking consistency...') if(dirName != ''): coDir = dirName else: coDir = projectName if not(os.path.exists(coDir)): print color.red('Directiry ' + coDir + ' does not exist - EXIT!') sys.exit(1) else: print color.green('Check out OK') print return coDir
def test_testName(self): color.blue("test here baby") result = util.goodRepr("\n") print("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++") color.red("result") print(result) print("*****************************************************************")
def check_port_available(self): all_enable = True logger.info('Check status of ports for master...') meta = [['HOST', 'PORT', 'STATUS']] for node in self.master_ip_list: for port in self.master_port_list: result, status = net.is_port_empty(node, port) if not result: all_enable = False meta.append([node, port, color.red(status)]) continue meta.append([node, port, color.green(status)]) table = AsciiTable(meta) print(table.table) if self.slave_ip_list: logger.info('Check status of ports for slave...') meta = [['HOST', 'PORT', 'STATUS']] for node in self.slave_ip_list: for port in self.slave_port_list: result, status = net.is_port_empty(node, port) if not result: all_enable = False meta.append([node, port, color.red(status)]) continue meta.append([node, port, color.green(status)]) table = AsciiTable(meta) print(table.table) return all_enable
def test_named_colors(): for i in color_names: print(getattr(color, i)(i) + color.red('compare')) print( color.black(getattr(color, i + '_bg')(i + '_bg')) + color.red('compare')) print(getattr(color, i + '_hl')(i + '_hl') + color.red('compare'))
def filename2(filename, obj): data = filer.read(filename) color.red("obj") print(repr(obj)) regex = "(\S+) as " + obj color.red("regex") print(repr(regex)) m = re.findall(regex, data) match = len(m) if match: obj = m[0] # folder = os.path.join(os.path.dirname(filename), obj+ '.py') rel2 = "./" + obj filename2 = absRel.AbsAddExtension(filename, rel2) if not os.path.isfile(filename2): regex2 = "sys.path.insert\(0, '(.+)'\)" matches = re.findall(regex2, data) for m in matches: filename2 = os.path.join(m, obj + ".py") if os.path.isfile(filename2): break if not os.path.isfile(filename2): filename2 = filename return filename2
def generateFuncUsageByLineContentGo(lineContent): # get func parts: (caller, method, args, returnParams) = g.getGoFuncDeclarationPartsByLineContent(lineContent) returnParamsSplitedList = g.splitArgs(returnParams) color.red("returnParamsSplitedList") print(returnParamsSplitedList) # split args argsSplitedList = g.splitArgs(args) # get vars commas str (_, varsCommasStr, _) = g.getVarBlockByStructureListOfNameTypeName(argsSplitedList) # get return params comma string (_, returnParamsCommasStr, _) = g.getVarBlockByStructureListOfNameTypeName(returnParamsSplitedList) callerVarName = g.getCallerVarName(caller) funcCall = g.innerTestFuncPartGoTestPrepare_callTestableFunc(callerVarName, method, returnParamsCommasStr, varsCommasStr) # get var block and add before funcCall (varBlock, _, _) = getVarBlock(caller, args, returnParams) # func usage total funcUsageTotal = "/*{}*/\n{}".format(varBlock, funcCall) return funcUsageTotal
def test_testName(self): color.blue("test here baby") inputText = """ def currentFile(self): return os.path.join (self.dataFolder, 'current.data') def testFolder(self): self.dataFolder = "/Users/maks/Library/Application Support/Sublime Text 3/Packages/workflow/testData" """ expected = """ def currentFile(self): return os.path.join (self.dataFolder, 'current.data') def testFolder(self): self.dataFolder = "/Users/maks/Library/Application Support/Sublime Text 3/Packages/workflow/testData" """ result = beatyModel.py(inputText) color.red("inputText") print(repr(inputText)) print(inputText) assertMy.stringDiffByLines(result, expected)
def check_hosts_connection(self, hosts, show_result=False): host_status = [] success_count = 0 for host in hosts: try: client = get_ssh(host) client.close() logger.debug('{} ssh... OK'.format(host)) success_count += 1 host_status.append([host, color.green('OK')]) except HostNameError: host_status.append([host, color.red('UNKNOWN HOST')]) logger.debug('{} gethostbyname... FAIL'.format(host)) except HostConnectionError: host_status.append([host, color.red('CONNECTION FAIL')]) logger.debug('{} connection... FAIL'.format(host)) except SSHConnectionError: host_status.append([host, color.red('SSH FAIL')]) logger.debug('{} ssh... FAIL'.format(host)) if show_result: table = AsciiTable([['HOST', 'STATUS']] + host_status) print(table.table) if len(hosts) != success_count: return False return True
def rsync_fb_conf(): logger.info('Sync conf...') cluster_id = config.get_cur_cluster_id() if not validate_id(cluster_id): logger.warn('Invalid cluster id: {}'.format(cluster_id)) return cluster_list = get_cluster_list() if cluster_id not in cluster_list: logger.warn('Cluster not exist: {}'.format(cluster_id)) return my_address = config.get_local_ip_list() path_of_fb = config.get_path_of_fb(cluster_id) props_path = path_of_fb['redis_properties'] key = 'sr2_redis_master_hosts' nodes = config.get_props(props_path, key, []) meta = [['HOST', 'RESULT']] path_of_fb = config.get_path_of_fb(cluster_id) conf_path = path_of_fb['conf_path'] cluster_path = path_of_fb['cluster_path'] for node in nodes: if net.get_ip(node) in my_address: meta.append([node, color.green('OK')]) continue client = net.get_ssh(node) if not client: meta.append([node, color.red('SSH ERROR')]) continue if not net.is_dir(client, cluster_path): meta.append([node, color.red('NO CLUSTER')]) continue net.copy_dir_to_remote(client, conf_path, conf_path) meta.append([node, color.green('OK')]) utils.print_table(meta)
def test_testName(self): color.blue("test here baby") inputText = """ def dataFile(self): return os.path.join (self.dataFolder, 'iterations.data') def currentFile(self): return os.path.join (self.dataFolder, 'current.data') """ expected = """ def dataFile(self): return os.path.join (self.dataFolder, 'iterations.data') def currentFile(self): return os.path.join (self.dataFolder, 'current.data')""" result = beatyModel.py(inputText) color.red("inputText") print(repr(inputText)) print(inputText) assertMy.stringDiffByLines(result, expected)
def removeAfterModuleExports(fileContent): color.red("fileContent in relativeRequireIced_model.py") print(fileContent) sub = "module.exports" if sub in fileContent: index = fileContent.index(sub) fileContent = fileContent[:index] return fileContent
def test_testName(self): inputText = repr("'") result = util.replaceLastAndFirstQuotes(inputText) print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') color.red('result') print(repr(result)) print('*****************************************************************')
def removeRowsStartingFromSpace(fileContent): # should remove the second and third strings from the following content: # module.exports = (input, test)-> # th.log "input" # th.log input fileContentWithouIntendedRows = re.sub(r"\n\s+.*", "", fileContent) color.red("fileContentWithouIntendedRows in py") print(fileContentWithouIntendedRows) return fileContentWithouIntendedRows
def test_testName(self): clip = """File "/Users/maks/Library/Application Support/Sublime Text 3/Packages/navigateTo/findRequire_test.py", line 17""" result = pyOutPutParse.parse(clip) color.red('result') print(result) self.assertEqual(result, ['/Users/maks/Library/Application Support/Sublime Text 3/Packages/navigateTo/findRequire_test.py:17'])
def run(self, edit): color.red ("duplicate line called") for region in self.view.sel(): if region.empty(): line = self.view.line(region) line_contents = self.view.substr(line) + '\n' self.view.insert(edit, line.begin(), line_contents) else: self.view.insert(edit, region.begin(), self.view.substr(region))
def createFromPosition(filename, position): ### read from file ### text = filer2.read(filename) ### get method name ### methodName = navigateToModel.method(text, position) color.red('methodName') print(repr(methodName)) ### generate test file and write it to disk ### return create(filename, methodName)
def clearEmptyLines(text): regex = '\n*\s*\n+' m = re.findall(regex, text) color.red('m') print(repr(m)) result = re.sub(regex, '\n', text) return result
def test_testName(self): color.blue("test here baby") inputText = """import sublime import sublime_plugin import os from os import listdir from os.path import isfile, join import sys sys.path.insert(0, '/Users/maks/Library/Application Support/Sublime Text 3/Packages/goodPath') import findAllRelative_model class repaire_relative_paths_plugin_Command(sublime_plugin.WindowCommand): def run(self): print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') print("new run repaire_relative_paths_plugin_") print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++') window = self.window view = window.active_view() filename = view.file_name() findAllRelative_model.goAndWrite(filename) sublime.status_message("repaire_relative_paths_plugin done") """ filename = os.path.join(currentFolder, 'files/printColor.poligon') filer.write(filename, inputText) clear.pyFile(filename) result = filer.read(filename) color.red('result') print(repr(result)) expected = """import sublime import sublime_plugin import os from os import listdir from os.path import isfile, join import sys sys.path.insert(0, '/Users/maks/Library/Application Support/Sublime Text 3/Packages/goodPath') import findAllRelative_model class repaire_relative_paths_plugin_Command(sublime_plugin.WindowCommand): def run(self): window = self.window view = window.active_view() filename = view.file_name() findAllRelative_model.goAndWrite(filename) sublime.status_message("repaire_relative_paths_plugin done")""" color.red('expected') print(expected) assertMy.stringDiffByLines(result, expected )
def getDataCardNames(dataCardPath): if not(os.path.isdir(dataCardPath)): print color.red('Data card file ' + dataCardPath + ' does not exist - EXIT!') sys.exit(1) dataCardNames = [] dataCards = os.listdir(dataCardPath) for card in dataCards: if(os.path.isfile(dataCardPath+'/'+card)): dataCardNames.append(card) return dataCardNames
def test_testName(self): color.blue("test here baby") findUsagesModel = FindUsagesModel(os.path.join(currentFolder, 'dataPoligon/')) findUsagesModel.i.currentSet(('/path/to/first.py', 1)) result = findUsagesModel.next() color.red('result') print(repr(result)) expected = ('/path/to/second.py', 2, '2 of 3') assertMy.equals(result, expected)
def findRequire(text, objectName): regex = "{} =.+'(.+)'".format(objectName) color.red('regex') print(repr(regex)) result = re.findall(regex, text) if len(result): return result[0] else: return None
def test_testName(self): color.blue("test here baby") inputText = repr('\n') result = util.replaceLastAndFirstQuotes(inputText) color.red('inputText') print(inputText) color.red('result') print(result)
def writeTestFileBySourceFileTargetAndPosition(targetFileName, position): ### read target file name ### targetFileContent = filer2.read(targetFileName) ### generate test file content by targetFileContent and position ### testFileContent = createTestFileContentBySourceFileTargetAndPosition(targetFileContent, position) color.red("testFileContent") print(testFileContent) methodName = getMethodNameByFileContentAndPosition(targetFileContent, position) return create(targetFileName, methodName, testFileContent)
def test_testName(self): color.blue("test here baby") filename = os.path.abspath(os.path.join(currentFolder, '../../util/filer2.py')) position = 131 findUsagesModel = FindUsagesModel(os.path.join(currentFolder, 'dataPoligon2/')) result = findUsagesModel.find(filename, position) color.red('result') print(repr(result)) expected = (os.path.abspath(os.path.join(currentFolder, '../../util/replace_require_test.py')), 1194, "2 of 2") self.assertEquals(result, expected)
def coffeeCompile(filename): bashCommand = 'coffee -cb "{}"'.format(filename) color.red("bashCommand") print(bashCommand) # process = subprocess.Popen(bashCommand, stdout=subprocess.PIPE) # output = process.communicate()[0] # import subprocess # subprocess.Popen(bashCommand) bash.run_script(bashCommand)
def getArgsByLineContentGo(lineContent): color.red("lineContent") print(lineContent) regex = re.compile(r"\S\(([^\(]+)\)") m = regex.findall(lineContent) if m: lastGroup = m[-1] result = lastGroup return result else: return ""
def getReturnParamsForAutocbCommaSeparated(fileContent): # cb arg1, arg2 fileContent = fileContent.strip() m = re.findall(r"cb (.+)", fileContent) if m: commaSeparatedArgs = m[-1] color.red("commaSeparatedArgs") print(commaSeparatedArgs) return replaceNullByErr(commaSeparatedArgs) else: return "()" # no params for func: (cb)->
def returnParamsForSyncExpressionOrReturn(targetFileContent): returnParams = justArgsForSync(targetFileContent) color.red ("returnParams") print (returnParams) if returnParams == 'actual': returnParamsExpression = returnArgsByExpressionWithoutWordReturn(targetFileContent) color.red("returnParamsExpression") print(returnParamsExpression) if not returnParamsExpression == "exports": # exception returnParams = returnParamsExpression return returnParams
def get_search_results(pkt): ''' Parse through packets that match tshark filter for search ''' global found, foundunenc, searchterm # Searches are case insensitive pcre = re.compile('(?i)' + searchterm) print( color.green( color.bright('Found match in %s packet [%d] (%s):' % (pcapfile, int(pkt.number), pkt.highest_layer)))) found = True foundunenc = True for layer in pkt.layers: for field_line in layer._get_all_field_lines(): if pcre.search(field_line): print('%s: %s' % (layer.layer_name, field_line.rstrip())) print( color.bright( color.red('%s found in unencrypted %s traffic!' % (searchterm, pkt.highest_layer)))) if args.verbose: print('----- Full packet dump begin -----') print(pkt) print('----- Full packet dump end -------')
def main(): parser = argparse.ArgumentParser( description= 'Verify SSL certificate validation for one or more tested application') parser.add_argument('app_or_capture', metavar='appname', nargs='?', help='Application name or network capture file') args = parser.parse_args() app = args.app_or_capture if args.app_or_capture: check_app(app) else: for entry in os.listdir('results'): if os.path.isdir(os.path.join('results', entry)): app = entry check_app(app) eprint('') eprint(color.bright('SSL test summary:')) eprint(color.bright(color.red(('Failed:')))) for app in ssl_failed: eprint(app) if ssl_notest: eprint(color.bright('Not tested:')) for app in ssl_notest: eprint(app) eprint(color.bright(color.green(('Passed:')))) for app in ssl_passed: eprint(app)
def getLabObject(labdb): ''' Used to generate a pjl lab object from the labDB.xml database Args: labdb (pjlDB.labDB) entire lab database object generated by pjlDB Return: lab (pjlDB._LabItem) individual lab item generated by pjlDB ''' if debug: print(color.green("[Debug - getLabObject] entering")) validID = False while not validID: idnum = input(color.yellow("Enter lab ID number: ")) if len(idnum) == 4 and idnum.isdigit() == True: try: lab = labdb.getLab(idnum) validID = True except pjlDB.IDDoesNotExist: ### not working properly print("Message") else: print( color.red("[ERROR] ") + "ID formate in not valid. Valid IDs are of the form ####. Please try again" ) validID = False if debug: print(color.green("[Debug - getLabObject] leaving")) return lab
def check_app(app): failedssltest = False badrequests = [] # Get mitmproxy log file location if app.endswith('.log'): flowfile = app jsonfile = '%s.%s' % (flowfile, json_output) if os.path.exists(flowfile): sys.stdout = Logger('%s.%s' % (flowfile, report_output)) else: flowfile = os.path.join('results', app, 'ssltest.log') jsonfile = os.path.join(os.path.dirname(flowfile), json_output) if os.path.exists(flowfile): sys.stdout = Logger(os.path.join('results', app, report_output)) if os.path.exists(flowfile): badsslmsgs = [] with open(flowfile, "rb") as logfile: freader = io.FlowReader(logfile) pp = pprint.PrettyPrinter(indent=4) try: for msg in freader.stream(): scheme = msg.request.scheme if scheme == 'https': failedssltest = True badsslmsgs.append(msg) if failedssltest: ssl_failed.append(app) print( color.bright( '%s fails to validate SSL certificates properly' % app)) print('Offending URIs accessed:') for msg in badsslmsgs: method = msg.request.method uri = msg.request.pretty_url request = '%s %s' % (method, uri) badrequests.append(request) request = color.bright(color.red((request))) print(request) else: print('No HTTPS traffic detected for app %s' % app) ssl_passed.append(app) except FlowReadException as e: print("Flow file corrupted: {}".format(e)) report = {} report['app'] = app report['testtime'] = os.path.getmtime(flowfile) report['failedtest'] = failedssltest report['ssl_failed'] = badrequests with open(jsonfile, 'w') as fp: json.dump(report, fp) else: ssl_notest.append(app)
def diff(n1, n2): if n2 is None: return color.cyan(' %9f') % n1 if n1 > n2: return color.blue('+%9f') % (n1) elif n1 < n2: return color.red('-%9f') % (n1) else: return color.yellow(' %9f') % n1
def set_document(project, document_name): # DOC need be created before running the script try: document = Document(project, document_name, None, None, None) except PylarionLibException: print( red("Error: Can't not open \"KernelNetworkQE/KN-TC Kernel NIC Driver New Test Cases\" " "to move new case into it.\n Please create it in polarion.\n")) raise else: return document
def render(self): clear() print(gray("( To exit, hit Ctrl + C )\n\n")) count = "(" + str(len( self.used_incorrect_letters)) + "/" + str(CHANCES) + ")" if (CHANCES - len(self.used_incorrect_letters) < 3): count = red(count) else: count = gray(count) render_noose(len(self.used_incorrect_letters)) print("Used " + count + ": " + " ".join(self.used_incorrect_letters)) print(self.make_word_bar()) print(self.make_message_box())
def get_case_id(case_title_prefix, case_name, topo, document, project, dryrun): """get or create case_id""" case_name = case_name.replace("/kernel/networking/", "") try: if topo == "": case_list = get_case_id_by_sql(case_title_prefix, case_name, topo, project) else: tmp1 = get_case_id_by_sql(case_title_prefix, case_name, "TOPO=%s" % topo, project) tmp2 = get_case_id_by_sql(case_title_prefix, case_name, "FUNC=%s" % topo, project) case_list = tmp1 + tmp2 except WebFault: # retry time.sleep(3) return get_case_id(case_title_prefix, case_name, topo, document, project, dryrun) except PylarionLibException: # retry time.sleep(3) return get_case_id(case_title_prefix, case_name, topo, document, project, dryrun) if len(case_list) == 1: logger.debug("There is only one %s" % case_list[0].work_item_id) return case_list[0].work_item_id elif len(case_list) == 0: logger.warning("Can't find right case-NAME: {}, TOPO: {}".format( case_name, topo)) if not dryrun: try: # logger.info("%s can't be found" % case_name) return create_new_case(case_title_prefix, case_name, topo, document, project) except: logger.error("Can't create new test case automatically.") raise else: # 找到多个,通过“TOPO=” 或者“--FUNC=”过滤case logger.error("Find more than one case. \"{}\", \"{}\".".format( case_name, topo)) print( red("Find more than one case. \"{}\", \"{}\".".format( case_name, topo))) with open("fail.csv", "a") as fcsv: fcsv.write("Error: Find more than one case-----\n") fcsv.write(time.ctime() + "\n") fcsv.write("{},{}\n".format(case_name, topo)) return None
def testHost(host): ''' Test what computer this being run on. As of now it is machinne specific Args: host (str) name of host script was designed for Return: none ''' thishost = os.uname()[1] if thishost not in host: print( color.red("[ERROR] ") + "This script is designed to be run on " + host + " only. Exiting...") exit()
def report(worklog, config): lines = [] total = timedelta(seconds=0) rollup = dict() lines.append('{} {}'.format( color.bold('Worklog Report for'), color.purple(worklog.when.strftime('%F'), bold=True))) if len(worklog) == 0: lines.append(' no entries') else: for task, next_task in worklog.pairwise(): if isinstance(task, GoHome): continue if isinstance(next_task, DummyRightNow): colorize_end_time = color.yellow else: colorize_end_time = color.green delta = next_task.start - task.start if task.include_in_rollup(): total += delta if task.description not in rollup: rollup[task.description] = delta else: rollup[task.description] += delta if delta > timedelta(): if not task.logged: task.logged = False lines.append(' {:5s} {} {:5s} {}{!s:>7}{} {} {} {}'.format( color.green(task.start.strftime('%H:%M')), color.black('-', intense=True), colorize_end_time(next_task.start.strftime('%H:%M')), color.black('(', intense=True), Duration(delta).colorized(), color.black(')', intense=True), { True: color.green('*'), False: color.red('*') }[task.logged], task.ticket, task.description)) lines.append('\n {!s:>7} {}'.format( Duration(total).colorized(underline=True), color.colorize('TOTAL', bold=True, underline=True))) for key in sorted(rollup.keys()): lines.append(' {!s:>7} {}'.format( Duration(rollup[key]).colorized(), color.bold(key))) print('\n'.join(lines))
def addSupportFolder(info, root): ''' adds contents of Support_Docs folder to repository Args: info (dict) information about new lab object Return: none ''' originDir = info["originalDir"] + "Support_Docs" destinationDir = root + info["labFolder"] + "/Support_Docs" if os.path.isdir(originDir): if not os.path.isdir(destinationDir): print("Support_Docs Folder does not exist. Adding new folder " + destinationDir) os.system("mkdir " + destinationDir) if os.path.isdir(destinationDir): os.system("rsync -avz " + originDir + "/ " + destinationDir) else: print(color.red("Something when wrong. Exiting...")) exit()
def post_runs(run_ids, case_ids, case_results, case_comments, run_path, project, login, run_plannedin, dryrun): """posting function which doesn't consider the role of case, compared with post_runs_filter_by_role """ for index, (case_id, run_id, result, comment) in enumerate( zip(case_ids, run_ids, case_results, case_comments)): if "%s.xml" % run_id in os.listdir(run_path): tr = open("{}/{}.xml".format(run_path, run_id), 'a') else: tr = open("{}/{}.xml".format(run_path, run_id), 'a') tr.write( xml_testrun_init.format(project, login, login, run_plannedin, "true", dryrun, run_id, "featureverification")) if case_id is not None and result == "passed": tr.write(xml_testcase_passed.format(case_id)) elif case_id is not None and result == "failed": tr.write(xml_testcase_failed.format(case_id)) else: print(red("%s is None" % case_id)) tr.close() for file_name in os.listdir(run_path): if file_name.endswith(".xml"): with open("{}/{}".format(run_path, file_name), 'a') as tr: tr.write(xml_testrun_end)
from keras.layers import LSTM from keras.layers import Input from keras.layers import Dense from keras.layers import Dropout import matplotlib.pyplot as plt from prepare import prepare import color data, target = prepare('./data/XRP_usdt_xrp_1.csv', './data/XRP_usdt_btc_1.csv', './data/XRP_btc_xrp_1.csv') data = np.array(data, dtype=float) print(color.red(data.shape)) target = np.array(target, dtype=float) print(color.red(target.shape)) # model = Sequential() # model.add(LSTM(60, return_sequences=True, batch_input_shape=(None, len(data[0]), 6))) # model.add(Dropout(0.35)) # model.add(LSTM(100, return_sequences=False)) # model.add(Dropout(0.35)) # model.add(Dense(1)) # # mean_squared_error, mean_squared_error # model.compile(loss='mse', optimizer='rmsprop', metrics=['accuracy']) # model.summary()
def test_notty(): """ Run `nosetests -vs test/notty_test.py | less` to see red is not red """ color.use_color_no_tty(False) print color.red('red')
import color print(color.blue('-=' * 20)) print(color.green('CALCULADORA DE HEXADECIMAL - OCTAL - BINÁRIO')) print(color.blue('-=' * 20)) num = int(input('Digitite um número qualquer que seja inteiro: ')) print(color.blue('-=' * 20)) print(color.yellow('[1] HEXADECIMAL ')) print(color.red('[2] OCTAL')) print(color.green('[3] BINÁRIO')) print(color.blue('-=' * 20)) opcao = int(input('Escolha uma das opções: ')) print(color.blue('-=' * 20)) if opcao == 1: print( color.yellow(' O numero {} convertido para HEXADECIMAL É {}'.format( num, hex(num)[2:]))) elif opcao == 2: print( color.red('O numero {} convertido para OCTAL é {}'.format( num, oct(num)[2:]))) elif opcao == 3: print( color.green('O numero {} convertido para BINÁRIO é {}'.format( num, bin(num)[2:]))) else: print('\033[2;30;41mOPÇÃO INVALIDA\033[m') print(color.blue('-=' * 20))
def error(msg, indent=0): log(indentString(color.red('ERROR: ' + msg), indent))
def generate_report(app, pcapfile=''): ''' Print report based on collected data ''' global sslpacketcount if app.endswith('.pcap'): app_or_pcap = 'pcap' jsonfile = '%s.%s' % (pcapfile, json_output) else: app_or_pcap = 'application' jsonfile = os.path.join(os.path.dirname(pcapfile), json_output) report = {} report['app'] = app report['testtime'] = os.path.getmtime(pcapfile) report['sslversions'] = net.sslversions report['requestedciphers'] = net.requestedciphers report['negotiatedciphers'] = net.negotiatedciphers report['dtlsversions'] = net.dtlsversions report['negotiateddtlsciphers'] = net.negotiateddtlsciphers seen_mandatory_ciphers = [] seen_optional_ciphers = [] seen_other_ciphers = [] failedtest = False failedreasons = [] print('') print('Summary for application: %s' % color.bright(color.cyan(app))) print('') if net.sslpacketcount > 0: print(color.bright('TLS/SSL protocols used:')) # For each target (unsorted) for sslversion in net.sslversions: if sslversion == 'TLS 1.2': sslversion = color.bright(color.green(sslversion)) else: failedtest = True failedreasons.append('%s is used, rather than TLS 1.2' % sslversion) sslversion = color.bright(color.red(sslversion)) print(sslversion) print( color.bright('Hosts using %s:' % color.decolorize(sslversion))) for host in net.sslversions[color.decolorize(sslversion)]: print(host) print('') for ciphersuite in net.requestedciphers: if ciphersuite in net.mandatory_ciphers: #ciphersuite = color.bright(color.green(ciphersuite)) seen_mandatory_ciphers.append(ciphersuite) elif ciphersuite in net.optional_ciphers: #ciphersuite = color.bright(ciphersuite) seen_optional_ciphers.append(ciphersuite) else: #ciphersuite = color.dim(ciphersuite) seen_other_ciphers.append(ciphersuite) if len(seen_mandatory_ciphers) == 0: failedtest = True failedreasons.append('%s is not supported by client' % net.mandatory_ciphers[0]) print( color.bright( 'Observed mandatory ciphers in TLS/SSL client requests:')) for cipher in seen_mandatory_ciphers: print(color.bright(color.green(cipher))) report['seen_mandatory_ciphers'] = seen_mandatory_ciphers print('') print( color.bright( 'Observed optional ciphers in TLS/SSL client requests:')) for cipher in seen_optional_ciphers: print(cipher) report['seen_optional_ciphers'] = seen_optional_ciphers print('') print( color.bright('Observed other ciphers in TLS/SSL client requests:')) for cipher in seen_other_ciphers: print(color.dim(cipher)) report['seen_other_ciphers'] = seen_other_ciphers print('') print(color.bright('Negotiated TLS/SSL ciphers:')) for ciphersuite in net.negotiatedciphers: if ciphersuite in net.mandatory_ciphers: ciphersuite = color.bright(color.green(ciphersuite)) elif ciphersuite in net.optional_ciphers: pass #ciphersuite = color.bright(ciphersuite) else: ciphersuite = color.dim(ciphersuite) print(ciphersuite) print( color.bright('Hosts using %s:' % color.decolorize(ciphersuite))) for host in net.negotiatedciphers[color.decolorize(ciphersuite)]: print(host) print('') print('') else: print(color.bright(color.green('No TLS/SSL traffic seen'))) print('') if net.dtlspacketcount > 0: print(color.bright('DTLS protocols used:')) # For each target (unsorted) for dtlsversion in net.dtlsversions: if dtlsversion == 'DTLS 1.2': dtlsversion = color.bright(color.green(dtlsversion)) else: failedtest = True failedreasons.append('%s is used, rather than DTLS 1.2' % dtlsversion) dtlsversion = color.bright(color.red(dtlsversion)) print(dtlsversion) print( color.bright('Hosts using %s:' % color.decolorize(dtlsversion))) for host in net.dtlsversions[color.decolorize(dtlsversion)]: print(host) print('') report['dtlsciphers'] = net.requesteddtlsciphers for ciphersuite in net.requesteddtlsciphers: if ciphersuite in net.mandatory_ciphers: #ciphersuite = color.bright(color.green(ciphersuite)) seen_mandatory_ciphers.append(ciphersuite) elif ciphersuite in net.optional_ciphers: #ciphersuite = color.bright(ciphersuite) seen_optional_ciphers.append(ciphersuite) else: #ciphersuite = color.dim(ciphersuite) seen_other_ciphers.append(ciphersuite) if len(seen_mandatory_ciphers) == 0: failedtest = True failedreasons.append('%s is not supported by client' % net.mandatory_ciphers[0]) print( color.bright( 'Observed mandatory ciphers in DTLS client requests:')) for cipher in seen_mandatory_ciphers: print(color.bright(color.green(cipher))) print('') report['seen_mandatory_dtls_ciphers'] = seen_mandatory_ciphers print( color.bright('Observed optional ciphers in DTLS client requests:')) for cipher in seen_optional_ciphers: print(cipher) print('') report['seen_optional_dtls_ciphers'] = seen_optional_ciphers print(color.bright('Observed other ciphers in DTLS client requests:')) for cipher in seen_other_ciphers: print(color.dim(cipher)) print('') report['seen_other_dtls_ciphers'] = seen_other_ciphers print(color.bright('Negotiated DTLS ciphers:')) for ciphersuite in net.negotiateddtlsciphers: if ciphersuite in net.mandatory_ciphers: ciphersuite = color.bright(color.green(ciphersuite)) elif ciphersuite in net.optional_ciphers: pass #ciphersuite = color.bright(ciphersuite) else: ciphersuite = color.dim(ciphersuite) print(ciphersuite) print( color.bright('Hosts using %s:' % color.decolorize(ciphersuite))) for host in net.negotiateddtlsciphers[color.decolorize( ciphersuite)]: print(host) print('') print('') else: print(color.bright(color.green('No DTLS traffic seen'))) report['failedtest'] = failedtest report['failedreasons'] = failedreasons if failedtest: print( color.bright( color.red('App %s failed crypto checking because:' % app))) for reason in failedreasons: print(color.bright(color.red(reason))) else: print(color.bright(color.green('App %s passed crypto checking' % app))) # print(report) with open(jsonfile, 'w') as fp: json.dump(report, fp)
def test_decorations(): for i in ['bold', 'italic', 'underline', 'strike', 'blink']: print '#' + i for j in color_names: c = getattr(color, j)(j) print getattr(color, i)(c) + color.red('compare')
def visual(self): if self.colornum == 0: color.gold() elif self.colornum == 1: color.red() glutSolidTeapot(1)
def get_dtls_info(pkt): global dtlspacketcount, dtlsversions, negotiateddtlsciphers try: dtlspkt = pkt.dtls dtlspacketcount = dtlspacketcount + 1 handshake = dtlspkt.handshake if handshake == 'Handshake Protocol: Client Hello': dtlshost = get_host_contacted(pkt) # print(pkt) maxdtlsversion = 0 ciphersuitelist = [] destination_host = get_host_contacted(pkt) for field_line in dtlspkt._get_all_field_lines(): if field_line.startswith('\tVersion: '): intdtlsversion = extract_intval(field_line) if intdtlsversion > maxdtlsversion: # Newer DTLS version than we've seen so far maxdtlsversion = intdtlsversion dtlsversion = extract_property( field_line, 'Version') if field_line.startswith('\tCipher Suite: '): ciphersuite = extract_property( field_line, 'Cipher Suite') if ciphersuite not in requesteddtlsciphers: requesteddtlsciphers.append(ciphersuite) if ciphersuite in mandatory_ciphers: ciphersuite = color.bright( color.green(ciphersuite)) elif ciphersuite in optional_ciphers: ciphersuite = color.bright(ciphersuite) ciphersuitelist.append(ciphersuite) # print('%s: %s' % # (color.bright('Cipher suite'), ciphersuite)) # Add host to list of hosts contacted per DTLS version dtlsversions = addonlynew( dtlsversions, dtlsversion, dtlshost) if str(dtlsversion) == 'DTLS 1.2': dtlsversion = color.green(dtlsversion) else: dtlsversion = color.red(dtlsversion) if args.verbose: print('Client request handshake with %s: %s' % (destination_host, color.bright(dtlsversion))) for ciphersuite in ciphersuitelist: if args.verbose: print('%s: %s' % ('Client-supported cipher suite', ciphersuite)) elif handshake == 'Handshake Protocol: Server Hello': dtlshost = get_source_host(pkt) #print('Server hello!') negotiated_ciphersuite = pkt.dtls.handshake_ciphersuite.showname negotiated_ciphersuite = extract_notab_property( negotiated_ciphersuite, 'Cipher Suite') # print('*** Negotiated DTLS ciphersuite: %s' % # negotiated_ciphersuite) # if negotiated_ciphersuite not in negotiateddtlsciphers: # negotiateddtlsciphers.append(negotiated_ciphersuite) negotiateddtlsciphers = addonlynew( negotiateddtlsciphers, negotiated_ciphersuite, dtlshost) if args.verbose: print('Negotiated ciphersuite with %s: %s' % (dtlshost, color.bright(negotiated_ciphersuite))) print('***********') except AttributeError: pass
'size': 0, 'long': '0', 'short': '0' } # Check for valid url try: r = requests.get(url) print(color.magenta('STARTING SERVER BENCHMARKING')) print(color.magenta('URL:\t\t', url)) print(color.magenta('Clients:\t', clients)) print(color.magenta('Requests:\t', max_hits, '\n')) time.sleep(1) except: print(color.red('Bad url, stopping')) sys.exit(1) print(color.yellow('** Cattle of Geryon 2.0')) print(color.yellow('** Preparing 1 concurrent users for battle.')) print(color.yellow('The server is now under siege...')) # Start benchmark i = 0 while i < clients: hits = 0 while hits < max_hits: r = requests.get(url) # Status of request status = r.status_code
def get_ssl_info(pkt): global sslpacketcount, sslversions, negotiatedciphers try: # Assume SSLv3 or TLS sslpkt = pkt.ssl sslpacketcount = sslpacketcount + 1 handshake = sslpkt.handshake if handshake == 'Handshake Protocol: Client Hello': # print(pkt) maxsslversion = 0 ciphersuitelist = [] sslhost = get_host_contacted(pkt) for field_line in sslpkt._get_all_field_lines(): if field_line.startswith('\tVersion: '): intsslversion = extract_intval(field_line) if intsslversion > maxsslversion: # Newer SSL/TLS version than we've seen so far maxsslversion = intsslversion sslversion = extract_property( field_line, 'Version') if field_line.startswith('\tCipher Suite: '): ciphersuite = extract_property( field_line, 'Cipher Suite') if ciphersuite not in requestedciphers: requestedciphers.append(ciphersuite) if ciphersuite in mandatory_ciphers: ciphersuite = color.bright( color.green(ciphersuite)) elif ciphersuite in optional_ciphers: ciphersuite = color.bright(ciphersuite) ciphersuitelist.append(ciphersuite) # print('%s: %s' % # (color.bright('Cipher suite'), ciphersuite)) # Add host to list of hosts contacted per SSL version sslversions = addonlynew( sslversions, sslversion, sslhost) if str(sslversion) == 'TLS 1.2': sslversion = color.green(sslversion) else: sslversion = color.red(sslversion) if args.verbose: print('Client request handshake with %s: %s' % (sslhost, color.bright(sslversion))) for ciphersuite in ciphersuitelist: if args.verbose: print('%s: %s' % ('Client-supported cipher suite', ciphersuite)) elif handshake == 'Handshake Protocol: Server Hello': sslhost = get_source_host(pkt) #print('Server hello!') negotiated_ciphersuite = pkt.ssl.handshake_ciphersuite.showname negotiated_ciphersuite = extract_notab_property( negotiated_ciphersuite, 'Cipher Suite') # print('*** Negotiated SSL/TLS ciphersuite: %s' % # negotiated_ciphersuite) # if negotiated_ciphersuite not in negotiatedciphers: # negotiatedciphers.append(negotiated_ciphersuite) negotiatedciphers = addonlynew( negotiatedciphers, negotiated_ciphersuite, sslhost) if args.verbose: print('Negotiated ciphersuite with %s: %s' % (sslhost, color.bright(negotiated_ciphersuite))) print('***********') except AttributeError: # SSLv2 doesn't have "handshake" structure try: sslpkt = pkt.ssl sslhost = get_host_contacted(pkt) if sslpkt.record == 'SSLv2 Record Layer: Client Hello': sslversion = 'SSLv2' if sslversion not in sslversions: sslversions.append(str(sslversion)) destination_host = get_host_contacted(pkt) if args.verbose: print('Client request handshake with %s: %s' % (destination_host, color.bright(color.red('SSLv2')))) for field_line in sslpkt._get_all_field_lines(): if field_line.startswith('\tCipher Spec: '): ciphersuite = extract_property( field_line, 'Cipher Spec') if ciphersuite not in requestedciphers: requestedciphers.append(ciphersuite) if ciphersuite in mandatory_ciphers: ciphersuite = color.bright( color.green(ciphersuite)) elif ciphersuite in optional_ciphers: ciphersuite = color.bright(ciphersuite) if args.verbose: print('%s: %s' % ('Client-supported cipher spec', ciphersuite)) elif sslpkt.record == 'SSLv2 Record Layer: Server Hello': negotiated_cipherspec = pkt.ssl.handshake_cipherspec.showname negotiated_cipherspec = extract_notab_property( negotiated_cipherspec, 'Cipher Spec') if negotiated_cipherspec not in negotiatedciphers: negotiatedciphers.append(negotiated_cipherspec) if negotiated_cipherspec not in optional_ciphers and negotiated_cipherspec not in mandatory_ciphers: negotiated_cipherspec = color.red( negotiated_cipherspec) destination_host = get_source_host(pkt) if args.verbose: print('Negotiated cipherspec with %s: %s' % (destination_host, color.bright(negotiated_cipherspec))) print('***********') except AttributeError: pass
def main(argv): logger = Logger(__file__) # initial parameters dryrun = False document_name = 'KernelNetworkQE/KN-Pylarion' case_title_prefix = 'KN-TC New-Test case Pylarion' run_xml_path = './testruns' try: opts, args = getopt(argv[1:], "hu:d:s:f:p:i:t:n", [ "user="******"password="******"doc=", "sheet=", "file=", "project=", "plannedin=", "title=", "dryrun" ]) except: usage() exit(-1) else: for opt, arg in opts: if opt == '-h': usage() exit(-1) elif opt in ("-u", "--user"): user = arg elif opt in ("--password", ): password = arg elif opt in ("-d", "--doc"): doc = arg elif opt in ("-s", "--sheet"): sheet = arg run_xml_path = './%s' % sheet elif opt in ("-f", "--file"): csv_file = arg elif opt in ("-p", "--project"): project = arg elif opt in ("-i", "--plannedin"): run_plannedin = arg elif opt in ("-t", "--title"): run_id_prefix = arg elif opt in ("-n", "--dryrun"): dryrun = True if "project" not in locals() or "run_plannedin" not in locals( ) or project == "" or run_plannedin == "": usage() exit(-1) if "password" not in locals(): password = authentication() if password is None: print( red("Configuration File of Pylarion Can\'t Be Found, Please Input Your Kerberos Password" )) password = raw_input() if doc != '' and sheet != '': ws = WorkSheet(doc, sheet) cases = ws.cases if ws.check_cases() is False: logger.error('Missing Cols') exit(-1) elif csv_file != '': cases = [] with open(csv_file, 'r') as fcsv: for row in csv.reader(fcsv): cases.append(row) else: usage() exit(-1) logger.info('Start time: %s' % time.ctime()) print(blue('Start time: %s' % time.ctime())) document = set_document(project, document_name) logger.info('filter_useless_cases') print(blue('filter_useless_cases')) cases = cases_filter(cases) logger.info('get_cases_ids') print(blue('get_cases_ids')) cases_ids = get_cases_ids(cases, case_title_prefix, document, project, dryrun) if dryrun: for index, (case, case_id) in enumerate(zip(cases, cases_ids)): print('the %s-th case: %s' % (index, case)) print('the %s-th case_id: %s' % (index, case_id)) logger.info('Ending time: %s' % time.ctime()) print(blue('Ending time: %s' % time.ctime())) return None logger.info('get_cases_results_and_comments') print(blue('get_cases_results_and_comments')) cases_results = get_cases_results(cases) cases_comments = get_cases_comments(cases) logger.info('rm -rf %s' % run_xml_path) print(blue('rm -rf %s' % run_xml_path)) clear_path(run_xml_path) logger.info('Updating %s' % run_xml_path) print(blue('Updating %s' % run_xml_path)) runs_ids = gen_runs_ids_for_cases(cases, run_id_prefix) # post_runs(runs_ids, cases_ids, cases_results, cases_comments, run_xml_path, project, user, run_plannedin, dryrun) post_runs_filter_by_role(runs_ids, cases_ids, cases_results, cases_comments, run_xml_path, project, user, run_plannedin, dryrun) logger.info('Post %s' % run_xml_path) print(blue('Post %s' % run_xml_path)) post(user, password, run_xml_path) logger.info('Ending time: %s' % time.ctime()) print(blue('Ending time: %s' % time.ctime()))
def error(word): Log._print("[-] %s\n" % color.red(word))
def context(context): Log._print("%s" % (color.red(context)))
def evaluate_solutions(results): ''' Evaluates the solutions returned by TS Parameters ---------- results : list A list with the results of the TS. This list is a list of dicts under the following form: { 'time': float, # The time wasted in the search 'best': list # The best solution found in the search, 'total_i': int, # The number of the final iteration 'i_best': int, # The iteration where the best solution was found 'fault': list, # The list with the faulted lines 'i_local': int, # The parameter of the max local search 'itm': int, # The parameter of the max iteration to reset the TS 'max_i': int, # The parameter of the max iteration set in the TS } Raises ------ Exception In case the solution don't match any supported network model. ''' for i, res in enumerate(results): print(color.blue('\nSEARCH #%d ------------' % i)) validation = ev.validate(res['best']) if validation: if len(res['best']) == len(default_topologies['10-bus']): default = default_topologies['10-bus'].copy() elif len(res['best']) == len(default_topologies['16-bus']): default = default_topologies['16-bus'].copy() elif len(res['best']) == len(default_topologies['33-bus']): default = default_topologies['33-bus'].copy() elif len(res['best']) == len(default_topologies['119-bus']): default = default_topologies['119-bus'].copy() else: raise (Exception('No such model to this solution.')) faulted = default.copy() for f in res['fault']: faulted[f] = 0 value = ev.value(res['best']) zeros = list() for j, element in enumerate(default): if element == 0: zeros.append(j) ones = list() for j, element in enumerate(default): if element == 1: ones.append(j) opened_switches = list() for j, element in enumerate(res['best']): if element == 0 and j not in zeros: opened_switches.append(j) closed_switches = list() for j, element in enumerate(res['best']): if element == 1 and j not in ones: closed_switches.append(j) print(color.green('VALIDATION: %s' % validation, 'b')) print('VALUE:', value) print('NAB:', len(ev.unsupplied_buses(faulted))) print( 'NRB:', value - (ev.value(default) - len(ev.unsupplied_buses(faulted)))) print('OPENED SW:', opened_switches) print('CLOSED SW:', closed_switches) print('TIME:', res['time']) else: print(color.red('VALIDATION: %s' % validation, 'b'))