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                 if args:
  75                         self._report_new_message("No arguments supported")
  76                         return
  77
  78                 try:
  79                         for machine in self._conn.session.stateMachine._machines:
  80                                 machine.reset_timers()
  81                 except Exception, e:
  82                         self._report_new_message(str(e))
  83
  84         def help_reset_state_machine(self):
  85                 self._report_new_message("Reset the refreshing state machine")
  86
  87         def do_get_state(self, args):
  88                 if args:
  89                         self._report_new_message("No arguments supported")
  90                         return
  91
  92                 try:
  93                         state = self._conn.session.stateMachine.state
  94                         self._report_new_message(str(state))
  95                 except Exception, e:
  96                         self._report_new_message(str(e))
  97
  98         def help_get_state(self):
  99                 self._report_new_message("Print the current state the refreshing state machine is in")
 100
 101         def do_is_authed(self, args):
 102                 if args:
 103                         self._report_new_message("No arguments supported")
 104                         return
 105
 106                 try:
 107                         isAuthed = self._conn.session.backend.is_authed()
 108                         self._report_new_message(str(isAuthed))
 109                 except Exception, e:
 110                         self._report_new_message(str(e))
 111
 112         def help_is_authed(self):
 113                 self._report_new_message("Print whether logged in to Google Voice")
 114
 115         def do_is_dnd(self, args):
 116                 if args:
 117                         self._report_new_message("No arguments supported")
 118                         return
 119
 120                 try:
 121                         isDnd = self._conn.session.backend.is_dnd()
 122                         self._report_new_message(str(isDnd))
 123                 except Exception, e:
 124                         self._report_new_message(str(e))
 125
 126         def help_is_dnd(self):
 127                 self._report_new_message("Print whether Do-Not-Disturb mode enabled on the Google Voice account")
 128
 129         def do_get_account_number(self, args):
 130                 if args:
 131                         self._report_new_message("No arguments supported")
 132                         return
 133
 134                 try:
 135                         number = self._conn.session.backend.get_account_number()
 136                         self._report_new_message(number)
 137                 except Exception, e:
 138                         self._report_new_message(str(e))
 139
 140         def help_get_account_number(self):
 141                 self._report_new_message("Print the Google Voice account number")
 142
 143         def do_get_callback_numbers(self, args):
 144                 if args:
 145                         self._report_new_message("No arguments supported")
 146                         return
 147
 148                 try:
 149                         numbers = self._conn.session.backend.get_callback_numbers()
 150                         numbersDisplay = "\n".join(
 151                                 "%s: %s" % (name, number)
 152                                 for (number, name) in numbers.iteritems()
 153                         )
 154                         self._report_new_message(numbersDisplay)
 155                 except Exception, e:
 156                         self._report_new_message(str(e))
 157
 158         def help_get_callback_numbers(self):
 159                 self._report_new_message("Print a list of all configured callback numbers")
 160
 161         def do_get_sane_callback_number(self, args):
 162                 if args:
 163                         self._report_new_message("No arguments supported")
 164                         return
 165
 166                 try:
 167                         number = gvoice.backend.get_sane_callback(self._conn.session.backend)
 168                         self._report_new_message(number)
 169                 except Exception, e:
 170                         self._report_new_message(str(e))
 171
 172         def help_get_sane_callback_number(self):
 173                 self._report_new_message("Print the best guess of callback numbers to use")
 174
 175         def do_get_callback_number(self, args):
 176                 if args:
 177                         self._report_new_message("No arguments supported")
 178                         return
 179
 180                 try:
 181                         number = self._conn.session.backend.get_callback_number()
 182                         self._report_new_message(number)
 183                 except Exception, e:
 184                         self._report_new_message(str(e))
 185
 186         def help_get_callback_number(self):
 187                 self._report_new_message("Print the callback number currently enabled")
 188
 189         def do_call(self, args):
 190                 if not args:
 191                         self._report_new_message("Must specify the phone number and only the phone nunber")
 192                         return
 193
 194                 try:
 195                         number = args
 196                         self._conn.session.backend.call(number)
 197                 except Exception, e:
 198                         self._report_new_message(str(e))
 199
 200         def help_call(self):
 201                 self._report_new_message("\n".join(["call NUMBER", "Initiate a callback, Google forwarding the call to the callback number"]))
 202
 203         def do_send_sms(self, args):
 204                 args = args.split(" ")
 205                 if 1 < len(args):
 206                         self._report_new_message("Must specify the phone number and then message")
 207                         return
 208
 209                 try:
 210                         number = args[0]
 211                         message = " ".join(args[1:])
 212                         self._conn.session.backend.send_sms(number, message)
 213                 except Exception, e:
 214                         self._report_new_message(str(e))
 215
 216         def help_send_sms(self):
 217                 self._report_new_message("\n".join(["send_sms NUMBER MESSAGE0 MESSAGE1 ...", "Send an sms to number NUMBER"]))
 218
 219         def do_version(self, args):
 220                 if args:
 221                         self._report_new_message("No arguments supported")
 222                         return
 223                 self._report_new_message("%s-%s" % (constants.__version__, constants.__build__))
 224
 225         def help_version(self):
 226                 self._report_new_message("Prints the version (hint: %s-%s)" % (constants.__version__, constants.__build__))
 227
 228         def do_get_polling(self, args):
 229                 if args:
 230                         self._report_new_message("No arguments supported")
 231                         return
 232                 self._report_new_message("\n".join((
 233                         "Contacts:", repr(self._conn.session.addressbookStateMachine)
 234                 )))
 235                 self._report_new_message("\n".join((
 236                         "Voicemail:", repr(self._conn.session.voicemailsStateMachine)
 237                 )))
 238                 self._report_new_message("\n".join((
 239                         "Texts:", repr(self._conn.session.textsStateMachine)
 240                 )))
 241
 242         def help_get_polling(self):
 243                 self._report_new_message("Prints the frequency each of the state machines updates")
 244
 245         def do_grab_log(self, args):
 246                 if args:
 247                         self._report_new_message("No arguments supported")
 248                         return
 249
 250                 try:
 251                         publishProps = self._conn._generate_props(telepathy.CHANNEL_TYPE_FILE_TRANSFER, self.__otherHandle, False)
 252                         self._conn._channel_manager.channel_for_props(publishProps, signal=True)
 253                 except Exception, e:
 254                         self._report_new_message(str(e))
 255
 256         def help_grab_log(self):
 257                 self._report_new_message("Download the debug log for including with bug report")
 258                 self._report_new_message("Warning: this may contain sensitive information")
 259
 260         def do_save_log(self, args):
 261                 if not args:
 262                         self._report_new_message("Must specify a filename to save the log to")
 263                         return
 264
 265                 try:
 266                         filename = os.path.expanduser(args)
 267                         with open(constants._user_logpath_, "r") as f:
 268                                 logLines = f.xreadlines()
 269                                 log = "".join(logLines)
 270                         with open(filename, "w") as f:
 271                                 f.write(log)
 272                 except Exception, e:
 273                         self._report_new_message(str(e))
 274
 275         def help_save_log(self):
 276                 self._report_new_message("Save the log to a specified location")