[PanSTARRS DR1 Downloader] Download the StackObjectThin and StackObjectAttributes Tables from MAST #panstarrs #dr1 #casjobs #sherlock
| #!/usr/local/bin/python | |
| # encoding: utf-8 | |
| """ | |
| *Download the PanSTARRS DR1 Catalogue from MAST via CasJobs into FITS files containing 500,000 rows each* | |
| :Author: | |
| David Young | |
| :Date Created: | |
| June 18, 2018 | |
| Usage: | |
| panstarrs_dr1_downloader | |
| Options: | |
| -h, --help show this help message | |
| """ | |
| ################# GLOBAL IMPORTS #################### | |
| import sys | |
| import os | |
| from fundamentals import tools | |
| import yaml | |
| import urllib | |
| from subprocess32 import Popen, PIPE, STDOUT, TimeoutExpired | |
| import uuid as pyuuid | |
| import re | |
| import requests | |
| import shutil | |
| from fundamentals.download import multiobject_download | |
| import time | |
| from datetime import datetime, date | |
| from dateutil.relativedelta import relativedelta | |
| import uuid as pyuuid | |
| querySize = 2500000 | |
| def main(arguments=None): | |
| """ | |
| *The main function used when ``panstarrs_dr1_downloader.py`` is run as a single script from the cl* | |
| """ | |
| # SETUP THE COMMAND-LINE UTIL SETTINGS | |
| su = tools( | |
| arguments=arguments, | |
| docString=__doc__, | |
| logLevel="INFO", | |
| options_first=False, | |
| projectName=False | |
| ) | |
| arguments, settings, log, dbConn = su.setup() | |
| # UNPACK REMAINING CL ARGUMENTS USING `EXEC` TO SETUP THE VARIABLE NAMES | |
| # AUTOMATICALLY | |
| for arg, val in arguments.iteritems(): | |
| if arg[0] == "-": | |
| varname = arg.replace("-", "") + "Flag" | |
| else: | |
| varname = arg.replace("<", "").replace(">", "") | |
| if isinstance(val, str) or isinstance(val, unicode): | |
| exec(varname + " = '%s'" % (val,)) | |
| else: | |
| exec(varname + " = %s" % (val,)) | |
| if arg == "--dbConn": | |
| dbConn = val | |
| log.debug('%s = %s' % (varname, val,)) | |
| # GENERATE BOOKKEEPING YAML DATABASE | |
| bkfileName = "bookkeeper.yaml" | |
| exists = os.path.exists(bkfileName) | |
| if not exists: | |
| bookkeeper = {} | |
| joblist = ["one", "two", "three", "four", | |
| "five", "six", "seven", "eight"] | |
| bookkeeper["jobs"] = {} | |
| for j in joblist: | |
| bookkeeper["jobs"][j] = { | |
| "max_objid": 0, | |
| "thin_job_id": 0, | |
| "attr_job_id": None, | |
| "status": None | |
| } | |
| bookkeeper["master_max_objid"] = 0 | |
| bookkeeper["rows_downloaded"] = 0 | |
| stream = file(bkfileName, 'w') | |
| yaml.dump(bookkeeper, stream, default_flow_style=False) | |
| stream.close() | |
| time.sleep(1) | |
| # OPEN BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| # LOOP THROUGH OVER QUERIES AND DOWNLOADS UNTIL HIGHEST OBJID IS REACHED | |
| while bookkeeper["master_max_objid"] < 215993524933671565: | |
| # OPEN BOOKKEEPER | |
| log.info('RESTARTING THE LOOP' % locals()) | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| stream.close() | |
| log.info('1. starting new queries' % locals()) | |
| start_new_queries(log) | |
| log.info('2. extracting query results from MyDB' % locals()) | |
| extract_results(log) | |
| log.info('3. dropping the MyDB tables' % locals()) | |
| drop_tables(log) | |
| log.info('4. downloading the output fits files' % locals()) | |
| download_results(log) | |
| log.info('5. restarting failed jobs' % locals()) | |
| restart_failed_jobs(log) | |
| log.info('6. killing timed out jobs' % locals()) | |
| timeout_long_running_jobs(log) | |
| # INCREMENTAL BOOKKEEPER BACKUP | |
| now = datetime.now() | |
| now = now.strftime("%Y%m%dt%H") | |
| shutil.copyfile('bookkeeper.yaml', | |
| 'bookkeeper_%(now)s.yaml' % locals()) | |
| return | |
| def current_jobs( | |
| log): | |
| """*check casjobs for any currently running jobs and return job IDs* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| **Return:** | |
| - ``jobs`` -- list of currently running job IDs | |
| """ | |
| log.debug('starting the ``current_jobs`` function') | |
| cmd = """java -jar /usr/local/bin/casjobs.jar jobs -status running""" % locals() | |
| p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| log.debug('output: %(stdout)s' % locals()) | |
| if "no jobs found" not in stdout.lower(): | |
| jobs = [] | |
| regex = re.compile(r'JobID: (\d+)') | |
| regexIterator = regex.finditer(stdout) | |
| for match in regexIterator: | |
| jobs.append(int(match.group(1))) | |
| else: | |
| jobs = [] | |
| log.debug('completed the ``current_jobs`` function') | |
| return jobs | |
| def start_new_queries( | |
| log): | |
| """*Find empty jobs and start new queries* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| **Return:** | |
| - None | |
| """ | |
| log.debug('starting the ``start_new_queries`` function') | |
| global querySize | |
| # READ BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| stream.close() | |
| # NUMBER OF ROWS PER FILE | |
| numberRows = querySize | |
| # ITERATE OVER 8 JOBS AND TRIGGER NEW QUERIES IF THERE IS SPACE AVAILABLE | |
| # (i.e STATUS IS COMPLETE) | |
| for k, v in bookkeeper["jobs"].iteritems(): | |
| if not v["status"] or v["status"] == "complete": | |
| # USE THE OLD MAX OBJID FOR QUERY LOWER LIMIT - COLLECT NEW MAX ID | |
| # 500,000 ROWS ON | |
| oldMaxId = int(bookkeeper["master_max_objid"]) | |
| newMaxId = None | |
| while newMaxId == None: | |
| newMaxId = get_next_maxid(log) | |
| # NEW STACK ATTR QUERY TO COLLECT 500,000 ROWS | |
| uuid = "a" + newMaxId | |
| query = """SELECT top %(numberRows)s into myDB.%(uuid)s objID, uniquePspsSTid, gpsfLikelihood, gmomentR1, gmomentRH, gKronRad, gExtNSigma, rpsfLikelihood, rmomentR1, rmomentRH, rKronRad, rExtNSigma, ipsfLikelihood, imomentR1, imomentRH, iKronRad, iExtNSigma, zpsfLikelihood, zmomentR1, zmomentRH, zKronRad, zExtNSigma, ypsfLikelihood, ymomentR1, ymomentRH, yKronRad, yExtNSigma from StackObjectAttributes WHERE primaryDetection = 1 and objid > %(oldMaxId)s order by objid""" % locals() | |
| jobId = submit_query(log=log, query=query, uuid=uuid) | |
| bookkeeper["jobs"][k]["attr_job_id"] = int(jobId) | |
| time.sleep(1) | |
| # NEW STACK THIN QUERY TO COLLECT 500,000 ROWS | |
| uuid = "t" + newMaxId | |
| query = """SELECT top %(numberRows)s into myDB.%(uuid)s objID, uniquePspsSTid, primaryDetection, bestDetection, gra, gdec, gPSFMag, gPSFMagErr, gApMag, gApMagErr, gKronMag, gKronMagErr, ginfoFlag, ginfoFlag2, ginfoFlag3, rra, rdec, rPSFMag, rPSFMagErr, rApMag, rApMagErr, rKronMag, rKronMagErr, rinfoFlag, rinfoFlag2, rinfoFlag3, ira, idec, iPSFMag, iPSFMagErr, iApMag, iApMagErr, iKronMag, iKronMagErr, iinfoFlag, iinfoFlag2, iinfoFlag3, zra, zdec, zPSFMag, zPSFMagErr, zApMag, zApMagErr, zKronMag, zKronMagErr, zinfoFlag, zinfoFlag2, zinfoFlag3, yra, ydec, yPSFMag, yPSFMagErr, yApMag, yApMagErr, yKronMag, yKronMagErr, yinfoFlag, yinfoFlag2, yinfoFlag3 from StackObjectThin WHERE primaryDetection = 1 and objid > %(oldMaxId)s order by objid""" % locals() | |
| jobId = submit_query(log=log, query=query, uuid=uuid) | |
| bookkeeper["jobs"][k]["thin_job_id"] = int(jobId) | |
| bookkeeper["jobs"][k]["status"] = "running" | |
| bookkeeper["jobs"][k]["max_objid"] = int(newMaxId) | |
| bookkeeper["jobs"][k]["min_objid"] = oldMaxId | |
| bookkeeper["master_max_objid"] = int(newMaxId) | |
| # UPDATE BOOKKEEPING FILE WITH THE QUERY JOB IDS | |
| stream = file('bookkeeper.yaml', 'w') | |
| yaml.dump(bookkeeper, stream, default_flow_style=False) | |
| stream.close() | |
| time.sleep(1) | |
| log.debug('completed the ``start_new_queries`` function') | |
| return None | |
| def extract_results( | |
| log): | |
| """*check on running jobs and request to extract the results for those jobs that have finished* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| **Return:** | |
| - None | |
| """ | |
| log.debug('starting the ``extract_results`` function') | |
| # READ BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| stream.close() | |
| # ITERATE THORUGH JOBS - IF RUNNING CHECK IF JOBS IS COMPLETE. | |
| for k, v in bookkeeper["jobs"].iteritems(): | |
| if v["status"] == "running": | |
| for thisId in [v["attr_job_id"], v["thin_job_id"]]: | |
| extract = True | |
| status = query_job_status(log=log, jobId=thisId) | |
| if status == "failed" or status == None: | |
| extract = False | |
| bookkeeper["jobs"][k]["status"] = "failed" | |
| if status != "complete": | |
| extract = False | |
| break | |
| # IF BOTH THIN AND ATTR QUERIES COMPLETE THEN TRIGGER EXTRACT TO | |
| # FITS | |
| if extract: | |
| # BOTH JOBS COMPLETE - EXTRACT | |
| maxId = int(v["max_objid"]) | |
| query = "java -jar /usr/local/bin/casjobs.jar extract -a FITS -b a%(maxId)s" % locals( | |
| ) | |
| os.system(query) | |
| query = "java -jar /usr/local/bin/casjobs.jar extract -a FITS -b t%(maxId)s" % locals( | |
| ) | |
| os.system(query) | |
| bookkeeper["jobs"][k]["status"] = "extracting" | |
| # UPDATE BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'w') | |
| yaml.dump(bookkeeper, stream, default_flow_style=False) | |
| stream.close() | |
| time.sleep(1) | |
| log.debug('completed the ``extract_results`` function') | |
| return None | |
| def download_results( | |
| log): | |
| """*download the FITS files for tables that have been extracted and dropped* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| **Return:** | |
| - None | |
| """ | |
| log.debug('starting the ``download_results`` function') | |
| global querySize | |
| # READ BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| stream.close() | |
| downloads = [] | |
| filenames = [] | |
| jobNumbers = [] | |
| found = None | |
| for k, v in bookkeeper["jobs"].iteritems(): | |
| if v["status"] == "dropping" and not found: | |
| maxId = v["max_objid"] | |
| urls = ["a", "t"] | |
| downloaded = True | |
| for u in urls: | |
| if u == 't': | |
| thisId = v["thin_job_id"] | |
| else: | |
| thisId = v["attr_job_id"] | |
| status = query_job_status(log=log, jobId=thisId) | |
| if status != "complete": | |
| downloaded = False | |
| break | |
| # IF TABLE IS DROPPED EXPORT RESULTS | |
| local_filename = "%(u)s%(maxId)0.18d.fits" % locals() | |
| url = "http://ps1images.stsci.edu/datadelivery/outgoing/casjobs/fits/%(u)s%(maxId)s_daveyoung.fit" % locals( | |
| ) | |
| downloads.append(url) | |
| filenames.append(local_filename) | |
| jobNumbers.append(k) | |
| found = True | |
| if len(filenames): | |
| this = (" and ").join(filenames) | |
| print "Downloading %(this)s" % locals() | |
| localUrls = multiobject_download( | |
| urlList=downloads, | |
| downloadDirectory="./", | |
| log=log, | |
| timeStamp=False, | |
| timeout=500, | |
| concurrentDownloads=2, | |
| resetFilename=filenames, | |
| credentials=False, | |
| longTime=False, | |
| indexFilenames=False | |
| ) | |
| downloaded = [] | |
| for l, j in zip(localUrls, jobNumbers): | |
| if l and j in downloaded: | |
| bookkeeper["jobs"][j]["status"] = "complete" | |
| bookkeeper["rows_downloaded"] = int( | |
| bookkeeper["rows_downloaded"]) + querySize | |
| elif l: | |
| downloaded.append(j) | |
| elif not l and j in downloaded: | |
| bookkeeper["jobs"][j]["status"] = "onefailed" | |
| for j in jobNumbers: | |
| if j not in downloaded: | |
| bookkeeper["jobs"][j]["status"] = "failed" | |
| # UPDATE BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'w') | |
| yaml.dump(bookkeeper, stream, default_flow_style=False) | |
| stream.close() | |
| time.sleep(1) | |
| log.debug('completed the ``download_results`` function') | |
| return None | |
| def drop_tables( | |
| log): | |
| """*if tables are being extracted try and drop the database tables* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| **Return:** | |
| - None | |
| """ | |
| log.debug('starting the ``drop_tables`` function') | |
| # READ BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| stream.close() | |
| # TEST IF PREVIOUS DROPS WORKED - IF NOT TRY AGAIN | |
| for k, v in bookkeeper["jobs"].iteritems(): | |
| if v["status"] == "dropping": | |
| maxId = v["max_objid"] | |
| urls = ["a", "t"] | |
| for u in urls: | |
| if u == 't': | |
| thisId = v["thin_job_id"] | |
| else: | |
| thisId = v["attr_job_id"] | |
| status = query_job_status(log=log, jobId=thisId) | |
| if status == None: | |
| bookkeeper["jobs"][k]["status"] = "failed" | |
| elif status == "failed": | |
| # TEST TABLE EXISTS | |
| query = """java -jar /usr/local/bin/casjobs.jar tables """ % locals( | |
| ) | |
| p = Popen(query, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| if "%(u)s%(maxId)s" % locals() not in stdout: | |
| bookkeeper["jobs"][k]["status"] = "failed" | |
| else: | |
| # SHOULD NOT BE ABLE TO DROP TABLE IF EXPORT IS | |
| # ONGOING | |
| query = """drop table %(u)s%(maxId)s""" % locals( | |
| ) | |
| jobId = submit_query( | |
| log=log, query=query, uuid=pyuuid.uuid1(), scheme="MyDB") | |
| if u == "a": | |
| bookkeeper["jobs"][k][ | |
| "attr_job_id"] = int(jobId) | |
| else: | |
| bookkeeper["jobs"][k][ | |
| "thin_job_id"] = int(jobId) | |
| # UPDATE BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'w') | |
| yaml.dump(bookkeeper, stream, default_flow_style=False) | |
| stream.close() | |
| time.sleep(1) | |
| # FOR TABLES THAT ARE BEING EXTRACTED TRY AND DUMP THE TABLE - WILL FAIL | |
| # IF STILL EXTRACTING | |
| for k, v in bookkeeper["jobs"].iteritems(): | |
| if v["status"] == "extracting": | |
| maxId = v["max_objid"] | |
| prefix = ["a", "t"] | |
| for u in prefix: | |
| # SHOULD NOT BE ABLE TO DROP TABLE IF EXPORT IS ONGOING | |
| query = """drop table %(u)s%(maxId)s""" % locals( | |
| ) | |
| jobId = submit_query(log=log, query=query, | |
| uuid=pyuuid.uuid1(), scheme="MyDB") | |
| if u == "a": | |
| bookkeeper["jobs"][k]["attr_job_id"] = int(jobId) | |
| else: | |
| bookkeeper["jobs"][k]["thin_job_id"] = int(jobId) | |
| bookkeeper["jobs"][k]["status"] = "dropping" | |
| # UPDATE BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'w') | |
| yaml.dump(bookkeeper, stream, default_flow_style=False) | |
| stream.close() | |
| time.sleep(1) | |
| log.debug('completed the ``drop_tables`` function') | |
| return None | |
| def restart_failed_jobs( | |
| log): | |
| """*try and restart failed queries* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| **Return:** | |
| - None | |
| """ | |
| log.debug('starting the ``restart_failed_jobs`` function') | |
| global querySize | |
| # NUMBER OF ROWS PER FILE | |
| numberRows = querySize | |
| # READ BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| stream.close() | |
| # RESTART FAILED JOBS | |
| for k, v in bookkeeper["jobs"].iteritems(): | |
| if v["status"] == "failed": | |
| maxId = v["max_objid"] | |
| minId = int(v["min_objid"]) | |
| urls = ["a", "t"] | |
| # MAKE SURE BOTH JOBS ARE COMPLETED/FAILED | |
| completed = True | |
| for u in urls: | |
| if u == 't': | |
| thisId = v["thin_job_id"] | |
| else: | |
| thisId = v["attr_job_id"] | |
| status = query_job_status(log, thisId) | |
| if status and status not in ["failed", "complete"]: | |
| completed = False | |
| print status, status, status | |
| if not completed: | |
| continue | |
| tableExists = True | |
| while tableExists: | |
| tableExists = False | |
| for u in urls: | |
| if u == 't': | |
| thisId = v["thin_job_id"] | |
| else: | |
| thisId = v["attr_job_id"] | |
| # TEST IF TABLE EXISTS | |
| query = """java -jar /usr/local/bin/casjobs.jar tables """ % locals( | |
| ) | |
| p = Popen(query, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| thisTable = "%(u)s%(maxId)s" % locals() | |
| if thisTable in stdout: | |
| # TRY AND DROP TABLE | |
| tableExists = True | |
| exists = True | |
| query = """java -jar /usr/local/bin/casjobs.jar execute -t "MyDB" "drop table %(thisTable)s" """ % locals( | |
| ) | |
| p = Popen(query, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| time.sleep(1) | |
| # NEW STACK ATTR QUERY TO COLLECT 500,000 ROWS | |
| uuid = "a" + str(maxId) | |
| query = """SELECT top %(numberRows)s into myDB.%(uuid)s objID, uniquePspsSTid, gpsfLikelihood, gmomentR1, gmomentRH, gKronRad, gExtNSigma, rpsfLikelihood, rmomentR1, rmomentRH, rKronRad, rExtNSigma, ipsfLikelihood, imomentR1, imomentRH, iKronRad, iExtNSigma, zpsfLikelihood, zmomentR1, zmomentRH, zKronRad, zExtNSigma, ypsfLikelihood, ymomentR1, ymomentRH, yKronRad, yExtNSigma from StackObjectAttributes WHERE primaryDetection = 1 and objid > %(minId)s order by objid """ % locals() | |
| jobId = submit_query(log=log, query=query, uuid=uuid) | |
| bookkeeper["jobs"][k]["attr_job_id"] = int(jobId) | |
| time.sleep(1) | |
| # NEW STACK THIN QUERY TO COLLECT 500,000 ROWS | |
| uuid = "t" + str(maxId) | |
| query = """SELECT top %(numberRows)s into myDB.%(uuid)s objID, uniquePspsSTid, primaryDetection, bestDetection, gra, gdec, gPSFMag, gPSFMagErr, gApMag, gApMagErr, gKronMag, gKronMagErr, ginfoFlag, ginfoFlag2, ginfoFlag3, rra, rdec, rPSFMag, rPSFMagErr, rApMag, rApMagErr, rKronMag, rKronMagErr, rinfoFlag, rinfoFlag2, rinfoFlag3, ira, idec, iPSFMag, iPSFMagErr, iApMag, iApMagErr, iKronMag, iKronMagErr, iinfoFlag, iinfoFlag2, iinfoFlag3, zra, zdec, zPSFMag, zPSFMagErr, zApMag, zApMagErr, zKronMag, zKronMagErr, zinfoFlag, zinfoFlag2, zinfoFlag3, yra, ydec, yPSFMag, yPSFMagErr, yApMag, yApMagErr, yKronMag, yKronMagErr, yinfoFlag, yinfoFlag2, yinfoFlag3 from StackObjectThin WHERE primaryDetection = 1 and objid > %(minId)s order by objid""" % locals() | |
| jobId = submit_query(log=log, query=query, uuid=uuid) | |
| bookkeeper["jobs"][k]["thin_job_id"] = int(jobId) | |
| bookkeeper["jobs"][k]["status"] = "running" | |
| # UPDATE BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'w') | |
| yaml.dump(bookkeeper, stream, default_flow_style=False) | |
| stream.close() | |
| time.sleep(1) | |
| log.debug('completed the ``restart_failed_jobs`` function') | |
| return None | |
| # use the tab-trigger below for new function | |
| def timeout_long_running_jobs( | |
| log): | |
| """*check for jobs that have been running/stuck for a long peroid of time and cancel them to unclog the queue* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| **Return:** | |
| - None | |
| """ | |
| log.debug('starting the ``timeout_long_running_jobs`` function') | |
| # READ BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| stream.close() | |
| # GRAB ALL RUNNING JOBS | |
| query = """java -jar /usr/local/bin/casjobs.jar j -t started """ % locals( | |
| ) | |
| p = Popen(query, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| regex = re.compile( | |
| r'Jobid: (?P<jobid>\d+).*?\nStatus:\s+(?P<status>.*?)\s+submitted: (?P<datetime>.*?)\s+Completed', re.S | re.I) | |
| now = datetime.utcnow() | |
| thisIter = regex.finditer(stdout) | |
| for item in thisIter: | |
| thisId = item.group("jobid") | |
| try: | |
| jobStart = datetime.strptime( | |
| item.group("datetime"), '%m/%d/%Y %H:%M') | |
| jobStart = jobStart + relativedelta(months=1) | |
| except: | |
| jobStart = datetime.strptime(item.group( | |
| "datetime").replace("0/", "1/", 1), '%m/%d/%Y %H:%M') | |
| if now.hour > jobStart.hour: | |
| jobStart = jobStart + relativedelta(hours=12) | |
| jobStart = jobStart - relativedelta(hours=1) | |
| diff = now - jobStart | |
| diffMin = diff.days / (24 * 60) + diff.seconds / 60 | |
| if diffMin > 180: | |
| for k, v in bookkeeper["jobs"].iteritems(): | |
| if bookkeeper["jobs"][k]["attr_job_id"] == thisId: | |
| bookkeeper["jobs"][k]["status"] = "failed" | |
| if bookkeeper["jobs"][k]["thin_job_id"] == thisId: | |
| bookkeeper["jobs"][k]["status"] = "failed" | |
| # print "open | |
| # http://mastweb.stsci.edu/ps1casjobs/cancelJob.aspx?id=%(thisId)s&CancelJob=Cancel+Job" | |
| # % locals() | |
| # UPDATE BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'w') | |
| yaml.dump(bookkeeper, stream, default_flow_style=False) | |
| stream.close() | |
| time.sleep(1) | |
| log.debug('completed the ``timeout_long_running_jobs`` function') | |
| return None | |
| def submit_query( | |
| log, | |
| query, | |
| uuid, | |
| scheme="PanSTARRS_DR1"): | |
| """*submit a query and return the job id* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| - ``query`` -- the MAST casjob query to submit | |
| - ``uuid`` -- the UUID with which to name the query and resulting database table | |
| - ``scheme`` -- the scheme to query | |
| **Return:** | |
| - ``jobID`` -- the job id from the submitted query | |
| """ | |
| log.debug('starting the ``submit_query`` function') | |
| query = """java -jar /usr/local/bin/casjobs.jar submit -t %(scheme)s -n "%(uuid)s" "%(query)s" """ % locals( | |
| ) | |
| p = Popen(query, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| log.debug('output: %(stdout)s' % locals()) | |
| matchObject = re.search(r"JobID is (\d+)", stdout) | |
| if matchObject: | |
| jobId = matchObject.group(1) | |
| else: | |
| jobId = None | |
| log.debug('completed the ``submit_query`` function') | |
| return jobId | |
| # use the tab-trigger below for new function | |
| def get_next_maxid( | |
| log): | |
| """*get the next maximum ID for the next batch of rows to request from MAST* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| **Return:** | |
| - ``maxid`` -- the maximum ID of the next batch of rows to request | |
| """ | |
| log.debug('starting the ``get_next_maxid`` function') | |
| global querySize | |
| # READ BOOKKEEPER | |
| stream = file('bookkeeper.yaml', 'r') | |
| bookkeeper = yaml.load(stream) | |
| stream.close() | |
| # NUMBER OF ROWS PER FILE | |
| numberRows = querySize | |
| oldMaxId = int(bookkeeper["master_max_objid"]) | |
| offset = numberRows - 1 | |
| query = """SELECT objID as maxId into myDB.maxid from StackObjectAttributes WHERE primaryDetection = 1 and objid > %(oldMaxId)s order by objid offset %(offset)s rows fetch next 1 rows only""" % locals( | |
| ) | |
| jobId = submit_query(log=log, query=query, uuid="maxid") | |
| waiting = True | |
| while waiting: | |
| time.sleep(10) | |
| status = query_job_status(log, jobId) | |
| if status.lower() == "complete": | |
| waiting = False | |
| query = """java -jar /usr/local/bin/casjobs.jar execute -t "MyDB" "select maxId from maxid" """ | |
| p = Popen(query, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| log.debug('output: %(stdout)s' % locals()) | |
| matchObject = re.search(r"\d{5,30}", stdout) | |
| if matchObject: | |
| maxid = matchObject.group() | |
| else: | |
| maxid = None | |
| elif status.lower() == "failed": | |
| log.error('cound not get maxid') | |
| waiting = False | |
| maxid = None | |
| # TEST TABLE EXISTS | |
| query = """java -jar /usr/local/bin/casjobs.jar tables """ % locals( | |
| ) | |
| p = Popen(query, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| if "maxid" in stdout.lower(): | |
| query = """drop table maxid""" % locals( | |
| ) | |
| jobId = submit_query( | |
| log=log, query=query, uuid=pyuuid.uuid1(), scheme="MyDB") | |
| waiting = True | |
| while waiting: | |
| time.sleep(10) | |
| status = query_job_status(log, jobId) | |
| if status.lower() == "complete": | |
| waiting = False | |
| log.debug('completed the ``get_next_maxid`` function') | |
| return maxid | |
| def query_job_status( | |
| log, | |
| jobId): | |
| """*query the status of a job* | |
| **Key Arguments:** | |
| - ``log`` -- logger | |
| - ``jobId`` -- the casjob job id to request a status for | |
| **Return:** | |
| - ``status`` -- the status of the job | |
| """ | |
| log.debug('starting the ``query_job_status`` function') | |
| status = None | |
| attempt = 0 | |
| while status == None and attempt != 3: | |
| query = """ java -jar /usr/local/bin/casjobs.jar jobs -j %(jobId)s """ % locals( | |
| ) | |
| log.debug("""query: `%(query)s`""" % locals()) | |
| p = Popen(query, stdout=PIPE, stderr=PIPE, shell=True) | |
| stdout, stderr = p.communicate() | |
| log.debug('output: %(stdout)s' % locals()) | |
| matchObject = re.search(r"Status: (\S+)", stdout) | |
| if matchObject: | |
| status = matchObject.group(1) | |
| if status == "failed" and "There is already an object" in stdout: | |
| status = "complete" | |
| else: | |
| log.error('cound not find status of jobid %(jobId)s' % locals()) | |
| attempt += 1 | |
| time.sleep(1) | |
| log.debug('completed the ``query_job_status`` function') | |
| return status | |
| # use the tab-trigger below for new function | |
| # xt-def-function | |
| if __name__ == '__main__': | |
| main() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment