Added hostdir.py - a simple Chromoting Directory client.

remoting/tools/hostdir.py

Index: remoting/tools/hostdir.py
diff --git a/remoting/tools/hostdir.py b/remoting/tools/hostdir.py
new file mode 100755
index 0000000000000000000000000000000000000000..d4905f4897777438e3d8899e274ba9f3482f277c
--- /dev/null
+++ b/remoting/tools/hostdir.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2010 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Chromoting Directory API client implementation. Used for testing/debugging
+# purposes. Requires Python 2.6: json module is not available in earlier
+# versions.
+
+import os
+import httplib
+import json
+import urllib
+import urllib2
+import random
+import sys
+
+DEFAULT_DIRECTORY_SERVER = 'www-googleapis-test.sandbox.google.com'
+
+auth_filepath = os.path.join(os.path.expanduser('~'),
+                             '.chromotingDirectoryAuthToken')
+
+def random_uuid():
+  return ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x" %
+    tuple(map(lambda x: random.randrange(0,65536), range(8))))
+
+class Host:
+  def __init__(self, parameters=None):
+    if parameters != None:
+      self.host_id = parameters[u"hostId"]
+      self.host_name = parameters[u"hostName"]
+      self.public_key = parameters[u"publicKey"]
+      # Following fields may be missing, use get() for them.
+      self.jabber_id = parameters.get(u"jabberId")
+      self.created_time = parameters.get(u"createdTime")
+      self.updated_time = parameters.get(u"updatedTime")
+      self.status = parameters.get(u"status")
+    else:
+      self.host_id = random_uuid()
+      import socket
+      self.host_name = socket.gethostname()
+      self.public_key = None
+      self.jabber_id = None
+      self.created_time = None
+      self.updated_time = None
+      self.status = None
+
+class HostDirectoryError(Exception):
+  def __init__(self, message, response):
+    Exception.__init__(self, message)
+    print response
+    self._response = response
+
+class HostDirectory:
+  def __init__(self, username, auth_token, server=DEFAULT_DIRECTORY_SERVER):
+    self._username = username
+    self._auth_token = auth_token
+    self._base_url = '/chromoting/v1/@me/hosts'
+
+    self._http = httplib.HTTPConnection(server)
+    self._headers = {"Authorization": "GoogleLogin auth=" + self._auth_token,
+                     "Content-Type": "application/json" }
+
+  def add_host(self, host):
+    host_json = { 'data':
+                    { 'hostId': host.host_id,
+                      'hostName': host.host_name,
+                      'publicKey': host.public_key,
+                      }
+                  }
+    if host.jabber_id:
+      host_json['data']['jabberId'] = host.jabber_id
+    post_data = json.dumps(host_json)
+    self._http.request("POST", self._base_url, post_data, self._headers)
+    response = self._http.getresponse()
+    if response.status != 200:
+      raise HostDirectoryError(response.reason, response.read())
+    data = response.read()
+
+  def get_hosts(self):
+    self._http.request("GET", self._base_url, headers=self._headers)
+    response = self._http.getresponse()
+    if response.status != 200:
+      raise HostDirectoryError(response.reason, response.read())
+    data = response.read()
+    data = json.loads(data)[u'data']
+    results = []
+    if data.has_key(u'items'):
+      for item in data[u'items']:
+        results.append(Host(item))
+    return results
+
+  def delete_host(self, host_id):
+    url = self._base_url + '/' + host_id
+    self._http.request("DELETE", url, headers=self._headers)
+    response = self._http.getresponse()
+    if response.status / 100 != 2: # Normally 204 is returned
+      raise HostDirectoryError(response.reason, response.read())
+    data = response.read()
+
+def usage():
+  sys.stderr.write(
+      ("Usage:\n" +
+       " Login: \t\t%(cmd)s login\n" +
+       " Register host: \t%(cmd)s insert --hostId=<hostId>" +
+       " --hostName=<hostName> \\\n" +
+       "\t\t\t    --publicKey=<publicKey>  --jabberId=<jabberId>\n" +
+       " List hosts: \t\t%(cmd)s list\n" +
+       " Delete a host: \t%(cmd)s delete <host_id>\n")
+                   % {"cmd" : sys.argv[0]})
+  return 1
+
+class CommandError(Exception):
+  def __init__(self, message):
+    Exception.__init__(self, message)
+
+def load_auth_token():
+  try:
+    lines = open(auth_filepath).readlines()
+  except IOError as e:
+    raise CommandError("Can't open file (%s). Please run " +
+                       "'%s login' and try again." %
+                       (auth_filepath, sys.argv[0]))
+  if len(lines) != 2:
+    raise CommandError("Invalid auth file (%s). Please run " +
+                       "'%s login' and try again." %
+                       (auth_filepath, sys.argv[0]))
+  return map(lambda x: x.strip(), lines)
+
+def login_cmd(args):
+  """login command"""
+  if len(args) != 0:
+    return usage()
+
+  import getpass
+  import gaia_auth
+
+  print "Email:",
+  email = raw_input()
+  passwd = getpass.getpass("Password: ")
+
+  authenticator = gaia_auth.GaiaAuthenticator('chromoting');
+  auth_token = authenticator.authenticate(email, passwd)
+
+  # Set permission mask for created file.
+  os.umask(0066)
+  auth_file = open(auth_filepath, 'w')
+  auth_file.write(email)
+  auth_file.write('\n')
+  auth_file.write(auth_token)
+  auth_file.close()
+
+  print 'Auth token: ', auth_token
+  print '...saved in', auth_filepath
+
+def list_cmd(args):
+  """list command"""
+  if len(args) != 0:
+    return usage()
+  (username, token) = load_auth_token()
+  client = HostDirectory(username, token)
+  print '%36s  %30s   %s' % ("HOST ID", "HOST NAME", "JABBER ID")
+  for host in client.get_hosts():
+    print '%36s  %30s   %s' % (host.host_id, host.host_name, host.jabber_id)
+  return 0
+
+def insert_cmd(args):
+  """insert command"""
+  (username, token) = load_auth_token()
+  client = HostDirectory(username, token)
+
+  host = Host()
+  for arg in args:
+    if arg.startswith("--hostId="):
+      host.host_id = arg[len("--hostId="):]
+    elif arg.startswith("--hostName="):
+      host.host_name = arg[len("--hostName="):]
+    elif arg.startswith("--publicKey="):
+      host.public_key = arg[len("--publicKey="):]
+    elif arg.startswith("--jabberId="):
+      host.jabber_id = arg[len("--jabberId="):]
+    else:
+      return usage()
+
+  client.add_host(host)
+  return 0
+
+def delete_cmd(args):
+  """delete command"""
+  if len(args) != 1:
+    return usage()
+  host_id = args[0]
+  (username, token) = load_auth_token()
+  client = HostDirectory(username, token)
+  client.delete_host(host_id)
+  return 0
+
+def main():
+  import sys
+  args = sys.argv[1:]
+  if len(args) == 0:
+    return usage()
+  command = args[0]
+
+  try:
+    if command == "help":
+      usage()
+    elif command == "login":
+      return login_cmd(args[1:])
+    elif command == "list":
+      return list_cmd(args[1:])
+    elif command == "insert":
+      return insert_cmd(args[1:])
+    elif command == "delete":
+      return delete_cmd(args[1:])
+    else:
+      raise CommandError("Unknown command: %s" % command);
+
+  except CommandError as e:
+    sys.stderr.write("%s\n" % e.args[0])
+    return 1
+
+  return 0
+
+if __name__ == '__main__':
+  sys.exit(main())