glue.datafind

85 """Connection to LIGO data replicator service using HTTP. 86 87 @param host: the name of the server with which to connect 88 @param port: the port on which to connect 89 @param **kwargs: other keyword arguments accepted by 90 L{httplib.HTTPConnection} 91 92 @type host: L{str} 93 @type port: L{int} 94 """ 95 LIGOTimeGPSType = lal.LIGOTimeGPS

96 - def __init__(self, host=None, **kwargs):

97 """Connect to the LDR host using HTTPS. Default host is 98 defined by the %s environment variable. 99 """ 100 if not host: 101 host,port = find_server() 102 kwargs.setdefault("port", port) 103 six.moves.http_client.HTTPConnection.__init__(self, host, **kwargs)

104 __init__.__doc__ %= _server_env 105

106 - def _requestresponse(self, method, url, body=None, headers={}):

107 """Internal method to perform request and verify reponse. 108 109 @param method: name of the method to use (e.g. 'GET') 110 @param url : remote URL to query 111 112 @type method: L{str} 113 @type url : L{str} 114 115 @returns: L{str} response from server query 116 117 @raises RuntimeError: if query is unsuccessful 118 """ 119 try: 120 self.request(method, url) 121 response = self.getresponse() 122 except Exception as e: 123 raise RuntimeError("Unable to query server %s: %s\n\n" 124 "Perhaps you need a valid proxy credential?\n" 125 % (self.host, e)) 126 if response.status != 200: 127 raise RuntimeError("Server returned code %d: %s%s" 128 % (response.status, response.reason, 129 response.read())) 130 return response

131

132 - def ping(self):

133 """Ping the LDR host to test for life 134 135 @raises RuntimeError: when ping fails 136 @returns: 0 if ping was successful 137 """ 138 url = "%s/gwf/%s/%s/%s,%s" % (_url_prefix, 'H', 'R', '1', '2') 139 self._requestresponse("HEAD", url) 140 return 0

141

142 - def find_observatories(self, match=None):

143 """Query the LDR host for observatories. Use match to 144 restrict returned observatories to those matching the 145 regular expression. 146 147 Example: 148 149 >>> connection.find_observatories() 150 ['AGHLT', 'G', 'GHLTV', 'GHLV', 'GHT', 'H', 'HL', 'HLT', 151 'L', 'T', 'V', 'Z'] 152 >>> connection.find_observatories("H") 153 ['H', 'HL', 'HLT'] 154 155 @type match: L{str} 156 @param match: 157 name to match return observatories against 158 159 @returns: L{list} of observatory prefixes 160 """ 161 url = "%s/gwf.json" % _url_prefix 162 response = self._requestresponse("GET", url) 163 sitelist = sorted(set(decode(response.read()))) 164 if match: 165 regmatch = re.compile(match) 166 sitelist = [site for site in sitelist if regmatch.search(site)] 167 return sitelist

168

169 - def find_types(self, site=None, match=None):

170 """Query the LDR host for frame types. Use site to restrict 171 query to given observatory prefix, and use match to restrict 172 returned types to those matching the regular expression. 173 174 Example: 175 176 >>> connection.find_types("L", "RDS") 177 ['L1_RDS_C01_LX', 178 'L1_RDS_C02_LX', 179 'L1_RDS_C03_L2', 180 'L1_RDS_R_L1', 181 'L1_RDS_R_L3', 182 'L1_RDS_R_L4', 183 'PEM_RDS_A6', 184 'RDS_R_L1', 185 'RDS_R_L2', 186 'RDS_R_L3', 187 'TESTPEM_RDS_A6'] 188 189 @param site: single-character name of site to match 190 @param match: type-name to match against 191 192 @type site: L{str} 193 @type match: L{str} 194 195 @returns: L{list} of frame types 196 """ 197 if site: 198 url = "%s/gwf/%s.json" % (_url_prefix, site[0]) 199 else: 200 url = "%s/gwf/all.json" % _url_prefix 201 response = self._requestresponse("GET", url) 202 typelist = sorted(set(decode(response.read()))) 203 if match: 204 regmatch = re.compile(match) 205 typelist = [type for type in typelist if regmatch.search(type)] 206 return typelist

207

208 - def find_times(self, site, frametype, gpsstart=None, gpsend=None):

209 """Query the LDR for times for which frames are avaliable 210 211 Use gpsstart and gpsend to restrict the returned times to 212 this semiopen interval. 213 214 @returns: L{segmentlist<glue.segments.segmentlist>} 215 216 @param site: 217 single-character name of site to match 218 @param frametype: 219 name of frametype to match 220 @param gpsstart: 221 integer GPS start time of query 222 @param gpsend: 223 integer GPS end time of query 224 225 @type site: L{str} 226 @type frametype: L{str} 227 @type gpsstart: L{int} 228 @type gpsend: L{int} 229 """ 230 if gpsstart and gpsend: 231 url = ("%s/gwf/%s/%s/segments/%d,%d.json" 232 % (_url_prefix, site, frametype, gpsstart, gpsend)) 233 else: 234 url = ("%s/gwf/%s/%s/segments.json" 235 % (_url_prefix, site, frametype)) 236 237 response = self._requestresponse("GET", url) 238 segmentlist = decode(response.read()) 239 return segments.segmentlist(map(segments.segment, segmentlist))

240

241 - def find_frame(self, framefile, urltype=None, on_missing="warn"):

