def __init__(self):
ConfigurableNode.__init__(self)
self._url = 'unknown'
self._poll_event = None
self._period = 0.2
# Pre-load attributes.
self.off_text = "Off"
self.on_text = "On"
self.auto_text = "Auto"
self.reverse_output = 0
self.output = REQUIRED
self.input = REQUIRED
self.period = self._period
self.asyncOK = 1
self.state = 2
self.debug = 0
self.__running = False
self._init_debug()
self.OFF = EnumeratedValue(0, self.off_text)
self.ON = EnumeratedValue(1, self.on_text)
self.AUTO = EnumeratedValue(2, self.auto_text)
self._NORMAL = 0
self._SAFETY = 1
self._output_state = self._NORMAL
self._output_lock = Lock()
self._changes_at = 0
self._waiting_value = None
self._value = None
self._lock = Lock()
return
def __init__(self):
self.rt_request_obj = device.real_time_value_req()
self.rt_response_obj = device.real_time_value_res()
self.cr_request_obj = device.control_relay_req()
self.cr_response_obj = device.control_relay_res()
self.rt_lock = Lock()
self.cr_lock = Lock()
self.rt_last_updated = 0
super(DeviceRT, self).__init__()
def __init__(self):
CompositeNode.__init__(self)
EventProducerMixin.__init__(self)
self._schedule_lock = Lock()
self._schedule_condition = Condition()
self._value_lock = Lock()
self._value_condition = Condition()
self.__schedule = None
self.__value = None
def __init__(self):
Calculator.__init__(self)
EventProducerMixin.__init__(self)
self._state = self.INITIALIZING
self._current_id = None
self._scheduled = None
self._state_lock = Lock()
self._schedule_lock = Lock()
self.require_acknowledge = 0
return
def __init__(self):
self._cpex_lock=RLock() # cpex switch list lock, used for setting/getting the "primary" cpex switch.
self._cache_lock=Lock() # domain value cache lock.
self._cpex_switch_map_lock = Lock() # lock for cpex switches cache data structure
self._cache_value=None
self._cache_time=0
self._cpex_switch_map_cache=SwitchMap({})
self._cpex_switch_map_time=0
self.ttl=30
self._reinit()
return
def __init__(self, port):
self.lock = Lock()
self.port = port
self.units = {}
self.connected = 0
if not port.is_open():
port.open()
def __init__(self):
self.__alarm_queue = Queue()
self.__current_thread = None
self.__lock = Lock()
self._init_default_attribute_values()
Client.__init__(self)
return
def __init__(self):
self.observers = {}
self.data = None
self.running = False
self._ob_lock = Lock()
super(BrivoDispatcher, self).__init__()
return
def __init__(self, *args, **kw):
DefaultTestFixture.__init__(self, *args, **kw)
EventConsumerMixin.__init__(self, self.change_of_value)
self.__event_lock = Lock()
self.__event_updated_values = {}
self._cov_counter = 0
return
def setUp(self):
DefaultTestFixture.setUp(self)
self.lock = Lock()
self.pool = ThreadPool(3)
self.queue = Queue()
self.simple_action_counter = 0
return
def __init__(self):
Exporter.__init__(self)
EventConsumerMixin.__init__(self, self.handle_connected,
self.connection_event_error)
self.running = 0
self._scheduled = None
self._lock = Lock()
def __init__(self):
super(DRASManager, self).__init__()
self.__scheduled = None
self.__observers = {}
self.__lock = Lock()
self.running = 0
return
def __init__(self,
ion,
slave_address,
writer_class,
ttl=1.0,
entry=None,
ip=None):
self.ion = ion
self.lh = ion.line_handler
self.slave_address = slave_address
self.writer = writer_class(self)
self.ttl = ttl
self.start = None
self.count = 0
self.last = self.start
self.map = {}
self.command = None
self.response = None
self.timestamp = time()
self.entry = entry
self.ip = ip
self.lock = Lock() # Light weight, non-reentrant lock.
self.error_count = 0
self.last_error = None
self.error_rate = 0.0
def __init__(self):
self.address = '000000000000'
#don't pay attention to the value of bin_addr, it's randomly chosen
self.bin_addr = '\x74\x60\x01\x43\x61\x09'
self.last_updated = 0
self.lock = Lock()
super(OmniDevice, self).__init__()
class SocketMapNotifier(asyncore.dispatcher, object):
usednames = weakref.WeakValueDictionary()
classlock = Lock()
def __unused_socket_name(self, suffix):
while True:
socket_name = os.path.join(
TMP_DIR, 'SocketMapNotifier-%d.%04d' % (gettid(), suffix))
if not self.usednames.has_key(socket_name):
return socket_name, suffix
suffix += 1
raise EUnreachable()
def __socket_name(self):
suffix = 1
socket_name, suffix = self.__unused_socket_name(suffix)
while os.path.exists(socket_name):
try:
os.remove(socket_name)
except:
suffix += 1
socket_name, suffix = self.__unused_socket_name(suffix)
self.usednames[socket_name] = self
return socket_name
def __setup_sockets(self):
socket_name = self.__socket_name()
listen = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
listen.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
listen.bind(socket_name)
listen.listen(1)
self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.connect(socket_name)
self.__output, addr = listen.accept()
self.__output.setblocking(0)
listen.close()
finally:
os.remove(socket_name)
return
def __init__(self, map):
self.__map = map
self.__output = None
super(SocketMapNotifier, self).__init__(None, None)
self.classlock.acquire()
try:
self.__setup_sockets()
finally:
self.classlock.release()
return
def wakeup(self):
try:
self.__output.send('B')
except socket.error, why:
if why[0] != EWOULDBLOCK:
raise
return
def __init__(self):
AutoDiscoveredNode.__init__(self)
self._who_is_thread = None
self.found_devices = {} #all devices on network
self._lock = Lock()
self.running = 0
self._device_table_size = 0
self.bcu_list = []
def __init__(self, node):
self.__lock = Lock()
self.__last_save = {}
self.max_seq = -1
self.pending_seqs = []
self.inprocess_seqs = []
PersistentDataObject.__init__(self, node, auto_load=True)
return
def __init__(self):
self._subscription_lock = Lock()
self._subscribed = 0
self._subscribers = {}
self._last_value = None
self._last_rcvd = None
self._decode_indexes = {}
return
def __init__(self):
self._link = None #get 'actual' node
self.link = None
self._proxy_get = None #set to actual's preferred get method
self._proxy_set = None
self._proxy_start_exception = None
self._proxy_sid = None
self.proxy_direction = GET_ONLY #direction subscription "pushes" the data
self._proxy_active_source = None
self._proxy_active_destination = None
self._proxy_active_lock = Lock()
self._proxy_active_thread_lock = Lock()
self._proxy_active_event = None
self._proxy_trigger_counter = 0
self._retry_win_high = 30
EventConsumerMixin.__init__(self, self.change_of_value)
self.debug = debug
def __init__(self):
self.lightpoints = {}
self.running = False
self.endpoint = None
self.lh = None
self._seq_num = 1
self._sched_lock = Lock()
super(Gateway, self).__init__()
def __init__(self):
self.__lock = Lock()
self.__rids = {}
self.__identifiers = {}
self.__rid_filters = {}
self.__class_cache = {}
self.__consumers = weakref.WeakKeyDictionary()
self.__pending = []
def __init__(self):
self._lock = Lock()
self._started = 0
self._alarm = [] # can have a whole MESS o' alarms at startup...
self._scheduled = None
self.trigger_node_url_posn = None # allow source stamping
self.trigger_node_msg_posn = None # allow source stamping
self._waiting_alarm_sid = None
ServiceNode.__init__(self)
def __init__(self):
self._base64string = None
self._group_lock = Lock()
self._request_q = Queue()
self._transaction_q = Queue()
self._backed_up = False
self.__s_id = id(self)
super(Station, self).__init__()
return
def __init__(self, timeout, scan_time):
#self._c == {group_id:{addr:last_msg}}
self._c = {}
self._cache_lock = Lock() #can add more granular locking, if need be
self._subscr_list = {} # == {(group_id,addr):[call_back_meth]} ...
self.timeout = timeout
if not scan_time:
self.scan_time = max(self.timeout / 4, 30)
self._scan_scheduled = None
def __init__( self ):
ConfigurableNode.__init__( self )
self.isRunning = 0
self.ipcheck_pid = 0
self._lock = Lock()
self.thread = None
self.first_time = 0
self.log_name = 'broadway'
self.update_count = 0
def __init__(self):
Node.__init__(self)
self._dev_name = None # Can programmatically override BEFORE start.
self._lock = Lock()
self._popen = None
self._apps = []
self._groups = []
self._discovery_ts = None
return
def __init__(self):
self._last_rcvd = 0
self._subscribers = 0
self._scheduled = None
self._skip_cache = False
self._cached_result = None
self._exec_delay = _Buffer(5)
self._subscription_lock = Lock()
CompositeNode.__init__(self)
EventProducerMixin.__init__(self)
def __init__(self,socket,*args):
if not isinstance(socket,_Socket):
raise EInvalidValue('socket',socket,
'Must be mpx.lib.socket.socket')
self._safety = 0
if isinstance(socket,_SafetySocket):
self._safety = 1
self._socket = socket
self._ssl = _original_ssl(socket._socket,*args)
self._lock = Lock()
def __init__(self, parent, line_handler, command, timeout=1.0):
self._ion = parent
self._lh = line_handler
self._command = command
self._timeout = timeout
self._cache = None
self._timestamp = time.time()
self._expire_after = self._timestamp - 1.0
self._lock = Lock() # Light weight, non-reentrant lock.
self._map = {}
def __init__(self):
self._history = None
self._history_lock = Lock()
self._sid = None
self._nid = 1
self._poll_failure = False
self._scheduled = None
self.running = False
super(Kwh2Kw, self).__init__()
return
