namespace module is gone, plxrn provides PL-specific translations
[sfa.git] / sfa / plc / sfaImport.py
1 #
2 # The import tool assumes that the existing PLC hierarchy should all be part
3 # of "planetlab.us" (see the root_auth and level1_auth variables below).
4 #
5 # Public keys are extracted from the users' SSH keys automatically and used to
6 # create GIDs. This is relatively experimental as a custom tool had to be
7 # written to perform conversion from SSH to OpenSSL format. It only supports
8 # RSA keys at this time, not DSA keys.
9 ##
10
11 import getopt
12 import sys
13 import tempfile
14
15 from sfa.util.sfalogging import sfa_logger_goes_to_import,sfa_logger
16
17 from sfa.util.record import *
18 from sfa.util.table import SfaTable
19 from sfa.util.xrn import get_authority, hrn_to_urn
20 from sfa.util.plxrn import email_to_hrn
21 from sfa.util.config import Config
22 from sfa.trust.certificate import convert_public_key, Keypair
23 from sfa.trust.trustedroot import *
24 from sfa.trust.hierarchy import *
25 from sfa.trust.gid import create_uuid
26
27
28 def _un_unicode(str):
29    if isinstance(str, unicode):
30        return str.encode("ascii", "ignore")
31    else:
32        return str
33
34 def _cleanup_string(str):
35     # pgsql has a fit with strings that have high ascii in them, so filter it
36     # out when generating the hrns.
37     tmp = ""
38     for c in str:
39         if ord(c) < 128:
40             tmp = tmp + c
41     str = tmp
42
43     str = _un_unicode(str)
44     str = str.replace(" ", "_")
45     str = str.replace(".", "_")
46     str = str.replace("(", "_")
47     str = str.replace("'", "_")
48     str = str.replace(")", "_")
49     str = str.replace('"', "_")
50     return str
51
52 class sfaImport:
53
54     def __init__(self):
55        sfa_logger_goes_to_import()
56        self.logger = sfa_logger()
57        self.AuthHierarchy = Hierarchy()
58        self.config = Config()
59        self.TrustedRoots = TrustedRootList(Config.get_trustedroots_dir(self.config))
60        self.plc_auth = self.config.get_plc_auth()
61        self.root_auth = self.config.SFA_REGISTRY_ROOT_AUTH
62         
63        # connect to planetlab
64        self.shell = None
65        if "Url" in self.plc_auth:
66           from sfa.plc.remoteshell import RemoteShell
67           self.shell = RemoteShell(self.logger)
68        else:
69           import PLC.Shell
70           self.shell = PLC.Shell.Shell(globals = globals())        
71
72
73     def create_top_level_auth_records(self, hrn):
74         urn = hrn_to_urn(hrn, 'authority')
75         # make sure parent exists
76         parent_hrn = get_authority(hrn)
77         if not parent_hrn:
78             parent_hrn = hrn
79         if not parent_hrn == hrn:
80             self.create_top_level_auth_records(parent_hrn)
81
82         # create the authority if it doesnt already exist 
83         if not self.AuthHierarchy.auth_exists(urn):
84             self.logger.info("Import: creating top level authorities")
85             self.AuthHierarchy.create_auth(urn)
86         
87         # create the db record if it doesnt already exist    
88         auth_info = self.AuthHierarchy.get_auth_info(hrn)
89         table = SfaTable()
90         auth_record = table.find({'type': 'authority', 'hrn': hrn})
91
92         if not auth_record:
93             auth_record = SfaRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="authority", pointer=-1)
94             auth_record['authority'] = get_authority(auth_record['hrn'])
95             self.logger.info("Import: inserting authority record for " + hrn)
96             table.insert(auth_record)
97
98
99     def import_person(self, parent_hrn, person):
100         hrn = email_to_hrn(parent_hrn, person['email'])
101
102         # ASN.1 will have problems with hrn's longer than 64 characters
103         if len(hrn) > 64:
104             hrn = hrn[:64]
105
106         self.logger.info("Import: person " + hrn)
107         key_ids = []
108         if 'key_ids' in person and person['key_ids']:
109             key_ids = person["key_ids"]
110             # get the user's private key from the SSH keys they have uploaded
111             # to planetlab
112             keys = self.shell.GetKeys(self.plc_auth, key_ids)
113             key = keys[0]['key']
114             pkey = convert_public_key(key)
115             if not pkey:
116                 pkey = Keypair(create=True)
117         else:
118             # the user has no keys
119             self.logger.warning("Import: person %s does not have a PL public key"%hrn)
120             # if a key is unavailable, then we still need to put something in the
121             # user's GID. So make one up.
122             pkey = Keypair(create=True)
123
124         # create the gid
125         urn = hrn_to_urn(hrn, 'user')
126         person_gid = self.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
127         table = SfaTable()
128         person_record = SfaRecord(hrn=hrn, gid=person_gid, type="user", pointer=person['person_id'])
129         person_record['authority'] = get_authority(person_record['hrn'])
130         existing_records = table.find({'hrn': hrn, 'type': 'user', 'pointer': person['person_id']})
131         if not existing_records:
132             table.insert(person_record)
133         else:
134             self.logger.info("Import: %s exists, updating " % hrn)
135             existing_record = existing_records[0]
136             person_record['record_id'] = existing_record['record_id']
137             table.update(person_record)
138
139     def import_slice(self, parent_hrn, slice):
140         slicename = slice['name'].split("_",1)[-1]
141         slicename = _cleanup_string(slicename)
142
143         if not slicename:
144             self.logger.error("Import: failed to parse slice name " + slice['name'])
145             return
146
147         hrn = parent_hrn + "." + slicename
148         self.logger.info("Import: slice " + hrn)
149
150         pkey = Keypair(create=True)
151         urn = hrn_to_urn(hrn, 'slice')
152         slice_gid = self.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
153         slice_record = SfaRecord(hrn=hrn, gid=slice_gid, type="slice", pointer=slice['slice_id'])
154         slice_record['authority'] = get_authority(slice_record['hrn'])
155         table = SfaTable()
156         existing_records = table.find({'hrn': hrn, 'type': 'slice', 'pointer': slice['slice_id']})
157         if not existing_records:
158             table.insert(slice_record)
159         else:
160             self.logger.info("Import: %s exists, updating " % hrn)
161             existing_record = existing_records[0]
162             slice_record['record_id'] = existing_record['record_id']
163             table.update(slice_record)
164
165     def import_node(self, parent_hrn, node):
166         nodename = node['hostname'].split(".")[0]
167         nodename = _cleanup_string(nodename)
168         
169         if not nodename:
170             self.logger.error("Import: failed to parse node name " + node['hostname'])
171             return
172
173         hrn = parent_hrn + "." + nodename
174         self.logger.info("Import: node %s" % hrn)
175         # ASN.1 will have problems with hrn's longer than 64 characters
176         if len(hrn) > 64:
177             hrn = hrn[:64]
178
179         table = SfaTable()
180         node_record = table.find({'type': 'node', 'hrn': hrn})
181         pkey = Keypair(create=True)
182         urn = hrn_to_urn(hrn, 'node')
183         node_gid = self.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
184         node_record = SfaRecord(hrn=hrn, gid=node_gid, type="node", pointer=node['node_id'])
185         node_record['authority'] = get_authority(node_record['hrn'])
186         existing_records = table.find({'hrn': hrn, 'type': 'node', 'pointer': node['node_id']})
187         if not existing_records:
188             table.insert(node_record)
189         else:
190             self.logger.info("Import: %s exists, updating " % hrn)
191             existing_record = existing_records[0]
192             node_record['record_id'] = existing_record['record_id']
193             table.update(node_record)
194
195     
196     def import_site(self, parent_hrn, site):
197         shell = self.shell
198         plc_auth = self.plc_auth
199         sitename = site['login_base']
200         sitename = _cleanup_string(sitename)
201         hrn = parent_hrn + "." + sitename
202         # Hardcode 'internet2' into the hrn for sites hosting
203         # internet2 nodes. This is a special operation for some vini
204         # sites only
205         if ".vini" in parent_hrn and parent_hrn.endswith('vini'):
206             if sitename.startswith("i2"):
207                 #sitename = sitename.replace("ii", "")
208                 hrn = ".".join([parent_hrn, "internet2", sitename])
209             elif sitename.startswith("nlr"):
210                 #sitename = sitename.replace("nlr", "")
211                 hrn = ".".join([parent_hrn, "internet2", sitename])
212
213         urn = hrn_to_urn(hrn, 'authority')
214         self.logger.info("Import: site " + hrn)
215
216         # create the authority
217         if not self.AuthHierarchy.auth_exists(urn):
218             self.AuthHierarchy.create_auth(urn)
219
220         auth_info = self.AuthHierarchy.get_auth_info(urn)
221
222         table = SfaTable()
223         auth_record = SfaRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="authority", pointer=site['site_id'])
224         auth_record['authority'] = get_authority(auth_record['hrn'])
225         existing_records = table.find({'hrn': hrn, 'type': 'authority', 'pointer': site['site_id']})
226         if not existing_records:
227             table.insert(auth_record)
228         else:
229             self.logger.info("Import: %s exists, updating " % hrn)
230             existing_record = existing_records[0]
231             auth_record['record_id'] = existing_record['record_id']
232             table.update(auth_record)
233
234         return hrn
235
236
237     def delete_record(self, hrn, type):
238         # delete the record
239         table = SfaTable()
240         record_list = table.find({'type': type, 'hrn': hrn})
241         for record in record_list:
242             self.logger.info("Import: removing record %s %s" % (type, hrn))
243             table.remove(record)