import socket
+_moduleLogger = logging.getLogger("browser_emu")
socket.setdefaulttimeout(10)
@return: The raw HTML page data
"""
- logging.warning("Performing download of %s" % url)
+ _moduleLogger.warning("Performing download of %s" % url)
if extraheaders is None:
extraheaders = {}
req, u = self.build_opener(url, postdata, extraheaders, forbid_redirect)
openerdirector = u.open(req)
if self.debug:
- print req.get_method(), url
- print openerdirector.code, openerdirector.msg
- print openerdirector.headers
+ _moduleLogger.info("%r - %r" % (req.get_method(), url))
+ _moduleLogger.info("%r - %r" % (openerdirector.code, openerdirector.msg))
+ _moduleLogger.info("%r" % (openerdirector.headers))
self.cookies.extract_cookies(openerdirector, req)
if only_head:
return openerdirector
raise
# Retry :-)
- if self.debug:
- print "MozillaEmulator: urllib2.URLError, retryting ", cnt
+ _moduleLogger.info("MozillaEmulator: urllib2.URLError, retryting %d" % cnt)
def _read(self, openerdirector, trycount):
chunks = []
import gtk_toolbox
+_moduleLogger = logging.getLogger("dc_glade")
+
+
def getmtime_nothrow(path):
try:
return os.path.getmtime(path)
self._window.connect("key-press-event", self._on_key_press)
self._window.connect("window-state-event", self._on_window_state_change)
if not hildonize.IS_HILDON_SUPPORTED:
- logging.warning("No hildonization support")
+ _moduleLogger.warning("No hildonization support")
hildonize.set_application_title(self._window, "%s" % constants.__pretty_app_name__)
device = osso.DeviceState(self._osso)
device.set_device_state_callback(self._on_device_state_change, 0)
else:
- logging.warning("No device state support")
+ _moduleLogger.warning("No device state support")
try:
import alarm_handler
with gtk_toolbox.gtk_lock():
self._errorDisplay.push_exception()
alarm_handler = None
- logging.warning("No notification support")
+ _moduleLogger.warning("No notification support")
if hildonize.IS_HILDON_SUPPORTED:
try:
import led_handler
self._ledHandler = led_handler.LedHandler()
except Exception, e:
- logging.exception('LED Handling failed: "%s"' % str(e))
+ _moduleLogger.exception('LED Handling failed: "%s"' % str(e))
self._ledHandler = None
else:
self._ledHandler = None
self._connection.connect("connection-event", self._on_connection_change, constants.__app_magic__)
self._connection.request_connection(conic.CONNECT_FLAG_NONE)
else:
- logging.warning("No connection support")
+ _moduleLogger.warning("No connection support")
except Exception, e:
with gtk_toolbox.gtk_lock():
self._errorDisplay.push_exception()
serviceId = self._defaultBackendId
loggedIn = True
except Exception, e:
- logging.exception('Session refresh failed with the following message "%s"' % str(e))
+ _moduleLogger.exception('Session refresh failed with the following message "%s"' % str(e))
if not loggedIn:
loggedIn, serviceId = self._login_by_user(numOfAttempts)
"""
loggedIn = self._phoneBackends[self._defaultBackendId].is_authed()
if loggedIn:
- logging.info("Logged into %r through cookies" % self._phoneBackends[self._defaultBackendId])
+ _moduleLogger.info("Logged into %r through cookies" % self._phoneBackends[self._defaultBackendId])
return loggedIn
def _login_by_settings(self):
loggedIn = self._phoneBackends[self._defaultBackendId].login(username, password)
if loggedIn:
self._credentials = username, password
- logging.info("Logged into %r through settings" % self._phoneBackends[self._defaultBackendId])
+ _moduleLogger.info("Logged into %r through settings" % self._phoneBackends[self._defaultBackendId])
return loggedIn
def _login_by_user(self, numOfAttempts):
if loggedIn:
serviceId = tmpServiceId
self._credentials = username, password
- logging.info("Logged into %r through user request" % self._phoneBackends[serviceId])
+ _moduleLogger.info("Logged into %r through user request" % self._phoneBackends[serviceId])
else:
serviceId = self.NULL_BACKEND
self._notebook.set_current_page(self.ACCOUNT_TAB)
if self._alarmHandler is not None:
self._alarmHandler.load_settings(config, "alarm")
except ConfigParser.NoOptionError, e:
- logging.exception(
+ _moduleLogger.exception(
"Settings file %s is missing section %s" % (
constants._user_settings_,
e.section,
),
)
except ConfigParser.NoSectionError, e:
- logging.exception(
+ _moduleLogger.exception(
"Settings file %s is missing section %s" % (
constants._user_settings_,
e.section,
try:
view.load_settings(config, sectionName)
except ConfigParser.NoOptionError, e:
- logging.exception(
+ _moduleLogger.exception(
"Settings file %s is missing section %s" % (
constants._user_settings_,
e.section,
),
)
except ConfigParser.NoSectionError, e:
- logging.exception(
+ _moduleLogger.exception(
"Settings file %s is missing section %s" % (
constants._user_settings_,
e.section,
elif previousOrientation == gtk.ORIENTATION_VERTICAL:
hildonize.window_to_portrait(self._window)
except ConfigParser.NoOptionError, e:
- logging.exception(
+ _moduleLogger.exception(
"Settings file %s is missing section %s" % (
constants._user_settings_,
e.section,
),
)
except ConfigParser.NoSectionError, e:
- logging.exception(
+ _moduleLogger.exception(
"Settings file %s is missing section %s" % (
constants._user_settings_,
e.section,
import logging
+_moduleLogger = logging.getLogger("dialcentral")
sys.path.insert(0,"/usr/lib/dialcentral/")
userLogPath = "%s/dialcentral.log" % constants._data_path_
logging.basicConfig(level=logging.DEBUG, filename=userLogPath)
-logging.info("Dialcentral %s-%s" % (constants.__version__, constants.__build__))
+_moduleLogger.info("Dialcentral %s-%s" % (constants.__version__, constants.__build__))
try:
dc_glade.run_dialpad()
import gtk
+_moduleLogger = logging.getLogger("gtk_toolbox")
+
+
def get_screen_orientation():
width, height = gtk.gdk.get_default_root_window().get_size()
if width < height:
mappedItem = function(*item)
target.send(mappedItem)
except Exception, e:
- logging.exception("Forwarding exception!")
+ _moduleLogger.exception("Forwarding exception!")
target.throw(e.__class__, str(e))
def push_exception(self):
userMessage = str(sys.exc_info()[1])
self.push_message(userMessage)
- logging.exception(userMessage)
+ _moduleLogger.exception(userMessage)
def pop_message(self):
del self.__messages[0]
def push_exception(self, exception = None):
userMessage = str(sys.exc_value)
- logging.exception(userMessage)
+ _moduleLogger.exception(userMessage)
def pop_message(self):
if 0 < len(self.__messages):
del self.__messages[0]
def __show_message(self, message):
- logging.debug(message)
+ _moduleLogger.debug(message)
class MessageBox(gtk.MessageDialog):
self._calendar.select_month(self._displayDate.month, self._displayDate.year)
self._calendar.select_day(self._displayDate.day)
except Exception, e:
- logging.exception(e)
+ _moduleLogger.exception(e)
class QuickAddView(object):
simplejson = None
+_moduleLogger = logging.getLogger("gv_backend")
_TRUE_REGEX = re.compile("true")
_FALSE_REGEX = re.compile("false")
try:
self._grab_account_info()
except Exception, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
return False
self._browser.cookies.save()
try:
loginSuccessOrFailurePage = self._browser.download(self._loginURL, loginPostData)
except urllib2.URLError, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
raise RuntimeError("%s is not accesible" % self._loginURL)
return self.is_authed()
}
callSuccessPage = self._browser.download(self._clicktocallURL, clickToCallData, None, otherData)
except urllib2.URLError, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
raise RuntimeError("%s is not accesible" % self._clicktocallURL)
if self._gvDialingStrRe.search(callSuccessPage) is None:
}
smsSuccessPage = self._browser.download(self._sendSmsURL, smsData, None, otherData)
except urllib2.URLError, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
raise RuntimeError("%s is not accesible" % self._sendSmsURL)
return True
try:
contactsPage = self._browser.download(contactsPageUrl)
except urllib2.URLError, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
raise RuntimeError("%s is not accesible" % contactsPageUrl)
for contact_match in self._contactsRe.finditer(contactsPage):
contactId = contact_match.group(1)
try:
detailPage = self._browser.download(self._contactDetailURL + '/' + contactId)
except urllib2.URLError, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
raise RuntimeError("%s is not accesible" % self._contactDetailURL)
for detail_match in self._contactDetailPhoneRe.finditer(detailPage):
try:
voicemailPage = self._browser.download(self._voicemailURL)
except urllib2.URLError, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
raise RuntimeError("%s is not accesible" % self._voicemailURL)
voicemailHtml = self._grab_html(voicemailPage)
parsedVoicemail = self._parse_voicemail(voicemailHtml)
try:
smsPage = self._browser.download(self._smsURL)
except urllib2.URLError, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
raise RuntimeError("%s is not accesible" % self._smsURL)
smsHtml = self._grab_html(smsPage)
parsedSms = self._parse_sms(smsHtml)
if anGroup is not None:
self._accountNum = anGroup.group(1)
else:
- logging.debug("Could not extract account number from GoogleVoice")
+ _moduleLogger.debug("Could not extract account number from GoogleVoice")
self._callbackNumbers = {}
for match in self._callbackRe.finditer(page):
try:
flatXml = self._browser.download(url)
except urllib2.URLError, e:
- logging.exception(str(e))
+ _moduleLogger.exception(str(e))
raise RuntimeError("%s is not accesible" % url)
allRecentHtml = self._grab_html(flatXml)
import null_backend
+_moduleLogger = logging.getLogger("gv_views")
+
+
def make_ugly(prettynumber):
"""
function to take a phone number and strip out all non-numeric
if not self._backend.is_valid_syntax(number) and 0 < len(number):
self._errorDisplay.push_message("%s is not a valid callback number" % number)
elif number == self._backend.get_callback_number():
- logging.warning(
+ _moduleLogger.warning(
"Callback number already is %s" % (
self._backend.get_callback_number(),
),
make_pretty(number), make_pretty(self._backend.get_callback_number())
)
self._callbackSelectButton.set_label(make_pretty(number))
- logging.info(
+ _moduleLogger.info(
"Callback number set to %s" % (
self._backend.get_callback_number(),
),
number = make_ugly(userSelection)
self._set_callback_number(number)
except RuntimeError, e:
- logging.exception("%s" % str(e))
+ _moduleLogger.exception("%s" % str(e))
except Exception, e:
self._errorDisplay.push_exception()
self._update_alarm_settings(recurrence)
except RuntimeError, e:
- logging.exception("%s" % str(e))
+ _moduleLogger.exception("%s" % str(e))
except Exception, e:
self._errorDisplay.push_exception()
__version__ = constants.__version__
__build__ = constants.__build__
__changelog__ = """
+1.0.7
+* Debugging: Improved logging output
+
1.0.6
* Fremantle Prep: Simplified menus in prep for no menu or the Fremantle App Menu
* Fremantle Prep: Implemented a work around for https://bugs.maemo.org/show_bug.cgi?id=4957
import warnings
import sys
+sys.path.append("/usr/lib/dialcentral")
sys.path.append("../../src")
import browser_emu
warnings.warn(traceback.format_exc())
raise RuntimeError("%s is not accesible" % gv_backend.GVDialer._loginURL)
with open("loggingin.txt", "w") as f:
- f.write(page)
+ f.write(loginSuccessOrFailurePage)
forwardPage = browser.download(gv_backend.GVDialer._forwardURL)