def connectionClosed(self):
self.__debugger.sessionConnectionClosed(self)
for runtime in self.__runtimes.values():
for thread in runtime.getThreads():
try: thread.cancel()
except: logger.logException()
def __close(self, handler):
self.__sockets.remove(handler)
try:
handler.setSocket(None)
except:
logger.logException()
def loadCommandsFromFile(path):
if not isfile(path): raise CommandError, "Not a regular file: %s" % path
if not access(path, R_OK): raise CommandError, "Can not read file: %s" % path
names = {}
try: execfile(path, names)
except SyntaxError:
logger.logException()
raise CommandError, "Syntax error while loading file: %s" % path
except:
logger.logException()
raise CommandError, "Failed to load file: %s" % path
commands = names.get("__commands__", {})
if not commands: raise CommandError, "File contained no commands: %s" % path
for name, data in commands.items():
valid = True
if type(name) != type(""): valid = False
if type(data) == type(()) and (len(data) != 2 or type(data[0]) != type("") or not callable(data[1])): valid = False
if type(data) != type(()) and not callable(data): valid = False
if not valid: raise CommandError, "File contained invalid commands: %s" % path
return commands.items()
def loadCommandsFromFile(path):
if not isfile(path): raise CommandError, "Not a regular file: %s" % path
if not access(path, R_OK):
raise CommandError, "Can not read file: %s" % path
names = {}
try:
execfile(path, names)
except SyntaxError:
logger.logException()
raise CommandError, "Syntax error while loading file: %s" % path
except:
logger.logException()
raise CommandError, "Failed to load file: %s" % path
commands = names.get("__commands__", {})
if not commands:
raise CommandError, "File contained no commands: %s" % path
for name, data in commands.items():
valid = True
if type(name) != type(""): valid = False
if type(data) == type(
()) and (len(data) != 2 or type(data[0]) != type("")
or not callable(data[1])):
valid = False
if type(data) != type(()) and not callable(data): valid = False
if not valid:
raise CommandError, "File contained invalid commands: %s" % path
return commands.items()
def connectionClosed(self):
self.__debugger.sessionConnectionClosed(self)
for runtime in self.__runtimes.values():
for thread in runtime.getThreads():
try: thread.cancel()
except: logger.logException()
def parseMessage(session, data):
type = data.parseUnsigned()
messageType = messageTypes.get(type, GenericMessage)
logger.logDebug("message", "Parsing message: %r" % messageType)
message = messageType(session)
try:
message.parse(data)
except Close:
raise
except:
logger.logException()
logger.logDebug("parsing-failed", data.getMessageText())
return message
def setReadBuffer(self, buffer):
logger.logDebug("send", "Buffer length (in): %d" % len(buffer))
while len(buffer) >= 12:
size = int(buffer[0:8], 16)
length = int(buffer[8:12], 16)
if len(buffer) - 12 < size: break
try: self.parseMessage(size, length, buffer[12:12 + size])
except Close: raise
except: logger.logException()
buffer = buffer[12 + size:]
logger.logDebug("send", "Buffer length (loop): %d" % len(buffer))
logger.logDebug("send", "Buffer length (out): %d" % len(buffer))
self.__rbuffer = buffer
def run(self, lines):
self.__socketmanager.start()
try:
self.__ui.start("Opera ECMAScript debugger\n")
except:
logger.logException()
logger.logFatal("UI failure, exiting.")
else:
lastLine = None
withCurrentSession, withCurrentRuntime = None, None
while not self.__quit:
if not lines:
try:
line = self.__ui.readLine(self.getPrompt,
TabCompleter(self))
if line is None:
self.__quit = True
break
if not line.strip():
if lastLine: line = lastLine
else: continue
else: lastLine = line.split(" ")[0]
lines = [line]
withCurrentSession, withCurrentRuntime = None, None
except:
logger.logException()
logger.logFatal("UI failure, exiting.")
break
try:
self.execute(lines, withCurrentSession, withCurrentRuntime)
except CommandError, error:
self.__ui.writeln(error[0])
except DebuggerError, error:
self.__ui.writeln(error[0])
except:
def parseAuxiliary(self, data):
logger.logDebug("parsing", str(data))
while data:
try:
type = data.parseUnsigned()
except:
logger.logDebug("auxbug", "While parsing: %d" % self.getType())
logger.logException()
auxiliaryType = auxiliaryTypes.get(type)
if not auxiliaryType:
logger.logWarning(
"Unknown auxiliary type: %d (skipping rest of message)" %
type)
while data:
data.parseAny()
else:
auxiliary = auxiliaryType(self)
auxiliary.parse(data)
self.__auxiliary.append(auxiliary)
def setReadBuffer(self, buffer):
logger.logDebug("send", "Buffer length (in): %d" % len(buffer))
while len(buffer) >= 12:
size = int(buffer[0:8], 16)
length = int(buffer[8:12], 16)
if len(buffer) - 12 < size: break
try:
self.parseMessage(size, length, buffer[12:12 + size])
except Close:
raise
except:
logger.logException()
buffer = buffer[12 + size:]
logger.logDebug("send", "Buffer length (loop): %d" % len(buffer))
logger.logDebug("send", "Buffer length (out): %d" % len(buffer))
self.__rbuffer = buffer
def run(self, lines):
self.__socketmanager.start()
try: self.__ui.start("Opera ECMAScript debugger\n")
except:
logger.logException()
logger.logFatal("UI failure, exiting.")
else:
lastLine = None
withCurrentSession, withCurrentRuntime = None, None
while not self.__quit:
if not lines:
try:
line = self.__ui.readLine(self.getPrompt, TabCompleter(self))
if line is None:
self.__quit = True
break
if not line.strip():
if lastLine: line = lastLine
else: continue
else: lastLine = line.split(" ")[0]
lines = [line]
withCurrentSession, withCurrentRuntime = None, None
except:
logger.logException()
logger.logFatal("UI failure, exiting.")
break
try: self.execute(lines, withCurrentSession, withCurrentRuntime)
except CommandError, error: self.__ui.writeln(error[0])
except DebuggerError, error: self.__ui.writeln(error[0])
except:
logger.logException()
self.__ui.writeln("Internal debugger error.")
else: raise CommandError, "%s: need current runtime." % self.__name
def getThread(self, needThread=True, needRuntime=True, needSession=True):
runtime = self.getRuntime(needRuntime, needSession)
if runtime:
thread = runtime.getCurrentThread()
if thread or not needThread: return thread
else: raise CommandError, "%s: need current thread." % self.__name
def __call__(self):
try: return self.__command(self)
except CommandError, e:
if not e[0].startswith("%s: " % self.getName()): raise CommandError, "%s: %s" % (self.getName(), e[0])
else: raise
except:
logger.logException()
raise CommandError, "%s: command failed." % self.__name
def loadCommandsFromFile(path):
if not isfile(path): raise CommandError, "Not a regular file: %s" % path
if not access(path, R_OK): raise CommandError, "Can not read file: %s" % path
names = {}
try: execfile(path, names)
except SyntaxError:
logger.logException()
raise CommandError, "Syntax error while loading file: %s" % path
except:
logger.logException()
raise CommandError, "Failed to load file: %s" % path
def run(self):
while not self.__closed:
pollobject = poll()
if sys.platform != "win32": pollobject.register(self.__rfd, POLLIN)
self.__lock.acquire()
for handler in self.__sockets:
if handler.getSocket() is not None:
flags = 0
if handler.getReadBuffer() is not None: flags = POLLIN
if handler.getWriteBuffer() is not None: flags = POLLOUT
pollobject.register(handler.getSocket().fileno(), flags)
if self.__listenSocket:
pollobject.register(self.__listenSocket.fileno(), POLLIN)
self.__lock.release()
if sys.platform == "win32": timeout = 0.1
else: timeout = None
while True:
try:
ready = pollobject.poll(timeout)
break
except error, (code, msg):
if code != EINTR: raise
self.__lock.acquire()
for fileno, flag in ready:
if sys.platform != "win32" and fileno == self.__rfd:
os.read(self.__rfd, 1024)
continue
if self.__listenSocket and fileno == self.__listenSocket.fileno():
logger.logDebug("connections", "New connection.")
newSocket, newAddress = self.__listenSocket.accept()
newSocket.setblocking(0)
newHandler = self.__listener.getSocketHandler(newSocket)
if newHandler:
self.__add(newHandler)
for handler in self.__sockets[:]:
if handler.getSocket() is not None and handler.getSocket().fileno() == fileno:
if flag == POLLIN:
try:
data = handler.getSocket().recv(16384)
if len(data) == 0: self.__close(handler)
else:
try:
handler.setReadBuffer(handler.getReadBuffer() + data)
except Close:
self.__close(handler)
except:
logger.logException()
self.__close(handler)
break
elif flag == POLLOUT:
try:
buffer = handler.getWriteBuffer()
written = handler.getSocket().send(buffer)
if written == len(buffer): handler.setWriteBuffer(None)
else: handler.setWriteBuffer(buffer[written:])
except:
logger.logException()
self.__close(handler)
break
else:
self.__close(handler)
break
self.__lock.release()
def __close(self, handler):
self.__sockets.remove(handler)
try: handler.setSocket(None)
except: logger.logException()
try: self.execute(lines, withCurrentSession, withCurrentRuntime)
except CommandError, error: self.__ui.writeln(error[0])
except DebuggerError, error: self.__ui.writeln(error[0])
except:
logger.logException()
self.__ui.writeln("Internal debugger error.")
self.__commandQueueLock.acquire()
try:
if self.__commandQueue: lines, withCurrentSession, withCurrentRuntime = self.__commandQueue.pop(0)
else: lines, withCurrentSession, withCurrentRuntime = [], None, None
finally: self.__commandQueueLock.release()
try: self.__ui.exit(self.__quit and "Good bye!" or None)
except: logger.logException()
try: self.__socketmanager.exit()
except: logger.logException()
if self.__quit: exit(0)
else: exit(1)
# Called by the "quit" command.
def quit(self):
self.__quit = True
# From SocketManagerListener: called by SocketManager when a new connection is established.
def getSocketHandler(self, socket):
session = Session()
connection = Connection(socket)
session.setDebugger(self)
def run(self):
while not self.__closed:
pollobject = poll()
if sys.platform != "win32": pollobject.register(self.__rfd, POLLIN)
self.__lock.acquire()
for handler in self.__sockets:
if handler.getSocket() is not None:
flags = 0
if handler.getReadBuffer() is not None: flags = POLLIN
if handler.getWriteBuffer() is not None: flags = POLLOUT
pollobject.register(handler.getSocket().fileno(), flags)
if self.__listenSocket:
pollobject.register(self.__listenSocket.fileno(), POLLIN)
self.__lock.release()
if sys.platform == "win32": timeout = 0.1
else: timeout = None
while True:
try:
ready = pollobject.poll(timeout)
break
except error, (code, msg):
if code != EINTR: raise
self.__lock.acquire()
for fileno, flag in ready:
if sys.platform != "win32" and fileno == self.__rfd:
os.read(self.__rfd, 1024)
continue
if self.__listenSocket and fileno == self.__listenSocket.fileno(
):
logger.logDebug("connections", "New connection.")
newSocket, newAddress = self.__listenSocket.accept()
newSocket.setblocking(0)
newHandler = self.__listener.getSocketHandler(newSocket)
if newHandler:
self.__add(newHandler)
for handler in self.__sockets[:]:
if handler.getSocket() is not None and handler.getSocket(
).fileno() == fileno:
if flag == POLLIN:
try:
data = handler.getSocket().recv(16384)
if len(data) == 0: self.__close(handler)
else:
try:
handler.setReadBuffer(
handler.getReadBuffer() + data)
except Close:
self.__close(handler)
except:
logger.logException()
self.__close(handler)
break
elif flag == POLLOUT:
try:
buffer = handler.getWriteBuffer()
written = handler.getSocket().send(buffer)
if written == len(buffer):
handler.setWriteBuffer(None)
else:
handler.setWriteBuffer(buffer[written:])
except:
logger.logException()
self.__close(handler)
break
else:
self.__close(handler)
break
self.__lock.release()
runtime = self.getRuntime(needRuntime, needSession)
if runtime:
thread = runtime.getCurrentThread()
if thread or not needThread: return thread
else: raise CommandError, "%s: need current thread." % self.__name
def __call__(self):
try:
return self.__command(self)
except CommandError, e:
if not e[0].startswith("%s: " % self.getName()):
raise CommandError, "%s: %s" % (self.getName(), e[0])
else:
raise
except:
logger.logException()
raise CommandError, "%s: command failed." % self.__name
def loadCommandsFromFile(path):
if not isfile(path): raise CommandError, "Not a regular file: %s" % path
if not access(path, R_OK):
raise CommandError, "Can not read file: %s" % path
names = {}
try:
execfile(path, names)
except SyntaxError:
logger.logException()
raise CommandError, "Syntax error while loading file: %s" % path
