path: root/omegle/__init__.py

#!/usr/bin/python
# -*- vim: encoding: utf-8 -*-
# Yves Fischer, xapek.org 2009
import sys
import httplib
import urllib
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)