sface/sfiprocess.py

   1
   2 import os
   3 import json
   4 import pickle
   5 import sys
   6 import tempfile
   7 import time
   8
   9 from PyQt4.QtCore import *
  10 from sface.config import config
  11 from sface.xmlrpcwindow import get_tracker, XmlrpcReader
  12
  13 def find_executable(exec_name):
  14     """find the given executable in $PATH"""
  15     paths = os.getenv("PATH").split(':')
  16     for p in paths:
  17         exec_path = os.path.join(p, exec_name)
  18         if os.path.exists(exec_path) and os.access(exec_path,os.X_OK):
  19             return exec_path
  20     return None
  21
  22
  23 class SfiProcess(QObject):
  24     def __init__(self, parent=None):
  25         QObject.__init__(self, parent)
  26
  27         env = QProcess.systemEnvironment()
  28         env << "PYTHONPATH=%s" % ":".join(sys.path)
  29         self.process = QProcess()
  30         self.process.setEnvironment(env)
  31         self.connect(self.process, SIGNAL("finished(int, QProcess::ExitStatus)"),
  32                      self.processFinished)
  33
  34         self.xmlrpcreader = XmlrpcReader() # this one is for parsing XMLRPC responses
  35
  36         # holds aggregate output from processStandardOutput(); used by xmlrpc
  37         # tracker.
  38         self.output = ""
  39
  40         self.do_raw = True   # xxx should check version of sfa
  41
  42         self.connect(self.process, SIGNAL("readyReadStandardOutput()"),
  43                      self.processStandardOutput)
  44         self.connect(self.process, SIGNAL("readyReadStandardError()"),
  45                      self.processStandardError)
  46
  47     def __init_command(self, args):
  48         self.args = QStringList()
  49         self.args << "-d"
  50         self.args << config.get_dirname()
  51
  52         # this shows xmlrpc conversation, see sfi.py docs.
  53         # always do this, so we can parse the XML result for faults and show
  54         # then to the users.
  55         self.args << QString('-D')
  56
  57         if self.do_raw:
  58             self.raw_filename = tempfile.mktemp(suffix=".raw")
  59             self.args << QString('-R')
  60             self.args << QString(self.raw_filename)
  61             self.args << QString('--rawformat')
  62             self.args << QString('json')
  63         else:
  64             self.raw_filename = None
  65
  66         for arg in args:
  67             self.args << QString(arg)
  68
  69         self.exe = find_executable("sfi.py")
  70         if not self.exe:
  71             print "FATAL.. Could not locate binary sfi.py - not much we can do without that"
  72
  73     def isRunning(self):
  74         return self.process.state() != QProcess.NotRunning
  75
  76     def processStandardOutput(self):
  77         output = self.process.readAllStandardOutput()
  78         self.output = self.output + output
  79         if config.debug:
  80             try:
  81                 print output
  82             except IOError, e:
  83                 if (e.errno == 4):
  84                     # XXX why is this happening??
  85                     print "*** caught EINTR"
  86                 else:
  87                     raise
  88
  89
  90     def processStandardError(self):
  91         print self.process.readAllStandardError()
  92
  93     def processFinished(self):
  94         if self.process.exitStatus() == QProcess.CrashExit:
  95             print self.readOutput()
  96             print "Process exited with errors:",
  97             err = self.process.error()
  98             if err == QProcess.FailedToStart:
  99                 print "FailedToStart"
 100             elif err == QProcess.Crashed:
 101                 print "Crashed"
 102             elif err == QProcess.Timedout:
 103                 print "Timedout"
 104             elif err == QProcess.WriteError:
 105                 print "WriteError"
 106             elif err == QProcess.ReadError:
 107                 print "ReadError"
 108             elif err == QProcess.UnknownError:
 109                 print "UnknownError"
 110
 111         self.raw_data = None
 112         if (self.raw_filename != None) and os.path.exists(self.raw_filename):
 113             if hasattr(json, "loads"):
 114                 self.raw_data = json.loads(open(self.raw_filename,"r").read())
 115             else:
 116                 self.raw_data = json.read(open(self.raw_filename,"r").read())
 117
 118             os.remove(self.raw_filename)
 119
 120         self.geni_code=None
 121         self.geni_output=None
 122         if (self.raw_data!=None) and (type(self.raw_data)==dict):
 123             code = self.raw_data.get("code",{})
 124             self.geni_code = code.get("geni_code",None)
 125             self.geni_output = self.raw_data.get("output","")
 126
 127         # extract any faults from the XMLRPC response(s)
 128         self.xmlrpcreader.responses = []
 129         self.xmlrpcreader.store(self.output)
 130         self.xmlrpcreader.extractXml()
 131         self.responses = self.xmlrpcreader.responses
 132         self.faults = [x for x in self.responses if (x["kind"]=="fault")]
 133
 134         # if we got a nonzero
 135         if (self.geni_code!=None) and (self.geni_code!=0):
 136             x = {"kind": "bad_geni_code"}
 137             x["faultCode"] = str(self.geni_code)
 138             faultString = "Nonzero geni_code: " + str(self.geni_code)
 139             if self.geni_output:
 140                 faultString = faultString + " output: " + str(self.geni_output)
 141             x["faultString"] = faultString
 142             self.faults.append(x)
 143
 144         self.trace_end()
 145         self.emit(SIGNAL("finished()"))
 146
 147     def getFaultString(self):
 148         if self.faults == []:
 149             return None
 150
 151         return self.faults[0].get("faultString","") + " (" + self.faults[0].get("faultCode","") + ")"
 152
 153     def retrieveRspec(self):
 154         slice = config.getSlice()
 155         mgr = config.getSlicemgr()
 156         # Write RSpec to file
 157         filename = config.fullpath ("%s.rspec"%slice)
 158         try:
 159             os.remove(filename)
 160         except:
 161             pass
 162         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 163                 "-r", config.getRegistry(), "-s", mgr, "resources",
 164                 "-o", filename, slice]
 165
 166         self.__init_command(args)
 167         self.start()
 168         return filename
 169
 170     def retrieveResources(self):
 171         mgr = config.getSlicemgr()
 172         # Write RSpec to file
 173         filename = config.getResourcesRSpecFile()
 174         try:
 175             os.remove(filename)
 176         except:
 177             pass
 178         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 179                 "-r", config.getRegistry(), "-s", mgr, "resources",
 180                 "-o", filename]
 181
 182         self.__init_command(args)
 183         self.start()
 184         return filename
 185
 186
 187     def listRecords(self, hrn, rectype=None, filename=None):
 188         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 189                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "list", "-F", "xmllist", hrn]
 190
 191         if not filename:
 192             filename = config.getAuthorityListFile()
 193
 194         # we can't tell whether SFI will create one file or many, so delete
 195         # leftovers from last time, then we'll know what we got, after we get it.
 196         if os.path.exists(filename):
 197             os.remove(filename)
 198         if os.path.exists(filename + ".1"):
 199             os.remove(filename + ".1")
 200         args.append("-o")
 201         args.append(filename)
 202
 203         if rectype:
 204             args.append("-t")
 205             args.append(rectype)
 206
 207         self.__init_command(args)
 208         self.start()
 209
 210     def getRecord(self, hrn, filename=None):
 211         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 212                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "show", hrn]
 213         if filename:
 214             args.append("-o")
 215             args.append(filename)
 216         self.__init_command(args)
 217         self.start()
 218
 219     def getSliceRecord(self):
 220         self.getRecord(config.getSlice(), config.getSliceRecordFile())
 221
 222     def getAuthorityRecord(self):
 223         self.getRecord(config.getAuthority(), config.getAuthorityRecordFile())
 224
 225     def applyRSpec(self, rspec, aggAddr=None, aggPort=None, saveObtained=True):
 226         # that's what we pass, like in what we'd like to get
 227         requested = config.getSliceRSpecFile() + "_new"
 228         # that's what we actually receive
 229         # just overwrite the slice file as if we'd used 'resources'
 230         obtained = config.getSliceRSpecFile()
 231         rspec.save(requested)
 232         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 233                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "create"]
 234
 235         if saveObtained:
 236             args = args + ["-o", obtained]
 237
 238         if aggAddr:
 239             args = args + ["-a", aggAddr, "-p", str(aggPort)]
 240
 241         args = args + [config.getSlice(), requested]
 242
 243         self.__init_command(args)
 244         self.start()
 245
 246     def deleteSlivers(self, slice=None, aggAddr=None, aggPort=None):
 247         if not slice:
 248             slice = config.getSlice()
 249
 250         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 251                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "delete"]
 252
 253         if aggAddr:
 254             args = args + ["-a", aggAddr, "-p", str(aggPort)]
 255
 256         args = args + [slice]
 257
 258         self.__init_command(args)
 259         self.start()
 260
 261     def updateRecord(self, filename):
 262         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 263                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "update", filename]
 264         self.__init_command(args)
 265         self.start()
 266
 267     def addRecord(self, filename):
 268         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 269                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "add", filename]
 270         self.__init_command(args)
 271         self.start()
 272
 273     def removeRecord(self, hrn):
 274         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 275                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "remove", hrn]
 276         self.__init_command(args)
 277         self.start()
 278
 279     def renewSlivers(self, expiration, slice=None):
 280         if not slice:
 281             slice = config.getSlice()
 282
 283         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 284                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "renew",
 285                 slice, expiration]
 286         self.__init_command(args)
 287         self.start()
 288
 289     def sliverStatus(self, slice=None, filename=None):
 290         if not slice:
 291             slice = config.getSlice()
 292
 293         if not filename:
 294             filename = config.fullpath(slice+".sliverstatus")
 295
 296         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 297                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "status",
 298                 "-o", filename, "-F", "pickled", slice]
 299         self.__init_command(args)
 300         self.start()
 301
 302     def getSliceMgrVersion(self, filename=None):
 303         if not filename:
 304             filename = config.fullpath("slicemgr.version")
 305
 306         args = ["-u", config.getUser(), "-a", config.getAuthority(),
 307                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "version",
 308                 "-o", filename, "-F", "pickled",]
 309         self.__init_command(args)
 310         self.start()
 311
 312     def start(self):
 313         self.respones = []
 314         self.faults = []
 315         self.output = ""
 316         self.trace_command()
 317         self.process.start(self.exe, self.args)
 318
 319     def readOutput(self):
 320         if self.process.state() == QProcess.NotRunning:
 321             return self.process.readAll()
 322
 323     def trace_command (self):
 324         if config.verbose:
 325             self._trace=time.time()
 326             command = "%s %s" % (self.exe, self.args.join(" "))
 327             print time.strftime('%H:%M:%S'),'Invoking',command
 328
 329     def trace_end (self):
 330         if config.verbose:
 331 #            command = "%s %s" % (self.exe, self.args.join(" "))
 332             print time.strftime('%H:%M:%S'),"Done [%.3f s]"%(time.time()-self._trace)
 333         if config.debug:
 334             get_tracker().getAndPrint(self.output)
 335