async def main(): client = Client("opc.tcp://localhost:53530/OPCUA/SimulationServer/") client.set_security_string( "Basic256Sha256,Sign,certificate-example.der,private-key-example.pem") client.session_timeout = 2000 async with client: root = client.nodes.root objects = client.nodes.objects while True: print("childs og objects are: ", await objects.get_children()) await asyncio.sleep(1)
async def test_subscription_keepalive_count(mocker): """ Check the subscription parameter MaxKeepAliveCount value with various publishInterval and session_timeout values. """ mock_subscription = mocker.patch( "asyncua.common.subscription.Subscription.init", new=CoroutineMock()) c = Client("opc.tcp://fake") # session timeout < publish_interval c.session_timeout = 30000 # ms publish_interval = 1000 # ms handler = 123 sub = await c.create_subscription(publish_interval, handler) assert sub.parameters.RequestedMaxKeepAliveCount == 22 # session_timeout > publish_interval c.session_timeout = 30000 publish_interval = 75000 sub = await c.create_subscription(publish_interval, handler) assert sub.parameters.RequestedMaxKeepAliveCount == 0
def test_get_keepalive_count(mocker): """ Check the subscription parameter MaxKeepAliveCount value with various publishInterval and session_timeout values. """ c = Client("opc.tcp://fake") # session timeout < publish_interval publish_interval = 1000 # ms c.session_timeout = 30000 # ms keepalive_count = c.get_keepalive_count(publish_interval) assert keepalive_count == 22 # session_timeout > publish_interval publish_interval = 75000 c.session_timeout = 30000 keepalive_count = c.get_keepalive_count(publish_interval) assert keepalive_count == 0 # RequestedPublishingInterval == 0 publish_interval = 0 keepalive_count = c.get_keepalive_count(publish_interval) assert keepalive_count == 22
def __init__(self, config: HaConfig, security: Optional[HaSecurityConfig] = None, loop=None) -> None: self._config: HaConfig = config self._keepalive_task: Dict[KeepAlive, asyncio.Task] = {} self._manager_task: Dict[HaManager, asyncio.Task] = {} self._reconciliator_task: Dict[Reconciliator, asyncio.Task] = {} self._gen_sub: Generator[str, None, None] = self.generate_sub_name() self.loop: asyncio.unix_events._UnixSelectorEventLoop = ( loop or asyncio.get_event_loop()) self._url_to_reset_lock = asyncio.Lock(loop=self.loop) self._ideal_map_lock: asyncio.Lock = asyncio.Lock(loop=self.loop) self._client_lock: asyncio.Lock = asyncio.Lock(loop=self.loop) self.clients: Dict[Client, ServerInfo] = {} self.active_client: Optional[Client] = None # full type: Dict[str, SortedDict[str, VirtualSubscription]] self.ideal_map: Dict[str, SortedDict] = {} self.sub_names: Set[str] = set() self.url_to_reset: Set[str] = set() self.is_running = False if config.ha_mode != HaMode.WARM: # TODO # Check if transparent redundancy support exist for the server (nodeid=2035) # and prevent using HaClient with such servers. raise NotImplementedError( f"{config.ha_mode} not currently supported by HaClient") for url in self.urls: c = Client(url, timeout=self._config.request_timeout, loop=self.loop) # timeouts for the session and secure channel are in ms c.session_timeout = self._config.session_timeout * 1000 c.secure_channel_timeout = self._config.secure_channel_timeout * 1000 c.description = self._config.session_name server_info = ServerInfo(url) self.clients[c] = server_info self.ideal_map[url] = SortedDict() # security can also be set via the set_security method self.security_config: HaSecurityConfig = (security if security else HaSecurityConfig()) self.manager = HaManager(self, self._config.manager_timer) self.reconciliator = Reconciliator(self._config.reconciliator_timer, self)