class TestClass(object):
"""This class only exists for testing the mirror classes with less
overhead than the whole server containing CANopen communication."""
def __init__(self, logger):
self.isinit = False
self.logger = logger
# setup our server
self.server = Server()
self.server.set_endpoint('opc.tcp://localhost:4840/')
self.server.allow_remote_admin(True)
# setup our own namespace, not really necessary but should as spec
uri = "http://yourorganisation.org/DCSControllerDesign/"
self.idx = self.server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
self.objects = self.server.get_objects_node()
# populating our address space; in most real use cases this should be
# imported from UA spec XML.
self.logger.notice('Import UA spec from xml ...')
self.server.import_xml('dcscontrollerdesign.xml')
self.dctni = ua.NodeId.from_string(f'ns={self.idx};i=1003')
self.logger.info(f'{self.dctni}')
self.logger.success('Done')
def __enter__(self):
return self
def __exit__(self, exception_type, exception_value, traceback):
self.server.stop()
if isinstance(exception_value, KeyboardInterrupt):
self.logger.warning('Received Ctrl+C event (KeyboardInterrupt).')
return True
def start(self):
"""Create one mirrored DCS Controller and start the OPC server"""
self.mDC42 = self.objects.add_object(self.idx, 'DCSController42',
self.dctni)
# starting!
self.server.start()
sleep(1)
# after the UA server is started initialize the mirrored object
self.logger.notice('Initialize mirrored object ...')
self.mDC42py = MyDCSController(self, self.mDC42, 42)
sleep(10) # Wait until the class is initialized
self.logger.success('... Done.')
self.isinit = True
self.run()
def run(self):
"""Do nothing"""
while (True):
pass
def __init__(self, name, shared):
super().__init__(name, shared)
self.logger = logging.getLogger(self.name)
self.logger.info("init")
self.shared.config.set_hidden_value(self.name, "user")
self.shared.config.set_hidden_value(self.name, "password")
self.shared.config.set_hidden_value(self.name, "password_hash")
def config(key, val):
return self.shared.config.config(self.name, key, val)
endpoint = config("endpoint", "no_endpoint")
certificate = config("certificate", "")
private_key = config("private_key", "")
uri = config("uri", "http://examples.freeopcua.github.io")
root_object_name = config("root_object_name", "TEST")
separator = config("separator", ".")
namespace = config("namespace", 2)
self.oldnew = config("oldnew_comparision", 0)
admin_username = config("user", "admin")
admin_password = config("password", "admin")
admin_password_hash = config("password_hash", "").replace("$$", "$")
security_ids = []
anonymous_on = config("anonymous_on", 0)
username_on = config("username_on", 1)
certificate_on = config("certificate_basic256sha256_on", 0)
if anonymous_on:
security_ids.append("Anonymous")
if username_on:
security_ids.append("Username")
if certificate_on:
security_ids.append("Basic256Sha256")
security_policy = []
if config("nosecurity_on", 1):
security_policy.append(ua.SecurityPolicyType.NoSecurity)
if config("basic128rsa15_sign_on", 0):
security_policy.append(ua.SecurityPolicyType.Basic128Rsa15_Sign)
if config("basic128rsa15_signandencrypt_on", 0):
security_policy.append(
ua.SecurityPolicyType.Basic128Rsa15_SignAndEncrypt)
if config("basic256_sign_on", 0):
security_policy.append(ua.SecurityPolicyType.Basic256_Sign)
if config("basic256_signandencrypt_on", 0):
security_policy.append(
ua.SecurityPolicyType.Basic256_SignAndEncrypt)
if config("basic256sha256_sign_on", 1):
security_policy.append(ua.SecurityPolicyType.Basic256Sha256_Sign)
if config("basic256sha256_signandencrypt_on", 1):
security_policy.append(
ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt)
initial_values_is_quality_good = config(
"initial_values_is_quality_good", 0)
if anonymous_on:
server = Server()
else:
server = Server(iserver=CustomInternalServer())
server.iserver.set_parent(server)
server.set_endpoint(endpoint)
server.allow_remote_admin(False)
if certificate and private_key:
server.load_certificate(str(certificate))
server.load_private_key(str(private_key))
if security_ids:
server.set_security_IDs(security_ids)
if security_policy:
server.set_security_policy(security_policy)
def custom_user_manager(isession, userName, password):
if userName != admin_username:
return False
if admin_password_hash:
if werkzeug.security.check_password_hash(
admin_password_hash, password):
return True
else:
# fallback to plaintext
if password == admin_password:
return True
return False
if username_on:
server.user_manager.set_user_manager(custom_user_manager)
idx = server.register_namespace(uri)
objects = server.get_objects_node()
root = objects.add_object(idx, root_object_name)
self.server = server
self.objects = objects
self.root = root
self.sep = separator
self.ns = namespace
self.items = []
if initial_values_is_quality_good:
self.initial_status_code = ua.StatusCodes.Good
else:
self.initial_status_code = ua.StatusCodes.BadWaitingForInitialData
