Changeset 932
- Timestamp:
- 09/05/07 18:36:40 (1 year ago)
- Files:
-
- trunk/proto/doc/rfc/Ntk_p2p_over_ntk/Ntk_p2p_over_ntk.tex (modified) (1 diff)
- trunk/src/pyntk/CITE (modified) (1 diff)
- trunk/src/pyntk/core/hook.py (modified) (3 diffs)
- trunk/src/pyntk/core/map.py (modified) (6 diffs)
- trunk/src/pyntk/core/qspn.py (modified) (2 diffs)
- trunk/src/pyntk/core/radar.py (modified) (9 diffs)
- trunk/src/pyntk/core/route.py (modified) (10 diffs)
- trunk/src/pyntk/lib/rpc.py (modified) (8 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/proto/doc/rfc/Ntk_p2p_over_ntk/Ntk_p2p_over_ntk.tex
r859 r932 194 194 The node $\ove m$ will then recompute $m=\h(k)$. 195 195 This time, more levels will be defined, 196 because $\ove m$ is nearer to the$m$ and its196 because $\ove m$ is nearer to $m$ and its 197 197 map can give more accurate information 198 198 (regarding $m$). trunk/src/pyntk/CITE
r861 r932 18 18 ANDNA document |{andnadoc}| 19 19 http://netsukuku.freaknet.org/doc/main_doc/andna.pdf 20 21 * * * RFC * * * 22 23 P2P over Ntk |{P2PNtk}| 24 http://netsukuku.freaknet.org/files/doc/main_doc/ntk_rfc/Ntk_p2p_over_ntk.pdf trunk/src/pyntk/core/hook.py
r931 r932 192 192 193 193 ## complete the hook 194 self.radar.do_reply = False 194 195 195 196 # close the ntkd sessions … … 201 202 202 203 # reset the map 204 self.maproute.me_change(newip[:]) 203 205 for l in reversed(xrange(lvl)): self.maproute.level_reset(l) 206 207 self.radar.do_reply = True 208 209 # warn our neighbours 210 for nr in self.neigh: 211 nrnip=self.maproute.ip_to_nip(nr.ip) 212 nr.ntkd.neigh.ip_change(oldip, newip) 204 213 205 214 # Restore the neighbours in the map and send the ETP … … 208 217 # we've done our part 209 218 self.events.send('HOOKED', (oldip, newip[:])) 210 211 # warn our previous internal neighbours212 for nr in self.neigh:213 nrnip=self.maproute.ip_to_nip(nr.ip)214 if self.maproute.nip_cmp(oldip, nrnip) <= 0:215 nr.ntkd.neigh.delete(oldip)216 219 ## 217 220 trunk/src/pyntk/core/map.py
r930 r932 26 26 from random import randint 27 27 28 class DataClass: 29 """Data class example. 30 31 A Data class contains information regarding a node of the map. 32 Each Map.node[level][id] entry is a Data class instance. 33 34 This Data class is just a stub. 35 As another example, look MapRoute and RouteNode in route.py 36 """ 37 38 def __init__(self, level, id): 39 # do something 40 pass 41 42 def is_free(self): 43 """Returns True if this data class is free. False otherwise""" 44 return True 45 28 46 class Map: 29 47 … … 43 61 44 62 # The member self.node[l][i] is a node of level l and its ID is i 45 self.node = [[None for i in xrange(gsize)] for i in xrange(levels)]63 self.node = [[None]*gize]*levels 46 64 # Number of nodes of each level 47 self.node_nb = [ 0 for i in xrange(levels) ]65 self.node_nb = [0]*levels 48 66 49 self.events = Event( [ 'N EW_NODE', 'DEL_NODE' ] )67 self.events = Event( [ 'NODE_NEW', 'NODE_DELETED', 'ME_CHANGED' ] ) 50 68 51 69 def node_get(self, lvl, id): … … 60 78 61 79 def node_add(self, lvl, id): 62 if self.node[lvl][id] is None: 63 node=self.node_get(lvl, id) 64 self.node_nb[lvl]+=1 65 self.events.send('NEW_NODE', (lvl, id)) 80 node=self.node_get(lvl, id) 81 self.node_nb[lvl]+=1 82 self.events.send('NODE_NEW', (lvl, id)) 66 83 67 84 def node_del(self, lvl, id): 68 if self.node[lvl][id] is not None: 69 self.node_nb[lvl]-=1 70 self.events.send('DEL_NODE', (lvl, id)) 85 self.node_nb[lvl]-=1 86 self.events.send('NODE_DELETED', (lvl, id)) 71 87 self.node[lvl][id]=None 72 88 … … 79 95 return [nid for n in self.node[lvl] 80 96 for nid in self.gsize 81 if self.node[lvl][nid] != None]97 if self.node[lvl][nid].is_free() ] 82 98 83 99 def is_in_level(self, nip, lvl): … … 116 132 def level_reset(self, level): 117 133 """Resets the specified level, without raising any event""" 118 self.node[level] = [None for i in xrange(gsize)]134 self.node[level] = [None]*self.gsize 119 135 self.node_nb[level] = 0 120 136 … … 123 139 for l in xrange(self.levels): 124 140 self.level_reset(l) 141 142 def me_change(self, new_me): 143 """Changes self.me""" 144 old_me=self.me[:] 145 self.me=new_me 146 self.events.send('ME_CHANGED', (old_me, new_me)) trunk/src/pyntk/core/qspn.py
r931 r932 33 33 self.maproute=maproute 34 34 35 neigh.events.listen('NE W_NEIGH', self.etp_new_changed)36 neigh.events.listen(' REM_NEIGH', self.etp_new_changed)37 neigh.events.listen(' DEL_NEIGH', self.etp_new_dead)35 neigh.events.listen('NEIGH_NEW', self.etp_new_changed) 36 neigh.events.listen('NEIGH_REM_CHGED', self.etp_new_changed) 37 neigh.events.listen('NEIGH_DELETED', self.etp_new_dead) 38 38 39 39 self.events = Event(['ETP_EXECED', 'NET_COLLISION']) … … 265 265 266 266 if neigh.netid == self.radar.netid \ 267 or self.radar.netid == None:267 or self.radar.netid == -1: 268 268 self.radar.netid = neigh.netid 269 269 return (False, R) # all ok trunk/src/pyntk/core/radar.py
r931 r932 73 73 self.netid_table = {} 74 74 # the events we raise 75 self.events = Event(['NE W_NEIGH', 'DEL_NEIGH', 'REM_NEIGH'])75 self.events = Event(['NEIGH_NEW', 'NEIGH_DELETED', 'NEIGH_REM_CHGED']) 76 76 77 77 def neigh_list(self): … … 101 101 return a Neigh object from an ip 102 102 """ 103 104 return Neigh(ip, self.translation_table[ip], self.ip_table[ip].rtt, 105 self.netid_table[ip]) 103 if ip not in self.translation_table: 104 return None 105 else: 106 return Neigh(ip, self.translation_table[ip], 107 self.ip_table[ip].rtt, self.netid_table[ip]) 108 109 def id_to_ip(self, id): 110 """ Returns the IP associated to `id'. 111 If not found, returns None""" 112 for ip in self.translation_table: 113 if self.translation_table[ip] == id: 114 return ip 115 return None 116 117 def id_to_neigh(self, id): 118 """ Returns a Neigh object from an id """ 119 return self.ip_to_neigh(self.id_to_ip(id)) 106 120 107 121 def _truncate(self, ip_table): … … 176 190 self.ip_to_id(key) 177 191 # send a message notifying we added a node 178 self.events.send('NE W_NEIGH',192 self.events.send('NEIGH_NEW', 179 193 (Neigh(key, self.translation_table(key), 180 194 self.ip_table[key].rtt, self.netid_table[key]))) … … 184 198 if(abs(ip_table[key].rtt - self.ip_table[key].rtt) / self.ip_table[key].rtt > self.rtt_mav_var): 185 199 # send a message notifying the node's rtt changed 186 self.events.send(' REM_NEIGH',200 self.events.send('NEIGH_REM_CHGED', 187 201 (Neigh(key, self.translation_table[key], ip_table[key].rtt), 188 202 self.ip_table[key].rtt, … … 193 207 194 208 def readvertise(self): 195 """Sends a NE W_NEIGHevent for each stored neighbour"""209 """Sends a NEIGH_NEW event for each stored neighbour""" 196 210 for key in ip_table: 197 self.events.send('NE W_NEIGH',211 self.events.send('NEIGH_NEW', 198 212 (Neigh(key, self.translation_table(key), 199 213 self.ip_table[key].rtt, self.netid_table[key]))) … … 201 215 def delete(self, ip, remove_from_iptable=True): 202 216 """Deletes an entry from the ip_table""" 203 if ip in self.ip_table andremove_from_iptable:217 if remove_from_iptable: 204 218 del self.ip_table[ip] 205 219 # delete the entry from the translation table... … … 208 222 old_netid = self.netid_table.pop(ip) 209 223 # send a message notifying we deleted the entry 210 self.events.send('DEL_NEIGH', (Neigh(ip, old_id, None, old_netid))) 224 self.events.send('NEIGH_DELETED', (Neigh(ip, old_id, None, old_netid))) 225 226 def ip_change(self, oldip, newip): 227 """Adds `newip' in the Neighbours as a copy of `oldip', then it removes 228 `oldip'. The relative events are raised.""" 229 230 self.ip_table[newip] = self.ip_table[oldip] 231 self.translation_table[newip]= self.translation_table[oldip] 232 self.netid_table[newip] = self.netid_table[oldip] 233 234 self.events.send('NEIGH_NEW', 235 (Neigh(newip, self.translation_table(newip), 236 self.ip_table[newip].rtt, self.netid_table[newip]))) 237 self.delete(oldip) 238 211 239 212 240 class Radar: … … 237 265 238 266 # Our netid. It's a random id used to detect network collisions. 239 self.netid = None 267 self.netid = -1 268 269 # If set to True, this module will reply to radar queries sent by our 270 # neighbours. 271 self.do_reply = False 240 272 241 273 def run(self, started=0): … … 269 301 def reply(self): 270 302 """ As answer we'll return our netid """ 271 return self.netid 303 if self.do_reply: 304 return self.netid 305 else: 306 return DoNotReply 272 307 273 308 def time_register(self, ip, net_device, msg): trunk/src/pyntk/core/route.py
r930 r932 21 21 sys.path.append("..") 22 22 from lib.event import Event 23 from core.map import Map 23 24 24 25 class Rem: … … 272 273 return self.routes == [] 273 274 275 def is_free(self) 276 return self.is_empty() 277 274 278 def nroutes(self): 275 279 return len(self.routes) … … 290 294 Map.__init__(self, levels, gsize, RouteNode, me) 291 295 292 self.events.add( [ ' NEW_ROUTE',293 ' DEL_ROUTE',294 'R EM_ROUTE', # the route's rem changed295 296 'NE W_NEIGH',297 ' DEL_NEIGH',298 ' REM_NEIGH'296 self.events.add( [ 'ROUTE_NEW', 297 'ROUTE_DELETED', 298 'ROUTE_REM_CHGED', # the route's rem changed 299 300 'NEIGH_NEW', 301 'NEIGH_DELETED', 302 'NEIGH_REM_CHGED' 299 303 ] ) 300 304 … … 304 308 if not silent: 305 309 if ret == 1: 306 self.events.send(' NEW_ROUTE', (lvl, dst, gw, rem))310 self.events.send('ROUTE_NEW', (lvl, dst, gw, rem)) 307 311 if n.nroutes() == 1: 308 312 # The node is new … … 310 314 elif ret == 2: 311 315 oldrem=val 312 self.events.send('R EM_ROUTE', (lvl, dst, gw, rem, oldrem))316 self.events.send('ROUTE_REM_CHGED', (lvl, dst, gw, rem, oldrem)) 313 317 return ret 314 318 … … 318 322 319 323 if not silent: 320 self.events.send(' DEL_ROUTE', (lvl, dst, gw))324 self.events.send('ROUTE_DELETED', (lvl, dst, gw)) 321 325 322 326 if d.is_empty(): … … 335 339 oldrem=val 336 340 if not silent: 337 self.events.send('R EM_ROUTE', (lvl, dst, gw, newrem, oldrem))341 self.events.send('ROUTE_REM_CHGED', (lvl, dst, gw, newrem, oldrem)) 338 342 else: 339 343 return 0 … … 358 362 self.route_del(lvl, dst, neigh.id, silent=1) 359 363 if not silent: 360 self.events.send(' REM_DEL', (lvl, dst, neigh))364 self.events.send('NEIGH_DELETED', (lvl, dst, neigh)) 361 365 362 366 def routeneigh_add(self, neigh, silent=0): … … 364 368 lvl, nid = routeneigh_get(neigh) 365 369 if not silent: 366 self.events.send(' REM_ADD', (lvl, nid, neigh))370 self.events.send('NEIGH_NEW', (lvl, nid, neigh)) 367 371 return self.route_add(0, nid, nid, neigh.rem, silent=1) 368 372 … … 370 374 lvl, nid = routeneigh_get(neigh) 371 375 if not silent: 372 self.events.send(' REM_NEIGH', (lvl, nid, neigh))376 self.events.send('NEIGH_REM_CHGED', (lvl, nid, neigh)) 373 377 return self.route_rem(lvl, dst, neigh.rem, silent=1) 374 378 trunk/src/pyntk/lib/rpc.py
r911 r932 37 37 ntk_server.register_instance(MyClass()) 38 38 ntk_server.serve_forever() 39 40 39 ''' 40 41 ## TODO 42 # 43 # - Support for broadcast queries. See radar.py and how it utilises NtkdBroadcast 44 # 45 #### Done, but to be revisioned 46 # 47 # - If the function on the remote side returns DoNotReply, then 48 # reply must be sent! 49 # 50 # - The client must not create a new connection for each new rpc_call! 51 # Create a connection just when the instance is created 52 # 53 ## 54 41 55 import logging 42 56 import socket … … 46 60 47 61 62 DoNotReply = "__DoNotReply__" 63 48 64 class RPCError(Exception): 49 65 pass … … 61 77 This class is used to perform RPC call using the following form: 62 78 63 ntkd. ept.mymethod(p1, p2, p3)79 ntkd.mymethod1.mymethod2.func(p1, p2, p3) 64 80 65 81 instead of: 66 82 67 ntkd.rmt(' etp.mymethod', (p1, p2, p3))83 ntkd.rmt('mymethod1.method2.func', (p1, p2, p3)) 68 84 ''' 69 85 def __init__(self, name=''): … … 159 175 except RPCError: 160 176 logging.debug('An error occurred during request handling') 161 else:177 elif response != DoNotReply: 162 178 self.request.send(response) 163 self.request.close()179 #self.request.close() 164 180 logging.debug('Response sended') 165 181 … … 181 197 self.port = port 182 198 199 self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 200 self.connected = False 201 183 202 def rpc_call(self, func_name, params): 184 203 '''Performs a rpc call … … 188 207 ''' 189 208 190 self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 191 self.socket.connect((self.host, self.port))209 if not self.connected: 210 self.connect() 192 211 193 212 data = rencode.dumps((func_name, params)) … … 195 214 196 215 recv_encoded_data = self.socket.recv(1024) 197 self.socket.close()198 199 216 recv_data = rencode.loads(recv_encoded_data) 200 217 … … 207 224 208 225 return recv_data 226 227 def connect(self): 228 self.socket.connect((self.host, self.port)) 229 self.connected = True 230 231 def close(self): 232 self.socket.close() 233 self.connected = False
