blah

git-svn-id: http://xapek.org/svn/common/omegle@1480 d0e8fea9-7529-0410-93fb-d39fd5b9c1dd

1 files changed, 0 insertions, 269 deletions

diff --git a/omegle.py b/omegle.py
deleted file mode 100644
index 528b629..0000000
--- a/omegle.py
+++ /dev/null
@@ -1,269 +0,0 @@
-import sys
-import httplib
-import socket
-import urllib
-import time
-import json
-import logging
-from threading import Thread, Lock, Event
-
-__all__ = ['OmegleChat', 'get_count']
-
-class Timer(Thread):
-	"""
-	This class defines a object that calls the function object
-	given as func every given interval in a Thread and stops immedietly after
-	stop() has been called
-	"""
-	def __init__(self,func,interval=0.50):
-		Thread.__init__(self)
-		self.logger = logging.getLogger(__name__ + "." + self.__class__.__name__)
-		self.func = func
-		self.interval = interval
-
-		self.running = False
-
-		self.event = Event()
-
-	def run(self):
-		self.running = True
-		while self.running:
-			self.func()
-			self.event.wait(self.interval)
-			self.event.clear()
-		self.logger.debug("self.running == False")
-
-	def stop(self):
-		""" XXX break func() ? """
-		self.running = False
-		self.event.set()
-
-class RESTClient(object):
-	"""Some routines used for calling the webservice"""
-	headers = {
-		"Content-type": "application/x-www-form-urlencoded; charset=utf-8",
-		"Accept": "application/json"
-	}
-	def __init__(self,host,http_debuglevel=0):
-		self.host=host
-		self.conn_lock = Lock()
-		self.conn = httplib.HTTPConnection(host)
-		self.conn.set_debuglevel(http_debuglevel)
-	
-	def request(self,method,path,params):
-		self.conn_lock.acquire()
-		try:
-			headers = RESTClient.headers.copy()
-			headers['Host'] = self.host
-			headers['Content-Length'] = str(len(params))
-			self.conn.request(method,path,params,headers)
-			resp = self.conn.getresponse()
-		finally:
-			self.conn_lock.release()
-		return resp
-
-
-class OmegleChat(RESTClient):
-	def __init__(self,poll_interval=0.5,name="",host="omegle.com"):
-		self.name = name
-		self.poll_interval=poll_interval
-		RESTClient.__init__(self,host)
-
-		self.timer = Timer(self._events, poll_interval)
-		self.logger = logging.getLogger(__name__ + "." + self.__class__.__name__ + name)
-		self.is_confirmed = False #after getting a connection confirm
-		self.is_connected = False #after having self.id
-
-	def start(self):
-		"""Starts a chat session. You have to wait until 
-		is_confirmed is set (or use on_connect)"""
-		self.logger.debug("/start host=%s" % self.host)
-		if self.is_connected:
-			self.logger.error("Already connected")
-			raise Exception("Already connected")
-		resp = RESTClient.request(self, "POST", "/start", {})
-		body=resp.read()
-		id=body.split("\"")
-		if id.__len__() == 3:
-			self.id = id[1]
-			self.logger.info("Connected id=%s" % self.id)
-			#start /events polling
-			self.is_connected = True
-			self.timer = Timer(self._events, self.poll_interval)
-			self.timer.start()
-		else:
-			self.logger.error("Bad response: %s" % body)
-			raise Exception("Bad response: %s" % body)
-
-	def disconnect(self):
-		"""Close a chat session."""
-		self.logger.debug("disconnect()")
-		self.is_confirmed = False
-		self.timer.stop()
-		if self.is_connected:
-			r = RESTClient.request(self,"POST", "/disconnect", urllib.urlencode({'id': self.id}))
-			body = r.read()
-			self.logger.debug("/disconnect sent. Read: %s" % body)
-			if body == "win":
-				self.is_connected = False
-				self.id = None
-				self.conn.close()
-			else:
-				raise Exception("/disconnect; Bad response: %s" % body)
-
-	def _events(self):
-		"""does use its own "HTTPConnection" because its called async from a thread"""
-		conn = httplib.HTTPConnection(self.host)
-		params = urllib.urlencode({'id' : self.id})
-		headers = OmegleChat.headers.copy()
-		headers['Host'] = "omegle.com"
-		headers['Content-Length'] = str(len(params))
-		conn.request("POST", 
-			"/events", 
-			params,
-			OmegleChat.headers)
-		r=conn.getresponse()
-		body=r.read()
-		self._dispatch_event(conn,body)
-		conn.close()
-
-	def send(self,msg):
-		"""Send a message to the Stranger
-		Arguments:
-		msg -- the message - in utf8
-		"""
-		#if a raw string given, assume its utf8
-		if msg.__class__ == str:
-			try:
-				msg = msg.decode("utf8")
-			except UnicodeDecodeError:
-				pass
-		#convert utf8 to RAW-utf8
-		try:
-			msg = msg.encode("utf8")
-		except UnicodeEncodeError,e:
-			self.logger.critical(e)
-
-		if not self.is_confirmed:
-			self.logger.error("Cant send message if not is_confirmed")
-			return ###XXX raise??
-
-		params = {'id':self.id,'msg':msg}
-		params = urllib.urlencode(params)
-		try:
-			r = RESTClient.request(self,"POST","/send",params)
-		except Exception,e:
-			self.logger.error("Error by /send request: %s" % e)
-			raise e
-			return
-
-		body = r.read()
-		if body != "win":
-			self.logger.error("/send; Bad response %s" % body)
-			raise Exception("/send; Bad response %s" % body)
-
-	def typing(self):
-		"""Notify the Stranger that youre typing a message"""
-		r = RESTClient.request(self, "POST", "/typing", urllib.urlencode({'id':self.id}))
-		body = r.read()
-		if body != "win":
-			self.logger.error("/typing; Bad response %s" % body)
-			raise Exception("/typing; Bad response %s" % body)
-
-	def stopped_typing(self):
-		"""Notify the Stranger that youre stopped typing"""
-		r = RESTClient.request(self, "POST", "/stoppedtyping", urllib.urlencode({'id':self.id}))
-		body = r.read()
-		if body != "win":
-			self.logger.error("/stoppedtyping; Bad response %s" % body)
-			raise Exception("/stoppedtyping; Bad response %s" % body)
-
-	def _dispatch_event(self,conn,body):
-		try:
-			data_set=json.read(body.decode("utf8"))
-			if not data_set:
-				self.on_idle()
-				return
-			for data in data_set:
-				if not self.is_connected: #in case of disconnect
-					break #stop dispatching messages
-				if data[0] == "typing":
-					self.on_typing()
-				elif data[0] == "gotMessage" and data.__len__() == 2:
-					self.on_message(data[1])
-				elif data[0] == "connected":
-					self.is_confirmed = True
-					self.on_connect()
-				elif data[0] == "strangerDisconnected":
-					self.is_confirmed = False
-					self.is_connected = False
-					self.timer.stop()
-					self.on_disconnect()
-				elif data[0] == "stoppedTyping":
-					self.on_stopped_typing()
-				elif data[0] == "waiting":
-					self.on_wait()
-				else:
-					self.logger.error("Unknown JSON Data: %s" % body)
-		except json.ReadException:
-			self.logger.error("Json ReadException. Body: %s" % body)
-
-	def on_idle(self):
-		self.logger.debug("event: no data received")
-	def on_message(self,message):
-		"""To be overwritten"""
-		self.logger.info("<<< %s" % message)
-	def on_connect(self):
-		"""To be overwritten"""
-		self.logger.info("Connection confirmed")
-	def on_typing(self):
-		"""To be overwritten"""
-		self.logger.info("Stranger is typing")
-	def on_stopped_typing(self):
-		"""To be overwritten"""
-		self.logger.info("Stranger stopped typing")
-	def on_disconnect(self):
-		"""To be overwritten"""
-		self.logger.info("Stranger Disconnectet")
-	def on_wait(self):
-		"""To be overwritten"""
-		self.logger.info("Server sent [\"waiting\"]")
-
-def get_count(host="omegle.com"):
-	"""Return the number of current online omegle users"""
-	headers = {
-		"Host" : host,
-		"Content-type": "application/x-www-form-urlencoded; charset=utf-8",
-		"Accept": "application/json"}
-	conn = httplib.HTTPConnection(host)
-	conn.request("GET", 
-		"/count", 
-		urllib.urlencode({}),
-		headers)
-	body = conn.getresponse().read()
-	conn.close()
-	return body
-
-if __name__ == "__main__":
-	"""Extrem einfacher Chat-Client"""
-	logging.basicConfig(level=logging.INFO)
-	print "Lets chat. Type \"quit\" to disconnect"
-	chat = OmegleChat()
-	def exit():
-		OmegleChat.on_disconnect(chat)
-		sys.exit(0)
-	chat.on_disconnect = exit
-	chat.start()
-	while 1==1:
-		try:
-			cmd=sys.stdin.readline().strip()
-		except KeyboardInterrupt:
-			chat.disconnect()
-			break
-		if cmd=="quit":
-			chat.disconnect()
-			break
-		else:
-			print ">>> %s" % cmd
-			chat.send(cmd)
-