def outcleanor(url, options):
print "Deprecated"
return
if duplicateLock(): return
do_not_autoapprove = []#'T2_FR_CCIN2P3']
LI = lockInfo()
sites_and_datasets = defaultdict(list)
our_copies = defaultdict(list)
wf_cleaned = {}
wfs = []
for fetch in options.fetch.split(','):
wfs.extend(session.query(Workflow).filter(Workflow.status==fetch).all())
random.shuffle( wfs )
last_answer = None
for wfo in wfs :
if options.number and len(wf_cleaned)>= options.number:
print "Reached",options.number,"cleaned"
break
print '-'*100
wfi = workflowInfo(url, wfo.name)
goes = {} # boolean per output
for dataset in wfi.request['OutputDatasets']:
goes[dataset] = False
keep_one_out = False ## change to no copy kept, since this is DDM handled
status = getDatasetStatus( dataset )
print "\n\tLooking at",dataset,status,"\n"
vetoes = None
if status == 'INVALID':
vetoes = ['Export','Buffer'] ## can take themselves out
keep_one_out = False # just wipe clean
elif status == None:
print dataset,"actually does not exist. skip"
goes[dataset] = True
continue
elif status in ['PRODUCTION','VALID'] and wfo.status in ['forget','trouble']:
print dataset,"should probably be invalidated. (",wfo.status,") skip"
keep_one_out = False # just wipe clean
continue ## you are not sure. just skip it for the time being
elif status == 'PRODUCTION' and wfo.status in ['clean']:
print dataset,"should probably be set valid .skip"
continue ## you are not sure. just skip it for the time being
if status == 'VALID' and dataset.startswith('/MinBias'):
print "This is a /MinBias. skip"
continue
if '/DQM' in dataset:
keep_one_out = False
custodials = findCustodialLocation(url, dataset)
if not len(custodials):
print dataset,"has no custodial site yet, excluding from cleaning"
continue
total_size = getDatasetSize( dataset )
our_presence = getDatasetPresence(url, dataset, complete=None, group="DataOps", vetoes=vetoes)
also_our_presence = getDatasetPresence(url, dataset, complete=None, group="", vetoes=vetoes)
## merge in one unique dict
for site in also_our_presence:
if site in our_presence:
there,frac = our_presence[site]
other,ofrac = also_our_presence[site]
our_presence[site] = (max(there,other),max(frac,ofrac))
else:
our_presence[site] = also_our_presence[site]
if our_presence: print our_presence
## analysis ops copies need to be taken into account
anaops_presence = getDatasetPresence(url, dataset, complete=None, group="AnalysisOps")
own_by_anaops = anaops_presence.keys()
## all our copies
to_be_cleaned = our_presence.keys()
if not len(to_be_cleaned):
print "nowhere to be found of ours,",len(own_by_anaops),"in analysi ops pool"
goes[dataset] = True
continue
print "Where we own bits of dataset"
print to_be_cleaned
if len(own_by_anaops):
## remove site with the anaops copies
to_be_cleaned = list(set(to_be_cleaned) - set(own_by_anaops))
keep_one_out = False ## in that case, just remove our copies
print "Own by anaops (therefore not keep a copy of ours)"
print own_by_anaops
else:
## we should not be looking at anything that was not passed to DDM, otherwise we'll be cutting the grass under our feet
using_the_same = getWorkflowByInput(url, dataset, details=True)
conflict = False
for other in using_the_same:
if other['RequestName'] == wfo.name: continue
if other['RequestType'] == 'Resubmission': continue
if not other['RequestStatus'] in ['announced','normal-archived','aborted','rejected','aborted-archived','rejected-archived','closed-out','None',None]:
print other['RequestName'],'is in status',other['RequestStatus'],'preventing from cleaning',dataset
conflict=True
break
if conflict:
continue
## not being used. a bit less dangerous to clean-out
## keep one full copy out there
full_copies = [site for (site,(there,fract)) in our_presence.items() if there]
if keep_one_out:
if not len(full_copies):
print "we do not own a full copy of",dataset,status,wfo.status,".skip"
continue
t1_full_copies = [ site for site in full_copies if site.startswith('T1')]
if t1_full_copies:
stay_there = random.choice( t1_full_copies ) #at a place own by ops
else:
stay_there = random.choice( full_copies ) #at a place own by ops
print "Where we keep a full copy", stay_there
to_be_cleaned.remove( stay_there )
our_copies[stay_there].append( dataset )
LI.release_except( dataset, stay_there, 'cleanup of output after production')
else:
print "We do not want to keep a copy of ",dataset,status,wfo.status
LI.release_everywhere( dataset, 'cleanup of output after production')
if len(to_be_cleaned):
print "Where we can clean"
print to_be_cleaned
for site in to_be_cleaned:
sites_and_datasets[site].append( (dataset, total_size*our_presence[site][1]/100., status) )
goes[dataset] = True
else:
print "no cleaning to be done"
goes[dataset] = True
print wfo.name,"scrutinized"
if all(goes.values()):
print "\t",wfo.name,"can toggle -out"
def ask():
global last_answer
last_answer = raw_input('go on ?')
return last_answer
if options.auto or ask() in ['y','']:
if all(goes.values()):
wfo.status = wfo.status+'-out'
wf_cleaned[wfo.name] = wfo.status
continue
elif last_answer in ['q','n']:
break
else:
return
if options.auto:
pass
elif last_answer in ['q']:
return
print "Potential cleanups"
for (site,items) in sites_and_datasets.items():
cleanup = sum([size for (_,size,_) in items])
print "\n\t potential cleanup of","%8.4f"%cleanup,"GB at ",site
print "\n".join([ds+" "+st for ds,_,st in items])
datasets = [ ds for ds,_,st in items]
print "Copies and bits we are going to delete"
print json.dumps( sites_and_datasets, indent=2)
print "Copies we are keeping"
print json.dumps( our_copies, indent=2 )
print "Workflows cleaned for output"
print json.dumps( wf_cleaned, indent=2 )
#stamp = time.strftime("%Y%m%d%H%M%S", time.localtime())
#open('outcleaning_%s.json'%stamp,'w').write( json.dumps( sites_and_datasets, indent=2))
#open('keepcopies_%s.json'%stamp,'w').write( json.dumps( our_copies, indent=2))
#open('wfcleanout_%s.json'%stamp,'w').write( json.dumps( wf_cleaned, indent=2))
if (not options.test) and (options.auto or raw_input("Satisfied ? (y will trigger status change and deletion requests)") in ['y']):
for (site,items) in sites_and_datasets.items():
#datasets = [ ds for ds,_,st in items]
#is_tape = any([v in site for v in ['MSS','Export','Buffer'] ])
#comments="Cleanup output after production. DataOps will take care of approving it."
#if is_tape:
# comments="Cleanup output after production."
#print "making deletion to",site
#result = makeDeleteRequest(url, site, datasets, comments=comments)
#print result
## approve it right away ?
#for did in [item['id'] for item in result['phedex']['request_created']]:
# if not is_tape:
# print "auto-approving to",site,"?"
# if not site in do_not_autoapprove:
# approveSubscription(url, did, nodes = [site], comments = 'Production cleaning by data ops, auto-approved')
# pass
pass
session.commit()
else:
print "Not making the deletion and changing statuses"
def checkor(url, spec=None, options=None):
fDB = falseDB()
wfs=[]
if options.fetch:
#workflows = getWorkflows(url, status='completed')
#for wf in workflows:
# wfo = session.query(Workflow).filter(Workflow.name == wf ).first()
# if wfo:
# if not wfo.status in ['away','assistance']: continue
# wfs.append(wfo )
wfs.extend( session.query(Workflow).filter(Workflow.status == 'away').all() )
wfs.extend( session.query(Workflow).filter(Workflow.status== 'assistance').all() )
else:
## than get all in need for assistance
wfs.extend( session.query(Workflow).filter(Workflow.status.startswith('assistance-')).all() )
custodials = defaultdict(list) #sites : dataset list
transfers = defaultdict(list) #sites : dataset list
invalidations = [] #a list of files
SI = siteInfo()
CI = campaignInfo()
def get_campaign(output, wfi):
campaign = None
try:
campaign = output.split('/')[2].split('-')[0]
except:
if 'Campaign' in wfi.request:
campaign = wfi.request['Campaign']
return campaign
for wfo in wfs:
if spec and not (spec in wfo.name): continue
## get info
wfi = workflowInfo(url, wfo.name)
## make sure the wm status is up to date.
# and send things back/forward if necessary.
wfo.wm_status = wfi.request['RequestStatus']
if wfo.wm_status == 'closed-out':
## manually closed-out
print wfo.name,"is already",wfo.wm_status
wfo.status = 'close'
session.commit()
continue
elif wfo.wm_status in ['failed','aborted','aborted-archived','rejected','rejected-archived']:
## went into trouble
wfo.status = 'trouble'
print wfo.name,"is in trouble",wfo.wm_status
session.commit()
continue
elif wfo.wm_status in ['assigned','acquired']:
## not worth checking yet
print wfo.name,"not running yet"
session.commit()
continue
if wfo.wm_status != 'completed':
## for sure move on with closeout check if in completed
print "no need to check on",wfo.name,"in status",wfo.wm_status
session.commit()
continue
session.commit()
sub_assistance="" # if that string is filled, there will be need for manual assistance
is_closing = True
## do the closed-out checks one by one
# tuck out DQMIO/DQM
wfi.request['OutputDatasets'] = [ out for out in wfi.request['OutputDatasets'] if not '/DQM' in out]
## anything running on acdc
familly = getWorkflowById(url, wfi.request['PrepID'], details=True)
acdc = []
for member in familly:
if member['RequestName'] == wfo.name: continue
if member['RequestDate'] < wfi.request['RequestDate']: continue
if member['RequestType'] != 'Resubmission': continue
if member['RequestStatus'] in ['running-opened','running-closed','assignment-approved','assigned','acquired']:
print wfo.name,"still has an ACDC running",member['RequestName']
acdc.append( member['RequestName'] )
#print json.dumps(member,indent=2)
## hook for just waiting ...
is_closing = False
## completion check
percent_completions = {}
event_expected,lumi_expected = wfi.request['TotalInputEvents'],wfi.request['TotalInputLumis']
fractions_pass = {}
for output in wfi.request['OutputDatasets']:
event_count,lumi_count = getDatasetEventsAndLumis(dataset=output)
percent_completions[output] = 0.
if lumi_expected:
percent_completions[output] = lumi_count / float( lumi_expected )
fractions_pass[output] = 0.95
c = get_campaign(output, wfi)
if c in CI.campaigns and 'fractionpass' in CI.campaigns[c]:
fractions_pass[output] = CI.campaigns[c]['fractionpass']
print "overriding fraction to",fractions_pass[output],"for",output
if options.fractionpass:
fractions_pass[output] = options.fractionpass
print "overriding fraction to",fractions_pass[output],"by command line for",output
if not all([percent_completions[out] > fractions_pass[out] for out in fractions_pass]):
print wfo.name,"is not completed"
print json.dumps(percent_completions, indent=2)
print json.dumps(fractions_pass, indent=2)
## hook for creating automatically ACDC ?
sub_assistance+='-recovery'
is_closing = False
## correct lumi < 300 event per lumi
events_per_lumi = {}
for output in wfi.request['OutputDatasets']:
events_per_lumi[output] = getDatasetEventsPerLumi( output )
lumi_upper_limit = {}
for output in wfi.request['OutputDatasets']:
upper_limit = 300.
campaign = get_campaign(output, wfi)
if campaign in CI.campaigns and 'lumisize' in CI.campaigns[campaign]:
upper_limit = CI.campaigns[campaign]['lumisize']
print "overriding the upper lumi size to",upper_limit,"for",campaign
if options.lumisize:
upper_limit = options.lumisize
print "overriding the upper lumi size to",upper_limit,"by command line"
lumi_upper_limit[output] = upper_limit
if any([ events_per_lumi[out] > lumi_upper_limit[out] for out in events_per_lumi]):
print wfo.name,"has big lumisections"
print json.dumps(events_per_lumi, indent=2)
## hook for rejecting the request ?
sub_assistance+='-biglumi'
is_closing = False
any_presence = {}
for output in wfi.request['OutputDatasets']:
any_presence[output] = getDatasetPresence(url, output, vetoes=[])
## custodial copy
custodial_locations = {}
custodial_presences = {}
for output in wfi.request['OutputDatasets']:
custodial_presences[output] = [s for s in any_presence[output] if 'MSS' in s]
custodial_locations[output] = phedexClient.getCustodialSubscriptionRequestSite(output)
if not custodial_locations[output]:
custodial_locations[output] = []
vetoed_custodial_tier = ['MINIAODSIM']
out_worth_checking = [out for out in custodial_locations.keys() if out.split('/')[-1] not in vetoed_custodial_tier]
if not all(map( lambda sites : len(sites)!=0, [custodial_locations[out] for out in out_worth_checking])):
print wfo.name,"has not all custodial location"
print json.dumps(custodial_locations, indent=2)
##########
## hook for making a custodial replica ?
custodial = None
## get from other outputs
for output in out_worth_checking:
if len(custodial_locations[output]):
custodial = custodial_locations[output][0]
## try to get it from campaign configuration
if not custodial:
for output in out_worth_checking:
campaign = get_campaign(output, wfi)
if campaign in CI.campaigns and 'custodial' in CI.campaigns[campaign]:
custodial = CI.campaigns[campaign]['custodial']
print "Setting custodial to",custodial,"from campaign configuration"
break
## get from the parent
if not custodial and 'InputDataset' in wfi.request:
parents_custodial = findCustodialLocation(url, wfi.request['InputDataset'])
if len(parents_custodial):
custodial = parents_custodial[0]
else:
print "the input dataset",wfi.request['InputDataset'],"does not have custodial in the first place. abort"
continue
if not custodial:
## pick one at random
custodial = SI.pick_SE()
if custodial and not sub_assistance and not acdc:
## register the custodial request, if there are no other big issues
for output in out_worth_checking:
if not len(custodial_locations[output]):
custodials[custodial].append( output )
else:
print "cannot find a custodial for",wfo.name
is_closing = False
## disk copy
disk_copies = {}
for output in wfi.request['OutputDatasets']:
disk_copies[output] = [s for s in any_presence[output] if (not 'MSS' in s) and (not 'Buffer' in s)]
if not all(map( lambda sites : len(sites)!=0, disk_copies.values())):
print wfo.name,"has not all output on disk"
print json.dumps(disk_copies, indent=2)
## presence in dbs
dbs_presence = {}
dbs_invalid = {}
for output in wfi.request['OutputDatasets']:
dbs_presence[output] = dbs3Client.getFileCountDataset( output )
dbs_invalid[output] = dbs3Client.getFileCountDataset( output, onlyInvalid=True)
## presence in phedex
phedex_presence ={}
for output in wfi.request['OutputDatasets']:
phedex_presence[output] = phedexClient.getFileCountDataset(url, output )
fraction_invalid = 0.01
if not all([dbs_presence[out] == (dbs_invalid[out]+phedex_presence[out]) for out in wfi.request['OutputDatasets']]) and not options.ignorefiles:
print wfo.name,"has a dbs,phedex mismatch"
print json.dumps(dbs_presence, indent=2)
print json.dumps(dbs_invalid, indent=2)
print json.dumps(phedex_presence, indent=2)
## hook for just waiting ...
is_closing = False
if not all([(dbs_invalid[out] <= int(fraction_invalid*dbs_presence[out])) for out in wfi.request['OutputDatasets']]) and not options.ignorefiles:
print wfo.name,"has a dbs invalid file level too high"
print json.dumps(dbs_presence, indent=2)
print json.dumps(dbs_invalid, indent=2)
print json.dumps(phedex_presence, indent=2)
## need to be going and taking an eye
sub_assistance+="-invalidfiles"
is_closing = False
## put that heavy part at the end
## duplication check
duplications = {}
if is_closing:
for output in wfi.request['OutputDatasets']:
try:
duplications[output] = dbs3Client.duplicateRunLumi( output )
except:
try:
duplications[output] = dbs3Client.duplicateRunLumi( output )
except:
print "was not possible to get the duplicate count for",output
is_closing=False
if any(duplications.values()) and not options.ignoreduplicates:
print wfo.name,"has duplicates"
print json.dumps(duplications,indent=2)
## hook for making file invalidation ?
sub_assistance+='-duplicates'
is_closing = False
## for visualization later on
if not wfo.name in fDB.record:
#print "adding",wfo.name,"to close out record"
fDB.record[wfo.name] = {
'datasets' :{},
'name' : wfo.name,
'closeOutWorkflow' : None,
}
fDB.record[wfo.name]['closeOutWorkflow'] = is_closing
for output in wfi.request['OutputDatasets']:
if not output in fDB.record[wfo.name]['datasets']: fDB.record[wfo.name]['datasets'][output] = {}
rec = fDB.record[wfo.name]['datasets'][output]
rec['percentage'] = float('%.2f'%(percent_completions[output]*100))
rec['duplicate'] = duplications[output] if output in duplications else 'N/A'
rec['phedexReqs'] = float('%.2f'%any_presence[output][custodial_presences[output][0]][1]) if len(custodial_presences[output])!=0 else 'N/A'
rec['closeOutDataset'] = is_closing
rec['transPerc'] = float('%.2f'%any_presence[output][ disk_copies[output][0]][1]) if len(disk_copies[output])!=0 else 'N/A'
rec['correctLumis'] = int(events_per_lumi[output]) if (events_per_lumi[output] > lumi_upper_limit[output]) else True
rec['missingSubs'] = False if len(custodial_locations[output])==0 else ','.join(list(set(custodial_locations[output])))
rec['dbsFiles'] = dbs_presence[output]
rec['dbsInvFiles'] = dbs_invalid[output]
rec['phedexFiles'] = phedex_presence[output]
rec['acdc'] = len(acdc)
## and move on
if is_closing:
## toggle status to closed-out in request manager
print "setting",wfo.name,"closed-out"
if not options.test:
reqMgrClient.closeOutWorkflowCascade(url, wfo.name)
# set it from away/assistance* to close
wfo.status = 'close'
session.commit()
else:
print wfo.name,"needs assistance"
## that means there is something that needs to be done acdc, lumi invalidation, custodial, name it
wfo.status = 'assistance'+sub_assistance
if not options.test:
print "setting",wfo.name,"to",wfo.status
session.commit()
fDB.summary()
## custodial requests
print "Custodials"
print json.dumps(custodials, indent=2)
for site in custodials:
print ','.join(custodials[site]),'=>',site
if not options.test:
result = makeReplicaRequest(url, site, list(set(custodials[site])),"custodial copy at production close-out",custodial='y',priority='low')
print result
print "Transfers"
print json.dumps(transfers, indent=2)
## replicas requests
for site in transfers:
print ','.join(transfers[site]),'=>',site
if not options.test:
result = None
#result = makeReplicaRequest(url, site, list(set(transfers[site])),"copy to disk at production close-out")
print result
print "File Invalidation"
print invalidations
def cleanor(url, specific=None):
print "Deprecated"
return
if duplicateLock() : return
delete_per_site = {}
do_not_autoapprove = []#'T2_FR_CCIN2P3']
SI = siteInfo()
CI = campaignInfo()
LI = lockInfo()
counts=0
for wfo in session.query(Workflow).filter(Workflow.status == 'done').all():
keep_a_copy = False
if specific and not specific in wfo.name: continue
## what was in input
wl = getWorkLoad(url, wfo.name )
if 'Campaign' in wl and wl['Campaign'] in CI.campaigns and 'clean-in' in CI.campaigns[wl['Campaign']] and CI.campaigns[wl['Campaign']]['clean-in']==False:
print "Skipping cleaning on input for campaign",wl['Campaign'], "as per campaign configuration"
continue
dataset= 'N/A'
if 'InputDataset' in wl:
dataset = wl['InputDataset']
print dataset,"in input"
#print json.dumps(wl, indent=2)
announced_log = filter(lambda change : change["Status"] in ["closed-out","normal-archived","announced"],wl['RequestTransition'])
if not announced_log:
print "Cannot figure out when",wfo.name,"was finished"
continue
now = time.mktime(time.gmtime()) / (60*60*24.)
then = announced_log[-1]['UpdateTime'] / (60.*60.*24.)
if (now-then) <2:
print "workflow",wfo.name, "finished",now-then,"days ago. Too fresh to clean"
continue
else:
print "workflow",wfo.name,"has finished",now-then,"days ago."
if not 'InputDataset' in wl:
## should we set status = clean ? or something even further
print "passing along",wfo.name,"with no input"
wfo.status = 'clean'
session.commit()
continue
if 'MinBias' in dataset:
print "Should not clean anything using",dataset,"setting status further"
wfo.status = 'clean'
session.commit()
continue
total_size = getDatasetSize( dataset ) ## in Gb
#if counts> 20: break
counts+=1
## find any location it is at
our_presence = getDatasetPresence(url, dataset, complete=None, group="DataOps")
also_our_presence = getDatasetPresence(url, dataset, complete=None, group="")
## is there a custodial !!!
custodials = findCustodialLocation(url, dataset)
if not len(custodials):
print dataset,"has no custodial site yet, excluding from cleaning"
continue
## find out whether it is still in use
using_the_same = getWorkflowByInput(url, dataset, details=True)
conflict=False
for other in using_the_same:
if other['RequestName'] == wfo.name: continue
if other['RequestType'] == 'Resubmission': continue
if not other['RequestStatus'] in ['announced','normal-archived','aborted','rejected','aborted-archived','aborted-completed','rejected-archived','closed-out','None',None,'new']:
print other['RequestName'],'is in status',other['RequestStatus'],'preventing from cleaning',dataset
conflict=True
break
if 'Campaign' in other and other['Campaign'] in CI.campaigns and 'clean-in' in CI.campaigns[other['Campaign']] and CI.campaigns[other['Campaign']]['clean-in']==False:
print other['RequestName'],'is in campaign',other['Campaign']
conflict = True
break
if conflict: continue
print "other statuses:",[other['RequestStatus'] for other in using_the_same if other['RequestName'] != wfo.name]
## find all disks
to_be_cleaned = filter(lambda site : site.startswith('T2') or site.endswith('Disk') ,our_presence.keys())
to_be_cleaned.extend( filter(lambda site : site.startswith('T2') or site.endswith('Disk') ,also_our_presence.keys()))
print to_be_cleaned,"for",total_size,"GB"
anaops_presence = getDatasetPresence(url, dataset, complete=None, group="AnalysisOps")
own_by_anaops = anaops_presence.keys()
print "Own by analysis ops and vetoing"
print own_by_anaops
## need to black list the sites where there is a copy of analysis ops
to_be_cleaned = [site for site in to_be_cleaned if not site in own_by_anaops ]
## keep one copy out there
if 'Campaign' in wl and wl['Campaign'] in CI.campaigns and 'keep-one' in CI.campaigns[wl['Campaign']] and CI.campaigns[wl['Campaign']]['keep-one']==True:
print "Keeping a copy of input for",wl['Campaign']
keep_a_copy = True
if keep_a_copy:
keep_at = None
full_copies = [site for (site,(there,_)) in our_presence.items() if there and site.startswith('T1')]
full_copies.extend( [site for (site,(there,_)) in also_our_presence.items() if there and site.startswith('T1')] )
if not full_copies:
full_copies = [site for (site,(there,_)) in our_presence.items() if there and site.startswith('T2')]
full_copies.extend( [site for (site,(there,_)) in also_our_presence.items() if there and site.startswith('T2')] )
if full_copies:
keep_at = random.choice( full_copies )
if not keep_at:
print "We are enable to find a place to keep a full copy of",dataset,"skipping"
continue
else:
## keeping that copy !
print "Keeping a full copy of",dataset,"at",keep_at,"not setting the status further"
to_be_cleaned.remove( keep_at )
else:
wfo.status = 'clean'
## collect delete request per site
for site in to_be_cleaned :
if not site in delete_per_site: delete_per_site[site] = []
if not dataset in [existing[0] for existing in delete_per_site[site]]:
delete_per_site[site].append( (dataset, total_size) )
session.commit()
#open('deletes.json','w').write( json.dumps(delete_per_site,indent=2) )
print json.dumps(delete_per_site, indent=2)
print "\n\n ------- \n\n"
## unroll the deletion per site
## maybe find the optimum site/dataset dataset/site to limit the number of ph requests
for site in delete_per_site:
dataset_list = [info[0] for info in delete_per_site[site]]
size_removal = sum([info[1] for info in delete_per_site[site]]) / 1024.
if site in SI.disk:
free = SI.disk[site]
print site,"has",size_removal,"TB of potential cleanup.",free,"TB available."
else:
print site,"has",size_removal,"TB of potential cleanup. no info on available."
print "\t",','.join(dataset_list)
## make deletion requests
for site in delete_per_site:
site_datasets = [info[0] for info in delete_per_site[site]]
is_tape = any([v in site for v in ['MSS','Export','Buffer'] ])
#comments="Cleanup input after production. DataOps will take care of approving it."
#if is_tape:
# comments="Cleanup input after production."
for item in site_datasets:
LI.release( item, site, 'cleanup of input after production')
def assignor(url ,specific = None, talk=True, options=None):
CI = campaignInfo()
SI = siteInfo()
wfos=[]
if specific:
wfos = session.query(Workflow).filter(Workflow.name==specific).all()
if not wfos:
if specific:
wfos = session.query(Workflow).filter(Workflow.status=='considered').all()
wfos.extend( session.query(Workflow).filter(Workflow.status=='staging').all())
wfos.extend(session.query(Workflow).filter(Workflow.status=='staged').all())
for wfo in wfos:
if specific:
if not any(map(lambda sp: sp in wfo.name,specific.split(','))): continue
#if not specific in wfo.name: continue
print wfo.name,"to be assigned"
wfh = workflowInfo( url, wfo.name)
#wl = getWorkLoad(url, wfo.name )
if not CI.go( wfh.request['Campaign'] ):
print "No go for",wfh.request['Campaign']
continue
injection_time = time.mktime(time.strptime('.'.join(map(str,wfh.request['RequestDate'])),"%Y.%m.%d.%H.%M.%S")) / (60.*60.)
now = time.mktime(time.gmtime()) / (60.*60.)
if float(now - injection_time) < 4.:
print "It is too soon to inject: %3.2fH remaining"%(now - injection_time)
if not options.test:
continue
#grace_period = 4 #days
#if float(now - injection_time) > grace_period*24.:
# print "it has been",grace_period,"need to do something"
# options.restrict = True
#else:
# print now,injection_time,now - injection_time
#print wl
if wfh.request['RequestStatus'] !='assignment-approved':
print wfo.name,wfh.request['RequestStatus'],"skipping"
if not options.test:
continue
version=wfh.getNextVersion()
(lheinput,primary,parent,secondary) = wfh.getIO()
sites_allowed = getSiteWhiteList( (lheinput,primary,parent,secondary) )
sites_custodial = list(set(itertools.chain.from_iterable([findCustodialLocation(url, prim) for prim in primary])))
sites_out = [SI.pick_dSE([SI.CE_to_SE(ce) for ce in sites_allowed])]
if len(sites_custodial)==0:
sites_custodial = [SI.pick_SE()]
print "picked",sites_custodial," as custodial for",wfo.name
if len(sites_custodial)>1:
print "more than one custodial for",wfo.name
sys.exit(36)
sites_with_data = copy.deepcopy( sites_allowed )
for prim in list(primary)+list(secondary):
presence = getDatasetPresence( url, prim )
if talk:
print prim,presence
sites_with_data = [site for site in sites_with_data if any([osite.startswith(site) for osite in [psite for (psite,frac) in presence.items() if frac[1]>90.]])]
sites_with_data = list(set(sites_with_data))
if options.restrict:
if talk:
print sites_allowed
sites_allowed = sites_with_data
else:
if set(sites_with_data) != set(sites_allowed):
## the data is not everywhere we wanted to run at : enable aaa
print "Resorting to AAA reading for",list(set(sites_allowed) - set(sites_with_data))
#options.useSiteListAsLocation = True
print "Not commissioned yet"
continue
if not len(sites_allowed):
print wfo.name,"cannot be assign with no matched sites"
continue
parameters={
'SiteWhitelist' : sites_allowed,
'CustodialSites' : sites_custodial,
'NonCustodialSites' : sites_out,
'AutoApproveSubscriptionSites' : list(set(sites_out+sites_custodial)),
'AcquisitionEra' : wfh.acquisitionEra(),
'ProcessingString' : wfh.processingString(),
'MergedLFNBase' : '/store/mc', ## to be figured out ! from Hi shit
'ProcessingVersion' : version,
}
##parse options entered in command line if any
if options:
for key in reqMgrClient.assignWorkflow.keys:
v=getattr(options,key)
if v!=None:
if ',' in v: parameters[key] = filter(None,v.split(','))
else: parameters[key] = v
## take care of a few exceptions
if (wfh.request['Memory']*1000) > 3000000:
parameters['MaxRSS'] = 4000000
## pick up campaign specific assignment parameters
parameters.update( CI.parameters(wfh.request['Campaign']) )
if not options.test:
parameters['execute'] = True
if not wfh.checkWorkflowSplitting():
## needs to go to event based ? fail for now
print "Falling back to event splitting ?"
parameters['SplittingAlgorithm'] = 'EventBased'
## plain assignment here
result = reqMgrClient.assignWorkflow(url, wfo.name, 'production', parameters)
# set status
if not options.test:
if result:
wfo.status = 'away'
session.commit()
else:
print "ERROR could not assign",wfo.name
else:
pass
## don't even try to keep the lock
print "\tunlocking",dataset,"for bad dataset status",ds_status
continue
creators = getWorkflowByOutput( url, dataset , details=True)
creators_status = [r['RequestStatus'] for r in creators]
print "Statuses of workflow that made the dataset",creators_status
if all(status in ['aborted','rejected','aborted-archived','rejected-archived'] for status in creators_status):
## crap
print "\tunlocking",dataset,"for bad workflow statuses"
continue
relock=False
(_,dsn,ps,tier) = dataset.split('/')
if not tier in tier_no_custodial:
custodials = findCustodialLocation(url, dataset)
if len(custodials) == 0:
print "Can't unlock",dataset,"because it is not custodial yet",ds_status
## add it back for that reason
newly_locking.add(dataset)
relock = True
if not relock:
print "\tunlocking",dataset
##would like to pass to *-unlock, or even destroy from local db
for creator in creators:
for wfo in session.query(Workflow).filter(Workflow.name==creator['RequestName']).all():
if not 'unlock' in wfo.status:
wfo.status +='-unlock'
print "setting",wfo.name,"to",wfo.status
session.commit()
