docs: def get_output(self):
      """
      Return the output file, i.e. the file containing the frame cache data.
      or the files itself as tuple (for DAX)
      """
      if self.__dax:
        # we are a dax running in grid mode so we need to resolve the
        # frame file metadata into LFNs so pegasus can query the RLS
        if self.__lfn_list is None:
  
          if self.job().lsync_cache():
            # get the lfns from the lsync cache object
            if self.__lfn_list is None:
              self.__lfn_list = self.job().lsync_cache().get_lfns(
                self.get_observatory(), self.get_type(),
                self.get_start(), self.get_end())
  
          else:
            # try querying the ligo_data_find server
            try:
              server = os.environ['LIGO_DATAFIND_SERVER']
            except KeyError:
              raise RuntimeError, \
                "Environment variable LIGO_DATAFIND_SERVER is not set"
  
            try:
              h = httplib.HTTPConnection(server)
            except:
              # try and get a proxy or certificate
              # FIXME this doesn't check that it is valid, though
              cert = None
              key = None
              try:
                proxy = os.environ['X509_USER_PROXY']
                cert = proxy
                key = proxy
              except:
                try:
                  cert = os.environ['X509_USER_CERT']
                  key = os.environ['X509_USER_KEY']
                except:
                  uid = os.getuid()
                  proxy_path = "/tmp/x509up_u%d" % uid
                  if os.access(path, os.R_OK):
                    cert = proxy_path
                    key = proxy_path
  
              h = httplib.HTTPSConnection(server, key_file = key, cert_file = cert)
  
            # construct the URL for a simple data find query
            url = "/LDR/services/data/v1/gwf/%s/%s/%s,%s.json" % (
              self.get_observatory(), self.get_type(),
              str(self.get_start()), str(self.get_end()))
  
            # query the server
            h.request("GET", url)
            response = h.getresponse()
  
            if response.status != 200:
              msg = "Server returned code %d: %s" % (response.status, response.reason)
              body = response.read()
              msg += body
              raise RuntimeError, msg
  
            # since status is 200 OK read the URLs
            body = response.read()
  
            # decode the JSON
            urlList = cjson.decode(body)
            lfnDict = {}
            for url in urlList:
              path = urlparse.urlparse(url)[2]
              lfn = os.path.split(path)[1]
              lfnDict[lfn] = 1
  
            self.__lfn_list = lfnDict.keys()
            self.__lfn_list.sort()
  
        return self.__lfn_list
      else:
        return self.__output