def stdServer(server: Server, contractSerializer: Serializer) -> None:
sout = sys.stdout.buffer
sin = sys.stdin.buffer
def writeBytes(value: bytes) -> None:
sent = 0
while sent < len(value):
written = sout.write(value[sent:])
if written == 0:
raise RuntimeError("pipe connection broken")
sent += written
def readBytes(length: int) -> bytes:
buffer = b''
while len(buffer) < length:
chunk = sin.read(length - len(buffer))
if len(chunk) == 0:
raise RuntimeError("pipe connection broken")
buffer += chunk
return buffer
messageSerializer = MessageSerializer(contractSerializer)
writer = Writer(writeBytes)
reader = Reader(readBytes)
while True:
messageSerializer.write(
server.invoke(cast(Request, messageSerializer.read(reader))),
writer)
sout.flush()
def stdServer(server: Server, contractSerializer: Serializer) -> None:
sout = sys.stdout.buffer
sin = sys.stdin.buffer
def writeBytes(value: bytes) -> None:
sent = 0
while sent < len(value):
written = sout.write(value[sent:])
if written == 0:
raise RuntimeError("pipe connection broken")
sent += written
def readBytes(length: int) -> bytes:
buffer = b''
while len(buffer) < length:
chunk = sin.read(length - len(buffer))
if len(chunk) == 0:
raise RuntimeError("pipe connection broken")
buffer += chunk
return buffer
messageSerializer = MessageSerializer(contractSerializer)
writer = Writer(writeBytes)
reader = Reader(readBytes)
while True:
messageSerializer.write(server.invoke(cast(Request, messageSerializer.read(reader))), writer)
sout.flush()
def testDuplicatedService(self):
try:
Server([echo_service, echo_service])
self.fail()
except RuntimeError as e:
self.assertEqual(str(e), "serviceId 2 already added")
import unittest
from io import BytesIO
from typing import Any, cast
from test.serialize_test import createWriter, createReader
from tutorial.base_types_external import Integer
from tutorial.generated import ACCEPTOR
from tutorial.generated.contract import SystemException
from tutorial.socket_client import serializer
from tutorial.socket_server import EchoServiceImpl, InstrumentServiceImpl
from yass import Server, Client, Request, Reply, MessageSerializer
echo_service = ACCEPTOR.echoService.service(EchoServiceImpl())
instrument_service = ACCEPTOR.instrumentService.service(
InstrumentServiceImpl())
server = Server([echo_service, instrument_service])
class Test(unittest.TestCase):
def testInvalidService(self):
try:
server.invoke(Request(123, 321, []))
self.fail()
except RuntimeError as e:
self.assertEqual(str(e), "no serviceId 123 found")
def testInvalidMethod(self):
try:
echo_service.invoke(Request(123, 321, []))
self.fail()
except RuntimeError as e:
def socketServer(transport: ServerTransport, address: Any, backlog: int,
sslContext: SSLContext) -> None:
serverSocket = socket.socket()
serverSocket.bind(address)
serverSocket.listen(backlog)
while True:
try:
s = cast(
SSLSocket,
sslContext.wrap_socket(serverSocket.accept()[0],
server_side=True))
try:
print(s.getpeercert())
transport.invoke(SocketStream(s))
finally:
s.close()
except Exception as e:
print("exception:", e)
if __name__ == "__main__":
print("started")
socketServer(
defaultServerTransport(
serializer,
Server([
ACCEPTOR.echoService.service(EchoServiceImpl()),
ACCEPTOR.instrumentService.service(InstrumentServiceImpl(),
serverPrinter)
])), address, 5, sslContext("ClientCA.cert.pem", "Server.key.pem"))
def writeBytes(value): # type: (bytes) -> None
sout.write(value)
def readBytes(length): # type: (int) -> bytes
buffer = b''
while len(buffer) < length:
chunk = sin.read(length - len(buffer))
if len(chunk) == 0:
raise RuntimeError("pipe connection broken")
buffer += chunk
return buffer
messageSerializer = MessageSerializer(contractSerializer)
writer = Writer(writeBytes)
reader = Reader(readBytes)
while True:
messageSerializer.write(
server.invoke(cast(Request, messageSerializer.read(reader))),
writer)
sout.flush()
print('server started', file=sys.stderr)
stdServer(
Server([
ACCEPTOR.echoService.service(EchoServiceImpl()),
ACCEPTOR.instrumentService.service(InstrumentServiceImpl())
]), serializer)
def socketServer(transport, address, backlog, sslContext): # type: (ServerTransport, Any, int, SSLContext) -> None
serverSocket = socket.socket()
serverSocket.bind(address)
serverSocket.listen(backlog)
while True:
try:
s = cast(SSLSocket, sslContext.wrap_socket(serverSocket.accept()[0], server_side=True))
try:
print(s.getpeercert())
transport.invoke(SocketStream(s))
finally:
s.close()
except Exception as e:
print("exception: " + str(e))
if __name__ == "__main__":
print("started")
socketServer(
defaultServerTransport(
serializer,
Server([
ACCEPTOR.echoService.service(EchoServiceImpl()),
ACCEPTOR.instrumentService.service(InstrumentServiceImpl(), serverPrinter)
])
),
address,
5,
sslContext("ClientCA.cert.pem", "Server.key.pem")
)