def __init__(self, getopt=False, **keywords):
# all of the variables above become attributes of AliceConfig;
# we pick the value passed to this function (if there was one)
# or the default value otherwise
self.private_ip = None
for variable in alice_options.keys():
if variable in keywords:
self.__dict__[variable] = keywords[variable]
else:
self.__dict__[variable] = alice_options[variable][0]
if getopt:
self.get_options()
# Defaults remaining if getopt hasn't set things:
if self.interface == None and getopt:
self.interface = local_ip.get_interface()
log.info("interface is now %s", self.interface)
if self.force_private_ip and self.private_ip == None: # could have been set by getopt?
self.private_ip = force_private_ip
if self.private_ip == None:
self.private_ip = local_ip.get_local_ip(self.interface)
def __init__(self, getopt=False, **keywords):
# all of the variables above become attributes of AliceConfig;
# we pick the value passed to this function (if there was one)
# or the default value otherwise
self.private_ip = None
for variable in alice_options.keys():
if variable in keywords:
self.__dict__[variable] = keywords[variable]
else:
self.__dict__[variable] = alice_options[variable][0]
if getopt:
self.get_options()
# Defaults remaining if getopt hasn't set things:
if self.interface == None and getopt:
self.interface = local_ip.get_interface()
log.info("interface is now %s", self.interface)
if self.force_private_ip and self.private_ip == None: # could have been set by getopt?
self.private_ip = force_private_ip
if self.private_ip == None:
self.private_ip = local_ip.get_local_ip(self.interface)
def pcap_playback(self,
filename1,
ip_in_pcap1,
filename2,
ip_in_pcap2,
skew_pcap2,
playback_offset=0,
keep_archives=False,
force_public_ip1=False,
force_public_ip2=False):
ip = local_ip.get_local_ip()
localhost = "127.0.0.1"
if ip == localhost:
print "Can't run system tests without a non-localhost interface!!"
return 0
# We turn the packet filter off, because it would require extra waiting
# mechanisms for the new-members messages to arrive in time for the
# filtering mechanism. NTP is off because we don't need it. Cleaning has
# to be off because the timestamps in the pcaps are antique.
if not force_public_ip1:
public_ip1 = ip_in_pcap1
else:
public_ip1 = force_public_ip1
client1= Alice.Alice(linkobj=LocalAliceLink,\
config=AliceConfig(host="localhost", port=self.port, use_ntp=False,\
do_cleaning=False, seriousness=seriousness_threshold,\
filter_packets=False, keep_archives=keep_archives,\
force_public_ip=public_ip1, pcap_playback=filename1,\
force_private_ip=ip_in_pcap1, logfile=None, pcap_logdir=None))
if not force_public_ip2:
public_ip2 = ip_in_pcap2
else:
public_ip2 = force_public_ip2
client2= Alice.Alice(\
config=AliceConfig(host=ip, port=self.port, use_ntp=False,\
do_cleaning=False, seriousness=seriousness_threshold, skew=skew_pcap2,\
filter_packets=False, keep_archives=keep_archives,\
force_public_ip=public_ip2, pcap_playback=filename2,\
force_private_ip=ip_in_pcap2, logfile=None, \
pcap_logdir=None))
time.sleep(2)
# if we have a negative playback_offset, switch the order of events
if playback_offset < 0.0:
playback_offset *= -1
client1, client2 = client2, client1
client2.listener.start()
client2.start()
time.sleep(playback_offset)
client1.listener.start()
client1.start()
client1.listener.done.wait()
client2.listener.done.wait()
def setUp(self):
self.ip = local_ip.get_local_ip()
self.localhost = "127.0.0.1"
if self.ip == self.localhost:
print "Can't run testFlowManagement without a non-localhost interface"
return 0
self.port = random.randint(17000,18000)
self.server = Switzerland.SwitzerlandMasterServer(SwitzerlandConfig(port=self.port, keep_threads=True, logging=False, allow_fake_ips=True))
util.ThreadLauncher(self.server.accept_connections).start()
self.lh_config = AliceConfig(host="localhost", port=self.port)
self.net_config = AliceConfig(host=self.ip, port=self.port)
def setUp(self):
self.ip = local_ip.get_local_ip()
self.localhost = "127.0.0.1"
if self.ip == self.localhost:
print "Can't run testFlowManagement without a non-localhost interface"
return 0
self.port = random.randint(17000, 18000)
self.server = Switzerland.SwitzerlandMasterServer(
SwitzerlandConfig(port=self.port,
keep_threads=True,
logging=False,
allow_fake_ips=True))
util.ThreadLauncher(self.server.accept_connections).start()
self.lh_config = AliceConfig(host="localhost", port=self.port)
self.net_config = AliceConfig(host=self.ip, port=self.port)
def pcap_playback(self, filename1, ip_in_pcap1, filename2, ip_in_pcap2, skew_pcap2, playback_offset=0, keep_archives=False, force_public_ip1=False, force_public_ip2=False):
ip = local_ip.get_local_ip()
localhost = "127.0.0.1"
if ip == localhost:
print "Can't run system tests without a non-localhost interface!!"
return 0
# We turn the packet filter off, because it would require extra waiting
# mechanisms for the new-members messages to arrive in time for the
# filtering mechanism. NTP is off because we don't need it. Cleaning has
# to be off because the timestamps in the pcaps are antique.
if not force_public_ip1:
public_ip1 = ip_in_pcap1
else:
public_ip1 = force_public_ip1
client1= Alice.Alice(linkobj=LocalAliceLink,\
config=AliceConfig(host="localhost", port=self.port, use_ntp=False,\
do_cleaning=False, seriousness=seriousness_threshold,\
filter_packets=False, keep_archives=keep_archives,\
force_public_ip=public_ip1, pcap_playback=filename1,\
force_private_ip=ip_in_pcap1, logfile=None, pcap_logdir=None))
if not force_public_ip2:
public_ip2 = ip_in_pcap2
else:
public_ip2 = force_public_ip2
client2= Alice.Alice(\
config=AliceConfig(host=ip, port=self.port, use_ntp=False,\
do_cleaning=False, seriousness=seriousness_threshold, skew=skew_pcap2,\
filter_packets=False, keep_archives=keep_archives,\
force_public_ip=public_ip2, pcap_playback=filename2,\
force_private_ip=ip_in_pcap2, logfile=None, \
pcap_logdir=None))
time.sleep(2)
# if we have a negative playback_offset, switch the order of events
if playback_offset < 0.0:
playback_offset *= -1
client1, client2 = client2, client1
client2.listener.start()
client2.start()
time.sleep(playback_offset)
client1.listener.start()
client1.start()
client1.listener.done.wait()
client2.listener.done.wait()
def __init__(self, log, seriousness=0, accounting=True, private_ip=False):
"""Alice will connect to a server here, Switzerland will get a socket from
a listening SwitzerlandMasterServer"""
self.seriousness_threshold = seriousness
self.accounting = accounting
self.log = log
if private_ip:
log.debug("Setting private IP to %s" % private_ip)
self.private_ip = private_ip
else:
self.private_ip = local_ip.get_local_ip()
self.ready = threading.Event(
) # ready for the sender thread, currently set
# after we know if we're firewalled or not
self.sequence_no = 0 # sequence number for sent messages
# this is a lock for data that's shared between read and write threads
self.status_lock = threading.RLock()
self.bailing_out = False
self.bailout_waiting = None # if we get a bailout during handshake
self.closed = False
self.messages_in = 0
self.messages_out = 0
self.in_log = []
self.out_log = []
self.faking = False
self.hash_length = hash_length
# For handling acknowledgement messages and replies (which basically
# count as acks for most purposes)
self.ack_lock = threading.RLock()
self.timeout_period = 25 # the time we'll wait for an ack/reply
self.ack_timeouts = [
] # ordered list of (deadline, sequence_no, msg_type)
self.expected_acknowledgments = {} # callbacks for failed acks
self.last_deadline = 0 # the last ack deadline around
self.last_sent = time.time()
# this dict passes state from an outbound message that expects a reply
# to the handler for the inbound reply:
self.reply_data_table = {}
threading.Thread.__init__(self)
def __init__(self, log, seriousness=0, accounting=True, private_ip=False):
"""Alice will connect to a server here, Switzerland will get a socket from
a listening SwitzerlandMasterServer"""
self.seriousness_threshold=seriousness
self.accounting = accounting
self.log = log
if private_ip:
log.debug("Setting private IP to %s" % private_ip)
self.private_ip = private_ip
else:
self.private_ip = local_ip.get_local_ip()
self.ready=threading.Event() # ready for the sender thread, currently set
# after we know if we're firewalled or not
self.sequence_no = 0 # sequence number for sent messages
# this is a lock for data that's shared between read and write threads
self.status_lock = threading.RLock()
self.bailing_out = False
self.bailout_waiting = None # if we get a bailout during handshake
self.closed = False
self.messages_in = 0
self.messages_out = 0
self.in_log = []
self.out_log = []
self.faking = False
self.hash_length = hash_length
# For handling acknowledgement messages and replies (which basically
# count as acks for most purposes)
self.ack_lock= threading.RLock()
self.timeout_period = 25 # the time we'll wait for an ack/reply
self.ack_timeouts = [] # ordered list of (deadline, sequence_no, msg_type)
self.expected_acknowledgments = {} # callbacks for failed acks
self.last_deadline = 0 # the last ack deadline around
self.last_sent = time.time()
# this dict passes state from an outbound message that expects a reply
# to the handler for the inbound reply:
self.reply_data_table = {}
threading.Thread.__init__(self)
def testProtocolBasics(self):
print 80 * "-"
print " testProtocolBasics"
print 80 * "-"
client = AliceLink(threading.Event(), None, self.lh_config)
client.start()
client.ready.wait()
server_thread = self.server.threads[-1] # XXX not safe!!!
client.send_message("ping")
client.send_message("test", [1, 0, [1, 2, 4]])
client.send_message("test", [2, 0, [1, 2, 5]])
client.send_message("test", [3, 0, [1, 2, 6]])
client.send_message("ping")
client.send_message("ping")
client.send_message("ping")
time.sleep(1)
client.send_message("signoff")
time.sleep(1)
#print "Server in:"
#print "\n".join(map(repr, server_thread.in_log))
server_thread.status_lock.acquire()
# adding one for the firewall mss now in Protocol.setup(), and one more
# for the default new-members message in Switzerland.new_link() and its
# ack
self.assertEqual(server_thread.messages_in, 8 + 2)
self.assertEqual(server_thread.messages_out,
4 + 2) # just for the pings
self.assert_(server_thread.closed)
self.assertEqual(client.messages_out, 8 + 2)
self.assertEqual(client.messages_in, 4 + 2)
self.assert_(["test", 3, 0, [1, 2, 6]] in client.out_log)
self.assert_(["test", 3, 0, [1, 2, 6]] in server_thread.in_log)
if local_ip.get_local_ip() != "127.0.0.1":
#self.assert_(['you-are-firewalled', 0, '127.0.0.1'] in server_thread.out_log)
#self.assert_(['you-are-firewalled', 0, '127.0.0.1'] in client.in_log)
self.assert_(
['public-ip', 0, '127.0.0.1'] in server_thread.out_log)
self.assert_(['public-ip', 0, '127.0.0.1'] in client.in_log)
server_thread.status_lock.release()
def testProtocolBasics(self):
print 80 * "-"
print " testProtocolBasics"
print 80 * "-"
client = AliceLink(threading.Event(), None, self.lh_config)
client.start()
client.ready.wait()
server_thread = self.server.threads[-1] # XXX not safe!!!
client.send_message("ping")
client.send_message("test", [1,0,[1,2,4]])
client.send_message("test", [2,0,[1,2,5]])
client.send_message("test", [3,0,[1,2,6]])
client.send_message("ping")
client.send_message("ping")
client.send_message("ping")
time.sleep(1)
client.send_message("signoff")
time.sleep(1)
#print "Server in:"
#print "\n".join(map(repr, server_thread.in_log))
server_thread.status_lock.acquire()
# adding one for the firewall mss now in Protocol.setup(), and one more
# for the default new-members message in Switzerland.new_link() and its
# ack
self.assertEqual(server_thread.messages_in, 8+2)
self.assertEqual(server_thread.messages_out, 4+2) # just for the pings
self.assert_(server_thread.closed)
self.assertEqual(client.messages_out,8+2)
self.assertEqual(client.messages_in,4+2)
self.assert_(["test", 3, 0, [1,2,6]] in client.out_log)
self.assert_(["test", 3, 0, [1,2,6]] in server_thread.in_log)
if local_ip.get_local_ip() != "127.0.0.1":
#self.assert_(['you-are-firewalled', 0, '127.0.0.1'] in server_thread.out_log)
#self.assert_(['you-are-firewalled', 0, '127.0.0.1'] in client.in_log)
self.assert_(['public-ip', 0, '127.0.0.1'] in server_thread.out_log)
self.assert_(['public-ip', 0, '127.0.0.1'] in client.in_log)
server_thread.status_lock.release()