Cli improvements

CHANGELOG.rst

@@ -1,6 +1,13 @@
 Changelog
 ---------
 
+v0.4.2
+======
+- Command line fixes:
+    - Support passing ssl certificate and http headers when using ws/wss
+    - Support requesting --version without the need to specify URI arguments
+    - Option --interactionModel to specify interaction (eg. request_response, request_stream)
+    - Added Metadata Push support
 
 v0.4.1
 ======

examples/fixtures.py

@@ -7,46 +7,63 @@
 
 
 @contextmanager
-def cert_gen(emailAddress="emailAddress",
-             commonName="commonName",
-             countryName="NT",
-             localityName="localityName",
-             stateOrProvinceName="stateOrProvinceName",
-             organizationName="organizationName",
-             organizationUnitName="organizationUnitName",
-             serialNumber=0,
-             validityStartInSeconds=0,
-             validityEndInSeconds=None) -> Tuple[str, str]:
-    if validityEndInSeconds is None:
-        validityEndInSeconds = int(timedelta(days=3650).total_seconds())
+def generate_certificate_and_key(email_address="emailAddress",
+                                 common_name="localhost",
+                                 country_name="NT",
+                                 locality_name="localityName",
+                                 state_or_province_name="stateOrProvinceName",
+                                 organization_name="organizationName",
+                                 organization_unit_name="organizationUnitName",
+                                 serial_number=0,
+                                 validity_start_in_seconds=0,
+                                 validity_end_in_seconds=None) -> Tuple[str, str]:
+    if validity_end_in_seconds is None:
+        validity_end_in_seconds = int(timedelta(days=3650).total_seconds())
+
     # can look at generated file using openssl:
     # openssl x509 -inform pem -in selfsigned.crt -noout -text
     # create a key pair
-    k = crypto.PKey()
-    k.generate_key(crypto.TYPE_RSA, 4096)
+    private_key = create_key()
 
     # create a self-signed cert
-    cert = crypto.X509()
-    cert.get_subject().C = countryName
-    cert.get_subject().ST = stateOrProvinceName
-    cert.get_subject().L = localityName
-    cert.get_subject().O = organizationName
-    cert.get_subject().OU = organizationUnitName
-    cert.get_subject().CN = commonName
-    cert.get_subject().emailAddress = emailAddress
-    cert.set_serial_number(serialNumber)
-    cert.gmtime_adj_notBefore(0)
-    cert.gmtime_adj_notAfter(validityEndInSeconds)
-    cert.set_issuer(cert.get_subject())
-    cert.set_pubkey(k)
-    cert.sign(k, 'sha512')
+    cert = create_self_signed_certificate(common_name, country_name, email_address, private_key, locality_name,
+                                          organization_name,
+                                          organization_unit_name, serial_number, state_or_province_name,
+                                          validity_end_in_seconds, validity_start_in_seconds)
 
     with tempfile.NamedTemporaryFile() as certificate_file:
         with tempfile.NamedTemporaryFile() as key_file:
             certificate_file.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
             certificate_file.flush()
 
-            key_file.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, k))
+            key_file.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, private_key))
             key_file.flush()
 
             yield certificate_file.name, key_file.name
+
+
+def create_key():
+    k = crypto.PKey()
+    k.generate_key(crypto.TYPE_RSA, 4096)
+    return k
+
+
+def create_self_signed_certificate(common_name, country_name, email_address, private_key, locality_name,
+                                   organization_name,
+                                   organization_unit_name, serial_number, state_or_province_name,
+                                   validity_end_in_seconds, validity_start_in_seconds):
+    cert = crypto.X509()
+    cert.get_subject().C = country_name
+    cert.get_subject().ST = state_or_province_name
+    cert.get_subject().L = locality_name
+    cert.get_subject().O = organization_name
+    cert.get_subject().OU = organization_unit_name
+    cert.get_subject().CN = common_name
+    cert.get_subject().emailAddress = email_address
+    cert.set_serial_number(serial_number)
+    cert.gmtime_adj_notBefore(validity_start_in_seconds)
+    cert.gmtime_adj_notAfter(validity_end_in_seconds)
+    cert.set_issuer(cert.get_subject())
+    cert.set_pubkey(private_key)
+    cert.sign(private_key, 'sha512')
+    return cert

examples/server_aiohttp_websocket.py

@@ -4,7 +4,7 @@
 import asyncclick as click
 from aiohttp import web
 
-from examples.fixtures import cert_gen
+from examples.fixtures import generate_certificate_and_key
 from rsocket.helpers import create_future
 from rsocket.local_typing import Awaitable
 from rsocket.payload import Payload
@@ -42,7 +42,7 @@ async def start_server(with_ssl: bool, port: int):
     if with_ssl:
         ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
 
-        with cert_gen() as (certificate, key):
+        with generate_certificate_and_key() as (certificate, key):
             ssl_context.load_cert_chain(certificate, key)
     else:
         ssl_context = None

examples/server_with_routing.py

@@ -9,7 +9,7 @@
 from aiohttp import web
 
 from examples.example_fixtures import large_data1
-from examples.fixtures import cert_gen
+from examples.fixtures import generate_certificate_and_key
 from examples.response_channel import response_stream_1, LoggingSubscriber
 from response_stream import response_stream_2
 from rsocket.extensions.authentication import Authentication, AuthenticationSimple
@@ -136,15 +136,18 @@ async def start_server(with_ssl: bool, port: int, transport: str):
         app = web.Application()
         app.add_routes([web.get('/', websocket_handler_factory(handler_factory=handler_factory))])
 
-        if with_ssl:
-            ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+        with generate_certificate_and_key() as (certificate_path, key_path):
+            if with_ssl:
+                ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
 
-            with cert_gen() as (certificate, key):
-                ssl_context.load_cert_chain(certificate, key)
-        else:
-            ssl_context = None
+                logging.info('Certificate %s', certificate_path)
+                logging.info('Private-key %s', key_path)
 
-        await web._run_app(app, port=port, ssl_context=ssl_context)
+                ssl_context.load_cert_chain(certificate_path, key_path)
+            else:
+                ssl_context = None
+
+            await web._run_app(app, port=port, ssl_context=ssl_context)
     elif transport == 'tcp':
 
         server = await asyncio.start_server(handle_client, 'localhost', port)