FreeOpcUa / python-opcua

    __repr__ = __str__

class RegisteredServer(FrozenClass):

    '''

    The information required to register a server with a discovery server.

    :ivar ServerUri:

    :vartype ServerUri: String

    :ivar ProductUri:

    :vartype ProductUri: String

    :ivar ServerNames:

    :vartype ServerNames: LocalizedText

    :ivar ServerType:

    :vartype ServerType: ApplicationType

    :ivar GatewayServerUri:

    :vartype GatewayServerUri: String

    :ivar DiscoveryUrls:

    :vartype DiscoveryUrls: String

    :ivar SemaphoreFilePath:

    :vartype SemaphoreFilePath: String

    :ivar IsOnline:

    :vartype IsOnline: Boolean

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ServerUri = None

        self.ProductUri = None

        self.ServerNames = []

        self.ServerType = ApplicationType(0)

        self.GatewayServerUri = None

        self.DiscoveryUrls = []

        self.SemaphoreFilePath = None

        self.IsOnline = True

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.ServerUri))

        packet.append(pack_string(self.ProductUri))

        packet.append(uatype_Int32.pack(len(self.ServerNames)))

        for fieldname in self.ServerNames:

            packet.append(fieldname.to_binary())

        packet.append(uatype_UInt32.pack(self.ServerType.value))

        packet.append(pack_string(self.GatewayServerUri))

        packet.append(uatype_Int32.pack(len(self.DiscoveryUrls)))

        for fieldname in self.DiscoveryUrls:

            packet.append(pack_string(fieldname))

        packet.append(pack_string(self.SemaphoreFilePath))

        packet.append(uatype_Boolean.pack(self.IsOnline))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisteredServer(data)

    def _binary_init(self, data):

        self.ServerUri = unpack_string(data)

        self.ProductUri = unpack_string(data)

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(LocalizedText.from_binary(data))

        self.ServerNames = array

        self.ServerType = ApplicationType(uatype_UInt32.unpack(data.read(4))[0])

        self.GatewayServerUri = unpack_string(data)

        self.DiscoveryUrls = unpack_uatype_array('String', data)

        self.SemaphoreFilePath = unpack_string(data)

        self.IsOnline = uatype_Boolean.unpack(data.read(1))[0]

    def __str__(self):

        return 'RegisteredServer(' + 'ServerUri:' + str(self.ServerUri) + ', ' + \

               'ProductUri:' + str(self.ProductUri) + ', ' + \

               'ServerNames:' + str(self.ServerNames) + ', ' + \

               'ServerType:' + str(self.ServerType) + ', ' + \

               'GatewayServerUri:' + str(self.GatewayServerUri) + ', ' + \

               'DiscoveryUrls:' + str(self.DiscoveryUrls) + ', ' + \

               'SemaphoreFilePath:' + str(self.SemaphoreFilePath) + ', ' + \

               'IsOnline:' + str(self.IsOnline) + ')'

    __repr__ = __str__

    __repr__ = __str__

class EndpointDescription(FrozenClass):

    '''

    The description of a endpoint that can be used to access a server.

    :ivar EndpointUrl:

    :vartype EndpointUrl: String

    :ivar Server:

    :vartype Server: ApplicationDescription

    :ivar ServerCertificate:

    :vartype ServerCertificate: ByteString

    :ivar SecurityMode:

    :vartype SecurityMode: MessageSecurityMode

    :ivar SecurityPolicyUri:

    :vartype SecurityPolicyUri: String

    :ivar UserIdentityTokens:

    :vartype UserIdentityTokens: UserTokenPolicy

    :ivar TransportProfileUri:

    :vartype TransportProfileUri: String

    :ivar SecurityLevel:

    :vartype SecurityLevel: Byte

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.EndpointUrl = None

        self.Server = ApplicationDescription()

        self.ServerCertificate = None

        self.SecurityMode = MessageSecurityMode(0)

        self.SecurityPolicyUri = None

        self.UserIdentityTokens = []

        self.TransportProfileUri = None

        self.SecurityLevel = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.EndpointUrl))

        packet.append(self.Server.to_binary())

        packet.append(pack_bytes(self.ServerCertificate))

        packet.append(uatype_UInt32.pack(self.SecurityMode.value))

        packet.append(pack_string(self.SecurityPolicyUri))

        packet.append(uatype_Int32.pack(len(self.UserIdentityTokens)))

        for fieldname in self.UserIdentityTokens:

            packet.append(fieldname.to_binary())

        packet.append(pack_string(self.TransportProfileUri))

        packet.append(uatype_Byte.pack(self.SecurityLevel))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return EndpointDescription(data)

    def _binary_init(self, data):

        self.EndpointUrl = unpack_string(data)

        self.Server = ApplicationDescription.from_binary(data)

        self.ServerCertificate = unpack_bytes(data)

        self.SecurityMode = MessageSecurityMode(uatype_UInt32.unpack(data.read(4))[0])

        self.SecurityPolicyUri = unpack_string(data)

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(UserTokenPolicy.from_binary(data))

        self.UserIdentityTokens = array

        self.TransportProfileUri = unpack_string(data)

        self.SecurityLevel = uatype_Byte.unpack(data.read(1))[0]

    def __str__(self):

        return 'EndpointDescription(' + 'EndpointUrl:' + str(self.EndpointUrl) + ', ' + \

               'Server:' + str(self.Server) + ', ' + \

               'ServerCertificate:' + str(self.ServerCertificate) + ', ' + \

               'SecurityMode:' + str(self.SecurityMode) + ', ' + \

               'SecurityPolicyUri:' + str(self.SecurityPolicyUri) + ', ' + \

               'UserIdentityTokens:' + str(self.UserIdentityTokens) + ', ' + \

               'TransportProfileUri:' + str(self.TransportProfileUri) + ', ' + \

               'SecurityLevel:' + str(self.SecurityLevel) + ')'

    __repr__ = __str__