def test_valid(self): bar_builder = GroupBuilder('my_bar', attributes={'data_type': 'Bar', 'attr1': text('a string attribute')}, datasets=[DatasetBuilder('data', 100, attributes={'attr2': 10})]) foo_builder = GroupBuilder('my_foo', attributes={'data_type': 'Foo', 'foo_attr': text('example Foo object')}, groups=[bar_builder]) results = self.vmap.validate(foo_builder) self.assertEqual(len(results), 0)
def getSpecs(self): bar = GroupSpec('A test group specification with a data type', data_type_def='Bar', datasets=[ DatasetSpec('an example dataset', 'int', name='data', attributes=[ AttributeSpec( 'attr2', 'an example integer attribute', 'int') ]) ], attributes=[ AttributeSpec('attr1', text('an example string attribute'), 'text') ]) foo = GroupSpec('A test group that contains a data type', data_type_def='Foo', groups=[ GroupSpec('A Bar group for Foos', name='my_bar', data_type_inc='Bar') ], attributes=[ AttributeSpec( 'foo_attr', 'a string attribute specified as text', 'text', required=False) ]) return (bar, foo)
def test_valid(self): builder = GroupBuilder('my_bar', attributes={'data_type': 'Bar', 'attr1': text('a string attribute')}, datasets=[DatasetBuilder('data', 100, attributes={'attr2': 10})]) validator = self.vmap.get_validator('Bar') result = validator.validate(builder) self.assertEqual(len(result), 0)
def test_invalid_missing_req_type(self): foo_builder = GroupBuilder('my_foo', attributes={'data_type': 'Foo', 'foo_attr': text('example Foo object')}) results = self.vmap.validate(foo_builder) self.assertIsInstance(results[0], MissingDataType) # noqa: F405 self.assertEqual(results[0].name, 'Foo') self.assertEqual(results[0].reason, 'missing data type Bar')
def test_invalid_wrong_name_req_type(self): bar_builder = GroupBuilder('bad_bar_name', attributes={'data_type': 'Bar', 'attr1': 'a string attribute'}, datasets=[DatasetBuilder('data', 100, attributes={'attr2': 10})]) foo_builder = GroupBuilder('my_foo', attributes={'data_type': 'Foo', 'foo_attr': text('example Foo object')}, groups=[bar_builder]) results = self.vmap.validate(foo_builder) self.assertEqual(len(results), 1) self.assertIsInstance(results[0], MissingDataType) # noqa: F405 self.assertEqual(results[0].data_type, 'Bar')
def WampSessionProcMapper(funcname): wampfuncname = text('.'.join((ID, funcname))) def catcher_func(*args, **kwargs): if _WampSession is not None: try: return threads.blockingCallFromThread( reactor, _WampSession.call, wampfuncname, *args, **kwargs) except TransportLost: confnodesroot.logger.write_error(_("Connection lost!\n")) confnodesroot._SetConnector(None) except Exception: errmess = traceback.format_exc() confnodesroot.logger.write_error(errmess+"\n") print(errmess) # confnodesroot._SetConnector(None) return PLCObjDefaults.get(funcname) return catcher_func
def onJoin(self, details): global _WampSession _WampSession = self ID = self.config.extra["ID"] for name, kwargs in ExposedCalls: try: registerOptions = types.RegisterOptions(**kwargs) except TypeError as e: registerOptions = None print(_("TypeError register option: {}".format(e))) self.register(GetCallee(name), u'.'.join((ID, name)), registerOptions) for name in SubscribedEvents: self.subscribe(GetCallee(name), text(name)) for func in DoOnJoin: func(self) print(_('WAMP session joined (%s) by:' % time.ctime()), ID)
def RegisterWampClient(): # start logging to console # log.startLogging(sys.stdout) # create a WAMP application session factory component_config = types.ComponentConfig( realm=text(realm), extra={"ID": ID}) session_factory = wamp.ApplicationSessionFactory( config=component_config) session_factory.session = cls # create a WAMP-over-WebSocket transport client factory transport_factory = WampWebSocketClientFactory( session_factory, url=url, serializers=[MsgPackSerializer()]) # start the client from a Twisted endpoint conn = connectWS(transport_factory) confnodesroot.logger.write(_("WAMP connecting to URL : %s\n") % url) return conn
def get_md5hash(self): c = text(self.msgid) + text(self.msgstr) + text(self.msgctxt) return md5(c.encode("utf8")).hexdigest()
def __getitem__(self, key): return text(getattr(self, key))
def create(options): key = ec.generate_private_key(ec.SECP256R1(), default_backend()) options.key_output.write( key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.TraditionalOpenSSL, encryption_algorithm=serialization.NoEncryption())) # Various details about who we are. For a self-signed certificate the # subject and issuer are always the same. subjectList = [] try: if options.country: subjectList += [ x509.NameAttribute(x509.oid.NameOID.COUNTRY_NAME, text(options.country)) ] if options.state: subjectList += [ x509.NameAttribute(x509.oid.NameOID.STATE_OR_PROVINCE_NAME, text(options.state)) ] if options.locality: subjectList += [ x509.NameAttribute(x509.oid.NameOID.LOCALITY_NAME, text(options.locality)) ] if options.organization: subjectList += [ x509.NameAttribute(x509.oid.NameOID.ORGANIZATION_NAME, text(options.organization)) ] if options.common_name: subjectList += [ x509.NameAttribute(x509.oid.NameOID.COMMON_NAME, text(options.common_name)) ] if len(subjectList) == 0: subjectList += [ x509.NameAttribute(x509.oid.NameOID.COMMON_NAME, text('localhost')) ] subject = issuer = x509.Name(subjectList) except ValueError as e: LOG.critical('Error creating certificate: {}'.format(e.message)) fname = options.output_file.name options.output_file.close() os.remove(fname) return 1 subjectKey = key.public_key().public_bytes( serialization.Encoding.DER, serialization.PublicFormat.SubjectPublicKeyInfo) subjectKeyIdentifier = utils.sha_hash( subjectKey)[:160 // 8] # Use RFC7093, Method 1 try: cert = x509.CertificateBuilder().subject_name(subject).issuer_name( issuer).public_key(key.public_key( )).serial_number(x509.random_serial_number()).not_valid_before( datetime.datetime.utcnow()).not_valid_after( datetime.datetime.utcnow() + datetime.timedelta(days=options.valid_time)).add_extension( x509.KeyUsage(digital_signature=True, content_commitment=False, key_encipherment=False, data_encipherment=False, key_agreement=False, key_cert_sign=False, crl_sign=False, encipher_only=False, decipher_only=False), critical=False).add_extension( x509.SubjectAlternativeName( [x509.DNSName(u"localhost")]), critical=False, ).add_extension( x509.ExtendedKeyUsage( [x509.oid.ExtendedKeyUsageOID.CODE_SIGNING]), critical=False, ).add_extension( x509.SubjectKeyIdentifier(subjectKeyIdentifier), critical=False, # Sign our certificate with our private key ).sign(key, hashes.SHA256(), default_backend()) except ValueError as e: LOG.critical('Error creating certificate: {}'.format(e.message)) fname = options.output_file.name options.output_file.close() os.remove(fname) return 1 # Write our certificate out to disk. options.output_file.write(cert.public_bytes(serialization.Encoding.DER)) options.output_file.close() print( '[\033[1;93mWARNING\033[1;0m]: Certificates generated with this tool are self-signed and for testing only', file=sys.stderr) if options.valid_time < 10 * 365.25: print( '[\033[1;93mWARNING\033[1;0m]: This certificate is valid for {} days. For production,' 'use certificates with at least 10 years validity.'.format( options.valid_time), file=sys.stderr) return 0
def PublishEventWithOwnID(eventID, value): if getWampStatus() == "Attached": _WampSession.publishWithOwnID(text(eventID), value)
def publishWithOwnID(self, eventID, value): ID = self.config.extra["ID"] self.publish(text(ID+'.'+eventID), value)