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

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