more examples

Author: irmen

Pyro5/compatibility/Pyro4.py

@@ -53,7 +53,7 @@ def __init__(self, namespace):
         self.namespace = namespace
 
     def __getattr__(self, item):
-        raise NotImplementedError("The Pyro4 compatibility layer doesn't provide the Pyro4.{0} namespace, "
+        raise NotImplementedError("The Pyro4 compatibility layer doesn't provide the Pyro4.{0} module, "
                                   "first make sure the code only uses symbols from the Pyro4 package directly"
                                   .format(self.namespace))
 

Pyro5/protocol.py

@@ -159,7 +159,7 @@ def add_payload(self, payload):
             while i < self.annotations_size:
                 annotation_id = bytes(payload[i:i+4]).decode("ascii")
                 length = int.from_bytes(payload[i+4:i+8], "big")
-                self.annotations[annotation_id] = payload[i+8:i+8+length]
+                self.annotations[annotation_id] = payload[i+8:i+8+length]     # note: it stores a memoryview!
                 i += 8 + length
             assert i == self.annotations_size
             self.data = payload[self.annotations_size:]

Readme.rst

@@ -59,6 +59,9 @@ changes done based on original Pyro4
   A single thread is the sole "owner" of a proxy. Another thread can use proxy._pyroClaimOwnership to take over.
 - simplified serializers by moving the task of compressing data to the protocol module instead (where it belonged)
 - optimized wire messages (less code, sometimes less data copying by using memoryviews)
+- annotations on the protocol message are stored as no-copy memoryviews now. A memoryview doesn't support all
+  methods you might expect so sometimes it may be required now to convert it to bytes or bytearray in your
+  own code first, before further processing. Note that this will create a copy again, so it's best avoided.
 - for now, requires ``msgpack`` to be installed as well as ``serpent``.
 
 

certs/client_cert.pem

@@ -0,0 +1,23 @@
+-----BEGIN CERTIFICATE-----
+MIID3DCCAsSgAwIBAgIJANw+/bUr6dNQMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD
+VQQGEwJOTDETMBEGA1UECAwKU29tZS1TdGF0ZTEWMBQGA1UECgwNUmF6b3J2aW5l
+Lm5ldDEOMAwGA1UECwwFUHlybzUxEjAQBgNVBAMMCWxvY2FsaG9zdDEiMCAGCSqG
+SIb3DQEJARYTaXJtZW5AcmF6b3J2aW5lLm5ldDAeFw0xODA2MTMyMjQ2MTRaFw0y
+MDExMjkyMjQ2MTRaMIGCMQswCQYDVQQGEwJOTDETMBEGA1UECAwKU29tZS1TdGF0
+ZTEWMBQGA1UECgwNUmF6b3J2aW5lLm5ldDEOMAwGA1UECwwFUHlybzUxEjAQBgNV
+BAMMCWxvY2FsaG9zdDEiMCAGCSqGSIb3DQEJARYTaXJtZW5AcmF6b3J2aW5lLm5l
+dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALkoq/1zaZwjMn76HLTz
+XJkz8FBz74fydwyentCtH4k6fRa83Oc73qtpBw8p/vNxWrQb5mO7D5JW2sxAQBhL
+sjq5KT/JC5zFJbutTXjGmYX9hqe14ts8rNbfCIBHYhZHTPKVTAvJZda2sG+KrOa8
+ojQf8D57T2nQ2TggYPetTPX0JLjEXXe8FRZcjdQm2j0pVptiErj2nLkCFaRV0/WO
+lrHEI9J3N2PV8FEClLhqgGmzmvDFrGwul3nPw7Z2Z4B0iAdoBK4X7mm+DlFPGQD+
+QBcxSfsDCoNjqt4mUeitdyqG8XvOARWNma19S/KF4fEh19MN8bJQwsh/N6JJw5G3
+n2MCAwEAAaNTMFEwHQYDVR0OBBYEFBUythr0ngdQ6e11uqlbX99a71tJMB8GA1Ud
+IwQYMBaAFBUythr0ngdQ6e11uqlbX99a71tJMA8GA1UdEwEB/wQFMAMBAf8wDQYJ
+KoZIhvcNAQELBQADggEBACCBDVBY5ba1SRcoKBYCJaT6bEWbIMetXaNvRqLEwrwC
+QntNlaoyCYt7nY6p3Kc/OxujAJse7FovACLpCiXqAn1YIv2hixKodVwRvNEdOQOD
+ohBmtOdxcjzs4MRCo87ZyoJwgphmai3uYcwcEr6sMVmTURl91PQJuM3+B9tx5aGF
+VWuXFHahJ0tHmblp02Imq0je8536REb+rQyuRsFIAUmgTqn30WEay36sh+JYG4tK
+EwEhpG+/OjSghB3doqUqMu7bYi2W6/EVsjNhmTv5pv6E7azG32ebb6fiz6Bne0Ub
+dehUNY0kMoBM53UG1QjOxBNVsNWelEM/OU39/sVwi2k=
+-----END CERTIFICATE-----

certs/client_key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC5KKv9c2mcIzJ+
++hy081yZM/BQc++H8ncMnp7QrR+JOn0WvNznO96raQcPKf7zcVq0G+Zjuw+SVtrM
+QEAYS7I6uSk/yQucxSW7rU14xpmF/YanteLbPKzW3wiAR2IWR0zylUwLyWXWtrBv
+iqzmvKI0H/A+e09p0Nk4IGD3rUz19CS4xF13vBUWXI3UJto9KVabYhK49py5AhWk
+VdP1jpaxxCPSdzdj1fBRApS4aoBps5rwxaxsLpd5z8O2dmeAdIgHaASuF+5pvg5R
+TxkA/kAXMUn7AwqDY6reJlHorXcqhvF7zgEVjZmtfUvyheHxIdfTDfGyUMLIfzei
+ScORt59jAgMBAAECggEBALJI91KUTpyJR5X8Pqf9rKvX1w2glIPSc88y7LkB+duo
+9clvEUWV4FIsTx/K0DKYcz35n11oQRYni4YgV5cNTBA/OfixHP1W135e4LnqgOkD
+tSTHfiibw9Eh8I2ULl5FSVJLb23p/qVAQ6MjZFjISWbnWezPzyeUcZQZmUTjGbe4
+Olw+7T/DIKASuWzyxjEwYEHmCp6sBAN2E4BjkaH40oOo4h2movgpEL5wqMJf2zG1
+z8vzpXRT8OXqyClX4o/9yaVgA3VWMZPYp0FSu3gd99uZ8o+EekD0EVaA1cCCvN3J
+qBkkWdf+4fqOyU8XSxE95YgKnPWPUO36/03/tlslDAECgYEA2qYNZHBeZm+66cEM
+WlMcv1qp3U2utpotNo7Iz8lp4hVhCaFVhMuhRbNe6RpxHBoOsDTBSBWy/Urg+hWv
+MZTDk9dfS/5oYLosQ9gftq+wgzKtpfUSQU9lYVbapCPyQiXhq+fqU1aCX47Qpesa
+6NrjrhG28YtFT8trMOhFKO+bcHUCgYEA2MoLUMpqReAP4d56W2tiuAXBw64Lhdzo
+grFeNXsHrFEclofQbe0OuUE0IMPYjtHpdFVyiU2umW3paHFlBTUJYqZCMdliBj7Y
+sOx8xKzaAXZbVwDIwzWfcj+QCvjRi90nlanoZ6jf5HeIBjt44xz0+8aYzDmPDsfO
+ADMDB0+x1XcCgYBVMd6GBELEJ0TtUAtAJqJM7UbCtEIfZHO5jmkwjYp0TWBCIFry
+I2XzgrC4o1TvXjfa8LNfIxVbHJIM3+Yjq5OJR6IaOkbxaZlV1iCFTm+4r0Z6I8O5
+LvaRtwX6bwc2Pwxvry3eyxaBpWQnQjR6BtAwQzbFZz7amKhrphVMnhAzAQKBgQCo
+bLBF4DyYdO9h59rf05oqpi5XvIwvP+VURECRBDh947Z2LKX+AUKDIulA22cP7n2V
+aB1IFxYjFYVVI2P8m6vi/JBI8j5547GuIsz8b94fbLih63YOU0bBGCjsnUsPgo4S
+dKKehlELyuHfFa1hpUmfojdr0vwV251sAjXEJGJhGQKBgQCBK1ZtedBCuyuavKcI
+Na/bYC84nHnKSEfGhx8lUG2ugX3lXIlrElqSpoUFSCRdKadHRBKYS6mg02Y48B1N
+XrJ3sNMS6k6xq/57y1LlnOjzdnP9gqYQ9xMbvkvxzJjI+i0yOJRufYREb6DD7g50
+w80R2Deyap2JbcdBOlLdAYC/Uw==
+-----END PRIVATE KEY-----

certs/readme.txt

@@ -0,0 +1,14 @@
+These SSL/TLS certificates are self-signed and have no CA trust chain.
+They contain some info to see that they're for Pyro5 (O=Razorvine.net, OU=Pyro5, CN=localhost)
+They're meant to be used for testing purposes. There is no key password.
+
+It's easy to make your own certs by the way, it's mentioned in the docs of the ssl module:
+https://docs.python.org/3/library/ssl.html#self-signed-certificates
+
+For instance:
+
+$ openssl req -new -x509 -days 365 -nodes -out cert.pem -keyout key.pem
+
+
+It's also possible to make your own CA certs and sign your client and server certs
+with them, but that is a lot more elaborate.

certs/server_cert.pem

@@ -0,0 +1,23 @@
+-----BEGIN CERTIFICATE-----
+MIID3DCCAsSgAwIBAgIJAIw60qiKBlfvMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD
+VQQGEwJOTDETMBEGA1UECAwKU29tZS1TdGF0ZTEWMBQGA1UECgwNUmF6b3J2aW5l
+Lm5ldDEOMAwGA1UECwwFUHlybzUxEjAQBgNVBAMMCWxvY2FsaG9zdDEiMCAGCSqG
+SIb3DQEJARYTaXJtZW5AcmF6b3J2aW5lLm5ldDAeFw0xODA2MTMyMjQ3MTBaFw0y
+MDExMjkyMjQ3MTBaMIGCMQswCQYDVQQGEwJOTDETMBEGA1UECAwKU29tZS1TdGF0
+ZTEWMBQGA1UECgwNUmF6b3J2aW5lLm5ldDEOMAwGA1UECwwFUHlybzUxEjAQBgNV
+BAMMCWxvY2FsaG9zdDEiMCAGCSqGSIb3DQEJARYTaXJtZW5AcmF6b3J2aW5lLm5l
+dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJTxdAgMnOFaDKYt+EW
+FqNRqlH26WttK8eWqlBoeX0fRVdAxxyl4IUsCq46FSQqEipWYW9pfQyuNTXyK49y
+ELhuxPC4gHz6+bPkspqchwGLkon9MiLFRklXGPNAVpI7evbR3zY3+jw6eT0+6xck
+I8yedT6eJ61bIKQ/4jsZl3SIqwRA93XHf1ouXR6F6rBA0UnG6mxhVyudpN3sd0uQ
+Z4NFKQNJmqVrYeUh+4+xKQe2FYueyuCpbqX/XpE3ZHkx+X9R4upIeJDZNuzxtE0V
+3iguClgrMwGriRECjNUDqnHdP79SgI+iW44cmZJQEehkyjtjMBkUL/c/GXreov6f
+e0ECAwEAAaNTMFEwHQYDVR0OBBYEFBvuzbXIjlbpqekKSKSAlTEoM16eMB8GA1Ud
+IwQYMBaAFBvuzbXIjlbpqekKSKSAlTEoM16eMA8GA1UdEwEB/wQFMAMBAf8wDQYJ
+KoZIhvcNAQELBQADggEBABGU3AsGeFGqBoc24oNmTx2ksacgW6YUIMupXSnL/CNv
+klBLbB/WDYWJxwqgfAY3EB0DtneLxBQTPiE2VmuC9aPOHjyYGKyCMrD/sHKwUmFr
+KO1SBdhSTxcHMw3D8byN90ZPNOCefHhUXLj+lVq019w36xU1CRDjBEJ2nSO/zpB5
+nGD2tsJ1WFsQ2XXzP6bR8/CqyB1mVZK3FA+qI+tH9sX16GdPlGIY/2HXmVGt7QFu
+Cd/LQp9tBcZ0DpthoZCTZwdMILEDUxFSw1WjBUGQKcm+GH4ofaFdI7d73I/nei6a
+RdgMl8btfLRYXvUcwtH/NGw0LC+YKBm2DmmCasP41Ko=
+-----END CERTIFICATE-----

certs/server_key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDCU8XQIDJzhWgy
+mLfhFhajUapR9ulrbSvHlqpQaHl9H0VXQMccpeCFLAquOhUkKhIqVmFvaX0MrjU1
+8iuPchC4bsTwuIB8+vmz5LKanIcBi5KJ/TIixUZJVxjzQFaSO3r20d82N/o8Onk9
+PusXJCPMnnU+nietWyCkP+I7GZd0iKsEQPd1x39aLl0eheqwQNFJxupsYVcrnaTd
+7HdLkGeDRSkDSZqla2HlIfuPsSkHthWLnsrgqW6l/16RN2R5Mfl/UeLqSHiQ2Tbs
+8bRNFd4oLgpYKzMBq4kRAozVA6px3T+/UoCPoluOHJmSUBHoZMo7YzAZFC/3Pxl6
+3qL+n3tBAgMBAAECggEBAIm/yGEX8athzdLP3sh3V+S9ZvZjCGNWJ8p7So9k/3lq
+SUTobjwoeVbtOUT3dzUDfYz1XmwTYskyVBXBbI9qU9/o5UGeB7aQUaDrZI+klS7L
+OT0HdhqfrIsgaldELBnMgAWmD4vnckJvULHRf+QPgjDxwjp48bc4+ZJ0lnE+WtYH
+Lrnao/P2Al2hGEcnYSWyGphdqmOnCy7pplETN7cyLiDarZjde5BM/lcAH001LIpW
+yoJftm/gl4MjEW5v82L9tadzOgRJyybhHG5k34bzaBpV63p3jp0FsBX587C4NIP4
+BmnIhfEMpq9RjS9L7vYSKbzMge/Prj0L8g5r90pZAeECgYEA4Odx7fMEZlVgQHU6
+5ZgdJKLJ8lYQ3pcy+3pgPj7HlT/N6REbn8OOO91vEalpHi8I1hOERRzjIWQGH5oR
+tzNdFf9BsuIs7Ur6tCYoYcy2pz25zwh58xOtqAvScE2aGVvBP1iTpKGEXkwv0Nn7
+zWcbwh22BIckCzYK2RQaXY/irV8CgYEA3TIMz9sNkOi/iAzh4Ey26nIKfOg852A8
+33c+wvpNcWSGYR9OLnk/a8AGjT+HQA8w8kU3s79T0S7IVLDeVnQomh1lklfhRGGH
+6QL/u/miAhIY2ykOtBFS7zICyH0egXUWQea6t3aiHNgqFMLyipa0SngamG9/vP9O
+tRSl0j+b+18CgYABUVnZixL7hoSJ3CX8Mmf5Tvrf8KEorLofvxfRRYzl0vnh47fF
+t9+dei6sa9Gx25SxrGuZ/BFYoL1ocf6olCR3fIdmBO0+drIBXDfgWtK3KCVukR4l
+zne2BFu3TL0aaO8478vtqwSbiNa+4ogXLAN9n67xV9leN3LY0sVUxwMNAQKBgQCO
+cnX3wc0JviniVtF73kuJzeldKT5Xjw2Ep8l+TS1kUeWMVFnH6gNiw6Y0fm3+Xgoa
+a2ME2bkDpIoUqFZ2/JVNMpM/3GJQ5DJfZ7QDfS7NAJSLRvSWF/X93ooWTSVBH4M2
+63zhO4AI7VikSCtj/suajaAq/NsZfp1UVji3nok4JwKBgFoeRO1ezkq3J7igkIBr
+d6D8u6z1/3sAgnYJLbSKjgdpewcedRV9uVC1g0tFRPRjTG7X0F7+ZPLaVjDM8UvO
+2zhPOL6S0+fYg2bUPHexuEf2ec0PqIF6rAS+0cR85AohAXqyYGydmyDCQFDNvOvW
+ygLQbLsx9AyZzrqsRoEJ7Yo6
+-----END PRIVATE KEY-----

examples/old_pyro4/hugetransfer/Readme.txt

@@ -22,10 +22,10 @@ Performance numbers with the various serializers on my local network:
 
 serializer | performance (string) | performance (bytes)
 -----------+---------------------------------------------
-   pickle  |     ? kb/sec     |   ? kb/sec
   marshal  |     ? kb/sec     |   ? kb/sec
      json  |     ? kb/sec     |   not supported
   serpent  |     ? kb/sec     |    ? kb/sec
+  msgpack  |     ? kb/sec     |    ? kb/sec
 
 
 Performance of the download via iterator is almost identical to

examples/old_pyro4/ssl/Readme.txt

@@ -0,0 +1,17 @@
+SSL example showing how to configure 2-way-SSL with custom certificate validation.
+
+What this means is that the server has a certificate, and the client as well.
+The server only accepts connections from clients that provide the proper certificate
+(and ofcourse, clients only connect to servers having a proper certificate).
+
+By using Pyro's handshake mechanism you can easily add custom certificate verification steps
+in both the client (proxy) and server (daemon). This is more or less required, because
+you should be checking if the certificate is indeed from the party you expected...
+
+This example uses the self-signed demo certs that come with Pyro, so in the code
+you'll also see that we configure the SSL_CACERTS so that SSL will accept the self-signed
+certificate as a valid cert.
+
+
+
+If the connection is successfully established, all communication is then encrypted and secure.

examples/old_pyro4/ssl/client.py

@@ -0,0 +1,60 @@
+from Pyro5.compatibility import Pyro4
+import Pyro4.core
+import Pyro4.errors
+
+
+Pyro4.config.SSL = True
+Pyro4.config.SSL_CACERTS = "../../certs/server_cert.pem"    # to make ssl accept the self-signed server cert
+Pyro4.config.SSL_CLIENTCERT = "../../certs/client_cert.pem"
+Pyro4.config.SSL_CLIENTKEY = "../../certs/client_key.pem"
+print("SSL enabled (2-way).")
+
+
+def verify_cert(cert):
+    if not cert:
+        raise Pyro4.errors.CommunicationError("cert missing")
+    # note: hostname and expiry date validation is already successfully performed by the SSL layer itself
+    # not_before = datetime.datetime.utcfromtimestamp(ssl.cert_time_to_seconds(cert["notBefore"]))
+    # print("not before:", not_before)
+    # not_after = datetime.datetime.utcfromtimestamp(ssl.cert_time_to_seconds(cert["notAfter"]))
+    # print("not after:", not_after)
+    # today = datetime.datetime.now()
+    # if today > not_after or today < not_before:
+    #     raise Pyro4.errors.CommunicationError("cert not yet valid or expired")
+    if cert["serialNumber"] != "8C3AD2A88A0657EF":
+        raise Pyro4.errors.CommunicationError("cert serial number incorrect", cert["serialNumber"])
+    issuer = dict(p[0] for p in cert["issuer"])
+    subject = dict(p[0] for p in cert["subject"])
+    if issuer["organizationName"] != "Razorvine.net":
+        # issuer is not often relevant I guess, but just to show that you have the data
+        raise Pyro4.errors.CommunicationError("cert not issued by Razorvine.net")
+    if subject["countryName"] != "NL":
+        raise Pyro4.errors.CommunicationError("cert not for country NL")
+    if subject["organizationName"] != "Razorvine.net":
+        raise Pyro4.errors.CommunicationError("cert not for Razorvine.net")
+    print("(SSL server cert is ok: serial={ser}, subject={subj})"
+          .format(ser=cert["serialNumber"], subj=subject["organizationName"]))
+
+
+# to make Pyro verify the certificate on new connections, use the handshake mechanism:
+class CertCheckingProxy(Pyro4.Proxy):
+    def _pyroValidateHandshake(self, response):
+        cert = self._pyroConnection.getpeercert()
+        verify_cert(cert)
+
+
+# Note: to automatically enforce certificate verification for all proxy objects you create,
+# you can also monkey-patch the method in the Proxy class itself.
+# Then you don't have to make sure that you're using CertCheckingProxy every time.
+# However some other Proxy subclass can (will) override this again!
+#
+# def certverifier(self, response):
+#     cert = self._pyroConnection.getpeercert()
+#     verify_cert(cert)
+# Pyro4.core.Proxy._pyroValidateHandshake = certverifier
+
+
+uri = input("Server uri: ").strip()
+with CertCheckingProxy(uri) as p:
+    response = p.echo("client speaking")
+    print("response:", response)

examples/old_pyro4/ssl/server.py

@@ -0,0 +1,52 @@
+from Pyro5.compatibility import Pyro4
+import Pyro4.core
+
+
+class Safe(object):
+    @Pyro4.expose
+    def echo(self, message):
+        print("got message:", message)
+        return "hi!"
+
+
+Pyro4.config.SSL = True
+Pyro4.config.SSL_REQUIRECLIENTCERT = True   # enable 2-way ssl
+Pyro4.config.SSL_SERVERCERT = "../../certs/server_cert.pem"
+Pyro4.config.SSL_SERVERKEY = "../../certs/server_key.pem"
+Pyro4.config.SSL_CACERTS = "../../certs/client_cert.pem"    # to make ssl accept the self-signed client cert
+print("SSL enabled (2-way).")
+
+
+class CertValidatingDaemon(Pyro4.Daemon):
+    def validateHandshake(self, conn, data):
+        cert = conn.getpeercert()
+        if not cert:
+            raise Pyro4.errors.CommunicationError("client cert missing")
+        # note: hostname and expiry date validation is already successfully performed by the SSL layer itself
+        # not_before = datetime.datetime.utcfromtimestamp(ssl.cert_time_to_seconds(cert["notBefore"]))
+        # print("not before:", not_before)
+        # not_after = datetime.datetime.utcfromtimestamp(ssl.cert_time_to_seconds(cert["notAfter"]))
+        # print("not after:", not_after)
+        # today = datetime.datetime.now()
+        # if today > not_after or today < not_before:
+        #     raise Pyro4.errors.CommunicationError("cert not yet valid or expired")
+        if cert["serialNumber"] != "DC3EFDB52BE9D350":
+            raise Pyro4.errors.CommunicationError("cert serial number incorrect", cert["serialNumber"])
+        issuer = dict(p[0] for p in cert["issuer"])
+        subject = dict(p[0] for p in cert["subject"])
+        if issuer["organizationName"] != "Razorvine.net":
+            # issuer is not often relevant I guess, but just to show that you have the data
+            raise Pyro4.errors.CommunicationError("cert not issued by Razorvine.net")
+        if subject["countryName"] != "NL":
+            raise Pyro4.errors.CommunicationError("cert not for country NL")
+        if subject["organizationName"] != "Razorvine.net":
+            raise Pyro4.errors.CommunicationError("cert not for Razorvine.net")
+        print("(SSL client cert is ok: serial={ser}, subject={subj})"
+              .format(ser=cert["serialNumber"], subj=subject["organizationName"]))
+        return super(CertValidatingDaemon, self).validateHandshake(conn, data)
+
+
+d = CertValidatingDaemon()
+uri = d.register(Safe)
+print("server uri:", uri)
+d.requestLoop()

examples/old_pyro4/thirdpartylib/Readme.txt

@@ -0,0 +1,10 @@
+This example shows two ways of dealing with a third party library whose
+source code you cannot or don't want to change, and still use its classes directly in Pyro.
+
+The first server uses the @expose decorator but applies it as a regular function to create a wrapped,
+eposed class from the library class. That wrapped class is then registered instead.
+There are a couple of caveats when using this approach, see the relevant paragraph
+in the server chapter in the documentation for details.
+
+The second server2 shows the approach that I personally prefer: creating explicit adapter classes
+that call out to the library. You then have full control over what is happening.

examples/old_pyro4/thirdpartylib/awesome_thirdparty_library.py

@@ -0,0 +1,22 @@
+# This is an AWESOME LIBRARY.
+# You can use its AWESOME CLASSES to do Great Things.
+# The author however DOESN'T allow you to CHANGE the source code and taint it with Pyro decorators!
+
+
+class WeirdReturnType(object):
+    def __init__(self, value):
+        self.value = value
+
+
+class AwesomeClass(object):
+    def method(self, arg):
+        print("Awesome object is called with: ", arg)
+        return "awesome"
+
+    def private(self):
+        print("This should be a private method...")
+        return "boo"
+
+    def weird(self):
+        print("Weird!")
+        return WeirdReturnType("awesome")

examples/old_pyro4/thirdpartylib/client.py

@@ -0,0 +1,18 @@
+from Pyro5.compatibility import Pyro4
+import Pyro4
+import Pyro4.errors
+
+
+uri = input("Enter the URI of the thirdparty library object: ").strip()
+with Pyro4.Proxy(uri) as remote:
+    print(remote.method("how are you?"))
+
+    try:
+        print(remote.weird())
+    except Pyro4.errors.SerializeError:
+        print("couldn't call weird() due to serialization error of the result value! (is ok)")
+
+    try:
+        print(remote.private())    # we can call this if full class is exposed...
+    except AttributeError:
+        print("couldn't call private(), it doesn't seem to be exposed! (is ok)")

examples/old_pyro4/thirdpartylib/server.py

@@ -0,0 +1,14 @@
+from awesome_thirdparty_library import AwesomeClass
+from Pyro5.compatibility import Pyro4
+import Pyro4
+
+
+# expose the class from the library using @expose as wrapper function:
+ExposedClass = Pyro4.expose(AwesomeClass)
+
+
+with Pyro4.Daemon() as daemon:
+    # register the wrapped class instead of the library class itself:
+    uri = daemon.register(ExposedClass, "example.thirdpartylib")
+    print("wrapped class registered, uri: ", uri)
+    daemon.requestLoop()

examples/old_pyro4/thirdpartylib/server2.py

@@ -0,0 +1,27 @@
+from awesome_thirdparty_library import AwesomeClass
+from Pyro5.compatibility import Pyro4
+import Pyro4
+
+
+# create adapter class that only exposes what should be accessible,
+# and calls into the library class from there:
+
+class AwesomeAdapterClass(AwesomeClass):
+    @Pyro4.expose
+    def method(self, arg):
+        print("Adapter class is called...")
+        return super(AwesomeAdapterClass, self).method(arg)
+
+    @Pyro4.expose
+    def weird(self):
+        result = super(AwesomeAdapterClass, self).weird()
+        # we have full control over what is returned and can turn the custom
+        # result class into a normal string value that has no issues traveling over the wire
+        return "weird " + result.value
+
+
+with Pyro4.Daemon() as daemon:
+    # register the adapter class instead of the library class itself:
+    uri = daemon.register(AwesomeAdapterClass, "example.thirdpartylib")
+    print("adapter class registered, uri: ", uri)
+    daemon.requestLoop()

examples/old_pyro4/timezones/Readme.txt

@@ -0,0 +1,10 @@
+This example exercises the support for pytz/dateutil timezones in the serializers.
+You'll see that this is quite problematic as the tz info is not really a standard
+extension, or some serializers may fail to serialize a datetime object at all.
+
+The only solution is to convert back to a datetime without tz info (so perhaps
+normalize them all to UTC) before transferring, or avoiding datetime objects entirely...
+
+
+PREREQUISITES:
+install the 'pytz' and 'python-dateutil' libraries