Rezzect/syncplay
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Added name of lagging watcher in rewind

Browse Source 
Some refactoring
This commit is contained in:
Uriziel 2012-09-27 00:15:02 +02:00
parent 4b5550fb24
commit 3f9bc25b30
2 changed files with 31 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
syncplay/client.py
View File

@ -439,7 +439,7 @@ class SyncplayClientManager(object):
if abs(diff) > 4: if abs(diff) > 4:
self.player.set_position(position) self.player.set_position(position)
#self.player.set_paused(True) #self.player.set_paused(True)
message = "Rewinded due to time difference" message = "Rewinded due to time difference with %s" % name
self.ui.showMessage(message) self.ui.showMessage(message)
if self.player_paused and not paused: if self.player_paused and not paused:

72
syncplay/server.py
View File

@ -12,10 +12,9 @@ from .network_utils import argumentCount, CommandProtocol
random.seed() random.seed()
CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
def random_chars(): def random_chars():
return ''.join(random.choice(CHARS) for _ in xrange(10)) chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
return ''.join(random.choice(chars) for _ in xrange(10))
def state(state): def state(state):
def decorator(f): def decorator(f):
@ -47,7 +46,7 @@ class SyncServerProtocol(CommandProtocol):
))) )))
def connectionLost(self, reason): def connectionLost(self, reason):
self.factory.remove_watcher(self) self.factory.removeWatcher(self)
def change_state(self, state): def change_state(self, state):
self.state = state self.state = state
@ -69,11 +68,11 @@ class SyncServerProtocol(CommandProtocol):
@state('init') @state('init')
@argumentCount(2, 3) @argumentCount(2, 3)
def iam(self, args): def iam(self, args):
name = re.sub('[^\w]','',args.pop(0)) name = str(args.pop(0).encode('ascii','replace'))
if not name: if not name:
self.dropWithError('Invalid nickname') self.dropWithError('Invalid nickname')
return return
room = re.sub('[^\w]','',args.pop(0)) room = str(args.pop(0).encode('ascii','replace'))
if not room: if not room:
self.dropWithError('Invalid room') self.dropWithError('Invalid room')
return return
@ -82,10 +81,11 @@ class SyncServerProtocol(CommandProtocol):
password = args.pop(0) password = args.pop(0)
if(self.factory.password <> password): if(self.factory.password <> password):
self.dropWithError('Wrong server password specified') self.dropWithError('Wrong server password specified')
return
else: else:
self.dropWithError('No password specified') self.dropWithError('No password specified')
return return
self.factory.add_watcher(self.__protocol, name, room) self.factory.addWatcher(self.__protocol, name, room)
self.__protocol.change_state('connected') self.__protocol.change_state('connected')
@ -99,10 +99,8 @@ class SyncServerProtocol(CommandProtocol):
position = int(position) position = int(position)
except ValueError: except ValueError:
self.dropWithError('Invalid arguments') self.dropWithError('Invalid arguments')
ctime /= 1000.0 ctime /= 1000.0
position /= 1000.0 position /= 1000.0
self.factory.seek(self.__protocol, counter, ctime, position) self.factory.seek(self.__protocol, counter, ctime, position)
@state('connected') @state('connected')
@ -113,9 +111,7 @@ class SyncServerProtocol(CommandProtocol):
ctime = int(ctime) ctime = int(ctime)
except ValueError: except ValueError:
self.dropWithError('Invalid arguments') self.dropWithError('Invalid arguments')
ctime /= 100000.0 ctime /= 100000.0
self.factory.pong_received(self.__protocol, value, ctime) self.factory.pong_received(self.__protocol, value, ctime)
@state('connected') @state('connected')
@ -123,7 +119,6 @@ class SyncServerProtocol(CommandProtocol):
def playing(self, args): def playing(self, args):
self.factory.playing_received(self.__protocol, args[0], args[1], args[2]) self.factory.playing_received(self.__protocol, args[0], args[1], args[2])
@state('connected') @state('connected')
@argumentCount(1) @argumentCount(1)
def room(self, args): def room(self, args):
@ -133,7 +128,7 @@ class SyncServerProtocol(CommandProtocol):
self.factory.broadcast(watcher, lambda receiver: receiver.watcher_proto.sender.send_room(watcher.name,watcher.room)) self.factory.broadcast(watcher, lambda receiver: receiver.watcher_proto.sender.send_room(watcher.name,watcher.room))
if not watcher.room in self.factory.paused: if not watcher.room in self.factory.paused:
self.factory.paused[watcher.room] = True self.factory.paused[watcher.room] = True
self.factory.remove_room_if_empty(old_room) self.factory.removeRoomIfEmpty(old_room)
@state('connected') @state('connected')
@argumentCount(0) @argumentCount(0)
@ -259,7 +254,7 @@ class SyncFactory(Factory):
def buildProtocol(self, addr): def buildProtocol(self, addr):
return SyncServerProtocol(self) return SyncServerProtocol(self)
def add_watcher(self, watcher_proto, name, room): def addWatcher(self, watcher_proto, name, room):
allnames = [] allnames = []
for watcher in self.watchers.itervalues(): for watcher in self.watchers.itervalues():
allnames.append(watcher.name.lower()) allnames.append(watcher.name.lower())
@ -275,11 +270,11 @@ class SyncFactory(Factory):
self.send_state_to(watcher) self.send_state_to(watcher)
self.send_ping_to(watcher) self.send_ping_to(watcher)
def remove_watcher(self, watcher_proto): def removeWatcher(self, watcher_proto):
watcher = self.watchers.pop(watcher_proto, None) watcher = self.watchers.pop(watcher_proto, None)
if not watcher: if not watcher:
return return
self.remove_room_if_empty(watcher.room) self.removeRoomIfEmpty(watcher.room)
watcher.active = False watcher.active = False
self.broadcast(watcher, lambda receiver: receiver.watcher_proto.sender.send_left(watcher.name)) self.broadcast(watcher, lambda receiver: receiver.watcher_proto.sender.send_left(watcher.name))
@ -287,28 +282,24 @@ class SyncFactory(Factory):
self.pause_change_time = None self.pause_change_time = None
self.pause_change_by = None self.pause_change_by = None
def remove_room_if_empty(self, room): def removeRoomIfEmpty(self, room):
room_user_count = sum(1 if watcher.room == room else 0 for watcher in self.watchers.itervalues()) room_user_count = sum(1 if watcher.room == room else 0 for watcher in self.watchers.itervalues())
if not room_user_count: if not room_user_count:
self.paused.pop(room) self.paused.pop(room)
def update_state(self, watcher_proto, counter, ctime, paused, position): def update_state(self, watcher_proto, counter, ctime, paused, position):
watcher = self.watchers.get(watcher_proto) watcher = self.watchers.get(watcher_proto)
if not watcher: if not watcher:
return return
curtime = time.time() curtime = time.time()
ctime += watcher.time_offset ctime += watcher.time_offset
if not paused: if not paused:
position += curtime - ctime position += curtime - ctime
watcher.paused = paused watcher.paused = paused
watcher.position = position watcher.position = position
watcher.max_position = max(position, watcher.max_position) watcher.max_position = max(position, watcher.max_position)
watcher.last_update = curtime watcher.last_update = curtime
watcher.counter = counter watcher.counter = counter
pause_changed = paused != self.paused[watcher.room] pause_changed = paused != self.paused[watcher.room]
if pause_changed and ( if pause_changed and (
not self.pause_change_by or not self.pause_change_by or
@ -320,26 +311,20 @@ class SyncFactory(Factory):
self.pause_change_by = watcher self.pause_change_by = watcher
else: else:
pause_changed = False pause_changed = False
position, _ = self.find_position(watcher.room)
position = self.find_position(watcher.room) self.send_state_to(watcher, position, curtime) # To jest kurwa bez sensu
self.send_state_to(watcher, position, curtime)
self.broadcast_room(watcher, lambda receiver: self.send_state_to(receiver, position, curtime) if pause_changed or (curtime-receiver.last_update_sent) > self.update_time_limit else False) self.broadcast_room(watcher, lambda receiver: self.send_state_to(receiver, position, curtime) if pause_changed or (curtime-receiver.last_update_sent) > self.update_time_limit else False)
def seek(self, watcher_proto, counter, ctime, position): def seek(self, watcher_proto, counter, ctime, position):
watcher = self.watchers.get(watcher_proto) watcher = self.watchers.get(watcher_proto)
if not watcher: if not watcher:
return return
#print watcher.name, 'seeked to', position
curtime = time.time() curtime = time.time()
ctime += watcher.time_offset ctime += watcher.time_offset
position += curtime - ctime position += curtime - ctime
watcher.counter = counter watcher.counter = counter
watcher.max_position = position watcher.max_position = position
self.send_state_to(watcher, position, curtime) self.send_state_to(watcher, position, curtime)
self.broadcast_room(watcher, lambda receiver: self.__do_seek(receiver, position, watcher, curtime)) self.broadcast_room(watcher, lambda receiver: self.__do_seek(receiver, position, watcher, curtime))
def __do_seek(self, receiver, position, watcher, curtime): def __do_seek(self, receiver, position, watcher, curtime):
@ -347,31 +332,30 @@ class SyncFactory(Factory):
receiver.watcher_proto.sender.send_seek(curtime-receiver.time_offset, position, watcher.name) receiver.watcher_proto.sender.send_seek(curtime-receiver.time_offset, position, watcher.name)
def send_state_to(self, watcher, position=None, curtime=None): def send_state_to(self, watcher, position=None, curtime=None):
minWatcher = None
if position is None: if position is None:
position = self.find_position(watcher.room) position, minWatcher = self.find_position(watcher.room)
minWatcher = minWatcher.name if minWatcher else None
if curtime is None: if curtime is None:
curtime = time.time() curtime = time.time()
ctime = curtime - watcher.time_offset ctime = curtime - watcher.time_offset
if self.pause_change_by: if self.pause_change_by:
watcher.watcher_proto.sender.send_state(watcher.counter, ctime, self.paused[watcher.room], position, self.pause_change_by.name) watcher.watcher_proto.sender.send_state(watcher.counter, ctime, self.paused[watcher.room], position, self.pause_change_by.name)
else: else:
watcher.watcher_proto.sender.send_state(watcher.counter, ctime, self.paused[watcher.room], position, None) watcher.watcher_proto.sender.send_state(watcher.counter, ctime, self.paused[watcher.room], position, minWatcher)
watcher.last_update_sent = curtime watcher.last_update_sent = curtime
def find_position(self, room): def find_position(self, room):
curtime = time.time() curtime = time.time()
try: minPos = 0.0
return min( minWatcher = None
max(watcher.max_position, watcher.position + (0 if self.paused[watcher.room] else curtime-watcher.last_update)) for watcher in self.watchers.itervalues():
for watcher in self.watchers.itervalues() if watcher.last_update and watcher.room == room:
if watcher.last_update and watcher.room == room watcherPos = max(watcher.max_position, watcher.position + (0 if self.paused[watcher.room] else curtime-watcher.last_update))
) minPos = watcherPos if watcherPos < min else min
except ValueError: minWatcher = watcher
#min() arg is an empty sequence return minPos, minWatcher
return 0.0
def pong_received(self, watcher_proto, value, ctime): def pong_received(self, watcher_proto, value, ctime):
watcher = self.watchers.get(watcher_proto) watcher = self.watchers.get(watcher_proto)
@ -409,7 +393,7 @@ class SyncFactory(Factory):
if not watcher.active: if not watcher.active:
return return
if (time.time()-watcher.last_update_sent) > 8: if (time.time()-watcher.last_update_sent) > 8:
self.remove_watcher(watcher.watcher_proto) self.removeWatcher(watcher.watcher_proto)
return return
chars = None chars = None