def __init__(self, *, dbHost, dbName, dbUser, dbPass, root):
self._host = dbHost
self._port = 3306
self._user = dbUser
self._pass = dbPass
self._dbase = dbName
self._root = root
self._cmdTs = None
self._varTs = None
self._db = None
self._dbLock = threading.Lock()
self._varSer = {}
self._cmdSer = {}
self._runEn = False
self._thread = None
self._log = pyrogue.logInit(cls=self)
if not root.running:
raise Exception(
"MysqlGw can not be setup on a tree which is not started")
# Connect to server
with self._dbLock:
if not self._connect():
return
# Create PVs
for v in self._root.variableList:
if v.isCommand:
self._addCommand(v)
elif v.isVariable:
self._addVariable(v)
self._db.commit()
self._delOldEntries()
def __init__(self, addr="localhost", port=9099):
rogue.interfaces.ZmqClient.__init__(self, addr, port)
self._varListeners = []
self._root = None
# Setup logging
self._log = pr.logInit(cls=self, name="VirtualClient", path=None)
# Get root name as a connection test
self.setTimeout(1000)
rn = None
while rn is None:
rn = self._remoteAttr('__rootname__', None)
print("Connected to {} at {}:{}".format(rn, addr, port))
# Try to connect to root entity, long timeout
print("Getting structure for {}".format(rn))
self.setTimeout(120000)
r = self._remoteAttr('__structure__', None)
print("Ready to use {}".format(rn))
# Update tree
r._virtAttached(r, r, self)
self._root = r
def __init__(self, *, host, dest, uid, ssi=False):
rogue.interfaces.stream.Master.__init__(self)
rogue.interfaces.stream.Slave.__init__(self)
threading.Thread.__init__(self)
self._log = pyrogue.logInit(self)
ibPort = 5000 + dest + uid * 100
obPort = 6000 + dest + uid * 100
ocPort = 7000 + dest + uid * 100
sbPort = 8000 + dest + uid * 100
self._ctx = zmq.Context()
self._ibSock = self._ctx.socket(zmq.REP)
self._obSock = self._ctx.socket(zmq.REQ)
self._ocSock = self._ctx.socket(zmq.REQ)
self._sbSock = self._ctx.socket(zmq.REQ)
self._ibSock.connect("tcp://%s:%i" % (host, ibPort))
self._obSock.connect("tcp://%s:%i" % (host, obPort))
self._ocSock.connect("tcp://%s:%i" % (host, ocPort))
self._sbSock.connect("tcp://%s:%i" % (host, sbPort))
self._log.info(
"Destination %i : id = %i, ib = %i, ob = %i, Code = %i, Side Data = %i"
% (dest, uid, ibPort, obPort, ocPort, sbPort))
self._ssi = ssi
self._enable = True
self.rxCount = 0
self.txCount = 0
self.start()
def __init__(self, device, baud, timeout=1, **kwargs):
super().__init__(4,4096) # Set min and max size to 4 bytes
self._log = pyrogue.logInit(cls=self, name=f'{device}')
self.serialPort = serial.Serial(device, baud, timeout=timeout, **kwargs)
self._workerQueue = queue.Queue()
self._workerThread = threading.Thread(target=self._worker)
self._workerThread.start()
def yamlToData(stream='',fName=None):
"""
Load yaml to data structure.
A yaml string or file path may be passed.
"""
log = pr.logInit(name='yamlToData')
class PyrogueLoader(yaml.Loader):
pass
def include_mapping(loader, node):
rel = loader.construct_scalar(node)
# Filename starts with absolute path
if rel[0] == '/':
filename = rel
# Filename is relative and we know the base path
elif fName is not None:
filename = os.path.join(os.path.dirname(fName), rel)
# File is relative without a base path, assume cwd (Current working directory)
else:
filename = node
# Recursive call, flatten relative jumps
return yamlToData(fName=os.path.abspath(filename))
def construct_mapping(loader, node):
loader.flatten_mapping(node)
return odict(loader.construct_pairs(node))
PyrogueLoader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG,construct_mapping)
PyrogueLoader.add_constructor('!include',include_mapping)
# Use passed string
if fName is None:
return yaml.load(stream,Loader=PyrogueLoader)
# Main or sub-file is in a zip
elif '.zip' in fName:
base = fName.split('.zip')[0] + '.zip'
sub = fName.split('.zip')[1][1:] # Strip leading '/'
log.debug("loading {} from zipfile {}".format(sub,base))
with zipfile.ZipFile(base, 'r', compression=zipfile.ZIP_LZMA) as myzip:
with myzip.open(sub) as myfile:
return yaml.load(myfile.read(),Loader=PyrogueLoader)
# Non zip file
else:
log.debug("loading {}".format(fName))
with open(fName,'r') as f:
return yaml.load(f.read(),Loader=PyrogueLoader)
def __init__(self, *, name, mode, device):
self._name = name
self._mode = mode
self._device = device
self._lock = threading.RLock()
self._doUpdate = False
# Setup logging
self._log = pr.logInit(self, name)
def __init__(self, *, path, mode, device):
self._path = path
self._mode = mode
self._device = device
self._lock = threading.RLock()
self._doUpdate = False
# Setup logging
self._log = pr.logInit(cls=self,name=path)
def __init__(self, *, base, root, incGroups, excGroups, pvMap=None):
self._root = root
self._base = base
self._log = pyrogue.logInit(cls=self)
self._server = None
self._incGroups = incGroups
self._excGroups = excGroups
self._pvMap = pvMap
self._started = False
self._provider = p4p.server.StaticProvider(__name__)
def __init__(self,*, root):
self._pq = [] # The heap queue
self._entries = {} # {Block: Entry} mapping to look up if a block is already in the queue
self._counter = itertools.count()
self._lock = threading.RLock()
self._update = threading.Condition()
self._run = True
self._root = root
self._pollThread = threading.Thread(target=self._poll)
# Setup logging
self._log = pr.logInit(self)
def __init__(self, url):
self._log = pr.logInit(cls=self, name="SqlLogger", path=None)
self._url = url
self._conn = None
self._thread = None
self._queue = queue.Queue()
self._thread = threading.Thread(target=self._worker)
self._thread.start()
try:
conn = sqlalchemy.create_engine(self._url)
self._log.info("Opened database connection to {}".format(
self._url))
except Exception as e:
self._log.error(
"Failed to open database connection to {}: {}".format(
self._url, e))
return
self._metadata = sqlalchemy.MetaData(conn)
self._varTable = sqlalchemy.Table(
'variables', self._metadata,
sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True),
sqlalchemy.Column('timestamp',
sqlalchemy.DateTime(timezone=True),
server_default=sqlalchemy.func.now()),
sqlalchemy.Column('path', sqlalchemy.String),
sqlalchemy.Column('enum', sqlalchemy.String),
sqlalchemy.Column('disp', sqlalchemy.String),
sqlalchemy.Column('value', sqlalchemy.String),
sqlalchemy.Column('severity', sqlalchemy.String),
sqlalchemy.Column('status', sqlalchemy.String))
self._logTable = sqlalchemy.Table(
'syslog', self._metadata,
sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True),
sqlalchemy.Column('timestamp',
sqlalchemy.DateTime(timezone=True),
server_default=sqlalchemy.func.now()),
sqlalchemy.Column('name', sqlalchemy.String),
sqlalchemy.Column('message', sqlalchemy.String),
sqlalchemy.Column('exception', sqlalchemy.String),
sqlalchemy.Column('levelName', sqlalchemy.String),
sqlalchemy.Column('levelNumber', sqlalchemy.Integer))
self._varTable.create(conn, checkfirst=True)
self._logTable.create(conn, checkfirst=True)
self._conn = conn
def __init__(self, host, port):
self._log = pyrogue.logInit(cls=self, name=f'{host}.{port}')
self._ctx = zmq.Context()
self._sbPush = self._ctx.socket(zmq.PUSH)
self._sbPush.connect(f"tcp://{host}:{port+1}")
self._sbPull = self._ctx.socket(zmq.PULL)
self._sbPull.connect(f"tcp://{host}:{port}")
self._log.info("Connected to port {} on host {}".format(port, host))
self._recvCb = self._defaultRecvCb
self._lock = threading.Lock()
self._run = True
self._recvThread = threading.Thread(target=self._recvWorker)
self._recvThread.start()
def __init__(self,
*,
base,
root,
incGroups=None,
excGroups=None,
pvMap=None,
syncRead=True,
threadCount=0):
self._root = root
self._base = base
self._log = pyrogue.logInit(cls=self)
self._syncRead = syncRead
self._srv = rogue.protocols.epicsV3.Server(threadCount)
self._pvMap = pvMap
self._incGroups = incGroups
self._excGroups = excGroups
self._started = False
def __init__(self, attrs):
super().__init__(name=attrs['name'],
description=attrs['description'],
expand=attrs['expand'],
hidden=attrs['hidden'])
self._path = attrs['path']
self._class = attrs['class']
self._nodes = attrs['nodes']
self._bases = attrs['bases']
# Tracking
self._parent = None
self._root = None
self._client = None
self._functions = []
# Setup logging
self._log = pr.logInit(cls=self, name=self.name, path=self._path)
def __init__(self,*,base,root,pvMap=None, syncRead=True, threadCount=0):
self._root = root
self._base = base
self._log = pyrogue.logInit(cls=self)
self._syncRead = syncRead
self._srv = rogue.protocols.epicsV3.Server(threadCount)
if not root.running:
raise Exception("Epics can not be setup on a tree which is not started")
if pvMap is None:
doAll = True
self._pvMap = {}
else:
doAll = False
self._pvMap = pvMap
# Create PVs
for v in self._root.variableList:
self._addPv(v,doAll)
def __init__(self, *, variable, localSet, localGet, value):
self._path = variable.path
self._mode = variable.mode
self._device = variable.parent
self._localSet = localSet
self._localGet = localGet
self._variable = variable
self._variables = [variable] # Used by poller
self._value = value
self._lock = threading.RLock()
self._doUpdate = False
self._enable = True
# Setup logging
self._log = pr.logInit(cls=self, name=self._path)
# Wrap local functions
self._localSetWrap = pr.functionWrapper(
function=self._localSet,
callArgs=['dev', 'var', 'value', 'changed'])
self._localGetWrap = pr.functionWrapper(function=self._localGet,
callArgs=['dev', 'var'])
def __init__(self, addr="localhost", port=9099):
if hash((addr, port)) in VirtualClient.ClientCache:
return
VirtualClient.ClientCache[hash((addr, port))] = self
rogue.interfaces.ZmqClient.__init__(self, addr, port, False)
self._varListeners = []
self._monitors = []
self._root = None
self._link = False
self._ltime = time.time()
# Setup logging
self._log = pr.logInit(cls=self, name="VirtualClient", path=None)
# Get root name as a connection test
self.setTimeout(1000, True)
self._root = None
while self._root is None:
self._root = self._remoteAttr('__ROOT__', None)
print("Connected to {} at {}:{}".format(self._root.name, addr, port))
self._root._parent = self._root
self._root._root = self._root
self._root._client = self
setattr(self, self._root.name, self._root)
# Link tracking
self._link = True
self._ltime = self._root.Time.value()
# Create monitoring thread
self._monEnable = True
self._monThread = threading.Thread(target=self._monWorker)
self._monThread.start()
def __init__(self, url):
self._log = pr.logInit(cls=self, name="SqlReader", path=None)
self._url = url
self._conn = None
try:
conn = sqlalchemy.create_engine(self._url)
self._log.info("Opened database connection to {}".format(
self._url))
except Exception as e:
self._log.error(
"Failed to open database connection to {}: {}".format(
self._url, e))
return
self._metadata = sqlalchemy.MetaData(conn)
self._varTable = sqlalchemy.Table('variables',
self._metadata,
autoload=True)
self._logTable = sqlalchemy.Table('syslog',
self._metadata,
autoload=True)
self._conn = conn