def imap_to_campfire(imap_login, campfire_login):
"""
Checks IMAP inbox and posts info to Campfire.
"""
# connect to IMAP
i = imaplib.IMAP4_SSL(imap_login['server'])
i.login(imap_login['user'], imap_login['password'])
# connect to Campfire
c = Campfire(campfire_login['subdomain'])
c.login(campfire_login['user'], campfire_login['password'])
room = c.find_room_by_name(campfire_login['room'])
typ, data = i.select("INBOX")
msg_total = int(data[0])
#import pdb; pdb.set_trace()
for msg_id in range(1, msg_total+1):
typ, data = i.fetch(msg_id, "(BODY[HEADER.FIELDS (TO SUBJECT)])")
#retrieve relative part of message
msg_info = data[0][1]
#archive message
i.store(msg_id, "+FLAGS", r'(\Deleted)')
#post to Campfire
room.paste("*New Message*\r\n%s" % msg_info)
i.close()
i.logout()
c.logout()
class CampfireTest(unittest.TestCase):
def setUp(self):
self.response = utils.MockResponse()
self.campfire = Campfire('foobar')
response = self.response
HTTPConnection.request = lambda self, m, l, b, h: None
HTTPConnection.getresponse = lambda self: response
httplib2.Response = utils.MockHttplib2Response
def test_creation(self):
self.assertEqual('foobar', self.campfire.subdomain)
self.assertEqual(False, self.campfire.logged_in)
self.assertEqual(None, self.campfire.cookie)
uri = 'http://foobar.campfirenow.com'
self.assertEqual(urlparse(uri), self.campfire.uri)
self.assertEqual(self.campfire._uri_for(), '%s/' % uri)
def test_ssl(self):
campfire = Campfire('foobar', True)
uri = 'https://foobar.campfirenow.com'
self.assertEqual(urlparse(uri), campfire.uri)
def test_verify_response_success(self):
self.response.status = 200
self.assertEqual(True, self.campfire._verify_response(self.response,
success=True))
def test_verify_response_redirect_true(self):
self.response.status = 302
self.assertEqual(True, self.campfire._verify_response(self.response,
redirect=True))
def test_verify_response_redirect_false(self):
self.response.status = 200
self.assertEqual(False, self.campfire._verify_response(self.response,
redirect=True))
def test_verify_response_redirect_to(self):
self.response.status = 304
self.assertEqual(True, self.campfire._verify_response(self.response,
redirect_to='/foobar'))
def test_verify_response_redirect_to_without_redirect(self):
self.response.status = 200
self.assertEqual(False, self.campfire._verify_response(self.response,
redirect_to='/foobar'))
def test_verify_response_redirect_to_wrong_path(self):
response = utils.MockResponse()
response.headers['location'] = '/baz'
response.status = 304
self.assertEqual(False, self.campfire._verify_response(response,
redirect_to='/foobar'))
def test_prepare_request(self):
headers = self.campfire._prepare_request()
self.assert_('User-Agent' in headers)
self.assert_(headers['User-Agent'].startswith('Pinder/'))
headers = self.campfire._prepare_request(ajax=True)
self.assert_('X-Requested-With' in headers)
self.campfire.cookie = 'cookie'
headers = self.campfire._prepare_request()
self.assertEqual(headers['cookie'], self.campfire.cookie)
def test_perform_request(self):
response = self.campfire._perform_request('GET', '')
self.assertEqual(self.campfire.cookie, response.getheader('set-cookie'))
def test_login(self):
utils.FIXTURE = 'default'
self.response.headers['location'] = self.campfire._uri_for()
self.response.status = 302
self.assertEqual(True, self.campfire.login('foo', 'foopass'))
def test_find_room_by_name(self):
utils.FIXTURE = 'rooms_names'
room = self.campfire.find_room_by_name('Room A')
self.assert_(room is not None)
self.assert_(self.campfire.find_room_by_name('No Room') is None)
def test_find_room_by_name_no_rooms(self):
utils.FIXTURE = 'no_rooms'
self.assert_(self.campfire.find_room_by_name('Room A') is None)
def test_create_room(self):
utils.FIXTURE = 'rooms_names'
name = 'New Room'
self.assert_(self.campfire.find_room_by_name(name) is None)
new_room_markup = self.response.read().splitlines()
new_room_markup.append("""
<div id="room_1234" class="room available shaded"><h2>
<a href="http://sample.campfirenow.com/room/1234">%s</a>
</h2>
</div>""" % name)
self.response.read = lambda: '\n'.join(new_room_markup)
self.assert_(self.campfire.find_room_by_name(name) is not None)
def test_users_rooms_empty(self):
utils.FIXTURE = 'chat_rooms_empty'
self.assert_(not self.campfire.users())
def test_users_rooms_one_empty(self):
utils.FIXTURE = 'chat_rooms_one_empty'
self.assert_('Tom Jones' in self.campfire.users('Room A'))
self.assert_(not self.campfire.users('Room B'))
def test_users_rooms_not_empty(self):
utils.FIXTURE = 'chat_rooms_not_empty'
users = self.campfire.users()
self.assertEqual(['Tom Jones', 'Gloria Estefan'], list(users))
def test_rooms_names(self):
utils.FIXTURE = 'rooms_names'
self.assertEqual(['Room A', 'Room B'], self.campfire.rooms_names())
def test_rooms(self):
utils.FIXTURE = 'rooms_names'
from pinder import Room
self.assert_(isinstance(self.campfire.rooms()[0], Room))
def test_find_or_create_room_by_name(self):
utils.FIXTURE = 'chat_rooms_empty'
room = self.campfire.find_room_by_name('Room A')
self.assertEqual(room, self.campfire.find_or_create_room_by_name(
'Room A'))
def test_room_id_from_url(self):
self.assertEqual(None, self.campfire._room_id_from_uri(
'http://www.google.com'))
self.assertEqual('1234', self.campfire._room_id_from_uri(
'http://foo.campfirenow.com/room/1234/foo/bar'))
def test_transcripts(self):
utils.FIXTURE = 'transcripts'
transcripts = self.campfire.transcripts()
self.assertEqual(2, len(transcripts.keys()))
self.assert_('12345' in transcripts.keys())
self.assertEqual(2001, transcripts['12345'][0].year)
def test_transcripts_empty(self):
utils.FIXTURE = 'no_transcripts'
transcripts = self.campfire.transcripts()
self.assertEqual({}, transcripts)
class Bob(object):
room = None
campfire = None
stdin_path = '/dev/null'
stdout_path = settings.LOG_FILE
stderr_path = settings.ERROR_FILE
pidfile_path = settings.LOCK_FILE
pidfile_timeout = settings.LOCK_TIMEOUT
files_preserve = [settings.DB_FILE, ]
def startup(self):
self.campfire = Campfire(
settings.CAMPFIRE_DOMAIN,
ssl=settings.CAMPFIRE_SSL
)
self.campfire.login(settings.CAMPFIRE_LOGIN, settings.CAMPFIRE_PASSWORD)
self.room = self.campfire.find_room_by_name(settings.CAMPFIRE_ROOM)
self.room.join()
self.room.speak("I'm alive!")
# Main function
def run(self):
if self.is_reset_mode():
self.reset_db()
else:
self.startup()
self.db = self.get_db_cursor()
while True:
entry = self.get_next_entry()
while entry:
self.room.ping()
if self.is_entry_interesting(entry):
self.report_entry(entry)
self.record_processed(entry)
entry = self.get_next_entry()
time.sleep(30)
def stop(self, *args, **kwargs):
print args
print kwargs
self.room.speak("I'm going down!")
self.room.leave()
self.campfire.logout()
# Campfire Fuctions
def report_entry(self, entry):
msg = self.gen_message(entry)
self.room.speak(msg)
# SVN Functions
def get_next_entry(self):
last_rev = self.get_last_entry()
if last_rev:
next = last_rev + 1
target_rev = pysvn.Revision(pysvn.opt_revision_kind.number, next)
else:
target_rev = pysvn.Revision(pysvn.opt_revision_kind.head)
try:
client = pysvn.Client()
entries = client.log(
settings.SVN_SERVER,
revision_start = target_rev,
discover_changed_paths = True,
limit = 1
)
entry = entries[0]
except pysvn.ClientError:
entry = None
return entry
def get_last_entry(self):
query = "SELECT rev FROM svn_log ORDER BY processed DESC LIMIT 1"
result = self.db.execute(query)
rev = result.fetchone()
if rev:
rev = rev[0]
return rev
def is_entry_interesting(self, entry):
interesting = False
for change in entry.changed_paths:
for prefix in settings.SVN_WATCH_PATHS:
if change.path.startswith(prefix):
interesting = True
break
return interesting
def gen_message(self, entry):
rev = entry.revision.number
url = settings.COMMIT_URL % rev
msg = '[%d] %s - "%s" (%s)' % (rev, entry.author, entry.message, url)
return msg
def record_processed(self, entry):
rev = entry.revision.number
now = datetime.now().isoformat()
query = "INSERT OR IGNORE INTO svn_log (rev, processed) VALUES (:rev, :now)"
result = self.db.execute(query, {'rev': rev, 'now': now})
self.db.connection.commit()
# Database Functions
def reset_db(self):
if os.path.exists(settings.DB_FILE):
os.remove(settings.DB_FILE)
db = self.get_db_cursor()
query = "CREATE TABLE svn_log (rev INTEGER PRIMARY KEY, processed);"
result = db.execute(query)
db.connection.commit()
print query
def get_db_cursor(self):
conn = sqlite3.connect(settings.DB_FILE)
db = conn.cursor()
return db
def is_reset_mode(self):
parser = OptionParser()
parser.add_option("-R", "--resetdb",
action="store_true", dest="reset_db", default=False,
help="Reset the db file.")
(options, args) = parser.parse_args()
return options.reset_db
