-
Notifications
You must be signed in to change notification settings - Fork 0
/
server_dep3.py
175 lines (140 loc) · 5.81 KB
/
server_dep3.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
import socket
import sys
import time
import threading
import Queue
import SocketServer
import simplejson as json
padding = "blankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblankblanknkblankblankblankblankblankblankblankblankblankblankblankblanknkblankblankblankblankblankblankblank"
bQueue = Queue.Queue()
mQueue = Queue.Queue()
bSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
SEGMENTS = 20
PACKAGES = 150
# Thread that handles broadcasting of messages
# Runs of off the bQueue
class ThreadBroadcast(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self.queue = queue
def run(self):
while True:
msg = self.queue.get()
bSocket.sendto(msg.toString(1*msg.quality), (msg.dest, 5006))
self.queue.task_done()
# Thread that handles listening of messages
# Creates a thread that runs the UDPSocket Server
# Socket server handles the actual incoming messages
class ThreadListen(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
def run(self):
server = SocketServer.UDPServer((socket.gethostname(), 9999), MyUDPHandler)
server.serve_forever()
# UDP Server that listens for incoming messages
# Once a message is received, it is offloaded to another thread for processing
class MyUDPHandler(SocketServer.BaseRequestHandler):
def handle(self):
data = self.request[0].strip()
mQueue.put(data)
# Thread the processes incoming messages
# Runs off of mQueue
class ThreadMessageHandle(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self.queue = queue
def run(self):
while True:
data = self.queue.get()
msg = Message.fromString(data)
server.checkMessage(msg)
self.queue.task_done()
# see client_dep2.py for info
class Message(object):
def __init__(self):
self.type = 0
self.time = time.time()
self.dest = ""
self.segment = -1
self.quality = -1
self.src = socket.gethostname()
self.message = ""
self.number = -1
def toString(self,amount):
fill = ""
for i in xrange(amount):
fill += padding
return_string = '{"type":"'+str(self.type)+'","segment":"'+str(self.segment)+'","quality":"'+str(self.quality)+'","message":"'+self.message+'","src":"'+self.src+'","number":"'+ str(self.number)+'","fill":"'+fill+'"}'
return return_string
@classmethod
def fromString(self,data):
msg = Message()
jsonObject = json.loads(data)
msg.segment = int(jsonObject['segment'])
msg.quality = int(jsonObject['quality'])
msg.type = int(jsonObject['type'])
msg.message = jsonObject['message']
msg.src = jsonObject['src']
msg.number = jsonObject['number']
return msg
# Simple client object that is used by the server to keep track of who it is broadcasting to
class Client(object):
def __init__(self,hostname):
self.hostname = hostname # hostname of the client
self.quality = 1 #current quality of the client
# Server object
class Server(object):
def __init__(self):
self.clients = [] #stores the clients of the server
self.current_segment = 0
def run(self):
for h in xrange(len(self.clients)): #loops through all client
client = self.clients[h]
dest = client.hostname
for i in xrange(SEGMENTS): # loops through each segment
quality = client.quality # set quality to a separate variable instead of using object variable to prevent the value changing mid segment
for j in xrange(PACKAGES): # loops through each packet
start_time = time.time()
# create message to send
msg = Message()
msg.dest = dest
msg.segment = i
msg.quality = quality
msg.number = j
bQueue.put(msg)
while (time.time() - start_time < float(1)/float(PACKAGES)): # wait for a specific time so 1 segment takes 1 second
pass
time.sleep(10)
# Checks the incoming message from a client
def checkMessage(self,msg):
print "Received " + str(msg.type) + " " + str(msg.src) + " " + str(msg.message)
if int(msg.type) == 1: # if type == 1, it is a message to change quality
for x in range(len(self.clients)): # loop through all the clients looking for a client that matches the message's origin
if self.clients[x].hostname == msg.src:
if (int(msg.message) > 0 and int(msg.message) < 5): #if the quality is valid, set the client's quality to the quality set within the message
self.clients[x].quality = int(msg.message)
# Create 20 threads to handle incoming messages
for i in range(20):
t = ThreadMessageHandle(mQueue)
t.setDaemon(True)
t.start()
# Create 50 threads to handle broadcasting messages
for i in range(50):
t = ThreadBroadcast(bQueue)
t.setDaemon(True)
t.start()
# Create one thread to run the UDP server off the main thread
for i in range(1):
t = ThreadListen()
t.setDaemon(True)
t.start()
server = Server()
# loop through the arguments,where each argument is a client
for x in range(1,len(sys.argv)):
client = Client(sys.argv[x])
server.clients.append(client)
start = time.time()
server.run()
print time.time() - start
# wait to make sure no packets are left to be sent
time.sleep(10)