def identify_pattern(self, node): print_writeofd("Pattern identified", self.ofd) self.identifed = True # Now check to see if this API pattern is defined in a function while isinstance(node.parent, ast.Module) == False: if isinstance(node.parent, ast.FunctionDef): print_writeofd("Note: The API call is defined in function: {}".format(node.parent.name), self.ofd) self.fct.append((node.parent.name, self.url, [])) break node = node.parent
def search_multi(self): self.all_fct_name = list2treelist(self.all_fct_name) start = datetime.now().time() end = datetime.now().time() time_elapsed = (datetime.combine(date.min, end) - datetime.combine(date.min, start)).total_seconds() # If a particular project takes more than 20 minutes, flag it and move on while self._round < MAXIMUM_SEARCH_ROUND: end = datetime.now().time() time_elapsed = (datetime.combine(date.min, end) - datetime.combine(date.min, start)).total_seconds() self.retrieve_and_search() self._round += 1 if time_elapsed > 20 * 60: print_writeofd( "This project took more than 20 minutes, jumping over for now", self.ofd) break # Print tree searched: print_writeofd("***", self.ofd) print_counter = 1 for elements in self.all_fct_name: print_writeofd("Tree Number {}".format(print_counter), self.ofd) render_beautify_tree_1(elements, self.ofd) print_counter += 1 print_writeofd("***", self.ofd)
def add_backward_links(content): try: p = ast.parse(content) except SyntaxError: try: content = use_2to3(content) p = ast.parse(content) except Exception as e: print_writeofd("EXCEPTION OCCURS: {}".format(e), ofd) return None except Exception as e: print_writeofd("EXCEPTION OCCURS: {}".format(e), ofd) return None # Traverse the tree to add links from child to parent, making it a doubly-linked tree for node in ast.walk(p): for child in ast.iter_child_nodes(node): child.parent = node return p
def check_recursion(self, node): while isinstance(node.parent, ast.Module) == False: if isinstance(node.parent, ast.FunctionDef): break_status = True for arguments in node.parent.args.args: if arguments.arg not in ["event", "context"]: break_status = False break if break_status: print_writeofd( "Function ({}, {}) is a lambda function".format( node.parent.name, slice_url(self.url_inspect)), self.ofd) self.traced_lambda = True inspect_tuple = (node.parent.name, self.url_inspect) if node.parent.name in NEGLECT_FUNCTION_NAME: print_writeofd( "The function call [{}] is defined in function [{}], NEGLECTED" .format(self.fct_inspect, node.parent.name), self.ofd) break # This case below is also ruled out because such tracing will make the graph very complicated and difficult to understand elif node.parent.name == self.fct_inspect: print_writeofd( "The function call [{}] is defined in function [{}], SAME ONE, NEGLECTED" .format(self.fct_inspect, node.parent.name), self.ofd) # If function of the same name is already traced either in the current round or in the tree, also neglect elif search_tuple_list(self.fctname_thisround, inspect_tuple) or search_tree( self.all_fct_name, inspect_tuple): print_writeofd( "The function call [{}] is defined in function [{}], ALREADY SEARCHED, NEGLECTED" .format(self.fct_inspect, node.parent.name), self.ofd) else: print_writeofd( "The function call [{}] is defined in function [{}]". format(self.fct_inspect, node.parent.name), self.ofd) self.fctname_thisround.append( (node.parent.name, self.url_inspect)) break node = node.parent
def identify_pattern(self, node, keyword): print_writeofd("Keyword identified: {}".format(keyword), self.ofd) # Now check to see if this API pattern is defined in a function while isinstance(node.parent, ast.Module) == False: if isinstance(node.parent, ast.FunctionDef): print_writeofd( "Note: The API call is defined in function: {}".format( node.parent.name), self.ofd) for arguments in node.parent.args.args: if arguments.arg not in ["event", "context"]: print_writeofd("This is not a lambda function", self.ofd) return False print_writeofd("This is a lambda function", self.ofd) return True node = node.parent return False
i = j continue # Judge if there is any other exception triggered if scan_block(lines, i, j, "EXCEPTION OCCURS"): proces_exception += 1 ofd.write("process_exception: {}".format(lines[k])) i = j continue # Judge if this is a no pattern identified case # If only relying on auto-tool: this should be a parallelism-used case if "NO PATTERN IDENTIFIED" in lines[j - 1]: if MANUAL_CHECKING: print("\n\n\n\n\n\n") print_writeofd("no_pattern: {}".format(lines[k].strip("\n")), ofd) print( "Please inspect the above. Enter 1 if this is a no parallelism case, and enter 2 if this is a use-parallelism case" ) user = input() while user != '1' and user != '2': print("PRESS 1 OR 2, NOT ANYTHING ELSE!") user = input() if user == '1': det_no_para += 1 print_writeofd( "no_pattern (no_parallelism): {}".format( lines[k].strip("\n")), ofd) i = j continue elif user == '2':
def render_beautify_tree(tree, ofd): tree = beautify_tree(tree) for pre, _, node in RenderTree(tree, style=AsciiStyle()): print_writeofd("%s%s" % (pre, node.name), ofd)
def retrieve_and_search(self): search_round = 0 end = self.all_fct_name while search_round < self._round: intmediate = [] for elements in end: for children in elements.children: intmediate.append(children) search_round += 1 end = intmediate print_writeofd( "Round {}, beginning tracing functions: ".format(self._round) + print_node_list(end), self.ofd) for elements in end: self.fctname_thisround = [] self.fct_inspect = elements.name[0] self.fct_inspect_url = elements.name[1] url_list = search_github(self.fct_inspect, self.repo, self.ofd) time.sleep(SLEEP_TIME) appear_url_list = url_list to_delete_list = [] for item in url_list: urlcontent = get_url_content(item, self.ofd) if urlcontent == None: continue p = add_backward_links(urlcontent) if p == None: continue self.url_inspect = item if (item == self.fct_inspect_url ) and self.manual_control_import: print_writeofd( "Info: importation file and to be imported function in the same file, importation check fulfilled", self.ofd) elif (item != self.fct_inspect_url) and self.manual_control_import: # Now checks for import self.checking_import = True self.import_true = False self.generic_visit(p) self.checking_import = False if self.import_true == False: print_writeofd( "Info: Importation check failed: function [{}] at url [{}], importation occurs in [{}]" .format(self.fct_inspect, slice_url(self.fct_inspect_url), slice_url(item)), self.ofd) to_delete_list.append(item) continue else: print_writeofd("Info: Importation check succeeded", self.ofd) self.generic_visit(p) for searched in self.fctname_thisround: node = Node((searched[0], searched[1], []), parent=elements) print_writeofd( "Traced functions {} based on [{}]".format( self.fctname_thisround, self.fct_inspect), self.ofd) for i in to_delete_list: appear_url_list.remove(i) print_writeofd( "This function [{}] appears in {}".format( self.fct_inspect, slice_list(appear_url_list)), self.ofd) for tree in self.all_fct_name: for members in PreOrderIter(tree): if members.name == (elements.name[0], elements.name[1], []): members.name = (elements.name[0], elements.name[1], appear_url_list)
def main_fct(self): self.generic_visit(self.entire_tree) if self.call_lineno == [] and self.while_lineno != []: print_writeofd("Start operation missing", self.ofd) return False if self.while_lineno == [] and self.call_lineno != []: print_writeofd("While loop operating missing", self.ofd) return False if self.while_lineno == [] and self.call_lineno == []: print_writeofd("Both start and loop operations missing", self.ofd) return False if len(self.while_lineno) != len(self.call_lineno): print_writeofd("Start and loop instance numbers do not match up", self.ofd) return False self.while_lineno.sort() self.call_lineno.sort() for call_lineno, while_lineno in zip(self.call_lineno, self.while_lineno): self.stage2(call_lineno, while_lineno) if self.not_safe_list != []: print_writeofd("------", self.ofd) print_writeofd( "Nodes in between start statement and while statement", self.ofd) for node in self.not_safe_list: print_writeofd(astor.to_source(node), self.ofd) print_writeofd("------", self.ofd) return True
url = line.split()[1] repo = re.sub('https://github.com/', '', url) repo = re.sub('\n', '', repo) print(url) ofd.write("{}\n".format(url)) url_list = [] for keyword in ASYNC_KEYWORD_LIST_EXIST: return_value = search_github(keyword, repo, ofd) if return_value != None: url_list.extend(return_value) elif return_value == None or return_value == []: continue if url_list == []: print_writeofd("No use of async", ofd) continue url_list_1 = [] for keyword in ASYNC_KEYWORD_LIST: return_value = search_github(keyword, repo, ofd) if return_value != None: url_list_1.extend(return_value) elif return_value == None or return_value == []: continue time.sleep(SLEEP_TIME) if url_list_1 == []: print_writeofd("No retrieve result", ofd) continue v = search_one_repo(remove_list_dup(url_list + url_list_1), ofd)
def check_instance_name(self, node): if not isinstance(node, ast.Name): print_writeofd("Node supposed to be name but not name: {}".format(ast.dump(node)), self.ofd) return False return True
elif user == '3' and printed_ent == 1: experi_ent += 1 ofd1.write("Entirely Experimental: ") ofd1.write(lines[k]) printed_ent = 0 printed_par = 0 print("\n\n\n\n\n\n") else: if printed_ent == 1: ofd1.write("Entirely constant: ") ofd1.write(lines[k]) accocc_ent += 1 if excepted == 1: excep += 1 ofd1.write(lines[k]) excepted = 0 print_writeofd("\n\n\n\n\n", ofd1) print_writeofd("Total file searched: {}".format(allfile), ofd1) print_writeofd("Entirely Constants found: {}".format(accocc_ent), ofd1) print_writeofd("Experimental Constants found: {}".format(experi_ent), ofd1) print_writeofd("Exceptions occurred: {}".format(excep), ofd1) if MANUAL_CHECKING: print_writeofd("RELYING ON MANUAL CHECKING: {} CONSTANT INPUTS".format(accocc_ent), ofd1) print_writeofd("RELYING ON MANUAL CHECKING: {} RELEVANT TOTAL PROJECTS".format(allfile - excep), ofd1) else: print_writeofd("RELYING ON AUTO TOOL: {} CONSTANT INPUTS".format(accocc_ent), ofd1) print_writeofd("RELYING ON AUTO TOOL: {} RELEVANT TOTAL PROJECTS".format(allfile - excep), ofd1)