def __init__(self):
self._threadpool = None
self._init_complete = False
self._port = None
self._request = {} # k:(rqst_type, addr,) v: request object
self.__update_freqs = {}
self.__callbacks = {}
self.__callback_lock = threading.Lock()
self.__port_lock = threading.Lock()
CompositeNode.__init__(self)
def __init__(self, port):
self.port = port
self._lock = threading.Lock() #for coordinating between threads
self._condition = threading.Condition(self._lock)
self._mutex = threading.Lock() #allow only one exclusive access at a time
self._running = 0
self._thread = None
self.debug = debug
self._offline = 0
self.point_dictionary = {}
self.broadcast_lists = {}
self.password = ''
def __init__(self):
CompositeNode.__init__(self)
self._internal_lock = threading.Lock()
self._lock = threading.Lock() # @todo - use a separate lock for reading and writing - C.Turner
self._devlock = None
self.poll = None
self.file = None
self._buf = array.array('c')
self._lock_requests = 0
self._blocking = 0
return
def __init__(self, length=None):
self.length = length
self.datastream = StringIO.StringIO()
self._lock = threading.Lock()
self._condition = threading.Condition(self._lock)
self._stream_closed = 0
self._done_collecting = 0
def __init__(self, name):
_logs_lock.acquire()
try:
if _logs.has_key(name):
from mpx.lib.msglog import types
raise ENameInUse(name, logtype=types.ERR)
self._lock = threading.Lock()
self._lock.acquire()
_logs[name] = self
finally:
_logs_lock.release()
try:
self.name = name
self.eval = RExec().r_eval
self.path = properties.LOGFILE_DIRECTORY
self.filename = os.path.join(self.path, self.name + ".log")
self.data_manager = _LogDataManager(self.filename)
self._slice_position = 0
self.max_return_length = 100000
self.last_values = self._get_last_row()
# It is likely that the log contains a higher seq number than
# the one that was last saved by DataManager, if so, update it.
# NOTE: the data manager will have a higher number if a trim_g* was
# done and then the log was closed.
if self.last_values:
if self.last_values[-1] >= self.data_manager.inspect_seq():
self.data_manager.set_seq(self.last_values[-1] + 1)
else:
self.last_values = []
finally:
self._lock.release()
def __init__(self):
self.__callbacks = {}
self.__callback_lock = threading.Lock()
self._rqst_queue = None
self.running = False
self.port = None
super(WXT510AsciiNetwork, self).__init__()
def __init__(self):
self._running = 0
self.driver = None
self.mac_address = None
self.discovery_mode = 'None'
CompositeNode.__init__(self)
AutoDiscoveredNode.__init__(self)
EventProducerMixin.__init__(self)
self.device_map = {} #keyed by mac address of clients; value=Child node
self._out_q = [] #request queue
self._out_q_cv = threading.Condition()
self._mutex = threading.Lock() #prevent multiple access to outbound commands
self._registered_clients = {}
self.transceiver_state = TransceiverState[0]
self.cov = ChangeOfValueEvent(self, None, self.transceiver_state)
self.debug = debug
self.timeout = 10 #seconds
self.who_is_interval = 10 #seconds
self.default_discovered_protocol_module = None
# @todo
# initailize this through configuration
self.default_discovered_protocol_module = feu
self.transceiver_state = 0
self.relay_node = '/interfaces/relay1' #this is temporary, should be None
self.active_devices = {}
self.status = None
def __init__(self, *args):
# This is required for use of older system, remove later...
self.__system_lock = threading.Lock()
self.__renaming_user = None
self.__running = threading.Event()
self.__sysadmin = None
self.__anonymous = None
super(UserManager, self).__init__(*args)
def __init__(self, *args):
self.dispatcher = Dispatcher()
self._lock = threading.Lock()
self.roles = []
self.readonly = []
self.homepage = '/'
self.__password = ''
self.description = ''
super(User, self).__init__(*args)
def __init__(self):
self._last_result = None
CompositeNode.__init__(self)
EventProducerMixin.__init__(self)
self._subscribe_lock = threading.Lock()
self._subscribed = 0
self._last_rcvd = 0
self._cached_result = None
self._msg_req_type = None
self._device_node = None
self._protocol_node = None
def __init__(self, log, period, trigger=None):
self.log = log
self.period = period
self.poll = select.poll()
self._lock = threading.Lock()
self._scheduled = None
self.running = 0
self.msglog = mpx.lib.msglog
self.columns = []
self.trigger = trigger
self._collect_failure = {}
def __init__(self, callback, buffer_size=1024):
CrossThreadStream.__init__(self)
self._lock = threading.Lock()
self._pollout = select.poll()
self._pollout.register(self.c_connection.fileno(), select.POLLOUT)
self._callback = callback
self.c_connection.setblocking(0)
self.s_connection.setblocking(1)
self._meta = {}
self._buffer_size = buffer_size
self._buffer = ''
def __init__(self):
self._lock = threading.Lock()
self._lock.acquire()
try:
self._poll_obj = select.poll()
self._far_cmd_skt = None
self._near_cmd_skt = None
self._create_cmd_skts(self._tmp_dir)
self._poll_obj.register(self._near_cmd_skt.fileno(), select.POLLIN)
finally:
self._lock.release()
return
def __init__(self):
CompositeNode.__init__(self)
self._internal_lock = threading.Lock()
self._lock = threading.RLock()
self._devlock = None
self.poll = None
self.file = None
self._buf = array.array('c')
self._lock_requests = 0
self._blocking = 0
return
def __init__(self,name):
self._write_lock = _threading.Lock()
self._trim_lock = _threading.Lock()
self._trim_lock.acquire()
self._write_lock.acquire()
try:
self.name = name
self._queue = []
self.eval = _security.RExec().r_eval
self.path = properties.LOGFILE_DIRECTORY
self.filename = os.path.join(self.path, self.name + ".log.2")
self.data_manager = LogDataManager(self.filename)
# If our file doesn't exist and one without a version number
# does, rename it (upgrade).
if (not os.path.exists(self.filename)
and _prior_version_exists(self.name,self.path)):
from mpx.upgrade.log import log_1
old = log_1.LogObject(name)
self.data_manager.upgrade(old.data_manager)
os.rename(old.filename,self.filename)
old.destroy()
del(log_1)
self._slice_position = 0
self.last_values = self._get_last_row()
# It is likely that the log contains a higher seq number than
# the one that was last saved by DataManager, if so, update it.
# NOTE: the data manager will have a higher number if a trim_g* was
# done and then the log was closed.
if self.last_values:
if self.last_values[-1] >= self.data_manager.inspect_seq():
self.data_manager.set_seq(self.last_values[-1] + 1)
else:
self.last_values = []
finally:
self._write_lock.release()
self._trim_lock.release()
def __init__(self):
self.__q = Queue.Queue()
self.__lock = threading.Lock()
def __init__(self):
self._process = None # Object returned by popen2.Popen4()
self._is_connected = 0 # 1 if connected, 0 otherwise
self._lock = threading.Lock(
) # Lock to make connect/disconnect thread safe
def __init__(self,*args,**kw):
self.__lock = threading.Lock()
return
def configure(self, columns, min_size=250, max_size=500):
self.set_limits(min_size, max_size)
LogObject.configure(self, columns)
self._trim_check = _threading.Lock()
return
class AVR(CompositeNode):
# Thread-safe lock. Should be extended to be process independant.
_lock = threading.Lock()
def __init__(self):
CompositeNode.__init__(self)
self.debug = 0
##
# @see mpx.ion.host.Host#configure
#
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, 'ncounters', REQUIRED, config, int)
set_attribute(self, 'nDIs', REQUIRED, config, int)
set_attribute(self, 'nrelays', REQUIRED, config, int)
set_attribute(self, 'ndallas_busses', REQUIRED, config, int)
set_attribute(self, 'nGPIOs', REQUIRED, config, int)
# Open the avr devices.
self.avr = None
self.avroob = None
try:
self.avr = open("/dev/avr", "r+")
self.avroob = open("/dev/avroob", "r")
self.p = select.poll()
self.p.register(self.avroob, select.POLLIN)
avr_maj_ver = ord(self.invoke_message('\x17\x00\x00')[0])
if (avr_maj_ver < 2) and (self.nGPIOs > 0):
self.nGPIOs = 0
msglog.log('mpx',msglog.types.ERR,'No GPIOs created; AVR version is %s; should be 2.x or greater.' \
% self.version())
# Attach the counters, relays and dallas busses to the AVR.
config_list = (('mpx.ion.host.avr.counter', 'counter',
self.ncounters), ('mpx.ion.host.avr.di', 'DI',
self.nDIs),
('mpx.ion.host.avr.relay', 'relay', self.nrelays),
('mpx.ion.host.avr.dallasbus', 'dallas',
self.ndallas_busses), ('mpx.ion.host.avr.gpio',
'gpio', self.nGPIOs))
for module, prefix, count in config_list:
for i in range(1, count + 1):
name = prefix + str(i)
config = {
'name': name,
'id': i,
'avr': self,
'parent': self
}
ion = mpx.lib.factory(module)
ion.configure(config)
except:
msglog.log('broadway', msglog.types.ERR,
"Failed to open avr device.")
msglog.exception()
self.p = select.poll()
if self.avr:
self.avr.close()
self.avr = None
if self.avroob:
self.avroob.close()
self.avroob = None
pass
return
# Actual AVR code.
##
# Lock AVR for safe access.
#
def lock(self):
self._lock.acquire()
return
##
# Unlock AVR to allow access.
#
def unlock(self):
self._lock.release()
return
##
# Print msg.
#
# @param msg Message to be printed.
#
def dump(self, msg):
for b in msg:
print "%02x" % (ord(b)),
print
##
# Get the version of the AVR module.
#
# @return AVR Version number.
#
def version(self):
rsp = self.invoke_message('\x17\x00\x00')
return "%d.%d" % (ord(rsp[0]), ord(rsp[1]))
def wait_for_oob(self):
# Only used by the AVR event thread.
self.p.poll()
return
##
# Send message to AVR.
#
# @param msg Message to send.
# @return Response sent back from AVR.
#
def invoke_message(self, msg):
self.lock()
try:
if self.debug:
print '> ',
self.dump(msg)
self.avr.write(msg)
hdr = self.avr.read(3)
rsp = self.avr.read(ord(hdr[2]))
if self.debug:
print '< ',
self.dump(rsp)
finally:
self.unlock()
pass
return rsp
from _log import LogEvent
from _log import LogObjectInfo
from _binary import BinaryColumnConfiguration
class _LogDict(dict):
def singleton_unload_hook(self):
pass
from mpx.lib import _singleton
_logs = _singleton.ReloadableSingletonFactory(_LogDict)
_logs_lock = threading.Lock()
def _setup_new_log(name, class_ref):
_logs_lock.acquire()
try:
if not _logs.has_key(name):
_logs[name] = class_ref(name)
elif not ((hasattr(_logs[name], '__outside_log')
and _logs[name].__outside_log)
or isinstance(_logs[name], class_ref)):
# The existing instance is not an instanciation of class_ref, nor
# of a class derived from class_ref.
raise ENameInUse(name)
log = _logs[name]
finally:
0x00, 0x00, 0x00, 0x00, type, b_data[0], b_data[1], 0x00
])
if (ext):
pkt.extend(ext) # add extension to hdr
pkt.extend(
array.array('B', [b_flags[0], b_flags[1], b_flags[2], b_flags[3]]))
debug_print(1, 'Formed outgoing pkt:')
if debug_lvl > 0:
print_array_as_hex(pkt)
return pkt
host_channel_lock = threading.Lock()
class RzHostPkt(object):
def __init__(self, pkt=None):
self._pkt = pkt
def tofile(self, fileno):
#only one request at a time - once we do sequence packets we can relax this
host_channel_lock.acquire()
try:
#examine type of packet going to modem server and prepare for response
type = self._pkt[6]
self._pkt.tofile(fileno)
#wait for ACK or response
finally:
