specify -t --type option when calling sfi show

[sface.git] / sface / sfiprocess.py

diff --git a/sface/sfiprocess.py b/sface/sfiprocess.py
index 35f0ca9..089c739 100644 (file)
--- a/sface/sfiprocess.py
+++ b/sface/sfiprocess.py
@@ -1,7 +1,9 @@
 
 import os
+import json
 import pickle
 import sys
+import tempfile
 import time
 
 from PyQt4.QtCore import *
@@ -13,7 +15,7 @@ def find_executable(exec_name):
     paths = os.getenv("PATH").split(':')
     for p in paths:
         exec_path = os.path.join(p, exec_name)
-        if os.path.exists(exec_path):
+        if os.path.exists(exec_path) and os.access(exec_path,os.X_OK):
             return exec_path
     return None
 
@@ -35,12 +37,14 @@ class SfiProcess(QObject):
         # tracker.
         self.output = ""
 
+        self.do_raw = True   # xxx should check version of sfa
+
         self.connect(self.process, SIGNAL("readyReadStandardOutput()"),
                      self.processStandardOutput)
         self.connect(self.process, SIGNAL("readyReadStandardError()"),
                      self.processStandardError)
 
-    def __init_command(self, args):
+    def __init_command(self, args, save_filename=None):
         self.args = QStringList()
         self.args << "-d"
         self.args << config.get_dirname()
@@ -50,6 +54,17 @@ class SfiProcess(QObject):
         # then to the users.
         self.args << QString('-D')
 
+        if self.do_raw:
+            self.raw_filename = tempfile.mktemp(suffix=".raw")
+            self.args << QString('-R')
+            self.args << QString(self.raw_filename)
+            self.args << QString('--rawformat')
+            self.args << QString('json')
+        else:
+            self.raw_filename = None
+
+        self.save_filename = save_filename
+
         for arg in args:
             self.args << QString(arg)
 
@@ -95,6 +110,34 @@ class SfiProcess(QObject):
             elif err == QProcess.UnknownError:
                 print "UnknownError"
 
+        self.raw_data = None
+        if (self.raw_filename != None) and os.path.exists(self.raw_filename):
+            if hasattr(json, "loads"):
+                self.raw_data = json.loads(open(self.raw_filename,"r").read()) # python 2.6
+            else:
+                self.raw_data = json.read(open(self.raw_filename,"r").read()) # python 2.5
+
+            os.remove(self.raw_filename)
+
+        self.geni_code=None
+        self.geni_output=None
+        if (self.raw_data!=None) and (type(self.raw_data)==dict):
+            code = self.raw_data.get("code",{})
+            self.geni_code = code.get("geni_code",None)
+            self.geni_output = self.raw_data.get("output","")
+
+            if self.save_filename:
+                value = self.raw_data.get("value", None)
+                if value == None:
+                    if os.path.exists(self.save_filename):
+                        os.remove(self.save_filename)
+                elif type(value) == str:
+                    open(self.save_filename, "w").write(value)
+                elif hasattr(json, "dumps"):
+                    open(self.save_filename, "w").write(json.dumps(value))  # python 2.6
+                else:
+                    open(self.save_filename, "w").write(json.write(value))  # python 2.5
+
         # extract any faults from the XMLRPC response(s)
         self.xmlrpcreader.responses = []
         self.xmlrpcreader.store(self.output)
@@ -102,6 +145,16 @@ class SfiProcess(QObject):
         self.responses = self.xmlrpcreader.responses
         self.faults = [x for x in self.responses if (x["kind"]=="fault")]
 
+        # if we got a nonzero
+        if (self.geni_code!=None) and (self.geni_code!=0):
+            x = {"kind": "bad_geni_code"}
+            x["faultCode"] = str(self.geni_code)
+            faultString = "Nonzero geni_code: " + str(self.geni_code)
+            if self.geni_output:
+                faultString = faultString + " output: " + str(self.geni_output)
+            x["faultString"] = faultString
+            self.faults.append(x)
+
         self.trace_end()
         self.emit(SIGNAL("finished()"))
 
@@ -168,9 +221,15 @@ class SfiProcess(QObject):
         self.__init_command(args)
         self.start()
 
-    def getRecord(self, hrn, filename=None):
-        args = ["-u", config.getUser(), "-a", config.getAuthority(),
-                "-r", config.getRegistry(), "-s", config.getSlicemgr(), "show", hrn]
+    def getRecord(self, hrn, type=None, filename=None):
+        args = ["-u", config.getUser(), 
+                "-a", config.getAuthority(),
+                "-r", config.getRegistry(), 
+                "-s", config.getSlicemgr(), 
+                "show", hrn]
+        if type:
+            args.append("-t")
+            args.append(type) 
         if filename:
             args.append("-o")
             args.append(filename)
@@ -178,10 +237,10 @@ class SfiProcess(QObject):
         self.start()
 
     def getSliceRecord(self):
-        self.getRecord(config.getSlice(), config.getSliceRecordFile())
+        self.getRecord(config.getSlice(), type="slice", filename=config.getSliceRecordFile())
 
     def getAuthorityRecord(self):
-        self.getRecord(config.getAuthority(), config.getAuthorityRecordFile())
+        self.getRecord(config.getAuthority(), filename=config.getAuthorityRecordFile())
 
     def applyRSpec(self, rspec, aggAddr=None, aggPort=None, saveObtained=True):
         # that's what we pass, like in what we'd like to get
@@ -256,8 +315,8 @@ class SfiProcess(QObject):
 
         args = ["-u", config.getUser(), "-a", config.getAuthority(),
                 "-r", config.getRegistry(), "-s", config.getSlicemgr(), "status",
-                "-o", filename, "-F", "pickled", slice]
-        self.__init_command(args)
+                slice]
+        self.__init_command(args, save_filename = filename)
         self.start()
 
     def getSliceMgrVersion(self, filename=None):