def init_node(_node: NodeInfo, _item: dict, _rank: int) -> Optional[NodeInfo]:
if _node.id.lower() != _item["NodeId"].lower():
return None
_node.rank = _rank + 1
_node.name = _item["NodeName"]
_node.shares = int(_item["Shares"], 16)
return _node
def initlist(self,data):
self.head = NodeInfo(data[0])
p = self.head
for i in data[1:]:
node = NodeInfo(i)
p.nextnode = node
node.prevnode = p
p = p.nextnode
def append(self,item):
q = NodeInfo(item)
if self.head == 0:
self.head = q
else:
p = self.head
while p.nextnode != 0:
p = p.nextnode
p.nextnode = q
q.prevnode = p
def join(self):
nodeInfo = NodeInfo()
if (nodeInfo.isOnline==False):
ip = raw_input('Input IP to connect to:')
port = raw_input('Input port to connect to:')
nodeInfo.setParentNodeAddr(ip+":"+str(port))
proxy = xmlrpclib.ServerProxy("http://"+nodeInfo.parentNodeAddr+"/")
activeNodes = proxy.getActiveNodes()
print activeNodes
if(activeNodes != []):
for node in activeNodes:
nodeInfo.addActiveNode(node)
nodeInfo.setOnline(True)
for nodeAddr in nodeInfo.getActiveNodes():
if nodeAddr != nodeInfo.getNodeAddrStr():
self.joinRPC("http://" + nodeAddr + "/")
print "successfully joined"
return 0
else:
print "Something is wrong, node may already exist"
return -1
def addLink(self, fromNodeId: int, toNodeId: int, distance: int):
if (self.adjacencies.get(fromNodeId) is None):
print('Node with ID ' + fromNodeId + ' not found')
return
if (self.adjacencies.get(toNodeId) is None):
print('Node with ID ' + toNodeId + ' not found')
return
self.adjacencies[fromNodeId].append(NodeInfo(toNodeId, distance))
self.adjacencies[toNodeId].append(NodeInfo(fromNodeId, distance))
def adjustTest(self):
T = ParseTree()
nodes = [
Node(index=-1, word="DEFAULT", posTag="DEFAULT")
for i in range(0, 9)
]
nodes[0] = Node(index=0, word="ROOT", posTag="--")
nodes[0].info = NodeInfo(type="ROOT", value="ROOT")
nodes[1] = Node(index=1, word="return", posTag="--")
nodes[1].info = NodeInfo(type="SN", value="SELECT")
nodes[2] = Node(index=2, word="conference", posTag="--")
nodes[2].info = NodeInfo(type="NN", value="Author")
nodes[3] = Node(index=3, word="area", posTag="--")
nodes[3].info = NodeInfo(type="NN", value="Title")
nodes[4] = Node(index=4, word="each", posTag="--")
nodes[4].info = NodeInfo(type="QN", value=">")
nodes[5] = Node(index=5, word="papers", posTag="--")
nodes[5].info = NodeInfo(type="NN", value="Author")
nodes[6] = Node(index=6, word="citations", posTag="--")
nodes[6].info = NodeInfo(type="NN", value="Journal")
nodes[7] = Node(index=7, word="most", posTag="--")
nodes[7].info = NodeInfo(type="FN", value=">")
nodes[8] = Node(index=8, word="total", posTag="--")
nodes[8].info = NodeInfo(type="FN", value="Year")
T.root = nodes[0]
nodes[0].children.append(nodes[1])
nodes[1].parent = nodes[0]
nodes[1].children.append(nodes[2])
nodes[2].parent = nodes[1]
nodes[2].children.append(nodes[3])
nodes[3].parent = nodes[2]
nodes[2].children.append(nodes[5])
nodes[5].parent = nodes[2]
nodes[3].children.append(nodes[4])
nodes[4].parent = nodes[3]
nodes[5].children.append(nodes[6])
nodes[6].parent = nodes[5]
nodes[6].children.append(nodes[7])
nodes[7].parent = nodes[6]
nodes[6].children.append(nodes[8])
nodes[8].parent = nodes[6]
print(
"===========test for Running adjust() in TreeAdjustor===========")
treeList = TreeAdjustor.adjust(T)
print("Output size: %d" % len(treeList))
print("Output trees:")
ctr = 0
for tr in treeList:
print("Tree %d %s" % (ctr, tr.getSentence()))
ctr += 1
def _createListenerToServer(self,serverIp,serverPort):
# TODO] Set the fixed server address
# [Testing by simply read from file]
import configparser
from NodeInfo import NodeInfo
config = configparser.ConfigParser()
config.read('Config.ini')
num = config['default']['num']
nodes = config['nodes']
for key in nodes:
if key != self._id:
ip,port = nodes[key].split(":")
self._AllNodeInfo.addNode(NodeInfo(key,ip,port))
else:
ip, port = nodes[key].split(":")
self._ip = ip
self._port = port
# Initialize all the seq number
for key in nodes:
self._RequestNumber[key] = 0
# Initial the token if id is aa
if self._id == 'aa':
self._token.append(Token())
self._token[0].createFromList(self._AllNodeInfo)
self._tokenInfo.changeMode(hasToken=True)
def dijkstra_algorithm(self, source):
"""
dijksra's algorithm implementation
:param source: node to start the traversal from
:return: dictionary of predecessors of each node
"""
visited = {}
predecessors = {}
nodes_queue = queue.PriorityQueue()
for node in self.get_graph().get_all_v().values():
node1 = NodeInfo(node)
node.set_weight(-1)
visited[node.key] = False
source.set_weight(0)
nodes_queue.put(source)
while not nodes_queue.empty():
current_node = nodes_queue.get()
if visited.get(current_node.key) is False:
for node_id in current_node.out_edges.keys():
node = self.get_graph().get_all_v().get(node_id)
distance = current_node.out_edges.get(
node_id) + current_node.weight
if node.weight == -1 or distance < node.weight:
node.set_weight(distance)
predecessors[node.key] = current_node
nodes_queue.put(node)
visited[current_node.key] = True
return predecessors
def encoding(self, value):
for i in range(len(value)):
self.frequency_occurrence[ord(value[i])] = self.frequency_occurrence[ord(value[i])] + 1
for i in range((len(self.frequency_occurrence))):
if self.frequency_occurrence[i] != 0:
self.frequency_dict[chr(i)] = self.frequency_occurrence[i]
for values in self.frequency_dict:
self.node_info_list.append(NodeInfo(values, self.frequency_dict[values]))
self.node_info_list.sort(key=lambda x: x.value)
while len(self.node_info_list) > 1:
temp_node_one = self.node_info_list[0]
temp_node_two = self.node_info_list[1]
new_temp_node_value = temp_node_one.value + temp_node_two.value
new_temp_node_key = temp_node_one.key + temp_node_two.key
new_temp_node = NodeInfo(new_temp_node_key, new_temp_node_value)
new_temp_node.set_left_child(temp_node_one)
new_temp_node.set_right_child(temp_node_two)
self.node_info_list.append(new_temp_node)
del (self.node_info_list[0])
del (self.node_info_list[0])
self.huffman_root_node = self.node_info_list[0]
self.traverse_huffman_tree()
def signOff(self):
nodeInfo = NodeInfo()
currentNodeAddr = nodeInfo.getNodeAddrStr()
if nodeInfo.isOnline:
nodeInfo.setOnline(False)
print nodeInfo.getActiveNodes()
for nodeAddr in nodeInfo.getActiveNodes():
if nodeAddr != currentNodeAddr:
self.signOffRPC("http://"+nodeAddr+"/")
nodeInfo.clearActiveNodes()
print "successfully signed off"
def run(self):
isRunning = True
while(isRunning):
command = raw_input('Input Command:')
if command == "join":
self.client.join()
elif (command == "signoff"):
self.client.signOff()
elif command == "stop":
nodeInfo = NodeInfo()
self.client.signOff()
nodeInfo.setRunning(False)
isRunning = False
break
else:
print "Bad Input, Try join, signoff or stop"
def insert(self,index,item):
if self.is_empty() or index < 0 or index > self.getlength():
print 'Linklist is empty.'
return
if index == 0:
q = NodeInfo(item,self.head)
self.head = q
p = self.head
post = self.head
j = 0
while p.nextnode != 0 and j < index:
post = p
p = p.nextnode
j += 1
if index == j:
q = NodeInfo(item,p)
post.nextnode = q#?
q.prevnode = post
q.nextnode = p
p.prevnode = q
def add_node(self, node_id: int, pos: tuple = None) -> bool:
"""
Adds a node to the graph.
@param node_id: The node ID
@param pos: The position of the node
@return: True if the node was added successfully, False o.w.
Note: if the node id already exists the node will not be added
"""
if node_id not in self.nodes_list:
self.nodes_list[node_id] = NodeInfo(node_id, pos)
self.mc += 1
return True
return False
def enqueue(self, nodeId, cost):
node = NodeInfo(nodeId, cost)
if (self.isEmpty()):
self.collection.append(node)
else:
added = False
i = 1
while (i <= len(self.collection)):
if (node.cost < self.collection[i - 1].cost):
self.collection.insert(i - 1, node)
added = True
break
i = i + 1
if (added == False):
self.collection.append(node)
def delete(self,index):
if self.is_empty() or index < 0 or index > self.getlength():
print 'Linklist is empty.'
return
if index == 0:
q = NodeInfo(item,self.head)
self.head = q
p = self.head
post = self.head
j = 0
while p.nextnode != 0 and j < index:
post = p
p = p.nextnode
j += 1
if index == j:
post.nextnode = p.nextnode
p.nextnode.prevnode = post
def new_task(account, graph_id, task_name="New Task"):
#create a new task
# u_id = fetch_uid(account)
u_id = account
task = DAG(graph_id, u_id)
n_id = HashMaker().hash_task()
#insert to DAG_Node
task.add_node(n_id)
node_info = NodeInfo(n_id, u_id, task_name)
#add the first node
values = "({},{})".format(n_id, u_id)
insert('Node_Group', values)
#insert to NodeGroup
node_info.rename_task(task_name)
node_info.save_state()
return node_info
def add(nodeAddr):
nodeInfo = NodeInfo()
print "Node"+ nodeAddr+"has been added"
return nodeInfo.addActiveNode(nodeAddr)
def testTranslation1():
tree = ParseTree()
nodes = [
Node(index=-1, word="DEFAULT", posTag="DEFAULT")
for i in range(0, 6)
]
nodes[0] = Node(index=0, word="ROOT", posTag="ROOT")
nodes[0].info = NodeInfo(type="ROOT", value="ROOT")
nodes[1] = Node(index=1, word="return", posTag="--")
nodes[1].info = NodeInfo(type="SN", value="SELECT")
nodes[2] = Node(index=2, word="titles", posTag="--")
nodes[2].info = NodeInfo(type="NN", value="in.title")
nodes[3] = Node(index=3, word="theory", posTag="--")
nodes[3].info = NodeInfo(type="VN", value="in.area")
nodes[4] = Node(index=4, word="before", posTag="--")
nodes[4].info = NodeInfo(type="ON", value="<")
nodes[5] = Node(index=5, word="1970", posTag="--")
nodes[5].info = NodeInfo(type="VN", value="in.year")
tree.root = nodes[0]
tree.root.getChildren().append(nodes[1])
nodes[1].children.append(nodes[2])
nodes[2].parent = nodes[1]
nodes[2].children.append(nodes[3])
nodes[2].children.append(nodes[4])
nodes[3].parent = nodes[2]
nodes[4].parent = nodes[2]
nodes[4].children.append(nodes[5])
nodes[5].parent = nodes[4]
print(
"===========test for Running SyntacticEvaluator.numberOfInvalidNodes==========="
)
print("Input tree: ")
print(tree)
print("Number of Invalid nodes: %d " %
SyntacticEvaluator().numberOfInvalidNodes(tree) + "\n")
print("Invalid nodes: ")
for i in range(1, tree.size()):
if (nodes[i].isInvalid):
print(nodes[i])
print("===========test for Running mergeLNQN===========")
print("Input tree:")
print(tree)
newTree = tree.mergeLNQN()
print("Output tree:")
print(newTree)
print(
"===========test for Running adjust() in TreeAdjustor===========")
print("Input tree: ")
print(tree)
treeList = TreeAdjustor.adjust(tree)
print("Output size: %d" % len(treeList))
print("Output trees:")
for i in range(0, len(treeList)):
print("Tree " + str(i) + " :")
print(treeList[i])
print(
"===========test for Running getAdjustedTrees() in TreeAdjustor==========="
)
print("Number of possible trees for choice:")
result = TreeAdjustor.getAdjustedTrees(tree)
print(len(result))
for t in result:
print(t)
def signOffRPC(self,url):
nodeInfo = NodeInfo()
proxy = xmlrpclib.ServerProxy(url)
#multicall = xmlrpclib.MultiCall(proxy)
params = nodeInfo.getNodeAddrStr()
proxy.delete(params)
def joinRPC(self,url):
nodeInfo = NodeInfo()
proxy = xmlrpclib.ServerProxy(url)
#multicall = xmlrpclib.MultiCall(proxy)
params = nodeInfo.getNodeAddrStr()
proxy.add(params)
def stopClient(self):
nodeInfo = NodeInfo()
nodeInfo.setRunning(False)
def __init__(self,ip,port):
nodeInfo = NodeInfo(port,ip)
nodeInfo.setRunning(True)
nodeInfo.setNodeAddr(ip,port)
nodeInfo.addActiveNode(ip + ":" + str(port))
name = cf.get('mail', 'name')
address = cf.get('mail', 'address')
msg_address = formataddr((Header(name, 'utf-8').encode(), address))
server_host = cf.get('mail', 'server')
pt_str = cf.get('mail', 'port').strip()
port = 25 if len(pt_str) == 0 else int(pt_str)
server = smtplib.SMTP(server_host, port)
subject = cf.get('mail', 'subject')
mail_enable = True
watching_nodes = {}
time_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
with open(cf.get('app', 'node_info_file'), 'r') as f:
for line in f:
parts = line.split(',')
info = NodeInfo(parts[0].strip(), parts[1].strip(), parts[2].strip())
watching_nodes[info.id] = info
print(time_str, info.id, info.dingding, info.mail)
send_msg('Alaya预警正在运行！')
shares_increase_threshold = int(cf.get('alert_type', 'shares_increase_threshold')) * 10**18
shares_reduce_threshold = int(cf.get('alert_type', 'shares_reduce_threshold')) * 10**18
# 排名上升达到阈值进行提醒，-1表示永不提醒
rank_increase_threshold = int(cf.get('alert_type', 'rank_increase_threshold'))
# 排名下降达到阈值后进行提醒，-1为不提醒
rank_reduce_threshold = int(cf.get('alert_type', 'rank_reduce_threshold'))
# 排名达到阈值或阈值之后进行提醒，-1为不提醒
rank_threshold = int(cf.get('alert_type', 'rank_threshold'))
# 是否对状态改变进行提醒，true为提醒，false为不提醒
status_enable = cf.get('alert_type', 'status_enable')
while True:
try:
def delete(self, nodeAddr):
nodeInfo = NodeInfo()
print "Node"+ nodeAddr+"has been deleted"
return nodeInfo.delActiveNode(nodeAddr)
def getAdjustedTreesTest(self):
T = ParseTree()
nodes = [
Node(index=-1, word="DEFAULT", posTag="DEFAULT")
for i in range(0, 8)
]
nodes[0] = Node(index=0, word="ROOT", posTag="--")
nodes[0].info = NodeInfo(type="ROOT", value="ROOT")
nodes[1] = Node(index=1, word="return", posTag="--")
nodes[1].info = NodeInfo(type="SN", value="SELECT")
nodes[2] = Node(index=2, word="conference", posTag="--")
nodes[2].info = NodeInfo(type="NN", value="Author")
nodes[3] = Node(index=3, word="area", posTag="--")
nodes[3].info = NodeInfo(type="NN", value="Title")
nodes[4] = Node(index=4, word="papers", posTag="--")
nodes[4].info = NodeInfo(type="NN", value="Author")
nodes[5] = Node(index=5, word="citations", posTag="--")
nodes[5].info = NodeInfo(type="NN", value="Journal")
nodes[6] = Node(index=6, word="most", posTag="--")
nodes[6].info = NodeInfo(type="FN", value=">")
nodes[7] = Node(index=7, word="total", posTag="--")
nodes[7].info = NodeInfo(type="FN", value="Year")
T.root = nodes[0]
nodes[0].children.append(nodes[1])
nodes[1].parent = nodes[0]
nodes[1].children.append(nodes[2])
nodes[2].parent = nodes[1]
nodes[2].children.append(nodes[3])
nodes[3].parent = nodes[2]
nodes[2].children.append(nodes[4])
nodes[4].parent = nodes[2]
nodes[4].children.append(nodes[5])
nodes[5].parent = nodes[4]
nodes[5].children.append(nodes[6])
nodes[6].parent = nodes[5]
nodes[5].children.append(nodes[7])
nodes[7].parent = nodes[5]
print(
"===========test for Running getAdjustedTrees() in TreeAdjustor==========="
)
print("The original tree:")
print(T.toString())
print("Number of possible trees for choice:")
obj = TreeAdjustor()
result = TreeAdjustor.getAdjustedTrees(T)
# result = TreeAdjustor.adjust(T)
print(len(result))
# result = sorted(result,cmp=TreeAdjustorTest.cmpp)
# l =sorted(m, cmp =TreeAdjustor.timeStampCompare)
for i in range(0, len(result)):
for j in range(i + 1, len(result)):
if (result[i].getScore() <= result[j].getScore()):
temp = result[i]
result[i] = result[j]
result[j] = temp
print("The three trees with highest scores look like:")
for i in range(0, 5):
print(result[i])
for tree in result:
print(" treeList Result %s:%d" %
(tree.getSentence(), tree.getScore()))
tree.insertImplicitNodes()
query = tree.translateToSQL(self.schema)
print("qUERY: " + query.toString())
def describe_task(task_ID, abstract, new_title="", due_date=""):
task = NodeInfo(task_ID)
return task.describe_task(abstract, new_title, due_date)