242 """Query the LDR host for a single framefile 243 244 @returns: L{Cache<glue.lal.Cache>} 245 246 @param frametype: 247 name of frametype to match 248 @param urltype: 249 file scheme to search for (e.g. 'file') 250 @param on_missing: 251 what to do when the requested frame isn't found, one of: 252 - C{'warn'} (default): print a warning, 253 - C{'error'}: raise an L{RuntimeError}, or 254 - C{'ignore'}: do nothing 255 256 @type frametype: L{str} 257 @type urltype: L{str} 258 @type on_missing: L{str} 259 260 @raises RuntimeError: if given framefile is malformed 261 """ 262 if on_missing not in ("warn", "error", "ignore"): 263 raise ValueError("on_missing must be 'warn', 'error', or 'ignore'.") 264 framefile = os.path.basename(framefile) 265 # parse file name for site, frame type 266 try: 267 site,frametype,_,_ = framefile.split("-") 268 except Exception as e: 269 raise RuntimeError("Error parsing filename %s: %s" % (framefile, e)) 270 url = ("%s/gwf/%s/%s/%s.json" 271 % (_url_prefix, site, frametype, framefile)) 272 response = self._requestresponse("GET", url) 273 urllist = decode(response.read()) 274 if len(urllist) == 0: 275 if on_missing == "warn": 276 sys.stderr.write("No files found!\n") 277 elif on_missing == "error": 278 raise RuntimeError("No files found!") 279 # verify urltype is what we want 280 cache = lal.Cache(e for e in 281 [lal.CacheEntry.from_T050017(x, coltype=self.LIGOTimeGPSType) 282 for x in urllist] if not urltype or e.scheme == urltype) 283 return cache

284

285 - def find_latest(self, site, frametype, urltype=None, on_missing="warn"):

286 """Query for the most recent framefile of a given type. 287 288 @param site: 289 single-character name of site to match 290 @param frametype: 291 name of frametype to match 292 @param urltype: 293 file scheme to search for (e.g. 'file') 294 @param on_missing: 295 what to do when the requested frame isn't found, one of: 296 - C{'warn'} (default): print a warning, 297 - C{'error'}: raise an L{RuntimeError}, or 298 - C{'ignore'}: do nothing 299 300 @type site: L{str} 301 @type frametype: L{str} 302 @type urltype: L{str} 303 @type on_missing: L{str} 304 305 @returns: L{Cache<glue.lal.Cache>} with one 306 L{entry<glue.lal.CacheEntry>} 307 308 @raises RuntimeError: if given framefile is malformed 309 @raises RuntimeError: if no frames are found and C{on_missing='error'} 310 """ 311 if on_missing not in ('warn', 'error', 'ignore'): 312 raise ValueError("on_missing must be 'warn', 'error', or 'ignore'.") 313 url = "%s/gwf/%s/%s/latest" % (_url_prefix, site, frametype) 314 # if a URL type is specified append it to the path 315 if urltype: 316 url += "/%s" % urltype 317 # request JSON output 318 url += ".json" 319 response = self._requestresponse("GET", url) 320 urllist = decode(response.read()) 321 if len(urllist) == 0: 322 if on_missing == "warn": 323 sys.stderr.write("No files found!\n") 324 elif on_missing == "error": 325 raise RuntimeError("No files found!") 326 return lal.Cache([lal.CacheEntry.from_T050017(x, 327 coltype=self.LIGOTimeGPSType) for x in urllist])

328

329 - def find_frame_urls(self, site, frametype, gpsstart, gpsend, 330 match=None, urltype=None, on_gaps="warn"):

331 """Find the framefiles for the given type in the [start, end) interval 332 frame 333 334 @param site: 335 single-character name of site to match 336 @param frametype: 337 name of frametype to match 338 @param gpsstart: 339 integer GPS start time of query 340 @param gpsend: 341 integer GPS end time of query 342 @param match: 343 regular expression to match against 344 @param urltype: 345 file scheme to search for (e.g. 'file') 346 @param on_gaps: 347 what to do when the requested frame isn't found, one of: 348 - C{'warn'} (default): print a warning, 349 - C{'error'}: raise an L{RuntimeError}, or 350 - C{'ignore'}: do nothing 351 352 @type site: L{str} 353 @type frametype: L{str} 354 @type gpsstart: L{int} 355 @type gpsend: L{int} 356 @type match: L{str} 357 @type urltype: L{str} 358 @type on_gaps: L{str} 359 360 @returns: L{Cache<glue.lal.Cache>} 361 362 @raises RuntimeError: if gaps are found and C{on_gaps='error'} 363 """ 364 if on_gaps not in ("warn", "error", "ignore"): 365 raise ValueError("on_gaps must be 'warn', 'error', or 'ignore'.") 366 url = ("%s/gwf/%s/%s/%s,%s" 367 % (_url_prefix, site, frametype, gpsstart, gpsend)) 368 # if a URL type is specified append it to the path 369 if urltype: 370 url += "/%s" % urltype 371 # request JSON output 372 url += ".json" 373 # append a regex if input 374 if match: 375 url += "?match=%s" % match 376 # make query 377 response = self._requestresponse("GET", url) 378 urllist = decode(response.read()) 379 380 out = lal.Cache([lal.CacheEntry.from_T050017(x, 381 coltype=self.LIGOTimeGPSType) for x in urllist]) 382 383 if on_gaps == "ignore": 384 return out 385 else: 386 span = segments.segment(gpsstart, gpsend) 387 seglist = segments.segmentlist(e.segment for e in out).coalesce() 388 missing = (segments.segmentlist([span]) - seglist).coalesce() 389 if span in seglist: 390 return out 391 else: 392 msg = "Missing segments: \n%s" % "\n".join(map(str, missing)) 393 if on_gaps=="warn": 394 sys.stderr.write("%s\n" % msg) 395 return out 396 else: 397 raise RuntimeError(msg)

Source Code for Module glue.datafind