async def set_security(
self,
policy: ua.SecurityPolicy,
certificate: Union[str, uacrypto.CertProperties],
private_key: Union[str, uacrypto.CertProperties],
private_key_password: Optional[Union[str, bytes]] = None,
server_certificate: Optional[Union[str,
uacrypto.CertProperties]] = None,
mode: ua.MessageSecurityMode = ua.MessageSecurityMode.SignAndEncrypt,
):
"""
Set SecureConnection mode.
Call this before connect()
"""
if server_certificate is None:
# Force unencrypted/unsigned SecureChannel to list the endpoints
new_policy = ua.SecurityPolicy()
self.security_policy = new_policy
self.uaclient.security_policy = new_policy
# load certificate from server's list of endpoints
endpoints = await self.connect_and_get_server_endpoints()
endpoint = Client.find_endpoint(endpoints, mode, policy.URI)
server_certificate = uacrypto.x509_from_der(
endpoint.ServerCertificate)
elif not isinstance(server_certificate, uacrypto.CertProperties):
server_certificate = uacrypto.CertProperties(server_certificate)
if not isinstance(certificate, uacrypto.CertProperties):
certificate = uacrypto.CertProperties(certificate)
if not isinstance(private_key, uacrypto.CertProperties):
private_key = uacrypto.CertProperties(
private_key, password=private_key_password)
return await self._set_security(policy, certificate, private_key,
server_certificate, mode)
def __init__(self, url: str, timeout: int = 4, loop=None):
"""
:param url: url of the server.
if you are unsure of url, write at least hostname
and port and call get_endpoints
:param timeout:
Each request sent to the server expects an answer within this
time. The timeout is specified in seconds.
Some other client parameters can be changed by setting
attributes on the constructed object:
See the source code for the exhaustive list.
"""
self.loop = loop or asyncio.get_event_loop()
self.server_url = urlparse(url)
# take initial username and password from the url
self._username = self.server_url.username
self._password = self.server_url.password
self.name = "Pure Python Async. Client"
self.description = self.name
self.application_uri = "urn:freeopcua:client"
self.product_uri = "urn:freeopcua.github.io:client"
self.security_policy = ua.SecurityPolicy()
self.secure_channel_id = None
self.secure_channel_timeout = 3600000 # 1 hour
self.session_timeout = 3600000 # 1 hour
self._policy_ids = []
self.uaclient: UaClient = UaClient(timeout, loop=self.loop)
self.user_certificate = None
self.user_private_key = None
self._server_nonce = None
self._session_counter = 1
self.nodes = Shortcuts(self.uaclient)
self.max_messagesize = 0 # No limits
self.max_chunkcount = 0 # No limits
self._renew_channel_task = None
def __init__(self,
timeout=1,
security_policy=ua.SecurityPolicy(),
loop=None):
"""
:param timeout: Timeout in seconds
:param security_policy: Security policy (optional)
:param loop: Event loop (optional)
"""
self.logger = logging.getLogger(f"{__name__}.UASocketProtocol")
self.loop = loop or asyncio.get_event_loop()
self.transport = None
self.receive_buffer: Optional[bytes] = None
self.is_receiving = False
self.timeout = timeout
self.authentication_token = ua.NodeId()
self._request_id = 0
self._request_handle = 0
self._callbackmap: Dict[int, asyncio.Future] = {}
self._connection = SecureConnection(security_policy)
self.state = self.INITIALIZED
self.closed: bool = False
# needed to pass params from asynchronous request to synchronous data receive callback, as well as
# passing back the processed response to the request so that it can return it.
self._open_secure_channel_exchange = None
def __init__(self, timeout=1, loop=None):
self.logger = logging.getLogger(__name__ + '.UaClient')
self.loop = loop or asyncio.get_event_loop()
self._publish_callbacks = {}
self._timeout = timeout
self.security_policy = ua.SecurityPolicy()
self.protocol: UASocketProtocol = None
self._sub_cond = asyncio.Condition()
self._sub_data_queue = []
def __init__(self, timeout=1):
"""
:param timeout: Timout in seconds
"""
self.logger = logging.getLogger(f'{__name__}.UaClient')
self._subscription_callbacks = {}
self._timeout = timeout
self.security_policy = ua.SecurityPolicy()
self.protocol: Optional[UASocketProtocol] = None
self._publish_task = None
def __init__(self, internal_server: InternalServer, transport):
self.iserver: InternalServer = internal_server
self.name = transport.get_extra_info('peername')
self.sockname = transport.get_extra_info('sockname')
self.session: Optional[InternalSession] = None
self._transport = transport
# deque for Publish Requests
self._publish_requests: Deque[PublishRequestData] = deque()
# used when we need to wait for PublishRequest
self._publish_results: Deque[ua.PublishResult] = deque()
self._connection = SecureConnection(ua.SecurityPolicy())
def __init__(self, timeout=1, security_policy=ua.SecurityPolicy(), loop=None):
self.logger = logging.getLogger(__name__ + ".UASocketProtocol")
self.loop = loop or asyncio.get_event_loop()
self.transport = None
self.receive_buffer: bytes = None
self.is_receiving = False
self.timeout = timeout
self.authentication_token = ua.NodeId()
self._request_id = 0
self._request_handle = 0
self._callbackmap = {}
self._connection = SecureConnection(security_policy)
self.state = self.INITIALIZED
def __init__(self, timeout=1, security_policy=ua.SecurityPolicy(), loop=None):
"""
:param timeout: Timeout in seconds
:param security_policy: Security policy (optional)
:param loop: Event loop (optional)
"""
self.logger = logging.getLogger(f"{__name__}.UASocketProtocol")
self.loop = loop or asyncio.get_event_loop()
self.transport = None
self.receive_buffer: Optional[bytes] = None
self.is_receiving = False
self.timeout = timeout
self.authentication_token = ua.NodeId()
self._request_id = 0
self._request_handle = 0
self._callbackmap: Dict[int, asyncio.Future] = {}
self._connection = SecureConnection(security_policy)
self.state = self.INITIALIZED
def test_message_chunk():
pol = ua.SecurityPolicy()
chunks = MessageChunk.message_to_chunks(pol, b'123', 65536)
assert len(chunks) == 1
seq = 0
for chunk in chunks:
seq += 1
chunk.SequenceHeader.SequenceNumber = seq
chunk2 = MessageChunk.from_binary(pol, ua.utils.Buffer(chunks[0].to_binary()))
assert chunks[0].to_binary() == chunk2.to_binary()
# for policy None, MessageChunk overhead is 12+4+8 = 24 bytes
# Let's pack 11 bytes into 28-byte chunks. The message must be split as 4+4+3
chunks = MessageChunk.message_to_chunks(pol, b'12345678901', 28)
assert len(chunks) == 3
assert chunks[0].Body == b'1234'
assert chunks[1].Body == b'5678'
assert chunks[2].Body == b'901'
for chunk in chunks:
seq += 1
chunk.SequenceHeader.SequenceNumber = seq
assert len(chunk.to_binary()) <= 28
