ipsilon/providers/openidp.py

   1 #!/usr/bin/python
   2 #
   3 # Copyright (C) 2014  Ipsilon project Contributors, for licensee see COPYING
   4
   5 from __future__ import absolute_import
   6
   7 from ipsilon.providers.common import ProviderBase
   8 from ipsilon.providers.openid.auth import OpenID
   9 from ipsilon.providers.openid.extensions.common import LoadExtensions
  10 from ipsilon.util.plugin import PluginObject
  11 from ipsilon.util import config as pconfig
  12 from ipsilon.info.common import InfoMapping
  13
  14 from openid.server.server import Server
  15 # TODO: Move this to the database
  16 from openid.store.memstore import MemoryStore
  17
  18
  19 class IdpProvider(ProviderBase):
  20
  21     def __init__(self, *pargs):
  22         super(IdpProvider, self).__init__('openid', 'openid', *pargs)
  23         self.mapping = InfoMapping()
  24         self.page = None
  25         self.server = None
  26         self.basepath = None
  27         self.extensions = LoadExtensions()
  28         print self.extensions.available()
  29         print self.extensions.available().keys()
  30         self.description = """
  31 Provides OpenID 2.0 authentication infrastructure. """
  32
  33         self.new_config(
  34             self.name,
  35             pconfig.String(
  36                 'default email domain',
  37                 'Used for users missing the email property.',
  38                 'example.com'),
  39             pconfig.String(
  40                 'endpoint url',
  41                 'The Absolute URL of the OpenID provider',
  42                 'http://localhost:8080/idp/openid/'),
  43             pconfig.Template(
  44                 'identity url template',
  45                 'The templated URL where identities are exposed.',
  46                 'http://localhost:8080/idp/openid/id/%(username)s'),
  47             pconfig.List(
  48                 'trusted roots',
  49                 'List of trusted relying parties.'),
  50             pconfig.List(
  51                 'untrusted roots',
  52                 'List of untrusted relying parties.'),
  53             pconfig.Choice(
  54                 'enabled extensions',
  55                 'Choose the extensions to enable',
  56                 self.extensions.available().keys()),
  57         )
  58
  59     @property
  60     def endpoint_url(self):
  61         url = self.get_config_value('endpoint url')
  62         if url.endswith('/'):
  63             return url
  64         else:
  65             return url+'/'
  66
  67     @property
  68     def default_email_domain(self):
  69         return self.get_config_value('default email domain')
  70
  71     @property
  72     def identity_url_template(self):
  73         url = self.get_config_value('identity url template')
  74         if url.endswith('/'):
  75             return url
  76         else:
  77             return url+'/'
  78
  79     @property
  80     def trusted_roots(self):
  81         return self.get_config_value('trusted roots')
  82
  83     @property
  84     def untrusted_roots(self):
  85         return self.get_config_value('untrusted roots')
  86
  87     @property
  88     def enabled_extensions(self):
  89         return self.get_config_value('enabled extensions')
  90
  91     def get_tree(self, site):
  92         self.init_idp()
  93         self.page = OpenID(site, self)
  94         # self.admin = AdminPage(site, self)
  95
  96         # Expose OpenID presence in the root
  97         headers = self._root.default_headers
  98         headers['X-XRDS-Location'] = self.endpoint_url+'XRDS'
  99
 100         html_heads = self._root.html_heads
 101         HEAD_LINK = '<link rel="%s" href="%s">'
 102         openid_heads = [HEAD_LINK % ('openid2.provider', self.endpoint_url),
 103                         HEAD_LINK % ('openid.server', self.endpoint_url)]
 104         html_heads['openid'] = openid_heads
 105
 106         return self.page
 107
 108     def init_idp(self):
 109         self.server = Server(MemoryStore(), op_endpoint=self.endpoint_url)
 110
 111     def on_enable(self):
 112         super(IdpProvider, self).on_enable()
 113         self.init_idp()
 114         self.extensions.enable(self._config['enabled extensions'].get_value())
 115
 116
 117 class Installer(object):
 118
 119     def __init__(self, *pargs):
 120         self.name = 'openid'
 121         self.ptype = 'provider'
 122         self.pargs = pargs
 123
 124     def install_args(self, group):
 125         group.add_argument('--openid', choices=['yes', 'no'], default='yes',
 126                            help='Configure OpenID Provider')
 127
 128     def configure(self, opts):
 129         if opts['openid'] != 'yes':
 130             return
 131
 132         proto = 'https'
 133         if opts['secure'].lower() == 'no':
 134             proto = 'http'
 135         url = '%s://%s/%s/openid/' % (
 136             proto, opts['hostname'], opts['instance'])
 137
 138         # Add configuration data to database
 139         po = PluginObject(*self.pargs)
 140         po.name = 'openid'
 141         po.wipe_data()
 142         po.wipe_config_values()
 143         config = {'endpoint url': url,
 144                   'identity_url_template': '%sid/%%(username)s' % url}
 145         po.save_plugin_config(config)
 146
 147         # Update global config to add login plugin
 148         po.is_enabled = True
 149         po.save_enabled_state()