python.oracle Namespace Reference

Functions
def	parse_auth_file (file_name, connection)
def	get_authentication (connection="oracle://ATLAS_COOLPROD/ATLAS_COOLONL_GLOBAL")
def	make_oracle_connection (connection_string)
def	fetch_recent_runs (how_recent=ONE_WEEK, ascending=False)
def	fetch_runs_since (first_run=140000, ascending=False)
def	make_atlas_partition_query ()
def	fetch_last_n_atlas_runs (n=10)
def	fetch_atlas_runs ()
def	atlas_runs_set ()
def	atlas_runs_between (first, last)
def	filter_atlas_runs (iovs)

Variables
	Session = sessionmaker(engine)
	run_table
int	ONE_WEEK = 7*24*3600

Function Documentation

atlas_runs_between()

def python.oracle.atlas_runs_between	(		first,
			last
	)

Definition at line 143 of file oracle.py.

def atlas_runs_between(first, last):
 
    rows = make_atlas_partition_query()
    rows = rows.where(run_table.c.RUNNUMBER.between(first, last))
    
    with Session() as session:
        return [row.RUNNUMBER for row in session.execute(rows).fetchall()]
 

atlas_runs_set()

def python.oracle.atlas_runs_set

(

)

Definition at line 140 of file oracle.py.

def atlas_runs_set():
    return set(x.RUNNUMBER for x in fetch_atlas_runs())
 

fetch_atlas_runs()

def python.oracle.fetch_atlas_runs

(

)

Definition at line 135 of file oracle.py.

def fetch_atlas_runs():
    rows = make_atlas_partition_query()
    with Session() as session:
        return session.execute(rows).fetchall()
 

fetch_last_n_atlas_runs()

def python.oracle.fetch_last_n_atlas_runs

(

n = 10

)

Definition at line 127 of file oracle.py.

def fetch_last_n_atlas_runs(n=10):
    rows = (select(run_table.c.RUNNUMBER)
            .where(run_table.c.PARTITIONNAME == "ATLAS")
            .order_by(run_table.c.RUNNUMBER.desc()).limit(n))
    
    with Session() as session:
        return [row.RUNNUMBER for row in reversed(session.execute(rows).fetchall())]
 

fetch_recent_runs()

def python.oracle.fetch_recent_runs	(		how_recent = ONE_WEEK,
			ascending = False
	)

Retrieve a list of ATLAS runs from the database, since first_run

Definition at line 94 of file oracle.py.

def fetch_recent_runs(how_recent=ONE_WEEK, ascending=False):
    """
    Retrieve a list of ATLAS runs from the database, since first_run
    """
    from time import time, strftime, gmtime
    t = run_table
    
    ordering = t.c.RUNNUMBER.asc() if ascending else t.c.RUNNUMBER.desc()
    
    this_recent = strftime("%Y%m%dT%H%M%S", gmtime(time()-how_recent))
    condition = and_(t.c.STARTAT >= this_recent, t.c.PARTITIONNAME == "ATLAS")
    rows = select(run_table).where(condition).order_by(ordering)
    with Session() as session:
        return session.execute(rows).fetchall()
 

fetch_runs_since()

def python.oracle.fetch_runs_since	(		first_run = 140000,
			ascending = False
	)

Retrieve a list of ATLAS runs from the database, since first_run

Definition at line 109 of file oracle.py.

def fetch_runs_since(first_run=140000, ascending=False):
    """
    Retrieve a list of ATLAS runs from the database, since first_run
    """
    t = run_table
    
    ordering = t.c.RUNNUMBER.asc() if ascending else t.c.RUNNUMBER.desc()
    
    condition = and_(t.c.RUNNUMBER > first_run, t.c.PARTITIONNAME == "ATLAS")
    rows = select(run_table).where(condition).order_by(ordering)
    with Session() as session:
        return session.execute(rows).fetchall()
 

filter_atlas_runs()

def python.oracle.filter_atlas_runs

(

iovs

)

Definition at line 151 of file oracle.py.

