Add support to consume messages from specific partitions

Currently the kafka SimpleConsumer consumes messages from all
partitions. This commit will ensure that data is consumed only
from partitions specified during init
Support for async producer

The Java/Scala Kafka client supports a mechanism for sending
messages asynchronously by using a queue and a thread.
Messages are put on the queue and the worker thread keeps sending
it to the broker.

This ticket implements this feature in python
We use multiprocessing instead of threads to send the messages
Merge branch 'master' into asyncproducer

Conflicts:
	kafka/producer.py
Merge branch 'master' into partition
Add ack support for synchronous producer

Add support for two options in the producer - req_acks and ack_timeout
The acks, if any, are passed to the caller directly
Update README with new options
Fix import errors
Make the default case as 'ack on local write'

Also, ensure that the case of 'no-acks' works fine
In conn.send(), do not wait for the response. Wait for it only on
conn.recv(). This behaviour is fine now since the connection is not
shared among consumer threads etc.
Add exports in __init__
Add support for multi-process consumer
Minor bug fix
Added more documentation and clean up duplicate code
Added the modules in __init__.py
Implement blocking get_messages for SimpleConsumer

The implementation is done by using simple options to
Kafka Fetch Request

Also in the SimpleConsumer iterator, update the offset before the
message is yielded. This is so that the consumer state is not lost
if certain cases.
For eg: the message is yielded and consumed by the caller,
but the caller does not come back into the generator again.
The message will be consumed but the status is not updated in
the consumer
Added some comments about message state
Got MultiProcessConsumer working

Other changes
* Put a message size restriction on the shared queue
  - to prevent message overload
* Wait for a while after each process is started (in constructor)
* Wait for a while in each child if the consumer does not return any messages
  Just to be nice to the CPU.
* Control the start event more granularly - this prevents infinite loops
  if the control does not return to the generator. For eg:
  for msg in consumer:
      assert False
* Update message status before yield
Merge branch 'master' into asyncproducer
Merge branch 'master' into partition

Conflicts:
	kafka/consumer.py
Change auto_commit to False in SimpleConsumer

Also start a change log for important stuff like this

Closes #34
Fixing link in CHANGES.md