just some comments. nothing major.
[sfa.git] / cmdline / sfi.py
1 #! /usr/bin/env python
2 from __future__ import with_statement
3
4 # sfi -- slice-based facility interface
5
6 import sys
7 import os, os.path
8 import tempfile
9 from optparse import OptionParser
10 from geni.util.cert import Keypair, Certificate
11 from geni.util.credential import Credential
12 from geni.util.geniclient import GeniClient, ServerException
13 from geni.util.gid import create_uuid
14 from geni.util.record import GeniRecord
15
16 sfi_dir = os.path.expanduser("~/.sfi/")
17 slicemgr = None
18 registry = None
19 user = None
20 authority = None
21 verbose = False
22
23 #
24 # Establish Connection to SliceMgr and Registry Servers
25 #
26 def set_servers(options):
27    global slicemgr
28    global registry
29    global user
30    global authority
31
32    # Set SliceMgr URL
33    if (options.sm is not None):
34       sm_url = options.sm
35    elif ("SFI_SM" in os.environ):
36       sm_url = os.environ["SFI_SM"]
37    else:
38       print "No Known Slice Manager"
39       sys.exit(1)
40
41    # Set Registry URL
42    if (options.registry is not None):
43       reg_url = options.registry
44    elif ("SFI_REGISTRY" in os.environ):
45       reg_url = os.environ["SFI_REGISTRY"]
46    else:
47       print "No Known Registry Server"
48       sys.exit(1)
49
50    if options.verbose :
51       print "Contacting Slice Manager at:", sm_url
52       print "Contacting Registry at:", reg_url
53
54    # Set user HRN
55    if (options.user is not None):
56       user = options.user
57    elif ("SFI_USER" in os.environ):
58       user = os.environ["SFI_USER"]
59    else:
60       print "No Known User Name"
61       sys.exit(1)
62
63    # Set authority HRN
64    if (options.auth is not None):
65       authority = options.auth
66    elif ("SFI_AUTH" in os.environ):
67       authority = os.environ["SFI_AUTH"]
68    else:
69       authority = None
70
71    # Get key and certificate
72    key_file = get_key_file()
73    cert_file = get_cert_file(key_file)
74
75    # Establish connection to server(s)
76    slicemgr = GeniClient(sm_url, key_file, cert_file)
77    registry = GeniClient(reg_url, key_file, cert_file)
78    return
79
80 #
81 # Get various credential and spec files
82 #
83 # Establishes limiting conventions
84 #   - conflates MAs and SAs
85 #   - assumes last token in slice name is unique
86 #
87 # Bootstraps credentials
88 #   - bootstrap user credential from self-signed certificate
89 #   - bootstrap authority credential from user credential
90 #   - bootstrap slice credential from user credential
91 #
92
93 def get_leaf(name):
94    parts = name.split(".")
95    return parts[-1]
96
97 def get_key_file():
98    file = os.path.join(sfi_dir, get_leaf(user) + ".pkey")
99    if (os.path.isfile(file)):
100       return file
101    else:
102       print "Key file", file, "does not exist"
103       sys.exit(-1)
104    return
105
106 def get_cert_file(key_file):
107    global verbose
108
109    file = os.path.join(sfi_dir, get_leaf(user) + ".cert")
110    if (os.path.isfile(file)):
111       return file
112    else:
113       k = Keypair(filename = key_file)
114       cert = Certificate(subject=user)
115       cert.set_pubkey(k)
116       cert.set_issuer(k, user)
117       cert.sign()
118       if verbose :
119          print "Writing self-signed certificate to", file
120       cert.save_to_file(file)
121       return file
122
123 def get_user_cred():
124    global user
125
126    file = os.path.join(sfi_dir, get_leaf(user) + ".cred")
127    if (os.path.isfile(file)):
128       user_cred = Credential(filename=file)
129       return user_cred
130    else:
131       # bootstrap user credential
132       user_cred = registry.get_credential(None, "user", user)
133       if user_cred:
134          user_cred.save_to_file(file, save_parents=True)
135          if verbose:
136             print "Writing user credential to", file
137          return user_cred
138       else:
139          print "Failed to get user credential"
140          sys.exit(-1)
141
142 def get_auth_cred():
143    global authority
144
145    if not authority:
146       print "no authority specified. Use -a or set SF_AUTH"
147       sys.exit(-1)
148
149    file = os.path.join(sfi_dir, get_leaf("authority") +".cred")
150    if (os.path.isfile(file)):
151       auth_cred = Credential(filename=file)
152       return auth_cred
153    else:
154       # bootstrap authority credential from user credential
155       user_cred = get_user_cred()
156       auth_cred = registry.get_credential(user_cred, "sa", authority)
157       if auth_cred:
158          auth_cred.save_to_file(file, save_parents=True)
159          if verbose:
160             print "Writing authority credential to", file
161          return auth_cred
162       else:
163          print "Failed to get authority credential"
164          sys.exit(-1)
165
166 def get_slice_cred(name):
167    file = os.path.join(sfi_dir, "slice_" + get_leaf(name) + ".cred")
168    if (os.path.isfile(file)):
169       slice_cred = Credential(filename=file)
170       return slice_cred
171    else:
172       # bootstrap slice credential from user credential
173       user_cred = get_user_cred()
174       slice_cred = registry.get_credential(user_cred, "slice", name)
175       if slice_cred:
176          slice_cred.save_to_file(file, save_parents=True)
177          if verbose:
178             print "Writing slice credential to", file
179          return slice_cred
180       else:
181          print "Failed to get slice credential"
182          sys.exit(-1)
183
184 def get_rspec_file(rspec):
185    if (os.path.isabs(rspec)):
186       file = rspec
187    else:
188       file = os.path.join(sfi_dir, rspec)
189    if (os.path.isfile(file)):
190       return file
191    else:
192       print "No such rspec file", rspec
193       sys.exit(1)
194
195 def get_record_file(record):
196    if (os.path.isabs(record)):
197       file = record
198    else:
199       file = os.path.join(sfi_dir, record)
200    if (os.path.isfile(file)):
201       return file
202    else:
203       print "No such registry record file", record
204       sys.exit(1)
205
206 def load_publickey_string(fn):
207    f = file(fn,"r")
208    key_string = f.read()
209
210    # if the filename is a private key file, then extract the public key
211    if "PRIVATE KEY" in key_string:
212        outfn = tempfile.mktemp()
213        cmd = "openssl rsa -in " + fn + " -pubout -outform PEM -out " + outfn
214        os.system(cmd)
215        f = file(outfn, "r")
216        key_string = f.read()
217        os.remove(outfn)
218
219    return key_string
220
221 #
222 # Generate sub-command parser
223 #
224 def create_cmd_parser(command, additional_cmdargs = None):
225    cmdargs = {"list": "name",
226               "show": "name",
227               "remove": "name",
228               "add": "record",
229               "update": "record",
230               "slices": "",
231               "resources": "[name]",
232               "create": "name rspec",
233               "delete": "name",
234               "reset": "name",
235               "start": "name",
236               "stop": "name"
237              }
238
239    if additional_cmdargs:
240       cmdargs.update(additional_cmdargs)
241
242    if command not in cmdargs:
243       print "Invalid command\n"
244       print "Commands: ",
245       for key in cmdargs.keys():
246           print key+",",
247       print ""
248       sys.exit(2)
249
250    parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \
251       % (command, cmdargs[command]))
252    if command in ("resources"):
253       parser.add_option("-f", "--format", dest="format",type="choice",
254            help="display format (dns|ip|rspec)",default="rspec",
255            choices=("dns","ip","rspec"))
256    if command in ("list", "show", "remove"):
257       parser.add_option("-t", "--type", dest="type",type="choice",
258            help="type filter (user|slice|sa|ma|node|aggregate)",
259            choices=("user","slice","sa","ma","node","aggregate", "all"),
260            default="all")
261    if command in ("show", "list", "resources"):
262       parser.add_option("-o", "--output", dest="file",
263            help="output XML to file", metavar="FILE", default=None)
264    return parser
265
266 def create_parser():
267    # Generate command line parser
268    parser = OptionParser(usage="sfi [options] command [command_options] [command_args]",
269         description="Commands: list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset")
270    parser.add_option("-r", "--registry", dest="registry",
271         help="root registry", metavar="URL", default=None)
272    parser.add_option("-s", "--slicemgr", dest="sm",
273         help="slice manager", metavar="URL", default=None)
274    parser.add_option("-d", "--dir", dest="dir",
275         help="working directory", metavar="PATH", default = sfi_dir)
276    parser.add_option("-u", "--user", dest="user",
277         help="user name", metavar="HRN", default=None)
278    parser.add_option("-a", "--auth", dest="auth",
279         help="authority name", metavar="HRN", default=None)
280    parser.add_option("-v", "--verbose",
281         action="store_true", dest="verbose", default=False,
282         help="verbose mode")
283    parser.disable_interspersed_args()
284
285    return parser
286
287 def dispatch(command, cmd_opts, cmd_args):
288    globals()[command](cmd_opts, cmd_args)
289
290 #
291 # Main: parse arguments and dispatch to command
292 #
293 def main():
294    global verbose
295
296    parser = create_parser()
297    (options, args) = parser.parse_args()
298
299    if len(args) <= 0:
300         print "No command given. Use -h for help."
301         return -1
302
303    command = args[0]
304    (cmd_opts, cmd_args) = create_cmd_parser(command).parse_args(args[1:])
305    verbose = options.verbose
306    if verbose :
307       print "Resgistry %s, sm %s, dir %s, user %s, auth %s" % (options.registry, 
308                                             options.sm, 
309                                             options.dir,
310                                             options.user, 
311                                             options.auth)
312       print "Command %s" %command
313       if command in ("resources"):
314          print "resources cmd_opts %s" %cmd_opts.format
315       elif command in ("list","show","remove"):
316          print "cmd_opts.type %s" %cmd_opts.type
317       print "cmd_args %s" %cmd_args
318
319    set_servers(options)
320
321    try:
322       dispatch(command, cmd_opts, cmd_args)
323    except KeyError:
324       print "Command not found:", command
325       sys.exit(1)
326
327    return
328
329 #
330 # Following functions implement the commands
331 #
332 # Registry-related commands
333 #
334
335 # list entires in named authority registry
336 def list(opts, args):
337    global registry
338    user_cred = get_user_cred()
339    list = registry.list(user_cred, args[0])
340    # filter on person, slice, site, node, etc.  
341    # THis really should be in the filter_records funct def comment...
342    list = filter_records(opts.type, list)
343    display_records(list)
344    if opts.file:
345        save_records_to_file(opts.file, list)
346    return
347
348 # show named registry record
349 def show(opts, args):
350    global registry
351    user_cred = get_user_cred()
352    records = registry.resolve(user_cred, args[0])
353    records = filter_records(opts.type, records)
354    if not records:
355       print "No record of type", opts.type
356    display_records(records, True)
357    if opts.file:
358        save_records_to_file(opts.file, records)
359    return
360
361 # removed named registry record
362 #   - have to first retrieve the record to be removed
363 def remove(opts, args):
364    global registry
365    auth_cred = get_auth_cred()
366    return registry.remove(auth_cred, opts.type, args[0])
367
368 # add named registry record
369 def add(opts, args):
370    global registry
371    auth_cred = get_auth_cred()
372    rec_file = get_record_file(args[0])
373    record = load_record_from_file(rec_file)
374
375    # check and see if we need to create a gid for this record. The creator
376    # of the record signals this by filling in the create_gid, create_gid_hrn,
377    # and create_gid_key members.
378    # (note: we'd use an unsigned GID in the record instead, but pyOpenSSL is
379    #   broken and has no way for us to get the key back out of the gid)
380    geni_info = record.get_geni_info()
381    if "create_gid" in geni_info:
382        gid = registry.create_gid(auth_cred, geni_info["create_gid_hrn"], create_uuid(), geni_info["create_gid_key"])
383        record.set_gid(gid)
384
385        del geni_info["create_gid"]
386        del geni_info["create_gid_hrn"]
387        del geni_info["create_gid_key"]
388
389    return registry.register(auth_cred, record)
390
391 # update named registry entry
392 def update(opts, args):
393    global registry
394    user_cred = get_user_cred()
395    rec_file = get_record_file(args[0])
396    record = load_record_from_file(rec_file)
397    if record.get_type() == "user":
398        if record.get_name() == user_cred.get_gid_object().get_hrn():
399           cred = user_cred
400        else:
401           create = get_auth_cred()
402    elif record.get_type() in ["slice"]:
403        try:
404            cred = get_slice_cred(record.get_name())
405        except ServerException, e:
406            if "PermissionError" in e.args[0]:
407                cred = get_auth_cred()
408            else:
409                raise
410    elif record.get_type() in ["sa", "ma", "node"]:
411        cred = get_auth_cred()
412    else:
413        raise "unknown record type" + record.get_type()
414    return registry.update(cred, record)
415
416 #
417 # Slice-related commands
418 #
419
420 # list available nodes -- now use 'resources' w/ no argument instead
421 #def nodes(opts, args):
422 #   global slicemgr
423 #   user_cred = get_user_cred() 
424 #   if not opts.format:
425 #      context = None
426 #   else:
427 #      context = opts.format
428 #   results = slicemgr.list_nodes(user_cred)
429 #   if opts.format in ['rspec']:     
430 #      display_rspec(results)
431 #   else:
432 #      display_list(results)
433 #   if (opts.file is not None):
434 #      rspec = slicemgr.list_nodes(user_cred)
435 #      save_rspec_to_file(rspec, opts.file)
436 #   return
437
438 # list instantiated slices
439 def slices(opts, args):
440    global slicemgr
441    user_cred = get_user_cred() 
442    results = slicemgr.list_slices(user_cred)
443    display_list(results)
444    return
445
446 # show rspec for named slice
447 def resources(opts, args):
448    global slicemgr
449    if args: 
450        slice_cred = get_slice_cred(args[0])
451        result = slicemgr.get_resources(slice_cred, args[0])
452    else:
453        user_cred = get_user_cred()
454        result = slicemgr.get_resources(user_cred)   
455    display_rspec(result)
456    if (opts.file is not None):
457       save_rspec_to_file(opts.file, result)
458    return
459
460 # created named slice with given rspec
461 def create(opts, args):
462    global slicemgr
463    slice_hrn = args[0]
464    slice_cred = get_slice_cred(slice_hrn)
465    rspec_file = get_rspec_file(args[1])
466    with open(rspec_file) as f:
467       rspec = f.read()
468    return slicemgr.create_slice(slice_cred, slice_hrn, rspec)
469
470 # delete named slice
471 def delete(opts, args):
472    global slicemgr
473    slice_hrn = args[0]
474    slice_cred = get_slice_cred(slice_hrn)
475    
476    return slicemgr.delete_slice(slice_cred, slice_hrn)
477
478 # start named slice
479 def start(opts, args):
480    global slicemgr
481    slice_cred = get_slice_cred(args[0])
482    return slicemgr.start_slice(slice_cred)
483
484 # stop named slice
485 def stop(opts, args):
486    global slicemgr
487    slice_cred = get_slice_cred(args[0])
488    return slicemgr.stop_slice(slice_cred)
489
490 # reset named slice
491 def reset(opts, args):
492    global slicemgr
493    slice_cred = get_slice_cred(args[0])
494    return slicemgr.reset_slice(slice_cred)
495
496 #
497 #
498 # Display, Save, and Filter RSpecs and Records
499 #   - to be replace by EMF-generated routines
500 #
501 #
502
503 def display_rspec(rspec):
504    print rspec
505    return
506
507 def display_list(results):
508     for result in results:
509         print result
510
511 def save_rspec_to_file(rspec, filename):
512    if not filename.startswith(os.sep):
513        filename = sfi_dir + filename
514    if not filename.endswith(".rspec"):
515        filename = filename + ".rspec"
516
517    f = open(filename, 'w')
518    f.write(rspec)
519    f.close()
520    return
521
522 def display_records(recordList, dump = False):
523    ''' Print all fields in the record'''
524    for record in recordList:
525       display_record(record, dump)
526
527 def display_record(record, dump = False):
528    if dump:
529        record.dump()
530    else:
531        info = record.getdict()
532        print "%s (%s)" % (info['hrn'], info['type'])
533    return
534
535 def filter_records(type, records):
536    filtered_records = []
537    for record in records:
538        if (record.get_type() == type) or (type == "all"):
539            filtered_records.append(record)
540    return filtered_records
541
542 def save_records_to_file(filename, recordList):
543    index = 0
544    for record in recordList:
545        if index>0:
546            save_record_to_file(filename + "." + str(index), record)
547        else:
548            save_record_to_file(filename, record)
549        index = index + 1
550
551 def save_record_to_file(filename, record):
552    if not filename.startswith(os.sep):
553        filename = sfi_dir + filename
554    str = record.save_to_string()
555    file(filename, "w").write(str)
556    return
557
558 def load_record_from_file(filename):
559    str = file(filename, "r").read()
560    record = GeniRecord(string=str)
561    return record
562
563 if __name__=="__main__":
564    main()