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    result = registry.list(user_cred, args[0])
 296    display_record(opts.type, results)
 297    return
 298
 299 # show named registry record
 300 def show(opts, args):
 301    global registry
 302    user_cred = get_user_cred()
 303    result = reg_chan.resolve(user_cred, args[0])
 304    display_record(opts.type, results)
 305    if (opts.file is not None):
 306       save_record_to_file(opts.file, result)
 307    return
 308
 309 # removed named registry record
 310 #   - have to first retrieve the record to be removed
 311 def remove(opts, args):
 312    global registry
 313    auth_cred = get_auth_cred()
 314    results = registry.resolve(auth_cred, args[0])
 315    record = filter_record(opts.type, results)
 316    return registry.remove(auth_cred, record)
 317
 318 # add named registry record
 319 def add(opts, args):
 320    global registry
 321    auth_cred = get_auth_cred()
 322    rec_file = get_record_file(args[1])
 323    with open(rec_file) as f:
 324       record = f.read()
 325    return registry.register(auth_cred, record)
 326
 327 # update named registry entry
 328 def update(opts, args):
 329    global registry
 330    user_cred = get_user_cred()
 331    rec_file = get_record_file(args[1])
 332    with open(rec_file) as f:
 333       record = f.read()
 334    return registry.update(user_cred, record)
 335
 336 #
 337 # Slice-related commands
 338 #
 339
 340 # list available nodes
 341 def nodes(opts, args):
 342    global slicemgr
 343    user_cred = get_user_cred()
 344    if (len(args) == 0):
 345       context = None
 346    else:
 347       context = args[0]
 348    result = slicemgr.list_nodes(user_cred, context)
 349    display_rspec(opts.format, result)
 350    if (opts.file is not None):
 351       save_rspec_to_file(opts.file, result)
 352    return
 353
 354 # list instantiated slices
 355 def slices(opts, args):
 356    global slicemgr
 357    user_cred = get_user_cred()
 358    result = slicemgr.list_slices(user_cred)
 359    display_rspec(opts.format, results)
 360    return
 361
 362 # show rspec for named slice
 363 def resources(opts, args):
 364    global slicemgr
 365    slice_cred = get_slice_cred(args[0])
 366    result = slicemgr.get_slice_resources(slice_cred, args[0])
 367    display_rspec(opts.format, result)
 368    if (opts.file is not None):
 369       save_rspec_to_file(opts.file, result)
 370    return
 371
 372 # created named slice with given rspec
 373 def create(opts, args):
 374    global slicemgr
 375    slice_cred = get_slice_cred(args[0])
 376    rspec_file = get_rspec_file(args[1])
 377    with open(rspec_file) as f:
 378       rspec = f.read()
 379    return slicemgr.create_slice(slice_cred, rspec)
 380
 381 # delete named slice
 382 def delete(opts, args):
 383    global slicemgr
 384    slice_cred = get_slice_cred(args[0])
 385    return slicemgr.delete_slice(slice_cred)
 386
 387 # start named slice
 388 def start(opts, args):
 389    global slicemgr
 390    slice_cred = get_slice_cred(args[0])
 391    return slicemgr.start_slice(slice_cred)
 392
 393 # stop named slice
 394 def stop(opts, args):
 395    global slicemgr
 396    slice_cred = get_slice_cred(args[0])
 397    return slicemgr.stop_slice(slice_cred)
 398
 399 # reset named slice
 400 def reset(opts, args):
 401    global slicemgr
 402    slice_cred = get_slice_cred(args[0])
 403    return slicemgr.reset_slice(slice_cred)
 404
 405 #
 406 #
 407 # Display, Save, and Filter RSpecs and Records
 408 #   - to be replace by EMF-generated routines
 409 #
 410 #
 411
 412 def display_rspec(format, rspec):
 413    print "display rspec"
 414    return
 415
 416 def save_rspec_to_file(file, rspec):
 417    print "save rspec"
 418    return
 419
 420 def display_record(type, record):
 421    rec = filter_record(type, record)
 422    print "display record"
 423    return
 424
 425 def filter_record(type, record):
 426    print "filter record"
 427    return
 428
 429 def save_record_to_file(file, record):
 430    print "save record"
 431    return
 432
 433
 434 if __name__=="__main__":
 435    main()