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