def filter_atlas_runs(iovs):
 
    iov_runs = set(iov.since.run for iov in iovs)
    first, last = min(iov_runs), max(iov_runs)
    
    rows = make_atlas_partition_query()
    rows = rows.where(run_table.c.RUNNUMBER.between(first, last))
    
    with Session() as session:
        atlas_runs = set(row.RUNNUMBER for row in session.execute(rows).fetchall())
        keep_runs = atlas_runs.intersection(iov_runs)
    
        return IOVSet(iov for iov in iovs if iov.since.run in keep_runs)
    

get_authentication()

def python.oracle.get_authentication

(

connection = "oracle://ATLAS_COOLPROD/ATLAS_COOLONL_GLOBAL"

)

Retrieves authentication information from CORAL_AUTH_PATH authentication.xml

Definition at line 36 of file oracle.py.

def get_authentication(connection="oracle://ATLAS_COOLPROD/ATLAS_COOLONL_GLOBAL"):    """
    Retrieves authentication information from CORAL_AUTH_PATH authentication.xml
    """
    
    from os import environ
    from os.path import join as pjoin
    assert "CORAL_AUTH_PATH" in environ, "CORAL_AUTH_PATH environment var not set"
    
    auth_paths = environ["CORAL_AUTH_PATH"].split(":")
    
    for auth_path in auth_paths + ["."]:
        file_name = pjoin(auth_path, "authentication.xml")
        if exists(file_name):
            authentication = parse_auth_file(file_name, connection)
            if authentication:
                return authentication
    
    raise RuntimeError("Unable to locate credentials for %s." 
                          % connection)
 
 

make_atlas_partition_query()

def python.oracle.make_atlas_partition_query

(

)

Definition at line 122 of file oracle.py.

def make_atlas_partition_query():
    return (select(run_table.c.RUNNUMBER)
                  .where(run_table.c.PARTITIONNAME == "ATLAS")
                  .order_by(run_table.c.RUNNUMBER))
 

make_oracle_connection()

def python.oracle.make_oracle_connection

(

connection_string

)

Definition at line 57 of file oracle.py.

def make_oracle_connection(connection_string):
    "oracle://ATLAS_COOLPROD/ATLAS_COOLONL_GLOBAL"
    assert connection_string.startswith("oracle://"), "Not a connection string"
    host = urlparse (connection_string[len("oracle:"):]).netloc
    username, password = get_authentication(connection_string)
    conn_str = "oracle://%s:%s@%s" % (username, password, host)
    engine = create_engine(conn_str, pool_recycle=10*60)
    metadata = MetaData()
    metadata.reflect(engine)
    return engine, metadata
 
#conn_str = "oracle://%s:%s@ATLAS_COOLPROD" % get_authentication()
 
# Recycle the connection every 10 minutes
#engine = create_engine(conn_str, pool_recycle=10*60)
#metadata = MetaData(bind=engine)
 
engine, metadata = make_oracle_connection("oracle://ATLAS_COOLPROD"
                                          "/ATLAS_COOLONL_GLOBAL")

parse_auth_file()

def python.oracle.parse_auth_file	(		file_name,
			connection
	)

Definition at line 16 of file oracle.py.

def parse_auth_file(file_name, connection):
 
    dom = parse(file_name)
    
    connections = dom.getElementsByTagName("connection")
    desired_conn = lambda c: c.attributes.get("name").value == connection
    
    connections = list(filter(desired_conn, connections))
    
    if len(connections) < 1:
        return None
    
    info = {}
    for node in connections[0].childNodes:
        if node.nodeName == "parameter":
            info[node.getAttribute("name")] = str(node.getAttribute("value"))
                
    authentication = info["user"], info["password"]
    return authentication
 

Variable Documentation

ONE_WEEK

int python.oracle.ONE_WEEK = 7*24*3600

Definition at line 92 of file oracle.py.

run_table

python.oracle.run_table

Initial value:

=  Table("ATLAS_RUN_NUMBER.RUNNUMBER", metadata,
    Column("NAME",          String),
    Column("RUNNUMBER",     String),
    Column("STARTAT",       String),
    Column("DURATION",      Integer),
    Column("CREATEDBY",     String),
    Column("HOST",          String),
    Column("PARTITIONNAME", String),
    Column("CONFIGSCHEMA",  Integer),
    Column("CONFIGDATA",    String),
    Column("COMMENTS",      String),
    quote=False
)

Definition at line 78 of file oracle.py.

Session

python.oracle.Session = sessionmaker(engine)

Definition at line 76 of file oracle.py.