def __init__(self, **kwargs):
threading.Thread.__init__(self)
# TODO find a better Database name
self.db_name = kwargs.get('db_name', self.__class__.__name__)
self.db = DTNDatabase(self.db_name)
# IP
self.my_ip = kwargs.get(
'ip', '127.0.0.1') #socket.gethostbyname(socket.gethostname()))
self.dtn_port = kwargs.get('dtn_port', 5555)
self.dtn_listen = None
self.bcast_port = kwargs.get('bcast_port', 6666)
self.bcast_listen = None
# Sensor Host Information
# = server if it is Server Site Manager
# = mobile if it is Mobile Site Manager
self.sh = kwargs.get('sh', '')
# Target
# * means all
# or a list of SH
# Normally, server needs *
# client needs data of its own sh
self.target = kwargs.get('target', '*')
# DTN connection dict
# (SH, DTNConn)
self.dtn = dict()
# Dict which stores (SH, LastHash)
self.last_hash = dict()
# The last message received
# (SH, HASH)
self.last_hash = dict()
# flags
self.stop_flag = False
self.server_connected = False
# FIXME check if I need this
self.bufs = dict()
# FIXME seems does not work
signal.signal(signal.SIGINT, self.sighandler)
def __init__(self, **kwargs):
threading.Thread.__init__(self)
# TODO find a better Database name
self.db_name = kwargs.get('db_name', self.__class__.__name__)
self.db = DTNDatabase(self.db_name)
# IP
self.my_ip = kwargs.get('ip', '127.0.0.1')#socket.gethostbyname(socket.gethostname()))
self.dtn_port = kwargs.get('dtn_port', 5555)
self.dtn_listen = None
self.bcast_port = kwargs.get('bcast_port', 6666)
self.bcast_listen = None
# Sensor Host Information
# = server if it is Server Site Manager
# = mobile if it is Mobile Site Manager
self.sh = kwargs.get('sh', '')
# Target
# * means all
# or a list of SH
# Normally, server needs *
# client needs data of its own sh
self.target = kwargs.get('target', '*')
# DTN connection dict
# (SH, DTNConn)
self.dtn = dict()
# Dict which stores (SH, LastHash)
self.last_hash = dict()
# The last message received
# (SH, HASH)
self.last_hash = dict()
# flags
self.stop_flag = False
self.server_connected = False
# FIXME check if I need this
self.bufs = dict()
# FIXME seems does not work
signal.signal(signal.SIGINT, self.sighandler)
__date__ = 'Sun Apr 3 15:29:43 2011'
__version__ = '0.1'
import sys
import time
from DTNDatabase import DTNDatabase
from DTNMessage import DTNMessage
# dtncmd HOST NODE {CMD}
if len(sys.argv) < 3:
print 'python dtncmd.py 001E8C6C9172 ls'
sys.exit()
t = int(time.time() * 1000)
msg = '%d %s %d CMD {%s}' % (t, sys.argv[1], 30 * 24 * 60 * 60 * 1000,
' '.join(sys.argv[2:]))
m = DTNMessage()
m.handle(msg)
# TODO set message ip and port if possible
db = DTNDatabase('trapper')
db.insert_msg(m)
db.close()
print 'OK'
#for msg in db.select_all():
#print msg
class BaseDTNDevice(threading.Thread):
def __init__(self, **kwargs):
threading.Thread.__init__(self)
# TODO find a better Database name
self.db_name = kwargs.get('db_name', self.__class__.__name__)
self.db = DTNDatabase(self.db_name)
# IP
self.my_ip = kwargs.get('ip', '127.0.0.1')#socket.gethostbyname(socket.gethostname()))
self.dtn_port = kwargs.get('dtn_port', 5555)
self.dtn_listen = None
self.bcast_port = kwargs.get('bcast_port', 6666)
self.bcast_listen = None
# Sensor Host Information
# = server if it is Server Site Manager
# = mobile if it is Mobile Site Manager
self.sh = kwargs.get('sh', '')
# Target
# * means all
# or a list of SH
# Normally, server needs *
# client needs data of its own sh
self.target = kwargs.get('target', '*')
# DTN connection dict
# (SH, DTNConn)
self.dtn = dict()
# Dict which stores (SH, LastHash)
self.last_hash = dict()
# The last message received
# (SH, HASH)
self.last_hash = dict()
# flags
self.stop_flag = False
self.server_connected = False
# FIXME check if I need this
self.bufs = dict()
# FIXME seems does not work
signal.signal(signal.SIGINT, self.sighandler)
def sighandler(self, signum, frame):
self.stop()
def sub_init(self):
pass
def run(self):
self.sub_init()
self.stop_flag = False
# open listener
self.open_listener()
while not self.stop_flag:
try:
self.work()
except :
logger.error(sys.exc_info()[0])
break
# TODO
def stop(self):
self.stop_flag = True
for sh in self.dtn:
if self.dtn[sh] is not None:
self.dtn[sh].stop()
self.dtn[sh] = None
self.close_all_sockets()
self.db.close()
self.db.join()
def open_listener(self):
""" Open Listeners
@rewrite if implementing subclass
"""
self.dtn_listen = DTN._tcp_listen(self.my_ip, self.dtn_port)
self.bcast_listen = DTN._broadcast_listen(self.bcast_port)
def close_all_sockets(self):
""" Close all sockets """
readers = self.get_sockets(self.get_handle_map())
for s in readers:
if s is not None:
DTN._cleanup_socket(s)
def get_handle_map(self):
""" Return new (variable, function) list
f_map is a list of tuples
[(socket, func), (socket, func)]
@rewrite if implementing subclass which handles more sockets
"""
f_map = [
(self.dtn_listen ,self.handle_dtn_listen),
(self.bcast_listen ,self.handle_bcast_listen),
]
return f_map
def get_sockets(self, l):
""" return all the sockets
"""
readers = list()
for s in l:
if isinstance(s[0], socket.socket):
readers += [s[0]]
elif isinstance(s[0], list):
readers += s[0]
return readers
def work(self):
# update f_map and readers
f_map = self.get_handle_map()
readers = self.get_sockets(f_map)
try:
ready_to_read, ready_to_write, in_error = select.select(readers, [], [], 3)
except socket.timeout:
return
except:
logger.error('work error')
return
for r in ready_to_read:
for s in f_map:
if isinstance(s[0], socket.socket):
if r == s[0]:
s[1](r)
break
elif isinstance(s[0], list):
if r in s[0]:
s[1](r)
break
def handle_bcast_listen(self, s):
"""docstring for handle_bcast_listen"""
logger.debug('Recv bcast')
msg, addr = s.recvfrom(65535)
# send back DTN Port
s.sendto('%s %d' % (self.my_ip, self.dtn_port), addr)
def bcast(self, bcast_port):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.sendto(BCAST_MSG, ('<broadcast>', bcast_port))
logger.debug('send broadcast')
s.settimeout(2)
try:
buf, addr = s.recvfrom(2048)
logger.info('Received from %s: %s' % (buf.split()[0], buf.split()[1]))
s.close()
return buf.split()[0], int(buf.split()[1])
except socket.timeout:
logger.debug('no feedback')
except :
logger.debug('bcast socket error')
s.close()
return None
def handle_dtn_listen(self, s):
logger.info('DTN connection request')
conn_recv, remote = s.accept()
data = conn_recv.recv(1024)
sh = data.split()[0]
tar = ' '.join(data.split()[1:])
logger.debug('SH: %s, Target: %s' % (sh, tar))
if self.dtn.has_key(sh):
logger.debug(self.dtn[sh])
if self.dtn.has_key(sh) and self.dtn[sh] is not None:
conn_recv.send(EXIST_ERR)
logger.debug('DTN connection already exists between these two Site Managers')
return False
# Generate a random port for listening
random_n = 1
listener = None
while True:
try:
listener = DTN._tcp_listen(self.my_ip, self.dtn_port+random_n)
except:
random_n += 1
continue
break
conn_recv.send('%s %d %s' % (self.sh, self.dtn_port+random_n, self.target))
data = conn_recv.recv(1024)
if data == EXIST_ERR:
logger.debug('DTN connection already exists between these two Site Managers')
return False
# wait for connection
listener.settimeout(5)
try:
conn_send, remote = listener.accept()
except socket.timeout:
logger.debug('timeout')
return False
# remote[0] is IP
# remote[1] is PORT
#conn_send = DTN._tcp_connect(remote[0], port)
if conn_send is not None:
# send my SH info
#conn_send.send('%s %s' % (self.sh, self.target))
#data = conn_send.recv(1024)
#if data == EXIST_ERR:
#logger.debug('DTN connection already exists between these two Site Managers')
#return
#else:
#logger.debug('Good')
# Ready
dtn_conn = DTNConnection(conn_send, conn_recv, self.sh, sh, tar, self)
self.dtn[sh] = dtn_conn
if not self.last_hash.has_key(sh):
self.last_hash[sh] = ''
#if sh == SERVER_SH_INFO:
#self.server_connected = True
logger.info('New DTN connection established')
dtn_conn.start()
return True
return False
def connect_to_sm(self, ip, port, server_conn=False):
""" connect to specific IP:PORT
"""
logger.debug('Try to connect to Site Manager and establish DTN connection')
conn_send = DTN._tcp_connect(ip, port)
if conn_send is not None:
# send information
conn_send.send('%s %s\n' % (self.sh, self.target))
data = conn_send.recv(1024)
port_recv = 0
if data == EXIST_ERR:
logger.debug('DTN connection already exists between these two Site Managers')
return False
sh = data.split()[0]
port_recv = int(data.split()[1])
tar = ' '.join(data.split()[2:])
logger.debug('SH: %s, Port: %d, Target: %s' % (sh, port_recv, tar))
# check if site manager is connected
if self.dtn.has_key(sh) and self.dtn[sh] is not None:
conn_send.send(EXIST_ERR)
logger.debug('DTN connection already exists between these two Site Managers')
return False
else:
conn_send.send(SUCCESS_INFO)
# connect to ip using another port
conn_recv = DTN._tcp_connect(ip, port_recv)
if conn_recv is not None:
# Ready
dtn_conn = DTNConnection(conn_send, conn_recv, self.sh, sh, tar, self, server_conn=server_conn)
self.dtn[sh] = dtn_conn
if not self.last_hash.has_key(sh):
self.last_hash[sh] = ''
logger.info('New DTN connection established')
dtn_conn.start()
return True
return False
def stop_sh(self, sh):
if self.dtn[sh].has_key(sh):
self.dtn[sh].stop()
else:
logger.warning("no connection to %s" % sh)
def list_connected_sh(self):
return self.dtn.keys()
class BaseDTNDevice(threading.Thread):
def __init__(self, **kwargs):
threading.Thread.__init__(self)
# TODO find a better Database name
self.db_name = kwargs.get('db_name', self.__class__.__name__)
self.db = DTNDatabase(self.db_name)
# IP
self.my_ip = kwargs.get(
'ip', '127.0.0.1') #socket.gethostbyname(socket.gethostname()))
self.dtn_port = kwargs.get('dtn_port', 5555)
self.dtn_listen = None
self.bcast_port = kwargs.get('bcast_port', 6666)
self.bcast_listen = None
# Sensor Host Information
# = server if it is Server Site Manager
# = mobile if it is Mobile Site Manager
self.sh = kwargs.get('sh', '')
# Target
# * means all
# or a list of SH
# Normally, server needs *
# client needs data of its own sh
self.target = kwargs.get('target', '*')
# DTN connection dict
# (SH, DTNConn)
self.dtn = dict()
# Dict which stores (SH, LastHash)
self.last_hash = dict()
# The last message received
# (SH, HASH)
self.last_hash = dict()
# flags
self.stop_flag = False
self.server_connected = False
# FIXME check if I need this
self.bufs = dict()
# FIXME seems does not work
signal.signal(signal.SIGINT, self.sighandler)
def sighandler(self, signum, frame):
self.stop()
def sub_init(self):
pass
def run(self):
self.sub_init()
self.stop_flag = False
# open listener
self.open_listener()
while not self.stop_flag:
try:
self.work()
except:
logger.error(sys.exc_info()[0])
break
# TODO
def stop(self):
self.stop_flag = True
for sh in self.dtn:
if self.dtn[sh] is not None:
self.dtn[sh].stop()
self.dtn[sh] = None
self.close_all_sockets()
self.db.close()
self.db.join()
def open_listener(self):
""" Open Listeners
@rewrite if implementing subclass
"""
self.dtn_listen = DTN._tcp_listen(self.my_ip, self.dtn_port)
self.bcast_listen = DTN._broadcast_listen(self.bcast_port)
def close_all_sockets(self):
""" Close all sockets """
readers = self.get_sockets(self.get_handle_map())
for s in readers:
if s is not None:
DTN._cleanup_socket(s)
def get_handle_map(self):
""" Return new (variable, function) list
f_map is a list of tuples
[(socket, func), (socket, func)]
@rewrite if implementing subclass which handles more sockets
"""
f_map = [
(self.dtn_listen, self.handle_dtn_listen),
(self.bcast_listen, self.handle_bcast_listen),
]
return f_map
def get_sockets(self, l):
""" return all the sockets
"""
readers = list()
for s in l:
if isinstance(s[0], socket.socket):
readers += [s[0]]
elif isinstance(s[0], list):
readers += s[0]
return readers
def work(self):
# update f_map and readers
f_map = self.get_handle_map()
readers = self.get_sockets(f_map)
try:
ready_to_read, ready_to_write, in_error = select.select(
readers, [], [], 3)
except socket.timeout:
return
except:
logger.error('work error')
return
for r in ready_to_read:
for s in f_map:
if isinstance(s[0], socket.socket):
if r == s[0]:
s[1](r)
break
elif isinstance(s[0], list):
if r in s[0]:
s[1](r)
break
def handle_bcast_listen(self, s):
"""docstring for handle_bcast_listen"""
logger.debug('Recv bcast')
msg, addr = s.recvfrom(65535)
# send back DTN Port
s.sendto('%s %d' % (self.my_ip, self.dtn_port), addr)
def bcast(self, bcast_port):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.sendto(BCAST_MSG, ('<broadcast>', bcast_port))
logger.debug('send broadcast')
s.settimeout(2)
try:
buf, addr = s.recvfrom(2048)
logger.info('Received from %s: %s' %
(buf.split()[0], buf.split()[1]))
s.close()
return buf.split()[0], int(buf.split()[1])
except socket.timeout:
logger.debug('no feedback')
except:
logger.debug('bcast socket error')
s.close()
return None
def handle_dtn_listen(self, s):
logger.info('DTN connection request')
conn_recv, remote = s.accept()
data = conn_recv.recv(1024)
sh = data.split()[0]
tar = ' '.join(data.split()[1:])
logger.debug('SH: %s, Target: %s' % (sh, tar))
if self.dtn.has_key(sh):
logger.debug(self.dtn[sh])
if self.dtn.has_key(sh) and self.dtn[sh] is not None:
conn_recv.send(EXIST_ERR)
logger.debug(
'DTN connection already exists between these two Site Managers'
)
return False
# Generate a random port for listening
random_n = 1
listener = None
while True:
try:
listener = DTN._tcp_listen(self.my_ip,
self.dtn_port + random_n)
except:
random_n += 1
continue
break
conn_recv.send('%s %d %s' %
(self.sh, self.dtn_port + random_n, self.target))
data = conn_recv.recv(1024)
if data == EXIST_ERR:
logger.debug(
'DTN connection already exists between these two Site Managers'
)
return False
# wait for connection
listener.settimeout(5)
try:
conn_send, remote = listener.accept()
except socket.timeout:
logger.debug('timeout')
return False
# remote[0] is IP
# remote[1] is PORT
#conn_send = DTN._tcp_connect(remote[0], port)
if conn_send is not None:
# send my SH info
#conn_send.send('%s %s' % (self.sh, self.target))
#data = conn_send.recv(1024)
#if data == EXIST_ERR:
#logger.debug('DTN connection already exists between these two Site Managers')
#return
#else:
#logger.debug('Good')
# Ready
dtn_conn = DTNConnection(conn_send, conn_recv, self.sh, sh, tar,
self)
self.dtn[sh] = dtn_conn
if not self.last_hash.has_key(sh):
self.last_hash[sh] = ''
#if sh == SERVER_SH_INFO:
#self.server_connected = True
logger.info('New DTN connection established')
dtn_conn.start()
return True
return False
def connect_to_sm(self, ip, port, server_conn=False):
""" connect to specific IP:PORT
"""
logger.debug(
'Try to connect to Site Manager and establish DTN connection')
conn_send = DTN._tcp_connect(ip, port)
if conn_send is not None:
# send information
conn_send.send('%s %s\n' % (self.sh, self.target))
data = conn_send.recv(1024)
port_recv = 0
if data == EXIST_ERR:
logger.debug(
'DTN connection already exists between these two Site Managers'
)
return False
sh = data.split()[0]
port_recv = int(data.split()[1])
tar = ' '.join(data.split()[2:])
logger.debug('SH: %s, Port: %d, Target: %s' % (sh, port_recv, tar))
# check if site manager is connected
if self.dtn.has_key(sh) and self.dtn[sh] is not None:
conn_send.send(EXIST_ERR)
logger.debug(
'DTN connection already exists between these two Site Managers'
)
return False
else:
conn_send.send(SUCCESS_INFO)
# connect to ip using another port
conn_recv = DTN._tcp_connect(ip, port_recv)
if conn_recv is not None:
# Ready
dtn_conn = DTNConnection(conn_send,
conn_recv,
self.sh,
sh,
tar,
self,
server_conn=server_conn)
self.dtn[sh] = dtn_conn
if not self.last_hash.has_key(sh):
self.last_hash[sh] = ''
logger.info('New DTN connection established')
dtn_conn.start()
return True
return False
def stop_sh(self, sh):
if self.dtn[sh].has_key(sh):
self.dtn[sh].stop()
else:
logger.warning("no connection to %s" % sh)
def list_connected_sh(self):
return self.dtn.keys()
__credits__ = 'Python best'
__date__ = 'Sun Apr 3 15:29:43 2011'
__version__ = '0.1'
import sys
import time
from DTNDatabase import DTNDatabase
from DTNMessage import DTNMessage
# dtncmd HOST NODE {CMD}
if len(sys.argv) < 3:
print 'python dtncmd.py 001E8C6C9172 ls'
sys.exit()
t = int(time.time()*1000)
msg = '%d %s %d CMD {%s}' % (t, sys.argv[1], 30*24*60*60*1000, ' '.join(sys.argv[2:]))
m = DTNMessage()
m.handle(msg)
# TODO set message ip and port if possible
db = DTNDatabase('trapper')
db.insert_msg(m)
db.close()
print 'OK'
#for msg in db.select_all():
#print msg
