def __init__(self,
upstream_ip,
upstream_port,
enable_tls=False,
percentage_of_same_ips=0):
Thread.__init__(self)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.messageGenerator = MessageGenerator()
self.upstream_ip = upstream_ip
self.upstream_port = upstream_port
self.should_stop = False
self.enable_tls = enable_tls
self.current_xid = 1
self.percentage_of_same_ips = percentage_of_same_ips
self.last_sent_messages = []
self.matching_ips = []
self.non_matching_ips = []
for ip in itertools.product(range(231), range(3), range(256)):
self.matching_ips.append('{}.{}.0.{}'.format(ip[0], ip[1], ip[2]))
for ip in itertools.product(range(250, 256), range(63, 256),
range(256)):
self.non_matching_ips.append("{}.{}.{}.0".format(
ip[0], ip[1], ip[2]))
self.same_matching_ip = self.matching_ips[100]
self.same_non_matching_ip = self.non_matching_ips[100]
try:
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except (OSError, NameError):
pass
def __init__(self,
dpid,
warmup_time_s,
upstream_ip,
upstream_port,
initial_xid,
throughput_mode,
enable_tls=False):
Thread.__init__(self)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.dpid = dpid
self.currentXid = initial_xid
self.should_stop = self.getCurrentMicroSeconds() + 5000 * 1000000
self.results = []
self.warmup_time_s = warmup_time_s
self.upstream_ip = upstream_ip
self.upstream_port = upstream_port
self.messageGenerator = MessageGenerator()
self.last_packetin_sent = self.getCurrentMicroSeconds()
self.throughput_mode = throughput_mode
self.enable_tls = enable_tls
try:
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except (OSError, NameError):
pass
self.messages_to_send = [(2, Hello().pack())]
def generate_messages_for_user(user):
messageGenerator = MessageGenerator()
memberships = Membership.objects.filter(user=user)
for membership in memberships:
if (membership.messages_generated is False):
messageGenerator.generateMessages(membership.user, membership.project)
membership.messages_generated = True
membership.save()
def generate_messages(request, project_id):
messageGenerator = MessageGenerator()
project = Project.objects.get(pk = project_id)
Message.objects.filter(project = project_id).delete()
memberships = Membership.objects.filter(project = project_id)
for membership in memberships:
messageGenerator.generateMessages(membership.user, membership.project)
sms_messages = Message.objects.all().filter(project = project_id).order_by('send_at')
return render_to_response('sms/messages.html',
{ 'sms_messages' : sms_messages },
context_instance=RequestContext(request))
def __init__(self, upstream_ip, upstream_port, enable_tls=False):
Thread.__init__(self)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.messageGenerator = MessageGenerator()
self.upstream_ip = upstream_ip
self.upstream_port = upstream_port
self.should_stop = False
self.enable_tls = enable_tls
self.current_xid = 1
try:
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except (OSError, NameError):
pass
class PacketInEchoGenerator(Thread):
def __init__(self, upstream_ip, upstream_port, enable_tls=False):
Thread.__init__(self)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.messageGenerator = MessageGenerator()
self.upstream_ip = upstream_ip
self.upstream_port = upstream_port
self.should_stop = False
self.enable_tls = enable_tls
self.current_xid = 1
try:
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except (OSError, NameError):
pass
def run(self):
if self.enable_tls:
context = ssl.SSLContext(ssl.PROTOCOL_TLS)
context.check_hostname = False
socket = context.wrap_socket(self.socket,
server_hostname=self.upstream_ip)
else:
socket = self.socket
try:
socket.connect((self.upstream_ip, self.upstream_port))
print("flowmodgenerator connected!")
except socket.error as e:
if e.errno != 115 and e.errno != 36:
print("failed to connect: " + str(e))
return
socket.setblocking(False)
time.sleep(1)
while True:
ready_to_read, ready_to_write, error = select.select([socket],
[socket], [],
TIMEOUT_S)
if ready_to_write:
message = self.messageGenerator.generate_benchmark_message(
self.current_xid)
socket.sendall(message)
self.current_xid += 1
if self.should_stop: break
time.sleep(0.01)
socket.close()
def stop(self):
self.should_stop = True
def testInit(self):
msgGen = MessageGenerator(msgBurstSize=9, msgGroupIdRange=10)
self.assertIsInstance(msgGen, MessageGenerator)
msgGen = MessageGenerator(msgBurstSize=9)
self.assertIsInstance(msgGen, MessageGenerator)
msgGen = MessageGenerator(msgGroupIdRange=10)
self.assertIsInstance(msgGen, MessageGenerator)
with self.assertRaises(AssertionError):
msgGen = MessageGenerator(msgGroupIdRange=2.3)
with self.assertRaises(AssertionError):
msgGen = MessageGenerator(msgGroupIdRange=-1)
with self.assertRaises(AssertionError):
msgGen = MessageGenerator(msgBurstSize=2.3)
with self.assertRaises(AssertionError):
msgGen = MessageGenerator(msgBurstSize=-1)
def setUp(self):
## Test generator 1
self.g1 = msgGen = MessageGenerator(msgBurstSize=5, msgGroupIdRange=5)
## Test generator 2
self.g2 = msgGen = MessageGenerator(msgBurstSize=10,
msgGroupIdRange=10)
class FlowModGenerator(Thread):
def __init__(self,
upstream_ip,
upstream_port,
enable_tls=False,
percentage_of_same_ips=0):
Thread.__init__(self)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.messageGenerator = MessageGenerator()
self.upstream_ip = upstream_ip
self.upstream_port = upstream_port
self.should_stop = False
self.enable_tls = enable_tls
self.current_xid = 1
self.percentage_of_same_ips = percentage_of_same_ips
self.last_sent_messages = []
self.matching_ips = []
self.non_matching_ips = []
for ip in itertools.product(range(231), range(3), range(256)):
self.matching_ips.append('{}.{}.0.{}'.format(ip[0], ip[1], ip[2]))
for ip in itertools.product(range(250, 256), range(63, 256),
range(256)):
self.non_matching_ips.append("{}.{}.{}.0".format(
ip[0], ip[1], ip[2]))
self.same_matching_ip = self.matching_ips[100]
self.same_non_matching_ip = self.non_matching_ips[100]
try:
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except (OSError, NameError):
pass
def recent_same_message_percentage(self):
if len(self.last_sent_messages) == 0: return 0
number_of_same_messages = self.last_sent_messages.count(True)
return number_of_same_messages * 100 / len(self.last_sent_messages)
def get_next_ip(self, matching):
next_message_is_same = True
if self.recent_same_message_percentage(
) >= self.percentage_of_same_ips or self.percentage_of_same_ips == 0:
next_message_is_same = False
if self.percentage_of_same_ips == 100:
next_message_is_same = True
self.last_sent_messages.append(next_message_is_same)
if len(self.last_sent_messages) > 100: del self.last_sent_messages[0]
if next_message_is_same:
if matching:
return self.same_matching_ip
else:
return self.same_non_matching_ip
else:
if matching:
return self.matching_ips.pop(0)
else:
return self.non_matching_ips.pop(0)
def run(self):
if self.enable_tls:
context = ssl.SSLContext(ssl.PROTOCOL_TLS)
context.check_hostname = False
socket = context.wrap_socket(self.socket,
server_hostname=self.upstream_ip)
else:
socket = self.socket
try:
socket.connect((self.upstream_ip, self.upstream_port))
print("flowmodgenerator connected!")
except socket.error as e:
if e.errno != 115 and e.errno != 36:
print("failed to connect: " + str(e))
return
socket.setblocking(False)
time.sleep(1)
while True:
ready_to_read, ready_to_write, error = select.select([socket],
[socket], [],
TIMEOUT_S)
if ready_to_write:
src_ip = self.get_next_ip(self.current_xid % 2 == 0)
message = self.messageGenerator.generate_flow_mod_message(
xid=self.current_xid, srcIpAddress=src_ip)
socket.sendall(message)
self.current_xid += 1
if self.should_stop: break
time.sleep(0.01)
socket.close()
def stop(self):
self.should_stop = True
class Switch(Thread):
def __init__(self,
dpid,
warmup_time_s,
upstream_ip,
upstream_port,
initial_xid,
throughput_mode,
enable_tls=False):
Thread.__init__(self)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.dpid = dpid
self.currentXid = initial_xid
self.should_stop = self.getCurrentMicroSeconds() + 5000 * 1000000
self.results = []
self.warmup_time_s = warmup_time_s
self.upstream_ip = upstream_ip
self.upstream_port = upstream_port
self.messageGenerator = MessageGenerator()
self.last_packetin_sent = self.getCurrentMicroSeconds()
self.throughput_mode = throughput_mode
self.enable_tls = enable_tls
try:
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except (OSError, NameError):
pass
self.messages_to_send = [(2, Hello().pack())]
def on_message_received(self, data):
receive_time = self.getCurrentMicroSeconds()
try:
msg = unpack_message(data)
except:
print("received invalid message!")
return
print("received " + str(msg.header.message_type) + " " +
str(msg.header.xid))
if msg.header.message_type == Type.OFPT_PACKET_OUT or msg.header.message_type == Type.OFPT_ECHO_REPLY:
if receive_time - self.start_time > self.warmup_time_s * 1000000 and receive_time < self.should_stop:
self.results.append([receive_time, msg.header.xid])
if not self.throughput_mode and msg.header.xid == self.currentXid:
self.send_next()
elif msg.header.message_type == Type.OFPT_FEATURES_REQUEST:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_features_reply_message(
msg.header.xid, self.dpid)))
elif msg.header.message_type == Type.OFPT_SET_CONFIG:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_config_reply_message(
msg.header.xid, msg.flags, msg.miss_send_len)))
elif msg.header.message_type == Type.OFPT_ECHO_REQUEST:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_echo_reply_message(
msg.header.xid)))
elif msg.header.message_type == Type.OFPT_STATS_REQUEST:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_stats_reply_message()))
elif msg.header.message_type == Type.OFPT_VENDOR:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_vendor_reply_message(
msg.header.xid)))
if msg.header.message_type != Type.OFPT_PACKET_OUT and msg.header.message_type != Type.OFPT_ECHO_REPLY:
print("received " + str(msg.header.message_type) + " after " +
str((self.getCurrentMicroSeconds() - self.start_time) /
1000000) + "s")
def getCurrentMicroSeconds(self):
return int(datetime.timestamp(datetime.now()) * 1000000)
def send_next(self):
# time to establish openflow channel
if self.getCurrentMicroSeconds() - self.start_time < 5 * 1000000:
return
self.currentXid += 50
self.messages_to_send.append(
(self.currentXid,
self.messageGenerator.generate_benchmark_message(
self.currentXid)))
def run(self):
if self.enable_tls:
context = ssl.SSLContext(ssl.PROTOCOL_TLS)
#context.load_cert_chain(certfile="/home/daniel/ma-daniel-geiger/floodlight/tls/client.crt",
# keyfile="/home/daniel/ma-daniel-geiger/floodlight/tls/client.key")
#context.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1 | ssl.CERT_OPTIONAL
context.check_hostname = False
socket = context.wrap_socket(self.socket,
server_hostname=self.upstream_ip)
else:
socket = self.socket
try:
socket.connect((self.upstream_ip, self.upstream_port))
print(self.dpid + " connected!")
except Exception as e:
print("failed to connect: " + str(e))
return
socket.setblocking(False)
time.sleep(1)
self.start_time = self.getCurrentMicroSeconds()
while True:
ready_to_read, ready_to_write, error = select.select([socket],
[socket], [],
TIMEOUT_S)
if ready_to_read:
try:
data = socket.recv(BUFFER_SIZE)
except ssl.SSLWantReadError:
print("SSLWantReadError")
continue
self.on_message_received(data)
elif ready_to_write:
if len(self.messages_to_send) > 0:
xid, message_to_send = self.messages_to_send.pop(0)
if self.last_packetin_sent - self.start_time > self.warmup_time_s * 1000000 and self.last_packetin_sent < self.should_stop:
self.results.append(
[self.getCurrentMicroSeconds(), xid])
socket.sendall(message_to_send)
print("sent " + str(xid))
self.last_packetin_sent = self.getCurrentMicroSeconds()
if self.throughput_mode:
threading.Thread(target=self.send_next).start()
else:
print("socket error!")
if self.getCurrentMicroSeconds() - self.should_stop > 10000000:
break
if not self.throughput_mode and self.getCurrentMicroSeconds(
) - self.last_packetin_sent > 2000000:
print("timeout!")
self.send_next()
socket.close()
def get_results(self):
return self.results
def stop(self):
self.should_stop = self.getCurrentMicroSeconds()
