issue_owner_repo listlengths 2 2 | issue_body stringlengths 0 262k ⌀ | issue_title stringlengths 1 1.02k | issue_comments_url stringlengths 53 116 | issue_comments_count int64 0 2.49k | issue_created_at stringdate 1999-03-17 02:06:42 2025-06-23 11:41:49 | issue_updated_at stringdate 2000-02-10 06:43:57 2025-06-23 11:43:00 | issue_html_url stringlengths 34 97 | issue_github_id int64 132 3.17B | issue_number int64 1 215k |
|---|---|---|---|---|---|---|---|---|---|
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello there,
the element "RequiredModel" in some xml files (e.g. machinery) is not handled.
This causes crashes, if a special order while importing was not adhered. (import DI.xml -> import Machinery.xml ✔️ ; import Machinery.xml -> import DI.xml ❌ )
Some solution inspirations:
- import just fails, but with error that schema bar requires schema foo first. (would be quick, but dirty and more helpful)
- a list of all wanted schemas has to be passed to xmlparser with their path, instead of a single string with a path. Then the order will be figured out by that tag and the nodes imported in a working order (if a required schema is not in that list, it shall be tried to find it in the schema folder, otherwise fail) | xmlparser - requiredModel not handled | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/353/comments | 4 | 2020-12-07T12:31:03Z | 2021-01-06T07:57:14Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/353 | 758,467,028 | 353 |
[
"FreeOpcUa",
"opcua-asyncio"
] | After some longer time of operation I get the error below.
What can be done here? Is this a client problem, or just missing an adjustment on the OPC-UA server?
Code:
```python
url = f'opc.tcp://{cfg.endpoint}:{cfg.port}/'
async with Client(url=url) as client:
uri = 'http://Interface_1'
idx = await client.get_namespace_index(uri)
var = await client.nodes.root.get_child(
["0:Objects", "3:ServerInterfaces", f"{idx}:Interface_1",
f"{idx}:Gate"])
dv = ua.DataValue(ua.Variant(gate, ua.VariantType.Int16))
await var.write_value(dv) # set node value using implicit data type
var = await client.nodes.root.get_child(
["0:Objects", "3:ServerInterfaces", f"{idx}:Interface_1",
f"{idx}:Parcel_Barcode"])
val = '---'
dv = ua.DataValue(ua.Variant(val, ua.VariantType.String))
await var.write_value(dv) # set node value using implicit data type
var = await client.nodes.root.get_child(
["0:Objects", "3:ServerInterfaces", f"{idx}:Interface_1",
f"{idx}:Customer_Reference"])
val = '---'
dv = ua.DataValue(ua.Variant(val, ua.VariantType.String))
await var.write_value(dv) # set node value using implicit data type
var = await client.nodes.root.get_child(
["0:Objects", "3:ServerInterfaces", f"{idx}:Interface_1",
f"{idx}:Carrier"])
val = '---'
dv = ua.DataValue(ua.Variant(val, ua.VariantType.String))
await var.write_value(dv) # set node value using implicit data type
var = await client.nodes.root.get_child(
["0:Objects", "3:ServerInterfaces", f"{idx}:Interface_1",
f"{idx}:New_Data"])
dv = ua.DataValue(ua.Variant(True, ua.VariantType.Boolean))
await var.write_value(dv) # set node value using implicit data type
await asyncio.sleep(0.1)
var = await client.nodes.root.get_child(
["0:Objects", "3:ServerInterfaces", f"{idx}:Interface_1",
f"{idx}:OK"])
while await var.read_value() is False:
await asyncio.sleep(0.4)
```
```
Traceback (most recent call last):
File "/home/user/automation/packing/tasks/final.py", line 169, in answer
await _send_opc_ua(gate, parcel, shipping_information)
File "/home/user/automation/packing/tasks/final.py", line 76, in _send_opc_ua
async with Client(url=url) as client:
File "/home/user/lib/python3.7/site-packages/asyncua/client/client.py", line 72, in __aenter__
await self.connect()
File "/home/user/automation/lib/python3.7/site-packages/asyncua/client/client.py", line 245, in connect
await self.create_session()
File "/home/user/automation/lib/python3.7/site-packages/asyncua/client/client.py", line 368, in create_session
response = await self.uaclient.create_session(params)
File "/home/user/automation/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 298, in create_session
data = await self.protocol.send_request(request)
File "/home/user/automation/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 151, in send_request
self.check_answer(data, f" in response to {request.__class__.__name__}")
File "/home/user/automation/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 160, in check_answer
hdr.ServiceResult.check()
File "/home/user/automation/lib/python3.7/site-packages/asyncua/ua/uatypes.py", line 220, in check
raise UaStatusCodeError(self.value)
asyncua.ua.uaerrors._auto.BadTooManySessions: "The server has reached its maximum number of sessions."(BadTooManySessions)
```
| asyncua.ua.uaerrors._auto.BadTooManySessions: "The server has reached its maximum number of sessions." | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/351/comments | 3 | 2020-12-01T20:40:04Z | 2021-04-26T09:57:16Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/351 | 754,710,191 | 351 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi there!
Got a bit of what is potentially more of a conceptual issue. I am currently trying to detect events from a Beckhoff PLC's OPCUA-server, with a asyncua client. Firstly, to show what I'm after: using prosys OPCUA client, i can get a list of events that have happened like so:
and I would like to have that event list available in a python asyncua client script. So, I wrote something like:
```
import asyncio
import logging
from asyncua import Client
from datetime import datetime
logging.basicConfig(level=logging.INFO)
_logger = logging.getLogger(__name__)
class SubHandler:
"""
Subscription Handler. To receive events from server for a subscription
data_change and event methods are called directly from receiving thread.
Do not do expensive, slow or network operation there. Create another
thread if you need to do such a thing
"""
def event_notification(self, event):
_logger.info("New event received: %r", event)
async def main():
url = "opc.tcp://{IP}:4840"
async with Client(url=url) as client:
msclt = SubHandler()
sub = await client.create_subscription(50, msclt)
handle = await sub.subscribe_events(client.nodes.server)
await asyncio.sleep(100)
```
And nothing is received. my guess is that the subscription here only responds to *new* events and not existing ones which are still unacknowledged:
a) is that correct?
b) is there other functionality to get unacknowledged or still active events?
Any help would be greatly appreciated, i hope you're all having a good day! | Get event list as client | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/347/comments | 4 | 2020-11-25T16:03:15Z | 2020-11-26T09:22:27Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/347 | 750,941,070 | 347 |
[
"FreeOpcUa",
"opcua-asyncio"
] | My open62541 server sends a keep-alive message every 10 seconds when the Python client has a subscription. This is expected according to the OPC UA spec (see also #263). However, the Python client logs a warning every time one of these messages are received.
> NotificationMessage is None.
This comes from https://github.com/FreeOpcUa/opcua-asyncio/blob/6c504f24387b7fca2fae58546717d8200465ef16/asyncua/common/subscription.py#L107
This should be removed.
Also reported here: https://github.com/FreeOpcUa/python-opcua/issues/1137 | UA Client needlessly warns about the KeepAlive Message ("NotificationMessage is None.") | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/345/comments | 1 | 2020-11-25T07:49:35Z | 2020-11-25T07:57:04Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/345 | 750,581,530 | 345 |
[
"FreeOpcUa",
"opcua-asyncio"
] | https://github.com/FreeOpcUa/opcua-asyncio/blob/a0b1d2d16335f27008bc1018bf569bb36cbbb12b/asyncua/common/type_dictionary_buider.py#L163
What is the problem here?
Is this issue still existing?
Edit: I guess there is an 'l' missing in the file name as well. | Unknown issue in type_dictionary_buider.py | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/344/comments | 0 | 2020-11-23T14:02:46Z | 2023-03-29T10:14:54Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/344 | 748,829,216 | 344 |
[
"FreeOpcUa",
"opcua-asyncio"
] | There are 2 ToDos listed in test_subscription with the comment replace.
Was this a leftover of a sync time.sleep or with what shall sleep being replaced?
https://github.com/FreeOpcUa/opcua-asyncio/blob/cd8b41d828e154b46d8aecc69973805ce0382dc1/tests/test_subscriptions.py#L623 | Unknown replacement in test_serveral_different_events(opc) | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/343/comments | 0 | 2020-11-23T11:29:44Z | 2023-03-29T10:13:58Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/343 | 748,720,146 | 343 |
[
"FreeOpcUa",
"opcua-asyncio"
] | https://github.com/FreeOpcUa/opcua-asyncio/blob/cd8b41d828e154b46d8aecc69973805ce0382dc1/asyncua/ua/uatypes.py#L698
seems to be unused, except in test_unit.py.
The specs says about variants:
> "A Variant is a union of all built-in data types including an ExtensionObject. Variants can also
> contain arrays of any of these built-in types."
Is there a usecase for it?
In case it is removable:
- Remove class from uatypes.py
- Remove tests in test_unit.py or redo them?
In case not:
- remove FixMe
- add better comment what it is and for what it shall be used for | VariantTypeCustom unused | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/342/comments | 1 | 2020-11-23T10:57:44Z | 2023-03-29T10:12:46Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/342 | 748,697,004 | 342 |
[
"FreeOpcUa",
"opcua-asyncio"
] | coverage is a dependency listed in dev_requirements.txt, but it seems to be unused in Travis.
Was it ever used in Travis (or in other testbeds)?
If yes, why isn't it used anymore?
It is annoying to write tests, I know, but it in the long run it will help us to save time and nerves (wich contains a dependency to chocolate in my case, so I would even save money 😄 ). | Coverage dependency unused? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/341/comments | 0 | 2020-11-23T10:04:12Z | 2023-03-29T10:12:29Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/341 | 748,656,518 | 341 |
[
"FreeOpcUa",
"opcua-asyncio"
] | https://github.com/FreeOpcUa/opcua-asyncio/blob/f653d611b210f5a4f8b285382ad6a345f5e30ed9/asyncua/common/structures104.py#L202
Contains two #FIXME which contains two concerns about the correctness of it.
Todo:
- write test(s) for this method
- make tests run
- remove FIXME comments when done
In case this is touching a rat tail of problems (what I guess may happen), open a new issue and make a reference to this one. | Remove concerns in _read_data_type_definition | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/340/comments | 0 | 2020-11-23T09:48:43Z | 2023-03-29T10:11:47Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/340 | 748,644,440 | 340 |
[
"FreeOpcUa",
"opcua-asyncio"
] | https://github.com/FreeOpcUa/opcua-asyncio/blob/f653d611b210f5a4f8b285382ad6a345f5e30ed9/asyncua/common/structures.py#L201
is deprecated, but still used in tests (see e.g. test_custom_structures.py) and in some other files.
It should be replaced with https://github.com/FreeOpcUa/opcua-asyncio/blob/f653d611b210f5a4f8b285382ad6a345f5e30ed9/asyncua/common/structures104.py#L187
Todo:
- replace `load_type_definitions()` with `load_data_type_definitions()` (and so remove it from the project?)
- make tests run (perhaps fixes are necessarry) | load_type_definitions used in tests, but deprecated | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/339/comments | 0 | 2020-11-23T09:41:30Z | 2023-03-29T10:10:57Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/339 | 748,639,093 | 339 |
[
"FreeOpcUa",
"opcua-asyncio"
] | https://github.com/FreeOpcUa/opcua-asyncio/blob/d79d204928c1ea06b6bcca1e07e18fcad5a8221b/asyncua/client/client.py#L625
is logged with a warning of being deprecated, but is used in:
https://github.com/FreeOpcUa/opcua-asyncio/blob/08162c339728fd77fa342d37a869a37c3d1db4ca/tests/test_server.py#L530
and
https://github.com/FreeOpcUa/opcua-asyncio/blob/08162c339728fd77fa342d37a869a37c3d1db4ca/tests/test_server.py#L542
The source of this `load_enums()` is in structure and imported in server.py.
But there is also a `load_enums()` in structures104.py, which seems to be just used for `load_data_type_definitions()`.
Todo:
- ~~replace load_enums from structures.py with load_enums from structure104.py (if necessarry?)~~ (breaking changes in enums?)
- fix mentioned tests
- link from structures.load_enums() to structures104.load_enums() (or shouldn't calling the method anyway and `load_data_type_definition()` shall be called?) | load_enums deprecated, but used in tests | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/338/comments | 6 | 2020-11-23T09:29:37Z | 2023-03-29T10:10:21Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/338 | 748,630,510 | 338 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Steps to reproduce:
1. Ensure that the client is *not* able to connect to the given opc-ua server URI
2. `client.connect()`
3. `client.disconnect()`
The client will raise an `AttributeError`.
If one catches this, the asyncua thread hangs. | cannot stop client if no connection established | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/337/comments | 8 | 2020-11-18T15:12:59Z | 2021-07-20T14:40:28Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/337 | 745,746,540 | 337 |
[
"FreeOpcUa",
"opcua-asyncio"
] | There exist more standard_address_space_parts than used in standard_address_space.py.
Some newer parts seemes to be not imported in [standard_address_space.py](https://github.com/FreeOpcUa/opcua-asyncio/blob/master/asyncua/server/standard_address_space/standard_address_space.py) while running server-minimal.py.
Part12 is containing remaining Nodes if I run server-mininal.py, but perhaps it's just me? | Missing standard_address_spaces in fill_address_space | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/336/comments | 1 | 2020-11-18T09:58:12Z | 2021-02-12T19:38:37Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/336 | 745,510,269 | 336 |
[
"FreeOpcUa",
"opcua-asyncio"
] | There are 4 Tests being skipped of different reasons:
Since the XML file is given from [UA-Nodeset master branch](https://github.com/OPCFoundation/UA-Nodeset), we can't test the xml file itself if a Node is missing or similar. This is a trust thing we have to accept, since we can't change them. We just can report [issues here](https://apps.opcfoundation.org/mantis/my_view_page.php) and yes there are issues existing in these files.
I guess this test shall show, that the Number of XML Elements containing Aliases in a file is the same as Reference Nodes being created out of the same XML file...not sure if this is usable.
- https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/tests/test_standard_address_space.py#L54
I dont't know what with "theat" is meant. 😕
- https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/tests/test_custom_structures.py#L90
- https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/tests/test_custom_structures.py#L321
~~This test pass. Perhaps this was fixed with #130~~ ✔️ (done)
- https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/tests/test_xml.py#L67
| Redo skipped tests | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/334/comments | 2 | 2020-11-18T08:33:03Z | 2023-03-29T10:09:52Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/334 | 745,449,680 | 334 |
[
"FreeOpcUa",
"opcua-asyncio"
] | While tackling the lxml topic in #331 , I found some tests which are using deprecated methods:
load_type_definitions() from
https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/asyncua/server/server.py#L619 in (for example):
https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/asyncua/server/server.py#L619
and load_enums() from https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/asyncua/server/server.py#L636 in (for example):
https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/tests/test_server.py#L514
Since 1:1 replacement doesn't work these should be updated. | Tests running deprecated Methods load_type_definitions and load_enums | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/333/comments | 1 | 2020-11-17T13:01:55Z | 2020-12-02T07:47:52Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/333 | 744,717,279 | 333 |
[
"FreeOpcUa",
"opcua-asyncio"
] | There are existing many #FIXME (40), #TODO (~10?)and Deprecated (?) comments over the whole project.
How up-to-date are they?
If there are already workaround solutions (example: the `load_data_types_definition` exists and should be used instead of `load_types_definitions`, which is deprecated), are they implemented everywhere as well?
EDIT: As well I'm for a ban of future commits in master branch with FIXME/TODOs. If there is something to fix, it should be fixed first and if there is still something TODO it should be done. | Check FIXME, TODO and Deprecation comments up-to-dateness | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/332/comments | 1 | 2020-11-16T12:39:53Z | 2020-11-23T08:33:30Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/332 | 743,805,474 | 332 |
[
"FreeOpcUa",
"opcua-asyncio"
] | It appears there are several issues with `Server.unregister_to_discovery()` and related functionality:
1. `unregister_to_discovery()` is not async and does not await `Client.disconnect`
https://github.com/FreeOpcUa/opcua-asyncio/blob/9925e7d098f8949d3f928ac8fb72fe469c4c07c1/asyncua/server/server.py#L226-L231
which leads to the following error:
```asyncua/server/server.py:228: RuntimeWarning: coroutine 'Client.disconnect' was never awaited```
2. Changing `unregister_to_discovery()` to async and awaiting the `disconnect()` reveals further issues.
If renewal has been scheduled already, `_renew_registration()` continues to be called.
In this case, `client.register_server()` will fail with the following error as the client connection is already closed:
```asyncua/server/server.py:234> exception=ConnectionError('Connection is closed')>```
Removing the disconnected client from `_discovery_clients` resolves that particular issue.
3. The task for renewing keeps being executed even if `unregister_to_discovery` has been called for all registered discovery servers **and** even after the registered server has been **stopped**. The task keeps being rescheduled (and failing) until the event loop itself is stopped.
<details>
<summary>I reproduced the issue with the following snippet</summary>
```python
import asyncio
from asyncua import Server, ua
async def main():
disco = Server()
disco.name = "Discovery"
disco.application_type = ua.ApplicationType.DiscoveryServer
disco.set_endpoint("opc.tcp://0.0.0.0:4840")
disco.set_security_policy([ua.SecurityPolicyType.NoSecurity])
await disco.init()
async with disco:
server = Server()
server.name = "Server"
server.set_endpoint("opc.tcp://0.0.0.0:4841")
server.set_security_policy([ua.SecurityPolicyType.NoSecurity])
await server.init()
async with server:
await server.register_to_discovery(disco.endpoint.geturl(), 1)
await asyncio.sleep(2)
await server.unregister_to_discovery(disco.endpoint.geturl())
await asyncio.sleep(2)
await asyncio.sleep(5)
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```
</details>
#326 addresses those issues | Discovery registration cannot be stopped gracefully | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/328/comments | 1 | 2020-11-03T12:28:36Z | 2021-01-28T07:15:08Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/328 | 735,279,515 | 328 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello together,
I mentioned in #306 that I got some problems with the tests, which interfered eachother.
While testing the stuff through, I thought just changing the fixture to "function" would solve the problem.
But I suspect, that there is a memory leak happening which causes Travis freeze to death (10min. Timeout without response).
I would recommened that either each test cleans up behind itself and finishes clearly (not causing "Address already in use" and similar errors) or for every test a fresh server has to be buildUp and tearedDown afterwards somehow (which I would prefere and accept longer test runs). | Tests share same Server per testfile | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/322/comments | 10 | 2020-10-28T07:40:53Z | 2023-03-29T10:09:03Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/322 | 731,189,903 | 322 |
[
"FreeOpcUa",
"opcua-asyncio"
] | The README.md states, that neither the client nor the server has the XML protocol implemented yet. But the example "simple-client-server-xml" uses an XML-file for the NodeSet. Is this just old information or is there something else meant by "XML protocol"? Or maybe I missed something.
Thanks in advance!
| XML protocol not implemented yet? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/316/comments | 3 | 2020-10-19T11:56:17Z | 2020-10-19T13:28:14Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/316 | 724,542,371 | 316 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I wonder if the community has already considered integrating a high-availability client like described in the `Part 4 section 6.6.2.4.5` of the protocol specification to this library.
For quite some times now, I worked with a HA Client based on the python-opcua client. I am currently rewriting this on top of asyncua and I aim to support the ```Hot``` mode (```6.6.2.4.5.4```) and from there, the ```Warm``` (```6.6.2.4.5.3```) mode shouldn't be too much of a lift.
In a nutshell, the spec describes a higher level client which establishes connections to two identical servers, and promote the server with the highest healthy service level (> 200) as the primary. The difference between primary and secondary being the publishing mode (enabled/disabled) for the subscriptions. Also, the sampling must be activated on the secondary for `Hot`, but disabled for the`Warm` mode.
I plan to have an abstraction layer with an API similar to the Client. A user could then leverage it to create an ideal configuration that will be subsequently applied to the lower clients according to their role. We could use several tasks to:
1. Check the service level
2. Promote a primary and reconnect clients individually
3. Regularly merge the ideal and real configurations when needed.
I would like to know if there's people interested with such a feature and if this could be a good fit within the project. If that's the case, I will be able to suggest some PR soon to discuss the details. | [Topic] Support for HA Client | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/314/comments | 9 | 2020-10-14T22:40:44Z | 2023-03-29T10:07:49Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/314 | 721,841,602 | 314 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I have a running client with subscription that does just fine. After a while, I get the following error and the client disconnects:
```
Exception raised while parsing message from server
Traceback (most recent call last):
File "/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 79, in _process_received_data
msg = self._connection.receive_from_header_and_body(header, buf)
File "/lib/python3.8/site-packages/asyncua/common/connection.py", line 323, in receive_from_header_and_body
self._check_sym_header(security_header)
File "/lib/python3.8/site-packages/asyncua/common/connection.py", line 282, in _check_sym_header
raise ua.UaError(f"Invalid security token id {security_hdr.TokenId}, expected one of: {expected_tokens}")
asyncua.ua.uaerrors._base.UaError: Invalid security token id 18, expected one of: [16, 17, 0]
Error while renewing session
Traceback (most recent call last):
File "/lib/python3.8/site-packages/asyncua/client/client.py", line 387, in _renew_channel_loop
val = await self.nodes.server_state.read_value()
File "/lib/python3.8/site-packages/asyncua/common/node.py", line 167, in read_value
result = await self.read_data_value()
File "/lib/python3.8/site-packages/asyncua/common/node.py", line 178, in read_data_value
return await self.read_attribute(ua.AttributeIds.Value)
File "/lib/python3.8/site-packages/asyncua/common/node.py", line 285, in read_attribute
result = await self.server.read(params)
File "/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 353, in read
data = await self.protocol.send_request(request)
File "/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 141, in send_request
self._send_request(request, timeout, message_type),
File "/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 130, in _send_request
self.transport.write(msg)
AttributeError: 'NoneType' object has no attribute 'write'
```
I'm connecting to a Siemens S7-1200 PLC's built-in OPC-UA server. | Error while renewing session: Invalid security token id 18, expected one of: [16, 17, 0] | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/313/comments | 55 | 2020-10-14T11:13:29Z | 2023-03-29T10:06:53Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/313 | 721,366,810 | 313 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello, I am looking for some documentation / example on how to connect an ethernet controller that supports OPC-UA? I am hoping that this is still an active project?
Anyway, I need to connect a controller on ethernet to the server. I am assuming that when it gets connected all of the folders are automatically populated?
Thanks,
CJ | Connect Ethernet Device to OPC Server (Question) | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/311/comments | 28 | 2020-10-12T13:51:44Z | 2022-10-26T16:03:42Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/311 | 719,398,202 | 311 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Great job, first of all, nice to see this project so active!
I have been using asyncua for a while now, but recently I noticed that the ServerTimestamps where being returned as "0", so I decided to try out the most recent version on asyncua via pip (0.9.0).
After the update, on the top of a series of **"warnings"** about `Message: 'overwriting parent target, shouldbe fixed'` that I did not yet investigate there is an **error**:
`asyncua.ua.uaerrors._base.UaError: Non array Variant of type VariantType.NodeId cannot have value None`
This error appears related with one of my custom VariableType. This VariableType's relevant settings are:
I have already attempted to change the **ValueRank** from _Any_ to _Scalar_ (as on the attached picture), but problem persists.
Apart from the existence of the child properties this variable type is similar to the **ServerVendorCapabilityType** from the namespace 0 (http://opcfoundation.org/UA) (NumericNodeID 2137). I also attached that.
**Edit:** In fact I just noticed that the **IsAbstract** is checked in **ServerVendorCapabilityType** but not in my custom VariableType.
As you may have noticed I am using UaModeler from Unified Automation for developing my information model.
**The question:** Is this new behavior expected?
Note: I am using asyncua for my simulator of an OPC UA server that in reality is a PLC. The information model in the PLC works fine, as it does on 0.8.2
| import_xml fails on 0.9.0 (worked on 0.8.2) | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/308/comments | 4 | 2020-10-07T14:24:19Z | 2021-04-21T11:55:58Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/308 | 716,578,797 | 308 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hey,
i am kind of confused, i looked for quite some time to find the issue but i did not found it yet... maybe someone sees what i dont!
1. Import DI nodeset (Opc.Ua.Di.NodeSet2.xml)
2. Import Machinery nodeset (Opc.Ua.Machinery.NodeSet2.xml)
3. await server.load_type_definitions()
4. IMachineryItemVendorNameplateType ??? and some more are not there...
```xml
<UAObjectType NodeId="ns=1;i=1003" BrowseName="1:IMachineryItemVendorNameplateType" IsAbstract="true">
<DisplayName>IMachineryItemVendorNameplateType</DisplayName>
<Description Locale="en">Interface containing identification and nameplate information for a MachineryItem provided by the vendor</Description>
<Documentation>https://reference.opcfoundation.org/v104/Machinery/v100/docs/8.2</Documentation>
<References>
<Reference ReferenceType="HasSubtype" IsForward="false">ns=2;i=15035</Reference>
<Reference ReferenceType="HasProperty">ns=1;i=6027</Reference>
<Reference ReferenceType="HasProperty">ns=1;i=6022</Reference>
<Reference ReferenceType="HasProperty">ns=1;i=6026</Reference>
<Reference ReferenceType="HasProperty">ns=1;i=6024</Reference>
<Reference ReferenceType="HasProperty">ns=1;i=6025</Reference>
<Reference ReferenceType="HasInterface" IsForward="false">ns=1;i=1004</Reference>
</References>
</UAObjectType>
```
> INFO:asyncua.common.xmlparser:Parsing node: ns=1;i=1003 1:IMachineryItemVendorNameplateType
??? | XML-Import: Opc.Ua.Di.NodeSet2.xml + Opc.Ua.Machinery.NodeSet2.xml | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/307/comments | 60 | 2020-10-05T12:36:14Z | 2021-02-20T14:27:10Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/307 | 714,800,816 | 307 |
[
"FreeOpcUa",
"opcua-asyncio"
] | If I create two Nodes which share the same parent and have the same Browsename, the server is still running without throwing `Bad_BrowseNameDuplicated`.
Here "MyVariable" share the same parent "MyObject".
This should not be allowed.
EDIT: Even if their type may be different, the BrowseName can still be similar. | Multiple Nodes can share same BrowseName with same parent | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/305/comments | 1 | 2020-10-02T07:35:55Z | 2020-12-08T06:43:44Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/305 | 713,417,092 | 305 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Dear All,
I have no data from the event alarms subscription in the OPC UA server from Sinumerik 840D sl , I try from diferents examples and its not working, no events alarms was returning from the Server .... When a use the UA Expert in the same node that Im trying to subscription the events , it works...
Someone have any idea what's happening ?
The code is bellow :
# handler is the reference os my class that has the function def event_notification(self, event):
frequence = 1000
nodeId = "ns=2;i=1" #Sinumerick root Nodeid
self.event = await self.client.create_subscription(frequence, handler)
node = self.getNode(hwId)
await self.event.subscribe_data_change([node])
myevent = await self.client.nodes.root.get_child(["0:Types", "0:EventTypes", "0:BaseEventType"])
self.evhandle = await self.event.subscribe_events(node,myevent)
For the subscription data change its work fine with the Server …
Follow attached the print screen from UA Expert of event alarms View
Looking for the examples , the events are subscription with sucess , but no data are came from Sinumerik OPC UA. | Problem to get Alarms Event from SIEMENS 840D sl SINUMERIK OPC UA Server | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/304/comments | 7 | 2020-09-29T18:08:51Z | 2023-03-29T09:26:23Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/304 | 711,337,973 | 304 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello, every one.
**Steps to reproduce.**
1. Launch UA-Expert (v.1.5.1)
2. Launch examples/server-minimal.py
3. In UA-Expert add new server via Custom Discovery Service
**Ua Expert log:**
`
Discovery FindServersOnNetwork on opc.tcp://localhost:4840/ failed (BadUserAccessDenied), falling back to FindServers
DiscoveryWidget|Adding Server FreeOpcUa Python Server with URL opc.tcp://0.0.0.0:4840/freeopcua/server/
`
**Console Log:**
`
INFO:asyncua.server.binary_server_asyncio:New connection from ('192.168.0.3', 63999)
WARNING:asyncua.server.uaprocessor:Received a request of type 12208 without an existing session
WARNING:asyncua.server.uaprocessor:Someone attempted to do something they are not permitted to do
INFO:asyncua.server.binary_server_asyncio:processor returned False, we close connection from ('192.168.0.3', 63999)
INFO:asyncua.server.binary_server_asyncio:Lost connection from ('192.168.0.3', 63999), None
INFO:asyncua.server.uaprocessor:Cleanup client connection: ('192.168.0.3', 63999)
INFO:asyncua.server.binary_server_asyncio:New connection from ('192.168.0.3', 64002)
INFO:asyncua.server.uaprocessor:find servers request (None)
INFO:asyncua.server.binary_server_asyncio:processor returned False, we close connection from ('192.168.0.3', 64002)
INFO:asyncua.server.binary_server_asyncio:Lost connection from ('192.168.0.3', 64002), None
INFO:asyncua.server.uaprocessor:Cleanup client connection: ('192.168.0.3', 64002)`
imho the problem in nodeID 12208. if i do the same with opcua library, i will get
`Discovery FindServersOnNetwork on opc.tcp://localhost:4840/ failed (BadServiceUnsupported), falling back to FindServers`
`Unknown message received FourByteNodeId(i=12208`
I need to add new sever via Discovery Service becouse my client is using Siemens OPC Scout ( i have not access to this software for debug opcua communication), and he told me, that he can add new server endpoints ONLY with discovery service.
I have tried to add my server to the Local Discovery service (https://opcfoundation.org/developer-tools/samples-and-tools-unified-architecture/local-discovery-server-lds/), but no success. Many errors. But it is for another issue, that already exists | FindServersOnNetwork -> BadUserAccessDenied | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/301/comments | 4 | 2020-09-25T10:38:47Z | 2020-09-25T14:00:56Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/301 | 708,834,453 | 301 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi,
As far as I can tell, the package lxml is only used for XML import/export, but it is still a requirement even if that feature is not needed. Normally I would say no big deal but for frozen code (e.g. pyinstaller) it adds an extra 2MB to the executable which means additional delay during startup. If there is any way to make lxml optional - or only imported when it is really needed - then it would be nice to have.
Jonathan | Make lxml dependency optional | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/299/comments | 4 | 2020-09-24T16:17:53Z | 2020-12-07T11:08:16Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/299 | 708,304,546 | 299 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi,
The uaprocessor in opc-asyncio does not support ModifySubscriptionRequest_Encoding_DefaultBinary like its python-opcua cousin. I'm not sure why that is but would recommend to implement it.
As far as I can tell this requires minor modifications to uaprocessor.py, internal_session.py, and subscription_service.py.
Jonathan | ModifySubscriptionRequest_Encoding_DefaultBinary missing | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/298/comments | 2 | 2020-09-24T16:14:46Z | 2023-03-29T09:28:17Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/298 | 708,302,455 | 298 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello everybody,
I am currently trying to connect a program to an opcua-asyncio server via OPCUA. Unfortunately, I always get an error while browsing. How do I add browse functionality to the server or is it not yet supported?
Thanks for your help!
| Does opcua-asyncio servers support browse? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/297/comments | 20 | 2020-09-24T12:05:19Z | 2020-09-28T12:46:04Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/297 | 708,113,593 | 297 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hey,
I found a memory leak in the current master branch. My server was running on the last release 0.8.4 and there was no Probem.
Then I updated the library to the current master and realized a memory leak. First I thought that I have a leak in my code but now I found the error in the library.
To detect the leak I logged like this: (simplified)
import objgraph
objgraph.show_growth(limit=20, file=myFile)
Then I found that every 10 seconds there is one more frame and coroutine
frame 991 +1
coroutine 989 +1
Afterwards I searched the guilty pull request with the result #272
I just deleted line 139 and everything worked fine again.
Now we need to find out if the intended fix still works.
I dont know why we need this recursion there.
Can someone help me to fix that again?
best regards | Memory leak in Master | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/296/comments | 9 | 2020-09-23T13:59:11Z | 2021-04-14T11:14:08Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/296 | 707,392,446 | 296 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi folks,
Dataclasses were introduced in Python 3.7 but asyncua states that it supports Python 3.6. It is currently not usable on Python < 3.7.
Workaround is to install the backport,
> pip search dataclasses
dataclasses (0.7) - A backport of the dataclasses module for Python 3.6
A fix would be to include conditional in install requires,
```python
setup(
# ...
install_requires=[
# ...
"dataclasses; python_version<'3.7'",
]
)
``` | ModuleNotFoundError: No module named 'dataclasses' on Python 3.6 | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/295/comments | 3 | 2020-09-22T09:52:35Z | 2020-09-22T12:43:48Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/295 | 706,235,184 | 295 |
[
"FreeOpcUa",
"opcua-asyncio"
] | If a called method doesn't return output values the client call bugs out.
https://github.com/FreeOpcUa/opcua-asyncio/blob/75adf4f885a71ef3b8b49711dc12a6ed8dab87d8/asyncua/common/methods.py#L44
`result.OutputArguments` is `None`.
```python
ERROR:asyncua.server.address_space:Error executing method call CallMethodRequest(ObjectId:FourByteNodeId(ns=5;i=31), MethodId:GuidNodeId(ns=5;g=e2e0f53b-8dd8-4aff-95f7-605561425a8b), InputArguments:[Variant(val:1,type:VariantType.Int32)]), an exception was raised:
Traceback (most recent call last):
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/server/address_space.py", line 492, in _call
result = await self._run_method(node.call, method.ObjectId, *method.InputArguments)
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/server/address_space.py", line 509, in _run_method
return await func(parent, *args)
File "/home/randelung/Desktop/VL/OPC_Gateway/OPC_Gateway/__main__.py", line 41, in setValue
await node.call_method(node.nodeid, value.Value)
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/common/node.py", line 686, in call_method
return await call_method(self, methodid, *args)
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/common/methods.py", line 19, in call_method
result = await call_method_full(parent, methodid, *args)
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/common/methods.py", line 44, in call_method_full
result.OutputArguments = [var.Value for var in result.OutputArguments]
TypeError: 'NoneType' object is not iterable
```
Serverside (also asyncua), the method seems to work (using uaExpert).
However, Wireshark tells me that the result array dimension is -1, which would mean a null array and not a zero length array.
https://reference.opcfoundation.org/v104/Core/docs/Part4/5.11.2/ speaks of an empty array, though. So this may still be a server issue?
Even if the -1 length array wasn't entirely correct, it would still lead to the result of _nothing was returned_, so I'd recommend to include a `None` check before the mentioned iteration just to be sure. Since a plain `None` return value creates problems further down the call stack, I'd go with empty list.
Agree? | Client method call without return value throws exception | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/293/comments | 0 | 2020-09-21T19:23:05Z | 2020-09-25T09:52:47Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/293 | 705,854,796 | 293 |
[
"FreeOpcUa",
"opcua-asyncio"
] | https://github.com/FreeOpcUa/opcua-asyncio/blob/75adf4f885a71ef3b8b49711dc12a6ed8dab87d8/asyncua/ua/uatypes.py#L332
It matches a single byte instead of all of them being zero, e. g. `0032b2d5-c219-4524-8df5-5490a2109e9b`.
The consequence is that instead of the supplied GUID a new integer identifier is generated.
I can't say for sure that this is not an illegal node identifier, but
> Each value is formatted as a hexadecimal number with padded zeros.
(https://reference.opcfoundation.org/v104/Core/docs/Part6/5.1.3/)
seems to suggest multiple (especially leading) zeros can exist in a GUID.
I also found this:
> A Node in the AddressSpace shall not have a null as its NodeId.
(https://reference.opcfoundation.org/v104/Core/docs/Part3/8.2.4/)
but I think this references an all-zeros identifier, not containing a single zero byte.
Other than that there seems to be no restrictions.
My suggestion (which I'll gladly submit if you agree) is to replace the regex check with a check for an all zero bytes array.
```python
if self.NodeIdType == NodeIdType.Guid and self.Identifier.bytes == b'\00'*16:
``` | GUID with single zero byte misidentified as null identifier | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/290/comments | 1 | 2020-09-18T18:16:33Z | 2020-09-28T18:24:09Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/290 | 704,566,960 | 290 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi again!
I'm writing a proxy server to translate GUID requests to string requests since WinCC OA doesn't support the former.
Now I'm trying to have the client reconnect to the server if it goes down.
I'm testing the connection loss by terminating the WinCC OA OPC UA Server and seeing what happens.
So far I get an exception (0.8.4 from pip):
```
Traceback (most recent call last):
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/client/client.py", line 386, in _renew_channel_loop
await self.open_secure_channel(renew=True)
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/client/client.py", line 278, in open_secure_channel
result = await self.uaclient.open_secure_channel(params)
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 274, in open_secure_channel
return await self.protocol.open_secure_channel(params)
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 204, in open_secure_channel
self._send_request(request, message_type=ua.MessageType.SecureOpen),
File "/home/randelung/.local/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 130, in _send_request
self.transport.write(msg)
AttributeError: 'NoneType' object has no attribute 'write'
```
I found #241, but I believe that the `AttributeError` would just be replaced by a `ConnectionError`.
I see that automatic reconnection is on the to-do list. Is there a way to e. g. subscribe to a connection loss event and reinitialize the client myself? That would allow me to restore subscriptions and refuse method calls on the proxy server.
I'd like to not change your code if possible, but my first idea would be to make `UASocketProtocol.state` a property and trigger a callback when it's being changed.
Thanks! | Reconnecting to server that went away | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/288/comments | 6 | 2020-09-17T14:58:56Z | 2021-03-16T09:25:32Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/288 | 703,667,708 | 288 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I can't fetch this repository any more and i think it is due to the use of the `>` character in a recently introduced branch.
Anyone else having similar trouble?
```
git fetch
error: cannot lock ref 'refs/remotes/origin/Fix-history_sql.py-emitting-node-is-not-the-source-->-sql-error': Unable to create 'PycharmProjects/opcua-asyncio/.git/refs/remotes/origin/Fix-history_sql.py-emitting-node-is-not-the-source-->-sql-error.lock': Invalid argument
From https://github.com/FreeOpcUa/opcua-asyncio
! [new branch] Fix-history_sql.py-emitting-node-is-not-the-source-->-sql-error -> origin/Fix-history_sql.py-emitting-node-is-not-the-source-->-sql-error (unable to update local ref)
``` | git fetch fails because of branch name | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/286/comments | 7 | 2020-09-15T06:39:02Z | 2020-09-16T08:08:37Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/286 | 701,656,592 | 286 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I'm trying to connect to a server (< OPC UA 1.04) with AutoID companion spec structures via UA binary protocol with opcua-async 0.8.4. These structures contain optional fields. Seem like opc:Bits datatype somehow causes an error. Are optional structure fields supported by asyncua? If yes, perhaps you can give me a hint what I'm doing wrong? Thank you!
Here come the details of the error message:
When calling load_type_definition(), method fails with the following message
```
File "...\site-packages\asyncua\ua\ua_binary.py", line 484, in struct_from_binary
obj = objtype()
File "<string>", line 27, in __init__
AttributeError: module 'asyncua.ua' has no attribute 'Bit'
```
It looks like generated code is trying to use an non-existent type:
```
class RfidScanResult(object):
ua_types = [
('LocationSpecified', 'Bit'),
('Reserved1', 'Bit'),
('CodeType', 'CharArray'),
# ...
def __init__(self):
self.LocationSpecified = ua.Bit() # <-- This line causes the error
self.Reserved1 = ua.Bit()
```
| Does opcua-asyncio support structures with optional fields? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/280/comments | 12 | 2020-09-04T12:46:34Z | 2021-07-19T10:27:39Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/280 | 693,131,121 | 280 |
[
"FreeOpcUa",
"opcua-asyncio"
] | The pickle module in Python is a hot iron. It is a good serialiser, but the danger to execute unwanted code exists.
Pickle is used here:
https://github.com/FreeOpcUa/opcua-asyncio/blob/3636b610ae17a4c318730399150431afb8a81d5e/asyncua/server/address_space.py#L590
There are multiple options:
- leave as is
- remove them
- add a securitylayer around pickled data and decraypt them while unpickle
- add a logger warning & comments to be carful with that
What do you think about that?
(And would it be a good idea to add an extra Label for security vulnerabilities?)
EDIT: This was found via [bandit](https://github.com/PyCQA/bandit), which also recommends using other xml libraries, but this may be another issue) | security vulnerability: pickle module | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/277/comments | 7 | 2020-08-31T13:26:03Z | 2023-03-29T09:24:34Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/277 | 689,206,598 | 277 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Like @AndreasHeine mentioned in [python-opcua](https://github.com/FreeOpcUa/python-opcua/issues/1118) there are possible SQL Injections in history_sql.py.
The lines I found are:
https://github.com/FreeOpcUa/opcua-asyncio/blob/e6146e8666a7c1ad43ccdf74cd5fad9d5605a2ba/asyncua/server/history_sql.py#L58
https://github.com/FreeOpcUa/opcua-asyncio/blob/e6146e8666a7c1ad43ccdf74cd5fad9d5605a2ba/asyncua/server/history_sql.py#L67
https://github.com/FreeOpcUa/opcua-asyncio/blob/e6146e8666a7c1ad43ccdf74cd5fad9d5605a2ba/asyncua/server/history_sql.py#L98
https://github.com/FreeOpcUa/opcua-asyncio/blob/e6146e8666a7c1ad43ccdf74cd5fad9d5605a2ba/asyncua/server/history_sql.py#L142
https://github.com/FreeOpcUa/opcua-asyncio/blob/e6146e8666a7c1ad43ccdf74cd5fad9d5605a2ba/asyncua/server/history_sql.py#L155
https://github.com/FreeOpcUa/opcua-asyncio/blob/e6146e8666a7c1ad43ccdf74cd5fad9d5605a2ba/asyncua/server/history_sql.py#L170
Because I neither worked with SQL before, nor understanding the better way Andreas mentioned, I may not provide a PR for that at the moment (I have to check on that on Monday again, I got to many other things in my mind, but maybe I will put that on my agenda.). | security vulnerability: history_sql.py isn't injection safe! | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/276/comments | 4 | 2020-08-28T11:12:06Z | 2023-03-29T09:23:26Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/276 | 687,999,537 | 276 |
[
"FreeOpcUa",
"opcua-asyncio"
] | at first i have never used that history stuff ever before
1.
```
Traceback (most recent call last):
File "C:\Users\HeineAn\AppData\Local\Programs\Python\Python37-32\lib\site-packages\aiosqlite\core.py", line 153, in run
result = function()
sqlite3.OperationalError: table 0_2253 has no column named MyNumericProperty
Historizing SQL Insert Error for events from NumericNodeId(i=2253): table 0_2253 has no column named MyNumericProperty
```
2.
"server-events-history.py" is not async (looks like a copy of python-opcua)
I am reworking "2." facing issue "1.":
```python
import sys
sys.path.insert(0, "..")
import time
from datetime import datetime
import asyncio
from asyncua import ua, Server
from asyncua.server.history_sql import HistorySQLite
async def main():
# setup our server
server = Server()
await server.init()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = await server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.nodes.objects
# populating our address space
myobj = await objects.add_object(idx, "MyObject")
# Creating a custom event: Approach 1
# The custom event object automatically will have members from its parent (BaseEventType)
etype = await server.create_custom_event_type(2, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
# create second event
etype2 = await server.create_custom_event_type(2, 'MySecondEvent', ua.ObjectIds.BaseEventType,
[('MyOtherProperty', ua.VariantType.Float)])
# get an event generator for the myobj node which generates custom events
myevgen = await server.get_event_generator(etype, myobj)
myevgen.event.Severity = 500
myevgen.event.MyStringProperty = ua.Variant("hello world")
myevgen.event.MyNumericProperty = ua.Variant(-456)
# get another event generator for the myobj node which generates different custom events
myevgen2 = await server.get_event_generator(etype2, myobj)
myevgen2.event.Severity = 123
myevgen2.event.MyOtherProperty = ua.Variant(1.337)
# get an event generator for the server node which generates BaseEventType
serverevgen = await server.get_event_generator()
serverevgen.event.Severity = 111
# Configure server to use sqlite as history database (default is a simple in memory dict)
sqlite_history = HistorySQLite("my_event_history.db")
await sqlite_history.init()
server.iserver.history_manager.set_storage(sqlite_history)
# starting!
async with server:
# enable history for myobj events; must be called after start since it uses subscription
await server.iserver.enable_history_event(myobj, period=None)
# enable history for server events; must be called after start since it uses subscription
server_node = server.get_node(ua.ObjectIds.Server)
await server.historize_node_event(server_node, period=None)
count = 0
while True:
await asyncio.sleep(1)
count += 0.1
# generate events for subscribed clients and history
await myevgen.trigger(message="This is MyFirstEvent " + str(count))
await myevgen2.trigger(message="This is MySecondEvent " + str(count))
await serverevgen.trigger(message="Server Event Message")
await asyncio.sleep(1)
# read event history from sql
end_time = datetime.utcnow()
server_event_history = await server_node.read_event_history(None, end_time, 0)
if __name__ == '__main__':
asyncio.run(main())
``` | Event History and Example: "server-events-history.py" | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/275/comments | 17 | 2020-08-28T07:19:33Z | 2020-10-02T07:41:04Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/275 | 687,866,032 | 275 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hey ho together,
I was wondering how a Client gets it's target Node in the end, if it doesn't know it's NodeID.
The only option is via BrowseName (or better: the browsing path). But it is possible to create multiple Nodes with the same Browsename in the same Namespace, which may lead to chaos.
MyObject number one...
...and number two.
As I understand the [specs](https://reference.opcfoundation.org/v104/Core/docs/Part3/5.2.4/) here right, it is allowed to create multiple Nodes with the same Browsename, but they can't be in the same Node.
They can be in the same namespace, but in different paths or they are in different namespaces.
So we may need to add a check before adding the Node to the server, if this Browsename already exists, in the Node where it should be added ( I hope this is understandable?).
Am I missinterpreting the specs? | Identical browsenames in same Namespace? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/274/comments | 3 | 2020-08-26T14:21:43Z | 2020-12-08T06:43:50Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/274 | 686,362,483 | 274 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I have written an OPC UA Server which supports different OPCUA Policy Types.
Where in Client can I access that code or implement the same to connect with Server
Its an Asyncua Based Server Client | OPC UA Server-Client Policy Type | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/273/comments | 1 | 2020-08-26T08:54:38Z | 2023-03-29T09:23:13Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/273 | 686,140,111 | 273 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I have find a issue No #733,@brubbel suggested Discovery clients should be outside of server.py code, and I find the method "register_to_discovery" now is not in the server class of library "opcua". But in library "asyncua",method "register_to_discovery" is still in server class. My further question is that how to use this method?Could someone give a example about this method and add it to example folder?
I'm puzzled because even I don't use the method, UaExpert can find the server, like this:
<img width="384" alt="image" src="https://user-images.githubusercontent.com/57703532/90890226-26be1580-e3ec-11ea-8fbc-deab10eac4d2.png">
but in KepserverEx 6, when I create a new OPC UA Client chanel, the server can't be discovered,like this;
<img width="284" alt="image" src="https://user-images.githubusercontent.com/57703532/90890609-e612cc00-e3ec-11ea-9f1d-1706a246891c.png">
| About server method "register_to_discovery" | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/270/comments | 13 | 2020-08-21T12:28:47Z | 2023-02-05T21:53:29Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/270 | 683,526,109 | 270 |
[
"FreeOpcUa",
"opcua-asyncio"
] | hey!
I'm trying to have a long running OPC server/client "bridge". Similar to the code written here https://github.com/Green-Fusion/opcua-bridging/blob/master/examples/bridge/cloud/cloud/forwarding-service.py, which is every second read by another client. I find that after a few days the memory taken by the process continuously increases until the process crashes. I saw another person had similar issues in #79 so followed their method of using memtop, and after 24 hours of running I have this:
```
opcua_bridge_1 | WARNING:asyncua:
opcua_bridge_1 | refs:
opcua_bridge_1 | 66162 <class 'set'> {<weakref at 0x7f1ad5a0c830; to '_asyncio.Task' at 0x7f1ad5a00050>, <weakref at 0x7f1acfe5bef0; to '
opcua_bridge_1 | 66158 <class 'list'> [<Task finished coro=<UaProcessor.close() done, defined at /usr/local/lib/python3.7/site-packages/as
opcua_bridge_1 | 14367 <class 'dict'> {'__module__': 'asyncua.ua.object_ids', 'Null': 0, 'Boolean': 1, 'SByte': 2, 'Byte': 3, 'Int16': 4,
opcua_bridge_1 | 6764 <class 'dict'> {NumericNodeId(i=3062): NodeData(id:NumericNodeId(i=3062), attrs:{<AttributeIds.NodeId: 1>: Attribut
opcua_bridge_1 | 5742 <class 'list'> ['# module pyparsing.py\n', '#\n', '# Copyright (c) 2003-2018 Paul T. McGuire\n', '#\n', '# Permiss
opcua_bridge_1 | 2404 <class 'dict'> {139753465755680: <weakref at 0x7f1ae325d770; to 'type' at 0x7f1ae3aeb820 (type)>, 139753465774432:
opcua_bridge_1 | 740 <class 'dict'> {'__module__': 'lxml.etree', '__doc__': 'Libxml2 error types', '__dict__': <attribute '__dict__' of
opcua_bridge_1 | 594 <class 'pytz.lazy.LazyList.__new__.<locals>.LazyList'> ['Africa/Abidjan', 'Africa/Accra', 'Africa/Addis_Ababa', 'Africa/Algiers', 'Africa/Asmara', 'Africa/
opcua_bridge_1 | 594 <class 'pytz.lazy.LazySet.__new__.<locals>.LazySet'> LazySet({'America/New_York', 'America/El_Salvador', 'Pacific/Truk', 'Africa/Casablanca', 'America/Mo
opcua_bridge_1 | 558 <class 'dict'> {FourByteNodeId(i=14846): <class 'asyncua.ua.uaprotocol_auto.KeyValuePair'>, FourByteNodeId(i=15671)
opcua_bridge_1 |
opcua_bridge_1 | bytes:
opcua_bridge_1 | 2097384 {<weakref at 0x7f1ad5a0c830; to '_asyncio.Task' at 0x7f1ad5a00050>, <weakref at 0x7f1acfe5bef0; to '
opcua_bridge_1 | 589936 {'__module__': 'asyncua.ua.object_ids', 'Null': 0, 'Boolean': 1, 'SByte': 2, 'Byte': 3, 'Int16': 4,
opcua_bridge_1 | 578944 [<Task finished coro=<UaProcessor.close() done, defined at /usr/local/lib/python3.7/site-packages/as
opcua_bridge_1 | 147568 {NumericNodeId(i=3062): NodeData(id:NumericNodeId(i=3062), attrs:{<AttributeIds.NodeId: 1>: Attribut
opcua_bridge_1 | 51760 ['# module pyparsing.py\n', '#\n', '# Copyright (c) 2003-2018 Paul T. McGuire\n', '#\n', '# Permiss
opcua_bridge_1 | 36976 {139753465755680: <weakref at 0x7f1ae325d770; to 'type' at 0x7f1ae3aeb820 (type)>, 139753465774432:
opcua_bridge_1 | 36976 {'__module__': 'lxml.etree', '__doc__': 'Libxml2 error types', '__dict__': <attribute '__dict__' of
opcua_bridge_1 | 33008 LazySet({'America/New_York', 'America/El_Salvador', 'Pacific/Truk', 'Africa/Casablanca', 'America/Mo
opcua_bridge_1 | 33008 LazySet({'America/New_York', 'America/El_Salvador', 'Africa/Casablanca', 'America/Montserrat', 'Euro
opcua_bridge_1 | 18536 {'sys': <module 'sys' (built-in)>, 'builtins': <module 'builtins' (built-in)>, '_frozen_importlib':
opcua_bridge_1 |
opcua_bridge_1 | types:
opcua_bridge_1 | 170880 <class 'dict'>
opcua_bridge_1 | 69333 <class 'weakref'>
opcua_bridge_1 | 66173 <class 'Context'>
opcua_bridge_1 | 66167 <class 'coroutine'>
opcua_bridge_1 | 66162 <class '_asyncio.Task'>
opcua_bridge_1 | 39245 <class 'asyncua.ua.uatypes.StatusCode'>
opcua_bridge_1 | 39243 <class 'asyncua.ua.uatypes.DataValue'>
opcua_bridge_1 | 39243 <class 'asyncua.ua.uatypes.Variant'>
opcua_bridge_1 | 39238 <class 'asyncua.server.address_space.AttributeValue'>
opcua_bridge_1 | 15482 <class 'asyncua.ua.uatypes.NumericNodeId'>
```
It seems like the problem is here:
`opcua_bridge_1 | 2097384 {<weakref at 0x7f1ad5a0c830; to '_asyncio.Task' at 0x7f1ad5a00050>, <weakref at 0x7f1acfe5bef0; to ' ` which looks like just a plain set of "weakref"s to "Task"s.
If anyone already knows what the problem is that would help me a lot, but until then i'll start working on it | potential memory leak | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/267/comments | 12 | 2020-08-20T07:49:55Z | 2020-12-15T08:14:30Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/267 | 682,502,599 | 267 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I just recognised that Travis is not running anymore in our PRs.
Does anyone know why?
Edit: It seems to be an issue since more than 2 days, since @AndreasHeine latest PR wasn't checked either | Travis not running in PR | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/266/comments | 4 | 2020-08-19T13:05:56Z | 2020-08-21T05:44:11Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/266 | 681,824,796 | 266 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Dear `opcua-asyncio` team,
I have a question regarding events (as a newbie).
The server can create an event generator with the `get_event_generator` function and then use this generator to trigger events. However, the client does not have such a generator function. My question is: is there a way to trigger events with the client as well, which the server then listens to?
Some more background: I want the server to run a function whenever the client changes 3 variable values. For this, I intend to use a subscription handler on the client side. So far, I used the `datachange_notification` function in the subscription handler for this. However, the problem with this is that the the function on the server side is executed 3 times (when variable a, b and c change respectively). This is not what I want. Instead, I want to only run my function 1 time (when all three variables, a, b, and c have changed). Hence, my idea was to trigger an event by the client once this has happened (and let the server listen to this event instead of to variable value changes). I'd be super thankful for any advice on this.
Many, many thanks in advance for getting back.
| How to generate events with client | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/265/comments | 5 | 2020-08-19T08:48:25Z | 2021-05-10T22:00:55Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/265 | 681,662,800 | 265 |
[
"FreeOpcUa",
"opcua-asyncio"
] | (Caveat: My understanding mostly comes from v104 of the OPC UA spec.)
I'm writing code using asyncua to handle subscriptions, and in particular I'm trying to handle the case where a subscription gets deleted due to inactivity.
I'm testing this with a subscription that publishes every 100ms, with a MaxKeepAliveCount of 3000 (i.e. 5 minutes) and LifetimeCount of 10000 (i.e 16 minutes 40 seconds).
What I've noticed is that after 5 minutes, I see a message sequence like this in the logs:
```
2020-08-18 18:08:28 INFO Publish callback called with result: PublishResult(SubscriptionId:978017, AvailableSequenceNumbers:[], MoreNotifications:False, NotificationMessage:NotificationMessage(SequenceNumber:2, PublishTime:2020-08-18 16:08:28.220000, NotificationData:[]), Results:[StatusCode(Good)], DiagnosticInfos:[])
2020-08-18 18:08:28 DEBUG publish [SubscriptionAcknowledgement(SubscriptionId:978017, SequenceNumber:2)]
2020-08-18 18:08:28 DEBUG Sending: PublishRequest(TypeId:FourByteNodeId(i=826), RequestHeader:RequestHeader(AuthenticationToken:ByteStringNodeId(b=b'IK\x9c\xe2\xb9I\xa8\xd6\xf4r\xe9\xb7\xf9\x9fa\xfd'), Timestamp:2020-08-18 16:08:28.243105, RequestHandle:67, ReturnDiagnostics:0, AuditEntryId:None, TimeoutHint:0, AdditionalHeader:ExtensionObject(TypeId:TwoByteNodeId(i=0), Encoding:0, None bytes)), Parameters:PublishParameters(SubscriptionAcknowledgements:[SubscriptionAcknowledgement(SubscriptionId:978017, SequenceNumber:2)]))
```
Followed by this every 5 mintues after that
```
2020-08-18 18:13:28 INFO Publish callback called with result: PublishResult(SubscriptionId:978017, AvailableSequenceNumbers:[], MoreNotifications:False, NotificationMessage:NotificationMessage(SequenceNumber:2, PublishTime:2020-08-18 16:13:28.835000, NotificationData:[]), Results:[StatusCode(BadSequenceNumberUnknown)], DiagnosticInfos:[])
2020-08-18 18:13:28 DEBUG publish [SubscriptionAcknowledgement(SubscriptionId:978017, SequenceNumber:2)]
2020-08-18 18:13:28 DEBUG Sending: PublishRequest(TypeId:FourByteNodeId(i=826), RequestHeader:RequestHeader(AuthenticationToken:ByteStringNodeId(b=b'IK\x9c\xe2\xb9I\xa8\xd6\xf4r\xe9\xb7\xf9\x9fa\xfd'), Timestamp:2020-08-18 16:13:28.859147, RequestHandle:130, ReturnDiagnostics:0, AuditEntryId:None, TimeoutHint:0, AdditionalHeader:ExtensionObject(TypeId:TwoByteNodeId(i=0), Encoding:0, None bytes)), Parameters:PublishParameters(SubscriptionAcknowledgements:[SubscriptionAcknowledgement(SubscriptionId:978017, SequenceNumber:2)]))
```
and the subscription is never closed. Note the 'BadSequenceNumberUnknown' status code.
[From reading the spec](https://reference.opcfoundation.org/v104/Core/docs/Part1/7.11/), a KeepAliveMessage is described as follows:
"When there are no _Notifications_ to send within the keep-alive time interval, the _Server_ sends a **keep-alive _Message_ that contains the sequence number of the next _NotificationMessage_ sent**. (Bold emphasis mine).
What I think is happening is that the ua_client interprets the KeepAliveMessage as an empty notification with sequence number 2 and tries to acknowledge it. This causes the susbcription to end up in a strange state as it raises a BadSequenceNumberUnknown error trying to acknowledge the message.
EDIT: Again [from the spec](https://reference.opcfoundation.org/v104/Core/docs/Part4/5.13.1/), confirming that the PublishResult with no NotificationData is intended as a KeepAliveMesssage and should not be acknowledged
"When the maximum keep-alive count is reached, a Publish request is de-queued and used to return a keep-alive Message. This keep-alive Message informs the Client that the Subscription is still active. Each keep-alive Message is a response to a Publish request in which the notificationMessage parameter does not contain any Notifications and that contains the sequence number of the next NotificationMessage that is to be sent." | UA Client incorrectly acknowledges the KeepAlive Message | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/263/comments | 1 | 2020-08-19T07:28:01Z | 2020-08-19T13:32:31Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/263 | 681,613,394 | 263 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I have been getting this error with version 8.3 and higher, without deprecation warning or anything. Searched for a while and found that the name was changed to "read_browse_name()" instead of "get_browse_name".
Hasn't updated in the [ReadTheDocs ](https://python-opcua.readthedocs.io/en/latest/_modules/opcua/common/node.html#Node.get_browse_name)page either, any reason why this was changed?
https://github.com/FreeOpcUa/opcua-asyncio/blob/f653d611b210f5a4f8b285382ad6a345f5e30ed9/asyncua/common/node.py#L82 | AttributeError: 'Node' object has no attribute 'get_browse_name' | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/262/comments | 4 | 2020-08-18T08:50:19Z | 2021-08-17T06:10:33Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/262 | 680,817,676 | 262 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I am trying to Write OPCUA Server featuring Secuirty .
Few queries -
Where does the Server stores its Own certificate ?
Where does the Server stores Trusted and Rejected Certificate ?
I am Choosing one particular type of certificate and encryption , can I still have access to that server using None as well ?
Can I have user specific Nodes and Variables ? For eg - Particular user will have access to particular Nodes of Server in address space ?
| OPCUA Security | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/260/comments | 20 | 2020-08-17T05:51:58Z | 2023-03-29T09:19:55Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/260 | 679,955,445 | 260 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi!
I can connect the server with client "client-with-encryption.py", then I add a server in UaExpert, and use the configure same to client "client-with-encryption.py", but the application popup a warning dialog ,the warning message is " There was no exact match for the specified URL in the server's endpoints, using the first server certificate found for connecting".
| why i can't connect ''server-with-encryption.py" with UaExpert,but i can connet the server with "client-with-encryption.py" | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/259/comments | 9 | 2020-08-15T16:08:55Z | 2020-08-19T09:10:10Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/259 | 679,601,595 | 259 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi, your web address is http://freeopcua.github.io which if I type it into network explorer, the web can't open ,when I change the address to https://freeopcua.github.io, the web can properly opened. | a little discovery | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/258/comments | 6 | 2020-08-15T11:46:36Z | 2020-08-19T12:51:45Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/258 | 679,551,132 | 258 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Pardon my ignorance, I am new to both Python and OPC UA, but I believe I have found a bug in the subscription module in either the SubHandler sample class or the _call_datachange method of Subscription.
```python
class SubHandler:
def datachange_notification(self, node, val, data):
print("datachange_notification: NODE:%r VALUE:%s" % (node, val))
```
I will take line 128 from subscription.py (At the time of writing, not sure if there's a way to link it) as an example, but it seems that all of _call_datachange would be affected:
```python
self._handler.datachange_notification(data.node, item.Value.Value.Value, event_data)
```
Seems to only have 3 parameters, which produces the error below. If I delete the self parameter from SubHandler.datachange_notification or add self to the method it works fine.
```python
ERROR:asyncua.common.subscription:Exception calling data change handler
Traceback (most recent call last):
File "C:\Users\Hermann\AppData\Local\Programs\Python\Python38-32\lib\site-packages\asyncua\common\subscription.py", line 128, in _call_datachange
self._handler.datachange_notification(data.node, item.Value.Value.Value, event_data)
TypeError: datachange_notification() missing 1 required positional argument: 'data'
``` | Error with subscription datachange | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/257/comments | 4 | 2020-08-13T18:13:55Z | 2020-08-14T22:19:14Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/257 | 678,641,074 | 257 |
[
"FreeOpcUa",
"opcua-asyncio"
] | We are using the server functionality to test a client we are developing: the server is kind of a simulator of the real server.
For the purpose of covering some functionality of the client we would like to force the server to provide late responses do requests from the client; for example, when client makes a value read request of a variable to the server (asyncua) we would like to be able to make the server to only send the reply Xs after the request has been received.
Is there a way of doing this without having to change asyncua? Or do you have any suggestions on how to achieve this?
Thank you for any provided help! | Is there a possibility to manipulate server's response delay | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/256/comments | 2 | 2020-08-12T09:57:01Z | 2021-07-09T10:18:23Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/256 | 677,559,932 | 256 |
[
"FreeOpcUa",
"opcua-asyncio"
] | in fact it is on master. Just clone master and install
_Originally posted by @oroulet in https://github.com/FreeOpcUa/opcua-asyncio/issues/252#issuecomment-669480103_
It is working correctly now, it is reading data from the server as shown in the output below.
Thank you for now
Root children are [Node(i=85), Node(i=86), Node(i=87)]
var is: ns=3;i=1002
value of var is: -1.5835
setting float value
reading float value: 1.2339999675750732
Mehtod result is: 1.2246467991473532e-16
Python: New data change event ns=3;i=1002 -1.5835
Python: New data change event ns=3;i=1002 -1.213708
Python: New event Event(['EventId:b\'\\x00\\x00\\x00\\x00\\x00\\x00\\x00"\'', 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2787', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New event Event(["EventId:b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00#'", 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2788', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New event Event(["EventId:b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00%'", 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2787', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New data change event ns=3;i=1002 1.676917
Python: New event Event(["EventId:b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00&'", 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2788', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New data change event ns=3;i=1002 -1.976225
Python: New event Event(['EventId:b"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\'"', 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2787', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New event Event(["EventId:b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00('", 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2788', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New data change event ns=3;i=1002 -1.893093
Python: New event Event(["EventId:b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00)'", 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2787', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New event Event(["EventId:b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00*'", 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2788', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New data change event ns=3;i=1002 1.008998
Python: New event Event(["EventId:b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00+'", 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2787', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New event Event(["EventId:b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00,'", 'Severity:None', 'Time:None', 'Message:None', 'EventType:i=2788', 'SourceNode:i=2253', 'ReceiveTime:None', 'SourceName:Server', 'LocalTime:None'])
Python: New data change event ns=3;i=1002 1.367323
| in fact it is on master. Just clone master and install | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/254/comments | 0 | 2020-08-05T21:46:26Z | 2020-08-13T10:47:29Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/254 | 673,867,188 | 254 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi,
I am new in using opcua, so bare with the question.
Currently I'm implementing a python script for connecting with a opcua device. The device is configured to allow connection with Basic256 signed and encrypted.
In this library I saw, to set the security I need to load both private key and certificate file.
I talked to the engineers that work with the opcua device and they told me that the server in the device has a certificate and a private key, the client(python script) needs to accept this certificate and use 'anonymous' as user. This is how they work as well with uaExpert.
If I don't set any security policy, I will receive this
```
CRITICAL:asyncua.client.ua_client.UASocketProtocol:Received an error: MessageAbort(error:StatusCode(BadSecurityPolicyRejected), reason:None)
```
Questions:
* Is there a way to set the security policy without loading the certificate and private key files? and to use the certificate from the server?
* Is this a 'normal' way of working with opcua ?
Thanks! | Setting security policy without loading private key and certificate | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/253/comments | 11 | 2020-08-05T15:28:47Z | 2020-08-07T12:12:04Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/253 | 673,629,768 | 253 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Scenario
``
asyncua 0.8.4
python 3.8.5
``
I'm using the Prosys simulation server and a pc and running the opcua-asyncio client on another pc. Through opcua clients and Prosys for android I can communicate with the Prosys server, so there is no communication problem on the network. When I try to make the same communication with opcua-asyncio it generates the error below. How can I resolve this error? I'm using this sample code:
``
https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples/client_to_prosys.py
``
As the code in the example is using the same default parameters as the server, I didn't change it, I just changed the url that points to the server. I found some suggestions for one of the errors (BadTcpMessageTooLarge) to increase the maximum message size, but it doesn't show how to do this.
Another question in the code is about the stretch (line 31 of the example file) below.
``
static_idx = await client.get_namespace_index ("http://www.prosysopc.com/OPCUA/StaticNodes")
``
The url is the same as the one declared in the Prosys server namespaces, but when placed in the browser address bar it returns a 404 error. Is this right?
WARNING:asyncua.uaprotocol:Received an error: MessageAbort(error:StatusCode(BadTcpMessageTooLarge), reason:Bad_TcpMessageTooLarge (code=0x80800000, description="Chunk size (132) exceeded maximum (-1)"))
CRITICAL:asyncua.client.ua_client.UASocketProtocol:Received an error: MessageAbort(error:StatusCode(BadTcpMessageTooLarge), reason:Bad_TcpMessageTooLarge (code=0x80800000, description="Chunk size (132) exceeded maximum (-1)"))
ERROR:asyncua.client.ua_client.UASocketProtocol:Exception raised while parsing message from server
Traceback (most recent call last):
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 159, in _call_callback
self._callbackmap[request_id].set_result(body)
KeyError: 0
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 80, in _process_received_data
self._process_received_message(msg)
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 99, in _process_received_message
self._call_callback(0, ua.UaStatusCodeError(msg.Error.value))
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 161, in _call_callback
raise ua.UaError(
asyncua.ua.uaerrors._base.UaError: No request found for request id: 0, pending are dict_keys([1])
WARNING:asyncua.client.ua_client.UaClient:disconnect_socket was called but connection is closed
Traceback (most recent call last):
File "/home/marcelo/Documentos/OPC UA/python/opcua_asyncio.py", line 72, in <module>
asyncio.run(main())
File "/home/marcelo/.pyenv/versions/3.8.5/lib/python3.8/asyncio/runners.py", line 43, in run
return loop.run_until_complete(main)
File "/home/marcelo/.pyenv/versions/3.8.5/lib/python3.8/asyncio/base_events.py", line 616, in run_until_complete
return future.result()
File "/home/marcelo/Documentos/OPC UA/python/opcua_asyncio.py", line 27, in main
async with Client(url=url) as client:
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/client.py", line 71, in __aenter__
await self.connect()
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/client.py", line 228, in connect
await self.open_secure_channel()
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/client.py", line 278, in open_secure_channel
result = await self.uaclient.open_secure_channel(params)
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 274, in open_secure_channel
return await self.protocol.open_secure_channel(params)
File "/home/marcelo/.virtualenvs/OPC_UA-HBbcF4fs/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 203, in open_secure_channel
result = await asyncio.wait_for(
File "/home/marcelo/.pyenv/versions/3.8.5/lib/python3.8/asyncio/tasks.py", line 490, in wait_for
raise exceptions.TimeoutError()
asyncio.exceptions.TimeoutError
| Communication between Prosys Server and opcua-asyncio client generates error | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/252/comments | 9 | 2020-08-05T04:24:01Z | 2023-12-14T05:55:29Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/252 | 673,242,453 | 252 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Dear all,
I just started to look at opcua-asyncio for the project and need advice on it.
My goal is to read values from defined(monitored) nodes and write these values in XML format.
I am using a subscription to get updated values from the MDE server.
Questions
1. I have to output XML data with a very high frequency (10Hz) for our other application. But callback function is called when the client received the data change message. In this case, the subscription is not an efficient way? Is it better to get_values with node information without a subscription?
2. I have to generate XML while subscribing to the monitored nodes in server. I tried to put a while loop inside the async main function. But this while loop blocks others. What would be an efficient way to generate XML data with updated values from the callback function?
3. I think it is very important to efficiently use a callback function to get values from nodes with one subscription.
Is there any example code to look at how the "datachange_notification" function is used to get and save values?
It's quite challenging for me to come up with a clever idea.
Please give me any advice on this. | opcua-asyncio subscription and XML generation | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/250/comments | 5 | 2020-07-31T08:47:13Z | 2023-03-29T09:14:23Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/250 | 669,576,367 | 250 |
[
"FreeOpcUa",
"opcua-asyncio"
] | my time is a little limited this week maybe someone else could have a look?
```python
await instantiate(objects, server.get_node(f"ns=0;i=58"), ua.NodeId.from_string(f"ns={idx};i=1500"), f"{idx}:Obj1", "Obj1", idx, instantiate_optional=True) # dname="Obj1" => AttributeError: 'str' object has no attribute 'ua_types'
```
Traceback (most recent call last):
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\server\uaprocessor.py", line 119, in process_message
return await self._process_message(typeid, requesthdr, seqhdr, body)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\server\uaprocessor.py", line 209, in _process_message
self.send_response(requesthdr.RequestHandle, seqhdr, response)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\server\uaprocessor.py", line 46, in send_response
struct_to_binary(response), message_type=msgtype, request_id=seqhdr.RequestId)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 241, in struct_to_binary
packet.append(list_to_binary(uatype[6:], val))
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 281, in list_to_binary
pack = [to_binary(uatype, el) for el in val]
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 281, in <listcomp>
pack = [to_binary(uatype, el) for el in val]
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 269, in to_binary
return struct_to_binary(val)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 241, in struct_to_binary
packet.append(list_to_binary(uatype[6:], val))
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 281, in list_to_binary
pack = [to_binary(uatype, el) for el in val]
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 281, in <listcomp>
pack = [to_binary(uatype, el) for el in val]
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 269, in to_binary
return struct_to_binary(val)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 246, in struct_to_binary
packet.append(to_binary(uatype, val))
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 259, in to_binary
return pack_uatype(vtype, val)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 179, in pack_uatype
return struct_to_binary(value)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 238, in struct_to_binary
for name, uatype in obj.ua_types:
AttributeError: 'str' object has no attribute 'ua_types'
Error while processing message
Traceback (most recent call last):
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\server\uaprocessor.py", line 119, in process_message
return await self._process_message(typeid, requesthdr, seqhdr, body)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\server\uaprocessor.py", line 209, in _process_message
self.send_response(requesthdr.RequestHandle, seqhdr, response)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\server\uaprocessor.py", line 46, in send_response
struct_to_binary(response), message_type=msgtype, request_id=seqhdr.RequestId)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 241, in struct_to_binary
packet.append(list_to_binary(uatype[6:], val))
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 281, in list_to_binary
pack = [to_binary(uatype, el) for el in val]
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 281, in <listcomp>
pack = [to_binary(uatype, el) for el in val]
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 269, in to_binary
return struct_to_binary(val)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 241, in struct_to_binary
packet.append(list_to_binary(uatype[6:], val))
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 281, in list_to_binary
pack = [to_binary(uatype, el) for el in val]
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 281, in <listcomp>
pack = [to_binary(uatype, el) for el in val]
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 269, in to_binary
return struct_to_binary(val)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 246, in struct_to_binary
packet.append(to_binary(uatype, val))
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 259, in to_binary
return pack_uatype(vtype, val)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 179, in pack_uatype
return struct_to_binary(value)
File "C:\Users\andre\AppData\Local\Programs\Python\Python37\lib\site-packages\asyncua\ua\ua_binary.py", line 238, in struct_to_binary
for name, uatype in obj.ua_types:
AttributeError: 'str' object has no attribute 'ua_types' | error instantiate method -> dname -> str | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/247/comments | 3 | 2020-07-21T20:24:26Z | 2023-03-29T09:12:36Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/247 | 663,285,525 | 247 |
[
"FreeOpcUa",
"opcua-asyncio"
] | 0.8.4:
0.8.3
!?
| 0.8.3 -> 0.8.4 changes? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/246/comments | 7 | 2020-07-21T18:16:11Z | 2020-09-17T08:40:12Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/246 | 663,213,509 | 246 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Since we provide support for >=Python3.6, we may add Python3.7 and Python3.8 (actual stable) as well in out Travis tests? | Extend Travis with higher Python versions? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/243/comments | 6 | 2020-07-20T10:30:45Z | 2020-07-27T11:25:41Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/243 | 661,655,975 | 243 |
[
"FreeOpcUa",
"opcua-asyncio"
] | When disconnect happen `UASocketProtocol.transport` is silently set to `None` and I get `AttributeError`s instead of something more appropriate like `IOError`:
```python
AttributeError: 'NoneType' object has no attribute 'write'
```
I need to check if I am connected like that: `client.uaclient.protocol.transport is not None`.
Suggestion: throw `IOError` (or `ConnectionError`) when trying to use transport with broken connection. | UASocketProtocol transport should not be set to None silently on disconnect | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/241/comments | 4 | 2020-07-20T06:17:32Z | 2020-07-25T07:18:36Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/241 | 661,427,060 | 241 |
[
"FreeOpcUa",
"opcua-asyncio"
] | ```python
async def set_modelling_rule(self, mandatory: bool):
"""
Add a modelling rule reference to Node.
When creating a new object type, its variable and child nodes will not
be instanciated if they do not have modelling rule
if mandatory is None, the modelling rule is removed
"""
# remove all existing modelling rule
rules = await self.get_references(ua.ObjectIds.HasModellingRule)
await self.server.delete_references(list(map(self._fill_delete_reference_item, rules)))
# add new modelling rule as requested
if mandatory is not None:
rule = ua.ObjectIds.ModellingRule_Mandatory if mandatory else ua.ObjectIds.ModellingRule_Optional
await self.add_reference(rule, ua.ObjectIds.HasModellingRule, True, False)
```
old:
`if mandatory is not None:`
node.set_modelling_rule(None) #not mandatory
node.set_modelling_rule(False) #mandatory! <--- !!!
node.set_modelling_rule(True) #mandatory!
new:
`if mandatory is not None and mandatory is not False:`
would be more userfriendly!?
node.set_modelling_rule(None) #not mandatory
node.set_modelling_rule(False) #not mandatory
node.set_modelling_rule(True) #mandatory!
#239 | set modeling rule (node.py) | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/240/comments | 0 | 2020-07-20T06:03:24Z | 2020-07-20T07:04:58Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/240 | 661,418,284 | 240 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Trying to add an asyncua server from [ignition](https://en.wikipedia.org/wiki/Ignition_SCADA) fails with the following error message, even when using the permissive user manager :
```
UaServiceFaultException: status=Bad_UserAccessDenied, message=User does not have permission to perform the requested operation.
```
Trying to investigate this, it seems that Ignition sends a message with the following header and body :
```
Header(type:b'MSG', chunk_type:b'F', body_size:92, channel:18)
```
```
b'\x01\x00\xa6\x01\x00\x00 \xb8n\xb9\xe5Z\xd6\x01\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff`\xea\x00\x00\x00\x00\x00#\x00\x00\x00opc.tcp://host.docker.internal:4840\x00\x00\x00\x00\x00\x00\x00\x00'
```
(`opc.tcp://host.docker.internal:4840` being the address of the server)
and parsing the message falls inside [this condition in `UaProcessor._process_message`](https://github.com/FreeOpcUa/opcua-asyncio/blame/8c0fe3442d71c1ae90afbeb8026737506b0b21bc/asyncua/server/uaprocessor.py#L153-L154) :
```python
elif self.session is None:
raise ua.uaerrors.BadUserAccessDenied
```
This condition seems to have been added in https://github.com/FreeOpcUa/opcua-asyncio/commit/47920a7fe022a8682c833ff99124273943bf3982 , and the bug does not occur in v0.8.3 of this package (neither in the synchronous [python-opcua](https://github.com/FreeOpcUa/python-opcua)) | adding an asyncua server in ignition fails | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/236/comments | 0 | 2020-07-15T20:31:08Z | 2020-07-17T12:20:58Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/236 | 657,634,120 | 236 |
[
"FreeOpcUa",
"opcua-asyncio"
] | null | How can I set value to a Server Node using only NodeName from Client | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/235/comments | 21 | 2020-07-14T13:58:22Z | 2023-03-29T09:11:53Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/235 | 656,634,875 | 235 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi,
I'm using `python-opcua` to interact with a couple of Siemens PLCs: an S7-1511 and an S7-1212. I'm finding that their implementations of user-defined types are different.
## Ways to access user-defined type information
| S7-1511 | S7-1212 |
| - | - |
| `TypeDictionary`, `DataTypeDefinition` | `DataTypeDefinition` |
Apparently, the `TypeDictionary` approach has been removed in OPC-UA 1.04. This post has more information:
https://forum.prosysopc.com/forum/opc-ua-java-sdk/get-datatype-from-siemens-s7-1500-server-to-add-to-typedictionary/#p4112
Revision 1.04 Highlights (copied from OPC-10000-3: Address Space Model, Release 1.04)
| Mantis ID | Summary | Resolution |
| - | - | - |
| 3018 | Handling of DataType Encoding Information | Added Property to DataType NodeClass in 5.8.3 containing information about data type definition. Added DataTypes for handling the information in 8.48, 8.49, 8.50, 8.51, and 8.52. Removed the old approach having DataTypeDictionaries. This effects 5.6.2, where Properties have been removed, 5.8, where the old approach was defined in detail, and 5.5.1 as well as 7, where the ReferenceType HasDefinition and its usage was removed. The old approach is moved to an annex of Part 5 and can still be applied by OPC UA Applications. |
I'm able to read the `DataTypeDefinition` as follows, but haven't yet figured out how to parse it.
```python
type_node = self.client.get_node(variable_node.get_data_type())
dv = type_node.get_attribute(opcua.ua.attribute_ids.AttributeIds.DataTypeDefinition)
```
| [Topic] Support of DataTypeDefinition | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/234/comments | 16 | 2020-07-14T03:03:47Z | 2022-05-23T01:22:26Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/234 | 656,287,042 | 234 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi,
while browsing nodes in the example OPC UA server (examples/server-example.py) I noticed something weird (at least weird to me).
If I specify the HasSubType reference for the "referenceTypeId" parameter in the browse request, I will only get these references in the browse response if I also set the "includeSubtypes" parameter to true.
Other reference type IDs in the browse request wont show this behavior and I will get the requested references without setting includeSubTypes.
I only took a brief look at the code, but I would guess the behavior comes from 5f488ab2 (not verified, that this is the code path taken):
```python
def _suitable_reftype(self, ref1, ref2, subtypes):
"""
"""
if not subtypes and ref2.Identifier == ua.ObjectIds.HasSubtype:
return False
```
I didn't see anything in the OPC UA specification that would account for special handling of the HasSubType reference type in this case. Other OPC UA stacks also return references with HasSubType directly (without setting "IncludeSubtypes").
Is there a reason why the OPC UA server behaves this way?
Best regards
| Browsing HasSubType references without "includeSubtypes" | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/233/comments | 4 | 2020-07-13T08:24:39Z | 2022-09-07T09:16:12Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/233 | 655,645,977 | 233 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello,
I am trying to setup an OPC-UA server inside a Docker container (based on debian-buster) and I'm not quite clear on the behaviour of `Server.set_endpoint`. If I try to use anything other than `0.0.0.0`, I get an error from asyncio that it cannot bind to the address. For example, using localhost gives
```
server.set_endpoint(`opc.tcp://localhost:4840`) .....
OSError: [Errno 99] error while attempting to bind on address ('::1', 4840, 0, 0): cannot assign requested address
```
And a similar error, with the public IPv4 addres substituted for `::1`, if using the server IP.
Am I not using this correctly?
If I do use 0.0.0.0 then the resulting endpoints have address like 172.x.x.x with a discovery URL of 0.0.0.0 | Unable to set custom url as endpoint | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/232/comments | 3 | 2020-07-09T13:29:42Z | 2021-10-26T11:21:35Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/232 | 654,062,156 | 232 |
[
"FreeOpcUa",
"opcua-asyncio"
] | https://github.com/FreeOpcUa/opcua-asyncio/blob/55d76f6748a6fdb3dbf05d68f1bf9633586b2688/asyncua/ua/uatypes.py#L838
```python
def __init__(self, variant=None, status=None):
self.Encoding = 0
if not isinstance(variant, Variant):
variant = Variant(variant)
self.Value = variant
if status is None:
self.StatusCode = StatusCode()
else:
self.StatusCode = status
self.SourceTimestamp = None # DateTime()
self.SourcePicoseconds = None
self.ServerTimestamp = None # DateTime()
self.ServerPicoseconds = None
self._freeze = True
```
why is self.SourceTimestamp and self.ServerTimestamp = None?
guess it should be like `datetime.utcnow()` were there issues in the past?
its in both python-opcua and asyncua! | uatypes.py -> class DataValue | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/230/comments | 3 | 2020-07-07T21:18:19Z | 2023-03-29T09:11:16Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/230 | 652,653,849 | 230 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello together,
so the most time I dealt with the typical build-in Datatypes like int64, float, DateTime etc. and know how to make an extended datatype.
While scrolling throw the Address Space Model (Part 3) in the norms, there are even DataTypes like DateString, DurationString, DecimalString, ImageGIF etc. etc.
Is there already a way to create Nodes with such a DataType (and I am completly stumped) or is this a thing we shall deal with in future?
(Do we may need an example for such DataTypes?) | Make other simple DataType Nodes | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/228/comments | 3 | 2020-06-30T07:17:41Z | 2020-06-30T17:38:54Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/228 | 647,929,940 | 228 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello,
I just tried updating the code and now I get this error:
`C:\Users\User\AppData\Local\Programs\Python\Python37\python.exe C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py
WARNING:asyncua.client.client:Requested session timeout to be 3600000ms, got 60000ms instead
WARNING:asyncua.client.ua_client.UASocketProtocol:ServiceFault from server received in response to ActivateSessionRequest
Traceback (most recent call last):
File "C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py", line 44, in <module>
asyncio.run(main())
File "C:\Users\User\AppData\Local\Programs\Python\Python37\lib\asyncio\runners.py", line 43, in run
return loop.run_until_complete(main)
File "C:\Users\User\AppData\Local\Programs\Python\Python37\lib\asyncio\base_events.py", line 584, in run_until_complete
return future.result()
File "C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py", line 25, in main
async with Client(url=url) as client:
File "..\asyncua\client\client.py", line 71, in __aenter__
await self.connect()
File "..\asyncua\client\client.py", line 234, in connect
await self.activate_session(username=self._username, password=self._password, certificate=self.user_certificate)
File "..\asyncua\client\client.py", line 443, in activate_session
return await self.uaclient.activate_session(params)
File "..\asyncua\client\ua_client.py", line 302, in activate_session
data = await self.protocol.send_request(request)
File "..\asyncua\client\ua_client.py", line 144, in send_request
self.check_answer(data, f" in response to {request.__class__.__name__}")
File "..\asyncua\client\ua_client.py", line 153, in check_answer
hdr.ServiceResult.check()
File "..\asyncua\ua\uatypes.py", line 224, in check
raise UaStatusCodeError(self.value)
asyncua.ua.uaerrors._auto.BadIdentityTokenInvalid: "The user identity token is not valid."(BadIdentityTokenInvalid)`
**This is my URL:**
`url = "opc.tcp://localhost:49320/OPCUA/SimulationServer/"`
Do you know what the problem could be?
Thanks.
_Originally posted by @SAULSALBAL in https://github.com/FreeOpcUa/opcua-asyncio/issues/225#issuecomment-651231037_ | The user identity token is not valid. Example - client_to_kepware.py | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/227/comments | 6 | 2020-06-29T17:06:59Z | 2020-06-29T19:17:56Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/227 | 647,533,346 | 227 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello,
I am trying to read a tag from KEPServerEX 6 with the example - client_to_kepware, when I run the program I get the following error:
**Error:**
`C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py:28: RuntimeWarning: coroutine 'Client.connect' was never awaited
client.connect()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py:31: RuntimeWarning: coroutine 'Node.get_children' was never awaited
print("childs of root are: ", root.get_children())
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py:32: RuntimeWarning: coroutine 'Node.read_browse_name' was never awaited
print("name of root is", root.read_browse_name())
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py:34: RuntimeWarning: coroutine 'Node.get_children' was never awaited
print("childs og objects are: ", objects.get_children())
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py:38: RuntimeWarning: coroutine 'Node.read_value' was never awaited
print(f"tag1 is: {tag1} with value {tag1.read_value()} ")
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py:40: RuntimeWarning: coroutine 'Node.read_value' was never awaited
print(f"tag2 is: {tag2} with value {tag2.read_value()} ")
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py:55: RuntimeWarning: coroutine 'Client.disconnect' was never awaited
client.disconnect()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
Traceback (most recent call last):
File "C:/Users/User/PycharmProjects/opcua-asyncio/examples/client_to_kepware.py", line 44, in <module>
handle1 = sub.subscribe_data_change(tag1)
AttributeError: 'coroutine' object has no attribute 'subscribe_data_change'
Root is i=84
childs of root are: <coroutine object Node.get_children at 0x00000200456ED3C8>
name of root is <coroutine object Node.read_browse_name at 0x00000200456ED3C8>
childs og objects are: <coroutine object Node.get_children at 0x00000200456ED3C8>
tag1 is: ns=2;s=Channel1.Device1.Tag1 with value <coroutine object Node.read_value at 0x00000200456ED3C8>
tag2 is: ns=2;s=Channel1.Device1.Tag2 with value <coroutine object Node.read_value at 0x00000200456ED3C8>
sys:1: RuntimeWarning: coroutine 'Client.create_subscription' was never awaited
`
**This is my url to connect to kepware:**
client = Client("opc.tcp://127.0.0.1:49320/OPCUA/SimulationServer/") | Error- Example - client_to_kepware.py | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/225/comments | 3 | 2020-06-26T16:32:00Z | 2023-03-29T09:07:48Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/225 | 646,377,512 | 225 |
[
"FreeOpcUa",
"opcua-asyncio"
] | https://github.com/OPCFoundation/UA-Nodeset.git | OPC Foundation nodesets are no longer avalible ... ! | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/224/comments | 6 | 2020-06-24T12:30:06Z | 2020-06-29T06:48:50Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/224 | 644,576,973 | 224 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello together,
so while I couldn't understand #220 I wanted to test the stuff on a fresh pi 3+ with buster, a git clone and python 3.7.3 to be sure it is a python-version problem.
Well now while running pytest my Pi freezes and seems to work with 100% CPU (and is getting pretty hot).
It seems to happen either in `test_history_events` or `test_history_limits`.
Can somebody may confirm similar problems (or even better a solution or a way how I may log something like this?)? | [Busted] Rpi3 freeze while running pytest | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/223/comments | 33 | 2020-06-23T07:36:56Z | 2020-06-26T13:46:56Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/223 | 643,606,104 | 223 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I am using OPC UA Expert as an Client.
OPC Server adds Object and variable shows DataType as String after Subscription.
But for same object In the Attribute Panel it shows Float DataType.
While adding variable - My1Var = await My1.add_variable(idx, AddNode[1], dict1[node]['Value'])
How can I explicitly mention the specific DataType to the desired Variable. | DataType always Shows String by default | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/222/comments | 18 | 2020-06-23T04:09:51Z | 2023-03-29T09:07:08Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/222 | 643,514,471 | 222 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I'm new to OPC-UA so it may be a misunderstanding on how it should work or issue with UA server (FactoryTalk Linx) but if I try to get value of a node via NodeID I get a BadNodeIDUnkown exception from the server.
If I first interact with the parent of the Node (i.e. call `get_parent_descriptions()`) then call the same code, it works.
```python
from asyncua.sync import Client, Node, ua
url = "opc.tcp://10.12.27.15:4990/RinggoldUA"
client = Client(url, timeout=60*10)
client.connect()
root = client.nodes.root
objects = client.nodes.objects
#Try to get via NodeId
try:
value = client.get_node(ua.NodeId("::[CART15]Program:MainProgram.debug_MCPCOMS", 3)).get_value()
print(value)
except Exception as e:
print(e)
#Try to get children of parent first
try:
client.get_node(ua.NodeId("Program:MainProgram", 1465)).get_children_descriptions()
value = client.get_node(ua.NodeId("::[CART15]Program:MainProgram.debug_MCPCOMS", 3)).get_value()
print(value)
except Exception as e:
print(e)
client.disconnect()
```
Response I get is:
`
The node id refers to a node that does not exist in the server address space."(BadNodeIdUnknown)
True`
I was expecting to be able to get get value via NodeId directly. | get_node via NodeId fails until getting parent first | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/221/comments | 11 | 2020-06-22T17:13:01Z | 2020-06-23T15:55:51Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/221 | 643,236,379 | 221 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello everyone,
I have two odd behaviors and can't point it on an explicit commit (have gone back to last release, but I am pretty sure that all test have passed at that time).
My setup:
- PyCharm with Python3.8 with necessary packages.
- Ubuntu 20.04
1. In test_crypro_connect.py:
- test_basic256_encrypt_fail
- test_encrypted_private_key_handling_success
- test_encrypted_private_key_handling_failure
They fail while running all tests via pytests. If I rerun this failed test or test them individual, they pass.
The errors are the same:
```
ERROR [ 80%]
test setup failed
def raise_error():
__tracebackhide__ = True
if info["cancelled"]:
> assert False, f"Took too long to complete: {fle}:{lineno}"
E AssertionError: Took too long to complete: /home/MyUser/PycharmProjects/opc-asycnua/opcua-asyncio/tests/test_crypto_connect.py:91
E assert False
/usr/local/lib/python3.8/dist-packages/alt_pytest_asyncio/async_converters.py:73: AssertionError
```
2. All tests in test_history.py fail, because of the same error like in 1), but rerunning doesn't change anything.
I can't extract a usefull error/message out of it, but can somebody may confirm this? | [solved] Pytests in Python3.8 fail | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/220/comments | 3 | 2020-06-19T13:03:15Z | 2020-06-25T13:35:12Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/220 | 641,953,525 | 220 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I'm trying to create a OPC server using the[ client-example.py](https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples/client-example.py)
The Server works find and if i try to read using:
`"ns=2;i=3"` or any other i works find, but I can't find the way to read like a `"ns=2;s= ****"`
My client works fine wit a Siemens opc server using `DBName.VariableName` as a s
So I created the xml with `await server.export_xml_by_ns("tr.xml")` to try to understand how to call it. In the xml appear the variable devide_id as `"ns=1;i=3"`
This should be ns 2, right? and how I could read as a s= ? "Mydevide.device_id". I try it and putting in front the uri but return me StatusBadNodeIDUnknown (0x80340000)`
| server export xml namespace error and "ns =*;s=*" format | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/214/comments | 2 | 2020-06-18T02:32:53Z | 2020-06-29T01:57:28Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/214 | 640,860,267 | 214 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Switched from your `python-opcua` since it is in maintenance mode, planning to go async as soon as possible, but for now I can't yet and use `asyncua.sync` module, which gives me a problem:
`AttributeError: 'Node' object has no attribute 'get_properties'`
Looking at the code I found possible solution: add code below to `asyncua.sync.Node` class
```python
@syncmethod
def get_properties(self):
pass
```
Can open a Pull Request for this. What do you think? | Compatibility of sync module with python-opcua | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/213/comments | 4 | 2020-06-17T15:53:33Z | 2020-06-18T19:52:39Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/213 | 640,554,773 | 213 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello!
Dear @oroulet could you please help to understand how it possible to catch this exception?
https://github.com/FreeOpcUa/opcua-asyncio/blob/79072d761e3e1e4fcb00ec324bb6c3f4d13f7dbd/asyncua/client/client.py#L388-L390
I know only method like this
`self.client._renew_channel_task.add_done_callback(self.future_callback_error_logger)`
where in callback call `.result` on Future and handle exceptions, but this is access to protected attribute and feels not right.
First of all issue happens like this
> asyncio Task exception was never retrieved
future: <Task finished name='Task-30774' coro=<Client._renew_channel_loop() done, defined at /usr/local/lib/python3.8/site-packages/asyncua/client/client.py:361> exception=TimeoutError() created at /usr/local/lib/python3.8/site-packages/asyncua/client/client.py:358>
source_traceback: Object created at (most recent call last):
File "run.py", line 651, in <module>
p.start()
File "/usr/local/lib/python3.8/multiprocessing/
...
File "/usr/local/lib/python3.8/site-packages/asyncua/client/client.py", line 218, in connect
await self.create_session()
File "/usr/local/lib/python3.8/site-packages/asyncua/client/client.py", line 358, in create_session
self._renew_channel_task = self.loop.create_task(self._renew_channel_loop())
Traceback (most recent call last):
File "/usr/local/lib/python3.8/site-packages/asyncua/client/client.py", line 373, in _renew_channel_loop
await self.open_secure_channel(renew=True)
File "/usr/local/lib/python3.8/site-packages/asyncua/client/client.py", line 267, in open_secure_channel
result = await self.uaclient.open_secure_channel(params)
File "/usr/local/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 271, in open_secure_channel
return await self.protocol.open_secure_channel(params)
File "/usr/local/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 200, in open_secure_channel
result = await asyncio.wait_for(
File "/usr/local/lib/python3.8/asyncio/tasks.py", line 490, in wait_for
raise exceptions.TimeoutError()
asyncio.exceptions.TimeoutError | How catch error while renewing session Task? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/208/comments | 2 | 2020-06-04T20:52:14Z | 2021-07-19T10:27:10Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/208 | 631,137,351 | 208 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Trying to port the Example for Server Event History:
```python
import asyncio
import logging
from asyncua import ua, Server
from asyncua.server.history_sql import HistorySQLite
logging.basicConfig(level=logging.INFO)
_logger = logging.getLogger('asyncua')
async def main():
server = Server()
await server.init()
server.set_endpoint("opc.tcp://0.0.0.0:4845/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = await server.register_namespace(uri)
# populating our address space
myobj = await server.nodes.objects.add_object(idx, "MyObject")
# Creating a custom event
etype = await server.create_custom_event_type(
idx, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
# get an event generator for the myobj node which generates custom events
myevgen = await server.get_event_generator(etype, myobj)
# Configure server to use sqlite as history database (default is a simple in memory dict)
sqlite_history = HistorySQLite("my_event_history.sqlite")
await sqlite_history.init()
server.iserver.history_manager.set_storage(sqlite_history)
async with server:
count = 0
await server.iserver.enable_history_event(myobj, period=None, count=100)
while True:
await asyncio.sleep(5)
myevgen.event.Severity = count
myevgen.event.MyStringProperty = "Property %d" % count
myevgen.event.MyNumericProperty = count
# generate events for subscribed clients and history
await myevgen.trigger(message="This is MyFirstEvent %d" % count)
count += 1
if __name__ == "__main__":
asyncio.run(main())
```
So it generates a table with the fields of the event with the name 2_1 and then errors:
```
ERROR:aiosqlite:returning exception no such table: 0_2253
Traceback (most recent call last):
File "\.virtualenvs\opcua-asyncio_TEST-UFX3oYkk\lib\site-packages\aiosqlite\core.py", line 171, in run
result = function()
sqlite3.OperationalError: no such table: 0_2253
ERROR:asyncua.server.history_sql:Historizing SQL Insert Error for events from NumericNodeId(i=2253): no such table: 0_2253
ERROR:asyncio:Task exception was never retrieved
future: <Task finished name='Task-27' coro=<HistorySQLite.save_event() done, defined at \.virtualenvs\opcua-asyncio_TEST-UFX3oYkk\lib\site-packages\asyncua\server\history_sql.py:135> exception=KeyError(NumericNodeId(i=2253))>
Traceback (most recent call last):
File "\.virtualenvs\opcua-asyncio_TEST-UFX3oYkk\lib\site-packages\asyncua\server\history_sql.py", line 150, in save_event
period = self._datachanges_period[event.emitting_node]
KeyError: NumericNodeId(i=2253)
```
Is this a bug or am I supposed to generate the table manually?
| Example: Server Event History DB write Error | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/207/comments | 3 | 2020-06-04T13:42:13Z | 2023-03-29T09:17:21Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/207 | 630,836,475 | 207 |
[
"FreeOpcUa",
"opcua-asyncio"
] | When running test for a long time, the following exception occurs. why?
------------------------------------------------------------------------------------
Traceback (most recent call last):
File "/home/jfeengadmin/.pyenv/versions/3.8.1/lib/python3.8/site-packages/asyncua/client/ua_client.py", line 78, in _process_received_data
msg = self._connection.receive_from_header_and_body(header, buf)
File "/home/jfeengadmin/.pyenv/versions/3.8.1/lib/python3.8/site-packages/asyncua/common/connection.py", line 314, in receive_from_header_and_body
chunk = MessageChunk.from_header_and_body(self.security_policy, header, body)
File "/home/jfeengadmin/.pyenv/versions/3.8.1/lib/python3.8/site-packages/asyncua/common/connection.py", line 55, in from_header_and_body
crypto.verify(header_to_binary(obj.MessageHeader) + struct_to_binary(obj.SecurityHeader) + decrypted, signature)
File "/home/jfeengadmin/.pyenv/versions/3.8.1/lib/python3.8/site-packages/asyncua/crypto/security_policies.py", line 161, in verify
self.Verifier.verify(data, sig)
File "/home/jfeengadmin/.pyenv/versions/3.8.1/lib/python3.8/site-packages/asyncua/crypto/security_policies.py", line 286, in verify
raise uacrypto.InvalidSignature
AttributeError: module 'asyncua.crypto.uacrypto' has no attribute 'InvalidSignature'
| Exception raised while parsing message from server | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/195/comments | 17 | 2020-05-25T05:32:57Z | 2023-03-29T10:05:58Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/195 | 624,056,337 | 195 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Is it possible to return a dict as result of a method request?
I tried it with a raw dict, which was rasining an error, but a list was ok.
So down here my example code with my settings:
```
# just a simple example of a nonsense method
@uamethod
async def (my_input_vars):
d = {my_input_vars.name: "knock knock", "just_a_test":"who is there? ", my_input_vars.name:"Doctor"}
return d
[...]
ret_val = ua.Argument()
ret_val.Name = "variable results"
ret_val.DataType = ua.NodeId(ua.ObjectIds.String)
ret_val.ValueRank = 1
ret_val.ArrayDimensions = [ ]
ret_val.Description = ua.LocalizedText("Values of Variables")
[...]
await objects.add_method(idx, "get_values", get_device_values, [my_input_vars],[ret_val])
```
Do I need to create an extra extension tyoe or is there a possibility to use a standard one as well? | Dict as method return value? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/194/comments | 3 | 2020-05-20T10:16:06Z | 2020-05-20T10:35:20Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/194 | 621,641,270 | 194 |
[
"FreeOpcUa",
"opcua-asyncio"
] | After updating opcua-asyncio from 0.8.2 to 0.8.3, the following error occurred when running the program.
The program worked normally before.
'SecurityPolicyBasic256' object has no attribute 'host_certifiate'
What's wrong? | 0.8.2 -> 0.8.3 Update: Error when connecting a OPC UA Server with Basic256 | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/193/comments | 10 | 2020-05-18T05:26:47Z | 2023-03-29T08:30:25Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/193 | 619,918,843 | 193 |
[
"FreeOpcUa",
"opcua-asyncio"
] | The two new test in #182 I mentioned here:
https://github.com/FreeOpcUa/opcua-asyncio/pull/182#issuecomment-627897022
seems to fail every time, even if an TimeoutError was thrown.
I am using Python: 3.8.2.
Can anybody reproduce this problem?
| certificate_handling_failure and *_mismatched_creds always fails | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/191/comments | 6 | 2020-05-13T10:47:53Z | 2020-07-27T11:33:15Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/191 | 617,345,282 | 191 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi, is there a way to setup client in a permanent connection to the server so that it doesn't close after receiving the first message or after some time (like using sleep(n))? | Client in streaming | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/190/comments | 2 | 2020-05-13T08:26:14Z | 2020-05-13T10:43:18Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/190 | 617,249,003 | 190 |
[
"FreeOpcUa",
"opcua-asyncio"
] | **Hi ,
I am connecting to WinCC OPCUA Server with Basic128Rsa15 with the below code :**
```
logging.basicConfig(level=logging.WARNING)
client = Client("opc.tcp://EC2AMAZ-VJQV23P:4862")
client.set_security_string("Basic128Rsa15,SignAndEncrypt,AmazonRootCA1.pem,WinCCVMKey.pem")
client.application_uri = "urn:EC2AMAZ-VJQV23P:Siemens.Automation.WinCC"
try:
client.secure_channel_timeout = 30000000
client.session_timeout = 30000000
client.connect()
root = client.get_root_node()
objects = client.get_objects_node()
print("childs og objects are: ", objects.get_children())
#embed()
finally:
#client.disconnect()
print('')
```
But i am getting the below errors:
Also when i am using the client connection with the above code:
**client = Client("opc.tcp://15.206.2.148:4862")**
iam getting the TimeOutError.**
It would be great if anyone can help me out on this .
**Currently i am testing the Signing and Encryption OPCUA python client with WinCC Siemens OPCUA Server on the same local machine.**
Thanks
Rajnish Vishwakarma
| Connecting Siemens WinCC OPCUA server with Basic128Rsa15 with certificates. | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/189/comments | 4 | 2020-05-12T16:10:42Z | 2023-03-29T08:28:55Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/189 | 616,781,345 | 189 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi again, I need to find a way to get Event values and types, so i can send them to a Kafka topic.
Is there a way to extract and convert them to a JSON structure?
Or is there any other best practice to do such a job?
Thanks in advance 💪 | Server Event JSON serializer | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/188/comments | 4 | 2020-05-12T14:24:39Z | 2020-05-12T15:17:04Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/188 | 616,699,817 | 188 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I get an error when i try to import structures from the server if one beginns with a digit.
In common/structures.py line 305
Quick fix for me was just add a _ if it starts with a digit:
for element in model:
if (element.name[0].isdigit()):
element.name = "_" + element.name
code = element.get_code()
exec(code, env)
| Error when loading strucures which begin with a digit | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/187/comments | 2 | 2020-05-12T11:15:16Z | 2023-03-29T08:26:48Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/187 | 616,572,876 | 187 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hi, I took the event server example as is and i tried to run it, but all i got was:
```bash
INFO:asyncua.server.internal_session:Created internal session Internal
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=15957), requested parent node NumericNodeId(i=11715) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=15958), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=15959), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=15960), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=15961), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=15962), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=15963), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=15964), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=16134), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=16135), requested parent node NumericNodeId(i=15957) does not exists
INFO:asyncua.server.address_space:add_node: while adding node NumericNodeId(i=16136), requested parent node NumericNodeId(i=15957) does not exists
WARNING:asyncua.server.server:Endpoints other than open requested but private key and certificate are not set.
INFO:asyncua.server.internal_server:starting internal server
INFO:asyncua.server.binary_server_asyncio:Listening on 0.0.0.0:4840
INFO:asyncua.server.binary_server_asyncio:Closing asyncio socket server
INFO:asyncua.server.internal_server:stopping internal server
INFO:asyncua.server.internal_session:close session Internal
INFO:asyncua.server.subscription_service:delete subscriptions: []
Traceback (most recent call last):
File "opc-ua-server.py", line 57, in <module>
asyncio.run(main())
File "/home/federico/.pyenv/versions/3.8.2/lib/python3.8/asyncio/runners.py", line 43, in run
return loop.run_until_complete(main)
File "/home/federico/.pyenv/versions/3.8.2/lib/python3.8/asyncio/base_events.py", line 616, in run_until_complete
return future.result()
File "opc-ua-server.py", line 50, in main
await myevgen.trigger()
TypeError: object NoneType can't be used in 'await' expression
```
I used pip to install the package and I'm running python 3.8.
Am I doing something wrong? Is there a fix to this?
Btw thanks for the hard work 💪 | Examples: Event Server Error | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/186/comments | 4 | 2020-05-12T08:45:52Z | 2020-05-12T14:20:51Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/186 | 616,475,688 | 186 |
[
"FreeOpcUa",
"opcua-asyncio"
] | In the code, I had created an AirguardBaseObjectType and AirguardSensorType. The AirguardBaseObjectType is used as a nested object under AirguardSensorType. However, when connected to the server, the variables under AirguardBaseObjectType do not appear (circled in red)?
```
objects = server.get_objects_node()
types = server.get_node(ua.ObjectIds.BaseObjectType)
base = await types.add_object_type(idx, "AirguardBaseObjectType")
await (await base.add_variable(idx, "BadScanCounter", 1, ua.VariantType.Int64)).set_modelling_rule(True)
await (await base.add_variable(idx, "DetectorTemp", 0.0, ua.VariantType.Double)).set_modelling_rule(True)
sensor = await types.add_object_type(idx, "AirguardSensorType")
await (await sensor.add_object(idx, "AirguardBaseObject", objecttype=base)).set_modelling_rule(True)
await (await sensor.add_property(idx, "Latitude", 0.0, ua.VariantType.Double)).set_modelling_rule(True)
await (await sensor.add_property(idx, "Longitude", 0.0, ua.VariantType.Double)).set_modelling_rule(True)
await (await sensor.add_property(idx, "Region", "", ua.VariantType.String)).set_modelling_rule(True)
sensor_1 = await objects.add_object(idx, "Sensor001", objecttype=sensor)
```
| Components in nested object do not appear in OPCUA | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/185/comments | 9 | 2020-05-09T07:19:02Z | 2024-04-23T13:33:39Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/185 | 615,113,315 | 185 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello together,
just found an Issue here:
https://github.com/FreeOpcUa/opcua-asyncio/blob/5132c4edee2ae8348e5d960a2f890341b899d916/asyncua/server/server.py#L419
I guess `get_namespace_array` shall be a `async def` and return the value of the NamespaceArray Node. | get_namespace_array is not async | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/180/comments | 7 | 2020-05-05T09:13:48Z | 2020-05-07T09:07:32Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/180 | 612,456,306 | 180 |
[
"FreeOpcUa",
"opcua-asyncio"
] | hi all, just started using freeopcua. I create a custom base object type and now trying to create another object based on the custom object type. However, when using freeopcua client, i noticed that the TypeDefinition for the custom object is Boolean?
This is my code to create custom base object and create another object based on it:
```
base = await server.nodes.base_object_type.add_object_type(idx, "AirguardBaseObjectType")
await (await base.add_variable(idx, "BadScanCounter", 1, ua.VariantType.Int64)).set_modelling_rule(True)
region = await server.nodes.base_object_type.add_object_type(idx, "AirguardRegionType")
await (await region.add_object(idx, "AirguardBaseObjectType", objecttype=base)).set_modelling_rule(True)
```
This is a screenshot showing the TypeDefinition for my custom object (TOP) and a sample of the existing server (BOTTOM)
| Adding an existing object to another object in Freeopcua with proper TypeDefinition | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/179/comments | 0 | 2020-05-04T08:39:31Z | 2020-05-08T08:40:45Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/179 | 611,699,872 | 179 |
[
"FreeOpcUa",
"opcua-asyncio"
] | The sample client codes in examples folder (like client_to_kepware.py, client_to_prosys_cert.py, server-with-encryption.py) are not making asynchronous calls. So, I get errors like:
```
client_to_kepware.py:28: RuntimeWarning: coroutine 'Client.connect' was never awaited
client.connect()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
Root is Node(TwoByteNodeId(i=84))
childs of root are: <coroutine object Node.get_children at 0x7f3db857a540>
client_to_kepware.py:31: RuntimeWarning: coroutine 'Node.get_children' was never awaited
print("childs of root are: ", root.get_children())
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
name of root is <coroutine object Node.get_browse_name at 0x7f3db857a540>
client_to_kepware.py:32: RuntimeWarning: coroutine 'Node.get_browse_name' was never awaited
print("name of root is", root.get_browse_name())
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
childs og objects are: <coroutine object Node.get_children at 0x7f3db857a540>
client_to_kepware.py:34: RuntimeWarning: coroutine 'Node.get_children' was never awaited
print("childs og objects are: ", objects.get_children())
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
client_to_kepware.py:38: RuntimeWarning: coroutine 'Node.read_value' was never awaited
print("tag1 is: {0} with value {1} ".format(tag1, tag1.read_value()))
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
tag1 is: Node(StringNodeId(ns=2;s=Channel1.Device1.Tag1)) with value <coroutine object Node.read_value at 0x7f3db857a540>
client_to_kepware.py:40: RuntimeWarning: coroutine 'Node.read_value' was never awaited
print("tag2 is: {0} with value {1} ".format(tag2, tag2.read_value()))
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
tag2 is: Node(StringNodeId(ns=2;s=Channel1.Device1.Tag2)) with value <coroutine object Node.read_value at 0x7f3db857a540>
client_to_kepware.py:55: RuntimeWarning: coroutine 'Client.disconnect' was never awaited
client.disconnect()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
Traceback (most recent call last):
File "client_to_kepware.py", line 44, in <module>
handle1 = sub.subscribe_data_change(tag1)
AttributeError: 'coroutine' object has no attribute 'subscribe_data_change'
sys:1: RuntimeWarning: coroutine 'Client.create_subscription' was never awaited
``` | Example code not awaiting | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/174/comments | 2 | 2020-04-29T12:58:55Z | 2023-03-29T08:25:02Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/174 | 609,037,084 | 174 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hey ho together,
I am looking for a possibility to add Names and Description into Input- and Outputarguments in Methods, but can't find any at the moment.
Do I oversee something anywhere? | Name and Description of I/O in UA Methods | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/171/comments | 1 | 2020-04-21T06:29:28Z | 2020-04-21T06:37:12Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/171 | 603,742,341 | 171 |
[
"FreeOpcUa",
"opcua-asyncio"
] | When the server side is really stopped by shutdown etc., Please tell me how to catch exceptions such as ServiceFault on the client side. | How to catch exceptions such as ServiceFault... | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/170/comments | 3 | 2020-04-07T05:44:03Z | 2020-04-07T06:16:31Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/170 | 595,607,056 | 170 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Running `uadiscover` fails with the following error
```
Endpoint 1:
Traceback (most recent call last):
File "/home/njames/.local/bin/uadiscover", line 11, in <module>
load_entry_point('asyncua==0.8.2', 'console_scripts', 'uadiscover')()
File "/home/njames/repos/opcua-asyncio/asyncua/tools.py", line 595, in uadiscover
run(_uadiscover())
File "/home/njames/repos/opcua-asyncio/asyncua/tools.py", line 28, in run
return asyncio.run(coro)
File "/usr/local/lib/python3.8/asyncio/runners.py", line 43, in run
return loop.run_until_complete(main)
File "/usr/local/lib/python3.8/asyncio/base_events.py", line 616, in run_until_complete
return future.result()
File "/home/njames/repos/opcua-asyncio/asyncua/tools.py", line 634, in _uadiscover
for (n, v) in endpoint_to_strings(ep):
File "/home/njames/repos/opcua-asyncio/asyncua/tools.py", line 461, in endpoint_to_strings
('Server Certificate', cert_to_string(ep.ServerCertificate)),
File "/home/njames/repos/opcua-asyncio/asyncua/tools.py", line 450, in cert_to_string
from ..crypto import uacrypto
ValueError: attempted relative import beyond top-level package
```
This is fixed by changing
`from ..crypto import uacrypto`
to
`from .crypto import uacrypto` | `uadiscover` ImportError | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/167/comments | 1 | 2020-03-20T09:40:47Z | 2020-06-17T08:24:27Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/167 | 584,948,259 | 167 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Hello,
I am trying to retrieve as a client the complete address space of the opc-ua server. The idea should be of having a client cache of the whole address space. Is there a recursive browsing function for exploring the address space? If not, how can I do it? Does someone has already done it?
Thanks for the help | Browse the complete opc-ua address space | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/165/comments | 20 | 2020-03-16T09:16:31Z | 2022-11-17T09:59:03Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/165 | 582,128,382 | 165 |
[
"FreeOpcUa",
"opcua-asyncio"
] | Getting an error message `Received an error: MessageAbort(error:StatusCode(BadTcpMessageTooLarge), reason:Bad_TcpMessageTooLarge (code=0x80800000, description="Chunk size (132) exceeded maximum (-1)"))` when trying to connect to a OPC UA server.
## Current Behavior
The full log and traceback is as follows:
Received an error: MessageAbort(error:StatusCode(BadTcpMessageTooLarge), reason:Bad_TcpMessageTooLarge (code=0x80800000, description="Chunk size (132) exceeded maximum (-1)"))
Received an error: MessageAbort(error:StatusCode(BadTcpMessageTooLarge), reason:Bad_TcpMessageTooLarge (code=0x80800000, description="Chunk size (132) exceeded maximum (-1)"))
Exception raised while parsing message from server
Traceback (most recent call last):
File "/var/lang/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 158, in _call_callback
self._callbackmap[request_id].set_result(body)
KeyError: 0
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "/var/lang/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 79, in _process_received_data
self._process_received_message(msg)
File "/var/lang/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 98, in _process_received_message
self._call_callback(0, ua.UaStatusCodeError(msg.Error.value))
File "/var/lang/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 161, in _call_callback
f"No request found for request id: {request_id}, pending are {self._callbackmap.keys()}"
asyncua.ua.uaerrors._base.UaError: No request found for request id: 0, pending are dict_keys([1])
disconnect_socket was called but connection is closed
Traceback (most recent call last):
File "opc_ua_server_test.py", line 44, in <module>
loop.run_until_complete(query_opc_ua())
File "/var/lang/lib/python3.7/asyncio/base_events.py", line 584, in run_until_complete
return future.result()
File "opc_ua_server_test.py", line 31, in query_opc_ua
async with client_opc as client:
File "/var/lang/lib/python3.7/site-packages/asyncua/client/client.py", line 71, in __aenter__
await self.connect()
File "/var/lang/lib/python3.7/site-packages/asyncua/client/client.py", line 217, in connect
await self.open_secure_channel()
File "/var/lang/lib/python3.7/site-packages/asyncua/client/client.py", line 267, in open_secure_channel
result = await self.uaclient.open_secure_channel(params)
File "/var/lang/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 271, in open_secure_channel
return await self.protocol.open_secure_channel(params)
File "/var/lang/lib/python3.7/site-packages/asyncua/client/ua_client.py", line 202, in open_secure_channel
self.timeout
File "/var/lang/lib/python3.7/asyncio/tasks.py", line 423, in wait_for
raise futures.TimeoutError()
concurrent.futures._base.TimeoutError
## Possible Solution
The temporary fix is to revert back to version `0.8.1`, which is able to connect to the OPC UA server and read data successfully.
## Steps to Reproduce
1. Use Docker related files available [here](https://www.dropbox.com/sh/i97e5blempr6i4x/AACMCM5ATnrr31PoTUZmPZ8ka?dl=0)
2. Build a Docker image using the Dockerfile as is: `docker build . -t async-ua:requirements-ok`
3. In the Dockerfile, comment out line 15 and uncomment line 16 (=use `requirements-fails.txt`) for the Docker build
4. Build a Docker image using the revised Dockerfile: `docker build . -t async-ua:requirements-fails`
5. Test by running `docker run -it async-ua:requirements-ok` and later run `docker run -it async-ua:requirements-fails`
6. The first Docker container is able to connect to the OPC UA server and the logs are:
2020-03-14 00:44:51,926 - INFO - sys.version = 3.7.3 (default, May 31 2019, 14:47:02)
[GCC 4.8.3 20140911 (Red Hat 4.8.3-9)]
2020-03-14 00:44:51,998 - INFO - Node(TwoByteNodeId(i=84))
2020-03-14 00:44:52,014 - INFO - The triangle value = -1.3333333055583805
2020-03-14 00:44:53,031 - INFO - The triangle value = -1.5999999796457232
2020-03-14 00:44:54,046 - INFO - The triangle value = -1.866666653733066
2020-03-14 00:44:55,061 - INFO - The triangle value = -1.8666666721795913
2020-03-14 00:44:56,075 - INFO - The triangle value = -1.5999999980922488
2020-03-14 00:44:57,072 - INFO - The triangle value = -1.3333333998958972
2020-03-14 00:44:58,086 - INFO - The triangle value = -1.066666725808554
2020-03-14 00:44:59,101 - INFO - The triangle value = -0.8000000517212114
2020-03-14 00:45:00,117 - INFO - The triangle value = -0.5333333776338687
2020-03-14 00:45:01,132 - INFO - The triangle value = -0.266666703546526
7. The second Docker container return the error log and traceback detailed earlier
## Context (Environment)
The OPC UA server being used is the [Prosys OPC UA Simulation Server](https://www.prosysopc.com/products/opc-ua-simulation-server/)
| Bad_TcpMessageTooLarge error when using release 0.8.2 | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/164/comments | 4 | 2020-03-14T01:22:52Z | 2020-12-17T09:25:37Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/164 | 580,972,636 | 164 |
[
"FreeOpcUa",
"opcua-asyncio"
] | I am trying to troubleshoot the frequent [`Future for request id {request_id} is already done: {body}`](https://github.com/FreeOpcUa/opcua-asyncio/blob/5cadb8194ccd8a35622608a590f1c651351f5f75/asyncua/client/ua_client.py#L162-L163) errors I am seeing when using the sync client. The errors seem to occur only on `PublishResponse` messages, and my understanding of [this logic](https://github.com/FreeOpcUa/opcua-asyncio/blob/5cadb8194ccd8a35622608a590f1c651351f5f75/asyncua/client/ua_client.py#L475) is that the `PublishRequest` gets created and sent, but then won't [this](https://github.com/FreeOpcUa/opcua-asyncio/blob/5cadb8194ccd8a35622608a590f1c651351f5f75/asyncua/client/ua_client.py#L138-L141) always timeout and raise a `TimeoutError` because the timeout is 0? This then cancels the future with a `CancelledError` which I suspect then causes this error to occur whenever a `PublishResponse` message arrives. I'm curious whether this timeout makes sense to be 0, or if this is a holdover from `python-opcua` and this timeout argument can be removed for publishing? @cbergmiller I tagged you since you show up in the blame for this one, but it looks like it might be the change might originate [here](https://github.com/FreeOpcUa/python-opcua/commit/9e5a26a97f1079a5db1f55b365411c5e2b5d0317). Thanks for the help! | Why does send_request in UaClient.publish have timeout=0? | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/163/comments | 5 | 2020-03-12T00:42:14Z | 2020-03-17T15:02:44Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/163 | 579,623,227 | 163 |
[
"FreeOpcUa",
"opcua-asyncio"
] | When doing a load_type_definitions() request to a Siemens PLC OPC-UA server configured by the TIA portal, the XML is badly formatted since it contains a <xml /> tag before the rest of the XML. A simple search/replace to remove this part could prevent the error.
Also when loading the type definitions the structs are somehow not classified as arrays even though they are in the supplied XML structure. I haven't traced through the client yet to see why/where this bug is introduced. I'll get back to you.
With another OPC-UA server I get the exception: BadResponseTooLarge. when downloading the XML structure. The default setting in the client is: "params.MaxResponseMessageSize = 0 # means no max size". When viewing the node in UA-Expert i see this reported length: len=175766 | Load_type_definitions exceptions | https://api.github.com/repos/FreeOpcUa/opcua-asyncio/issues/160/comments | 3 | 2020-03-11T11:06:20Z | 2023-03-29T08:23:11Z | https://github.com/FreeOpcUa/opcua-asyncio/issues/160 | 579,182,248 | 160 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.