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 from optparse import OptionParser
   9 from util.cert import Keypair, Certificate
  10 from util.credential import Credential
  11 from util.geniclient import GeniClient
  12
  13 sfi_dir = os.path.expanduser("~/.sfi/")
  14 slicemgr = None
  15 registry = None
  16 user = None
  17 authority = None
  18 verbose = False
  19
  20 #
  21 # Establish Connection to SliceMgr and Registry Servers
  22 #
  23 def set_servers(options):
  24    global slicemgr
  25    global registry
  26    global user
  27    global authority
  28
  29    # Set SliceMgr URL
  30    if (options.sm is not None):
  31       sm_url = options.sm
  32    elif ("SFI_SM" in os.environ):
  33       sm_url = os.environ["SFI_SM"]
  34    else:
  35       print "No Known Slice Manager"
  36       sys.exit(1)
  37
  38    # Set Registry URL
  39    if (options.registry is not None):
  40       reg_url = options.registry
  41    elif ("SFI_REGISTRY" in os.environ):
  42       reg_url = os.environ["SFI_REGISTRY"]
  43    else:
  44       print "No Known Registry Server"
  45       sys.exit(1)
  46
  47    if options.verbose :
  48       print "Contacting Slice Manager at:", sm_url
  49       print "Contacting Registry at:", reg_url
  50
  51    # Set user HRN
  52    if (options.user is not None):
  53       user = options.user
  54    elif ("SFI_USER" in os.environ):
  55       user = os.environ["SFI_USER"]
  56    else:
  57       print "No Known User Name"
  58       sys.exit(1)
  59
  60    # Set authority HRN
  61    if (options.auth is not None):
  62       authority = options.auth
  63    elif ("SFI_AUTH" in os.environ):
  64       authority = os.environ["SFI_AUTH"]
  65    else:
  66       authority = None
  67
  68    # Get key and certificate
  69    key_file = get_key_file()
  70    cert_file = get_cert_file(key_file)
  71
  72    # Establish connection to server(s)
  73    slicemgr = GeniClient(sm_url, key_file, cert_file)
  74    registry = GeniClient(reg_url, key_file, cert_file)
  75    return
  76
  77 #
  78 # Get various credential and spec files
  79 #
  80 # Establishes limiting conventions
  81 #   - conflates MAs and SAs
  82 #   - assumes last token in slice name is unique
  83 #
  84 # Bootstraps credentials
  85 #   - bootstrap user credential from self-signed certificate
  86 #   - bootstrap authority credential from user credential
  87 #   - bootstrap slice credential from user credential
  88 #
  89
  90 def get_leaf(name):
  91    parts = name.split(".")
  92    return parts[-1]
  93
  94 def get_key_file():
  95    file = os.path.join(sfi_dir, get_leaf(user) + ".pkey")
  96    if (os.path.isfile(file)):
  97       return file
  98    else:
  99       print "Key file", file, "does not exist"
 100       sys.exit(-1)
 101    return
 102
 103 def get_cert_file(key_file):
 104    global verbose
 105
 106    file = os.path.join(sfi_dir, get_leaf(user) + ".cert")
 107    if (os.path.isfile(file)):
 108       return file
 109    else:
 110       k = Keypair(filename = key_file)
 111       cert = Certificate(subject=user)
 112       cert.set_pubkey(k)
 113       cert.set_issuer(k, user)
 114       cert.sign()
 115       if verbose :
 116          print "Writing self-signed certificate to", file
 117       cert.save_to_file(file)
 118       return file
 119
 120 def get_user_cred():
 121    global user
 122
 123    file = os.path.join(sfi_dir, get_leaf(user) + ".cred")
 124    if (os.path.isfile(file)):
 125       user_cred = Credential(filename=file)
 126       return user_cred
 127    else:
 128       # bootstrap user credential
 129       user_cred = registry.get_credential(None, "user", user)
 130       if user_cred:
 131          user_cred.save_to_file(file, save_parents=True)
 132          if verbose:
 133             print "Writing user credential to", file
 134          return user_cred
 135       else:
 136          print "Failed to get user credential"
 137          sys.exit(-1)
 138
 139 def get_auth_cred():
 140    global authority
 141
 142    file = os.path.join(sfi_dir, "authority.cred")
 143    if (os.path.isfile(file)):
 144       auth_cred = Credential(filename=file)
 145       return auth_cred
 146    else:
 147       # bootstrap authority credential from user credential
 148       user_cred = get_user_cred()
 149       auth_cred = registry.get_credential(user_cred, "sa", authority)
 150       if auth_cred:
 151          auth_cred.save_to_file(file, save_parents=True)
 152          if verbose:
 153             print "Writing authority credential to", file
 154          return auth_cred
 155       else:
 156          print "Failed to get authority credential"
 157          sys.exit(-1)
 158
 159 def get_slice_cred(name):
 160    file = os.path.join(sfi_dir, "slice_" + get_leaf(name) + ".cred")
 161    if (os.path.isfile(file)):
 162       slice_cred = Credential(filename=file)
 163       return slice_cred
 164    else:
 165       # bootstrap slice credential from user credential
 166       user_cred = get_user_cred()
 167       slice_cred = registry.get_credential(user_cred, "slice", name)
 168       if slice_cred:
 169          slice_cred.save_to_file(file, save_parents=True)
 170          if verbose:
 171             print "Writing slice credential to", file
 172          return slice_cred
 173       else:
 174          print "Failed to get slice credential"
 175          sys.exit(-1)
 176
 177 def get_rspec_file(rspec):
 178    if (os.path.isabs(rspec)):
 179       file = rspec
 180    else:
 181       file = os.path.join(sfi_dir, rspec)
 182    if (os.path.isfile(file)):
 183       return file
 184    else:
 185       print "No such rspec file"
 186       sys.exit(1)
 187
 188 def get_record_file(record):
 189    if (os.path.isabs(record)):
 190       file = record
 191    else:
 192       file = os.path.join(sfi_dir, record)
 193    if (os.path.isfile(file)):
 194       return file
 195    else:
 196       print "No such registry record file"
 197       sys.exit(1)
 198
 199
 200 #
 201 # Generate sub-command parser
 202 #
 203 def create_cmd_parser(command, additional_cmdargs = None):
 204    cmdargs = {"list": "name",
 205               "show": "name",
 206               "remove": "name",
 207               "add": "name record",
 208               "update": "name record",
 209               "nodes": "[name]",
 210               "slices": "",
 211               "resources": "name",
 212               "create": "name rspec",
 213               "delete": "name",
 214               "reset": "name",
 215               "start": "name",
 216               "stop": "name"
 217              }
 218
 219    if additional_cmdargs:
 220       cmdargs.update(additional_cmdargs)
 221
 222    if command not in cmdargs:
 223       print "Invalid command\n"
 224       print "Commands: ",
 225       for key in cmdargs.keys():
 226           print key+",",
 227       print ""
 228       sys.exit(2)
 229
 230    parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \
 231       % (command, cmdargs[command]))
 232    if command in ("nodes", "resources"):
 233       parser.add_option("-f", "--format", dest="format",type="choice",
 234            help="display format (dns|ip|hrn|rspec)",default="rspec",
 235            choices=("dns","ip","hrn","rspec"))
 236    if command in ("list", "show", "remove"):
 237       parser.add_option("-t", "--type", dest="type",type="choice",
 238            help="type filter (user|slice|sa|ma|node|aggregate)",
 239            choices=("user","slice","sa","ma","node","aggregate", "all"),
 240            default="all")
 241    if command in ("show", "list", "nodes", "resources"):
 242       parser.add_option("-o", "--output", dest="file",
 243            help="output XML to file", metavar="FILE", default=None)
 244    return parser
 245
 246 def create_parser():
 247    # Generate command line parser
 248    parser = OptionParser(usage="sfi [options] command [command_options] [command_args]",
 249         description="Commands: list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset")
 250    parser.add_option("-r", "--registry", dest="registry",
 251         help="root registry", metavar="URL", default=None)
 252    parser.add_option("-s", "--slicemgr", dest="sm",
 253         help="slice manager", metavar="URL", default=None)
 254    parser.add_option("-d", "--dir", dest="dir",
 255         help="working directory", metavar="PATH", default = sfi_dir)
 256    parser.add_option("-u", "--user", dest="user",
 257         help="user name", metavar="HRN", default=None)
 258    parser.add_option("-a", "--auth", dest="auth",
 259         help="authority name", metavar="HRN", default=None)
 260    parser.add_option("-v", "--verbose",
 261         action="store_true", dest="verbose", default=False,
 262         help="verbose mode")
 263    parser.disable_interspersed_args()
 264
 265    return parser
 266
 267 def dispatch(command, cmd_opts, cmd_args):
 268    globals()[command](cmd_opts, cmd_args)
 269
 270 #
 271 # Main: parse arguments and dispatch to command
 272 #
 273 def main():
 274    global verbose
 275
 276    parser = create_parser()
 277    (options, args) = parser.parse_args()
 278
 279    if len(args) <= 0:
 280         print "No command given. Use -h for help."
 281         return -1
 282
 283    command = args[0]
 284    (cmd_opts, cmd_args) = create_cmd_parser(command).parse_args(args[1:])
 285    verbose = options.verbose
 286    if verbose :
 287       print options.registry, options.sm, options.dir, options.verbose,\
 288          options.user, options.auth
 289       print command
 290       if command in ("nodes", "resources"):
 291          print cmd_opts.format
 292       elif command in ("list","show","remove"):
 293          print cmd_opts.type
 294       print cmd_args
 295
 296    set_servers(options)
 297
 298    try:
 299       dispatch(command, cmd_opts, cmd_args)
 300    except KeyError:
 301       print "Command not found:", command
 302       sys.exit(1)
 303
 304    return
 305
 306 #
 307 # Following functions implement the commands
 308 #
 309 # Registry-related commands
 310 #
 311
 312 # list entires in named authority registry
 313 def list(opts, args):
 314    global registry
 315    user_cred = get_user_cred()
 316    list = registry.list(user_cred, args[0])
 317    list = filter_records(opts.type, list)
 318    display_records(list)
 319    if opts.file:
 320        save_records_to_file(opts.file, list)
 321    return
 322
 323 # show named registry record
 324 def show(opts, args):
 325    global registry
 326    user_cred = get_user_cred()
 327    records = registry.resolve(user_cred, args[0])
 328    records = filter_records(opts.type, records)
 329    if not records:
 330       print "No record of type", opts.type
 331    display_records(records)
 332    if opts.file:
 333        save_records_to_file(opts.file, records)
 334    return
 335
 336 # removed named registry record
 337 #   - have to first retrieve the record to be removed
 338 def remove(opts, args):
 339    global registry
 340    auth_cred = get_auth_cred()
 341    return registry.remove(auth_cred, opts.type, args[0])
 342
 343 # add named registry record
 344 def add(opts, args):
 345    global registry
 346    auth_cred = get_auth_cred()
 347    rec_file = get_record_file(args[1])
 348    with open(rec_file) as f:
 349       record = f.read()
 350    return registry.register(auth_cred, record)
 351
 352 # update named registry entry
 353 def update(opts, args):
 354    global registry
 355    user_cred = get_user_cred()
 356    rec_file = get_record_file(args[1])
 357    with open(rec_file) as f:
 358       record = f.read()
 359    return registry.update(user_cred, record)
 360
 361 #
 362 # Slice-related commands
 363 #
 364
 365 # list available nodes
 366 def nodes(opts, args):
 367    global slicemgr
 368    user_cred = get_user_cred()
 369    if (len(args) == 0):
 370       context = None
 371    else:
 372       context = args[0]
 373    result = slicemgr.list_nodes(user_cred, context)
 374    display_rspec(opts.format, result)
 375    if (opts.file is not None):
 376       save_rspec_to_file(opts.file, result)
 377    return
 378
 379 # list instantiated slices
 380 def slices(opts, args):
 381    global slicemgr
 382    user_cred = get_user_cred()
 383    result = slicemgr.list_slices(user_cred)
 384    display_rspec(opts.format, results)
 385    return
 386
 387 # show rspec for named slice
 388 def resources(opts, args):
 389    global slicemgr
 390    slice_cred = get_slice_cred(args[0])
 391    result = slicemgr.get_slice_resources(slice_cred, args[0])
 392    display_rspec(opts.format, result)
 393    if (opts.file is not None):
 394       save_rspec_to_file(opts.file, result)
 395    return
 396
 397 # created named slice with given rspec
 398 def create(opts, args):
 399    global slicemgr
 400    slice_cred = get_slice_cred(args[0])
 401    rspec_file = get_rspec_file(args[1])
 402    with open(rspec_file) as f:
 403       rspec = f.read()
 404    return slicemgr.create_slice(slice_cred, rspec)
 405
 406 # delete named slice
 407 def delete(opts, args):
 408    global slicemgr
 409    slice_cred = get_slice_cred(args[0])
 410    return slicemgr.delete_slice(slice_cred)
 411
 412 # start named slice
 413 def start(opts, args):
 414    global slicemgr
 415    slice_cred = get_slice_cred(args[0])
 416    return slicemgr.start_slice(slice_cred)
 417
 418 # stop named slice
 419 def stop(opts, args):
 420    global slicemgr
 421    slice_cred = get_slice_cred(args[0])
 422    return slicemgr.stop_slice(slice_cred)
 423
 424 # reset named slice
 425 def reset(opts, args):
 426    global slicemgr
 427    slice_cred = get_slice_cred(args[0])
 428    return slicemgr.reset_slice(slice_cred)
 429
 430 #
 431 #
 432 # Display, Save, and Filter RSpecs and Records
 433 #   - to be replace by EMF-generated routines
 434 #
 435 #
 436
 437 def display_rspec(format, rspec):
 438    print "display rspec"
 439    return
 440
 441 def save_rspec_to_file(file, rspec):
 442    print "save rspec"
 443    return
 444
 445 def display_records(recordList):
 446    for record in recordList:
 447       display_record(record)
 448
 449 def display_record(record):
 450    record.dump(False)
 451    return
 452
 453 def filter_records(type, records):
 454    filtered_records = []
 455    for record in records:
 456        if (record.get_type() == type) or (type == "all"):
 457            filtered_records.append(record)
 458    return filtered_records
 459
 460 def save_records_to_file(filename, recordList):
 461    index = 0
 462    for record in recordList:
 463        if index>0:
 464            save_record_to_file(filename + "." + str(index), record)
 465        else:
 466            save_record_to_file(filename, record)
 467        index = index + 1
 468
 469 def save_record_to_file(filename, record):
 470    print "saving record", record.name, "to file", filename
 471    str = record.save_to_string()
 472    file(filename, "w").write(str)
 473    return
 474
 475 if __name__=="__main__":
 476    main()