# get logger if locked_by is None: msgPfx = None else: msgPfx = 'id={0}'.format(locked_by) tmpLog = core_utils.make_logger(_logger, msgPfx, method_name='get_jobs_in_sub_status') tmpLog.debug('start subStatus={0} timeColumn={1}'.format(sub_status, time_column)) timeNow = datetime.datetime.utcnow() # sql to count jobs being processed sqlC = "SELECT COUNT(*) cnt FROM {0} ".format(jobTableName) sqlC += "WHERE ({0} IS NOT NULL AND subStatus=:subStatus ".format(lock_column) if time_column is not None and interval_with_lock is not None: sqlC += "AND ({0} IS NOT NULL AND {0}>:lockTimeLimit) ".format(time_column) sqlC += ") OR subStatus=:newSubStatus " # count jobs if max_jobs > 0 and new_sub_status is not None: varMap = dict() varMap[':subStatus'] = sub_status varMap[':newSubStatus'] = new_sub_status if time_column is not None and interval_with_lock is not None: varMap[':lockTimeLimit'] = timeNow - datetime.timedelta(seconds=interval_with_lock) self.execute(sqlC, varMap) nProcessing, = self.cur.fetchone() if nProcessing >= max_jobs: # commit self.commit() tmpLog.debug('enough jobs {0} are being processed in {1} state'.format(nProcessing, new_sub_status)) return [] max_jobs -= nProcessing # sql to get job IDs sql = "SELECT PandaID FROM {0} ".format(jobTableName) sql += "WHERE subStatus=:subStatus " if time_column is not None: sql += "AND ({0} IS NULL ".format(time_column) if interval_with_lock is not None: sql += "OR ({0}<:lockTimeLimit AND {1} IS NOT NULL) ".format(time_column, lock_column) if interval_without_lock is not None: sql += "OR ({0}<:updateTimeLimit AND {1} IS NULL) ".format(time_column, lock_column) sql += ') ' sql += "ORDER BY {0} ".format(time_column) # sql to lock job sqlL = "UPDATE {0} SET {1}=:timeNow,{2}=:lockedBy ".format(jobTableName, time_column, lock_column) sqlL += "WHERE PandaID=:PandaID AND subStatus=:subStatus " if time_column is not None: sqlL += "AND ({0} IS NULL ".format(time_column) if interval_with_lock is not None: sqlL += "OR ({0}<:lockTimeLimit AND {1} IS NOT NULL) ".format(time_column, lock_column) if interval_without_lock is not None: sqlL += "OR ({0}<:updateTimeLimit AND {1} IS NULL) ".format(time_column, lock_column) sqlL += ') ' # sql to get jobs sqlGJ = "SELECT {0} FROM {1} ".format(JobSpec.column_names(), jobTableName) sqlGJ += "WHERE PandaID=:PandaID " # sql to get file sqlGF = "SELECT {0} FROM {1} ".format(FileSpec.column_names(), fileTableName) sqlGF += "WHERE PandaID=:PandaID AND fileType=:type " # get jobs varMap = dict() varMap[':subStatus'] = sub_status if interval_with_lock is not None: varMap[':lockTimeLimit'] = timeNow - datetime.timedelta(seconds=interval_with_lock) if interval_without_lock is not None: varMap[':updateTimeLimit'] = timeNow - datetime.timedelta(seconds=interval_without_lock) self.execute(sql, varMap) resList = self.cur.fetchall() pandaIDs = [] for pandaID, in resList: pandaIDs.append(pandaID) # partially randomise to increase success rate for lock nJobs = int(max_jobs * 0.2) subPandaIDs = list(pandaIDs[nJobs:]) random.shuffle(subPandaIDs) pandaIDs = pandaIDs[:nJobs] + subPandaIDs pandaIDs = pandaIDs[:max_jobs] jobSpecList = [] for pandaID in pandaIDs: # lock job if locked_by is not None: varMap = dict() varMap[':PandaID'] = pandaID varMap[':timeNow'] = timeNow varMap[':lockedBy'] = locked_by varMap[':subStatus'] = sub_status if interval_with_lock is not None: varMap[':lockTimeLimit'] = timeNow - datetime.timedelta(seconds=interval_with_lock) if interval_without_lock is not None: varMap[':updateTimeLimit'] = timeNow - datetime.timedelta(seconds=interval_without_lock) self.execute(sqlL, varMap) nRow = self.cur.rowcount # commit self.commit() else: nRow = 1 if nRow > 0: # get job varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlGJ, varMap) resGJ = self.cur.fetchone() # make job jobSpec = JobSpec() jobSpec.pack(resGJ) if locked_by is not None: jobSpec.lockedBy = locked_by setattr(jobSpec, time_column, timeNow) # get files varMap = dict() varMap[':PandaID'] = jobSpec.PandaID varMap[':type'] = 'input' self.execute(sqlGF, varMap) resGF = self.cur.fetchall() for resFile in resGF: fileSpec = FileSpec() fileSpec.pack(resFile) jobSpec.add_in_file(fileSpec) # append jobSpecList.append(jobSpec) tmpLog.debug('got {0} jobs'.format(len(jobSpecList))) return jobSpecList except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # register a worker def register_worker(self, workspec, jobspec_list, locked_by): tmpLog = core_utils.make_logger(_logger, 'batchID={0}'.format(workspec.batchID), method_name='register_worker') try: tmpLog.debug('start') # sql to check if exists sqlE = "SELECT 1 c FROM {0} WHERE workerID=:workerID ".format(workTableName) # sql to insert job and worker relationship sqlR = "INSERT INTO {0} ({1}) ".format(jobWorkerTableName, JobWorkerRelationSpec.column_names()) sqlR += JobWorkerRelationSpec.bind_values_expression() # sql to get number of workers sqlNW = "SELECT DISTINCT t.workerID FROM {0} t, {1} w ".format(jobWorkerTableName, workTableName) sqlNW += "WHERE t.PandaID=:pandaID AND w.workerID=t.workerID " sqlNW += "AND w.status IN (:st_submitted,:st_running,:st_idle) " # sql to decrement nNewWorkers sqlDN = "UPDATE {0} ".format(pandaQueueTableName) sqlDN += "SET nNewWorkers=nNewWorkers-1 " sqlDN += "WHERE queueName=:queueName AND nNewWorkers IS NOT NULL AND nNewWorkers>0 " # insert worker if new isNew = False if workspec.isNew: varMap = dict() varMap[':workerID'] = workspec.workerID self.execute(sqlE, varMap) resE = self.cur.fetchone() if resE is None: isNew = True if isNew: # insert a worker sqlI = "INSERT INTO {0} ({1}) ".format(workTableName, WorkSpec.column_names()) sqlI += WorkSpec.bind_values_expression() varMap = workspec.values_list() self.execute(sqlI, varMap) # decrement nNewWorkers varMap = dict() varMap[':queueName'] = workspec.computingSite self.execute(sqlDN, varMap) else: # not update workerID workspec.force_not_update('workerID') # update a worker sqlU = "UPDATE {0} SET {1} ".format(workTableName, workspec.bind_update_changes_expression()) sqlU += "WHERE workerID=:workerID " varMap = workspec.values_map(only_changed=True) varMap[':workerID'] = workspec.workerID self.execute(sqlU, varMap) # collect values to update jobs or insert job/worker mapping varMapsR = [] if jobspec_list is not None: for jobSpec in jobspec_list: # get number of workers for the job varMap = dict() varMap[':pandaID'] = jobSpec.PandaID varMap[':st_submitted'] = WorkSpec.ST_submitted varMap[':st_running'] = WorkSpec.ST_running varMap[':st_idle'] = WorkSpec.ST_idle self.execute(sqlNW, varMap) resNW = self.cur.fetchall() workerIDs = set() workerIDs.add(workspec.workerID) for tmpWorkerID, in resNW: workerIDs.add(tmpWorkerID) # update attributes if jobSpec.subStatus in ['submitted', 'running']: jobSpec.nWorkers = len(workerIDs) try: jobSpec.nWorkersInTotal += 1 except Exception: jobSpec.nWorkersInTotal = jobSpec.nWorkers elif workspec.hasJob == 1: if workspec.status == WorkSpec.ST_missed: # not update if other workers are active if len(workerIDs) > 1: continue core_utils.update_job_attributes_with_workers(workspec.mapType, [jobSpec], [workspec], {}, {}) jobSpec.trigger_propagation() else: jobSpec.subStatus = 'submitted' jobSpec.nWorkers = len(workerIDs) try: jobSpec.nWorkersInTotal += 1 except Exception: jobSpec.nWorkersInTotal = jobSpec.nWorkers else: if workspec.status == WorkSpec.ST_missed: # not update if other workers are active if len(workerIDs) > 1: continue core_utils.update_job_attributes_with_workers(workspec.mapType, [jobSpec], [workspec], {}, {}) jobSpec.trigger_propagation() else: jobSpec.subStatus = 'queued' # sql to update job if len(jobSpec.values_map(only_changed=True)) > 0: sqlJ = "UPDATE {0} SET {1} ".format(jobTableName, jobSpec.bind_update_changes_expression()) sqlJ += "WHERE PandaID=:cr_PandaID AND lockedBy=:cr_lockedBy " # update job varMap = jobSpec.values_map(only_changed=True) varMap[':cr_PandaID'] = jobSpec.PandaID varMap[':cr_lockedBy'] = locked_by self.execute(sqlJ, varMap) if jobSpec.subStatus in ['submitted', 'running']: # values for job/worker mapping jwRelation = JobWorkerRelationSpec() jwRelation.PandaID = jobSpec.PandaID jwRelation.workerID = workspec.workerID varMap = jwRelation.values_list() varMapsR.append(varMap) # insert job/worker mapping if len(varMapsR) > 0: self.executemany(sqlR, varMapsR) # commit self.commit() # return return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return False # insert workers def insert_workers(self, workspec_list, locked_by): tmpLog = core_utils.make_logger(_logger, 'locked_by={0}'.format(locked_by), method_name='insert_workers') try: tmpLog.debug('start') timeNow = datetime.datetime.utcnow() # sql to insert a worker sqlI = "INSERT INTO {0} ({1}) ".format(workTableName, WorkSpec.column_names()) sqlI += WorkSpec.bind_values_expression() for workSpec in workspec_list: tmpWorkSpec = copy.copy(workSpec) # insert worker if new if not tmpWorkSpec.isNew: continue tmpWorkSpec.modificationTime = timeNow tmpWorkSpec.status = WorkSpec.ST_pending varMap = tmpWorkSpec.values_list() self.execute(sqlI, varMap) # commit self.commit() # return return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return False # get queues to submit workers def get_queues_to_submit(self, n_queues, lookup_interval, lock_interval, locked_by, queue_lock_interval): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_queues_to_submit') tmpLog.debug('start') retMap = dict() siteName = None resourceMap = dict() # sql to get a site sqlS = "SELECT siteName FROM {0} ".format(pandaQueueTableName) sqlS += "WHERE submitTime IS NULL " sqlS += "OR (submitTime<:lockTimeLimit AND lockedBy IS NOT NULL) " sqlS += "OR (submitTime<:lookupTimeLimit AND lockedBy IS NULL) " sqlS += "ORDER BY submitTime " # sql to get queues sqlQ = "SELECT queueName,resourceType,nNewWorkers FROM {0} ".format(pandaQueueTableName) sqlQ += "WHERE siteName=:siteName " # sql to get orphaned workers sqlO = "SELECT workerID FROM {0} ".format(workTableName) sqlO += "WHERE computingSite=:computingSite " sqlO += "AND status=:status AND modificationTime<:timeLimit " # sql to delete orphaned workers. Not to use bulk delete to avoid deadlock with 0-record deletion sqlD = "DELETE FROM {0} ".format(workTableName) sqlD += "WHERE workerID=:workerID " # sql to count nQueue sqlN = "SELECT status,COUNT(*) cnt FROM {0} ".format(workTableName) sqlN += "WHERE computingSite=:computingSite " # sql to count re-fillers sqlR = "SELECT COUNT(*) cnt FROM {0} ".format(workTableName) sqlR += "WHERE computingSite=:computingSite AND status=:status " sqlR += "AND nJobsToReFill IS NOT NULL AND nJobsToReFill>0 " # sql to update timestamp and lock site sqlU = "UPDATE {0} SET submitTime=:submitTime,lockedBy=:lockedBy ".format(pandaQueueTableName) sqlU += "WHERE siteName=:siteName " sqlU += "AND (submitTime IS NULL OR submitTime<:timeLimit) " # get sites timeNow = datetime.datetime.utcnow() varMap = dict() varMap[':lockTimeLimit'] = timeNow - datetime.timedelta(seconds=queue_lock_interval) varMap[':lookupTimeLimit'] = timeNow - datetime.timedelta(seconds=lookup_interval) self.execute(sqlS, varMap) resS = self.cur.fetchall() for siteName, in resS: # update timestamp to lock the site varMap = dict() varMap[':siteName'] = siteName varMap[':submitTime'] = timeNow varMap[':lockedBy'] = locked_by varMap[':timeLimit'] = timeNow - datetime.timedelta(seconds=lookup_interval) self.execute(sqlU, varMap) nRow = self.cur.rowcount # commit self.commit() # skip if not locked if nRow == 0: continue # get queues varMap = dict() varMap[':siteName'] = siteName self.execute(sqlQ, varMap) resQ = self.cur.fetchall() for queueName, resourceType, nNewWorkers in resQ: # delete orphaned workers varMap = dict() varMap[':computingSite'] = queueName varMap[':status'] = WorkSpec.ST_pending varMap[':timeLimit'] = timeNow - datetime.timedelta(seconds=lock_interval) sqlO_tmp = sqlO if resourceType != 'ANY': varMap[':resourceType'] = resourceType sqlO_tmp += "AND resourceType=:resourceType " self.execute(sqlO_tmp, varMap) resO = self.cur.fetchall() for tmpWorkerID, in resO: varMap = dict() varMap[':workerID'] = tmpWorkerID self.execute(sqlD, varMap) # commit self.commit() # count nQueue varMap = dict() varMap[':computingSite'] = queueName varMap[':resourceType'] = resourceType sqlN_tmp = sqlN if resourceType != 'ANY': varMap[':resourceType'] = resourceType sqlN_tmp += "AND resourceType=:resourceType " sqlN_tmp += "GROUP BY status " self.execute(sqlN_tmp, varMap) nQueue = 0 nReady = 0 nRunning = 0 for workerStatus, tmpNum in self.cur.fetchall(): if workerStatus in [WorkSpec.ST_submitted, WorkSpec.ST_pending, WorkSpec.ST_idle]: nQueue += tmpNum elif workerStatus in [WorkSpec.ST_ready]: nReady += tmpNum elif workerStatus in [WorkSpec.ST_running]: nRunning += tmpNum # count nFillers varMap = dict() varMap[':computingSite'] = queueName varMap[':status'] = WorkSpec.ST_running sqlR_tmp = sqlR if resourceType != 'ANY': varMap[':resourceType'] = resourceType sqlR_tmp += "AND resourceType=:resourceType " self.execute(sqlR_tmp, varMap) nReFill, = self.cur.fetchone() nReady += nReFill # add retMap.setdefault(queueName, {}) retMap[queueName][resourceType] = {'nReady': nReady, 'nRunning': nRunning, 'nQueue': nQueue, 'nNewWorkers': nNewWorkers} resourceMap[resourceType] = queueName # enough queues if len(retMap) >= 0: break tmpLog.debug('got retMap {0}'.format(str(retMap))) tmpLog.debug('got siteName {0}'.format(str(siteName))) tmpLog.debug('got resourceMap {0}'.format(str(resourceMap))) return retMap, siteName, resourceMap except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {}, None, {} # get job chunks to make workers def get_job_chunks_for_workers(self, queue_name, n_workers, n_ready, n_jobs_per_worker, n_workers_per_job, use_job_late_binding, check_interval, lock_interval, locked_by, allow_job_mixture=False, max_workers_per_job_in_total=None, max_workers_per_job_per_cycle=None): toCommit = False try: # get logger tmpLog = core_utils.make_logger(_logger, 'queue={0}'.format(queue_name), method_name='get_job_chunks_for_workers') tmpLog.debug('start') # define maxJobs if n_jobs_per_worker is not None: maxJobs = (n_workers + n_ready) * n_jobs_per_worker else: maxJobs = -(-(n_workers + n_ready) // n_workers_per_job) # core part of sql # submitted and running are for multi-workers sqlCore = "WHERE (subStatus IN (:subStat1,:subStat2) OR (subStatus IN (:subStat3,:subStat4) " sqlCore += "AND nWorkers IS NOT NULL AND nWorkersLimit IS NOT NULL AND nWorkers1 nAvailableJobs = None if n_jobs_per_worker is not None and n_jobs_per_worker > 1: toCommit = True # sql to count jobs sqlC = "SELECT COUNT(*) cnt FROM {0} ".format(jobTableName) sqlC += sqlCore # count jobs varMap = dict() varMap[':subStat1'] = 'prepared' varMap[':subStat2'] = 'queued' varMap[':subStat3'] = 'submitted' varMap[':subStat4'] = 'running' varMap[':queueName'] = queue_name varMap[':lockTimeLimit'] = lockTimeLimit varMap[':checkTimeLimit'] = checkTimeLimit self.execute(sqlC, varMap) nAvailableJobs, = self.cur.fetchone() maxJobs = int(min(maxJobs, nAvailableJobs) / n_jobs_per_worker) * n_jobs_per_worker tmpStr = 'n_workers={0} n_ready={1} '.format(n_workers, n_ready) tmpStr += 'n_jobs_per_worker={0} n_workers_per_job={1} '.format(n_jobs_per_worker, n_workers_per_job) tmpStr += 'n_ava_jobs={0}'.format(nAvailableJobs) tmpLog.debug(tmpStr) if maxJobs == 0: tmpStr = 'skip due to maxJobs=0' tmpLog.debug(tmpStr) else: # get job IDs varMap = dict() varMap[':subStat1'] = 'prepared' varMap[':subStat2'] = 'queued' varMap[':subStat3'] = 'submitted' varMap[':subStat4'] = 'running' varMap[':queueName'] = queue_name varMap[':lockTimeLimit'] = lockTimeLimit varMap[':checkTimeLimit'] = checkTimeLimit self.execute(sqlP, varMap) resP = self.cur.fetchall() tmpStr = 'fetched {0} jobs'.format(len(resP)) tmpLog.debug(tmpStr) jobChunk = [] iJobs = 0 for pandaID, in resP: toCommit = True toEscape = False # lock job varMap = dict() varMap[':subStat1'] = 'prepared' varMap[':subStat2'] = 'queued' varMap[':subStat3'] = 'submitted' varMap[':subStat4'] = 'running' varMap[':queueName'] = queue_name varMap[':lockTimeLimit'] = lockTimeLimit varMap[':checkTimeLimit'] = checkTimeLimit varMap[':PandaID'] = pandaID varMap[':timeNow'] = timeNow varMap[':lockedBy'] = locked_by self.execute(sqlL, varMap) nRow = self.cur.rowcount if nRow > 0: iJobs += 1 # get job varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlJ, varMap) resJ = self.cur.fetchone() # make job jobSpec = JobSpec() jobSpec.pack(resJ) jobSpec.lockedBy = locked_by # get files varMap = dict() varMap[':PandaID'] = pandaID varMap[':type'] = 'input' self.execute(sqlGF, varMap) resGF = self.cur.fetchall() for resFile in resGF: fileSpec = FileSpec() fileSpec.pack(resFile) jobSpec.add_in_file(fileSpec) # new chunk if len(jobChunk) > 0 and jobChunk[0].taskID != jobSpec.taskID and not allow_job_mixture: tmpLog.debug('new chunk with {0} jobs due to taskID change'.format(len(jobChunk))) jobChunkList.append(jobChunk) jobChunk = [] # only prepared for new worker if len(jobChunkList) >= n_ready and jobSpec.subStatus == 'queued': toCommit = False else: jobChunk.append(jobSpec) # enough jobs in chunk if n_jobs_per_worker is not None and len(jobChunk) >= n_jobs_per_worker: tmpLog.debug('new chunk with {0} jobs due to n_jobs_per_worker'.format(len(jobChunk))) jobChunkList.append(jobChunk) jobChunk = [] # one job per multiple workers elif n_workers_per_job is not None: if jobSpec.nWorkersLimit is None: jobSpec.nWorkersLimit = n_workers_per_job if max_workers_per_job_in_total is not None: jobSpec.maxWorkersInTotal = max_workers_per_job_in_total nMultiWorkers = min(jobSpec.nWorkersLimit - jobSpec.nWorkers, n_workers - len(jobChunkList)) if jobSpec.maxWorkersInTotal is not None and jobSpec.nWorkersInTotal is not None: nMultiWorkers = min(nMultiWorkers, jobSpec.maxWorkersInTotal - jobSpec.nWorkersInTotal) if max_workers_per_job_per_cycle is not None: nMultiWorkers = min(nMultiWorkers, max_workers_per_job_per_cycle) if nMultiWorkers < 0: nMultiWorkers = 0 tmpLog.debug( 'new {0} chunks with {1} jobs due to n_workers_per_job'.format(nMultiWorkers, len(jobChunk))) for i in range(nMultiWorkers): jobChunkList.append(jobChunk) jobChunk = [] # enough job chunks if len(jobChunkList) >= n_workers: toEscape = True if toCommit: self.commit() else: self.rollback() if toEscape or iJobs >= maxJobs: break tmpLog.debug('got {0} job chunks'.format(len(jobChunkList))) return jobChunkList except Exception: # roll back if toCommit: self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # get workers to monitor def get_workers_to_update(self, max_workers, check_interval, lock_interval, locked_by): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_workers_to_update') tmpLog.debug('start') # sql to get workers sqlW = "SELECT workerID,configID,mapType FROM {0} ".format(workTableName) sqlW += "WHERE status IN (:st_submitted,:st_running,:st_idle) " sqlW += "AND ((modificationTime<:lockTimeLimit AND lockedBy IS NOT NULL) " sqlW += "OR (modificationTime<:checkTimeLimit AND lockedBy IS NULL)) " sqlW += "ORDER BY modificationTime LIMIT {0} ".format(max_workers) # sql to lock worker without time check sqlL = "UPDATE {0} SET modificationTime=:timeNow,lockedBy=:lockedBy ".format(workTableName) sqlL += "WHERE workerID=:workerID " # sql to update modificationTime sqlLM = "UPDATE {0} SET modificationTime=:timeNow ".format(workTableName) sqlLM += "WHERE workerID=:workerID " # sql to lock worker with time check sqlLT = "UPDATE {0} SET modificationTime=:timeNow,lockedBy=:lockedBy ".format(workTableName) sqlLT += "WHERE workerID=:workerID " sqlLT += "AND status IN (:st_submitted,:st_running,:st_idle) " sqlLT += "AND ((modificationTime<:lockTimeLimit AND lockedBy IS NOT NULL) " sqlLT += "OR (modificationTime<:checkTimeLimit AND lockedBy IS NULL)) " # sql to get associated workerIDs sqlA = "SELECT t.workerID FROM {0} t, {0} s, {1} w ".format(jobWorkerTableName, workTableName) sqlA += "WHERE s.PandaID=t.PandaID AND s.workerID=:workerID " sqlA += "AND w.workerID=t.workerID AND w.status IN (:st_submitted,:st_running,:st_idle) " # sql to get associated workers sqlG = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(), workTableName) sqlG += "WHERE workerID=:workerID " # sql to get associated PandaIDs sqlP = "SELECT PandaID FROM {0} ".format(jobWorkerTableName) sqlP += "WHERE workerID=:workerID " # get workerIDs timeNow = datetime.datetime.utcnow() lockTimeLimit = timeNow - datetime.timedelta(seconds=lock_interval) checkTimeLimit = timeNow - datetime.timedelta(seconds=check_interval) varMap = dict() varMap[':st_submitted'] = WorkSpec.ST_submitted varMap[':st_running'] = WorkSpec.ST_running varMap[':st_idle'] = WorkSpec.ST_idle varMap[':lockTimeLimit'] = lockTimeLimit varMap[':checkTimeLimit'] = checkTimeLimit self.execute(sqlW, varMap) resW = self.cur.fetchall() tmpWorkers = set() for workerID, configID, mapType in resW: # ignore configID if not core_utils.dynamic_plugin_change(): configID = None tmpWorkers.add((workerID, configID, mapType)) checkedIDs = set() retVal = {} for workerID, configID, mapType in tmpWorkers: # skip if workerID in checkedIDs: continue # get associated workerIDs varMap = dict() varMap[':workerID'] = workerID varMap[':st_submitted'] = WorkSpec.ST_submitted varMap[':st_running'] = WorkSpec.ST_running varMap[':st_idle'] = WorkSpec.ST_idle self.execute(sqlA, varMap) resA = self.cur.fetchall() workerIDtoScan = set() for tmpWorkID, in resA: workerIDtoScan.add(tmpWorkID) # add original ID just in case since no relation when job is not yet bound workerIDtoScan.add(workerID) # use only the largest worker to avoid updating the same worker set concurrently if mapType == WorkSpec.MT_MultiWorkers: if workerID != min(workerIDtoScan): # update modification time varMap = dict() varMap[':workerID'] = workerID varMap[':timeNow'] = timeNow self.execute(sqlLM, varMap) # commit self.commit() continue # lock worker varMap = dict() varMap[':workerID'] = workerID varMap[':lockedBy'] = locked_by varMap[':timeNow'] = timeNow varMap[':st_submitted'] = WorkSpec.ST_submitted varMap[':st_running'] = WorkSpec.ST_running varMap[':st_idle'] = WorkSpec.ST_idle varMap[':lockTimeLimit'] = lockTimeLimit varMap[':checkTimeLimit'] = checkTimeLimit self.execute(sqlLT, varMap) nRow = self.cur.rowcount # commit self.commit() # skip if not locked if nRow == 0: continue # get workers queueName = None workersList = [] for tmpWorkID in workerIDtoScan: checkedIDs.add(tmpWorkID) # get worker varMap = dict() varMap[':workerID'] = tmpWorkID self.execute(sqlG, varMap) resG = self.cur.fetchone() workSpec = WorkSpec() workSpec.pack(resG) if queueName is None: queueName = workSpec.computingSite workersList.append(workSpec) # get associated PandaIDs varMap = dict() varMap[':workerID'] = tmpWorkID self.execute(sqlP, varMap) resP = self.cur.fetchall() workSpec.pandaid_list = [] for tmpPandaID, in resP: workSpec.pandaid_list.append(tmpPandaID) if len(workSpec.pandaid_list) > 0: workSpec.nJobs = len(workSpec.pandaid_list) # lock worker if tmpWorkID != workerID: varMap = dict() varMap[':workerID'] = tmpWorkID varMap[':lockedBy'] = locked_by varMap[':timeNow'] = timeNow self.execute(sqlL, varMap) workSpec.lockedBy = locked_by workSpec.force_not_update('lockedBy') # commit self.commit() # add if queueName is not None: retVal.setdefault(queueName, dict()) retVal[queueName].setdefault(configID, []) retVal[queueName][configID].append(workersList) tmpLog.debug('got {0}'.format(str(retVal))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # get workers to propagate def get_workers_to_propagate(self, max_workers, check_interval): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_workers_to_propagate') tmpLog.debug('start') # sql to get worker IDs sqlW = "SELECT workerID FROM {0} ".format(workTableName) sqlW += "WHERE lastUpdate IS NOT NULL AND lastUpdate<:checkTimeLimit " sqlW += "ORDER BY lastUpdate " # sql to lock worker sqlL = "UPDATE {0} SET lastUpdate=:timeNow ".format(workTableName) sqlL += "WHERE lastUpdate IS NOT NULL AND lastUpdate<:checkTimeLimit " sqlL += "AND workerID=:workerID " # sql to get associated PandaIDs sqlA = "SELECT PandaID FROM {0} ".format(jobWorkerTableName) sqlA += "WHERE workerID=:workerID " # sql to get workers sqlG = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(), workTableName) sqlG += "WHERE workerID=:workerID " timeNow = datetime.datetime.utcnow() timeLimit = timeNow - datetime.timedelta(seconds=check_interval) # get workerIDs varMap = dict() varMap[':checkTimeLimit'] = timeLimit self.execute(sqlW, varMap) resW = self.cur.fetchall() tmpWorkers = [] for workerID, in resW: tmpWorkers.append(workerID) # partially randomize to increase hit rate nWorkers = int(max_workers * 0.2) subTmpWorkers = list(tmpWorkers[nWorkers:]) random.shuffle(subTmpWorkers) tmpWorkers = tmpWorkers[:nWorkers] + subTmpWorkers tmpWorkers = tmpWorkers[:max_workers] retVal = [] for workerID in tmpWorkers: # lock worker varMap = dict() varMap[':workerID'] = workerID varMap[':timeNow'] = timeNow varMap[':checkTimeLimit'] = timeLimit self.execute(sqlL, varMap) nRow = self.cur.rowcount if nRow > 0: # get worker varMap = dict() varMap[':workerID'] = workerID self.execute(sqlG, varMap) resG = self.cur.fetchone() workSpec = WorkSpec() workSpec.pack(resG) retVal.append(workSpec) # get associated PandaIDs varMap = dict() varMap[':workerID'] = workerID self.execute(sqlA, varMap) resA = self.cur.fetchall() workSpec.pandaid_list = [] for pandaID, in resA: workSpec.pandaid_list.append(pandaID) # commit self.commit() tmpLog.debug('got {0} workers'.format(len(retVal))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # get workers to feed events def get_workers_to_feed_events(self, max_workers, lock_interval, locked_by): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_workers_to_feed_events') tmpLog.debug('start') # sql to get workers sqlW = "SELECT workerID, status FROM {0} ".format(workTableName) sqlW += "WHERE eventsRequest=:eventsRequest AND status IN (:status1,:status2) " sqlW += "AND (eventFeedTime IS NULL OR eventFeedTime<:lockTimeLimit) " sqlW += "ORDER BY eventFeedTime LIMIT {0} ".format(max_workers) # sql to lock worker sqlL = "UPDATE {0} SET eventFeedTime=:timeNow,eventFeedLock=:lockedBy ".format(workTableName) sqlL += "WHERE eventsRequest=:eventsRequest AND status=:status " sqlL += "AND (eventFeedTime IS NULL OR eventFeedTime<:lockTimeLimit) " sqlL += "AND workerID=:workerID " # sql to get associated workers sqlG = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(), workTableName) sqlG += "WHERE workerID=:workerID " # get workerIDs timeNow = datetime.datetime.utcnow() lockTimeLimit = timeNow - datetime.timedelta(seconds=lock_interval) varMap = dict() varMap[':status1'] = WorkSpec.ST_running varMap[':status2'] = WorkSpec.ST_submitted varMap[':eventsRequest'] = WorkSpec.EV_requestEvents varMap[':lockTimeLimit'] = lockTimeLimit self.execute(sqlW, varMap) resW = self.cur.fetchall() tmpWorkers = dict() for tmpWorkerID, tmpWorkStatus in resW: tmpWorkers[tmpWorkerID] = tmpWorkStatus retVal = {} for workerID, workStatus in iteritems(tmpWorkers): # lock worker varMap = dict() varMap[':workerID'] = workerID varMap[':timeNow'] = timeNow varMap[':status'] = workStatus varMap[':eventsRequest'] = WorkSpec.EV_requestEvents varMap[':lockTimeLimit'] = lockTimeLimit varMap[':lockedBy'] = locked_by self.execute(sqlL, varMap) nRow = self.cur.rowcount # commit self.commit() # skip if not locked if nRow == 0: continue # get worker varMap = dict() varMap[':workerID'] = workerID self.execute(sqlG, varMap) resG = self.cur.fetchone() workSpec = WorkSpec() workSpec.pack(resG) if workSpec.computingSite not in retVal: retVal[workSpec.computingSite] = [] retVal[workSpec.computingSite].append(workSpec) tmpLog.debug('got {0} workers'.format(len(retVal))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # update jobs and workers def update_jobs_workers(self, jobspec_list, workspec_list, locked_by, panda_ids_list=None): try: timeNow = datetime.datetime.utcnow() # sql to check job sqlCJ = "SELECT status FROM {0} WHERE PandaID=:PandaID FOR UPDATE ".format(jobTableName) # sql to check file sqlFC = "SELECT {0} FROM {1} ".format(FileSpec.column_names(), fileTableName) sqlFC += "WHERE PandaID=:PandaID AND lfn=:lfn " # sql to get all LFNs sqlFL = "SELECT lfn FROM {0} ".format(fileTableName) sqlFL += "WHERE PandaID=:PandaID AND fileType<>:type " # sql to check file with eventRangeID sqlFE = "SELECT 1 c FROM {0} ".format(fileTableName) sqlFE += "WHERE PandaID=:PandaID AND lfn=:lfn AND eventRangeID=:eventRangeID ".format(fileTableName) # sql to insert file sqlFI = "INSERT INTO {0} ({1}) ".format(fileTableName, FileSpec.column_names()) sqlFI += FileSpec.bind_values_expression() # sql to get pending files sqlFP = "SELECT fileID,fsize,lfn FROM {0} ".format(fileTableName) sqlFP += "WHERE PandaID=:PandaID AND status=:status AND fileType<>:type " # sql to get provenanceID,workerID for pending files sqlPW = "SELECT SUM(fsize),provenanceID,workerID FROM {0} ".format(fileTableName) sqlPW += "WHERE PandaID=:PandaID AND status=:status AND fileType<>:type " sqlPW += "GROUP BY provenanceID,workerID " # sql to update pending files sqlFU = "UPDATE {0} ".format(fileTableName) sqlFU += "SET status=:status,zipFileID=:zipFileID " sqlFU += "WHERE fileID=:fileID " # sql to check event sqlEC = "SELECT eventRangeID,eventStatus FROM {0} ".format(eventTableName) sqlEC += "WHERE PandaID=:PandaID AND eventRangeID IS NOT NULL " # sql to check associated file sqlEF = "SELECT eventRangeID,status FROM {0} ".format(fileTableName) sqlEF += "WHERE PandaID=:PandaID AND eventRangeID IS NOT NULL " # sql to insert event sqlEI = "INSERT INTO {0} ({1}) ".format(eventTableName, EventSpec.column_names()) sqlEI += EventSpec.bind_values_expression() # sql to update event sqlEU = "UPDATE {0} ".format(eventTableName) sqlEU += "SET eventStatus=:eventStatus,subStatus=:subStatus " sqlEU += "WHERE PandaID=:PandaID AND eventRangeID=:eventRangeID " # sql to check if relationship is already available sqlCR = "SELECT 1 c FROM {0} WHERE PandaID=:PandaID AND workerID=:workerID ".format(jobWorkerTableName) # sql to insert job and worker relationship sqlIR = "INSERT INTO {0} ({1}) ".format(jobWorkerTableName, JobWorkerRelationSpec.column_names()) sqlIR += JobWorkerRelationSpec.bind_values_expression() # count number of workers sqlNW = "SELECT DISTINCT t.workerID FROM {0} t, {1} w ".format(jobWorkerTableName, workTableName) sqlNW += "WHERE t.PandaID=:PandaID AND w.workerID=t.workerID " sqlNW += "AND w.status IN (:st_submitted,:st_running,:st_idle) " # update job if jobspec_list is not None: if len(workspec_list) > 0 and workspec_list[0].mapType == WorkSpec.MT_MultiWorkers: isMultiWorkers = True else: isMultiWorkers = False for jobSpec in jobspec_list: tmpLog = core_utils.make_logger(_logger, 'PandaID={0} by {1}'.format(jobSpec.PandaID, locked_by), method_name='update_jobs_workers') # check job varMap = dict() varMap[':PandaID'] = jobSpec.PandaID self.execute(sqlCJ, varMap) resCJ = self.cur.fetchone() tmpJobStatus, = resCJ # don't update cancelled jobs if tmpJobStatus == ['cancelled']: pass else: # get nWorkers tmpLog.debug('start') activeWorkers = set() if isMultiWorkers: varMap = dict() varMap[':PandaID'] = jobSpec.PandaID varMap[':st_submitted'] = WorkSpec.ST_submitted varMap[':st_running'] = WorkSpec.ST_running varMap[':st_idle'] = WorkSpec.ST_idle self.execute(sqlNW, varMap) resNW = self.cur.fetchall() for tmpWorkerID, in resNW: activeWorkers.add(tmpWorkerID) jobSpec.nWorkers = len(activeWorkers) # get all LFNs allLFNs = set() varMap = dict() varMap[':PandaID'] = jobSpec.PandaID varMap[':type'] = 'input' self.execute(sqlFL, varMap) resFL = self.cur.fetchall() for tmpLFN, in resFL: allLFNs.add(tmpLFN) # insert files nFiles = 0 fileIdMap = {} zipFileRes = dict() for fileSpec in jobSpec.outFiles: # insert file if fileSpec.lfn not in allLFNs: if jobSpec.zipPerMB is None or fileSpec.isZip in [0, 1]: fileSpec.status = 'defined' jobSpec.hasOutFile = JobSpec.HO_hasOutput else: fileSpec.status = 'pending' varMap = fileSpec.values_list() self.execute(sqlFI, varMap) fileSpec.fileID = self.cur.lastrowid nFiles += 1 # mapping between event range ID and file ID if fileSpec.eventRangeID is not None: fileIdMap[fileSpec.eventRangeID] = fileSpec.fileID # associate to itself if fileSpec.isZip == 1: varMap = dict() varMap[':status'] = fileSpec.status varMap[':fileID'] = fileSpec.fileID varMap[':zipFileID'] = fileSpec.fileID self.execute(sqlFU, varMap) elif fileSpec.isZip == 1 and fileSpec.eventRangeID is not None: # add a fake file with eventRangeID which has the same lfn/zipFileID as zip file varMap = dict() varMap[':PandaID'] = fileSpec.PandaID varMap[':lfn'] = fileSpec.lfn varMap[':eventRangeID'] = fileSpec.eventRangeID self.execute(sqlFE, varMap) resFE = self.cur.fetchone() if resFE is None: if fileSpec.lfn not in zipFileRes: # get file varMap = dict() varMap[':PandaID'] = fileSpec.PandaID varMap[':lfn'] = fileSpec.lfn self.execute(sqlFC, varMap) resFC = self.cur.fetchone() zipFileRes[fileSpec.lfn] = resFC # associate to existing zip resFC = zipFileRes[fileSpec.lfn] zipFileSpec = FileSpec() zipFileSpec.pack(resFC) fileSpec.status = 'zipped' fileSpec.zipFileID = zipFileSpec.zipFileID varMap = fileSpec.values_list() self.execute(sqlFI, varMap) nFiles += 1 # mapping between event range ID and file ID fileIdMap[fileSpec.eventRangeID] = self.cur.lastrowid if nFiles > 0: tmpLog.debug('inserted {0} files'.format(nFiles)) # check pending files if jobSpec.zipPerMB is not None and \ not (jobSpec.zipPerMB == 0 and jobSpec.subStatus != 'to_transfer'): # get workerID and provenanceID of pending files zippedFileIDs = [] varMap = dict() varMap[':PandaID'] = jobSpec.PandaID varMap[':status'] = 'pending' varMap[':type'] = 'input' self.execute(sqlPW, varMap) resPW = self.cur.fetchall() for subTotalSize, tmpProvenanceID, tmpWorkerID in resPW: if jobSpec.subStatus == 'to_transfer' \ or (jobSpec.zipPerMB > 0 and subTotalSize > jobSpec.zipPerMB * 1024 * 1024) \ or (tmpWorkerID is not None and tmpWorkerID not in activeWorkers): sqlFPx = sqlFP varMap = dict() varMap[':PandaID'] = jobSpec.PandaID varMap[':status'] = 'pending' varMap[':type'] = 'input' if tmpProvenanceID is None: sqlFPx += 'AND provenanceID IS NULL ' else: varMap[':provenanceID'] = tmpProvenanceID sqlFPx += 'AND provenanceID=:provenanceID ' if tmpWorkerID is None: sqlFPx += 'AND workerID IS NULL ' else: varMap[':workerID'] = tmpWorkerID sqlFPx += 'AND workerID=:workerID' # get pending files self.execute(sqlFPx, varMap) resFP = self.cur.fetchall() tmpLog.debug('got {0} pending files for workerID={1} provenanceID={2}'.format( len(resFP), tmpWorkerID, tmpProvenanceID)) # make subsets subTotalSize = 0 subFileIDs = [] for tmpFileID, tmpFsize, tmpLFN in resFP: if jobSpec.zipPerMB > 0 and subTotalSize > 0 \ and (subTotalSize + tmpFsize > jobSpec.zipPerMB * 1024 * 1024): zippedFileIDs.append(subFileIDs) subFileIDs = [] subTotalSize = 0 subTotalSize += tmpFsize subFileIDs.append((tmpFileID, tmpLFN)) if (jobSpec.subStatus == 'to_transfer' or (jobSpec.zipPerMB > 0 and subTotalSize > jobSpec.zipPerMB * 1024 * 1024) or (tmpWorkerID is not None and tmpWorkerID not in activeWorkers)) \ and len(subFileIDs) > 0: zippedFileIDs.append(subFileIDs) # make zip files for subFileIDs in zippedFileIDs: # insert zip file fileSpec = FileSpec() fileSpec.status = 'zipping' fileSpec.lfn = 'panda.' + subFileIDs[0][-1] + '.zip' fileSpec.scope = 'panda' fileSpec.fileType = 'zip_output' fileSpec.PandaID = jobSpec.PandaID fileSpec.taskID = jobSpec.taskID fileSpec.isZip = 1 varMap = fileSpec.values_list() self.execute(sqlFI, varMap) # update pending files varMaps = [] for tmpFileID, tmpLFN in subFileIDs: varMap = dict() varMap[':status'] = 'zipped' varMap[':fileID'] = tmpFileID varMap[':zipFileID'] = self.cur.lastrowid varMaps.append(varMap) self.executemany(sqlFU, varMaps) # set zip output flag if len(zippedFileIDs) > 0: jobSpec.hasOutFile = JobSpec.HO_hasZipOutput # get event ranges and file stat eventFileStat = dict() eventRangesSet = set() doneEventRangesSet = set() if len(jobSpec.events) > 0: # get event ranges varMap = dict() varMap[':PandaID'] = jobSpec.PandaID self.execute(sqlEC, varMap) resEC = self.cur.fetchall() for tmpEventRangeID, tmpEventStatus in resEC: if tmpEventStatus in ['running']: eventRangesSet.add(tmpEventRangeID) else: doneEventRangesSet.add(tmpEventRangeID) # check associated file varMap = dict() varMap[':PandaID'] = jobSpec.PandaID self.execute(sqlEF, varMap) resEF = self.cur.fetchall() for tmpEventRangeID, tmpStat in resEF: eventFileStat[tmpEventRangeID] = tmpStat # insert or update events varMapsEI = [] varMapsEU = [] for eventSpec in jobSpec.events: # already done if eventSpec.eventRangeID in doneEventRangesSet: continue # set subStatus if eventSpec.eventStatus == 'finished': # check associated file if eventSpec.eventRangeID not in eventFileStat or \ eventFileStat[eventSpec.eventRangeID] == 'finished': eventSpec.subStatus = 'finished' elif eventFileStat[eventSpec.eventRangeID] == 'failed': eventSpec.eventStatus = 'failed' eventSpec.subStatus = 'failed' else: eventSpec.subStatus = 'transferring' else: eventSpec.subStatus = eventSpec.eventStatus # set fileID if eventSpec.eventRangeID in fileIdMap: eventSpec.fileID = fileIdMap[eventSpec.eventRangeID] # insert or update event if eventSpec.eventRangeID not in eventRangesSet: varMap = eventSpec.values_list() varMapsEI.append(varMap) else: varMap = dict() varMap[':PandaID'] = jobSpec.PandaID varMap[':eventRangeID'] = eventSpec.eventRangeID varMap[':eventStatus'] = eventSpec.eventStatus varMap[':subStatus'] = eventSpec.subStatus varMapsEU.append(varMap) if len(varMapsEI) > 0: self.executemany(sqlEI, varMapsEI) tmpLog.debug('inserted {0} event'.format(len(varMapsEI))) if len(varMapsEU) > 0: self.executemany(sqlEU, varMapsEU) tmpLog.debug('updated {0} event'.format(len(varMapsEU))) # update job varMap = jobSpec.values_map(only_changed=True) if len(varMap) > 0: tmpLog.debug('update job') # sql to update job sqlJ = "UPDATE {0} SET {1} ".format(jobTableName, jobSpec.bind_update_changes_expression()) sqlJ += "WHERE PandaID=:PandaID " jobSpec.lockedBy = None jobSpec.modificationTime = timeNow varMap = jobSpec.values_map(only_changed=True) varMap[':PandaID'] = jobSpec.PandaID self.execute(sqlJ, varMap) nRow = self.cur.rowcount tmpLog.debug('done with {0}'.format(nRow)) tmpLog.debug('all done for job') # commit self.commit() # update worker retVal = True for idxW, workSpec in enumerate(workspec_list): tmpLog = core_utils.make_logger(_logger, 'workerID={0}'.format(workSpec.workerID), method_name='update_jobs_workers') tmpLog.debug('update worker') workSpec.lockedBy = None if workSpec.status == WorkSpec.ST_running and workSpec.startTime is None: workSpec.startTime = timeNow elif workSpec.is_final_status(): if workSpec.startTime is None: workSpec.startTime = timeNow if workSpec.endTime is None: workSpec.endTime = timeNow if not workSpec.nextLookup: if workSpec.has_updated_attributes(): workSpec.modificationTime = timeNow else: workSpec.nextLookup = False # sql to update worker sqlW = "UPDATE {0} SET {1} ".format(workTableName, workSpec.bind_update_changes_expression()) sqlW += "WHERE workerID=:workerID AND lockedBy=:cr_lockedBy " sqlW += "AND (status NOT IN (:st1,:st2,:st3,:st4)) " varMap = workSpec.values_map(only_changed=True) if len(varMap) > 0: varMap[':workerID'] = workSpec.workerID varMap[':cr_lockedBy'] = locked_by varMap[':st1'] = WorkSpec.ST_cancelled varMap[':st2'] = WorkSpec.ST_finished varMap[':st3'] = WorkSpec.ST_failed varMap[':st4'] = WorkSpec.ST_missed self.execute(sqlW, varMap) nRow = self.cur.rowcount tmpLog.debug('done with {0}'.format(nRow)) if nRow == 0: retVal = False # insert relationship if necessary if panda_ids_list is not None and len(panda_ids_list) > idxW: varMapsIR = [] for pandaID in panda_ids_list[idxW]: varMap = dict() varMap[':PandaID'] = pandaID varMap[':workerID'] = workSpec.workerID self.execute(sqlCR, varMap) resCR = self.cur.fetchone() if resCR is None: jwRelation = JobWorkerRelationSpec() jwRelation.PandaID = pandaID jwRelation.workerID = workSpec.workerID varMap = jwRelation.values_list() varMapsIR.append(varMap) if len(varMapsIR) > 0: self.executemany(sqlIR, varMapsIR) tmpLog.debug('all done for worker') # commit self.commit() # return return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get jobs with workerID def get_jobs_with_worker_id(self, worker_id, locked_by, with_file=False, only_running=False, slim=False): try: # get logger tmpLog = core_utils.make_logger(_logger, 'workerID={0}'.format(worker_id), method_name='get_jobs_with_worker_id') tmpLog.debug('start') # sql to get PandaIDs sqlP = "SELECT PandaID FROM {0} ".format(jobWorkerTableName) sqlP += "WHERE workerID=:workerID " # sql to get jobs sqlJ = "SELECT {0} FROM {1} ".format(JobSpec.column_names(slim=slim), jobTableName) sqlJ += "WHERE PandaID=:PandaID " # sql to get job parameters sqlJJ = "SELECT jobParams FROM {0} ".format(jobTableName) sqlJJ += "WHERE PandaID=:PandaID " # sql to lock job sqlL = "UPDATE {0} SET modificationTime=:timeNow,lockedBy=:lockedBy ".format(jobTableName) sqlL += "WHERE PandaID=:PandaID " # sql to get files sqlF = "SELECT {0} FROM {1} ".format(FileSpec.column_names(), fileTableName) sqlF += "WHERE PandaID=:PandaID AND zipFileID IS NULL " # get jobs jobChunkList = [] timeNow = datetime.datetime.utcnow() varMap = dict() varMap[':workerID'] = worker_id self.execute(sqlP, varMap) resW = self.cur.fetchall() for pandaID, in resW: # get job varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlJ, varMap) resJ = self.cur.fetchone() # make job jobSpec = JobSpec() jobSpec.pack(resJ, slim=slim) if only_running and jobSpec.subStatus not in ['running', 'submitted', 'queued', 'idle']: continue jobSpec.lockedBy = locked_by # for old jobs without extractions if jobSpec.jobParamsExtForLog is None: varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlJJ, varMap) resJJ = self.cur.fetchone() jobSpec.set_blob_attribute('jobParams', resJJ[0]) jobSpec.get_output_file_attributes() jobSpec.get_logfile_info() # lock job if locked_by is not None: varMap = dict() varMap[':PandaID'] = pandaID varMap[':lockedBy'] = locked_by varMap[':timeNow'] = timeNow self.execute(sqlL, varMap) # get files if with_file: varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlF, varMap) resFileList = self.cur.fetchall() for resFile in resFileList: fileSpec = FileSpec() fileSpec.pack(resFile) jobSpec.add_file(fileSpec) # append jobChunkList.append(jobSpec) # commit self.commit() tmpLog.debug('got {0} job chunks'.format(len(jobChunkList))) return jobChunkList except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # get ready workers def get_ready_workers(self, queue_name, n_ready): try: # get logger tmpLog = core_utils.make_logger(_logger, 'queue={0}'.format(queue_name), method_name='get_ready_workers') tmpLog.debug('start') # sql to get workers sqlG = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(), workTableName) sqlG += "WHERE computingSite=:queueName AND (status=:status_ready OR (status=:status_running " sqlG += "AND nJobsToReFill IS NOT NULL AND nJobsToReFill>0)) " sqlG += "ORDER BY modificationTime LIMIT {0} ".format(n_ready) # sql to get associated PandaIDs sqlP = "SELECT COUNT(*) cnt FROM {0} ".format(jobWorkerTableName) sqlP += "WHERE workerID=:workerID " # get workers varMap = dict() varMap[':status_ready'] = WorkSpec.ST_ready varMap[':status_running'] = WorkSpec.ST_running varMap[':queueName'] = queue_name self.execute(sqlG, varMap) resList = self.cur.fetchall() retVal = [] for res in resList: workSpec = WorkSpec() workSpec.pack(res) # get number of jobs varMap = dict() varMap[':workerID'] = workSpec.workerID self.execute(sqlP, varMap) resP = self.cur.fetchone() if resP is not None and resP[0] > 0: workSpec.nJobs = resP[0] retVal.append(workSpec) # commit self.commit() tmpLog.debug('got {0}'.format(str(retVal))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # get a worker def get_worker_with_id(self, worker_id): try: # get logger tmpLog = core_utils.make_logger(_logger, 'workerID={0}'.format(worker_id), method_name='get_worker_with_id') tmpLog.debug('start') # sql to get a worker sqlG = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(), workTableName) sqlG += "WHERE workerID=:workerID " # get a worker varMap = dict() varMap[':workerID'] = worker_id self.execute(sqlG, varMap) res = self.cur.fetchone() workSpec = WorkSpec() workSpec.pack(res) # commit self.commit() tmpLog.debug('got') return workSpec except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return None # get jobs to trigger or check output transfer or zip output def get_jobs_for_stage_out(self, max_jobs, interval_without_lock, interval_with_lock, locked_by, sub_status, has_out_file_flag, bad_has_out_file_flag=None, max_files_per_job=None): try: # get logger msgPfx = 'thr={0}'.format(locked_by) tmpLog = core_utils.make_logger(_logger, msgPfx, method_name='get_jobs_for_stage_out') tmpLog.debug('start') # sql to get PandaIDs without FOR UPDATE which causes deadlock in MariaDB sql = "SELECT PandaID FROM {0} ".format(jobTableName) sql += "WHERE " sql += "(subStatus=:subStatus OR hasOutFile=:hasOutFile) " if bad_has_out_file_flag is not None: sql += "AND (hasOutFile IS NULL OR hasOutFile<>:badHasOutFile) " sql += "AND (stagerTime IS NULL " sql += "OR (stagerTime<:lockTimeLimit AND stagerLock IS NOT NULL) " sql += "OR (stagerTime<:updateTimeLimit AND stagerLock IS NULL) " sql += ") " sql += "ORDER BY stagerTime " sql += "LIMIT {0} ".format(max_jobs) # sql to lock job sqlL = "UPDATE {0} SET stagerTime=:timeNow,stagerLock=:lockedBy ".format(jobTableName) sqlL += "WHERE PandaID=:PandaID AND " sqlL += "(subStatus=:subStatus OR hasOutFile=:hasOutFile) " if bad_has_out_file_flag is not None: sqlL += "AND (hasOutFile IS NULL OR hasOutFile<>:badHasOutFile) " sqlL += "AND (stagerTime IS NULL " sqlL += "OR (stagerTime<:lockTimeLimit AND stagerLock IS NOT NULL) " sqlL += "OR (stagerTime<:updateTimeLimit AND stagerLock IS NULL) " sqlL += ") " # sql to get job sqlJ = "SELECT {0} FROM {1} ".format(JobSpec.column_names(slim=True), jobTableName) sqlJ += "WHERE PandaID=:PandaID " # sql to get job parameters sqlJJ = "SELECT jobParams FROM {0} ".format(jobTableName) sqlJJ += "WHERE PandaID=:PandaID " # sql to get files sqlF = "SELECT {0} FROM {1} ".format(FileSpec.column_names(), fileTableName) sqlF += "WHERE PandaID=:PandaID AND status=:status AND fileType<>:type " if max_files_per_job is not None and max_files_per_job > 0: sqlF += "LIMIT {0} ".format(max_files_per_job) # sql to get associated files sqlAF = "SELECT {0} FROM {1} ".format(FileSpec.column_names(), fileTableName) sqlAF += "WHERE PandaID=:PandaID AND zipFileID=:zipFileID AND fileType<>:type " # sql to increment attempt number sqlFU = "UPDATE {0} SET attemptNr=attemptNr+1 WHERE fileID=:fileID ".format(fileTableName) # get jobs timeNow = datetime.datetime.utcnow() lockTimeLimit = timeNow - datetime.timedelta(seconds=interval_with_lock) updateTimeLimit = timeNow - datetime.timedelta(seconds=interval_without_lock) varMap = dict() varMap[':subStatus'] = sub_status varMap[':hasOutFile'] = has_out_file_flag if bad_has_out_file_flag is not None: varMap[':badHasOutFile'] = bad_has_out_file_flag varMap[':lockTimeLimit'] = lockTimeLimit varMap[':updateTimeLimit'] = updateTimeLimit self.execute(sql, varMap) resList = self.cur.fetchall() jobSpecList = [] for pandaID, in resList: # lock job varMap = dict() varMap[':PandaID'] = pandaID varMap[':timeNow'] = timeNow varMap[':lockedBy'] = locked_by varMap[':lockTimeLimit'] = lockTimeLimit varMap[':updateTimeLimit'] = updateTimeLimit varMap[':subStatus'] = sub_status varMap[':hasOutFile'] = has_out_file_flag if bad_has_out_file_flag is not None: varMap[':badHasOutFile'] = bad_has_out_file_flag self.execute(sqlL, varMap) nRow = self.cur.rowcount # commit self.commit() if nRow > 0: # get job varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlJ, varMap) resJ = self.cur.fetchone() # make job jobSpec = JobSpec() jobSpec.pack(resJ, slim=True) jobSpec.stagerLock = locked_by jobSpec.stagerTime = timeNow # for old jobs without extractions if jobSpec.jobParamsExtForLog is None: varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlJJ, varMap) resJJ = self.cur.fetchone() jobSpec.set_blob_attribute('jobParams', resJJ[0]) jobSpec.get_output_file_attributes() jobSpec.get_logfile_info() # get files varMap = dict() varMap[':PandaID'] = jobSpec.PandaID varMap[':type'] = 'input' if has_out_file_flag == JobSpec.HO_hasOutput: varMap[':status'] = 'defined' elif has_out_file_flag == JobSpec.HO_hasZipOutput: varMap[':status'] = 'zipping' else: varMap[':status'] = 'transferring' self.execute(sqlF, varMap) resFileList = self.cur.fetchall() for resFile in resFileList: fileSpec = FileSpec() fileSpec.pack(resFile) fileSpec.attemptNr += 1 jobSpec.add_out_file(fileSpec) # increment attempt number varMap = dict() varMap[':fileID'] = fileSpec.fileID self.execute(sqlFU, varMap) jobSpecList.append(jobSpec) # commit if len(resFileList) > 0: self.commit() # get associated files if has_out_file_flag == JobSpec.HO_hasZipOutput: for fileSpec in jobSpec.outFiles: varMap = dict() varMap[':PandaID'] = fileSpec.PandaID varMap[':zipFileID'] = fileSpec.fileID varMap[':type'] = 'input' self.execute(sqlAF, varMap) resAFs = self.cur.fetchall() for resAF in resAFs: assFileSpec = FileSpec() assFileSpec.pack(resAF) fileSpec.add_associated_file(assFileSpec) # get associated workers tmpWorkers = self.get_workers_with_job_id(jobSpec.PandaID, use_commit=False) jobSpec.add_workspec_list(tmpWorkers) tmpLog.debug('got {0} jobs'.format(len(jobSpecList))) return jobSpecList except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # update job for stage-out def update_job_for_stage_out(self, jobspec, update_event_status, locked_by): try: # get logger tmpLog = core_utils.make_logger(_logger, 'PandaID={0} subStatus={1} thr={2}'.format(jobspec.PandaID, jobspec.subStatus, locked_by), method_name='update_job_for_stage_out') tmpLog.debug('start') # sql to update event sqlEU = "UPDATE {0} ".format(eventTableName) sqlEU += "SET eventStatus=:eventStatus,subStatus=:subStatus " sqlEU += "WHERE eventRangeID=:eventRangeID " sqlEU += "AND eventStatus<>:statusFailed AND subStatus<>:statusDone " # sql to update associated events sqlAE = "UPDATE {0} ".format(eventTableName) sqlAE += "SET eventStatus=:eventStatus,subStatus=:subStatus " sqlAE += "WHERE eventRangeID IN " sqlAE += "(SELECT eventRangeID FROM {0} ".format(fileTableName) sqlAE += "WHERE PandaID=:PandaID AND zipFileID=:zipFileID) " sqlAE += "AND eventStatus<>:statusFailed AND subStatus<>:statusDone " # sql to lock job again sqlLJ = "UPDATE {0} SET stagerTime=:timeNow ".format(jobTableName) sqlLJ += "WHERE PandaID=:PandaID AND stagerLock=:lockedBy " # sql to check lock sqlLC = "SELECT stagerLock FROM {0} ".format(jobTableName) sqlLC += "WHERE PandaID=:PandaID " # lock varMap = dict() varMap[':PandaID'] = jobspec.PandaID varMap[':lockedBy'] = locked_by varMap[':timeNow'] = datetime.datetime.utcnow() self.execute(sqlLJ, varMap) nRow = self.cur.rowcount # check just in case since nRow can be 0 if two lock actions are too close in time if nRow == 0: varMap = dict() varMap[':PandaID'] = jobspec.PandaID self.execute(sqlLC, varMap) resLC = self.cur.fetchone() if resLC is not None and resLC[0] == locked_by: nRow = 1 # commit self.commit() if nRow == 0: tmpLog.debug('skip since locked by another') return None # update files tmpLog.debug('update {0} files'.format(len(jobspec.outFiles))) for fileSpec in jobspec.outFiles: # sql to update file sqlF = "UPDATE {0} SET {1} ".format(fileTableName, fileSpec.bind_update_changes_expression()) sqlF += "WHERE PandaID=:PandaID AND fileID=:fileID " varMap = fileSpec.values_map(only_changed=True) updated = False if len(varMap) > 0: varMap[':PandaID'] = fileSpec.PandaID varMap[':fileID'] = fileSpec.fileID self.execute(sqlF, varMap) updated = True # update event status if update_event_status: if fileSpec.eventRangeID is not None: varMap = dict() varMap[':eventRangeID'] = fileSpec.eventRangeID varMap[':eventStatus'] = fileSpec.status varMap[':subStatus'] = fileSpec.status varMap[':statusFailed'] = 'failed' varMap[':statusDone'] = 'done' self.execute(sqlEU, varMap) updated = True if fileSpec.isZip == 1: # update files associated with zip file varMap = dict() varMap[':PandaID'] = fileSpec.PandaID varMap[':zipFileID'] = fileSpec.fileID varMap[':eventStatus'] = fileSpec.status varMap[':subStatus'] = fileSpec.status varMap[':statusFailed'] = 'failed' varMap[':statusDone'] = 'done' self.execute(sqlAE, varMap) updated = True nRow = self.cur.rowcount tmpLog.debug('updated {0} events'.format(nRow)) if updated: # lock job again varMap = dict() varMap[':PandaID'] = jobspec.PandaID varMap[':lockedBy'] = locked_by varMap[':timeNow'] = datetime.datetime.utcnow() self.execute(sqlLJ, varMap) # commit self.commit() nRow = self.cur.rowcount if nRow == 0: tmpLog.debug('skip since locked by another') return None # count files sqlC = "SELECT COUNT(*) cnt,status FROM {0} ".format(fileTableName) sqlC += "WHERE PandaID=:PandaID GROUP BY status " varMap = dict() varMap[':PandaID'] = jobspec.PandaID self.execute(sqlC, varMap) resC = self.cur.fetchall() cntMap = {} for cnt, fileStatus in resC: cntMap[fileStatus] = cnt # set job attributes jobspec.stagerLock = None if 'zipping' in cntMap: jobspec.hasOutFile = JobSpec.HO_hasZipOutput elif 'defined' in cntMap: jobspec.hasOutFile = JobSpec.HO_hasOutput elif 'transferring' in cntMap: jobspec.hasOutFile = JobSpec.HO_hasTransfer else: jobspec.hasOutFile = JobSpec.HO_noOutput if jobspec.subStatus == 'to_transfer': # change subStatus when no more files to trigger transfer if jobspec.hasOutFile not in [JobSpec.HO_hasOutput, JobSpec.HO_hasZipOutput]: jobspec.subStatus = 'transferring' jobspec.stagerTime = None elif jobspec.subStatus == 'transferring': # all done if jobspec.hasOutFile == JobSpec.HO_noOutput: jobspec.trigger_propagation() if 'failed' in cntMap: jobspec.status = 'failed' jobspec.subStatus = 'failed_to_stage_out' else: jobspec.subStatus = 'staged' # get finished files jobspec.reset_out_file() sqlFF = "SELECT {0} FROM {1} ".format(FileSpec.column_names(), fileTableName) sqlFF += "WHERE PandaID=:PandaID AND status=:status AND fileType IN (:type1,:type2) " varMap = dict() varMap[':PandaID'] = jobspec.PandaID varMap[':status'] = 'finished' varMap[':type1'] = 'output' varMap[':type2'] = 'log' self.execute(sqlFF, varMap) resFileList = self.cur.fetchall() for resFile in resFileList: fileSpec = FileSpec() fileSpec.pack(resFile) jobspec.add_out_file(fileSpec) # make file report jobspec.outputFilesToReport = core_utils.get_output_file_report(jobspec) # sql to update job sqlJ = "UPDATE {0} SET {1} ".format(jobTableName, jobspec.bind_update_changes_expression()) sqlJ += "WHERE PandaID=:PandaID AND stagerLock=:lockedBy " # update job varMap = jobspec.values_map(only_changed=True) varMap[':PandaID'] = jobspec.PandaID varMap[':lockedBy'] = locked_by self.execute(sqlJ, varMap) # commit self.commit() tmpLog.debug('done') # return return jobspec.subStatus except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return None # add a seq number def add_seq_number(self, number_name, init_value): try: # check if already there sqlC = "SELECT curVal FROM {0} WHERE numberName=:numberName ".format(seqNumberTableName) varMap = dict() varMap[':numberName'] = number_name self.execute(sqlC, varMap) res = self.cur.fetchone() # insert if missing if res is None: # make spec seqNumberSpec = SeqNumberSpec() seqNumberSpec.numberName = number_name seqNumberSpec.curVal = init_value # insert sqlI = "INSERT INTO {0} ({1}) ".format(seqNumberTableName, SeqNumberSpec.column_names()) sqlI += SeqNumberSpec.bind_values_expression() varMap = seqNumberSpec.values_list() self.execute(sqlI, varMap) # commit self.commit() return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get next value for a seq number def get_next_seq_number(self, number_name): try: # get logger tmpLog = core_utils.make_logger(_logger, 'name={0}'.format(number_name), method_name='get_next_seq_number') # increment sqlU = "UPDATE {0} SET curVal=curVal+1 WHERE numberName=:numberName ".format(seqNumberTableName) varMap = dict() varMap[':numberName'] = number_name self.execute(sqlU, varMap) # get sqlG = "SELECT curVal FROM {0} WHERE numberName=:numberName ".format(seqNumberTableName) varMap = dict() varMap[':numberName'] = number_name self.execute(sqlG, varMap) retVal, = self.cur.fetchone() # commit self.commit() tmpLog.debug('got {0}'.format(retVal)) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return None # get last update time for a cached info def get_cache_last_update_time(self, main_key, sub_key): try: # get logger tmpLog = core_utils.make_logger(_logger, 'mainKey={0} subKey={1}'.format(main_key, sub_key), method_name='get_cache_last_update_time') # get varMap = dict() varMap[":mainKey"] = main_key sqlU = "SELECT lastUpdate FROM {0} WHERE mainKey=:mainKey ".format(cacheTableName) if sub_key is not None: sqlU += "AND subKey=:subKey " varMap[":subKey"] = sub_key self.execute(sqlU, varMap) retVal = self.cur.fetchone() if retVal is not None: retVal, = retVal # commit self.commit() tmpLog.debug('got {0}'.format(retVal)) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return None # refresh a cached info def refresh_cache(self, main_key, sub_key, new_info): try: # get logger tmpLog = core_utils.make_logger(_logger, 'mainKey={0} subKey={1}'.format(main_key, sub_key), method_name='refresh_cache') # make spec cacheSpec = CacheSpec() cacheSpec.lastUpdate = datetime.datetime.utcnow() cacheSpec.data = new_info # check if already there varMap = dict() varMap[":mainKey"] = main_key sqlC = "SELECT lastUpdate FROM {0} WHERE mainKey=:mainKey ".format(cacheTableName) if sub_key is not None: sqlC += "AND subKey=:subKey " varMap[":subKey"] = sub_key self.execute(sqlC, varMap) retC = self.cur.fetchone() if retC is None: # insert if missing cacheSpec.mainKey = main_key cacheSpec.subKey = sub_key sqlU = "INSERT INTO {0} ({1}) ".format(cacheTableName, CacheSpec.column_names()) sqlU += CacheSpec.bind_values_expression() varMap = cacheSpec.values_list() else: # update sqlU = "UPDATE {0} SET {1} ".format(cacheTableName, cacheSpec.bind_update_changes_expression()) sqlU += "WHERE mainKey=:mainKey " varMap = cacheSpec.values_map(only_changed=True) varMap[":mainKey"] = main_key if sub_key is not None: sqlU += "AND subKey=:subKey " varMap[":subKey"] = sub_key self.execute(sqlU, varMap) # commit self.commit() # put into global dict cacheKey = 'cache|{0}|{1}'.format(main_key, sub_key) globalDict = core_utils.get_global_dict() globalDict.acquire() globalDict[cacheKey] = cacheSpec.data globalDict.release() tmpLog.debug('refreshed') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get a cached info def get_cache(self, main_key, sub_key=None): useDB = False try: # get logger tmpLog = core_utils.make_logger(_logger, 'mainKey={0} subKey={1}'.format(main_key, sub_key), method_name='get_cache') tmpLog.debug('start') # get from global dict cacheKey = 'cache|{0}|{1}'.format(main_key, sub_key) globalDict = core_utils.get_global_dict() # lock dict globalDict.acquire() # found if cacheKey in globalDict: # release dict globalDict.release() # make spec cacheSpec = CacheSpec() cacheSpec.data = globalDict[cacheKey] else: # read from database useDB = True sql = "SELECT {0} FROM {1} ".format(CacheSpec.column_names(), cacheTableName) sql += "WHERE mainKey=:mainKey " varMap = dict() varMap[":mainKey"] = main_key if sub_key is not None: sql += "AND subKey=:subKey " varMap[":subKey"] = sub_key self.execute(sql, varMap) resJ = self.cur.fetchone() # commit self.commit() if resJ is None: # release dict globalDict.release() return None # make spec cacheSpec = CacheSpec() cacheSpec.pack(resJ) # put into global dict globalDict[cacheKey] = cacheSpec.data # release dict globalDict.release() tmpLog.debug('done') # return return cacheSpec except Exception: if useDB: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return None # store commands def store_commands(self, command_specs): # get logger tmpLog = core_utils.make_logger(_logger, method_name='store_commands') tmpLog.debug('{0} commands'.format(len(command_specs))) if not command_specs: return True try: # sql to insert a command sql = "INSERT INTO {0} ({1}) ".format(commandTableName, CommandSpec.column_names()) sql += CommandSpec.bind_values_expression() # loop over all commands var_maps = [] for command_spec in command_specs: var_map = command_spec.values_list() var_maps.append(var_map) # insert self.executemany(sql, var_maps) # commit self.commit() # return return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return False # get commands for a receiver def get_commands_for_receiver(self, receiver, command_pattern=None): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_commands_for_receiver') tmpLog.debug('start') # sql to get commands varMap = dict() varMap[':receiver'] = receiver varMap[':processed'] = 0 sqlG = "SELECT {0} FROM {1} ".format(CommandSpec.column_names(), commandTableName) sqlG += "WHERE receiver=:receiver AND processed=:processed " if command_pattern is not None: varMap[':command'] = command_pattern if '%' in command_pattern: sqlG += "AND command LIKE :command " else: sqlG += "AND command=:command " sqlG += "FOR UPDATE " # sql to lock command sqlL = "UPDATE {0} SET processed=:processed WHERE command_id=:command_id ".format(commandTableName) self.execute(sqlG, varMap) commandSpecList = [] for res in self.cur.fetchall(): # make command commandSpec = CommandSpec() commandSpec.pack(res) # lock varMap = dict() varMap[':command_id'] = commandSpec.command_id varMap[':processed'] = 1 self.execute(sqlL, varMap) # append commandSpecList.append(commandSpec) # commit self.commit() tmpLog.debug('got {0} commands'.format(len(commandSpecList))) return commandSpecList except Exception: # dump error core_utils.dump_error_message(_logger) # return return [] # get command ids that have been processed and need to be acknowledged to panda server def get_commands_ack(self): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_commands_ack') tmpLog.debug('start') # sql to get commands that have been processed and need acknowledgement sql = """ SELECT command_id FROM {0} WHERE ack_requested=1 AND processed=1 """.format(commandTableName) self.execute(sql) command_ids = [row[0] for row in self.cur.fetchall()] tmpLog.debug('command_ids {0}'.format(command_ids)) return command_ids except Exception: # dump error core_utils.dump_error_message(_logger) # return return [] def clean_commands_by_id(self, commands_ids): """ Deletes the commands specified in a list of IDs """ # get logger tmpLog = core_utils.make_logger(_logger, method_name='clean_commands_by_id') try: # sql to delete a specific command sql = """ DELETE FROM {0} WHERE command_id=:command_id""".format(commandTableName) for command_id in commands_ids: var_map = {':command_id': command_id} self.execute(sql, var_map) self.commit() return True except Exception: self.rollback() core_utils.dump_error_message(tmpLog) return False def clean_processed_commands(self): """ Deletes the commands that have been processed and do not need acknowledgement """ tmpLog = core_utils.make_logger(_logger, method_name='clean_processed_commands') try: # sql to delete all processed commands that do not need an ACK sql = """ DELETE FROM {0} WHERE (ack_requested=0 AND processed=1) """.format(commandTableName) self.execute(sql) self.commit() return True except Exception: self.rollback() core_utils.dump_error_message(tmpLog) return False # get workers to kill def get_workers_to_kill(self, max_workers, check_interval): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_workers_to_kill') tmpLog.debug('start') # sql to get worker IDs sqlW = "SELECT workerID,status,configID FROM {0} ".format(workTableName) sqlW += "WHERE killTime IS NOT NULL AND killTime<:checkTimeLimit " sqlW += "ORDER BY killTime LIMIT {0} ".format(max_workers) # sql to lock or release worker sqlL = "UPDATE {0} SET killTime=:setTime ".format(workTableName) sqlL += "WHERE workerID=:workerID " sqlL += "AND killTime IS NOT NULL AND killTime<:checkTimeLimit " # sql to get workers sqlG = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(), workTableName) sqlG += "WHERE workerID=:workerID " timeNow = datetime.datetime.utcnow() timeLimit = timeNow - datetime.timedelta(seconds=check_interval) # get workerIDs varMap = dict() varMap[':checkTimeLimit'] = timeLimit self.execute(sqlW, varMap) resW = self.cur.fetchall() retVal = dict() for workerID, workerStatus, configID in resW: # ignore configID if not core_utils.dynamic_plugin_change(): configID = None # lock or release worker varMap = dict() varMap[':workerID'] = workerID varMap[':checkTimeLimit'] = timeLimit if workerStatus in (WorkSpec.ST_cancelled, WorkSpec.ST_failed, WorkSpec.ST_finished): # release varMap[':setTime'] = None else: # lock varMap[':setTime'] = timeNow self.execute(sqlL, varMap) # get worker nRow = self.cur.rowcount if nRow == 1 and varMap[':setTime'] is not None: varMap = dict() varMap[':workerID'] = workerID self.execute(sqlG, varMap) resG = self.cur.fetchone() workSpec = WorkSpec() workSpec.pack(resG) queueName = workSpec.computingSite retVal.setdefault(queueName, dict()) retVal[queueName].setdefault(configID, []) retVal[queueName][configID].append(workSpec) # commit self.commit() tmpLog.debug('got {0} workers'.format(len(retVal))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # get worker stats def get_worker_stats(self, site_name): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_worker_stats') tmpLog.debug('start') # sql to get nQueueLimit sqlQ = "SELECT queueName,resourceType,nNewWorkers FROM {0} ".format(pandaQueueTableName) sqlQ += "WHERE siteName=:siteName " # get nQueueLimit varMap = dict() varMap[':siteName'] = site_name self.execute(sqlQ, varMap) resQ = self.cur.fetchall() retMap = dict() for computingSite, resourceType, nNewWorkers in resQ: if resourceType not in retMap: retMap[resourceType] = { 'running': 0, 'submitted': 0, 'to_submit': nNewWorkers } # get worker stats sqlW = "SELECT wt.status, wt.computingSite, pq.resourceType, COUNT(*) cnt " sqlW += "FROM {0} wt, {1} pq ".format(workTableName, pandaQueueTableName) sqlW += "WHERE pq.siteName=:siteName AND wt.computingSite=pq.queueName AND wt.status IN (:st1,:st2) " sqlW += "GROUP BY wt.status, wt.computingSite, pq.resourceType " # get worker stats varMap = dict() varMap[':siteName'] = site_name varMap[':st1'] = 'running' varMap[':st2'] = 'submitted' self.execute(sqlW, varMap) resW = self.cur.fetchall() for workerStatus, computingSite, resourceType, cnt in resW: if resourceType not in retMap: retMap[resourceType] = { 'running': 0, 'submitted': 0, 'to_submit': 0 } retMap[resourceType][workerStatus] = cnt # commit self.commit() tmpLog.debug('got {0}'.format(str(retMap))) return retMap except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # get worker stats def get_worker_stats_bulk(self, active_ups_queues): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_worker_stats_bulk') tmpLog.debug('start') # sql to get nQueueLimit sqlQ = "SELECT queueName, resourceType, nNewWorkers FROM {0} ".format(pandaQueueTableName) # get nQueueLimit self.execute(sqlQ) resQ = self.cur.fetchall() retMap = dict() for computingSite, resourceType, nNewWorkers in resQ: retMap.setdefault(computingSite, {}) if resourceType and resourceType != 'ANY' and resourceType not in retMap[computingSite]: retMap[computingSite][resourceType] = {'running': 0, 'submitted': 0, 'to_submit': nNewWorkers} # get worker stats sqlW = "SELECT wt.status, wt.computingSite, wt.resourceType, COUNT(*) cnt " sqlW += "FROM {0} wt ".format(workTableName) sqlW += "WHERE wt.status IN (:st1,:st2) " sqlW += "GROUP BY wt.status,wt.computingSite, wt.resourceType " # get worker stats varMap = dict() varMap[':st1'] = 'running' varMap[':st2'] = 'submitted' self.execute(sqlW, varMap) resW = self.cur.fetchall() for workerStatus, computingSite, resourceType, cnt in resW: if resourceType and resourceType != 'ANY': retMap.setdefault(computingSite, {}) retMap[computingSite].setdefault(resourceType, {'running': 0, 'submitted': 0, 'to_submit': 0}) retMap[computingSite][resourceType][workerStatus] = cnt # if there are no jobs for an active UPS queue, it needs to be initialized so that the pilot streaming # on panda server starts processing the queue if active_ups_queues: for ups_queue in active_ups_queues: if ups_queue not in retMap or not retMap[ups_queue]: retMap[ups_queue] = {'SCORE': {'running': 0, 'submitted': 0, 'to_submit': 0}} # commit self.commit() tmpLog.debug('got {0}'.format(str(retMap))) return retMap except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # send kill command to workers associated to a job def kill_workers_with_job(self, panda_id): try: # get logger tmpLog = core_utils.make_logger(_logger, 'PandaID={0}'.format(panda_id), method_name='kill_workers_with_job') tmpLog.debug('start') # sql to set killTime sqlL = "UPDATE {0} SET killTime=:setTime ".format(workTableName) sqlL += "WHERE workerID=:workerID AND killTime IS NULL AND NOT status IN (:st1,:st2,:st3) " # sql to get associated workers sqlA = "SELECT workerID FROM {0} ".format(jobWorkerTableName) sqlA += "WHERE PandaID=:pandaID " # set an older time to trigger sweeper setTime = datetime.datetime.utcnow() - datetime.timedelta(hours=6) # get workers varMap = dict() varMap[':pandaID'] = panda_id self.execute(sqlA, varMap) resA = self.cur.fetchall() nRow = 0 for workerID, in resA: # set killTime varMap = dict() varMap[':workerID'] = workerID varMap[':setTime'] = setTime varMap[':st1'] = WorkSpec.ST_finished varMap[':st2'] = WorkSpec.ST_failed varMap[':st3'] = WorkSpec.ST_cancelled self.execute(sqlL, varMap) nRow += self.cur.rowcount # commit self.commit() tmpLog.debug('set killTime to {0} workers'.format(nRow)) return nRow except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return None # send kill command to a worker def kill_worker(self, worker_id): try: # get logger tmpLog = core_utils.make_logger(_logger, 'workerID={0}'.format(worker_id), method_name='kill_worker') tmpLog.debug('start') # sql to set killTime sqlL = "UPDATE {0} SET killTime=:setTime ".format(workTableName) sqlL += "WHERE workerID=:workerID AND killTime IS NULL AND NOT status IN (:st1,:st2,:st3) " # set an older time to trigger sweeper setTime = datetime.datetime.utcnow() - datetime.timedelta(hours=6) # set killTime varMap = dict() varMap[':workerID'] = worker_id varMap[':setTime'] = setTime varMap[':st1'] = WorkSpec.ST_finished varMap[':st2'] = WorkSpec.ST_failed varMap[':st3'] = WorkSpec.ST_cancelled self.execute(sqlL, varMap) nRow = self.cur.rowcount # commit self.commit() tmpLog.debug('set killTime with {0}'.format(nRow)) return nRow except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return None # get workers for cleanup def get_workers_for_cleanup(self, max_workers, status_timeout_map): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_workers_for_cleanup') tmpLog.debug('start') # sql to get worker IDs timeNow = datetime.datetime.utcnow() modTimeLimit = timeNow - datetime.timedelta(minutes=60) varMap = dict() varMap[':timeLimit'] = modTimeLimit sqlW = "SELECT workerID, configID FROM {0} ".format(workTableName) sqlW += "WHERE lastUpdate IS NULL AND (" for tmpStatus, tmpTimeout in iteritems(status_timeout_map): tmpStatusKey = ':status_{0}'.format(tmpStatus) tmpTimeoutKey = ':timeLimit_{0}'.format(tmpStatus) sqlW += '(status={0} AND endTime<={1}) OR '.format(tmpStatusKey, tmpTimeoutKey) varMap[tmpStatusKey] = tmpStatus varMap[tmpTimeoutKey] = timeNow - datetime.timedelta(hours=tmpTimeout) sqlW = sqlW[:-4] sqlW += ') ' sqlW += 'AND modificationTime<:timeLimit ' sqlW += "ORDER BY modificationTime LIMIT {0} ".format(max_workers) # sql to lock or release worker sqlL = "UPDATE {0} SET modificationTime=:setTime ".format(workTableName) sqlL += "WHERE workerID=:workerID AND modificationTime<:timeLimit " # sql to check associated jobs sqlA = "SELECT COUNT(*) cnt FROM {0} j, {1} r ".format(jobTableName, jobWorkerTableName) sqlA += "WHERE j.PandaID=r.PandaID AND r.workerID=:workerID " sqlA += "AND propagatorTime IS NOT NULL " # sql to get workers sqlG = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(), workTableName) sqlG += "WHERE workerID=:workerID " # sql to get PandaIDs sqlP = "SELECT j.PandaID FROM {0} j, {1} r ".format(jobTableName, jobWorkerTableName) sqlP += "WHERE j.PandaID=r.PandaID AND r.workerID=:workerID " # sql to get jobs sqlJ = "SELECT {0} FROM {1} ".format(JobSpec.column_names(), jobTableName) sqlJ += "WHERE PandaID=:PandaID " # sql to get files sqlF = "SELECT {0} FROM {1} ".format(FileSpec.column_names(), fileTableName) sqlF += "WHERE PandaID=:PandaID " # sql to get files not to be deleted. b.todelete is not used to use index on b.lfn sqlD = "SELECT b.lfn,b.todelete FROM {0} a, {0} b ".format(fileTableName) sqlD += "WHERE a.PandaID=:PandaID AND a.fileType=:fileType AND b.lfn=a.lfn " # get workerIDs timeNow = datetime.datetime.utcnow() self.execute(sqlW, varMap) resW = self.cur.fetchall() retVal = dict() iWorkers = 0 for workerID, configID in resW: # lock worker varMap = dict() varMap[':workerID'] = workerID varMap[':setTime'] = timeNow varMap[':timeLimit'] = modTimeLimit self.execute(sqlL, varMap) # commit self.commit() if self.cur.rowcount == 0: continue # ignore configID if not core_utils.dynamic_plugin_change(): configID = None # check associated jobs varMap = dict() varMap[':workerID'] = workerID self.execute(sqlA, varMap) nActJobs, = self.cur.fetchone() # cleanup when there is no active job if nActJobs == 0: # get worker varMap = dict() varMap[':workerID'] = workerID self.execute(sqlG, varMap) resG = self.cur.fetchone() workSpec = WorkSpec() workSpec.pack(resG) queueName = workSpec.computingSite retVal.setdefault(queueName, dict()) retVal[queueName].setdefault(configID, []) retVal[queueName][configID].append(workSpec) # get jobs jobSpecs = [] checkedLFNs = set() keepLFNs = set() varMap = dict() varMap[':workerID'] = workerID self.execute(sqlP, varMap) resP = self.cur.fetchall() for pandaID, in resP: varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlJ, varMap) resJ = self.cur.fetchone() jobSpec = JobSpec() jobSpec.pack(resJ) jobSpecs.append(jobSpec) # get LFNs not to be deleted varMap = dict() varMap[':PandaID'] = pandaID varMap[':fileType'] = 'input' self.execute(sqlD, varMap) resDs = self.cur.fetchall() for tmpLFN, tmpTodelete in resDs: if tmpTodelete == 0: keepLFNs.add(tmpLFN) # get files to be deleted varMap = dict() varMap[':PandaID'] = jobSpec.PandaID self.execute(sqlF, varMap) resFs = self.cur.fetchall() for resF in resFs: fileSpec = FileSpec() fileSpec.pack(resF) # skip if already checked if fileSpec.lfn in checkedLFNs: continue checkedLFNs.add(fileSpec.lfn) # check if it is ready to delete if fileSpec.lfn not in keepLFNs: jobSpec.add_file(fileSpec) workSpec.set_jobspec_list(jobSpecs) iWorkers += 1 tmpLog.debug('got {0} workers'.format(iWorkers)) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # delete a worker def delete_worker(self, worker_id): try: # get logger tmpLog = core_utils.make_logger(_logger, 'workerID={0}'.format(worker_id), method_name='delete_worker') tmpLog.debug('start') # sql to get jobs sqlJ = "SELECT PandaID FROM {0} ".format(jobWorkerTableName) sqlJ += "WHERE workerID=:workerID " # sql to delete job sqlDJ = "DELETE FROM {0} ".format(jobTableName) sqlDJ += "WHERE PandaID=:PandaID " # sql to delete files sqlDF = "DELETE FROM {0} ".format(fileTableName) sqlDF += "WHERE PandaID=:PandaID " # sql to delete events sqlDE = "DELETE FROM {0} ".format(eventTableName) sqlDE += "WHERE PandaID=:PandaID " # sql to delete relations sqlDR = "DELETE FROM {0} ".format(jobWorkerTableName) sqlDR += "WHERE PandaID=:PandaID " # sql to delete worker sqlDW = "DELETE FROM {0} ".format(workTableName) sqlDW += "WHERE workerID=:workerID " # get jobs varMap = dict() varMap[':workerID'] = worker_id self.execute(sqlJ, varMap) resJ = self.cur.fetchall() for pandaID, in resJ: varMap = dict() varMap[':PandaID'] = pandaID # delete job self.execute(sqlDJ, varMap) # delete files self.execute(sqlDF, varMap) # delete events self.execute(sqlDE, varMap) # delete relations self.execute(sqlDR, varMap) # delete worker varMap = dict() varMap[':workerID'] = worker_id self.execute(sqlDW, varMap) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # release jobs def release_jobs(self, panda_ids, locked_by): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='release_jobs') tmpLog.debug('start for {0} jobs'.format(len(panda_ids))) # sql to release job sql = "UPDATE {0} SET lockedBy=NULL ".format(jobTableName) sql += "WHERE PandaID=:pandaID AND lockedBy=:lockedBy " nJobs = 0 for pandaID in panda_ids: varMap = dict() varMap[':pandaID'] = pandaID varMap[':lockedBy'] = locked_by self.execute(sql, varMap) if self.cur.rowcount > 0: nJobs += 1 # commit self.commit() tmpLog.debug('released {0} jobs'.format(nJobs)) # return return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # clone queue def clone_queue_with_new_resource_type(self, site_name, queue_name, resource_type, new_workers): try: # get logger tmpLog = core_utils.make_logger(_logger, 'site_name={0} queue_name={1}'.format(site_name, queue_name), method_name='clone_queue_with_new_resource_type') tmpLog.debug('start') # get the values from one of the existing queues sql_select_queue = "SELECT {0} FROM {1} ".format(PandaQueueSpec.column_names(), pandaQueueTableName) sql_select_queue += "WHERE siteName=:siteName " var_map = dict() var_map[':siteName'] = site_name self.execute(sql_select_queue, var_map) queue = self.cur.fetchone() if queue: # a queue to clone was found var_map = {} attribute_list = [] attr_binding_list = [] for attribute, value in zip(PandaQueueSpec.column_names().split(','), queue): attr_binding = ':{0}'.format(attribute) if attribute == 'resourceType': var_map[attr_binding] = resource_type elif attribute == 'nNewWorkers': var_map[attr_binding] = new_workers elif attribute == 'uniqueName': var_map[attr_binding] = core_utils.get_unique_queue_name(queue_name, resource_type) else: var_map[attr_binding] = value attribute_list.append(attribute) attr_binding_list.append(attr_binding) sql_insert = "INSERT IGNORE INTO {0} ({1}) ".format(pandaQueueTableName, ','.join(attribute_list)) sql_values = "VALUES ({0}) ".format(','.join(attr_binding_list)) self.execute(sql_insert + sql_values, var_map) else: tmpLog.debug("Failed to clone the queue") self.commit() return True except Exception: self.rollback() core_utils.dump_error_message(_logger) return False # set queue limit def set_queue_limit(self, site_name, params): try: # get logger tmpLog = core_utils.make_logger(_logger, 'siteName={0}'.format(site_name), method_name='set_queue_limit') tmpLog.debug('start') # sql to reset queue limits before setting new command to avoid old values being repeated again and again sql_reset = "UPDATE {0} ".format(pandaQueueTableName) sql_reset += "SET nNewWorkers=:zero WHERE siteName=:siteName " # sql to get resource types sql_get_resource = "SELECT resourceType FROM {0} ".format(pandaQueueTableName) sql_get_resource += "WHERE siteName=:siteName " sql_get_resource += "FOR UPDATE " # sql to update nQueueLimit sql_update_queue = "UPDATE {0} ".format(pandaQueueTableName) sql_update_queue += "SET nNewWorkers=:nQueue WHERE siteName=:siteName AND resourceType=:resourceType " # sql to get num of submitted workers sql_count_workers = "SELECT COUNT(*) cnt " sql_count_workers += "FROM {0} wt, {1} pq ".format(workTableName, pandaQueueTableName) sql_count_workers += "WHERE pq.siteName=:siteName AND wt.computingSite=pq.queueName AND wt.status=:status " sql_count_workers += "ANd pq.resourceType=:resourceType " # reset nqueued for all resource types varMap = dict() varMap[':zero'] = 0 varMap[':siteName'] = site_name self.execute(sql_reset, varMap) # get resource types varMap = dict() varMap[':siteName'] = site_name self.execute(sql_get_resource, varMap) resRes = self.cur.fetchall() resource_type_list = set() for tmpRes, in resRes: resource_type_list.add(tmpRes) # set all queues nUp = 0 retMap = dict() queue_name = site_name for resource_type, value in iteritems(params): tmpLog.debug('Processing rt {0} -> {1}'.format(resource_type, value)) # get num of submitted workers varMap = dict() varMap[':siteName'] = site_name varMap[':resourceType'] = resource_type varMap[':status'] = 'submitted' self.execute(sql_count_workers, varMap) res = self.cur.fetchone() tmpLog.debug('{0} has {1} submitted workers'.format(resource_type, res)) nSubmittedWorkers = 0 if res is not None: nSubmittedWorkers, = res # set new value # value = max(value - nSubmittedWorkers, 0) if value is None: value = 0 varMap = dict() varMap[':nQueue'] = value varMap[':siteName'] = site_name varMap[':resourceType'] = resource_type self.execute(sql_update_queue, varMap) iUp = self.cur.rowcount # iUp is 0 when nQueue is not changed if iUp > 0 or resource_type in resource_type_list: # a queue was updated, add the values to the map retMap[resource_type] = value else: # no queue was updated, we need to create a new one for the resource type cloned = self.clone_queue_with_new_resource_type(site_name, queue_name, resource_type, value) if cloned: retMap[resource_type] = value iUp = 1 nUp += iUp tmpLog.debug('set nNewWorkers={0} to {1}:{2} with {3}'.format(value, queue_name, resource_type, iUp)) # commit self.commit() tmpLog.debug('updated {0} queues'.format(nUp)) return retMap except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # get the number of missed worker def get_num_missed_workers(self, queue_name, criteria): try: # get logger tmpLog = core_utils.make_logger(_logger,"queue={0}".format(queue_name), method_name='get_num_missed_workers') tmpLog.debug('start') # get worker stats sqlW = "SELECT COUNT(*) cnt " sqlW += "FROM {0} wt, {1} pq ".format(workTableName, pandaQueueTableName) sqlW += "WHERE wt.computingSite=pq.queueName AND wt.status=:status " # get worker stats varMap = dict() for attr, val in iteritems(criteria): if attr == 'timeLimit': sqlW += "AND wt.submitTime>:timeLimit " varMap[':timeLimit'] = val elif attr in ['siteName']: sqlW += "AND pq.{0}=:{0} ".format(attr) varMap[':{0}'.format(attr)] = val elif attr in ['computingSite', 'computingElement']: sqlW += "AND wt.{0}=:{0} ".format(attr) varMap[':{0}'.format(attr)] = val varMap[':status'] = 'missed' self.execute(sqlW, varMap) resW = self.cur.fetchone() if resW is None: nMissed = 0 else: nMissed, = resW # commit self.commit() tmpLog.debug('got nMissed={0} for {1}'.format(nMissed, str(criteria))) return nMissed except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return 0 # get a worker def get_workers_with_job_id(self, panda_id, use_commit=True): try: # get logger tmpLog = core_utils.make_logger(_logger, 'pandaID={0}'.format(panda_id), method_name='get_workers_with_job_id') tmpLog.debug('start') # sql to get workerIDs sqlW = "SELECT workerID FROM {0} WHERE PandaID=:PandaID ".format(jobWorkerTableName) sqlW += "ORDER BY workerID " # sql to get a worker sqlG = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(slim=True), workTableName) sqlG += "WHERE workerID=:workerID " # get workerIDs varMap = dict() varMap[':PandaID'] = panda_id self.execute(sqlW, varMap) retList = [] for worker_id, in self.cur.fetchall(): # get a worker varMap = dict() varMap[':workerID'] = worker_id self.execute(sqlG, varMap) res = self.cur.fetchone() workSpec = WorkSpec() workSpec.pack(res, slim=True) retList.append(workSpec) # commit if use_commit: self.commit() tmpLog.debug('got {0} workers'.format(len(retList))) return retList except Exception: # roll back if use_commit: self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # delete old process locks def clean_process_locks(self): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='clean_process_locks') tmpLog.debug('start') # delete locks sqlW = "DELETE FROM {0} ".format(processLockTableName) # get worker stats self.execute(sqlW) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get a process lock def get_process_lock(self, process_name, locked_by, lock_interval): try: # get logger tmpLog = core_utils.make_logger(_logger, "proc={0} by={1}".format(process_name, locked_by), method_name='get_process_lock') tmpLog.debug('start') # delete old lock sqlD = "DELETE FROM {0} ".format(processLockTableName) sqlD += "WHERE lockTime<:timeLimit " varMap = dict() varMap[':timeLimit'] = datetime.datetime.utcnow() - datetime.timedelta(hours=6) self.execute(sqlD, varMap) # commit self.commit() # check lock sqlC = "SELECT lockTime FROM {0} ".format(processLockTableName) sqlC += "WHERE processName=:processName " varMap = dict() varMap[':processName'] = process_name self.execute(sqlC, varMap) resC = self.cur.fetchone() retVal = False timeNow = datetime.datetime.utcnow() if resC is None: # insert lock if missing sqlI = "INSERT INTO {0} ({1}) ".format(processLockTableName, ProcessLockSpec.column_names()) sqlI += ProcessLockSpec.bind_values_expression() processLockSpec = ProcessLockSpec() processLockSpec.processName = process_name processLockSpec.lockedBy = locked_by processLockSpec.lockTime = timeNow varMap = processLockSpec.values_list() self.execute(sqlI, varMap) retVal = True else: oldLockTime, = resC timeLimit = timeNow - datetime.timedelta(seconds=lock_interval) if oldLockTime <= timeLimit: # update lock if old sqlU = "UPDATE {0} SET lockedBy=:lockedBy,lockTime=:timeNow ".format(processLockTableName) sqlU += "WHERE processName=:processName AND lockTime<=:timeLimit " varMap = dict() varMap[':processName'] = process_name varMap[':lockedBy'] = locked_by varMap[':timeLimit'] = timeLimit varMap[':timeNow'] = timeNow self.execute(sqlU, varMap) if self.cur.rowcount > 0: retVal = True # commit self.commit() tmpLog.debug('done with {0}'.format(retVal)) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # release a process lock def release_process_lock(self, process_name, locked_by): try: # get logger tmpLog = core_utils.make_logger(_logger, "proc={0} by={1}".format(process_name, locked_by), method_name='release_process_lock') tmpLog.debug('start') # delete old lock sqlC = "DELETE FROM {0} ".format(processLockTableName) sqlC += "WHERE processName=:processName AND lockedBy=:lockedBy " varMap = dict() varMap[':processName'] = process_name varMap[':lockedBy'] = locked_by self.execute(sqlC, varMap) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get file status def get_file_status(self, lfn, file_type, endpoint, job_status): try: # get logger tmpLog = core_utils.make_logger(_logger, 'lfn={0} endpoint={1}'.format(lfn, endpoint), method_name='get_file_status') tmpLog.debug('start') # sql to get files sqlF = "SELECT f.status, COUNT(*) cnt FROM {0} f, {1} j ".format(fileTableName, jobTableName) sqlF += "WHERE j.PandaID=f.PandaID AND j.status=:jobStatus " sqlF += "AND f.lfn=:lfn AND f.fileType=:type " if endpoint is not None: sqlF += "AND f.endpoint=:endpoint " sqlF += "GROUP BY f.status " # get files varMap = dict() varMap[':lfn'] = lfn varMap[':type'] = file_type varMap[':jobStatus'] = job_status if endpoint is not None: varMap[':endpoint'] = endpoint self.execute(sqlF, varMap) retMap = dict() for status, cnt in self.cur.fetchall(): retMap[status] = cnt # commit self.commit() tmpLog.debug('got {0}'.format(str(retMap))) return retMap except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # change file status def change_file_status(self, panda_id, data, locked_by): try: # get logger tmpLog = core_utils.make_logger(_logger, 'PandaID={0}'.format(panda_id), method_name='change_file_status') tmpLog.debug('start lockedBy={0}'.format(locked_by)) # sql to check lock of job sqlJ = "SELECT lockedBy FROM {0} ".format(jobTableName) sqlJ += "WHERE PandaID=:PandaID FOR UPDATE " # sql to update files sqlF = "UPDATE {0} ".format(fileTableName) sqlF += "SET status=:status WHERE fileID=:fileID " # check lock varMap = dict() varMap[':PandaID'] = panda_id self.execute(sqlJ, varMap) resJ = self.cur.fetchone() if resJ is None: tmpLog.debug('skip since job not found') else: lockedBy, = resJ if lockedBy != locked_by: tmpLog.debug('skip since lockedBy is inconsistent in DB {0}'.format(lockedBy)) else: # update files for tmpFileID, tmpLFN, newStatus in data: varMap = dict() varMap[':fileID'] = tmpFileID varMap[':status'] = newStatus self.execute(sqlF, varMap) tmpLog.debug('set new status {0} to {1}'.format(newStatus, tmpLFN)) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get group for a file def get_group_for_file(self, lfn, file_type, endpoint): try: # get logger tmpLog = core_utils.make_logger(_logger, 'lfn={0} endpoint={1}'.format(lfn, endpoint), method_name='get_group_for_file') tmpLog.debug('start') # sql to get group with the latest update sqlF = "SELECT * FROM (" sqlF += "SELECT groupID,groupStatus,groupUpdateTime FROM {0} ".format(fileTableName) sqlF += "WHERE lfn=:lfn AND fileType=:type " sqlF += "AND groupID IS NOT NULL AND groupStatus<>:ngStatus " if endpoint is not None: sqlF += "AND endpoint=:endpoint " sqlF += "ORDER BY groupUpdateTime DESC " sqlF += ") AS TMP LIMIT 1 " # get group varMap = dict() varMap[':lfn'] = lfn varMap[':type'] = file_type varMap[':ngStatus'] = 'failed' if endpoint is not None: varMap[':endpoint'] = endpoint self.execute(sqlF, varMap) resF = self.cur.fetchone() if resF is None: retVal = None else: groupID, groupStatus, groupUpdateTime = resF retVal = {'groupID': groupID, 'groupStatus': groupStatus, 'groupUpdateTime': groupUpdateTime} # commit self.commit() tmpLog.debug('got {0}'.format(str(retVal))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return None # get files with a group ID def get_files_with_group_id(self, group_id): try: # get logger tmpLog = core_utils.make_logger(_logger, 'groupID={0}'.format(group_id), method_name='get_files_with_group_id') tmpLog.debug('start') # sql to get files sqlF = "SELECT {0} FROM {1} ".format(FileSpec.column_names(), fileTableName) sqlF += "WHERE groupID=:groupID " # get files varMap = dict() varMap[':groupID'] = group_id retList = [] self.execute(sqlF, varMap) for resFile in self.cur.fetchall(): fileSpec = FileSpec() fileSpec.pack(resFile) retList.append(fileSpec) # commit self.commit() tmpLog.debug('got {0} files'.format(len(retList))) return retList except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # update group status def update_file_group_status(self, group_id, status_string): try: # get logger tmpLog = core_utils.make_logger(_logger, 'groupID={0}'.format(group_id), method_name='update_file_group_status') tmpLog.debug('start') # sql to get files sqlF = "UPDATE {0} set groupStatus=:groupStatus ".format(fileTableName) sqlF += "WHERE groupID=:groupID " # get files varMap = dict() varMap[':groupID'] = group_id varMap[':groupStatus'] = status_string self.execute(sqlF, varMap) nRow = self.cur.rowcount # commit self.commit() tmpLog.debug('updated {0} files'.format(nRow)) return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get file group status def get_file_group_status(self, group_id): try: # get logger tmpLog = core_utils.make_logger(_logger, 'groupID={0}'.format(group_id), method_name='get_file_group_status') tmpLog.debug('start') # sql to get files sqlF = "SELECT DISTINCT groupStatus FROM {0} ".format(fileTableName) sqlF += "WHERE groupID=:groupID " # get files varMap = dict() varMap[':groupID'] = group_id self.execute(sqlF, varMap) res = self.cur.fetchall() retVal = set() for groupStatus, in res: retVal.add(groupStatus) # commit self.commit() tmpLog.debug('get {0}'.format(str(retVal))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # lock job again def lock_job_again(self, panda_id, time_column, lock_column, locked_by): try: tmpLog = core_utils.make_logger(_logger, 'PandaID={0}'.format(panda_id), method_name='lock_job_again') tmpLog.debug('start column={0} id={1}'.format(lock_column, locked_by)) # check lock sqlC = "SELECT {0},{1} FROM {2} ".format(lock_column, time_column, jobTableName) sqlC += "WHERE PandaID=:pandaID " sqlC += "FOR UPDATE " varMap = dict() varMap[':pandaID'] = panda_id self.execute(sqlC, varMap) resC = self.cur.fetchone() if resC is None: retVal = False tmpLog.debug('not found') else: oldLockedBy, oldLockedTime = resC if oldLockedBy != locked_by: tmpLog.debug('locked by another {0} at {1}'.format(oldLockedBy, oldLockedTime)) retVal = False else: # update locked time sqlU = "UPDATE {0} SET {1}=:timeNow WHERE pandaID=:pandaID ".format(jobTableName, time_column) varMap = dict() varMap[':pandaID'] = panda_id varMap[':timeNow'] = datetime.datetime.utcnow() self.execute(sqlU, varMap) retVal = True # commit self.commit() tmpLog.debug('done with {0}'.format(retVal)) # return return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # set file group def set_file_group(self, file_specs, group_id, status_string): try: # get logger tmpLog = core_utils.make_logger(_logger, 'groupID={0}'.format(group_id), method_name='set_file_group') tmpLog.debug('start') timeNow = datetime.datetime.utcnow() # sql to update files sqlF = "UPDATE {0} ".format(fileTableName) sqlF += "SET groupID=:groupID,groupStatus=:groupStatus,groupUpdateTime=:groupUpdateTime " sqlF += "WHERE lfn=:lfn " # update files for fileSpec in file_specs: varMap = dict() varMap[':groupID'] = group_id varMap[':groupStatus'] = status_string varMap[':groupUpdateTime'] = timeNow varMap[':lfn'] = fileSpec.lfn self.execute(sqlF, varMap) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # refresh file group info def refresh_file_group_info(self, job_spec): try: # get logger tmpLog = core_utils.make_logger(_logger, 'pandaID={0}'.format(job_spec.PandaID), method_name='refresh_file_group_info') tmpLog.debug('start') # sql to get info sqlF = "SELECT groupID,groupStatus,groupUpdateTime FROM {0} ".format(fileTableName) sqlF += "WHERE lfn=:lfn " # get info for fileSpec in job_spec.inFiles.union(job_spec.outFiles): varMap = dict() varMap[':lfn'] = fileSpec.lfn self.execute(sqlF, varMap) resF = self.cur.fetchone() if resF is None: continue groupID, groupStatus, groupUpdateTime = resF fileSpec.groupID = groupID fileSpec.groupStatus = groupStatus fileSpec.groupUpdateTime = groupUpdateTime # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # increment submission attempt def increment_submission_attempt(self, panda_id, new_number): try: # get logger tmpLog = core_utils.make_logger(_logger, 'pandaID={0}'.format(panda_id), method_name='increment_submission_attempt') tmpLog.debug('start with newNum={0}'.format(new_number)) # sql to update attempt number sqlL = "UPDATE {0} SET submissionAttempts=:newNum ".format(jobTableName) sqlL += "WHERE PandaID=:PandaID " varMap = dict() varMap[':PandaID'] = panda_id varMap[':newNum'] = new_number self.execute(sqlL, varMap) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get queue status def get_worker_limits(self, site_name): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_worker_limits') tmpLog.debug('start') # sql to get sqlQ = "SELECT maxWorkers,nQueueLimitWorker,nQueueLimitWorkerRatio," sqlQ += "nQueueLimitWorkerMax,nQueueLimitWorkerMin FROM {0} ".format(pandaQueueTableName) sqlQ += "WHERE siteName=:siteName AND resourceType='ANY'" # sql to count resource types sqlNT = "SELECT COUNT(*) cnt FROM {0} ".format(pandaQueueTableName) sqlNT += "WHERE siteName=:siteName AND resourceType!='ANY'" # sql to count running workers sqlNR = "SELECT COUNT(*) cnt FROM {0} ".format(workTableName) sqlNR += "WHERE computingSite=:computingSite AND status IN (:status1)" # get varMap = dict() varMap[':siteName'] = site_name self.execute(sqlQ, varMap) resQ = self.cur.fetchall() # count resource types varMap = dict() varMap[':computingSite'] = site_name varMap[':siteName'] = site_name self.execute(sqlNT, varMap) resNT = self.cur.fetchall() # count running workers varMap = dict() varMap[':computingSite'] = site_name varMap[':status1'] = 'running' self.execute(sqlNR, varMap) resNR = self.cur.fetchall() # dynamic nQueueLimitWorker retMap = dict() nRunning = 0 nRT = 1 for cnt, in resNR: nRunning = cnt for cnt, in resNT: nRT = max(nRT, cnt) for maxWorkers, nQueueLimitWorker_orig, nQueueLimitWorkerRatio, \ nQueueLimitWorkerMax, nQueueLimitWorkerMin_orig in resQ: if nQueueLimitWorkerRatio is not None and nQueueLimitWorkerRatio > 0: nQueueLimitWorkerByRatio = int(nRunning * nQueueLimitWorkerRatio / 100) nQueueLimitWorkerMin = 1 if nQueueLimitWorkerMin_orig is not None: nQueueLimitWorkerMin = nQueueLimitWorkerMin_orig nQueueLimitWorkerMinAllRTs = nQueueLimitWorkerMin * nRT nQueueLimitWorker = max(nQueueLimitWorkerByRatio, nQueueLimitWorkerMinAllRTs) nQueueLimitWorkerPerRT = max(nQueueLimitWorkerByRatio, nQueueLimitWorkerMin) if nQueueLimitWorkerMax is not None: nQueueLimitWorker = min(nQueueLimitWorker, nQueueLimitWorkerMax) nQueueLimitWorkerPerRT = min(nQueueLimitWorkerPerRT, nQueueLimitWorkerMax) elif nQueueLimitWorker_orig is not None: nQueueLimitWorker = nQueueLimitWorker_orig nQueueLimitWorkerPerRT = nQueueLimitWorker else: nQueueLimitWorker = maxWorkers nQueueLimitWorkerPerRT = nQueueLimitWorker nQueueLimitWorker = min(nQueueLimitWorker, maxWorkers) retMap.update({ 'maxWorkers': maxWorkers, 'nQueueLimitWorker': nQueueLimitWorker, 'nQueueLimitWorkerPerRT': nQueueLimitWorkerPerRT, }) # commit self.commit() tmpLog.debug('got {0}'.format(str(retMap))) return retMap except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # get worker CE stats def get_worker_ce_stats(self, site_name): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_worker_ce_stats') tmpLog.debug('start') # get worker CE stats sqlW = "SELECT wt.status,wt.computingSite,wt.computingElement,COUNT(*) cnt " sqlW += "FROM {0} wt ".format(workTableName) sqlW += "WHERE wt.computingSite=:siteName AND wt.status IN (:st1,:st2) " sqlW += "GROUP BY wt.status,wt.computingElement " # get worker CE stats varMap = dict() varMap[':siteName'] = site_name varMap[':st1'] = 'running' varMap[':st2'] = 'submitted' self.execute(sqlW, varMap) resW = self.cur.fetchall() retMap = dict() for workerStatus, computingSite, computingElement, cnt in resW: if computingElement not in retMap: retMap[computingElement] = { 'running': 0, 'submitted': 0, } retMap[computingElement][workerStatus] = cnt # commit self.commit() tmpLog.debug('got {0}'.format(str(retMap))) return retMap except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # get worker CE backend throughput def get_worker_ce_backend_throughput(self, site_name, time_window): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_worker_ce_backend_throughput') tmpLog.debug('start') # get worker CE throughput sqlW = "SELECT wt.computingElement,wt.status,COUNT(*) cnt " sqlW += "FROM {0} wt ".format(workTableName) sqlW += "WHERE wt.computingSite=:siteName " sqlW += "AND wt.status IN (:st1,:st2,:st3) " sqlW += "AND wt.creationtime < :timeWindowMiddle " sqlW += "AND (wt.starttime is NULL OR " sqlW += "(wt.starttime >= :timeWindowStart AND wt.starttime < :timeWindowEnd) ) " sqlW += "GROUP BY wt.status,wt.computingElement " # time window start and end timeWindowEnd = datetime.datetime.utcnow() timeWindowStart = timeWindowEnd - datetime.timedelta(seconds=time_window) timeWindowMiddle = timeWindowEnd - datetime.timedelta(seconds=time_window/2) # get worker CE throughput varMap = dict() varMap[':siteName'] = site_name varMap[':st1'] = 'submitted' varMap[':st2'] = 'running' varMap[':st3'] = 'finished' varMap[':timeWindowStart'] = timeWindowStart varMap[':timeWindowEnd'] = timeWindowEnd varMap[':timeWindowMiddle'] = timeWindowMiddle self.execute(sqlW, varMap) resW = self.cur.fetchall() retMap = dict() for computingElement, workerStatus, cnt in resW: if computingElement not in retMap: retMap[computingElement] = { 'submitted': 0, 'running': 0, 'finished': 0, } retMap[computingElement][workerStatus] = cnt # commit self.commit() tmpLog.debug('got {0} with time_window={1} for site {2}'.format( str(retMap), time_window, site_name)) return retMap except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # add dialog message def add_dialog_message(self, message, level, module_name, identifier=None): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='add_dialog_message') tmpLog.debug('start') # delete old messages sqlS = "SELECT diagID FROM {0} ".format(diagTableName) sqlS += "WHERE creationTime<:timeLimit " varMap = dict() varMap[':timeLimit'] = datetime.datetime.utcnow() - datetime.timedelta(minutes=60) self.execute(sqlS, varMap) resS = self.cur.fetchall() sqlD = "DELETE FROM {0} ".format(diagTableName) sqlD += "WHERE diagID=:diagID " for diagID, in resS: varMap = dict() varMap[':diagID'] = diagID self.execute(sqlD, varMap) # commit self.commit() # make spec diagSpec = DiagSpec() diagSpec.moduleName = module_name diagSpec.creationTime = datetime.datetime.utcnow() diagSpec.messageLevel = level try: diagSpec.identifier = identifier[:100] except Exception: pass diagSpec.diagMessage = message[:500] # insert sqlI = "INSERT INTO {0} ({1}) ".format(diagTableName, DiagSpec.column_names()) sqlI += DiagSpec.bind_values_expression() varMap = diagSpec.values_list() self.execute(sqlI, varMap) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get dialog messages to send def get_dialog_messages_to_send(self, n_messages, lock_interval): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_dialog_messages_to_send') tmpLog.debug('start') # sql to select messages sqlD = "SELECT diagID FROM {0} ".format(diagTableName) sqlD += "WHERE (lockTime IS NULL OR lockTime<:timeLimit) " sqlD += "ORDER BY diagID LIMIT {0} ".format(n_messages) # sql to lock message sqlL = "UPDATE {0} SET lockTime=:timeNow ".format(diagTableName) sqlL += "WHERE diagID=:diagID " sqlL += "AND (lockTime IS NULL OR lockTime<:timeLimit) " # sql to get message sqlM = "SELECT {0} FROM {1} ".format(DiagSpec.column_names(), diagTableName) sqlM += "WHERE diagID=:diagID " # select messages timeLimit = datetime.datetime.utcnow() - datetime.timedelta(seconds=lock_interval) varMap = dict() varMap[':timeLimit'] = timeLimit self.execute(sqlD, varMap) resD = self.cur.fetchall() diagList = [] for diagID, in resD: # lock varMap = dict() varMap[':diagID'] = diagID varMap[':timeLimit'] = timeLimit varMap[':timeNow'] = datetime.datetime.utcnow() self.execute(sqlL, varMap) nRow = self.cur.rowcount if nRow == 1: # get varMap = dict() varMap[':diagID'] = diagID self.execute(sqlM, varMap) resM = self.cur.fetchone() # make spec diagSpec = DiagSpec() diagSpec.pack(resM) diagList.append(diagSpec) # commit self.commit() tmpLog.debug('got {0} messages'.format(len(diagList))) return diagList except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return [] # delete dialog messages def delete_dialog_messages(self, ids): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='delete_dialog_messages') tmpLog.debug('start') # sql to delete message sqlM = "DELETE FROM {0} ".format(diagTableName) sqlM += "WHERE diagID=:diagID " for diagID in ids: # lock varMap = dict() varMap[':diagID'] = diagID self.execute(sqlM, varMap) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # delete old jobs def delete_old_jobs(self, timeout): try: # get logger tmpLog = core_utils.make_logger(_logger, 'timeout={0}'.format(timeout), method_name='delete_old_jobs') tmpLog.debug('start') # sql to get old jobs to be deleted sqlGJ = "SELECT PandaID FROM {0} ".format(jobTableName) sqlGJ += "WHERE subStatus=:subStatus AND propagatorTime IS NULL " sqlGJ += "AND ((modificationTime IS NOT NULL AND modificationTime<:timeLimit1) " sqlGJ += "OR (modificationTime IS NULL AND creationTime<:timeLimit2)) " # sql to delete job sqlDJ = "DELETE FROM {0} ".format(jobTableName) sqlDJ += "WHERE PandaID=:PandaID " # sql to delete files sqlDF = "DELETE FROM {0} ".format(fileTableName) sqlDF += "WHERE PandaID=:PandaID " # sql to delete events sqlDE = "DELETE FROM {0} ".format(eventTableName) sqlDE += "WHERE PandaID=:PandaID " # sql to delete relations sqlDR = "DELETE FROM {0} ".format(jobWorkerTableName) sqlDR += "WHERE PandaID=:PandaID " # get jobs varMap = dict() varMap[':subStatus'] = 'done' varMap[':timeLimit1'] = datetime.datetime.utcnow() - datetime.timedelta(hours=timeout) varMap[':timeLimit2'] = datetime.datetime.utcnow() - datetime.timedelta(hours=timeout*2) self.execute(sqlGJ, varMap) resGJ = self.cur.fetchall() nDel = 0 for pandaID, in resGJ: varMap = dict() varMap[':PandaID'] = pandaID # delete job self.execute(sqlDJ, varMap) iDel = self.cur.rowcount if iDel > 0: nDel += iDel # delete files self.execute(sqlDF, varMap) # delete events self.execute(sqlDE, varMap) # delete relations self.execute(sqlDR, varMap) # commit self.commit() tmpLog.debug('deleted {0} jobs'.format(nDel)) return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get iterator of active workers to monitor fifo def get_active_workers(self, n_workers, seconds_ago=0): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_active_workers') tmpLog.debug('start') # sql to get workers sqlW = "SELECT {0} FROM {1} ".format(WorkSpec.column_names(), workTableName) sqlW += "WHERE status IN (:st_submitted,:st_running,:st_idle) " sqlW += "AND modificationTime<:timeLimit " sqlW += "ORDER BY modificationTime,computingSite LIMIT {0} ".format(n_workers) varMap = dict() varMap[':timeLimit'] = datetime.datetime.utcnow() - datetime.timedelta(seconds=seconds_ago) varMap[':st_submitted'] = WorkSpec.ST_submitted varMap[':st_running'] = WorkSpec.ST_running varMap[':st_idle'] = WorkSpec.ST_idle self.execute(sqlW, varMap) resW = self.cur.fetchall() def _get_workspec_from_record(rec): workspec = WorkSpec() workspec.pack(rec) workspec.pandaid_list = [] return workspec retVal = map(_get_workspec_from_record, resW) tmpLog.debug('got {0} workers'.format(len(resW))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # lock workers for specific thread def lock_workers(self, worker_id_list, lock_interval): try: timeNow = datetime.datetime.utcnow() lockTimeLimit = timeNow - datetime.timedelta(seconds=lock_interval) retVal = True # get logger tmpLog = core_utils.make_logger(_logger, method_name='lock_worker') tmpLog.debug('start') # loop for worker_id, attrs in iteritems(worker_id_list): varMap = dict() varMap[':workerID'] = worker_id varMap[':timeNow'] = timeNow varMap[':lockTimeLimit'] = lockTimeLimit varMap[':st1'] = WorkSpec.ST_cancelled varMap[':st2'] = WorkSpec.ST_finished varMap[':st3'] = WorkSpec.ST_failed varMap[':st4'] = WorkSpec.ST_missed # extract lockedBy varMap[':lockedBy'] = attrs['lockedBy'] if attrs['lockedBy'] is None: del attrs['lockedBy'] # sql to lock worker sqlL = "UPDATE {0} SET modificationTime=:timeNow".format(workTableName) for attrKey, attrVal in iteritems(attrs): sqlL += ',{0}=:{0}'.format(attrKey) varMap[':{0}'.format(attrKey)] = attrVal sqlL += " WHERE workerID=:workerID AND (lockedBy IS NULL " sqlL += "OR (modificationTime<:lockTimeLimit AND lockedBy IS NOT NULL)) " sqlL += "AND (status NOT IN (:st1,:st2,:st3,:st4)) " # lock worker self.execute(sqlL, varMap) nRow = self.cur.rowcount tmpLog.debug('done with {0}'.format(nRow)) # false if failed to lock if nRow == 0: retVal = False # commit self.commit() # return return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get queue config dumps def get_queue_config_dumps(self): try: retVal = dict() configIDs = set() # time limit timeLimit = datetime.datetime.utcnow() - datetime.timedelta(hours=24) # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_queue_config_dumps') tmpLog.debug('start') # sql to get used IDs sqlIJ = "SELECT DISTINCT configID FROM {0} ".format(jobTableName) self.execute(sqlIJ) resIJ = self.cur.fetchall() for tmpID, in resIJ: configIDs.add(tmpID) sqlIW = "SELECT DISTINCT configID FROM {0} ".format(workTableName) self.execute(sqlIW) resIW = self.cur.fetchall() for tmpID, in resIW: configIDs.add(tmpID) # sql to delete sqlD = "DELETE FROM {0} WHERE configID=:configID ".format(queueConfigDumpTableName) # sql to get config sqlQ = "SELECT {0} FROM {1} ".format(QueueConfigDumpSpec.column_names(), queueConfigDumpTableName) sqlQ += "FOR UPDATE " self.execute(sqlQ) resQs = self.cur.fetchall() iDump = 0 iDel = 0 for resQ in resQs: dumpSpec = QueueConfigDumpSpec() dumpSpec.pack(resQ) # delete if unused and too old if dumpSpec.configID not in configIDs and dumpSpec.creationTime < timeLimit: varMap = dict() varMap[':configID'] = dumpSpec.configID self.execute(sqlD, varMap) iDel += 1 else: retVal[dumpSpec.dumpUniqueName] = dumpSpec iDump += 1 # commit self.commit() tmpLog.debug('got {0} dumps and delete {1} dumps'.format(iDump, iDel)) # return return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return {} # add queue config dump def add_queue_config_dump(self, dump_spec): try: # sql to insert a job sqlJ = "INSERT INTO {0} ({1}) ".format(queueConfigDumpTableName, QueueConfigDumpSpec.column_names()) sqlJ += QueueConfigDumpSpec.bind_values_expression() # get logger tmpLog = core_utils.make_logger(_logger, method_name='add_queue_config_dumps') tmpLog.debug('start for {0}'.format(dump_spec.dumpUniqueName)) varMap = dump_spec.values_list() # insert self.execute(sqlJ, varMap) # commit self.commit() tmpLog.debug('done') # return return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return False # get configID for queue config dump def get_config_id_dump(self, dump_spec): try: # sql to get configID sqlJ = "SELECT configID FROM {0} ".format(queueConfigDumpTableName) sqlJ += "WHERE queueName=:queueName AND dumpUniqueName=:dumpUniqueName " # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_config_id_for_dump') tmpLog.debug('start for {0}:{1}'.format(dump_spec.queueName, dump_spec.dumpUniqueName)) # get varMap = dict() varMap[':queueName'] = dump_spec.queueName varMap[':dumpUniqueName'] = dump_spec.dumpUniqueName self.execute(sqlJ, varMap) resJ = self.cur.fetchone() if resJ is not None: configID, = resJ else: configID = None tmpLog.debug('got configID={0}'.format(configID)) # return return configID except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return None # purge a panda queue def purge_pq(self, queue_name): try: # get logger tmpLog = core_utils.make_logger(_logger, 'queueName={0}'.format(queue_name), method_name='purge_pq') tmpLog.debug('start') # sql to get jobs sqlJ = "SELECT PandaID FROM {0} ".format(jobTableName) sqlJ += "WHERE computingSite=:computingSite " # sql to get workers sqlW = "SELECT workerID FROM {0} ".format(workTableName) sqlW += "WHERE computingSite=:computingSite " # sql to get queue configs sqlQ = "SELECT configID FROM {0} ".format(queueConfigDumpTableName) sqlQ += "WHERE queueName=:queueName " # sql to delete job sqlDJ = "DELETE FROM {0} ".format(jobTableName) sqlDJ += "WHERE PandaID=:PandaID " # sql to delete files sqlDF = "DELETE FROM {0} ".format(fileTableName) sqlDF += "WHERE PandaID=:PandaID " # sql to delete events sqlDE = "DELETE FROM {0} ".format(eventTableName) sqlDE += "WHERE PandaID=:PandaID " # sql to delete relations by job sqlDRJ = "DELETE FROM {0} ".format(jobWorkerTableName) sqlDRJ += "WHERE PandaID=:PandaID " # sql to delete worker sqlDW = "DELETE FROM {0} ".format(workTableName) sqlDW += "WHERE workerID=:workerID " # sql to delete relations by worker sqlDRW = "DELETE FROM {0} ".format(jobWorkerTableName) sqlDRW += "WHERE workerID=:workerID " # sql to delete queue config sqlDQ = "DELETE FROM {0} ".format(queueConfigDumpTableName) sqlDQ += "WHERE configID=:configID " # sql to delete panda queue sqlDP = "DELETE FROM {0} ".format(pandaQueueTableName) sqlDP += "WHERE queueName=:queueName " # get jobs varMap = dict() varMap[':computingSite'] = queue_name self.execute(sqlJ, varMap) resJ = self.cur.fetchall() for pandaID, in resJ: varMap = dict() varMap[':PandaID'] = pandaID # delete job self.execute(sqlDJ, varMap) # delete files self.execute(sqlDF, varMap) # delete events self.execute(sqlDE, varMap) # delete relations self.execute(sqlDRJ, varMap) # get workers varMap = dict() varMap[':computingSite'] = queue_name self.execute(sqlW, varMap) resW = self.cur.fetchall() for workerID, in resW: varMap = dict() varMap[':workerID'] = workerID # delete workers self.execute(sqlDW, varMap) # delete relations self.execute(sqlDRW, varMap) # get queue configs varMap = dict() varMap[':queueName'] = queue_name self.execute(sqlQ, varMap) resQ = self.cur.fetchall() for configID, in resQ: varMap = dict() varMap[':configID'] = configID # delete queue configs self.execute(sqlDQ, varMap) # delete panda queue varMap = dict() varMap[':queueName'] = queue_name self.execute(sqlDP, varMap) # commit self.commit() tmpLog.debug('done') return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # disable multi workers def disable_multi_workers(self, panda_id): tmpLog = None try: # get logger tmpLog = core_utils.make_logger(_logger, 'PandaID={0}'.format(panda_id), method_name='disable_multi_workers') tmpLog.debug('start') # sql to update flag sqlJ = "UPDATE {0} SET moreWorkers=0 ".format(jobTableName) sqlJ += "WHERE PandaID=:pandaID AND nWorkers IS NOT NULL AND nWorkersLimit IS NOT NULL " sqlJ += "AND nWorkers>0 " # set flag varMap = dict() varMap[':pandaID'] = panda_id self.execute(sqlJ, varMap) nRow = self.cur.rowcount # commit self.commit() tmpLog.debug('done with {0}'.format(nRow)) # return return nRow except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return None # update PQ table def update_panda_queue_attribute(self, key, value, site_name=None, queue_name=None): tmpLog = None try: # get logger tmpLog = core_utils.make_logger(_logger, 'site={0} queue={1}'.format(site_name, queue_name), method_name='update_panda_queue') tmpLog.debug('start key={0}'.format(key)) # sql to update sqlJ = "UPDATE {0} SET {1}=:{1} ".format(pandaQueueTableName, key) sqlJ += "WHERE " varMap = dict() varMap[':{0}'.format(key)] = value if site_name is not None: sqlJ += "siteName=:siteName " varMap[':siteName'] = site_name else: sqlJ += "queueName=:queueName " varMap[':queueName'] = queue_name # update self.execute(sqlJ, varMap) nRow = self.cur.rowcount # commit self.commit() tmpLog.debug('done with {0}'.format(nRow)) # return return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return False # delete orphaned job info def delete_orphaned_job_info(self): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='delete_orphaned_job_info') tmpLog.debug('start') # sql to get job info to be deleted sqlGJ = "SELECT PandaID FROM {0} " sqlGJ += "WHERE PandaID NOT IN (" sqlGJ += "SELECT PandaID FROM {1}) " # sql to delete job info sqlDJ = "DELETE FROM {0} " sqlDJ += "WHERE PandaID=:PandaID " # sql to delete files sqlDF = "DELETE FROM {0} ".format(fileTableName) sqlDF += "WHERE PandaID=:PandaID " # sql to delete events sqlDE = "DELETE FROM {0} ".format(eventTableName) sqlDE += "WHERE PandaID=:PandaID " # sql to delete relations sqlDR = "DELETE FROM {0} ".format(jobWorkerTableName) sqlDR += "WHERE PandaID=:PandaID " # loop over all tables for tableName in [fileTableName, eventTableName, jobWorkerTableName]: # get job info self.execute(sqlGJ.format(tableName, jobTableName)) resGJ = self.cur.fetchall() nDel = 0 for pandaID, in resGJ: # delete varMap = dict() varMap[':PandaID'] = pandaID self.execute(sqlDJ.format(tableName), varMap) iDel = self.cur.rowcount if iDel > 0: nDel += iDel # commit self.commit() tmpLog.debug('deleted {0} records from {1}'.format(nDel, tableName)) return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # lock worker again to feed events def lock_worker_again_to_feed_events(self, worker_id, locked_by): try: tmpLog = core_utils.make_logger(_logger, 'workerID={0}'.format(worker_id), method_name='lock_worker_again_to_feed_events') tmpLog.debug('start id={0}'.format(locked_by)) # check lock sqlC = "SELECT eventFeedLock,eventFeedTime FROM {0} ".format(workTableName) sqlC += "WHERE workerID=:workerID " sqlC += "FOR UPDATE " varMap = dict() varMap[':workerID'] = worker_id self.execute(sqlC, varMap) resC = self.cur.fetchone() if resC is None: retVal = False tmpLog.debug('not found') else: oldLockedBy, oldLockedTime = resC if oldLockedBy != locked_by: tmpLog.debug('locked by another {0} at {1}'.format(oldLockedBy, oldLockedTime)) retVal = False else: # update locked time sqlU = "UPDATE {0} SET eventFeedTime=:timeNow WHERE workerID=:workerID ".format(workTableName) varMap = dict() varMap[':workerID'] = worker_id varMap[':timeNow'] = datetime.datetime.utcnow() self.execute(sqlU, varMap) retVal = True # commit self.commit() tmpLog.debug('done with {0}'.format(retVal)) # return return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # insert service metrics def insert_service_metrics(self, service_metric_spec): # get logger tmpLog = core_utils.make_logger(_logger, method_name='insert_service_metrics') tmpLog.debug('start') try: sql = "INSERT INTO {0} ({1}) ".format(serviceMetricsTableName, ServiceMetricSpec.column_names()) sql += ServiceMetricSpec.bind_values_expression() var_map = service_metric_spec.values_list() self.execute(sql, var_map) self.commit() return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(tmpLog) # return return False # get service metrics def get_service_metrics(self, last_update): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_service_metrics') tmpLog.debug('start with last_update: {0}'.format(last_update)) sql = "SELECT creationTime, hostName, metrics FROM {0} ".format(serviceMetricsTableName) sql += "WHERE creationTime>=:last_update " var_map = {':last_update': last_update} self.execute(sql, var_map) res = self.cur.fetchall() # change datetime objects to strings for json serialization later res_corrected = [] for entry in res: try: res_corrected.append([entry[0].strftime('%Y-%m-%d %H:%M:%S.%f'), entry[1], entry[2]]) except Exception: pass # commit self.commit() tmpLog.debug('got {0}'.format(str(res))) return res_corrected except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} # release a site def release_site(self, site_name, locked_by): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='release_site') tmpLog.debug('start') # sql to release site sql = "UPDATE {0} SET lockedBy=NULL ".format(pandaQueueTableName) sql += "WHERE siteName=:siteName AND lockedBy=:lockedBy " # release site varMap = dict() varMap[':siteName'] = site_name varMap[':lockedBy'] = locked_by self.execute(sql, varMap) n_done = self.cur.rowcount > 0 # commit self.commit() if n_done >= 1: tmpLog.debug('released {0}'.format(site_name)) else: tmpLog.debug('found nothing to release. Skipped'.format(site_name)) # return return True except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return False # get workers via workerID def get_workers_from_ids(self, ids): try: # get logger tmpLog = core_utils.make_logger(_logger, method_name='get_workers_from_ids') tmpLog.debug('start') # sql to get workers sqlW = ( "SELECT workerID,configID,mapType FROM {workTableName} " "WHERE workerID IN ({ids_str}) " "AND status IN (:st_submitted,:st_running,:st_idle) " ).format(workTableName=workTableName, ids_str=','.join([ str(_) for _ in ids])) # sql to get associated workerIDs sqlA = ( "SELECT t.workerID FROM {jobWorkerTableName} t, {jobWorkerTableName} s, {workTableName} w " "WHERE s.PandaID=t.PandaID AND s.workerID=:workerID " "AND w.workerID=t.workerID AND w.status IN (:st_submitted,:st_running,:st_idle) " ).format(jobWorkerTableName=jobWorkerTableName, workTableName=workTableName) # sql to get associated workers sqlG = ( "SELECT {0} FROM {1} " "WHERE workerID=:workerID " ).format(WorkSpec.column_names(), workTableName) # sql to get associated PandaIDs sqlP = ( "SELECT PandaID FROM {0} " "WHERE workerID=:workerID " ).format(jobWorkerTableName) # get workerIDs timeNow = datetime.datetime.utcnow() varMap = dict() varMap[':st_submitted'] = WorkSpec.ST_submitted varMap[':st_running'] = WorkSpec.ST_running varMap[':st_idle'] = WorkSpec.ST_idle self.execute(sqlW, varMap) resW = self.cur.fetchall() tmpWorkers = set() for workerID, configID, mapType in resW: # ignore configID if not core_utils.dynamic_plugin_change(): configID = None tmpWorkers.add((workerID, configID, mapType)) checkedIDs = set() retVal = {} for workerID, configID, mapType in tmpWorkers: # skip if workerID in checkedIDs: continue # get associated workerIDs varMap = dict() varMap[':workerID'] = workerID varMap[':st_submitted'] = WorkSpec.ST_submitted varMap[':st_running'] = WorkSpec.ST_running varMap[':st_idle'] = WorkSpec.ST_idle self.execute(sqlA, varMap) resA = self.cur.fetchall() workerIDtoScan = set() for tmpWorkID, in resA: workerIDtoScan.add(tmpWorkID) # add original ID just in case since no relation when job is not yet bound workerIDtoScan.add(workerID) # use only the largest worker to avoid updating the same worker set concurrently if mapType == WorkSpec.MT_MultiWorkers: if workerID != min(workerIDtoScan): continue # get workers queueName = None workersList = [] for tmpWorkID in workerIDtoScan: checkedIDs.add(tmpWorkID) # get worker varMap = dict() varMap[':workerID'] = tmpWorkID self.execute(sqlG, varMap) resG = self.cur.fetchone() workSpec = WorkSpec() workSpec.pack(resG) if queueName is None: queueName = workSpec.computingSite workersList.append(workSpec) # get associated PandaIDs varMap = dict() varMap[':workerID'] = tmpWorkID self.execute(sqlP, varMap) resP = self.cur.fetchall() workSpec.pandaid_list = [] for tmpPandaID, in resP: workSpec.pandaid_list.append(tmpPandaID) if len(workSpec.pandaid_list) > 0: workSpec.nJobs = len(workSpec.pandaid_list) # commit self.commit() # add if queueName is not None: retVal.setdefault(queueName, dict()) retVal[queueName].setdefault(configID, []) retVal[queueName][configID].append(workersList) tmpLog.debug('got {0}'.format(str(retVal))) return retVal except Exception: # roll back self.rollback() # dump error core_utils.dump_error_message(_logger) # return return {} from django.test import TestCase from django.core.exceptions import ValidationError from django.contrib.flatpages.models import FlatPage from oscar.core.validators import ExtendedURLValidator from oscar.core.validators import URLDoesNotExistValidator class TestExtendedURLValidatorWithVerifications(TestCase): """ ExtendedURLValidator with verify_exists=True """ def setUp(self): self.validator = ExtendedURLValidator(verify_exists=True) def test_validates_local_url(self): try: self.validator('/') except ValidationError: self.fail('ExtendedURLValidator raised ValidationError' 'unexpectedly!') def test_validates_local_url_with_query_strings(self): try: self.validator('/?q=test') # Query strings shouldn't affect validation except ValidationError: self.fail('ExtendedURLValidator raised ValidationError' 'unexpectedly!') def test_raises_validation_error_for_missing_urls(self): with self.assertRaises(ValidationError): self.validator('/invalid/') def test_validates_urls_missing_preceding_slash(self): try: self.validator('catalogue/') except ValidationError: self.fail('ExtendedURLValidator raised ValidationError' 'unexpectedly!') def test_raises_validation_error_for_urls_without_trailing_slash(self): with self.assertRaises(ValidationError): self.validator('/catalogue') # Missing the / is bad def test_validates_flatpages_urls(self): FlatPage.objects.create(title='test page', url='/test/page/') try: self.validator('/test/page/') except ValidationError: self.fail('ExtendedURLValidator raises ValidationError' 'unexpectedly!') class TestExtendedURLValidatorWithoutVerifyExists(TestCase): """ ExtendedURLValidator with verify_exists=False """ def setUp(self): self.validator = URLDoesNotExistValidator() def test_raises_exception_for_local_urls(self): self.assertRaises(ValidationError, self.validator, '/') def test_raises_exception_for_flatpages(self): FlatPage.objects.create(title='test page', url='/test/page/') self.assertRaises(ValidationError, self.validator, '/test/page/') # -*- coding:utf-8 -*- """ 宏观经济数据接口 Created on 2015/01/24 @author: Jimmy Liu @group : waditu @contact: jimmysoa@sina.cn """ import pandas as pd import numpy as np import re import json from tushare.stock import macro_vars as vs from tushare.stock import cons as ct try: from urllib.request import urlopen, Request except ImportError: from urllib2 import urlopen, Request def get_gdp_year(): """ 获取年度国内生产总值数据 Return -------- DataFrame year :统计年度 gdp :国内生产总值(亿元) pc_gdp :人均国内生产总值(元) gnp :国民生产总值(亿元) pi :第一产业(亿元) si :第二产业(亿元) industry :工业(亿元) cons_industry :建筑业(亿元) ti :第三产业(亿元) trans_industry :交通运输仓储邮电通信业(亿元) lbdy :批发零售贸易及餐饮业(亿元) """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[0], 0, 70, rdint)) text = urlopen(request, timeout=10).read() text = text.decode('gbk') if ct.PY3 else text regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] datastr = datastr.replace('"', '').replace('null', '0') js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.GDP_YEAR_COLS) df[df==0] = np.NaN return df def get_gdp_quarter(): """ 获取季度国内生产总值数据 Return -------- DataFrame quarter :季度 gdp :国内生产总值(亿元) gdp_yoy :国内生产总值同比增长(%) pi :第一产业增加值(亿元) pi_yoy:第一产业增加值同比增长(%) si :第二产业增加值(亿元) si_yoy :第二产业增加值同比增长(%) ti :第三产业增加值(亿元) ti_yoy :第三产业增加值同比增长(%) """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[0], 1, 250, rdint)) text = urlopen(request,timeout=10).read() text = text.decode('gbk') if ct.PY3 else text regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] datastr = datastr.replace('"', '').replace('null', '0') js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.GDP_QUARTER_COLS) df['quarter'] = df['quarter'].astype(object) df[df==0] = np.NaN return df def get_gdp_for(): """ 获取三大需求对GDP贡献数据 Return -------- DataFrame year :统计年度 end_for :最终消费支出贡献率(%) for_rate :最终消费支出拉动(百分点) asset_for :资本形成总额贡献率(%) asset_rate:资本形成总额拉动(百分点) goods_for :货物和服务净出口贡献率(%) goods_rate :货物和服务净出口拉动(百分点) """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[0], 4, 80, rdint)) text = urlopen(request,timeout=10).read() text = text.decode('gbk') if ct.PY3 else text regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] datastr = datastr.replace('"','').replace('null','0') js = json.loads(datastr) df = pd.DataFrame(js,columns=vs.GDP_FOR_COLS) df[df==0] = np.NaN return df def get_gdp_pull(): """ 获取三大产业对GDP拉动数据 Return -------- DataFrame year :统计年度 gdp_yoy :国内生产总值同比增长(%) pi :第一产业拉动率(%) si :第二产业拉动率(%) industry:其中工业拉动(%) ti :第三产业拉动率(%) """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[0], 5, 60, rdint)) text = urlopen(request,timeout=10).read() text = text.decode('gbk') if ct.PY3 else text regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] datastr = datastr.replace('"', '').replace('null', '0') js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.GDP_PULL_COLS) df[df==0] = np.NaN return df def get_gdp_contrib(): """ 获取三大产业贡献率数据 Return -------- DataFrame year :统计年度 gdp_yoy :国内生产总值 pi :第一产业献率(%) si :第二产业献率(%) industry:其中工业献率(%) ti :第三产业献率(%) """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[0], 6, 60, rdint)) text = urlopen(request, timeout=10).read() text = text.decode('gbk') if ct.PY3 else text regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] datastr = datastr.replace('"', '').replace('null', '0') js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.GDP_CONTRIB_COLS) df[df==0] = np.NaN return df def get_cpi(): """ 获取居民消费价格指数数据 Return -------- DataFrame month :统计月份 cpi :价格指数 """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[1], 0, 600, rdint)) text = urlopen(request,timeout=10).read() text = text.decode('gbk') if ct.PY3 else text regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.CPI_COLS) df['cpi'] = df['cpi'].astype(float) return df def get_ppi(): """ 获取工业品出厂价格指数数据 Return -------- DataFrame month :统计月份 ppiip :工业品出厂价格指数 ppi :生产资料价格指数 qm:采掘工业价格指数 rmi:原材料工业价格指数 pi:加工工业价格指数 cg:生活资料价格指数 food:食品类价格指数 clothing:衣着类价格指数 roeu:一般日用品价格指数 dcg:耐用消费品价格指数 """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[1], 3, 600, rdint)) text = urlopen(request, timeout=10).read() text = text.decode('gbk') if ct.PY3 else text regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.PPI_COLS) for i in df.columns: df[i] = df[i].apply(lambda x:np.where(x is None, np.NaN, x)) if i != 'month': df[i] = df[i].astype(float) return df def get_deposit_rate(): """ 获取存款利率数据 Return -------- DataFrame date :变动日期 deposit_type :存款种类 rate:利率（%） """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[2], 2, 600, rdint)) text = urlopen(request, timeout=10).read() text = text.decode('gbk') regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.DEPOSIT_COLS) for i in df.columns: df[i] = df[i].apply(lambda x:np.where(x is None, '--', x)) return df def get_loan_rate(): """ 获取贷款利率数据 Return -------- DataFrame date :执行日期 loan_type :存款种类 rate:利率（%） """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[2], 3, 800, rdint)) text = urlopen(request, timeout=10).read() text = text.decode('gbk') regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.LOAN_COLS) for i in df.columns: df[i] = df[i].apply(lambda x:np.where(x is None, '--', x)) return df def get_rrr(): """ 获取存款准备金率数据 Return -------- DataFrame date :变动日期 before :调整前存款准备金率(%) now:调整后存款准备金率(%) changed:调整幅度(%) """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[2], 4, 100, rdint)) text = urlopen(request, timeout=10).read() text = text.decode('gbk') regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.RRR_COLS) for i in df.columns: df[i] = df[i].apply(lambda x:np.where(x is None, '--', x)) return df def get_money_supply(): """ 获取货币供应量数据 Return -------- DataFrame month :统计时间 m2 :货币和准货币（广义货币M2）(亿元) m2_yoy:货币和准货币（广义货币M2）同比增长(%) m1:货币(狭义货币M1)(亿元) m1_yoy:货币(狭义货币M1)同比增长(%) m0:流通中现金(M0)(亿元) m0_yoy:流通中现金(M0)同比增长(%) cd:活期存款(亿元) cd_yoy:活期存款同比增长(%) qm:准货币(亿元) qm_yoy:准货币同比增长(%) ftd:定期存款(亿元) ftd_yoy:定期存款同比增长(%) sd:储蓄存款(亿元) sd_yoy:储蓄存款同比增长(%) rests:其他存款(亿元) rests_yoy:其他存款同比增长(%) """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[2], 1, 600, rdint)) text = urlopen(request, timeout=10).read() text = text.decode('gbk') regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.MONEY_SUPPLY_COLS) for i in df.columns: df[i] = df[i].apply(lambda x:np.where(x is None, '--', x)) return df def get_money_supply_bal(): """ 获取货币供应量(年底余额)数据 Return -------- DataFrame year :统计年度 m2 :货币和准货币(亿元) m1:货币(亿元) m0:流通中现金(亿元) cd:活期存款(亿元) qm:准货币(亿元) ftd:定期存款(亿元) sd:储蓄存款(亿元) rests:其他存款(亿元) """ rdint = vs.random() request = Request(vs.MACRO_URL%(vs.P_TYPE['http'], vs.DOMAINS['sina'], rdint, vs.MACRO_TYPE[2], 0, 200, rdint)) text = urlopen(request,timeout=10).read() text = text.decode('gbk') regSym = re.compile(r'\,count:(.*?)\}') datastr = regSym.findall(text) datastr = datastr[0] datastr = datastr.split('data:')[1] js = json.loads(datastr) df = pd.DataFrame(js, columns=vs.MONEY_SUPPLY_BLA_COLS) for i in df.columns: df[i] = df[i].apply(lambda x:np.where(x is None, '--', x)) return df import datetime from decimal import Decimal import types import six def is_protected_type(obj): """Determine if the object instance is of a protected type. Objects of protected types are preserved as-is when passed to force_unicode(strings_only=True). """ return isinstance(obj, ( six.integer_types + (types.NoneType, datetime.datetime, datetime.date, datetime.time, float, Decimal)) ) def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'): """ Similar to smart_text, except that lazy instances are resolved to strings, rather than kept as lazy objects. If strings_only is True, don't convert (some) non-string-like objects. """ # Handle the common case first, saves 30-40% when s is an instance of # six.text_type. This function gets called often in that setting. if isinstance(s, six.text_type): return s if strings_only and is_protected_type(s): return s try: if not isinstance(s, six.string_types): if hasattr(s, '__unicode__'): s = s.__unicode__() else: if six.PY3: if isinstance(s, bytes): s = six.text_type(s, encoding, errors) else: s = six.text_type(s) else: s = six.text_type(bytes(s), encoding, errors) else: # Note: We use .decode() here, instead of six.text_type(s, # encoding, errors), so that if s is a SafeBytes, it ends up being # a SafeText at the end. s = s.decode(encoding, errors) except UnicodeDecodeError as e: if not isinstance(s, Exception): raise UnicodeDecodeError(*e.args) else: # If we get to here, the caller has passed in an Exception # subclass populated with non-ASCII bytestring data without a # working unicode method. Try to handle this without raising a # further exception by individually forcing the exception args # to unicode. s = ' '.join([force_unicode(arg, encoding, strings_only, errors) for arg in s]) return s ############################################################################## # Copyright (c) 2013-2018, Lawrence Livermore National Security, LLC. # Produced at the Lawrence Livermore National Laboratory. # # This file is part of Spack. # Created by Todd Gamblin, tgamblin@llnl.gov, All rights reserved. # LLNL-CODE-647188 # # For details, see https://github.com/spack/spack # Please also see the NOTICE and LICENSE files for our notice and the LGPL. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License (as # published by the Free Software Foundation) version 2.1, February 1999. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and # conditions of the GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ############################################################################## from spack import * class PyConfigparser(PythonPackage): """This library brings the updated configparser from Python 3.5 to Python 2.6-3.5.""" homepage = "https://docs.python.org/3/library/configparser.html" url = "https://pypi.io/packages/source/c/configparser/configparser-3.5.0.tar.gz" version('3.5.0', 'cfdd915a5b7a6c09917a64a573140538') depends_on('py-setuptools', type='build') # This dependency breaks concretization # See https://github.com/spack/spack/issues/2793 # depends_on('py-ordereddict', when='^python@:2.6', type=('build', 'run')) ### # Copyright (c) 2005, Jeremiah Fincher # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions, and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright notice, # this list of conditions, and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the author of this software nor the name of # contributors to this software may be used to endorse or promote products # derived from this software without specific prior written consent. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. ### from supybot.test import * class AutoModeTestCase(PluginTestCase): plugins = ('AutoMode',) # vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79: # -*- coding: utf-8 -*- """ Created on Tue Dec 2 22:08:22 2014 @author: remi """ #trying to order points by octree with python from numpy import random, sqrt from sklearn import preprocessing import matplotlib.pyplot as plt #defining a dummy entry :a random 3D pointcloud pointcloud = random.rand(16*16,2); index = np.arange(1,16*16+1) #parameters tot_level = 3 ; #centering data so that leftmost pint is 0 abs, bottom most point is 0 pointcloud[:,0] = pointcloud[:,0]- np.amin(pointcloud[:,0]); pointcloud[:,1] = pointcloud[:,1]- np.amin(pointcloud[:,1]); #finding the max scaling, in X, Y or Z max_r = max(np.amax(pointcloud[:,0])-np.amin(pointcloud[:,0]), np.amax(pointcloud[:,1])-np.amin(pointcloud[:,1])) #dividing so max scale is 0 . Now the point cloud is between 0,1 and 0,1 pointcloud = pointcloud/ max_r ; #we have to trick a litlle, so has that for level 3 for instance, all value are between 0 and 7 included, but not reaching 8. pointcloud_int = np.trunc(abs((pointcloud*pow(2,tot_level)-0.0001))).astype(int) plt.plot(pointcloud[:,0],pointcloud[:,1], 'ro') ; plt.plot(pointcloud_int[:,0],pointcloud_int[:,1], 'ro') ; plt.axis([-1, 8, -1, 8]) ; plt.show() ; plt.close('all'); result_point = pointcloud_int[rec_ar[:,0]] plt.plot(result_point[:,0],result_point[:,1], 'ro') ; rec_ar = np.array(rec) piv_ar = np.array(piv) plt.plot(piv_ar[:,0], piv_ar[:,1], 'ro') ; np.binary_repr(1) def bin(s): return str(s) if s<=1 else bin(s>>1) + str(s&1) def testBit(int_type, offset): mask = 1 << offset return( (int_type & mask)>0 ) testBit(8,1) pointcloud_bin = np.binary_repr(pointcloud_int) pointcloud_int >> (tot_level-1) ; #np.binary_repr(8) ( ((pointcloud_int >> 1 ) << 1) ) >> (tot_level-1) ; testBit(pointcloud_int[:,1],3) #cut the input point cloud into 8 based on l bit value starting form right to left point_cloud_0_0_mask = np.logical_and((testBit(pointcloud_int[:,0],2)==0) , (testBit(pointcloud_int[:,1],2)==0) ) ; pivot = np.array([pow(2,tot_level-1),pow(2,tot_level-1)]) pointcloud_centered = pointcloud_int - pivot #coordinate to work : toto = np.array([1,2,3]) testBit(toto,1) (pointcloud_int >>1 )>>5 pow(2,4) 1<<4 # # level 0 result = list() ; pointcloud_int ; index pivot cur_lev = 0 rec = []; #find the 0 level point min_point = np.argmin(np.sum(np.abs(pointcloud_int - pivot ),axis=1)) result.append(list((index[min_point],cur_lev))) #compute the 4 sub parts for b_x in list((0,1)) : for b_y in list((0,1)) : #looping on all 4 sub parts print b_x, b_y rec.append (np.logical_and( (testBit(pointcloud_int[:,0],2)>0)==b_x ,(testBit(pointcloud_int[:,1],2)>0)==b_y ) ) testBit(pointcloud_int[:,0],2) print (testBit(pointcloud_int[:,0],2)>0==b_x) ; print (testBit(pointcloud_int[:,1],2)>0==b_y) ; rec[b_x,b_y] = np.logical_and((testBit(pointcloud_int[:,0],2)>0==b_x) ,(testBit(pointcloud_int[:,1],2)>0==b_y) ) print rec np.binary_repr(pointcloud_int[:,0] ) #givne a point cloud #compute the closest to center def recursive_octree_ordering(point_array,index_array, center_point, level,tot_level, result,piv): #importing necessary lib import numpy as np; #print for debug # print '\n\n working on level : '+str(level); # print 'input points: \n\t',point_array ; # print 'index_array : \n\t',index_array; # print 'center_point : \n\t',center_point; # print 'level : \n\t',level; # print 'tot_level : \n\t',tot_level; # print 'result : \n\t',result; #stopping condition : no points: if len(point_array) == 0|level<=2: return; #updatig level; sub_part_level = level+1 ; print 'level ',level,' , points remaining : ',len(point_array) ; print center_point; piv.append(center_point); #find the closest point to pivot min_point = np.argmin(np.sum(np.abs(point_array - center_point ),axis=1)) result.append(list((index_array[min_point],level))) ; #removing the found point from the array of points #np.delete(point_array, min_point, axis=0) ; #np.delete(index_array, min_point, axis=0) ; #stopping if it remains only one pioint : we won't divide further, same if we have reached max depth if (len(point_array) ==1 )|(level >= tot_level): return; #compute the 4 sub parts for b_x in list((0,1)) : for b_y in list((0,1)) : #looping on all 4 sub parts print (b_x*2-1), (b_y*2-1) ; udpate_to_pivot = np.asarray([ (b_x*2-1)*(pow(2,tot_level - level -2 )) ,(b_y*2-1)*(pow(2,tot_level - level -2 )) ]); sub_part_center_point = center_point +udpate_to_pivot; # we want to iterateon # we need to update : : point_array , index_array center_point , level #update point_array and index_array : we need to find the points that are in the subparts #update center point, we need to add/substract to previous pivot 2^level+11 #find the points concerned : point_in_subpart_mask = np.logical_and( testBit(point_array[:,0],tot_level - level-1) ==b_x , testBit(point_array[:,1],tot_level - level -1) ==b_y ) ; sub_part_points= point_array[point_in_subpart_mask]; sub_part_index = index_array[point_in_subpart_mask]; sub_part_center_point = center_point + np.asarray([ (b_x*2-1)*(pow(2,tot_level - level -2 )) ,(b_y*2-1)*(pow(2,tot_level - level -2 )) ]); if len(sub_part_points)>=1: recursive_octree_ordering(sub_part_points ,sub_part_index , sub_part_center_point , sub_part_level , tot_level , result , piv); continue; else: print 'at televel ',level,'bx by:',b_x,' ',b_y,' refusing to go one, ', len(sub_part_points), ' points remaining fo this' continue; rec = [] ; piv = [] ; recursive_octree_ordering(pointcloud_int,index,pivot,0,3,rec, piv ); #recursive_octree_ordering(pointcloud_int,index, np.array([2,2]),1,3,rec, piv ); piv_ar = np.array(piv) plt.plot(piv_ar[:,0], piv_ar[:,1], 'ro') ; plot(x=pointcloud_int[:,0].T,y=pointcloud_int[:,1].T, marker='o', color='r', ls='' ) plt.plot(pointcloud_int.T, marker='o', color='r', ls='') plt.imsave('/') from mpl_toolkits.mplot3d import Axes3D plt.scatter(pointcloud[:,0], pointcloud[:,1],c='red'); plt.scatter(pointcloud_int[:,0], pointcloud_int[:,1],c='green'); plt.plot(pointcloud[:,0],pointcloud[:,1], 'ro') plt.plot(pointcloud_int[:,0],pointcloud_int[:,1], 'ro') plt.axis([-1, 8, -1, 8]) plt.show(); fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(pointcloud_int[:,0], pointcloud_int[:,1]); ax.scatter(pointcloud_int[:,0], pointcloud_int[:,1], pointcloud_int[:,0], zdir='z', c= 'red') fig.show() fig, axes = plt.subplots(1, 2, figsize=(12,3)) axes[0].scatter(pointcloud[:,0], pointcloud[:,1],c='red'); axes[1].scatter(pointcloud_int[:,0], pointcloud_int[:,1],c='green'); fig.show(); for f in list((0,1)): (f*2-1) import octree_ordering # -*- encoding: utf-8 -*- ############################################################################## # # OpenERP, Open Source Management Solution # Copyright (C) 2011 Numérigraphe SARL. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see . # ############################################################################## import bank # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: # -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. import datetime import logging import requests import werkzeug.urls from ast import literal_eval from odoo import api, release, SUPERUSER_ID from odoo.exceptions import UserError from odoo.models import AbstractModel from odoo.tools.translate import _ from odoo.tools import config, misc, ustr _logger = logging.getLogger(__name__) class PublisherWarrantyContract(AbstractModel): _name = "publisher_warranty.contract" @api.model def _get_message(self): Users = self.env['res.users'] IrParamSudo = self.env['ir.config_parameter'].sudo() dbuuid = IrParamSudo.get_param('database.uuid') db_create_date = IrParamSudo.get_param('database.create_date') limit_date = datetime.datetime.now() limit_date = limit_date - datetime.timedelta(15) limit_date_str = limit_date.strftime(misc.DEFAULT_SERVER_DATETIME_FORMAT) nbr_users = Users.search_count([('active', '=', True)]) nbr_active_users = Users.search_count([("login_date", ">=", limit_date_str), ('active', '=', True)]) nbr_share_users = 0 nbr_active_share_users = 0 if "share" in Users._fields: nbr_share_users = Users.search_count([("share", "=", True), ('active', '=', True)]) nbr_active_share_users = Users.search_count([("share", "=", True), ("login_date", ">=", limit_date_str), ('active', '=', True)]) user = self.env.user domain = [('application', '=', True), ('state', 'in', ['installed', 'to upgrade', 'to remove'])] apps = self.env['ir.module.module'].sudo().search_read(domain, ['name']) enterprise_code = IrParamSudo.get_param('database.enterprise_code') web_base_url = IrParamSudo.get_param('web.base.url') msg = { "dbuuid": dbuuid, "nbr_users": nbr_users, "nbr_active_users": nbr_active_users, "nbr_share_users": nbr_share_users, "nbr_active_share_users": nbr_active_share_users, "dbname": self._cr.dbname, "db_create_date": db_create_date, "version": release.version, "language": user.lang, "web_base_url": web_base_url, "apps": [app['name'] for app in apps], "enterprise_code": enterprise_code, } if user.partner_id.company_id: company_id = user.partner_id.company_id msg.update(company_id.read(["name", "email", "phone"])[0]) return msg @api.model def _get_sys_logs(self): """ Utility method to send a publisher warranty get logs messages. """ msg = self._get_message() arguments = {'arg0': ustr(msg), "action": "update"} url = config.get("publisher_warranty_url") r = requests.post(url, data=arguments, timeout=30) r.raise_for_status() return literal_eval(r.text) @api.multi def update_notification(self, cron_mode=True): """ Send a message to Odoo's publisher warranty server to check the validity of the contracts, get notifications, etc... @param cron_mode: If true, catch all exceptions (appropriate for usage in a cron). @type cron_mode: boolean """ try: try: result = self._get_sys_logs() except Exception: if cron_mode: # we don't want to see any stack trace in cron return False _logger.debug("Exception while sending a get logs messages", exc_info=1) raise UserError(_("Error during communication with the publisher warranty server.")) # old behavior based on res.log; now on mail.message, that is not necessarily installed user = self.env['res.users'].sudo().browse(SUPERUSER_ID) poster = self.sudo().env.ref('mail.channel_all_employees') if not (poster and poster.exists()): if not user.exists(): return True poster = user for message in result["messages"]: try: poster.message_post(body=message, subtype='mt_comment', partner_ids=[user.partner_id.id]) except Exception: pass if result.get('enterprise_info'): # Update expiration date set_param = self.env['ir.config_parameter'].sudo().set_param set_param('database.expiration_date', result['enterprise_info'].get('expiration_date')) set_param('database.expiration_reason', result['enterprise_info'].get('expiration_reason', 'trial')) set_param('database.enterprise_code', result['enterprise_info'].get('enterprise_code')) except Exception: if cron_mode: return False # we don't want to see any stack trace in cron else: raise return True """Support for functionality to have conversations with Home Assistant.""" import logging import re import voluptuous as vol from homeassistant import core from homeassistant.components import http, websocket_api from homeassistant.components.http.data_validator import RequestDataValidator from homeassistant.const import HTTP_INTERNAL_SERVER_ERROR from homeassistant.helpers import config_validation as cv, intent from homeassistant.loader import bind_hass from .agent import AbstractConversationAgent from .default_agent import DefaultAgent, async_register _LOGGER = logging.getLogger(__name__) ATTR_TEXT = "text" DOMAIN = "conversation" REGEX_TYPE = type(re.compile("")) DATA_AGENT = "conversation_agent" DATA_CONFIG = "conversation_config" SERVICE_PROCESS = "process" SERVICE_PROCESS_SCHEMA = vol.Schema({vol.Required(ATTR_TEXT): cv.string}) CONFIG_SCHEMA = vol.Schema( { DOMAIN: vol.Schema( { vol.Optional("intents"): vol.Schema( {cv.string: vol.All(cv.ensure_list, [cv.string])} ) } ) }, extra=vol.ALLOW_EXTRA, ) async_register = bind_hass(async_register) @core.callback @bind_hass def async_set_agent(hass: core.HomeAssistant, agent: AbstractConversationAgent): """Set the agent to handle the conversations.""" hass.data[DATA_AGENT] = agent async def async_setup(hass, config): """Register the process service.""" hass.data[DATA_CONFIG] = config async def handle_service(service): """Parse text into commands.""" text = service.data[ATTR_TEXT] _LOGGER.debug("Processing: <%s>", text) agent = await _get_agent(hass) try: await agent.async_process(text, service.context) except intent.IntentHandleError as err: _LOGGER.error("Error processing %s: %s", text, err) hass.services.async_register( DOMAIN, SERVICE_PROCESS, handle_service, schema=SERVICE_PROCESS_SCHEMA ) hass.http.register_view(ConversationProcessView()) hass.components.websocket_api.async_register_command(websocket_process) hass.components.websocket_api.async_register_command(websocket_get_agent_info) hass.components.websocket_api.async_register_command(websocket_set_onboarding) return True @websocket_api.async_response @websocket_api.websocket_command( {"type": "conversation/process", "text": str, vol.Optional("conversation_id"): str} ) async def websocket_process(hass, connection, msg): """Process text.""" connection.send_result( msg["id"], await _async_converse( hass, msg["text"], msg.get("conversation_id"), connection.context(msg) ), ) @websocket_api.async_response @websocket_api.websocket_command({"type": "conversation/agent/info"}) async def websocket_get_agent_info(hass, connection, msg): """Do we need onboarding.""" agent = await _get_agent(hass) connection.send_result( msg["id"], { "onboarding": await agent.async_get_onboarding(), "attribution": agent.attribution, }, ) @websocket_api.async_response @websocket_api.websocket_command({"type": "conversation/onboarding/set", "shown": bool}) async def websocket_set_onboarding(hass, connection, msg): """Set onboarding status.""" agent = await _get_agent(hass) success = await agent.async_set_onboarding(msg["shown"]) if success: connection.send_result(msg["id"]) else: connection.send_error(msg["id"]) class ConversationProcessView(http.HomeAssistantView): """View to process text.""" url = "/api/conversation/process" name = "api:conversation:process" @RequestDataValidator( vol.Schema({vol.Required("text"): str, vol.Optional("conversation_id"): str}) ) async def post(self, request, data): """Send a request for processing.""" hass = request.app["hass"] try: intent_result = await _async_converse( hass, data["text"], data.get("conversation_id"), self.context(request) ) except intent.IntentError as err: _LOGGER.error("Error handling intent: %s", err) return self.json( { "success": False, "error": { "code": str(err.__class__.__name__).lower(), "message": str(err), }, }, status_code=HTTP_INTERNAL_SERVER_ERROR, ) return self.json(intent_result) async def _get_agent(hass: core.HomeAssistant) -> AbstractConversationAgent: """Get the active conversation agent.""" agent = hass.data.get(DATA_AGENT) if agent is None: agent = hass.data[DATA_AGENT] = DefaultAgent(hass) await agent.async_initialize(hass.data.get(DATA_CONFIG)) return agent async def _async_converse( hass: core.HomeAssistant, text: str, conversation_id: str, context: core.Context ) -> intent.IntentResponse: """Process text and get intent.""" agent = await _get_agent(hass) try: intent_result = await agent.async_process(text, context, conversation_id) except intent.IntentHandleError as err: intent_result = intent.IntentResponse() intent_result.async_set_speech(str(err)) if intent_result is None: intent_result = intent.IntentResponse() intent_result.async_set_speech("Sorry, I didn't understand that") return intent_result # -*- coding: utf-8 -*- # Copyright (c) 2015, Vispy Development Team. # Distributed under the (new) BSD License. See LICENSE.txt for more info. """ Some wrappers to avoid circular imports, or make certain calls easier. The idea of a 'global' vispy.use function is that although vispy.app and vispy.gloo.gl can be used independently, they are not complely independent for some configureation. E.g. when using real ES 2.0, the app backend should use EGL and not a desktop OpenGL context. Also, we probably want it to be easy to configure vispy to use the ipython notebook backend, which requires specifc config of both app and gl. This module does not have to be aware of the available app and gl backends, but it should be(come) aware of (in)compatibilities between them. """ import subprocess import inspect def use(app=None, gl=None): """ Set the usage options for vispy Specify what app backend and GL backend to use. Parameters ---------- app : str The app backend to use (case insensitive). Standard backends: * 'PyQt4': use Qt widget toolkit via PyQt4. * 'PyQt5': use Qt widget toolkit via PyQt5. * 'PySide': use Qt widget toolkit via PySide. * 'PyGlet': use Pyglet backend. * 'Glfw': use Glfw backend (successor of Glut). Widely available on Linux. * 'SDL2': use SDL v2 backend. * 'osmesa': Use OSMesa backend Additional backends: * 'ipynb_vnc': render in the IPython notebook via a VNC approach (experimental) gl : str The gl backend to use (case insensitive). Options are: * 'gl2': use Vispy's desktop OpenGL API. * 'pyopengl2': use PyOpenGL's desktop OpenGL API. Mostly for testing. * 'es2': (TO COME) use real OpenGL ES 2.0 on Windows via Angle. Availability of ES 2.0 is larger for Windows, since it relies on DirectX. * 'gl+': use the full OpenGL functionality available on your system (via PyOpenGL). Notes ----- If the app option is given, ``vispy.app.use_app()`` is called. If the gl option is given, ``vispy.gloo.use_gl()`` is called. If an app backend name is provided, and that backend could not be loaded, an error is raised. If no backend name is provided, Vispy will first check if the GUI toolkit corresponding to each backend is already imported, and try that backend first. If this is unsuccessful, it will try the 'default_backend' provided in the vispy config. If still not succesful, it will try each backend in a predetermined order. See Also -------- vispy.app.use_app vispy.gloo.gl.use_gl """ if app is None and gl is None: raise TypeError('Must specify at least one of "app" or "gl".') # Example for future. This wont work (yet). if app == 'ipynb_webgl': app = 'headless' gl = 'webgl' if app == 'osmesa': from ..util.osmesa_gl import fix_osmesa_gl_lib fix_osmesa_gl_lib() if gl is not None: raise ValueError("Do not specify gl when using osmesa") # Apply now if gl: from .. import gloo, config config['gl_backend'] = gl gloo.gl.use_gl(gl) if app: from ..app import use_app use_app(app) def run_subprocess(command, return_code=False, **kwargs): """Run command using subprocess.Popen Run command and wait for command to complete. If the return code was zero then return, otherwise raise CalledProcessError. By default, this will also add stdout= and stderr=subproces.PIPE to the call to Popen to suppress printing to the terminal. Parameters ---------- command : list of str Command to run as subprocess (see subprocess.Popen documentation). return_code : bool If True, the returncode will be returned, and no error checking will be performed (so this function should always return without error). **kwargs : dict Additional kwargs to pass to ``subprocess.Popen``. Returns ------- stdout : str Stdout returned by the process. stderr : str Stderr returned by the process. code : int The command exit code. Only returned if ``return_code`` is True. """ # code adapted with permission from mne-python use_kwargs = dict(stderr=subprocess.PIPE, stdout=subprocess.PIPE) use_kwargs.update(kwargs) p = subprocess.Popen(command, **use_kwargs) output = p.communicate() # communicate() may return bytes, str, or None depending on the kwargs # passed to Popen(). Convert all to unicode str: output = ['' if s is None else s for s in output] output = [s.decode('utf-8') if isinstance(s, bytes) else s for s in output] output = tuple(output) if not return_code and p.returncode: print(output[0]) print(output[1]) err_fun = subprocess.CalledProcessError.__init__ if 'output' in inspect.getargspec(err_fun).args: raise subprocess.CalledProcessError(p.returncode, command, output) else: raise subprocess.CalledProcessError(p.returncode, command) if return_code: output = output + (p.returncode,) return output """ Python Character Mapping Codec cp1254 generated from 'MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1254.TXT' with gencodec.py. """#" import codecs ### Codec APIs class Codec(codecs.Codec): def encode(self,input,errors='strict'): return codecs.charmap_encode(input,errors,encoding_table) def decode(self,input,errors='strict'): return codecs.charmap_decode(input,errors,decoding_table) class IncrementalEncoder(codecs.IncrementalEncoder): def encode(self, input, final=False): return codecs.charmap_encode(input,self.errors,encoding_table)[0] class IncrementalDecoder(codecs.IncrementalDecoder): def decode(self, input, final=False): return codecs.charmap_decode(input,self.errors,decoding_table)[0] class StreamWriter(Codec,codecs.StreamWriter): pass class StreamReader(Codec,codecs.StreamReader): pass ### encodings module API def getregentry(): return codecs.CodecInfo( name='cp1254', encode=Codec().encode, decode=Codec().decode, incrementalencoder=IncrementalEncoder, incrementaldecoder=IncrementalDecoder, streamreader=StreamReader, streamwriter=StreamWriter, ) ### Decoding Table decoding_table = ( '\x00' # 0x00 -> NULL '\x01' # 0x01 -> START OF HEADING '\x02' # 0x02 -> START OF TEXT '\x03' # 0x03 -> END OF TEXT '\x04' # 0x04 -> END OF TRANSMISSION '\x05' # 0x05 -> ENQUIRY '\x06' # 0x06 -> ACKNOWLEDGE '\x07' # 0x07 -> BELL '\x08' # 0x08 -> BACKSPACE '\t' # 0x09 -> HORIZONTAL TABULATION '\n' # 0x0A -> LINE FEED '\x0b' # 0x0B -> VERTICAL TABULATION '\x0c' # 0x0C -> FORM FEED '\r' # 0x0D -> CARRIAGE RETURN '\x0e' # 0x0E -> SHIFT OUT '\x0f' # 0x0F -> SHIFT IN '\x10' # 0x10 -> DATA LINK ESCAPE '\x11' # 0x11 -> DEVICE CONTROL ONE '\x12' # 0x12 -> DEVICE CONTROL TWO '\x13' # 0x13 -> DEVICE CONTROL THREE '\x14' # 0x14 -> DEVICE CONTROL FOUR '\x15' # 0x15 -> NEGATIVE ACKNOWLEDGE '\x16' # 0x16 -> SYNCHRONOUS IDLE '\x17' # 0x17 -> END OF TRANSMISSION BLOCK '\x18' # 0x18 -> CANCEL '\x19' # 0x19 -> END OF MEDIUM '\x1a' # 0x1A -> SUBSTITUTE '\x1b' # 0x1B -> ESCAPE '\x1c' # 0x1C -> FILE SEPARATOR '\x1d' # 0x1D -> GROUP SEPARATOR '\x1e' # 0x1E -> RECORD SEPARATOR '\x1f' # 0x1F -> UNIT SEPARATOR ' ' # 0x20 -> SPACE '!' # 0x21 -> EXCLAMATION MARK '"' # 0x22 -> QUOTATION MARK '#' # 0x23 -> NUMBER SIGN '$' # 0x24 -> DOLLAR SIGN '%' # 0x25 -> PERCENT SIGN '&' # 0x26 -> AMPERSAND "'" # 0x27 -> APOSTROPHE '(' # 0x28 -> LEFT PARENTHESIS ')' # 0x29 -> RIGHT PARENTHESIS '*' # 0x2A -> ASTERISK '+' # 0x2B -> PLUS SIGN ',' # 0x2C -> COMMA '-' # 0x2D -> HYPHEN-MINUS '.' # 0x2E -> FULL STOP '/' # 0x2F -> SOLIDUS '0' # 0x30 -> DIGIT ZERO '1' # 0x31 -> DIGIT ONE '2' # 0x32 -> DIGIT TWO '3' # 0x33 -> DIGIT THREE '4' # 0x34 -> DIGIT FOUR '5' # 0x35 -> DIGIT FIVE '6' # 0x36 -> DIGIT SIX '7' # 0x37 -> DIGIT SEVEN '8' # 0x38 -> DIGIT EIGHT '9' # 0x39 -> DIGIT NINE ':' # 0x3A -> COLON ';' # 0x3B -> SEMICOLON '<' # 0x3C -> LESS-THAN SIGN '=' # 0x3D -> EQUALS SIGN '>' # 0x3E -> GREATER-THAN SIGN '?' # 0x3F -> QUESTION MARK '@' # 0x40 -> COMMERCIAL AT 'A' # 0x41 -> LATIN CAPITAL LETTER A 'B' # 0x42 -> LATIN CAPITAL LETTER B 'C' # 0x43 -> LATIN CAPITAL LETTER C 'D' # 0x44 -> LATIN CAPITAL LETTER D 'E' # 0x45 -> LATIN CAPITAL LETTER E 'F' # 0x46 -> LATIN CAPITAL LETTER F 'G' # 0x47 -> LATIN CAPITAL LETTER G 'H' # 0x48 -> LATIN CAPITAL LETTER H 'I' # 0x49 -> LATIN CAPITAL LETTER I 'J' # 0x4A -> LATIN CAPITAL LETTER J 'K' # 0x4B -> LATIN CAPITAL LETTER K 'L' # 0x4C -> LATIN CAPITAL LETTER L 'M' # 0x4D -> LATIN CAPITAL LETTER M 'N' # 0x4E -> LATIN CAPITAL LETTER N 'O' # 0x4F -> LATIN CAPITAL LETTER O 'P' # 0x50 -> LATIN CAPITAL LETTER P 'Q' # 0x51 -> LATIN CAPITAL LETTER Q 'R' # 0x52 -> LATIN CAPITAL LETTER R 'S' # 0x53 -> LATIN CAPITAL LETTER S 'T' # 0x54 -> LATIN CAPITAL LETTER T 'U' # 0x55 -> LATIN CAPITAL LETTER U 'V' # 0x56 -> LATIN CAPITAL LETTER V 'W' # 0x57 -> LATIN CAPITAL LETTER W 'X' # 0x58 -> LATIN CAPITAL LETTER X 'Y' # 0x59 -> LATIN CAPITAL LETTER Y 'Z' # 0x5A -> LATIN CAPITAL LETTER Z '[' # 0x5B -> LEFT SQUARE BRACKET '\\' # 0x5C -> REVERSE SOLIDUS ']' # 0x5D -> RIGHT SQUARE BRACKET '^' # 0x5E -> CIRCUMFLEX ACCENT '_' # 0x5F -> LOW LINE '`' # 0x60 -> GRAVE ACCENT 'a' # 0x61 -> LATIN SMALL LETTER A 'b' # 0x62 -> LATIN SMALL LETTER B 'c' # 0x63 -> LATIN SMALL LETTER C 'd' # 0x64 -> LATIN SMALL LETTER D 'e' # 0x65 -> LATIN SMALL LETTER E 'f' # 0x66 -> LATIN SMALL LETTER F 'g' # 0x67 -> LATIN SMALL LETTER G 'h' # 0x68 -> LATIN SMALL LETTER H 'i' # 0x69 -> LATIN SMALL LETTER I 'j' # 0x6A -> LATIN SMALL LETTER J 'k' # 0x6B -> LATIN SMALL LETTER K 'l' # 0x6C -> LATIN SMALL LETTER L 'm' # 0x6D -> LATIN SMALL LETTER M 'n' # 0x6E -> LATIN SMALL LETTER N 'o' # 0x6F -> LATIN SMALL LETTER O 'p' # 0x70 -> LATIN SMALL LETTER P 'q' # 0x71 -> LATIN SMALL LETTER Q 'r' # 0x72 -> LATIN SMALL LETTER R 's' # 0x73 -> LATIN SMALL LETTER S 't' # 0x74 -> LATIN SMALL LETTER T 'u' # 0x75 -> LATIN SMALL LETTER U 'v' # 0x76 -> LATIN SMALL LETTER V 'w' # 0x77 -> LATIN SMALL LETTER W 'x' # 0x78 -> LATIN SMALL LETTER X 'y' # 0x79 -> LATIN SMALL LETTER Y 'z' # 0x7A -> LATIN SMALL LETTER Z '{' # 0x7B -> LEFT CURLY BRACKET '|' # 0x7C -> VERTICAL LINE '}' # 0x7D -> RIGHT CURLY BRACKET '~' # 0x7E -> TILDE '\x7f' # 0x7F -> DELETE '\u20ac' # 0x80 -> EURO SIGN '\ufffe' # 0x81 -> UNDEFINED '\u201a' # 0x82 -> SINGLE LOW-9 QUOTATION MARK '\u0192' # 0x83 -> LATIN SMALL LETTER F WITH HOOK '\u201e' # 0x84 -> DOUBLE LOW-9 QUOTATION MARK '\u2026' # 0x85 -> HORIZONTAL ELLIPSIS '\u2020' # 0x86 -> DAGGER '\u2021' # 0x87 -> DOUBLE DAGGER '\u02c6' # 0x88 -> MODIFIER LETTER CIRCUMFLEX ACCENT '\u2030' # 0x89 -> PER MILLE SIGN '\u0160' # 0x8A -> LATIN CAPITAL LETTER S WITH CARON '\u2039' # 0x8B -> SINGLE LEFT-POINTING ANGLE QUOTATION MARK '\u0152' # 0x8C -> LATIN CAPITAL LIGATURE OE '\ufffe' # 0x8D -> UNDEFINED '\ufffe' # 0x8E -> UNDEFINED '\ufffe' # 0x8F -> UNDEFINED '\ufffe' # 0x90 -> UNDEFINED '\u2018' # 0x91 -> LEFT SINGLE QUOTATION MARK '\u2019' # 0x92 -> RIGHT SINGLE QUOTATION MARK '\u201c' # 0x93 -> LEFT DOUBLE QUOTATION MARK '\u201d' # 0x94 -> RIGHT DOUBLE QUOTATION MARK '\u2022' # 0x95 -> BULLET '\u2013' # 0x96 -> EN DASH '\u2014' # 0x97 -> EM DASH '\u02dc' # 0x98 -> SMALL TILDE '\u2122' # 0x99 -> TRADE MARK SIGN '\u0161' # 0x9A -> LATIN SMALL LETTER S WITH CARON '\u203a' # 0x9B -> SINGLE RIGHT-POINTING ANGLE QUOTATION MARK '\u0153' # 0x9C -> LATIN SMALL LIGATURE OE '\ufffe' # 0x9D -> UNDEFINED '\ufffe' # 0x9E -> UNDEFINED '\u0178' # 0x9F -> LATIN CAPITAL LETTER Y WITH DIAERESIS '\xa0' # 0xA0 -> NO-BREAK SPACE '\xa1' # 0xA1 -> INVERTED EXCLAMATION MARK '\xa2' # 0xA2 -> CENT SIGN '\xa3' # 0xA3 -> POUND SIGN '\xa4' # 0xA4 -> CURRENCY SIGN '\xa5' # 0xA5 -> YEN SIGN '\xa6' # 0xA6 -> BROKEN BAR '\xa7' # 0xA7 -> SECTION SIGN '\xa8' # 0xA8 -> DIAERESIS '\xa9' # 0xA9 -> COPYRIGHT SIGN '\xaa' # 0xAA -> FEMININE ORDINAL INDICATOR '\xab' # 0xAB -> LEFT-POINTING DOUBLE ANGLE QUOTATION MARK '\xac' # 0xAC -> NOT SIGN '\xad' # 0xAD -> SOFT HYPHEN '\xae' # 0xAE -> REGISTERED SIGN '\xaf' # 0xAF -> MACRON '\xb0' # 0xB0 -> DEGREE SIGN '\xb1' # 0xB1 -> PLUS-MINUS SIGN '\xb2' # 0xB2 -> SUPERSCRIPT TWO '\xb3' # 0xB3 -> SUPERSCRIPT THREE '\xb4' # 0xB4 -> ACUTE ACCENT '\xb5' # 0xB5 -> MICRO SIGN '\xb6' # 0xB6 -> PILCROW SIGN '\xb7' # 0xB7 -> MIDDLE DOT '\xb8' # 0xB8 -> CEDILLA '\xb9' # 0xB9 -> SUPERSCRIPT ONE '\xba' # 0xBA -> MASCULINE ORDINAL INDICATOR '\xbb' # 0xBB -> RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK '\xbc' # 0xBC -> VULGAR FRACTION ONE QUARTER '\xbd' # 0xBD -> VULGAR FRACTION ONE HALF '\xbe' # 0xBE -> VULGAR FRACTION THREE QUARTERS '\xbf' # 0xBF -> INVERTED QUESTION MARK '\xc0' # 0xC0 -> LATIN CAPITAL LETTER A WITH GRAVE '\xc1' # 0xC1 -> LATIN CAPITAL LETTER A WITH ACUTE '\xc2' # 0xC2 -> LATIN CAPITAL LETTER A WITH CIRCUMFLEX '\xc3' # 0xC3 -> LATIN CAPITAL LETTER A WITH TILDE '\xc4' # 0xC4 -> LATIN CAPITAL LETTER A WITH DIAERESIS '\xc5' # 0xC5 -> LATIN CAPITAL LETTER A WITH RING ABOVE '\xc6' # 0xC6 -> LATIN CAPITAL LETTER AE '\xc7' # 0xC7 -> LATIN CAPITAL LETTER C WITH CEDILLA '\xc8' # 0xC8 -> LATIN CAPITAL LETTER E WITH GRAVE '\xc9' # 0xC9 -> LATIN CAPITAL LETTER E WITH ACUTE '\xca' # 0xCA -> LATIN CAPITAL LETTER E WITH CIRCUMFLEX '\xcb' # 0xCB -> LATIN CAPITAL LETTER E WITH DIAERESIS '\xcc' # 0xCC -> LATIN CAPITAL LETTER I WITH GRAVE '\xcd' # 0xCD -> LATIN CAPITAL LETTER I WITH ACUTE '\xce' # 0xCE -> LATIN CAPITAL LETTER I WITH CIRCUMFLEX '\xcf' # 0xCF -> LATIN CAPITAL LETTER I WITH DIAERESIS '\u011e' # 0xD0 -> LATIN CAPITAL LETTER G WITH BREVE '\xd1' # 0xD1 -> LATIN CAPITAL LETTER N WITH TILDE '\xd2' # 0xD2 -> LATIN CAPITAL LETTER O WITH GRAVE '\xd3' # 0xD3 -> LATIN CAPITAL LETTER O WITH ACUTE '\xd4' # 0xD4 -> LATIN CAPITAL LETTER O WITH CIRCUMFLEX '\xd5' # 0xD5 -> LATIN CAPITAL LETTER O WITH TILDE '\xd6' # 0xD6 -> LATIN CAPITAL LETTER O WITH DIAERESIS '\xd7' # 0xD7 -> MULTIPLICATION SIGN '\xd8' # 0xD8 -> LATIN CAPITAL LETTER O WITH STROKE '\xd9' # 0xD9 -> LATIN CAPITAL LETTER U WITH GRAVE '\xda' # 0xDA -> LATIN CAPITAL LETTER U WITH ACUTE '\xdb' # 0xDB -> LATIN CAPITAL LETTER U WITH CIRCUMFLEX '\xdc' # 0xDC -> LATIN CAPITAL LETTER U WITH DIAERESIS '\u0130' # 0xDD -> LATIN CAPITAL LETTER I WITH DOT ABOVE '\u015e' # 0xDE -> LATIN CAPITAL LETTER S WITH CEDILLA '\xdf' # 0xDF -> LATIN SMALL LETTER SHARP S '\xe0' # 0xE0 -> LATIN SMALL LETTER A WITH GRAVE '\xe1' # 0xE1 -> LATIN SMALL LETTER A WITH ACUTE '\xe2' # 0xE2 -> LATIN SMALL LETTER A WITH CIRCUMFLEX '\xe3' # 0xE3 -> LATIN SMALL LETTER A WITH TILDE '\xe4' # 0xE4 -> LATIN SMALL LETTER A WITH DIAERESIS '\xe5' # 0xE5 -> LATIN SMALL LETTER A WITH RING ABOVE '\xe6' # 0xE6 -> LATIN SMALL LETTER AE '\xe7' # 0xE7 -> LATIN SMALL LETTER C WITH CEDILLA '\xe8' # 0xE8 -> LATIN SMALL LETTER E WITH GRAVE '\xe9' # 0xE9 -> LATIN SMALL LETTER E WITH ACUTE '\xea' # 0xEA -> LATIN SMALL LETTER E WITH CIRCUMFLEX '\xeb' # 0xEB -> LATIN SMALL LETTER E WITH DIAERESIS '\xec' # 0xEC -> LATIN SMALL LETTER I WITH GRAVE '\xed' # 0xED -> LATIN SMALL LETTER I WITH ACUTE '\xee' # 0xEE -> LATIN SMALL LETTER I WITH CIRCUMFLEX '\xef' # 0xEF -> LATIN SMALL LETTER I WITH DIAERESIS '\u011f' # 0xF0 -> LATIN SMALL LETTER G WITH BREVE '\xf1' # 0xF1 -> LATIN SMALL LETTER N WITH TILDE '\xf2' # 0xF2 -> LATIN SMALL LETTER O WITH GRAVE '\xf3' # 0xF3 -> LATIN SMALL LETTER O WITH ACUTE '\xf4' # 0xF4 -> LATIN SMALL LETTER O WITH CIRCUMFLEX '\xf5' # 0xF5 -> LATIN SMALL LETTER O WITH TILDE '\xf6' # 0xF6 -> LATIN SMALL LETTER O WITH DIAERESIS '\xf7' # 0xF7 -> DIVISION SIGN '\xf8' # 0xF8 -> LATIN SMALL LETTER O WITH STROKE '\xf9' # 0xF9 -> LATIN SMALL LETTER U WITH GRAVE '\xfa' # 0xFA -> LATIN SMALL LETTER U WITH ACUTE '\xfb' # 0xFB -> LATIN SMALL LETTER U WITH CIRCUMFLEX '\xfc' # 0xFC -> LATIN SMALL LETTER U WITH DIAERESIS '\u0131' # 0xFD -> LATIN SMALL LETTER DOTLESS I '\u015f' # 0xFE -> LATIN SMALL LETTER S WITH CEDILLA '\xff' # 0xFF -> LATIN SMALL LETTER Y WITH DIAERESIS ) ### Encoding table encoding_table=codecs.charmap_build(decoding_table) # antfs-cli distutils setup script # # Copyright (c) 2012, Gustav Tiger # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. from __future__ import absolute_import, print_function from setuptools import setup try: with open('README.md') as file: long_description = file.read() except IOError: long_description = '' setup(name='antfs-cli', version='0.2', description='ANT-FS Command Line Interface', long_description=long_description, author='Gustav Tiger', author_email='gustav@tiger.name', packages=['antfs_cli'], entry_points={ 'console_scripts': ['antfs-cli=antfs_cli.program:main'] }, url='https://github.com/Tigge/antfs-cli', classifiers=['Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'Intended Audience :: End Users/Desktop', 'Intended Audience :: Healthcare Industry', 'License :: OSI Approved :: MIT License', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4'], dependency_links=['git+https://github.com/Tigge/openant.git#egg=openant-0.2'], install_requires=['openant>=0.2'], test_suite='tests') ''' Test one delayed preaccept callback ''' # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import re Test.Summary = ''' Test different combinations of TLS handshake hooks to ensure they are applied consistently. ''' Test.SkipUnless(Condition.HasProgram("grep", "grep needs to be installed on system for this test to work")) ts = Test.MakeATSProcess("ts", select_ports=False) server = Test.MakeOriginServer("server") request_header = {"headers": "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n", "timestamp": "1469733493.993", "body": ""} # desired response form the origin server response_header = {"headers": "HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n", "timestamp": "1469733493.993", "body": ""} server.addResponse("sessionlog.json", request_header, response_header) ts.addSSLfile("ssl/server.pem") ts.addSSLfile("ssl/server.key") ts.Variables.ssl_port = 4443 ts.Disk.records_config.update({ 'proxy.config.diags.debug.enabled': 1, 'proxy.config.diags.debug.tags': 'ssl_hook_test', 'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir), 'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir), # enable ssl port 'proxy.config.http.server_ports': '{0}:ssl'.format(ts.Variables.ssl_port), 'proxy.config.ssl.client.verify.server': 0, 'proxy.config.ssl.server.cipher_suite': 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:AES128-GCM-SHA256:AES256-GCM-SHA384:ECDHE-RSA-RC4-SHA:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:RC4-SHA:RC4-MD5:AES128-SHA:AES256-SHA:DES-CBC3-SHA!SRP:!DSS:!PSK:!aNULL:!eNULL:!SSLv2', }) ts.Disk.ssl_multicert_config.AddLine( 'dest_ip=* ssl_cert_name=server.pem ssl_key_name=server.key' ) ts.Disk.remap_config.AddLine( 'map https://example.com:4443 http://127.0.0.1:{0}'.format(server.Variables.Port) ) Test.PreparePlugin(os.path.join(Test.Variables.AtsTestToolsDir, 'plugins', 'ssl_hook_test.cc'), ts, '-d=1') tr = Test.AddTestRun("Test one delayed preaccept hook") tr.Processes.Default.StartBefore(server) tr.Processes.Default.StartBefore(Test.Processes.ts, ready=When.PortOpen(ts.Variables.ssl_port)) tr.StillRunningAfter = ts tr.StillRunningAfter = server tr.Processes.Default.Command = 'curl -k -H \'host:example.com:{0}\' https://127.0.0.1:{0}'.format(ts.Variables.ssl_port) tr.Processes.Default.ReturnCode = 0 tr.Processes.Default.Streams.stdout = "gold/preaccept-1.gold" ts.Streams.stderr = "gold/ts-preaccept-delayed-1.gold" preacceptstring = "Pre accept delay callback 0" ts.Streams.All = Testers.ContainsExpression( "\A(?:(?!{0}).)*{0}.*({0})?(?!.*{0}).*\Z".format(preacceptstring), "Pre accept message appears only once or twice", reflags=re.S | re.M) tr.Processes.Default.TimeOut = 5 tr.TimeOut = 5 # Copyright 2019 Fortinet, Inc. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Ansible. If not, see . # Make coding more python3-ish from __future__ import (absolute_import, division, print_function) __metaclass__ = type import os import json import pytest from mock import ANY from ansible.module_utils.network.fortios.fortios import FortiOSHandler try: from ansible.modules.network.fortios import fortios_switch_controller_security_policy_captive_portal except ImportError: pytest.skip("Could not load required modules for testing", allow_module_level=True) @pytest.fixture(autouse=True) def connection_mock(mocker): connection_class_mock = mocker.patch('ansible.modules.network.fortios.fortios_switch_controller_security_policy_captive_portal.Connection') return connection_class_mock fos_instance = FortiOSHandler(connection_mock) def test_switch_controller_security_policy_captive_portal_creation(mocker): schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema') set_method_result = {'status': 'success', 'http_method': 'POST', 'http_status': 200} set_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result) input_data = { 'username': 'admin', 'state': 'present', 'switch_controller_security_policy_captive_portal': { 'name': 'default_name_3', 'policy_type': 'captive-portal', 'vlan': 'test_value_5' }, 'vdom': 'root'} is_error, changed, response = fortios_switch_controller_security_policy_captive_portal.fortios_switch_controller_security_policy(input_data, fos_instance) expected_data = { 'name': 'default_name_3', 'policy-type': 'captive-portal', 'vlan': 'test_value_5' } set_method_mock.assert_called_with('switch-controller.security-policy', 'captive-portal', data=expected_data, vdom='root') schema_method_mock.assert_not_called() assert not is_error assert changed assert response['status'] == 'success' assert response['http_status'] == 200 def test_switch_controller_security_policy_captive_portal_creation_fails(mocker): schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema') set_method_result = {'status': 'error', 'http_method': 'POST', 'http_status': 500} set_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result) input_data = { 'username': 'admin', 'state': 'present', 'switch_controller_security_policy_captive_portal': { 'name': 'default_name_3', 'policy_type': 'captive-portal', 'vlan': 'test_value_5' }, 'vdom': 'root'} is_error, changed, response = fortios_switch_controller_security_policy_captive_portal.fortios_switch_controller_security_policy(input_data, fos_instance) expected_data = { 'name': 'default_name_3', 'policy-type': 'captive-portal', 'vlan': 'test_value_5' } set_method_mock.assert_called_with('switch-controller.security-policy', 'captive-portal', data=expected_data, vdom='root') schema_method_mock.assert_not_called() assert is_error assert not changed assert response['status'] == 'error' assert response['http_status'] == 500 def test_switch_controller_security_policy_captive_portal_removal(mocker): schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema') delete_method_result = {'status': 'success', 'http_method': 'POST', 'http_status': 200} delete_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.delete', return_value=delete_method_result) input_data = { 'username': 'admin', 'state': 'absent', 'switch_controller_security_policy_captive_portal': { 'name': 'default_name_3', 'policy_type': 'captive-portal', 'vlan': 'test_value_5' }, 'vdom': 'root'} is_error, changed, response = fortios_switch_controller_security_policy_captive_portal.fortios_switch_controller_security_policy(input_data, fos_instance) delete_method_mock.assert_called_with('switch-controller.security-policy', 'captive-portal', mkey=ANY, vdom='root') schema_method_mock.assert_not_called() assert not is_error assert changed assert response['status'] == 'success' assert response['http_status'] == 200 def test_switch_controller_security_policy_captive_portal_deletion_fails(mocker): schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema') delete_method_result = {'status': 'error', 'http_method': 'POST', 'http_status': 500} delete_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.delete', return_value=delete_method_result) input_data = { 'username': 'admin', 'state': 'absent', 'switch_controller_security_policy_captive_portal': { 'name': 'default_name_3', 'policy_type': 'captive-portal', 'vlan': 'test_value_5' }, 'vdom': 'root'} is_error, changed, response = fortios_switch_controller_security_policy_captive_portal.fortios_switch_controller_security_policy(input_data, fos_instance) delete_method_mock.assert_called_with('switch-controller.security-policy', 'captive-portal', mkey=ANY, vdom='root') schema_method_mock.assert_not_called() assert is_error assert not changed assert response['status'] == 'error' assert response['http_status'] == 500 def test_switch_controller_security_policy_captive_portal_idempotent(mocker): schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema') set_method_result = {'status': 'error', 'http_method': 'DELETE', 'http_status': 404} set_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result) input_data = { 'username': 'admin', 'state': 'present', 'switch_controller_security_policy_captive_portal': { 'name': 'default_name_3', 'policy_type': 'captive-portal', 'vlan': 'test_value_5' }, 'vdom': 'root'} is_error, changed, response = fortios_switch_controller_security_policy_captive_portal.fortios_switch_controller_security_policy(input_data, fos_instance) expected_data = { 'name': 'default_name_3', 'policy-type': 'captive-portal', 'vlan': 'test_value_5' } set_method_mock.assert_called_with('switch-controller.security-policy', 'captive-portal', data=expected_data, vdom='root') schema_method_mock.assert_not_called() assert not is_error assert not changed assert response['status'] == 'error' assert response['http_status'] == 404 def test_switch_controller_security_policy_captive_portal_filter_foreign_attributes(mocker): schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema') set_method_result = {'status': 'success', 'http_method': 'POST', 'http_status': 200} set_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result) input_data = { 'username': 'admin', 'state': 'present', 'switch_controller_security_policy_captive_portal': { 'random_attribute_not_valid': 'tag', 'name': 'default_name_3', 'policy_type': 'captive-portal', 'vlan': 'test_value_5' }, 'vdom': 'root'} is_error, changed, response = fortios_switch_controller_security_policy_captive_portal.fortios_switch_controller_security_policy(input_data, fos_instance) expected_data = { 'name': 'default_name_3', 'policy-type': 'captive-portal', 'vlan': 'test_value_5' } set_method_mock.assert_called_with('switch-controller.security-policy', 'captive-portal', data=expected_data, vdom='root') schema_method_mock.assert_not_called() assert not is_error assert changed assert response['status'] == 'success' assert response['http_status'] == 200 from __future__ import unicode_literals import re from .common import InfoExtractor from ..utils import ( unified_strdate, ) class KhanAcademyIE(InfoExtractor): _VALID_URL = r'^https?://(?:(?:www|api)\.)?khanacademy\.org/(?P[^/]+)/(?:[^/]+/){,2}(?P[^?#/]+)(?:$|[?#])' IE_NAME = 'KhanAcademy' _TESTS = [{ 'url': 'http://www.khanacademy.org/video/one-time-pad', 'md5': '7021db7f2d47d4fff89b13177cb1e8f4', 'info_dict': { 'id': 'one-time-pad', 'ext': 'mp4', 'title': 'The one-time pad', 'description': 'The perfect cipher', 'duration': 176, 'uploader': 'Brit Cruise', 'uploader_id': 'khanacademy', 'upload_date': '20120411', }, 'add_ie': ['Youtube'], }, { 'url': 'https://www.khanacademy.org/math/applied-math/cryptography', 'info_dict': { 'id': 'cryptography', 'title': 'Journey into cryptography', 'description': 'How have humans protected their secret messages through history? What has changed today?', }, 'playlist_mincount': 3, }] def _real_extract(self, url): m = re.match(self._VALID_URL, url) video_id = m.group('id') if m.group('key') == 'video': data = self._download_json( 'http://api.khanacademy.org/api/v1/videos/' + video_id, video_id, 'Downloading video info') upload_date = unified_strdate(data['date_added']) uploader = ', '.join(data['author_names']) return { '_type': 'url_transparent', 'url': data['url'], 'id': video_id, 'title': data['title'], 'thumbnail': data['image_url'], 'duration': data['duration'], 'description': data['description'], 'uploader': uploader, 'upload_date': upload_date, } else: # topic data = self._download_json( 'http://api.khanacademy.org/api/v1/topic/' + video_id, video_id, 'Downloading topic info') entries = [ { '_type': 'url', 'url': c['url'], 'id': c['id'], 'title': c['title'], } for c in data['children'] if c['kind'] in ('Video', 'Topic')] return { '_type': 'playlist', 'id': video_id, 'title': data['title'], 'description': data['description'], 'entries': entries, } # Copyright 2015 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np from tensorflow.python.framework import constant_op from tensorflow.python.framework import dtypes as dtypes_lib from tensorflow.python.framework import ops from tensorflow.python.ops import array_ops from tensorflow.python.ops import gradient_checker from tensorflow.python.ops import gradients_impl from tensorflow.python.platform import test from tensorflow.python.platform import tf_logging class MatrixDiagTest(test.TestCase): def testVector(self): with self.test_session(use_gpu=True): v = np.array([1.0, 2.0, 3.0]) mat = np.diag(v) v_diag = array_ops.matrix_diag(v) self.assertEqual((3, 3), v_diag.get_shape()) self.assertAllEqual(v_diag.eval(), mat) def _testBatchVector(self, dtype): with self.test_session(use_gpu=True): v_batch = np.array([[1.0, 0.0, 3.0], [4.0, 5.0, 6.0]]).astype(dtype) mat_batch = np.array([[[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 3.0]], [[4.0, 0.0, 0.0], [0.0, 5.0, 0.0], [0.0, 0.0, 6.0]]]).astype(dtype) v_batch_diag = array_ops.matrix_diag(v_batch) self.assertEqual((2, 3, 3), v_batch_diag.get_shape()) self.assertAllEqual(v_batch_diag.eval(), mat_batch) def testBatchVector(self): self._testBatchVector(np.float32) self._testBatchVector(np.float64) self._testBatchVector(np.int32) self._testBatchVector(np.int64) self._testBatchVector(np.bool) def testInvalidShape(self): with self.assertRaisesRegexp(ValueError, "must be at least rank 1"): array_ops.matrix_diag(0) def testInvalidShapeAtEval(self): with self.test_session(use_gpu=True): v = array_ops.placeholder(dtype=dtypes_lib.float32) with self.assertRaisesOpError("input must be at least 1-dim"): array_ops.matrix_diag(v).eval(feed_dict={v: 0.0}) def testGrad(self): shapes = ((3,), (7, 4)) with self.test_session(use_gpu=True): for shape in shapes: x = constant_op.constant(np.random.rand(*shape), np.float32) y = array_ops.matrix_diag(x) error = gradient_checker.compute_gradient_error(x, x.get_shape().as_list(), y, y.get_shape().as_list()) self.assertLess(error, 1e-4) class MatrixSetDiagTest(test.TestCase): def testSquare(self): with self.test_session(use_gpu=True): v = np.array([1.0, 2.0, 3.0]) mat = np.array([[0.0, 1.0, 0.0], [1.0, 0.0, 1.0], [1.0, 1.0, 1.0]]) mat_set_diag = np.array([[1.0, 1.0, 0.0], [1.0, 2.0, 1.0], [1.0, 1.0, 3.0]]) output = array_ops.matrix_set_diag(mat, v) self.assertEqual((3, 3), output.get_shape()) self.assertAllEqual(mat_set_diag, output.eval()) def testRectangular(self): with self.test_session(use_gpu=True): v = np.array([3.0, 4.0]) mat = np.array([[0.0, 1.0, 0.0], [1.0, 0.0, 1.0]]) expected = np.array([[3.0, 1.0, 0.0], [1.0, 4.0, 1.0]]) output = array_ops.matrix_set_diag(mat, v) self.assertEqual((2, 3), output.get_shape()) self.assertAllEqual(expected, output.eval()) v = np.array([3.0, 4.0]) mat = np.array([[0.0, 1.0], [1.0, 0.0], [1.0, 1.0]]) expected = np.array([[3.0, 1.0], [1.0, 4.0], [1.0, 1.0]]) output = array_ops.matrix_set_diag(mat, v) self.assertEqual((3, 2), output.get_shape()) self.assertAllEqual(expected, output.eval()) def _testSquareBatch(self, dtype): with self.test_session(use_gpu=True): v_batch = np.array([[-1.0, 0.0, -3.0], [-4.0, -5.0, -6.0]]).astype(dtype) mat_batch = np.array([[[1.0, 0.0, 3.0], [0.0, 2.0, 0.0], [1.0, 0.0, 3.0]], [[4.0, 0.0, 4.0], [0.0, 5.0, 0.0], [2.0, 0.0, 6.0]]]).astype(dtype) mat_set_diag_batch = np.array([[[-1.0, 0.0, 3.0], [0.0, 0.0, 0.0], [1.0, 0.0, -3.0]], [[-4.0, 0.0, 4.0], [0.0, -5.0, 0.0], [2.0, 0.0, -6.0]]]).astype(dtype) output = array_ops.matrix_set_diag(mat_batch, v_batch) self.assertEqual((2, 3, 3), output.get_shape()) self.assertAllEqual(mat_set_diag_batch, output.eval()) def testSquareBatch(self): self._testSquareBatch(np.float32) self._testSquareBatch(np.float64) self._testSquareBatch(np.int32) self._testSquareBatch(np.int64) self._testSquareBatch(np.bool) def testRectangularBatch(self): with self.test_session(use_gpu=True): v_batch = np.array([[-1.0, -2.0], [-4.0, -5.0]]) mat_batch = np.array( [[[1.0, 0.0, 3.0], [0.0, 2.0, 0.0]], [[4.0, 0.0, 4.0], [0.0, 5.0, 0.0]]]) mat_set_diag_batch = np.array( [[[-1.0, 0.0, 3.0], [0.0, -2.0, 0.0]], [[-4.0, 0.0, 4.0], [0.0, -5.0, 0.0]]]) output = array_ops.matrix_set_diag(mat_batch, v_batch) self.assertEqual((2, 2, 3), output.get_shape()) self.assertAllEqual(mat_set_diag_batch, output.eval()) def testInvalidShape(self): with self.assertRaisesRegexp(ValueError, "must be at least rank 2"): array_ops.matrix_set_diag(0, [0]) with self.assertRaisesRegexp(ValueError, "must be at least rank 1"): array_ops.matrix_set_diag([[0]], 0) def testInvalidShapeAtEval(self): with self.test_session(use_gpu=True): v = array_ops.placeholder(dtype=dtypes_lib.float32) with self.assertRaisesOpError("input must be at least 2-dim"): array_ops.matrix_set_diag(v, [v]).eval(feed_dict={v: 0.0}) with self.assertRaisesOpError( r"but received input shape: \[1,1\] and diagonal shape: \[\]"): array_ops.matrix_set_diag([[v]], v).eval(feed_dict={v: 0.0}) def testGrad(self): shapes = ((3, 4, 4), (3, 3, 4), (3, 4, 3), (7, 4, 8, 8)) with self.test_session(use_gpu=True): for shape in shapes: x = constant_op.constant( np.random.rand(*shape), dtype=dtypes_lib.float32) diag_shape = shape[:-2] + (min(shape[-2:]),) x_diag = constant_op.constant( np.random.rand(*diag_shape), dtype=dtypes_lib.float32) y = array_ops.matrix_set_diag(x, x_diag) error_x = gradient_checker.compute_gradient_error( x, x.get_shape().as_list(), y, y.get_shape().as_list()) self.assertLess(error_x, 1e-4) error_x_diag = gradient_checker.compute_gradient_error( x_diag, x_diag.get_shape().as_list(), y, y.get_shape().as_list()) self.assertLess(error_x_diag, 1e-4) def testGradWithNoShapeInformation(self): with self.test_session(use_gpu=True) as sess: v = array_ops.placeholder(dtype=dtypes_lib.float32) mat = array_ops.placeholder(dtype=dtypes_lib.float32) grad_input = array_ops.placeholder(dtype=dtypes_lib.float32) output = array_ops.matrix_set_diag(mat, v) grads = gradients_impl.gradients(output, [mat, v], grad_ys=grad_input) grad_input_val = np.random.rand(3, 3).astype(np.float32) grad_vals = sess.run(grads, feed_dict={ v: 2 * np.ones(3), mat: np.ones((3, 3)), grad_input: grad_input_val }) self.assertAllEqual(np.diag(grad_input_val), grad_vals[1]) self.assertAllEqual(grad_input_val - np.diag(np.diag(grad_input_val)), grad_vals[0]) class MatrixDiagPartTest(test.TestCase): def testSquare(self): with self.test_session(use_gpu=True): v = np.array([1.0, 2.0, 3.0]) mat = np.diag(v) mat_diag = array_ops.matrix_diag_part(mat) self.assertEqual((3,), mat_diag.get_shape()) self.assertAllEqual(mat_diag.eval(), v) def testRectangular(self): with self.test_session(use_gpu=True): mat = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) mat_diag = array_ops.matrix_diag_part(mat) self.assertAllEqual(mat_diag.eval(), np.array([1.0, 5.0])) mat = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) mat_diag = array_ops.matrix_diag_part(mat) self.assertAllEqual(mat_diag.eval(), np.array([1.0, 4.0])) def _testSquareBatch(self, dtype): with self.test_session(use_gpu=True): v_batch = np.array([[1.0, 0.0, 3.0], [4.0, 5.0, 6.0]]).astype(dtype) mat_batch = np.array([[[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 3.0]], [[4.0, 0.0, 0.0], [0.0, 5.0, 0.0], [0.0, 0.0, 6.0]]]).astype(dtype) self.assertEqual(mat_batch.shape, (2, 3, 3)) mat_batch_diag = array_ops.matrix_diag_part(mat_batch) self.assertEqual((2, 3), mat_batch_diag.get_shape()) self.assertAllEqual(mat_batch_diag.eval(), v_batch) def testSquareBatch(self): self._testSquareBatch(np.float32) self._testSquareBatch(np.float64) self._testSquareBatch(np.int32) self._testSquareBatch(np.int64) self._testSquareBatch(np.bool) def testRectangularBatch(self): with self.test_session(use_gpu=True): v_batch = np.array([[1.0, 2.0], [4.0, 5.0]]) mat_batch = np.array( [[[1.0, 0.0, 0.0], [0.0, 2.0, 0.0]], [[4.0, 0.0, 0.0], [0.0, 5.0, 0.0]]]) self.assertEqual(mat_batch.shape, (2, 2, 3)) mat_batch_diag = array_ops.matrix_diag_part(mat_batch) self.assertEqual((2, 2), mat_batch_diag.get_shape()) self.assertAllEqual(mat_batch_diag.eval(), v_batch) def testInvalidShape(self): with self.assertRaisesRegexp(ValueError, "must be at least rank 2"): array_ops.matrix_diag_part(0) def testInvalidShapeAtEval(self): with self.test_session(use_gpu=True): v = array_ops.placeholder(dtype=dtypes_lib.float32) with self.assertRaisesOpError("input must be at least 2-dim"): array_ops.matrix_diag_part(v).eval(feed_dict={v: 0.0}) def testGrad(self): shapes = ((3, 3), (2, 3), (3, 2), (5, 3, 3)) with self.test_session(use_gpu=True): for shape in shapes: x = constant_op.constant(np.random.rand(*shape), dtype=np.float32) y = array_ops.matrix_diag_part(x) error = gradient_checker.compute_gradient_error(x, x.get_shape().as_list(), y, y.get_shape().as_list()) self.assertLess(error, 1e-4) class DiagTest(test.TestCase): def diagOp(self, diag, dtype, expected_ans, use_gpu=False): with self.test_session(use_gpu=use_gpu): tf_ans = array_ops.diag(ops.convert_to_tensor(diag.astype(dtype))) out = tf_ans.eval() tf_ans_inv = array_ops.diag_part(expected_ans) inv_out = tf_ans_inv.eval() self.assertAllClose(out, expected_ans) self.assertAllClose(inv_out, diag) self.assertShapeEqual(expected_ans, tf_ans) self.assertShapeEqual(diag, tf_ans_inv) def testEmptyTensor(self): x = np.array([]) expected_ans = np.empty([0, 0]) self.diagOp(x, np.int32, expected_ans) def testRankOneIntTensor(self): x = np.array([1, 2, 3]) expected_ans = np.array( [[1, 0, 0], [0, 2, 0], [0, 0, 3]]) self.diagOp(x, np.int32, expected_ans) self.diagOp(x, np.int64, expected_ans) def testRankOneFloatTensor(self): x = np.array([1.1, 2.2, 3.3]) expected_ans = np.array( [[1.1, 0, 0], [0, 2.2, 0], [0, 0, 3.3]]) self.diagOp(x, np.float32, expected_ans) self.diagOp(x, np.float64, expected_ans) def testRankOneComplexTensor(self): for dtype in [np.complex64, np.complex128]: x = np.array([1.1 + 1.1j, 2.2 + 2.2j, 3.3 + 3.3j], dtype=dtype) expected_ans = np.array( [[1.1 + 1.1j, 0 + 0j, 0 + 0j], [0 + 0j, 2.2 + 2.2j, 0 + 0j], [0 + 0j, 0 + 0j, 3.3 + 3.3j]], dtype=dtype) self.diagOp(x, dtype, expected_ans) def testRankTwoIntTensor(self): x = np.array([[1, 2, 3], [4, 5, 6]]) expected_ans = np.array( [[[[1, 0, 0], [0, 0, 0]], [[0, 2, 0], [0, 0, 0]], [[0, 0, 3], [0, 0, 0]]], [[[0, 0, 0], [4, 0, 0]], [[0, 0, 0], [0, 5, 0]], [[0, 0, 0], [0, 0, 6]]]]) self.diagOp(x, np.int32, expected_ans) self.diagOp(x, np.int64, expected_ans) def testRankTwoFloatTensor(self): x = np.array([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]]) expected_ans = np.array( [[[[1.1, 0, 0], [0, 0, 0]], [[0, 2.2, 0], [0, 0, 0]], [[0, 0, 3.3], [0, 0, 0]]], [[[0, 0, 0], [4.4, 0, 0]], [[0, 0, 0], [0, 5.5, 0]], [[0, 0, 0], [0, 0, 6.6]]]]) self.diagOp(x, np.float32, expected_ans) self.diagOp(x, np.float64, expected_ans) def testRankTwoComplexTensor(self): for dtype in [np.complex64, np.complex128]: x = np.array([[1.1 + 1.1j, 2.2 + 2.2j, 3.3 + 3.3j], [4.4 + 4.4j, 5.5 + 5.5j, 6.6 + 6.6j]], dtype=dtype) expected_ans = np.array( [[[[1.1 + 1.1j, 0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j, 0 + 0j]], [[0 + 0j, 2.2 + 2.2j, 0 + 0j], [0 + 0j, 0 + 0j, 0 + 0j]], [[0 + 0j, 0 + 0j, 3.3 + 3.3j], [0 + 0j, 0 + 0j, 0 + 0j]]], [[[0 + 0j, 0 + 0j, 0 + 0j], [4.4 + 4.4j, 0 + 0j, 0 + 0j]], [[0 + 0j, 0 + 0j, 0 + 0j], [0 + 0j, 5.5 + 5.5j, 0 + 0j]], [[0 + 0j, 0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j, 6.6 + 6.6j]]]], dtype=dtype) self.diagOp(x, dtype, expected_ans) def testRankThreeFloatTensor(self): x = np.array([[[1.1, 2.2], [3.3, 4.4]], [[5.5, 6.6], [7.7, 8.8]]]) expected_ans = np.array( [[[[[[1.1, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 2.2], [0, 0]], [[0, 0], [0, 0]]]], [[[[0, 0], [3.3, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 4.4]], [[0, 0], [0, 0]]]]], [[[[[0, 0], [0, 0]], [[5.5, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 6.6], [0, 0]]]], [[[[0, 0], [0, 0]], [[0, 0], [7.7, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 8.8]]]]]]) self.diagOp(x, np.float32, expected_ans) self.diagOp(x, np.float64, expected_ans) def testRankThreeComplexTensor(self): for dtype in [np.complex64, np.complex128]: x = np.array([[[1.1 + 1.1j, 2.2 + 2.2j], [3.3 + 3.3j, 4.4 + 4.4j]], [[5.5 + 5.5j, 6.6 + 6.6j], [7.7 + 7.7j, 8.8 + 8.8j]]], dtype=dtype) expected_ans = np.array( [[[[[[1.1 + 1.1j, 0 + 0j], [0 + 0j, 0 + 0j]], [[0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j]]], [[[0 + 0j, 2.2 + 2.2j], [0 + 0j, 0 + 0j]], [[0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j]]]], [[[[0 + 0j, 0 + 0j], [3.3 + 3.3j, 0 + 0j]], [[0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j]]], [[[0 + 0j, 0 + 0j], [0 + 0j, 4.4 + 4.4j]], [[0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j]]]]], [[[[[0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j]], [[5.5 + 5.5j, 0 + 0j], [0 + 0j, 0 + 0j]]], [[[0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j]], [[0 + 0j, 6.6 + 6.6j], [0 + 0j, 0 + 0j]]]], [[[[0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j]], [[0 + 0j, 0 + 0j], [7.7 + 7.7j, 0 + 0j]]], [[[0 + 0j, 0 + 0j], [0 + 0j, 0 + 0j]], [[0 + 0j, 0 + 0j], [0 + 0j, 8.8 + 8.8j]]]]]], dtype=dtype) self.diagOp(x, dtype, expected_ans) class DiagPartOpTest(test.TestCase): def setUp(self): np.random.seed(0) def diagPartOp(self, tensor, dtype, expected_ans, use_gpu=False): with self.test_session(use_gpu=use_gpu): tensor = ops.convert_to_tensor(tensor.astype(dtype)) tf_ans_inv = array_ops.diag_part(tensor) inv_out = tf_ans_inv.eval() self.assertAllClose(inv_out, expected_ans) self.assertShapeEqual(expected_ans, tf_ans_inv) def testRankTwoFloatTensor(self): x = np.random.rand(3, 3) i = np.arange(3) expected_ans = x[i, i] self.diagPartOp(x, np.float32, expected_ans) self.diagPartOp(x, np.float64, expected_ans) def testRankFourFloatTensorUnknownShape(self): x = np.random.rand(3, 3) i = np.arange(3) expected_ans = x[i, i] for shape in None, (None, 3), (3, None): with self.test_session(use_gpu=False): t = ops.convert_to_tensor(x.astype(np.float32)) t.set_shape(shape) tf_ans = array_ops.diag_part(t) out = tf_ans.eval() self.assertAllClose(out, expected_ans) self.assertShapeEqual(expected_ans, tf_ans) def testRankFourFloatTensor(self): x = np.random.rand(2, 3, 2, 3) i = np.arange(2)[:, None] j = np.arange(3) expected_ans = x[i, j, i, j] self.diagPartOp(x, np.float32, expected_ans) self.diagPartOp(x, np.float64, expected_ans) def testRankSixFloatTensor(self): x = np.random.rand(2, 2, 2, 2, 2, 2) i = np.arange(2)[:, None, None] j = np.arange(2)[:, None] k = np.arange(2) expected_ans = x[i, j, k, i, j, k] self.diagPartOp(x, np.float32, expected_ans) self.diagPartOp(x, np.float64, expected_ans) def testOddRank(self): w = np.random.rand(2) x = np.random.rand(2, 2, 2) self.assertRaises(ValueError, self.diagPartOp, w, np.float32, 0) self.assertRaises(ValueError, self.diagPartOp, x, np.float32, 0) def testUnevenDimensions(self): w = np.random.rand(2, 5) x = np.random.rand(2, 1, 2, 3) self.assertRaises(ValueError, self.diagPartOp, w, np.float32, 0) self.assertRaises(ValueError, self.diagPartOp, x, np.float32, 0) class DiagGradOpTest(test.TestCase): def testDiagGrad(self): np.random.seed(0) shapes = ((3,), (3, 3), (3, 3, 3)) dtypes = (dtypes_lib.float32, dtypes_lib.float64) with self.test_session(use_gpu=False): errors = [] for shape in shapes: for dtype in dtypes: x1 = constant_op.constant(np.random.rand(*shape), dtype=dtype) y = array_ops.diag(x1) error = gradient_checker.compute_gradient_error( x1, x1.get_shape().as_list(), y, y.get_shape().as_list()) tf_logging.info("error = %f", error) self.assertLess(error, 1e-4) class DiagGradPartOpTest(test.TestCase): def testDiagPartGrad(self): np.random.seed(0) shapes = ((3, 3), (3, 3, 3, 3)) dtypes = (dtypes_lib.float32, dtypes_lib.float64) with self.test_session(use_gpu=False): errors = [] for shape in shapes: for dtype in dtypes: x1 = constant_op.constant(np.random.rand(*shape), dtype=dtype) y = array_ops.diag_part(x1) error = gradient_checker.compute_gradient_error( x1, x1.get_shape().as_list(), y, y.get_shape().as_list()) tf_logging.info("error = %f", error) self.assertLess(error, 1e-4) if __name__ == "__main__": test.main() # coding: utf-8 # # Copyright 2014 The Oppia Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, softwar # distributed under the License is distributed on an "AS-IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for classification of 2D coordinates.""" __author__ = 'Sean Lip' from extensions.rules import coord_two_dim import test_utils class CoordTwoDimRuleUnitTests(test_utils.GenericTestBase): """Tests for rules operating on CoordTwoDim objects.""" def test_within_rule(self): self.assertFalse(coord_two_dim.Within(10, [10, 10]).eval([0, 0])) self.assertTrue(coord_two_dim.Within(20, [10, 10]).eval([0, 0])) self.assertFalse(coord_two_dim.Within(10, [5, 10]).eval([-5, 0])) self.assertTrue(coord_two_dim.Within(20, [5, 10]).eval([-5, 0])) def test_not_within_rule(self): self.assertTrue(coord_two_dim.NotWithin(10, [10, 10]).eval([0, 0])) self.assertFalse(coord_two_dim.NotWithin(20, [10, 10]).eval([0, 0])) self.assertTrue(coord_two_dim.NotWithin(10, [5, 10]).eval([-5, 0])) self.assertFalse(coord_two_dim.NotWithin(20, [5, 10]).eval([-5, 0])) import threading from django.contrib.gis.geos.libgeos import lgeos, notice_h, error_h, CONTEXT_PTR class GEOSContextHandle(object): """ Python object representing a GEOS context handle. """ def __init__(self): # Initializing the context handler for this thread with # the notice and error handler. self.ptr = lgeos.initGEOS_r(notice_h, error_h) def __del__(self): if self.ptr: lgeos.finishGEOS_r(self.ptr) # Defining a thread-local object and creating an instance # to hold a reference to GEOSContextHandle for this thread. class GEOSContext(threading.local): handle = None thread_context = GEOSContext() class GEOSFunc(object): """ Class that serves as a wrapper for GEOS C Functions, and will use thread-safe function variants when available. """ def __init__(self, func_name): try: # GEOS thread-safe function signatures end with '_r', and # take an additional context handle parameter. self.cfunc = getattr(lgeos, func_name + '_r') self.threaded = True # Create a reference here to thread_context so it's not # garbage-collected before an attempt to call this object. self.thread_context = thread_context except AttributeError: # Otherwise, use usual function. self.cfunc = getattr(lgeos, func_name) self.threaded = False def __call__(self, *args): if self.threaded: # If a context handle does not exist for this thread, initialize one. if not self.thread_context.handle: self.thread_context.handle = GEOSContextHandle() # Call the threaded GEOS routine with pointer of the context handle # as the first argument. return self.cfunc(self.thread_context.handle.ptr, *args) else: return self.cfunc(*args) def __str__(self): return self.cfunc.__name__ # argtypes property def _get_argtypes(self): return self.cfunc.argtypes def _set_argtypes(self, argtypes): if self.threaded: new_argtypes = [CONTEXT_PTR] new_argtypes.extend(argtypes) self.cfunc.argtypes = new_argtypes else: self.cfunc.argtypes = argtypes argtypes = property(_get_argtypes, _set_argtypes) # restype property def _get_restype(self): return self.cfunc.restype def _set_restype(self, restype): self.cfunc.restype = restype restype = property(_get_restype, _set_restype) # errcheck property def _get_errcheck(self): return self.cfunc.errcheck def _set_errcheck(self, errcheck): self.cfunc.errcheck = errcheck errcheck = property(_get_errcheck, _set_errcheck) #!/usr/bin/python """ Copyright 2008 (c) Frederic Weisbecker Licensed under the terms of the GNU GPL License version 2 This script parses a trace provided by the function tracer in kernel/trace/trace_functions.c The resulted trace is processed into a tree to produce a more human view of the call stack by drawing textual but hierarchical tree of calls. Only the functions's names and the the call time are provided. Usage: Be sure that you have CONFIG_FUNCTION_TRACER # mount -t debugfs nodev /sys/kernel/debug # echo function > /sys/kernel/debug/tracing/current_tracer $ cat /sys/kernel/debug/tracing/trace_pipe > ~/raw_trace_func Wait some times but not too much, the script is a bit slow. Break the pipe (Ctrl + Z) $ scripts/draw_functrace.py < raw_trace_func > draw_functrace Then you have your drawn trace in draw_functrace """ import sys, re class CallTree: """ This class provides a tree representation of the functions call stack. If a function has no parent in the kernel (interrupt, syscall, kernel thread...) then it is attached to a virtual parent called ROOT. """ ROOT = None def __init__(self, func, time = None, parent = None): self._func = func self._time = time if parent is None: self._parent = CallTree.ROOT else: self._parent = parent self._children = [] def calls(self, func, calltime): """ If a function calls another one, call this method to insert it into the tree at the appropriate place. @return: A reference to the newly created child node. """ child = CallTree(func, calltime, self) self._children.append(child) return child def getParent(self, func): """ Retrieve the last parent of the current node that has the name given by func. If this function is not on a parent, then create it as new child of root @return: A reference to the parent. """ tree = self while tree != CallTree.ROOT and tree._func != func: tree = tree._parent if tree == CallTree.ROOT: child = CallTree.ROOT.calls(func, None) return child return tree def __repr__(self): return self.__toString("", True) def __toString(self, branch, lastChild): if self._time is not None: s = "%s----%s (%s)\n" % (branch, self._func, self._time) else: s = "%s----%s\n" % (branch, self._func) i = 0 if lastChild: branch = branch[:-1] + " " while i < len(self._children): if i != len(self._children) - 1: s += "%s" % self._children[i].__toString(branch +\ " |", False) else: s += "%s" % self._children[i].__toString(branch +\ " |", True) i += 1 return s class BrokenLineException(Exception): """If the last line is not complete because of the pipe breakage, we want to stop the processing and ignore this line. """ pass class CommentLineException(Exception): """ If the line is a comment (as in the beginning of the trace file), just ignore it. """ pass def parseLine(line): line = line.strip() if line.startswith("#"): raise CommentLineException m = re.match("[^]]+?\\] +([0-9.]+): (\\w+) <-(\\w+)", line) if m is None: raise BrokenLineException return (m.group(1), m.group(2), m.group(3)) def main(): CallTree.ROOT = CallTree("Root (Nowhere)", None, None) tree = CallTree.ROOT for line in sys.stdin: try: calltime, callee, caller = parseLine(line) except BrokenLineException: break except CommentLineException: continue tree = tree.getParent(caller) tree = tree.calls(callee, calltime) print CallTree.ROOT if __name__ == "__main__": main() # As a test suite for the os module, this is woefully inadequate, but this # does add tests for a few functions which have been determined to be more # portable than they had been thought to be. import os import unittest import warnings import sys from test import test_support warnings.filterwarnings("ignore", "tempnam", RuntimeWarning, __name__) warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning, __name__) # Tests creating TESTFN class FileTests(unittest.TestCase): def setUp(self): if os.path.exists(test_support.TESTFN): os.unlink(test_support.TESTFN) tearDown = setUp def test_access(self): f = os.open(test_support.TESTFN, os.O_CREAT|os.O_RDWR) os.close(f) self.assert_(os.access(test_support.TESTFN, os.W_OK)) def test_closerange(self): first = os.open(test_support.TESTFN, os.O_CREAT|os.O_RDWR) # We must allocate two consecutive file descriptors, otherwise # it will mess up other file descriptors (perhaps even the three # standard ones). second = os.dup(first) try: retries = 0 while second != first + 1: os.close(first) retries += 1 if retries > 10: # XXX test skipped print >> sys.stderr, ( "couldn't allocate two consecutive fds, " "skipping test_closerange") return first, second = second, os.dup(second) finally: os.close(second) # close a fd that is open, and one that isn't os.closerange(first, first + 2) self.assertRaises(OSError, os.write, first, "a") def test_rename(self): path = unicode(test_support.TESTFN) old = sys.getrefcount(path) self.assertRaises(TypeError, os.rename, path, 0) new = sys.getrefcount(path) self.assertEqual(old, new) class TemporaryFileTests(unittest.TestCase): def setUp(self): self.files = [] os.mkdir(test_support.TESTFN) def tearDown(self): for name in self.files: os.unlink(name) os.rmdir(test_support.TESTFN) def check_tempfile(self, name): # make sure it doesn't already exist: self.failIf(os.path.exists(name), "file already exists for temporary file") # make sure we can create the file open(name, "w") self.files.append(name) def test_tempnam(self): if not hasattr(os, "tempnam"): return warnings.filterwarnings("ignore", "tempnam", RuntimeWarning, r"test_os$") self.check_tempfile(os.tempnam()) name = os.tempnam(test_support.TESTFN) self.check_tempfile(name) name = os.tempnam(test_support.TESTFN, "pfx") self.assert_(os.path.basename(name)[:3] == "pfx") self.check_tempfile(name) def test_tmpfile(self): if not hasattr(os, "tmpfile"): return # As with test_tmpnam() below, the Windows implementation of tmpfile() # attempts to create a file in the root directory of the current drive. # On Vista and Server 2008, this test will always fail for normal users # as writing to the root directory requires elevated privileges. With # XP and below, the semantics of tmpfile() are the same, but the user # running the test is more likely to have administrative privileges on # their account already. If that's the case, then os.tmpfile() should # work. In order to make this test as useful as possible, rather than # trying to detect Windows versions or whether or not the user has the # right permissions, just try and create a file in the root directory # and see if it raises a 'Permission denied' OSError. If it does, then # test that a subsequent call to os.tmpfile() raises the same error. If # it doesn't, assume we're on XP or below and the user running the test # has administrative privileges, and proceed with the test as normal. if sys.platform == 'win32': name = '\\python_test_os_test_tmpfile.txt' if os.path.exists(name): os.remove(name) try: fp = open(name, 'w') except IOError, first: # open() failed, assert tmpfile() fails in the same way. # Although open() raises an IOError and os.tmpfile() raises an # OSError(), 'args' will be (13, 'Permission denied') in both # cases. try: fp = os.tmpfile() except OSError, second: self.assertEqual(first.args, second.args) else: self.fail("expected os.tmpfile() to raise OSError") return else: # open() worked, therefore, tmpfile() should work. Close our # dummy file and proceed with the test as normal. fp.close() os.remove(name) fp = os.tmpfile() fp.write("foobar") fp.seek(0,0) s = fp.read() fp.close() self.assert_(s == "foobar") def test_tmpnam(self): import sys if not hasattr(os, "tmpnam"): return warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning, r"test_os$") name = os.tmpnam() if sys.platform in ("win32",): # The Windows tmpnam() seems useless. From the MS docs: # # The character string that tmpnam creates consists of # the path prefix, defined by the entry P_tmpdir in the # file STDIO.H, followed by a sequence consisting of the # digit characters '0' through '9'; the numerical value # of this string is in the range 1 - 65,535. Changing the # definitions of L_tmpnam or P_tmpdir in STDIO.H does not # change the operation of tmpnam. # # The really bizarre part is that, at least under MSVC6, # P_tmpdir is "\\". That is, the path returned refers to # the root of the current drive. That's a terrible place to # put temp files, and, depending on privileges, the user # may not even be able to open a file in the root directory. self.failIf(os.path.exists(name), "file already exists for temporary file") else: self.check_tempfile(name) # Test attributes on return values from os.*stat* family. class StatAttributeTests(unittest.TestCase): def setUp(self): os.mkdir(test_support.TESTFN) self.fname = os.path.join(test_support.TESTFN, "f1") f = open(self.fname, 'wb') f.write("ABC") f.close() def tearDown(self): os.unlink(self.fname) os.rmdir(test_support.TESTFN) def test_stat_attributes(self): if not hasattr(os, "stat"): return import stat result = os.stat(self.fname) # Make sure direct access works self.assertEquals(result[stat.ST_SIZE], 3) self.assertEquals(result.st_size, 3) import sys # Make sure all the attributes are there members = dir(result) for name in dir(stat): if name[:3] == 'ST_': attr = name.lower() if name.endswith("TIME"): def trunc(x): return int(x) else: def trunc(x): return x self.assertEquals(trunc(getattr(result, attr)), result[getattr(stat, name)]) self.assert_(attr in members) try: result[200] self.fail("No exception thrown") except IndexError: pass # Make sure that assignment fails try: result.st_mode = 1 self.fail("No exception thrown") except TypeError: pass try: result.st_rdev = 1 self.fail("No exception thrown") except (AttributeError, TypeError): pass try: result.parrot = 1 self.fail("No exception thrown") except AttributeError: pass # Use the stat_result constructor with a too-short tuple. try: result2 = os.stat_result((10,)) self.fail("No exception thrown") except TypeError: pass # Use the constructr with a too-long tuple. try: result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14)) except TypeError: pass def test_statvfs_attributes(self): if not hasattr(os, "statvfs"): return try: result = os.statvfs(self.fname) except OSError, e: # On AtheOS, glibc always returns ENOSYS import errno if e.errno == errno.ENOSYS: return # Make sure direct access works self.assertEquals(result.f_bfree, result[3]) # Make sure all the attributes are there. members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files', 'ffree', 'favail', 'flag', 'namemax') for value, member in enumerate(members): self.assertEquals(getattr(result, 'f_' + member), result[value]) # Make sure that assignment really fails try: result.f_bfree = 1 self.fail("No exception thrown") except TypeError: pass try: result.parrot = 1 self.fail("No exception thrown") except AttributeError: pass # Use the constructor with a too-short tuple. try: result2 = os.statvfs_result((10,)) self.fail("No exception thrown") except TypeError: pass # Use the constructr with a too-long tuple. try: result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14)) except TypeError: pass def test_utime_dir(self): delta = 1000000 st = os.stat(test_support.TESTFN) # round to int, because some systems may support sub-second # time stamps in stat, but not in utime. os.utime(test_support.TESTFN, (st.st_atime, int(st.st_mtime-delta))) st2 = os.stat(test_support.TESTFN) self.assertEquals(st2.st_mtime, int(st.st_mtime-delta)) # Restrict test to Win32, since there is no guarantee other # systems support centiseconds if sys.platform == 'win32': def get_file_system(path): root = os.path.splitdrive(os.path.abspath(path))[0] + '\\' import ctypes kernel32 = ctypes.windll.kernel32 buf = ctypes.create_string_buffer("", 100) if kernel32.GetVolumeInformationA(root, None, 0, None, None, None, buf, len(buf)): return buf.value if get_file_system(test_support.TESTFN) == "NTFS": def test_1565150(self): t1 = 1159195039.25 os.utime(self.fname, (t1, t1)) self.assertEquals(os.stat(self.fname).st_mtime, t1) def test_1686475(self): # Verify that an open file can be stat'ed try: os.stat(r"c:\pagefile.sys") except WindowsError, e: if e.errno == 2: # file does not exist; cannot run test return self.fail("Could not stat pagefile.sys") from test import mapping_tests class EnvironTests(mapping_tests.BasicTestMappingProtocol): """check that os.environ object conform to mapping protocol""" type2test = None def _reference(self): return {"KEY1":"VALUE1", "KEY2":"VALUE2", "KEY3":"VALUE3"} def _empty_mapping(self): os.environ.clear() return os.environ def setUp(self): self.__save = dict(os.environ) os.environ.clear() def tearDown(self): os.environ.clear() os.environ.update(self.__save) # Bug 1110478 def test_update2(self): if os.path.exists("/bin/sh"): os.environ.update(HELLO="World") value = os.popen("/bin/sh -c 'echo $HELLO'").read().strip() self.assertEquals(value, "World") class WalkTests(unittest.TestCase): """Tests for os.walk().""" def test_traversal(self): import os from os.path import join # Build: # TESTFN/ # TEST1/ a file kid and two directory kids # tmp1 # SUB1/ a file kid and a directory kid # tmp2 # SUB11/ no kids # SUB2/ a file kid and a dirsymlink kid # tmp3 # link/ a symlink to TESTFN.2 # TEST2/ # tmp4 a lone file walk_path = join(test_support.TESTFN, "TEST1") sub1_path = join(walk_path, "SUB1") sub11_path = join(sub1_path, "SUB11") sub2_path = join(walk_path, "SUB2") tmp1_path = join(walk_path, "tmp1") tmp2_path = join(sub1_path, "tmp2") tmp3_path = join(sub2_path, "tmp3") link_path = join(sub2_path, "link") t2_path = join(test_support.TESTFN, "TEST2") tmp4_path = join(test_support.TESTFN, "TEST2", "tmp4") # Create stuff. os.makedirs(sub11_path) os.makedirs(sub2_path) os.makedirs(t2_path) for path in tmp1_path, tmp2_path, tmp3_path, tmp4_path: f = file(path, "w") f.write("I'm " + path + " and proud of it. Blame test_os.\n") f.close() if hasattr(os, "symlink"): os.symlink(os.path.abspath(t2_path), link_path) sub2_tree = (sub2_path, ["link"], ["tmp3"]) else: sub2_tree = (sub2_path, [], ["tmp3"]) # Walk top-down. all = list(os.walk(walk_path)) self.assertEqual(len(all), 4) # We can't know which order SUB1 and SUB2 will appear in. # Not flipped: TESTFN, SUB1, SUB11, SUB2 # flipped: TESTFN, SUB2, SUB1, SUB11 flipped = all[0][1][0] != "SUB1" all[0][1].sort() self.assertEqual(all[0], (walk_path, ["SUB1", "SUB2"], ["tmp1"])) self.assertEqual(all[1 + flipped], (sub1_path, ["SUB11"], ["tmp2"])) self.assertEqual(all[2 + flipped], (sub11_path, [], [])) self.assertEqual(all[3 - 2 * flipped], sub2_tree) # Prune the search. all = [] for root, dirs, files in os.walk(walk_path): all.append((root, dirs, files)) # Don't descend into SUB1. if 'SUB1' in dirs: # Note that this also mutates the dirs we appended to all! dirs.remove('SUB1') self.assertEqual(len(all), 2) self.assertEqual(all[0], (walk_path, ["SUB2"], ["tmp1"])) self.assertEqual(all[1], sub2_tree) # Walk bottom-up. all = list(os.walk(walk_path, topdown=False)) self.assertEqual(len(all), 4) # We can't know which order SUB1 and SUB2 will appear in. # Not flipped: SUB11, SUB1, SUB2, TESTFN # flipped: SUB2, SUB11, SUB1, TESTFN flipped = all[3][1][0] != "SUB1" all[3][1].sort() self.assertEqual(all[3], (walk_path, ["SUB1", "SUB2"], ["tmp1"])) self.assertEqual(all[flipped], (sub11_path, [], [])) self.assertEqual(all[flipped + 1], (sub1_path, ["SUB11"], ["tmp2"])) self.assertEqual(all[2 - 2 * flipped], sub2_tree) if hasattr(os, "symlink"): # Walk, following symlinks. for root, dirs, files in os.walk(walk_path, followlinks=True): if root == link_path: self.assertEqual(dirs, []) self.assertEqual(files, ["tmp4"]) break else: self.fail("Didn't follow symlink with followlinks=True") def tearDown(self): # Tear everything down. This is a decent use for bottom-up on # Windows, which doesn't have a recursive delete command. The # (not so) subtlety is that rmdir will fail unless the dir's # kids are removed first, so bottom up is essential. for root, dirs, files in os.walk(test_support.TESTFN, topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: dirname = os.path.join(root, name) if not os.path.islink(dirname): os.rmdir(dirname) else: os.remove(dirname) os.rmdir(test_support.TESTFN) class MakedirTests (unittest.TestCase): def setUp(self): os.mkdir(test_support.TESTFN) def test_makedir(self): base = test_support.TESTFN path = os.path.join(base, 'dir1', 'dir2', 'dir3') os.makedirs(path) # Should work path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4') os.makedirs(path) # Try paths with a '.' in them self.failUnlessRaises(OSError, os.makedirs, os.curdir) path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4', 'dir5', os.curdir) os.makedirs(path) path = os.path.join(base, 'dir1', os.curdir, 'dir2', 'dir3', 'dir4', 'dir5', 'dir6') os.makedirs(path) def tearDown(self): path = os.path.join(test_support.TESTFN, 'dir1', 'dir2', 'dir3', 'dir4', 'dir5', 'dir6') # If the tests failed, the bottom-most directory ('../dir6') # may not have been created, so we look for the outermost directory # that exists. while not os.path.exists(path) and path != test_support.TESTFN: path = os.path.dirname(path) os.removedirs(path) class DevNullTests (unittest.TestCase): def test_devnull(self): f = file(os.devnull, 'w') f.write('hello') f.close() f = file(os.devnull, 'r') self.assertEqual(f.read(), '') f.close() class URandomTests (unittest.TestCase): def test_urandom(self): try: self.assertEqual(len(os.urandom(1)), 1) self.assertEqual(len(os.urandom(10)), 10) self.assertEqual(len(os.urandom(100)), 100) self.assertEqual(len(os.urandom(1000)), 1000) # see http://bugs.python.org/issue3708 self.assertEqual(len(os.urandom(0.9)), 0) self.assertEqual(len(os.urandom(1.1)), 1) self.assertEqual(len(os.urandom(2.0)), 2) except NotImplementedError: pass class Win32ErrorTests(unittest.TestCase): def test_rename(self): self.assertRaises(WindowsError, os.rename, test_support.TESTFN, test_support.TESTFN+".bak") def test_remove(self): self.assertRaises(WindowsError, os.remove, test_support.TESTFN) def test_chdir(self): self.assertRaises(WindowsError, os.chdir, test_support.TESTFN) def test_mkdir(self): self.assertRaises(WindowsError, os.chdir, test_support.TESTFN) def test_utime(self): self.assertRaises(WindowsError, os.utime, test_support.TESTFN, None) def test_access(self): self.assertRaises(WindowsError, os.utime, test_support.TESTFN, 0) def test_chmod(self): self.assertRaises(WindowsError, os.utime, test_support.TESTFN, 0) class TestInvalidFD(unittest.TestCase): singles = ["fchdir", "fdopen", "dup", "fdatasync", "fstat", "fstatvfs", "fsync", "tcgetpgrp", "ttyname"] #singles.append("close") #We omit close because it doesn'r raise an exception on some platforms def get_single(f): def helper(self): if hasattr(os, f): self.check(getattr(os, f)) return helper for f in singles: locals()["test_"+f] = get_single(f) def check(self, f, *args): self.assertRaises(OSError, f, test_support.make_bad_fd(), *args) def test_isatty(self): if hasattr(os, "isatty"): self.assertEqual(os.isatty(test_support.make_bad_fd()), False) def test_closerange(self): if hasattr(os, "closerange"): fd = test_support.make_bad_fd() self.assertEqual(os.closerange(fd, fd + 10), None) def test_dup2(self): if hasattr(os, "dup2"): self.check(os.dup2, 20) def test_fchmod(self): if hasattr(os, "fchmod"): self.check(os.fchmod, 0) def test_fchown(self): if hasattr(os, "fchown"): self.check(os.fchown, -1, -1) def test_fpathconf(self): if hasattr(os, "fpathconf"): self.check(os.fpathconf, "PC_NAME_MAX") #this is a weird one, it raises IOError unlike the others def test_ftruncate(self): if hasattr(os, "ftruncate"): self.assertRaises(IOError, os.ftruncate, test_support.make_bad_fd(), 0) def test_lseek(self): if hasattr(os, "lseek"): self.check(os.lseek, 0, 0) def test_read(self): if hasattr(os, "read"): self.check(os.read, 1) def test_tcsetpgrpt(self): if hasattr(os, "tcsetpgrp"): self.check(os.tcsetpgrp, 0) def test_write(self): if hasattr(os, "write"): self.check(os.write, " ") if sys.platform != 'win32': class Win32ErrorTests(unittest.TestCase): pass class PosixUidGidTests(unittest.TestCase): if hasattr(os, 'setuid'): def test_setuid(self): if os.getuid() != 0: self.assertRaises(os.error, os.setuid, 0) self.assertRaises(OverflowError, os.setuid, 1<<32) if hasattr(os, 'setgid'): def test_setgid(self): if os.getuid() != 0: self.assertRaises(os.error, os.setgid, 0) self.assertRaises(OverflowError, os.setgid, 1<<32) if hasattr(os, 'seteuid'): def test_seteuid(self): if os.getuid() != 0: self.assertRaises(os.error, os.seteuid, 0) self.assertRaises(OverflowError, os.seteuid, 1<<32) if hasattr(os, 'setegid'): def test_setegid(self): if os.getuid() != 0: self.assertRaises(os.error, os.setegid, 0) self.assertRaises(OverflowError, os.setegid, 1<<32) if hasattr(os, 'setreuid'): def test_setreuid(self): if os.getuid() != 0: self.assertRaises(os.error, os.setreuid, 0, 0) self.assertRaises(OverflowError, os.setreuid, 1<<32, 0) self.assertRaises(OverflowError, os.setreuid, 0, 1<<32) if hasattr(os, 'setregid'): def test_setregid(self): if os.getuid() != 0: self.assertRaises(os.error, os.setregid, 0, 0) self.assertRaises(OverflowError, os.setregid, 1<<32, 0) self.assertRaises(OverflowError, os.setregid, 0, 1<<32) else: class PosixUidGidTests(unittest.TestCase): pass def test_main(): test_support.run_unittest( FileTests, TemporaryFileTests, StatAttributeTests, EnvironTests, WalkTests, MakedirTests, DevNullTests, URandomTests, Win32ErrorTests, TestInvalidFD, PosixUidGidTests ) if __name__ == "__main__": test_main() #!/usr/bin/env python # -*- coding: utf-8 -*- TARGETS = [ 'AjaxTest.py', ] PACKAGE = { 'title': 'Ajaxlib Test', 'desc': 'Experimental Dynamic Module loading of a Javascript Module', } def setup(targets): '''Setup example for translation, MUST call util.setup(targets).''' util.setup(targets) def translate(): '''Translate example, MUST call util.translate().''' util.translate() def install(package): '''Install and cleanup example module. MUST call util.install(package)''' util.install(package) ##---------------------------------------## # --------- (-: DO NOT EDIT :-) --------- # ##---------------------------------------## import sys import os examples = head = os.path.abspath(os.path.dirname(__file__)) while os.path.split(examples)[1].lower() != 'examples': examples = os.path.split(examples)[0] if not examples: raise ValueError("Cannot determine examples directory") sys.path.insert(0, os.path.join(examples)) from _examples import util sys.path.pop(0) util.init(head) setup(TARGETS) translate() install(PACKAGE) """ PingThread.py Thread that pings the target server """ # Imports import NetworkMonitor import re import ThreadBase import time import subprocess class PingThread(ThreadBase.ThreadBase): def __init__(self, platform, targetServer, interval, logFile, outputFile): """Constructor""" # Initialize variables super(PingThread, self).__init__("Ping", interval, logFile, outputFile) self.platform = platform self.targetServer = targetServer self.outputFile.SetFileHeader("Packets sent\tPackets received\tMinimum (ms)\tAverage (ms)\tMaximum (ms)\tStdev (ms)\tTotal time(s)") if self.platform == NetworkMonitor.PLATFORM_LINUX: # Ping output lines of interest look like the following on Ubuntu: # 4 packets transmitted, 4 received, 0% packet loss, time 3004ms # rtt min/avg/max/mdev = 47.014/51.046/62.049/6.368 ms self.command = "ping -c 4 -q %s" % self.targetServer self.regEx1 = re.compile("([0-9]+) packets transmitted, ([0-9]+) received, ([0-9.]+)% packet loss, time ([0-9]+)ms") self.regEx1Groups = 4 self.regEx2 = re.compile("rtt min/avg/max/mdev = ([0-9.]+)/([0-9.]+)/([0-9.]+)/([0-9.]+) ms") self.regEx2Groups = 4 elif self.platform == NetworkMonitor.PLATFORM_MACOS: # Ping output lines of interest look like the following on Mac OS: # 4 packets transmitted, 4 packets received, 0.0% packet loss # round-trip min/avg/max/stddev = 47.399/48.315/50.227/1.117 ms self.command = "ping -c 4 -q %s" % self.targetServer self.regEx1 = re.compile("([0-9]+) packets transmitted, ([0-9]+) packets received, ([0-9.]+)% packet loss") self.regEx1Groups = 3 self.regEx2 = re.compile("round-trip min/avg/max/stddev = ([0-9.]+)/([0-9.]+)/([0-9.]+)/([0-9.]+) ms") self.regEx2Groups = 4 elif self.platform == NetworkMonitor.PLATFORM_WINDOWS: # Ping output lines of interest look like the following on Windows: # Packets: Sent = 4, Received = 4, Lost = 0 (0% loss), # Minimum = 45ms, Maximum = 58ms, Average = 49ms self.command = "ping -n 4 %s" % self.targetServer self.regEx1 = re.compile("Packets: Sent = ([0-9]+), Received = ([0-9]+), Lost = ([0-9]+) \(([0-9.]+)% loss\),") self.regEx1Groups = 4 self.regEx2 = re.compile("Minimum = ([0-9.]+)ms, Maximum = ([0-9.]+)ms, Average = ([0-9.]+)ms") self.regEx2Groups = 3 else: raise Exception("Unknown platform: " + self.platform) def PingServer(self): """Pings the server four times and returns statistics""" # Create the process and read in the output lines proc = subprocess.Popen(self.command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) lines = proc.stdout.readlines() # Windows requires each line to be decoded if self.platform == NetworkMonitor.PLATFORM_WINDOWS: newLines = [] for line in lines: newLines.append(line.decode("utf-8")) lines = newLines # Wait until the process completes and parse the output proc.wait() packetsTransmitted = -1 packetsReceived = -1 min = -1 avg = -1 max = -1 stdev = -1 for line in lines: strippedLine = line.strip() result = self.regEx1.match(strippedLine) if (result is not None) and (result.lastindex >= self.regEx1Groups): packetsTransmitted = int(result.group(1)) packetsReceived = int(result.group(2)) result = self.regEx2.match(strippedLine) if (result is not None) and (result.lastindex >= self.regEx2Groups): min = float(result.group(1)) if self.platform != NetworkMonitor.PLATFORM_WINDOWS: avg = float(result.group(2)) max = float(result.group(3)) else: max = float(result.group(2)) avg = float(result.group(3)) if self.regEx2Groups == 4: stdev = float(result.group(4)) if packetsTransmitted == -1: # Failed to parse the output if proc.returncode != 0: error = "Ping command failed with the following output:\n" else: error = "Failed to parse ping output:\n" for line in lines: error += line self.logFile.Write(error) return (packetsTransmitted, packetsReceived, min, avg, max, stdev) def Capture(self): """Pings the server and writes the statistics as the next data point""" # Gather ping data startTime = time.time() pingPacketsTransmitted, pingPacketsReceived, pingMin, pingAverage, pingMax, pingStdev = self.PingServer() elapsedTime = time.time() - startTime # Write out the data point self.outputFile.Write("%i\t%i\t%0.3f\t%0.3f\t%0.3f\t%0.3f\t%0.2f" % (pingPacketsTransmitted, pingPacketsReceived, pingMin, pingAverage, pingMax, pingStdev, elapsedTime)) """ Support for Pilight sensors. For more details about this platform, please refer to the documentation at https://home-assistant.io/components/sensor.pilight/ """ import logging import voluptuous as vol from homeassistant.const import ( CONF_NAME, STATE_UNKNOWN, CONF_UNIT_OF_MEASUREMENT, CONF_PAYLOAD) from homeassistant.components.sensor import PLATFORM_SCHEMA from homeassistant.helpers.entity import Entity import homeassistant.components.pilight as pilight import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_VARIABLE = 'variable' DEFAULT_NAME = 'Pilight Sensor' DEPENDENCIES = ['pilight'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_VARIABLE): cv.string, vol.Required(CONF_PAYLOAD): vol.Schema(dict), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_UNIT_OF_MEASUREMENT, default=None): cv.string, }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Set up Pilight Sensor.""" add_devices([PilightSensor( hass=hass, name=config.get(CONF_NAME), variable=config.get(CONF_VARIABLE), payload=config.get(CONF_PAYLOAD), unit_of_measurement=config.get(CONF_UNIT_OF_MEASUREMENT) )]) class PilightSensor(Entity): """Representation of a sensor that can be updated using Pilight.""" def __init__(self, hass, name, variable, payload, unit_of_measurement): """Initialize the sensor.""" self._state = STATE_UNKNOWN self._hass = hass self._name = name self._variable = variable self._payload = payload self._unit_of_measurement = unit_of_measurement hass.bus.listen(pilight.EVENT, self._handle_code) @property def should_poll(self): """No polling needed.""" return False @property def name(self): """Return the name of the sensor.""" return self._name @property def unit_of_measurement(self): """Return the unit this state is expressed in.""" return self._unit_of_measurement @property def state(self): """Return the state of the entity.""" return self._state def _handle_code(self, call): """Handle received code by the pilight-daemon. If the code matches the defined playload of this sensor the sensor state is changed accordingly. """ # Check if received code matches defined playoad # True if payload is contained in received code dict, not # all items have to match if self._payload.items() <= call.data.items(): try: value = call.data[self._variable] self._state = value self.update_ha_state() except KeyError: _LOGGER.error( 'No variable %s in received code data %s', str(self._variable), str(call.data)) """Test inter-conversion of different polynomial classes. This tests the convert and cast methods of all the polynomial classes. """ from __future__ import division, absolute_import, print_function import operator as op from numbers import Number import numpy as np from numpy.polynomial import ( Polynomial, Legendre, Chebyshev, Laguerre, Hermite, HermiteE) from numpy.testing import ( assert_almost_equal, assert_raises, assert_equal, assert_, run_module_suite) from numpy.compat import long classes = ( Polynomial, Legendre, Chebyshev, Laguerre, Hermite, HermiteE) def test_class_methods(): for Poly1 in classes: for Poly2 in classes: yield check_conversion, Poly1, Poly2 yield check_cast, Poly1, Poly2 for Poly in classes: yield check_call, Poly yield check_identity, Poly yield check_basis, Poly yield check_fromroots, Poly yield check_fit, Poly yield check_equal, Poly yield check_not_equal, Poly yield check_add, Poly yield check_sub, Poly yield check_mul, Poly yield check_floordiv, Poly yield check_truediv, Poly yield check_mod, Poly yield check_divmod, Poly yield check_pow, Poly yield check_integ, Poly yield check_deriv, Poly yield check_roots, Poly yield check_linspace, Poly yield check_mapparms, Poly yield check_degree, Poly yield check_copy, Poly yield check_cutdeg, Poly yield check_truncate, Poly yield check_trim, Poly # # helper functions # random = np.random.random def assert_poly_almost_equal(p1, p2, msg=""): try: assert_(np.all(p1.domain == p2.domain)) assert_(np.all(p1.window == p2.window)) assert_almost_equal(p1.coef, p2.coef) except AssertionError: msg = "Result: %s\nTarget: %s", (p1, p2) raise AssertionError(msg) # # conversion methods that depend on two classes # def check_conversion(Poly1, Poly2): x = np.linspace(0, 1, 10) coef = random((3,)) d1 = Poly1.domain + random((2,))*.25 w1 = Poly1.window + random((2,))*.25 p1 = Poly1(coef, domain=d1, window=w1) d2 = Poly2.domain + random((2,))*.25 w2 = Poly2.window + random((2,))*.25 p2 = p1.convert(kind=Poly2, domain=d2, window=w2) assert_almost_equal(p2.domain, d2) assert_almost_equal(p2.window, w2) assert_almost_equal(p2(x), p1(x)) def check_cast(Poly1, Poly2): x = np.linspace(0, 1, 10) coef = random((3,)) d1 = Poly1.domain + random((2,))*.25 w1 = Poly1.window + random((2,))*.25 p1 = Poly1(coef, domain=d1, window=w1) d2 = Poly2.domain + random((2,))*.25 w2 = Poly2.window + random((2,))*.25 p2 = Poly2.cast(p1, domain=d2, window=w2) assert_almost_equal(p2.domain, d2) assert_almost_equal(p2.window, w2) assert_almost_equal(p2(x), p1(x)) # # methods that depend on one class # def check_identity(Poly): d = Poly.domain + random((2,))*.25 w = Poly.window + random((2,))*.25 x = np.linspace(d[0], d[1], 11) p = Poly.identity(domain=d, window=w) assert_equal(p.domain, d) assert_equal(p.window, w) assert_almost_equal(p(x), x) def check_basis(Poly): d = Poly.domain + random((2,))*.25 w = Poly.window + random((2,))*.25 p = Poly.basis(5, domain=d, window=w) assert_equal(p.domain, d) assert_equal(p.window, w) assert_equal(p.coef, [0]*5 + [1]) def check_fromroots(Poly): # check that requested roots are zeros of a polynomial # of correct degree, domain, and window. d = Poly.domain + random((2,))*.25 w = Poly.window + random((2,))*.25 r = random((5,)) p1 = Poly.fromroots(r, domain=d, window=w) assert_equal(p1.degree(), len(r)) assert_equal(p1.domain, d) assert_equal(p1.window, w) assert_almost_equal(p1(r), 0) # check that polynomial is monic pdom = Polynomial.domain pwin = Polynomial.window p2 = Polynomial.cast(p1, domain=pdom, window=pwin) assert_almost_equal(p2.coef[-1], 1) def check_fit(Poly): def f(x): return x*(x - 1)*(x - 2) x = np.linspace(0, 3) y = f(x) # check default value of domain and window p = Poly.fit(x, y, 3) assert_almost_equal(p.domain, [0, 3]) assert_almost_equal(p(x), y) assert_equal(p.degree(), 3) # check with given domains and window d = Poly.domain + random((2,))*.25 w = Poly.window + random((2,))*.25 p = Poly.fit(x, y, 3, domain=d, window=w) assert_almost_equal(p(x), y) assert_almost_equal(p.domain, d) assert_almost_equal(p.window, w) p = Poly.fit(x, y, [0, 1, 2, 3], domain=d, window=w) assert_almost_equal(p(x), y) assert_almost_equal(p.domain, d) assert_almost_equal(p.window, w) # check with class domain default p = Poly.fit(x, y, 3, []) assert_equal(p.domain, Poly.domain) assert_equal(p.window, Poly.window) p = Poly.fit(x, y, [0, 1, 2, 3], []) assert_equal(p.domain, Poly.domain) assert_equal(p.window, Poly.window) # check that fit accepts weights. w = np.zeros_like(x) z = y + random(y.shape)*.25 w[::2] = 1 p1 = Poly.fit(x[::2], z[::2], 3) p2 = Poly.fit(x, z, 3, w=w) p3 = Poly.fit(x, z, [0, 1, 2, 3], w=w) assert_almost_equal(p1(x), p2(x)) assert_almost_equal(p2(x), p3(x)) def check_equal(Poly): p1 = Poly([1, 2, 3], domain=[0, 1], window=[2, 3]) p2 = Poly([1, 1, 1], domain=[0, 1], window=[2, 3]) p3 = Poly([1, 2, 3], domain=[1, 2], window=[2, 3]) p4 = Poly([1, 2, 3], domain=[0, 1], window=[1, 2]) assert_(p1 == p1) assert_(not p1 == p2) assert_(not p1 == p3) assert_(not p1 == p4) def check_not_equal(Poly): p1 = Poly([1, 2, 3], domain=[0, 1], window=[2, 3]) p2 = Poly([1, 1, 1], domain=[0, 1], window=[2, 3]) p3 = Poly([1, 2, 3], domain=[1, 2], window=[2, 3]) p4 = Poly([1, 2, 3], domain=[0, 1], window=[1, 2]) assert_(not p1 != p1) assert_(p1 != p2) assert_(p1 != p3) assert_(p1 != p4) def check_add(Poly): # This checks commutation, not numerical correctness c1 = list(random((4,)) + .5) c2 = list(random((3,)) + .5) p1 = Poly(c1) p2 = Poly(c2) p3 = p1 + p2 assert_poly_almost_equal(p2 + p1, p3) assert_poly_almost_equal(p1 + c2, p3) assert_poly_almost_equal(c2 + p1, p3) assert_poly_almost_equal(p1 + tuple(c2), p3) assert_poly_almost_equal(tuple(c2) + p1, p3) assert_poly_almost_equal(p1 + np.array(c2), p3) assert_poly_almost_equal(np.array(c2) + p1, p3) assert_raises(TypeError, op.add, p1, Poly([0], domain=Poly.domain + 1)) assert_raises(TypeError, op.add, p1, Poly([0], window=Poly.window + 1)) if Poly is Polynomial: assert_raises(TypeError, op.add, p1, Chebyshev([0])) else: assert_raises(TypeError, op.add, p1, Polynomial([0])) def check_sub(Poly): # This checks commutation, not numerical correctness c1 = list(random((4,)) + .5) c2 = list(random((3,)) + .5) p1 = Poly(c1) p2 = Poly(c2) p3 = p1 - p2 assert_poly_almost_equal(p2 - p1, -p3) assert_poly_almost_equal(p1 - c2, p3) assert_poly_almost_equal(c2 - p1, -p3) assert_poly_almost_equal(p1 - tuple(c2), p3) assert_poly_almost_equal(tuple(c2) - p1, -p3) assert_poly_almost_equal(p1 - np.array(c2), p3) assert_poly_almost_equal(np.array(c2) - p1, -p3) assert_raises(TypeError, op.sub, p1, Poly([0], domain=Poly.domain + 1)) assert_raises(TypeError, op.sub, p1, Poly([0], window=Poly.window + 1)) if Poly is Polynomial: assert_raises(TypeError, op.sub, p1, Chebyshev([0])) else: assert_raises(TypeError, op.sub, p1, Polynomial([0])) def check_mul(Poly): c1 = list(random((4,)) + .5) c2 = list(random((3,)) + .5) p1 = Poly(c1) p2 = Poly(c2) p3 = p1 * p2 assert_poly_almost_equal(p2 * p1, p3) assert_poly_almost_equal(p1 * c2, p3) assert_poly_almost_equal(c2 * p1, p3) assert_poly_almost_equal(p1 * tuple(c2), p3) assert_poly_almost_equal(tuple(c2) * p1, p3) assert_poly_almost_equal(p1 * np.array(c2), p3) assert_poly_almost_equal(np.array(c2) * p1, p3) assert_poly_almost_equal(p1 * 2, p1 * Poly([2])) assert_poly_almost_equal(2 * p1, p1 * Poly([2])) assert_raises(TypeError, op.mul, p1, Poly([0], domain=Poly.domain + 1)) assert_raises(TypeError, op.mul, p1, Poly([0], window=Poly.window + 1)) if Poly is Polynomial: assert_raises(TypeError, op.mul, p1, Chebyshev([0])) else: assert_raises(TypeError, op.mul, p1, Polynomial([0])) def check_floordiv(Poly): c1 = list(random((4,)) + .5) c2 = list(random((3,)) + .5) c3 = list(random((2,)) + .5) p1 = Poly(c1) p2 = Poly(c2) p3 = Poly(c3) p4 = p1 * p2 + p3 c4 = list(p4.coef) assert_poly_almost_equal(p4 // p2, p1) assert_poly_almost_equal(p4 // c2, p1) assert_poly_almost_equal(c4 // p2, p1) assert_poly_almost_equal(p4 // tuple(c2), p1) assert_poly_almost_equal(tuple(c4) // p2, p1) assert_poly_almost_equal(p4 // np.array(c2), p1) assert_poly_almost_equal(np.array(c4) // p2, p1) assert_poly_almost_equal(2 // p2, Poly([0])) assert_poly_almost_equal(p2 // 2, 0.5*p2) assert_raises( TypeError, op.floordiv, p1, Poly([0], domain=Poly.domain + 1)) assert_raises( TypeError, op.floordiv, p1, Poly([0], window=Poly.window + 1)) if Poly is Polynomial: assert_raises(TypeError, op.floordiv, p1, Chebyshev([0])) else: assert_raises(TypeError, op.floordiv, p1, Polynomial([0])) def check_truediv(Poly): # true division is valid only if the denominator is a Number and # not a python bool. p1 = Poly([1,2,3]) p2 = p1 * 5 for stype in np.ScalarType: if not issubclass(stype, Number) or issubclass(stype, bool): continue s = stype(5) assert_poly_almost_equal(op.truediv(p2, s), p1) assert_raises(TypeError, op.truediv, s, p2) for stype in (int, long, float): s = stype(5) assert_poly_almost_equal(op.truediv(p2, s), p1) assert_raises(TypeError, op.truediv, s, p2) for stype in [complex]: s = stype(5, 0) assert_poly_almost_equal(op.truediv(p2, s), p1) assert_raises(TypeError, op.truediv, s, p2) for s in [tuple(), list(), dict(), bool(), np.array([1])]: assert_raises(TypeError, op.truediv, p2, s) assert_raises(TypeError, op.truediv, s, p2) for ptype in classes: assert_raises(TypeError, op.truediv, p2, ptype(1)) def check_mod(Poly): # This checks commutation, not numerical correctness c1 = list(random((4,)) + .5) c2 = list(random((3,)) + .5) c3 = list(random((2,)) + .5) p1 = Poly(c1) p2 = Poly(c2) p3 = Poly(c3) p4 = p1 * p2 + p3 c4 = list(p4.coef) assert_poly_almost_equal(p4 % p2, p3) assert_poly_almost_equal(p4 % c2, p3) assert_poly_almost_equal(c4 % p2, p3) assert_poly_almost_equal(p4 % tuple(c2), p3) assert_poly_almost_equal(tuple(c4) % p2, p3) assert_poly_almost_equal(p4 % np.array(c2), p3) assert_poly_almost_equal(np.array(c4) % p2, p3) assert_poly_almost_equal(2 % p2, Poly([2])) assert_poly_almost_equal(p2 % 2, Poly([0])) assert_raises(TypeError, op.mod, p1, Poly([0], domain=Poly.domain + 1)) assert_raises(TypeError, op.mod, p1, Poly([0], window=Poly.window + 1)) if Poly is Polynomial: assert_raises(TypeError, op.mod, p1, Chebyshev([0])) else: assert_raises(TypeError, op.mod, p1, Polynomial([0])) def check_divmod(Poly): # This checks commutation, not numerical correctness c1 = list(random((4,)) + .5) c2 = list(random((3,)) + .5) c3 = list(random((2,)) + .5) p1 = Poly(c1) p2 = Poly(c2) p3 = Poly(c3) p4 = p1 * p2 + p3 c4 = list(p4.coef) quo, rem = divmod(p4, p2) assert_poly_almost_equal(quo, p1) assert_poly_almost_equal(rem, p3) quo, rem = divmod(p4, c2) assert_poly_almost_equal(quo, p1) assert_poly_almost_equal(rem, p3) quo, rem = divmod(c4, p2) assert_poly_almost_equal(quo, p1) assert_poly_almost_equal(rem, p3) quo, rem = divmod(p4, tuple(c2)) assert_poly_almost_equal(quo, p1) assert_poly_almost_equal(rem, p3) quo, rem = divmod(tuple(c4), p2) assert_poly_almost_equal(quo, p1) assert_poly_almost_equal(rem, p3) quo, rem = divmod(p4, np.array(c2)) assert_poly_almost_equal(quo, p1) assert_poly_almost_equal(rem, p3) quo, rem = divmod(np.array(c4), p2) assert_poly_almost_equal(quo, p1) assert_poly_almost_equal(rem, p3) quo, rem = divmod(p2, 2) assert_poly_almost_equal(quo, 0.5*p2) assert_poly_almost_equal(rem, Poly([0])) quo, rem = divmod(2, p2) assert_poly_almost_equal(quo, Poly([0])) assert_poly_almost_equal(rem, Poly([2])) assert_raises(TypeError, divmod, p1, Poly([0], domain=Poly.domain + 1)) assert_raises(TypeError, divmod, p1, Poly([0], window=Poly.window + 1)) if Poly is Polynomial: assert_raises(TypeError, divmod, p1, Chebyshev([0])) else: assert_raises(TypeError, divmod, p1, Polynomial([0])) def check_roots(Poly): d = Poly.domain + random((2,))*.25 w = Poly.window + random((2,))*.25 tgt = np.sort(random((5,))) res = np.sort(Poly.fromroots(tgt, domain=d, window=w).roots()) assert_almost_equal(res, tgt) # default domain and window res = np.sort(Poly.fromroots(tgt).roots()) assert_almost_equal(res, tgt) def check_degree(Poly): p = Poly.basis(5) assert_equal(p.degree(), 5) def check_copy(Poly): p1 = Poly.basis(5) p2 = p1.copy() assert_(p1 == p2) assert_(p1 is not p2) assert_(p1.coef is not p2.coef) assert_(p1.domain is not p2.domain) assert_(p1.window is not p2.window) def check_integ(Poly): P = Polynomial # Check defaults p0 = Poly.cast(P([1*2, 2*3, 3*4])) p1 = P.cast(p0.integ()) p2 = P.cast(p0.integ(2)) assert_poly_almost_equal(p1, P([0, 2, 3, 4])) assert_poly_almost_equal(p2, P([0, 0, 1, 1, 1])) # Check with k p0 = Poly.cast(P([1*2, 2*3, 3*4])) p1 = P.cast(p0.integ(k=1)) p2 = P.cast(p0.integ(2, k=[1, 1])) assert_poly_almost_equal(p1, P([1, 2, 3, 4])) assert_poly_almost_equal(p2, P([1, 1, 1, 1, 1])) # Check with lbnd p0 = Poly.cast(P([1*2, 2*3, 3*4])) p1 = P.cast(p0.integ(lbnd=1)) p2 = P.cast(p0.integ(2, lbnd=1)) assert_poly_almost_equal(p1, P([-9, 2, 3, 4])) assert_poly_almost_equal(p2, P([6, -9, 1, 1, 1])) # Check scaling d = 2*Poly.domain p0 = Poly.cast(P([1*2, 2*3, 3*4]), domain=d) p1 = P.cast(p0.integ()) p2 = P.cast(p0.integ(2)) assert_poly_almost_equal(p1, P([0, 2, 3, 4])) assert_poly_almost_equal(p2, P([0, 0, 1, 1, 1])) def check_deriv(Poly): # Check that the derivative is the inverse of integration. It is # assumes that the integration has been checked elsewhere. d = Poly.domain + random((2,))*.25 w = Poly.window + random((2,))*.25 p1 = Poly([1, 2, 3], domain=d, window=w) p2 = p1.integ(2, k=[1, 2]) p3 = p1.integ(1, k=[1]) assert_almost_equal(p2.deriv(1).coef, p3.coef) assert_almost_equal(p2.deriv(2).coef, p1.coef) # default domain and window p1 = Poly([1, 2, 3]) p2 = p1.integ(2, k=[1, 2]) p3 = p1.integ(1, k=[1]) assert_almost_equal(p2.deriv(1).coef, p3.coef) assert_almost_equal(p2.deriv(2).coef, p1.coef) def check_linspace(Poly): d = Poly.domain + random((2,))*.25 w = Poly.window + random((2,))*.25 p = Poly([1, 2, 3], domain=d, window=w) # check default domain xtgt = np.linspace(d[0], d[1], 20) ytgt = p(xtgt) xres, yres = p.linspace(20) assert_almost_equal(xres, xtgt) assert_almost_equal(yres, ytgt) # check specified domain xtgt = np.linspace(0, 2, 20) ytgt = p(xtgt) xres, yres = p.linspace(20, domain=[0, 2]) assert_almost_equal(xres, xtgt) assert_almost_equal(yres, ytgt) def check_pow(Poly): d = Poly.domain + random((2,))*.25 w = Poly.window + random((2,))*.25 tgt = Poly([1], domain=d, window=w) tst = Poly([1, 2, 3], domain=d, window=w) for i in range(5): assert_poly_almost_equal(tst**i, tgt) tgt = tgt * tst # default domain and window tgt = Poly([1]) tst = Poly([1, 2, 3]) for i in range(5): assert_poly_almost_equal(tst**i, tgt) tgt = tgt * tst # check error for invalid powers assert_raises(ValueError, op.pow, tgt, 1.5) assert_raises(ValueError, op.pow, tgt, -1) def check_call(Poly): P = Polynomial d = Poly.domain x = np.linspace(d[0], d[1], 11) # Check defaults p = Poly.cast(P([1, 2, 3])) tgt = 1 + x*(2 + 3*x) res = p(x) assert_almost_equal(res, tgt) def check_cutdeg(Poly): p = Poly([1, 2, 3]) assert_raises(ValueError, p.cutdeg, .5) assert_raises(ValueError, p.cutdeg, -1) assert_equal(len(p.cutdeg(3)), 3) assert_equal(len(p.cutdeg(2)), 3) assert_equal(len(p.cutdeg(1)), 2) assert_equal(len(p.cutdeg(0)), 1) def check_truncate(Poly): p = Poly([1, 2, 3]) assert_raises(ValueError, p.truncate, .5) assert_raises(ValueError, p.truncate, 0) assert_equal(len(p.truncate(4)), 3) assert_equal(len(p.truncate(3)), 3) assert_equal(len(p.truncate(2)), 2) assert_equal(len(p.truncate(1)), 1) def check_trim(Poly): c = [1, 1e-6, 1e-12, 0] p = Poly(c) assert_equal(p.trim().coef, c[:3]) assert_equal(p.trim(1e-10).coef, c[:2]) assert_equal(p.trim(1e-5).coef, c[:1]) def check_mapparms(Poly): # check with defaults. Should be identity. d = Poly.domain w = Poly.window p = Poly([1], domain=d, window=w) assert_almost_equal([0, 1], p.mapparms()) # w = 2*d + 1 p = Poly([1], domain=d, window=w) assert_almost_equal([1, 2], p.mapparms()) if __name__ == "__main__": run_module_suite() import grokcore.component import z3c.traverser.interfaces import zeit.cms.workingcopy.interfaces import zope.app.container.btree import zope.app.security.interfaces import zope.component import zope.dublincore.interfaces import zope.interface import zope.publisher.interfaces import zope.security.interfaces import zope.security.management import zope.securitypolicy.interfaces class Workingcopy(zope.app.container.btree.BTreeContainer): """The working copy is the area of the CMS where users edit content.""" zope.interface.implements(zeit.cms.workingcopy.interfaces.IWorkingcopy) _order = () temporary = False # avoid migration of existing objects def __init__(self, temporary=False): super(Workingcopy, self).__init__() self.temporary = temporary def __iter__(self): for key in reversed(self._order): yield key for key in super(Workingcopy, self).__iter__(): if key in self._order: continue yield key def values(self): for key in self: yield self[key] def __setitem__(self, key, item): if not zeit.cms.workingcopy.interfaces.ILocalContent.providedBy(item): raise ValueError("Must provide ILocalContent") super(Workingcopy, self).__setitem__(key, item) self._order += (key, ) def __delitem__(self, key): super(Workingcopy, self).__delitem__(key) order = list(self._order) try: order.remove(key) except ValueError: pass else: self._order = tuple(order) class WorkingcopyLocation(zope.app.container.btree.BTreeContainer): """Location for working copies of all users.""" zope.interface.implements( zeit.cms.workingcopy.interfaces.IWorkingcopyLocation) def getWorkingcopy(self): """Get the working copy for the currently logged in user.""" principal = self._get_principal() return self.getWorkingcopyFor(principal) def getWorkingcopyFor(self, principal): principal_id = principal.id try: result = self[principal_id] except KeyError: # User doesn't have a working copy yet, create one result = self[principal_id] = Workingcopy() perms = ( zope.securitypolicy.interfaces.IPrincipalPermissionManager( result)) perms.grantPermissionToPrincipal('zeit.EditContent', principal_id) prm = zope.securitypolicy.interfaces.IPrincipalRoleManager( result) prm.assignRoleToPrincipal('zeit.Owner', principal_id) try: dc = zope.dublincore.interfaces.IDCDescriptiveProperties( result) except TypeError: pass else: if principal.title: dc.title = principal.title if principal.description: dc.description = principal.description return result def _get_principal(self): # Find the current principal. Note that it is possible for there # to be more than one principal - in this case we throw an error. interaction = zope.security.management.getInteraction() principal = None for p in interaction.participations: if principal is None: principal = p.principal else: raise ValueError("Multiple principals found") if principal is None: raise ValueError("No principal found") return principal @zope.component.adapter(zope.security.interfaces.IPrincipal) @zope.interface.implementer(zeit.cms.workingcopy.interfaces.IWorkingcopy) def principalAdapter(context): location = zope.component.getUtility( zeit.cms.workingcopy.interfaces.IWorkingcopyLocation) return location.getWorkingcopyFor(context) @grokcore.component.adapter(None) @grokcore.component.implementer(zeit.cms.workingcopy.interfaces.IWorkingcopy) def workingcopy_for_current_principal(ignored): # Find the current principal. Note that it is possible for there # to be more than one principal - in this case adapting fails try: interaction = zope.security.management.getInteraction() except zope.security.interfaces.NoInteraction: return principal = None for p in interaction.participations: if principal is None: principal = p.principal else: return if principal is None: return return zeit.cms.workingcopy.interfaces.IWorkingcopy(principal, None) class WorkingcopyTraverser(object): """Traverses to working copies, creating them on the fly.""" zope.interface.implements(z3c.traverser.interfaces.IPluggableTraverser) def __init__(self, context, request): self.context = context self.request = request def publishTraverse(self, request, name): auth = zope.component.getUtility( zope.app.security.interfaces.IAuthentication) try: principal = auth.getPrincipal(name) except zope.app.security.interfaces.PrincipalLookupError: raise zope.publisher.interfaces.NotFound( self.context, name, request) return zeit.cms.workingcopy.interfaces.IWorkingcopy(principal) import os import sys import shutil import string import subprocess import re from settings.settingsLoader import OXA_FILEHD_CACHE_VMS,OXA_FILEHD_REMOTE_VMS,OXA_FILEHD_CACHE_TEMPLATES,OXA_FILEHD_REMOTE_TEMPLATES,OXA_FILEHD_USE_CACHE,OXA_FILEHD_NICE_PRIORITY,OXA_FILEHD_CREATE_SPARSE_DISK,OXA_FILEHD_IONICE_CLASS, OXA_FILEHD_IONICE_PRIORITY,OXA_FILEHD_DD_BS_KB, OXA_DEFAULT_SWAP_SIZE_MB from utils.AgentExceptions import * from utils.Logger import Logger ''' @author: msune File-type Hd management routines ''' OXA_FILEHD_HD_TMP_MP="/tmp/oxa/hd" class FileHdManager(object): ''' File-type Hard Disk management routines ''' logger = Logger.getLogger() #Enables/disables the usage of Cache directory __useCache=OXA_FILEHD_USE_CACHE ##Utils @staticmethod def subprocessCall(command, priority=OXA_FILEHD_NICE_PRIORITY, ioPriority=OXA_FILEHD_IONICE_PRIORITY, ioClass=OXA_FILEHD_IONICE_CLASS, stdout=None): try: wrappedCmd = "/usr/bin/nice -n "+str(priority)+" /usr/bin/ionice -c "+str(ioClass)+" -n "+str(ioPriority)+" "+command FileHdManager.logger.debug("Executing: "+wrappedCmd) subprocess.check_call(wrappedCmd, shell=True, stdout=stdout) except Exception as e: FileHdManager.logger.error("Unable to execute command: "+command) raise e #Debug string @staticmethod def debugVM(vm): return " project:"+vm.project_id+", slice:"+vm.slice_id+", name:"+vm.name #Paths ''' Returns the container directory for the VM in remote FS''' @staticmethod def getRemoteHdDirectory(vm): return OXA_FILEHD_REMOTE_VMS+vm.project_id+"/"+vm.slice_id+"/" ''' Returns the container directory for the VM in remote Cache, if used''' @staticmethod def getHdDirectory(vm): if FileHdManager.__useCache: return OXA_FILEHD_CACHE_VMS+vm.project_id+"/"+vm.slice_id+"/" else: return OXA_FILEHD_REMOTE_VMS+vm.project_id+"/"+vm.slice_id+"/" ''' Returns the path of the hd file in Cache, if used''' @staticmethod def getHdPath(vm): if FileHdManager.__useCache: return OXA_FILEHD_CACHE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+".img" else: return OXA_FILEHD_REMOTE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+".img" ''' Returns the path of the hd file in Remote''' @staticmethod def getRemoteHdPath(vm): return OXA_FILEHD_REMOTE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+".img" ''' Returns the path of the swap hd file in Cache, if used''' @staticmethod def getSwapPath(vm): if FileHdManager.__useCache: return OXA_FILEHD_CACHE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+"_swap"+".img" else: return OXA_FILEHD_REMOTE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+"_swap"+".img" ''' Returns the path of the swap hd file in Remote''' @staticmethod def getRemoteSwapPath(vm): return OXA_FILEHD_REMOTE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+"_swap"+".img" ''' Returns the path of the config file in Cache, if used''' @staticmethod def getConfigFilePath(vm): if FileHdManager.__useCache: return OXA_FILEHD_CACHE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+".conf" else: return OXA_FILEHD_REMOTE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+".conf" ''' Returns the path of the config file in Remote''' @staticmethod def getRemoteConfigFilePath(vm): return OXA_FILEHD_REMOTE_VMS+vm.project_id+"/"+vm.slice_id+"/"+vm.name+".conf" ''' Returns the path of the temporally mounted Hd in the dom0 filesystem''' @staticmethod def getTmpMountedHdPath(vm): return OXA_FILEHD_HD_TMP_MP+vm.name+"_"+vm.uuid+"/" ''' Returns the path of the templates origin''' @staticmethod def getTemplatesPath(vm): if FileHdManager.__useCache: return OXA_FILEHD_CACHE_TEMPLATES else: return OXA_FILEHD_REMOTE_TEMPLATES ##Hooks '''Pre-start Hook''' @staticmethod def startHook(vm): if not FileHdManager.isVMinCacheFS(vm): FileHdManager.moveVMToCacheFS(vm) '''Pre-reboot Hook''' @staticmethod def rebootHook(vm): return '''Post-stop Hook''' @staticmethod def stopHook(vm): if FileHdManager.isVMinCacheFS(vm): FileHdManager.moveVMToRemoteFS(vm) ##Hd management routines @staticmethod def __fileTemplateExistsOrImportFromRemote(filepath): #if Cache is not used skip if not FileHdManager.__useCache: return True #Check cache if os.path.exists(OXA_FILEHD_CACHE_TEMPLATES+filepath): return True path = os.path.dirname(filepath) #Check remote if os.path.exists(OXA_FILEHD_REMOTE_TEMPLATES+path): #import from remote to cache FileHdManager.logger.info("Importing image to cache directory:"+OXA_FILEHD_REMOTE_TEMPLATES+path+"->"+OXA_FILEHD_CACHE_TEMPLATES+path) try: #Copy all FileHdManager.subprocessCall("/bin/cp "+ str(OXA_FILEHD_REMOTE_TEMPLATES+path)+" "+str(OXA_FILEHD_CACHE_TEMPLATES+path)) except Exception as e: return False return True return False @staticmethod def clone(vm): ##Check file existance in CACHE #FileHdManager.logger.debug("Checking:"+FileHdManager.getHdPath(vm)) if os.path.exists(FileHdManager.getHdPath(vm)): raise VMalreadyExists("Another VM with the same name exists in the same project and slice:"+FileHdManager.debugVM(vm)) #FileHdManager.logger.debug("Checking:"+FileHdManager.getRemoteHdPath(vm)) ##Check file existance in REMOTE if os.path.exists(FileHdManager.getRemoteHdPath(vm)): raise VMalreadyExists("Another VM with the same name exists in the same project and slice:"+FileHdManager.debugVM(vm)) if FileHdManager.__fileTemplateExistsOrImportFromRemote(vm.xen_configuration.hd_origin_path): path= "" try: #TODO: user authentication template_path=FileHdManager.getTemplatesPath(vm)+vm.xen_configuration.hd_origin_path template_swap_path=FileHdManager.getTemplatesPath(vm)+vm.xen_configuration.hd_origin_path+"_swap" vm_path=FileHdManager.getHdPath(vm) swap_path=FileHdManager.getSwapPath(vm) FileHdManager.logger.debug("Trying to clone from:"+template_path+"->>"+vm_path) if not os.path.exists(os.path.dirname(vm_path)): os.makedirs(os.path.dirname(vm_path)) count = (vm.xen_configuration.hd_size_mb*1024)/OXA_FILEHD_DD_BS_KB if (vm.xen_configuration.hd_size_mb*1024)/OXA_FILEHD_DD_BS_KB > 0: FileHdManager.logger.warning("HD size will be normalized") count =int(count) #Create HD FileHdManager.logger.info("Creating disks...") if OXA_FILEHD_CREATE_SPARSE_DISK: FileHdManager.logger.info("Main disk will be created as Sparse disk...") FileHdManager.subprocessCall("/bin/dd if=/dev/zero of="+str(vm_path)+" bs="+str(OXA_FILEHD_DD_BS_KB)+"k count=1 seek="+str(count)) else: FileHdManager.subprocessCall("/bin/dd if=/dev/zero of="+str(vm_path)+" bs="+str(OXA_FILEHD_DD_BS_KB)+"k count="+str(count)) #Create Swap and mkswap FileHdManager.logger.info("Creating swap disk...") swapCount=int((OXA_DEFAULT_SWAP_SIZE_MB*1024)/OXA_FILEHD_DD_BS_KB) FileHdManager.subprocessCall("/bin/dd if=/dev/zero of="+str(swap_path)+" bs="+str(OXA_FILEHD_DD_BS_KB)+"k count="+str(swapCount)) FileHdManager.logger.info("Creating swap filesystem...") FileHdManager.subprocessCall("/sbin/mkswap "+str(swap_path)) #Format FileHdManager.logger.info("Creating EXT3 fs...") FileHdManager.subprocessCall("/sbin/mkfs.ext3 -F -q "+str(vm_path)) #Untar disk contents FileHdManager.logger.info("Uncompressing disk contents...") path = FileHdManager.mount(vm) #mount with open(os.devnull, 'w') as opendev: FileHdManager.subprocessCall("/bin/tar -xvf "+str(template_path)+" -C "+str(path),stdout=opendev) except Exception as e: FileHdManager.logger.error("Could not clone image to working directory: "+str(e)) raise Exception("Could not clone image to working directory"+FileHdManager.debugVM(vm)) finally: try: FileHdManager.umount(path) except: pass else: raise Exception("Could not find origin hard-disk to clone"+FileHdManager.debugVM(vm)) @staticmethod def delete(vm): if not FileHdManager.isVMinRemoteFS(vm): FileHdManager.moveVMToRemoteFS(vm) os.remove(FileHdManager.getRemoteHdPath(vm)) os.remove(FileHdManager.getRemoteSwapPath(vm)) os.remove(FileHdManager.getRemoteConfigFilePath(vm)) #Mount/umount routines @staticmethod def mount(vm): path = FileHdManager.getTmpMountedHdPath(vm) if not os.path.isdir(path): os.makedirs(path) vm_path=FileHdManager.getHdPath(vm) FileHdManager.subprocessCall('/bin/mount -o loop '+str(vm_path)+" "+str(path)) return path @staticmethod def umount(path): FileHdManager.subprocessCall('/bin/umount -d '+str(path)) #remove dir os.removedirs(path) #Cache-Remote warehouse methods @staticmethod def isVMinRemoteFS(vm): return os.path.exists(FileHdManager.getRemoteHdPath(vm)) @staticmethod def isVMinCacheFS(vm): return os.path.exists(FileHdManager.getHdPath(vm)) @staticmethod def moveVMToRemoteFS(vm): #if Cache is not used skip if not FileHdManager.__useCache: return if FileHdManager.isVMinCacheFS(vm): #create dirs if do not exist already try: os.makedirs(FileHdManager.getRemoteHdDirectory(vm)) except Exception as e: pass #Move all files shutil.move(FileHdManager.getHdPath(vm),FileHdManager.getRemoteHdPath(vm)) shutil.move(FileHdManager.getSwapPath(vm),FileHdManager.getRemoteSwapPath(vm)) shutil.move(FileHdManager.getConfigFilePath(vm),FileHdManager.getRemoteConfigFilePath(vm)) else: raise Exception("Cannot find VM in CACHE FS"+FileHdManager.debugVM(vm) ) @staticmethod def moveVMToCacheFS(vm): #if Cache is not used skip if not FileHdManager.__useCache: return if FileHdManager.isVMinRemoteFS(vm): if FileHdManager.isVMinCacheFS(vm): raise Exception("Machine is already in Cache FS"+FileHdManager.debugVM(vm)) #create dirs if do not exist already try: os.makedirs(FileHdManager.getHdDirectory(vm)) except Exception as e: pass #Move all files shutil.move(FileHdManager.getRemoteHdPath(vm),FileHdManager.getHdPath(vm)) shutil.move(FileHdManager.getRemoteSwapPath(vm),FileHdManager.getSwapPath(vm)) shutil.move(FileHdManager.getRemoteConfigFilePath(vm),FileHdManager.getConfigFilePath(vm)) else: raise Exception("Cannot find VM in REMOTE FS"+FileHdManager.debugVM(vm)) import requests from httpretty import HTTPretty from social.p3 import urlparse from social.utils import parse_qs, url_add_parameters from social.tests.models import User from social.tests.backends.base import BaseBackendTest class BaseOAuthTest(BaseBackendTest): backend = None backend_path = None user_data_body = None user_data_url = '' user_data_content_type = 'application/json' access_token_body = None access_token_status = 200 expected_username = '' def extra_settings(self): return {'SOCIAL_AUTH_' + self.name + '_KEY': 'a-key', 'SOCIAL_AUTH_' + self.name + '_SECRET': 'a-secret-key'} def _method(self, method): return {'GET': HTTPretty.GET, 'POST': HTTPretty.POST}[method] def handle_state(self, start_url, target_url): start_query = parse_qs(urlparse(start_url).query) redirect_uri = start_query.get('redirect_uri') if getattr(self.backend, 'STATE_PARAMETER', False): if start_query.get('state'): target_url = url_add_parameters(target_url, { 'state': start_query['state'] }) if redirect_uri and getattr(self.backend, 'REDIRECT_STATE', False): redirect_query = parse_qs(urlparse(redirect_uri).query) if redirect_query.get('redirect_state'): target_url = url_add_parameters(target_url, { 'redirect_state': redirect_query['redirect_state'] }) return target_url def auth_handlers(self, start_url): target_url = self.handle_state(start_url, self.strategy.build_absolute_uri( self.complete_url )) HTTPretty.register_uri(HTTPretty.GET, start_url, status=301, location=target_url) HTTPretty.register_uri(HTTPretty.GET, target_url, status=200, body='foobar') HTTPretty.register_uri(self._method(self.backend.ACCESS_TOKEN_METHOD), uri=self.backend.access_token_url(), status=self.access_token_status, body=self.access_token_body or '', content_type='text/json') if self.user_data_url: HTTPretty.register_uri(HTTPretty.GET, self.user_data_url, body=self.user_data_body or '', content_type=self.user_data_content_type) return target_url def do_start(self): start_url = self.backend.start().url target_url = self.auth_handlers(start_url) response = requests.get(start_url) self.assertEqual(response.url, target_url) self.assertEqual(response.text, 'foobar') self.strategy.set_request_data(parse_qs(urlparse(target_url).query), self.backend) return self.backend.complete() class OAuth1Test(BaseOAuthTest): request_token_body = None raw_complete_url = '/complete/{0}/?oauth_verifier=bazqux&' \ 'oauth_token=foobar' def request_token_handler(self): HTTPretty.register_uri(self._method(self.backend.REQUEST_TOKEN_METHOD), self.backend.REQUEST_TOKEN_URL, body=self.request_token_body, status=200) def do_start(self): self.request_token_handler() return super(OAuth1Test, self).do_start() class OAuth2Test(BaseOAuthTest): raw_complete_url = '/complete/{0}/?code=foobar' refresh_token_body = '' def refresh_token_arguments(self): return {} def do_refresh_token(self): self.do_login() HTTPretty.register_uri(self._method(self.backend.REFRESH_TOKEN_METHOD), self.backend.refresh_token_url(), status=200, body=self.refresh_token_body) user = list(User.cache.values())[0] social = user.social[0] social.refresh_token(strategy=self.strategy, **self.refresh_token_arguments()) return user, social import sys from sklearn.externals.six.moves import cStringIO as StringIO import numpy as np import scipy.sparse as sp from sklearn.utils.testing import assert_equal from sklearn.utils.testing import assert_almost_equal from sklearn.utils.testing import assert_less from sklearn.utils.testing import assert_raises_regexp from sklearn.utils import check_random_state from sklearn.manifold.t_sne import _joint_probabilities from sklearn.manifold.t_sne import _kl_divergence from sklearn.manifold.t_sne import _gradient_descent from sklearn.manifold.t_sne import trustworthiness from sklearn.manifold.t_sne import TSNE from sklearn.manifold._utils import _binary_search_perplexity from scipy.optimize import check_grad from scipy.spatial.distance import pdist from scipy.spatial.distance import squareform def test_gradient_descent_stops(): # Test stopping conditions of gradient descent. class ObjectiveSmallGradient: def __init__(self): self.it = -1 def __call__(self, _): self.it += 1 return (10 - self.it) / 10.0, np.array([1e-5]) def flat_function(_): return 0.0, np.ones(1) # Gradient norm old_stdout = sys.stdout sys.stdout = StringIO() try: _, error, it = _gradient_descent( ObjectiveSmallGradient(), np.zeros(1), 0, n_iter=100, n_iter_without_progress=100, momentum=0.0, learning_rate=0.0, min_gain=0.0, min_grad_norm=1e-5, min_error_diff=0.0, verbose=2) finally: out = sys.stdout.getvalue() sys.stdout.close() sys.stdout = old_stdout assert_equal(error, 1.0) assert_equal(it, 0) assert("gradient norm" in out) # Error difference old_stdout = sys.stdout sys.stdout = StringIO() try: _, error, it = _gradient_descent( ObjectiveSmallGradient(), np.zeros(1), 0, n_iter=100, n_iter_without_progress=100, momentum=0.0, learning_rate=0.0, min_gain=0.0, min_grad_norm=0.0, min_error_diff=0.2, verbose=2) finally: out = sys.stdout.getvalue() sys.stdout.close() sys.stdout = old_stdout assert_equal(error, 0.9) assert_equal(it, 1) assert("error difference" in out) # Maximum number of iterations without improvement old_stdout = sys.stdout sys.stdout = StringIO() try: _, error, it = _gradient_descent( flat_function, np.zeros(1), 0, n_iter=100, n_iter_without_progress=10, momentum=0.0, learning_rate=0.0, min_gain=0.0, min_grad_norm=0.0, min_error_diff=-1.0, verbose=2) finally: out = sys.stdout.getvalue() sys.stdout.close() sys.stdout = old_stdout assert_equal(error, 0.0) assert_equal(it, 11) assert("did not make any progress" in out) # Maximum number of iterations old_stdout = sys.stdout sys.stdout = StringIO() try: _, error, it = _gradient_descent( ObjectiveSmallGradient(), np.zeros(1), 0, n_iter=11, n_iter_without_progress=100, momentum=0.0, learning_rate=0.0, min_gain=0.0, min_grad_norm=0.0, min_error_diff=0.0, verbose=2) finally: out = sys.stdout.getvalue() sys.stdout.close() sys.stdout = old_stdout assert_equal(error, 0.0) assert_equal(it, 10) assert("Iteration 10" in out) def test_binary_search(): # Test if the binary search finds Gaussians with desired perplexity. random_state = check_random_state(0) distances = random_state.randn(50, 2) distances = distances.dot(distances.T) np.fill_diagonal(distances, 0.0) desired_perplexity = 25.0 P = _binary_search_perplexity(distances, desired_perplexity, verbose=0) P = np.maximum(P, np.finfo(np.double).eps) mean_perplexity = np.mean([np.exp(-np.sum(P[i] * np.log(P[i]))) for i in range(P.shape[0])]) assert_almost_equal(mean_perplexity, desired_perplexity, decimal=3) def test_gradient(): # Test gradient of Kullback-Leibler divergence. random_state = check_random_state(0) n_samples = 50 n_features = 2 n_components = 2 alpha = 1.0 distances = random_state.randn(n_samples, n_features) distances = distances.dot(distances.T) np.fill_diagonal(distances, 0.0) X_embedded = random_state.randn(n_samples, n_components) P = _joint_probabilities(distances, desired_perplexity=25.0, verbose=0) fun = lambda params: _kl_divergence(params, P, alpha, n_samples, n_components)[0] grad = lambda params: _kl_divergence(params, P, alpha, n_samples, n_components)[1] assert_almost_equal(check_grad(fun, grad, X_embedded.ravel()), 0.0, decimal=5) def test_trustworthiness(): # Test trustworthiness score. random_state = check_random_state(0) # Affine transformation X = random_state.randn(100, 2) assert_equal(trustworthiness(X, 5.0 + X / 10.0), 1.0) # Randomly shuffled X = np.arange(100).reshape(-1, 1) X_embedded = X.copy() random_state.shuffle(X_embedded) assert_less(trustworthiness(X, X_embedded), 0.6) # Completely different X = np.arange(5).reshape(-1, 1) X_embedded = np.array([[0], [2], [4], [1], [3]]) assert_almost_equal(trustworthiness(X, X_embedded, n_neighbors=1), 0.2) def test_preserve_trustworthiness_approximately(): # Nearest neighbors should be preserved approximately. random_state = check_random_state(0) X = random_state.randn(100, 2) for init in ('random', 'pca'): tsne = TSNE(n_components=2, perplexity=10, learning_rate=100.0, init=init, random_state=0) X_embedded = tsne.fit_transform(X) assert_almost_equal(trustworthiness(X, X_embedded, n_neighbors=1), 1.0, decimal=1) def test_fit_csr_matrix(): # X can be a sparse matrix. random_state = check_random_state(0) X = random_state.randn(100, 2) X[(np.random.randint(0, 100, 50), np.random.randint(0, 2, 50))] = 0.0 X_csr = sp.csr_matrix(X) tsne = TSNE(n_components=2, perplexity=10, learning_rate=100.0, random_state=0) X_embedded = tsne.fit_transform(X_csr) assert_almost_equal(trustworthiness(X_csr, X_embedded, n_neighbors=1), 1.0, decimal=1) def test_preserve_trustworthiness_approximately_with_precomputed_distances(): # Nearest neighbors should be preserved approximately. random_state = check_random_state(0) X = random_state.randn(100, 2) D = squareform(pdist(X), "sqeuclidean") tsne = TSNE(n_components=2, perplexity=10, learning_rate=100.0, metric="precomputed", random_state=0) X_embedded = tsne.fit_transform(D) assert_almost_equal(trustworthiness(D, X_embedded, n_neighbors=1, precomputed=True), 1.0, decimal=1) def test_early_exaggeration_too_small(): # Early exaggeration factor must be >= 1. tsne = TSNE(early_exaggeration=0.99) assert_raises_regexp(ValueError, "early_exaggeration .*", tsne.fit_transform, np.array([[0.0]])) def test_too_few_iterations(): # Number of gradient descent iterations must be at least 200. tsne = TSNE(n_iter=199) assert_raises_regexp(ValueError, "n_iter .*", tsne.fit_transform, np.array([[0.0]])) def test_non_square_precomputed_distances(): # Precomputed distance matrices must be square matrices. tsne = TSNE(metric="precomputed") assert_raises_regexp(ValueError, ".* square distance matrix", tsne.fit_transform, np.array([[0.0], [1.0]])) def test_init_not_available(): # 'init' must be 'pca' or 'random'. assert_raises_regexp(ValueError, "'init' must be either 'pca' or 'random'", TSNE, init="not available") def test_distance_not_available(): # 'metric' must be valid. tsne = TSNE(metric="not available") assert_raises_regexp(ValueError, "Unknown metric not available.*", tsne.fit_transform, np.array([[0.0], [1.0]])) def test_pca_initialization_not_compatible_with_precomputed_kernel(): # Precomputed distance matrices must be square matrices. tsne = TSNE(metric="precomputed", init="pca") assert_raises_regexp(ValueError, "The parameter init=\"pca\" cannot be " "used with metric=\"precomputed\".", tsne.fit_transform, np.array([[0.0], [1.0]])) def test_verbose(): random_state = check_random_state(0) tsne = TSNE(verbose=2) X = random_state.randn(5, 2) old_stdout = sys.stdout sys.stdout = StringIO() try: tsne.fit_transform(X) finally: out = sys.stdout.getvalue() sys.stdout.close() sys.stdout = old_stdout assert("[t-SNE]" in out) assert("Computing pairwise distances" in out) assert("Computed conditional probabilities" in out) assert("Mean sigma" in out) assert("Finished" in out) assert("early exaggeration" in out) assert("Finished" in out) def test_chebyshev_metric(): # t-SNE should allow metrics that cannot be squared (issue #3526). random_state = check_random_state(0) tsne = TSNE(metric="chebyshev") X = random_state.randn(5, 2) tsne.fit_transform(X) def test_reduction_to_one_component(): # t-SNE should allow reduction to one component (issue #4154). random_state = check_random_state(0) tsne = TSNE(n_components=1) X = random_state.randn(5, 2) X_embedded = tsne.fit(X).embedding_ assert(np.all(np.isfinite(X_embedded))) # -*- coding: utf-8 -*- ''' Mepinta Copyright (c) 2011-2012, Joaquin G. Duo This file is part of Mepinta. Mepinta is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Mepinta is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Mepinta. If not, see . ''' from getDefaultContext import getDefaultContext from pipeline_backend.logging.logging import LOG_INFO from plugins_tests.base.K3dMeshPluginTest import K3dMeshPluginTest class SelectFaceByNumber(K3dMeshPluginTest): def __post_init__(self): import plugins.c_and_cpp.processors.k3dv1.mesh.selection.bynumber.SelectFaceByNumber as select self.testedProcessors.append(select) def _createInputMesh(self, test_pline): import plugins.c_and_cpp.processors.k3dv1.mesh.input.file.OBJMeshReader as obj_rdr obj_node = test_pline.append(obj_rdr) test_pline.setValue(obj_node.inputs.file, '/home/jduo/output.obj') test_pline.defaultMarked.append(obj_node.functions.loadMesh) return obj_node def definePluginPipeline(self, test_pline): select = self.testedProcessors[0] n_sel = test_pline.append(select) import plugins.c_and_cpp.processors.k3dv1.mesh.modifiers.polyhedron.ExtrudeFaces as ext_fac n_ext = test_pline.append(ext_fac) test_pline.setValue(n_sel.inputs.primitive_number, 0) test_pline.setValue(n_sel.inputs.face_index, 0) test_pline.setValue(n_ext.inputs.segments, 2) test_pline.setValue(n_ext.inputs.distance, 4.0) def getTimeParameters(self): return self.time.startEndStepSleep(end=-15., step=2, sleep=0.1) def stressPipeline(self, test_pline, time): nodes = test_pline.getNodesDict() node_sel = nodes['SelectFaceByNumber 1'] test_pline.setValue(node_sel.inputs.face_index, time *2) node_ext = nodes['ExtrudeFaces 1'] test_pline.setValue(node_ext.inputs.distance, 1.0 + time/4.0) test_pline.setValue(node_ext.inputs.segments, 1.0 + time/4.0) test = SelectFaceByNumber if __name__ == "__main__": sfbn = SelectFaceByNumber(getDefaultContext(LOG_INFO)) # Licensed under a 3-clause BSD style license - see LICENSE.rst """ This module tests some of the methods related to the ``ECSV`` reader/writer. Requires `pyyaml `_ to be installed. """ import os import copy import sys import numpy as np from ....table import Table, Column from ....table.table_helpers import simple_table from ....tests.helper import pytest from ....extern.six.moves import StringIO from ..ecsv import DELIMITERS from ... import ascii from .... import units as u try: import yaml # pylint: disable=W0611 HAS_YAML = True except ImportError: HAS_YAML = False DTYPES = ['bool', 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64', 'float16', 'float32', 'float64', 'float128', 'str'] if os.name == 'nt' or sys.maxsize <= 2**32: DTYPES.remove('float128') T_DTYPES = Table() for dtype in DTYPES: if dtype == 'bool': data = np.array([False, True, False]) elif dtype == 'str': data = np.array(['ab 0', 'ab, 1', 'ab2']) else: data = np.arange(3, dtype=dtype) c = Column(data, unit='m / s', description='descr_' + dtype, meta={'meta ' + dtype: 1}) T_DTYPES[dtype] = c T_DTYPES.meta['comments'] = ['comment1', 'comment2'] # Corresponds to simple_table() SIMPLE_LINES = ['# %ECSV 0.9', '# ---', '# datatype:', '# - {name: a, datatype: int64}', '# - {name: b, datatype: float64}', '# - {name: c, datatype: string}', 'a b c', '1 1.0 c', '2 2.0 d', '3 3.0 e'] @pytest.mark.skipif('not HAS_YAML') def test_write_simple(): """ Write a simple table with common types. This shows the compact version of serialization with one line per column. """ t = simple_table() out = StringIO() t.write(out, format='ascii.ecsv') assert out.getvalue().splitlines() == SIMPLE_LINES @pytest.mark.skipif('not HAS_YAML') def test_write_full(): """ Write a full-featured table with common types and explicitly checkout output """ t = T_DTYPES['bool', 'int64', 'float64', 'str'] lines = ['# %ECSV 0.9', '# ---', '# datatype:', '# - name: bool', '# unit: m / s', '# datatype: bool', '# description: descr_bool', '# meta: {meta bool: 1}', '# - name: int64', '# unit: m / s', '# datatype: int64', '# description: descr_int64', '# meta: {meta int64: 1}', '# - name: float64', '# unit: m / s', '# datatype: float64', '# description: descr_float64', '# meta: {meta float64: 1}', '# - name: str', '# unit: m / s', '# datatype: string', '# description: descr_str', '# meta: {meta str: 1}', '# meta: !!omap', '# - comments: [comment1, comment2]', 'bool int64 float64 str', 'False 0 0.0 "ab 0"', 'True 1 1.0 "ab, 1"', 'False 2 2.0 ab2'] out = StringIO() t.write(out, format='ascii.ecsv') assert out.getvalue().splitlines() == lines @pytest.mark.skipif('not HAS_YAML') def test_write_read_roundtrip(): """ Write a full-featured table with all types and see that it round-trips on readback. Use both space and comma delimiters. """ t = T_DTYPES for delimiter in DELIMITERS: out = StringIO() t.write(out, format='ascii.ecsv', delimiter=delimiter) t2s = [Table.read(out.getvalue(), format='ascii.ecsv'), Table.read(out.getvalue(), format='ascii'), ascii.read(out.getvalue()), ascii.read(out.getvalue(), format='ecsv', guess=False), ascii.read(out.getvalue(), format='ecsv')] for t2 in t2s: assert t.meta == t2.meta for name in t.colnames: assert t[name].attrs_equal(t2[name]) assert np.all(t[name] == t2[name]) @pytest.mark.skipif('not HAS_YAML') def test_bad_delimiter(): """ Passing a delimiter other than space or comma gives an exception """ out = StringIO() with pytest.raises(ValueError) as err: T_DTYPES.write(out, format='ascii.ecsv', delimiter='|') assert 'only space and comma are allowed' in str(err.value) @pytest.mark.skipif('not HAS_YAML') def test_bad_header_start(): """ Bad header without initial # %ECSV x.x """ lines = copy.copy(SIMPLE_LINES) lines[0] = '# %ECV 0.9' with pytest.raises(ascii.InconsistentTableError): Table.read('\n'.join(lines), format='ascii.ecsv', guess=False) @pytest.mark.skipif('not HAS_YAML') def test_bad_delimiter_input(): """ Illegal delimiter in input """ lines = copy.copy(SIMPLE_LINES) lines.insert(2, '# delimiter: |') with pytest.raises(ValueError) as err: Table.read('\n'.join(lines), format='ascii.ecsv', guess=False) assert 'only space and comma are allowed' in str(err.value) @pytest.mark.skipif('not HAS_YAML') def test_multidim_input(): """ Multi-dimensional column in input """ t = Table([np.arange(4).reshape(2, 2)], names=['a']) out = StringIO() with pytest.raises(ValueError) as err: t.write(out, format='ascii.ecsv') assert 'ECSV format does not support multidimensional column' in str(err.value) @pytest.mark.skipif('not HAS_YAML') def test_round_trip_empty_table(): """Test fix in #5010 for issue #5009 (ECSV fails for empty type with bool type)""" t = Table(dtype=[bool, 'i', 'f'], names=['a', 'b', 'c']) out = StringIO() t.write(out, format='ascii.ecsv') t2 = Table.read(out.getvalue(), format='ascii.ecsv') assert t.dtype == t2.dtype assert len(t2) == 0 @pytest.mark.skipif('not HAS_YAML') def test_csv_ecsv_colnames_mismatch(): """ Test that mismatch in column names from normal CSV header vs. ECSV YAML header raises the expected exception. """ lines = copy.copy(SIMPLE_LINES) header_index = lines.index('a b c') lines[header_index] = 'a b d' with pytest.raises(ValueError) as err: ascii.read(lines, format='ecsv') assert "column names from ECSV header ['a', 'b', 'c']" in str(err) @pytest.mark.skipif('not HAS_YAML') def test_regression_5604(): """ See https://github.com/astropy/astropy/issues/5604 for more. """ t = Table() t.meta = {"foo": 5*u.km, "foo2": u.s} t["bar"] = [7]*u.km out = StringIO() t.write(out, format="ascii.ecsv") assert '!astropy.units.Unit' in out.getvalue() assert '!astropy.units.Quantity' in out.getvalue() # Core imports import Queue import thread import time # Library imports from mock import patch, MagicMock, PropertyMock # Package imports from ..core.Thread_Manager import Thread_Manager from ..core.Threadable import Threadable from ..settings.Arguments import Arguments from ..reconstruction.Buffer import Buffer from ..zigbee.Packet import Packet from ..zigbee.RF_Sensor import RF_Sensor, DisabledException from ..zigbee.TDMA_Scheduler import TDMA_Scheduler from settings import SettingsTestCase from zigbee_packet import ZigBeePacketTestCase class ZigBeeRFSensorTestCase(SettingsTestCase, ZigBeePacketTestCase): """ Test case base class that provides the necessities to create one of the `RF_Sensor` types of objects. """ def setUp(self): super(ZigBeeRFSensorTestCase, self).setUp() self.arguments = Arguments("settings.json", ["--rf-sensor-id", "1"]) self.thread_manager = Thread_Manager() self.location_callback = MagicMock(return_value=((0, 0), 0)) self.receive_callback = MagicMock() self.valid_callback = MagicMock(return_value=(True, True)) def _create_sensor(self, sensor_type, **kwargs): """ Create the RF sensor object. The `sensor_type` is a class that is either `RF_Sensor` or a subclass thereof. Additional keyword arguments are passed through to the object initialization. The resulting `RF_Sensor` object is returned. """ return sensor_type(self.arguments, self.thread_manager, self.location_callback, self.receive_callback, self.valid_callback, **kwargs) class TestZigBeeRFSensor(ZigBeeRFSensorTestCase): def setUp(self): super(TestZigBeeRFSensor, self).setUp() self.settings = self.arguments.get_settings("zigbee_base") type_mock = PropertyMock(return_value="zigbee_base") with patch.object(RF_Sensor, "type", new_callable=type_mock): self.rf_sensor = self._create_sensor(RF_Sensor) def test_initialization(self): # Providing an uncallable callback raises an exception. with self.assertRaises(TypeError): RF_Sensor(self.arguments, self.thread_manager, None, None, None) # Not providing an `Arguments` object raises an exception. with self.assertRaises(ValueError): RF_Sensor(None, self.thread_manager, self.location_callback, self.receive_callback, self.valid_callback) # The settings must be loaded when an `Arguments` object is provided. self.assertEqual(self.rf_sensor._settings, self.settings) # Common member variables must be initialized. self.assertEqual(self.rf_sensor._id, self.settings.get("rf_sensor_id")) self.assertEqual(self.rf_sensor._number_of_sensors, self.settings.get("number_of_sensors")) self.assertEqual(self.rf_sensor._address, None) self.assertEqual(self.rf_sensor._connection, None) self.assertEqual(self.rf_sensor._buffer, None) self.assertIsInstance(self.rf_sensor._scheduler, TDMA_Scheduler) self.assertIsInstance(self.rf_sensor._packets, Queue.Queue) self.assertEqual(self.rf_sensor._packets.qsize(), 0) self.assertIsInstance(self.rf_sensor._custom_packets, Queue.Queue) self.assertEqual(self.rf_sensor._custom_packets.qsize(), 0) self.assertEqual(self.rf_sensor._joined, False) self.assertEqual(self.rf_sensor._activated, False) self.assertEqual(self.rf_sensor._started, False) self.assertEqual(self.rf_sensor._loop_delay, self.settings.get("loop_delay")) self.assertTrue(hasattr(self.rf_sensor._location_callback, "__call__")) self.assertTrue(hasattr(self.rf_sensor._receive_callback, "__call__")) self.assertTrue(hasattr(self.rf_sensor._valid_callback, "__call__")) def test_id(self): # The RF sensor ID must be returned. self.assertEqual(self.rf_sensor.id, self.rf_sensor._id) def test_number_of_sensors(self): # The number of sensors must be returned. self.assertEqual(self.rf_sensor.number_of_sensors, self.rf_sensor._number_of_sensors) def test_buffer(self): # Providing an invalid buffer raises an exception. with self.assertRaises(ValueError): self.rf_sensor.buffer = [] # A valid buffer must be set and returned. buffer = Buffer(self.settings) self.rf_sensor.buffer = buffer self.assertEqual(self.rf_sensor.buffer, buffer) def test_type(self): # Verify that the interface requires subclasses to implement # the `type` property. with self.assertRaises(NotImplementedError): dummy = self.rf_sensor.type def test_identity(self): # The identity must include the ID, address and network join status. self.assertEqual(self.rf_sensor.identity, { "id": self.rf_sensor._id, "address": self.rf_sensor._address, "joined": self.rf_sensor._joined }) def test_activate(self): with patch.object(RF_Sensor, "_setup") as setup_mock: with patch.object(thread, "start_new_thread") as start_new_thread_mock: self.rf_sensor.activate() # The sensor must be setup and the loop thread must be started. self.assertTrue(self.rf_sensor._activated) self.assertEqual(setup_mock.call_count, 1) self.assertEqual(start_new_thread_mock.call_count, 1) def test_deactivate(self): connection_mock = MagicMock() with patch.object(RF_Sensor, "_setup"): with patch.object(thread, "start_new_thread"): self.rf_sensor.activate() self.rf_sensor._connection = connection_mock self.rf_sensor.deactivate() # The connection must be closed and the sensor must be deactivated. self.assertEqual(self.rf_sensor._activated, False) self.assertEqual(connection_mock.close.call_count, 1) self.assertEqual(self.rf_sensor._connection, None) def test_start(self): # The sensor must be started for sending RSSI broadcast/ground # station packets. Make sure that the schedule will try to shift again # when the measurements start. self.rf_sensor.start() self.assertTrue(self.rf_sensor._started) self.assertEqual(self.rf_sensor._packets.qsize(), 0) self.assertNotEqual(self.rf_sensor._scheduler.timestamp, 0.0) def test_stop(self): # Pretend that we start the RF sensor so that we know that `stop` # functions. self.rf_sensor.start() # The sensor must be stopped for sending custom packets. Make sure that # the scheduler timestamp is reset, so that it updates correctly in # case we restart the sensor measurements. self.rf_sensor.stop() self.assertEqual(self.rf_sensor._started, False) self.assertEqual(self.rf_sensor._scheduler.timestamp, 0.0) def test_enqueue(self): # Providing a packet that is not a `Packet` object raises an exception. with self.assertRaises(TypeError): self.rf_sensor.enqueue({ "foo": "bar" }) # Providing a private packet raises an exception. with self.assertRaises(ValueError): self.packet.set("specification", "rssi_broadcast") self.rf_sensor.enqueue(self.packet) # Packets that do not have a destination must be broadcasted. # We subtract one because we do not send to ourself. self.packet.set("specification", "waypoint_clear") self.packet.set("to_id", 2) self.rf_sensor.enqueue(self.packet) self.assertEqual(self.rf_sensor._custom_packets.qsize(), self.rf_sensor.number_of_sensors - 1) for to_id in xrange(1, self.rf_sensor.number_of_sensors + 1): if to_id == self.rf_sensor.id: continue item = self.rf_sensor._custom_packets.get() self.assertIsInstance(item["packet"], Packet) self.assertEqual(item["packet"].get_all(), { "specification": "waypoint_clear", "to_id": 2 }) self.assertEqual(item["to"], to_id) self.assertEqual(self.rf_sensor._custom_packets.qsize(), 0) # Packets that do contain a destination must be enqueued directly. self.rf_sensor.enqueue(self.packet, to=2) self.assertEqual(self.rf_sensor._custom_packets.qsize(), 1) self.assertEqual(self.rf_sensor._custom_packets.get(), { "packet": self.packet, "to": 2 }) self.assertEqual(self.rf_sensor._custom_packets.qsize(), 0) def test_discover(self): # Providing an invalid callback raises an exception. with self.assertRaisesRegexp(TypeError, "callback is not callable"): self.rf_sensor.discover(None) callback_mock = MagicMock() # Providing invalid required sensors raises an exception. with self.assertRaisesRegexp(TypeError, "must be a `set`"): self.rf_sensor.discover(callback_mock, required_sensors=2) # Providing an set of required sensors that cannot be discovered raises # an exception. with self.assertRaisesRegexp(ValueError, "only contain vehicle sensors"): self.rf_sensor.discover(callback_mock, required_sensors=set([0])) def test_setup(self): # Verify that the interface requires subclasses to implement # the `_setup` method. with self.assertRaises(NotImplementedError): self.rf_sensor._setup() def test_loop(self): self.rf_sensor._activated = True with patch.object(Threadable, "interrupt") as interrupt_mock: with patch.object(RF_Sensor, "_loop_body") as loop_body_mock: # The loop body and interrupt handler must be called when # an exception other than a `DisabledException` is raised. loop_body_mock.configure_mock(side_effect=RuntimeError) self.rf_sensor._loop() loop_body_mock.assert_called_once_with() interrupt_mock.assert_called_once_with() with patch.object(Threadable, "interrupt") as interrupt_mock: with patch.object(RF_Sensor, "_loop_body") as loop_body_mock: # The loop body must be called when a `DisabledException` is # raised, but nothing else must happen. loop_body_mock.configure_mock(side_effect=DisabledException) self.rf_sensor._loop() loop_body_mock.assert_called_once_with() interrupt_mock.assert_not_called() def test_loop_body(self): with patch.object(RF_Sensor, "_send_custom_packets") as send_custom_packets_mock: # Send custom packets when the sensor has been activated, # but not started. self.rf_sensor._loop_body() send_custom_packets_mock.assert_called_once_with() # If the current time is inside an allocated slot, then packets # may be sent. in_slot_mock = PropertyMock(return_value=True) with patch.object(TDMA_Scheduler, "in_slot", new_callable=in_slot_mock): with patch.object(TDMA_Scheduler, "update") as update_mock: with patch.object(RF_Sensor, "_send") as send_mock: self.rf_sensor._started = True # Send RSSI broadcast/ground station packets when the sensor # has been activated and started. self.rf_sensor._loop_body() update_mock.assert_called_once_with() send_mock.assert_called_once_with() # If the current time is not inside an allocated slot, then no # packets may be sent. in_slot_mock = PropertyMock(return_value=False) with patch.object(TDMA_Scheduler, "in_slot", new_callable=in_slot_mock): with patch.object(TDMA_Scheduler, "update") as update_mock: with patch.object(RF_Sensor, "_send") as send_mock: self.rf_sensor._started = True # Send RSSI broadcast/ground station packets when the sensor # has been activated and started. self.rf_sensor._loop_body() update_mock.assert_not_called() send_mock.assert_not_called() @patch.object(RF_Sensor, "_send_tx_frame") def test_send(self, send_tx_frame_mock): self.rf_sensor._packets.put(self.rf_sensor._create_rssi_broadcast_packet(2))