git.maemo.org Git - theonering/blob - src/channel/debug_prompt.py

   1 from __future__ import with_statement
   2
   3 import os
   4 import cmd
   5 import StringIO
   6 import time
   7 import datetime
   8 import logging
   9
  10 import telepathy
  11
  12 import constants
  13 import tp
  14 import gtk_toolbox
  15 import gvoice
  16
  17
  18 _moduleLogger = logging.getLogger("channel.debug_prompt")
  19
  20
  21 class DebugPromptChannel(tp.ChannelTypeText, cmd.Cmd):
  22
  23         def __init__(self, connection, manager, props, contactHandle):
  24                 self.__manager = manager
  25                 self.__props = props
  26
  27                 cmd.Cmd.__init__(self, "Debug Prompt")
  28                 self.use_rawinput = False
  29                 tp.ChannelTypeText.__init__(self, connection, manager, props)
  30                 self.__nextRecievedId = 0
  31                 self.__lastMessageTimestamp = datetime.datetime(1, 1, 1)
  32
  33                 self.__otherHandle = contactHandle
  34
  35         @gtk_toolbox.log_exception(_moduleLogger)
  36         def Send(self, messageType, text):
  37                 if messageType != telepathy.CHANNEL_TEXT_MESSAGE_TYPE_NORMAL:
  38                         raise telepathy.errors.NotImplemented("Unhandled message type: %r" % messageType)
  39
  40                 self.Sent(int(time.time()), messageType, text)
  41
  42                 oldStdin, oldStdout = self.stdin, self.stdout
  43                 try:
  44                         self.stdin = currentStdin = StringIO.StringIO()
  45                         self.stdout = currentStdout = StringIO.StringIO()
  46                         self.onecmd(text)
  47                 finally:
  48                         self.stdin, self.stdout = oldStdin, oldStdout
  49
  50                 stdoutData = currentStdout.getvalue().strip()
  51                 if stdoutData:
  52                         self._report_new_message(stdoutData)
  53
  54         @gtk_toolbox.log_exception(_moduleLogger)
  55         def Close(self):
  56                 self.close()
  57
  58         def close(self):
  59                 _moduleLogger.debug("Closing debug")
  60                 tp.ChannelTypeText.Close(self)
  61                 self.remove_from_connection()
  62
  63         def _report_new_message(self, message):
  64                 currentReceivedId = self.__nextRecievedId
  65
  66                 timestamp = int(time.time())
  67                 type = telepathy.CHANNEL_TEXT_MESSAGE_TYPE_NORMAL
  68
  69                 self.Received(currentReceivedId, timestamp, self.__otherHandle, type, 0, message.strip())
  70
  71                 self.__nextRecievedId += 1
  72
  73         def do_reset_state_machine(self, args):
  74                 try:
  75                         args = args.strip().lower()
  76                         if not args:
  77                                 args  = "all"
  78                         if args == "all":
  79                                 for machine in self._conn.session.stateMachine._machines:
  80                                         machine.reset_timers()
  81                         elif args == "contacts":
  82                                 self._conn.session.addressbookStateMachine.reset_timers()
  83                         elif args == "voicemail":
  84                                 self._conn.session.voicemailsStateMachine.reset_timers()
  85                         elif args == "texts":
  86                                 self._conn.session.textsStateMachine.reset_timers()
  87                         else:
  88                                 self._report_new_message('Unknown machine "%s"' % (args, ))
  89                 except Exception, e:
  90                         self._report_new_message(str(e))
  91
  92         def help_reset_state_machine(self):
  93                 self._report_new_message("""Reset the refreshing state machine.
  94 "reset_state_machine" - resets all
  95 "reset_state_machine all"
  96 "reset_state_machine contacts"
  97 "reset_state_machine voicemail"
  98 "reset_state_machine texts"
  99 """)
 100
 101         def do_get_state(self, args):
 102                 if args:
 103                         self._report_new_message("No arguments supported")
 104                         return
 105
 106                 try:
 107                         state = self._conn.session.stateMachine.state
 108                         self._report_new_message(str(state))
 109                 except Exception, e:
 110                         self._report_new_message(str(e))
 111
 112         def help_get_state(self):
 113                 self._report_new_message("Print the current state the refreshing state machine is in")
 114
 115         def do_is_authed(self, args):
 116                 if args:
 117                         self._report_new_message("No arguments supported")
 118                         return
 119
 120                 try:
 121                         isAuthed = self._conn.session.backend.is_authed()
 122                         self._report_new_message(str(isAuthed))
 123                 except Exception, e:
 124                         self._report_new_message(str(e))
 125
 126         def help_is_authed(self):
 127                 self._report_new_message("Print whether logged in to Google Voice")
 128
 129         def do_is_dnd(self, args):
 130                 if args:
 131                         self._report_new_message("No arguments supported")
 132                         return
 133
 134                 try:
 135                         isDnd = self._conn.session.backend.is_dnd()
 136                         self._report_new_message(str(isDnd))
 137                 except Exception, e:
 138                         self._report_new_message(str(e))
 139
 140         def help_is_dnd(self):
 141                 self._report_new_message("Print whether Do-Not-Disturb mode enabled on the Google Voice account")
 142
 143         def do_get_account_number(self, args):
 144                 if args:
 145                         self._report_new_message("No arguments supported")
 146                         return
 147
 148                 try:
 149                         number = self._conn.session.backend.get_account_number()
 150                         self._report_new_message(number)
 151                 except Exception, e:
 152                         self._report_new_message(str(e))
 153
 154         def help_get_account_number(self):
 155                 self._report_new_message("Print the Google Voice account number")
 156
 157         def do_get_callback_numbers(self, args):
 158                 if args:
 159                         self._report_new_message("No arguments supported")
 160                         return
 161
 162                 try:
 163                         numbers = self._conn.session.backend.get_callback_numbers()
 164                         numbersDisplay = "\n".join(
 165                                 "%s: %s" % (name, number)
 166                                 for (number, name) in numbers.iteritems()
 167                         )
 168                         self._report_new_message(numbersDisplay)
 169                 except Exception, e:
 170                         self._report_new_message(str(e))
 171
 172         def help_get_callback_numbers(self):
 173                 self._report_new_message("Print a list of all configured callback numbers")
 174
 175         def do_get_sane_callback_number(self, args):
 176                 if args:
 177                         self._report_new_message("No arguments supported")
 178                         return
 179
 180                 try:
 181                         number = gvoice.backend.get_sane_callback(self._conn.session.backend)
 182                         self._report_new_message(number)
 183                 except Exception, e:
 184                         self._report_new_message(str(e))
 185
 186         def help_get_sane_callback_number(self):
 187                 self._report_new_message("Print the best guess of callback numbers to use")
 188
 189         def do_get_callback_number(self, args):
 190                 if args:
 191                         self._report_new_message("No arguments supported")
 192                         return
 193
 194                 try:
 195                         number = self._conn.session.backend.get_callback_number()
 196                         self._report_new_message(number)
 197                 except Exception, e:
 198                         self._report_new_message(str(e))
 199
 200         def help_get_callback_number(self):
 201                 self._report_new_message("Print the callback number currently enabled")
 202
 203         def do_call(self, args):
 204                 if not args:
 205                         self._report_new_message("Must specify the phone number and only the phone nunber")
 206                         return
 207
 208                 try:
 209                         number = args
 210                         self._conn.session.backend.call(number)
 211                 except Exception, e:
 212                         self._report_new_message(str(e))
 213
 214         def help_call(self):
 215                 self._report_new_message("\n".join(["call NUMBER", "Initiate a callback, Google forwarding the call to the callback number"]))
 216
 217         def do_send_sms(self, args):
 218                 args = args.split(" ")
 219                 if 1 < len(args):
 220                         self._report_new_message("Must specify the phone number and then message")
 221                         return
 222
 223                 try:
 224                         number = args[0]
 225                         message = " ".join(args[1:])
 226                         self._conn.session.backend.send_sms(number, message)
 227                 except Exception, e:
 228                         self._report_new_message(str(e))
 229
 230         def help_send_sms(self):
 231                 self._report_new_message("\n".join(["send_sms NUMBER MESSAGE0 MESSAGE1 ...", "Send an sms to number NUMBER"]))
 232
 233         def do_version(self, args):
 234                 if args:
 235                         self._report_new_message("No arguments supported")
 236                         return
 237                 self._report_new_message("%s-%s" % (constants.__version__, constants.__build__))
 238
 239         def help_version(self):
 240                 self._report_new_message("Prints the version (hint: %s-%s)" % (constants.__version__, constants.__build__))
 241
 242         def do_get_polling(self, args):
 243                 if args:
 244                         self._report_new_message("No arguments supported")
 245                         return
 246                 self._report_new_message("\n".join((
 247                         "Contacts:", repr(self._conn.session.addressbookStateMachine)
 248                 )))
 249                 self._report_new_message("\n".join((
 250                         "Voicemail:", repr(self._conn.session.voicemailsStateMachine)
 251                 )))
 252                 self._report_new_message("\n".join((
 253                         "Texts:", repr(self._conn.session.textsStateMachine)
 254                 )))
 255
 256         def help_get_polling(self):
 257                 self._report_new_message("Prints the frequency each of the state machines updates")
 258
 259         def do_grab_log(self, args):
 260                 if args:
 261                         self._report_new_message("No arguments supported")
 262                         return
 263
 264                 try:
 265                         publishProps = self._conn.generate_props(telepathy.CHANNEL_TYPE_FILE_TRANSFER, self.__otherHandle, False)
 266                         self._conn._channel_manager.channel_for_props(publishProps, signal=True)
 267                 except Exception, e:
 268                         self._report_new_message(str(e))
 269
 270         def help_grab_log(self):
 271                 self._report_new_message("Download the debug log for including with bug report")
 272                 self._report_new_message("Warning: this may contain sensitive information")
 273
 274         def do_save_log(self, args):
 275                 if not args:
 276                         self._report_new_message("Must specify a filename to save the log to")
 277                         return
 278
 279                 try:
 280                         filename = os.path.expanduser(args)
 281                         with open(constants._user_logpath_, "r") as f:
 282                                 logLines = f.xreadlines()
 283                                 log = "".join(logLines)
 284                         with open(filename, "w") as f:
 285                                 f.write(log)
 286                 except Exception, e:
 287                         self._report_new_message(str(e))
 288
 289         def help_save_log(self):
 290                 self._report_new_message("Save the log to a specified location")