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:", registry_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(registry_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 = 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 = 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 = 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 # Generate sub-command parser
 201 #
 202 def create_cmd_parser(command):
 203    cmdargs = {"list": "name",
 204               "show": "name",
 205               "remove": "name",
 206               "add": "name record",
 207               "update": "name record",
 208               "nodes": "[name]",
 209               "slices": "",
 210               "resources": "name",
 211               "create": "name rspec",
 212               "delete": "name",
 213               "reset": "name",
 214               "start": "name",
 215               "stop": "name"
 216              }
 217    if command not in cmdargs:
 218       print "Invalid command\n"
 219       print "Commands:list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset"
 220       sys.exit(2)
 221
 222    parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \
 223       % (command, cmdargs[command]))
 224    if command in ("nodes", "resources"):
 225       parser.add_option("-f", "--format", dest="format",type="choice",
 226            help="display format (dns|ip|hrn|rspec)",default="rspec",
 227            choices=("dns","ip","hrn","rspec"))
 228    if command in ("list", "show", "remove"):
 229       parser.add_option("-t", "--type", dest="type",type="choice",
 230            help="type filter (user|slice|sa|ma|node|aggregate)",
 231            choices=("user","slice","sa","ma","node","aggregate", "all"),
 232            default="all")
 233    if command in ("show", "nodes", "resources"):
 234       parser.add_option("-o", "--output", dest="file",
 235            help="output XML to file", metavar="FILE", default=None)
 236    return parser
 237
 238 #
 239 # Main: parse arguments and dispatch to command
 240 #
 241 def main():
 242    global verbose
 243
 244    # Generate command line parser
 245    parser = OptionParser(usage="sfi [options] command [command_options] [command_args]",
 246         description="Commands: list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset")
 247    parser.add_option("-r", "--registry", dest="registry",
 248         help="root registry", metavar="URL", default=None)
 249    parser.add_option("-s", "--slicemgr", dest="sm",
 250         help="slice manager", metavar="URL", default=None)
 251    parser.add_option("-d", "--dir", dest="dir",
 252         help="working directory", metavar="PATH", default = sfi_dir)
 253    parser.add_option("-u", "--user", dest="user",
 254         help="user name", metavar="HRN", default=None)
 255    parser.add_option("-a", "--auth", dest="auth",
 256         help="authority name", metavar="HRN", default=None)
 257    parser.add_option("-v", "--verbose",
 258         action="store_true", dest="verbose", default=False,
 259         help="verbose mode")
 260    parser.disable_interspersed_args()
 261    (options, args) = parser.parse_args()
 262    command = args[0]
 263    (cmd_opts, cmd_args) = create_cmd_parser(command).parse_args(args[1:])
 264    verbose = options.verbose
 265    if verbose :
 266       print options.registry, options.sm, options.dir, options.verbose,\
 267          options.user, options.auth
 268       print command
 269       if command in ("nodes", "resources"):
 270          print cmd_opts.format
 271       elif command in ("list","show","remove"):
 272          print cmd_opts.type
 273       print cmd_args
 274
 275    set_servers(options)
 276
 277    # Dispatch to selected command
 278    try:
 279       globals()[command](cmd_opts, cmd_args)
 280    except KeyError:
 281       print "Command not found:", command
 282       sys.exit(1)
 283    return
 284
 285 #
 286 # Following functions implement the commands
 287 #
 288 # Registry-related commands
 289 #
 290
 291 # list entires in named authority registry
 292 def list(opts, args):
 293    global registry
 294    user_cred = get_user_cred()
 295    list = registry.list(user_cred, args[0])
 296    for record in list :
 297       if (filter_record(opts.type, record) is not None):
 298          display_record(record)
 299    return
 300
 301 # show named registry record
 302 def show(opts, args):
 303    global registry
 304    user_cred = get_user_cred()
 305    record = reg_chan.resolve(user_cred, args[0])
 306    if (opts.type == record.get_type()):
 307       display_record(record)
 308    else :
 309       print "No record of type", opts.type
 310    if (opts.file is not None):
 311       save_record_to_file(opts.file, result)
 312    return
 313
 314 # removed named registry record
 315 #   - have to first retrieve the record to be removed
 316 def remove(opts, args):
 317    global registry
 318    auth_cred = get_auth_cred()
 319    list = registry.resolve(auth_cred, args[0])
 320    for record in list :
 321       if (filter_record(opts.type, record) is not None):
 322          return registry.remove(auth_cred, record)
 323    return
 324
 325 # add named registry record
 326 def add(opts, args):
 327    global registry
 328    auth_cred = get_auth_cred()
 329    rec_file = get_record_file(args[1])
 330    with open(rec_file) as f:
 331       record = f.read()
 332    return registry.register(auth_cred, record)
 333
 334 # update named registry entry
 335 def update(opts, args):
 336    global registry
 337    user_cred = get_user_cred()
 338    rec_file = get_record_file(args[1])
 339    with open(rec_file) as f:
 340       record = f.read()
 341    return registry.update(user_cred, record)
 342
 343 #
 344 # Slice-related commands
 345 #
 346
 347 # list available nodes
 348 def nodes(opts, args):
 349    global slicemgr
 350    user_cred = get_user_cred()
 351    if (len(args) == 0):
 352       context = None
 353    else:
 354       context = args[0]
 355    result = slicemgr.list_nodes(user_cred, context)
 356    display_rspec(opts.format, result)
 357    if (opts.file is not None):
 358       save_rspec_to_file(opts.file, result)
 359    return
 360
 361 # list instantiated slices
 362 def slices(opts, args):
 363    global slicemgr
 364    user_cred = get_user_cred()
 365    result = slicemgr.list_slices(user_cred)
 366    display_rspec(opts.format, results)
 367    return
 368
 369 # show rspec for named slice
 370 def resources(opts, args):
 371    global slicemgr
 372    slice_cred = get_slice_cred(args[0])
 373    result = slicemgr.get_slice_resources(slice_cred, args[0])
 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 # created named slice with given rspec
 380 def create(opts, args):
 381    global slicemgr
 382    slice_cred = get_slice_cred(args[0])
 383    rspec_file = get_rspec_file(args[1])
 384    with open(rspec_file) as f:
 385       rspec = f.read()
 386    return slicemgr.create_slice(slice_cred, rspec)
 387
 388 # delete named slice
 389 def delete(opts, args):
 390    global slicemgr
 391    slice_cred = get_slice_cred(args[0])
 392    return slicemgr.delete_slice(slice_cred)
 393
 394 # start named slice
 395 def start(opts, args):
 396    global slicemgr
 397    slice_cred = get_slice_cred(args[0])
 398    return slicemgr.start_slice(slice_cred)
 399
 400 # stop named slice
 401 def stop(opts, args):
 402    global slicemgr
 403    slice_cred = get_slice_cred(args[0])
 404    return slicemgr.stop_slice(slice_cred)
 405
 406 # reset named slice
 407 def reset(opts, args):
 408    global slicemgr
 409    slice_cred = get_slice_cred(args[0])
 410    return slicemgr.reset_slice(slice_cred)
 411
 412 #
 413 #
 414 # Display, Save, and Filter RSpecs and Records
 415 #   - to be replace by EMF-generated routines
 416 #
 417 #
 418
 419 def display_rspec(format, rspec):
 420    print "display rspec"
 421    return
 422
 423 def save_rspec_to_file(file, rspec):
 424    print "save rspec"
 425    return
 426
 427 def display_record(record):
 428    record.dump(False)
 429    return
 430
 431 def filter_record(type, record):
 432    if (record.get_type() == type):
 433       return record
 434    else:
 435       return None
 436
 437 def save_record_to_file(file, record):
 438    print "save record"
 439    return
 440
 441
 442 if __name__=="__main__":
 443    main()