def main():
platform = Platform()
# you can register a method of a class
platform.register('hello.world.1', Hi().hello, 5)
# or register a function
platform.register('hello.world.2', hello, 10)
po = PostOffice()
# demonstrate sending asynchronously. Note that key-values in the headers will be encoded as strings
po.send('hello.world.1', headers={'one': 1}, body='hello world one')
po.send('hello.world.2', headers={'two': 2}, body='hello world two')
# demonstrate a RPC request
try:
result = po.request('hello.world.2', 2.0, headers={'some_key': 'some_value'}, body='hello world')
if isinstance(result, EventEnvelope):
print('Received RPC response:')
print("HEADERS =", result.get_headers(), ", BODY =", result.get_body(),
", STATUS =", result.get_status(),
", EXEC =", result.get_exec_time(), ", ROUND TRIP =", result.get_round_trip(), "ms")
except TimeoutError as e:
print("Exception: ", str(e))
# illustrate parallel RPC requests
event_list = list()
event_list.append(EventEnvelope().set_to('hello.world.1').set_body("first request"))
event_list.append(EventEnvelope().set_to('hello.world.2').set_body("second request"))
try:
result = po.parallel_request(event_list, 2.0)
if isinstance(result, list):
print('Received', len(result), 'RPC responses:')
for res in result:
print("HEADERS =", res.get_headers(), ", BODY =", res.get_body(),
", STATUS =", res.get_status(),
", EXEC =", res.get_exec_time(), ", ROUND TRIP =", res.get_round_trip(), "ms")
except TimeoutError as e:
print("Exception: ", str(e))
# connect to the network
platform.connect_to_cloud()
# wait until connected
while not platform.cloud_ready():
try:
time.sleep(0.1)
except KeyboardInterrupt:
# this allows us to stop the application while waiting for cloud connection
platform.stop()
return
# Demonstrate broadcast feature
# the event will be broadcast to multiple application instances that serve the same route
po.broadcast("hello.world.1", body="this is a broadcast message from "+platform.get_origin())
# demonstrate deferred delivery
po.send_later('hello.world.1', headers={'hello': 'world'}, body='this message arrives 5 seconds later', seconds=5.0)
#
# this will keep the main thread running in the background
# so we can use Control-C or KILL signal to stop the application
platform.run_forever()
def main():
platform = Platform()
platform.connect_to_cloud()
# wait until connected
while not platform.cloud_ready():
try:
time.sleep(0.1)
except KeyboardInterrupt:
# this allows us to stop the application while waiting for cloud connection
platform.stop()
return
util = Utility()
pubsub = PubSub()
if pubsub.feature_enabled():
# Publish an event
# headers = optional parameters for the event
# body = event payload
for x in range(10):
print("publishing event#", x)
pubsub.publish("hello.topic",
headers={
"some_parameter": "some_value",
"n": x
},
body="hello world " +
util.get_iso_8601(time.time()))
# quit application
platform.stop()
else:
print("Pub/Sub feature not available from the underlying event stream")
print("Did you start the language connector with Kafka?")
print(
"e.g. java -Dcloud.connector=kafka -Dcloud.services=kafka.reporter -jar language-connector-1.12.31.jar"
)
def main():
platform = Platform()
log = platform.get_logger()
# connect to the network
platform.connect_to_cloud()
# wait until connected
while not platform.cloud_ready():
try:
time.sleep(0.1)
except KeyboardInterrupt:
# this allows us to stop the application while waiting for cloud connection
platform.stop()
return
#
# You can create a new I/O stream using ObjectStreamIO.
# This requires a live connection to the language connector.
#
stream = ObjectStreamIO(10)
in_stream_id = stream.get_input_stream()
out_stream_id = stream.get_output_stream()
output_stream = ObjectStreamWriter(out_stream_id)
input_stream = ObjectStreamReader(in_stream_id)
for i in range(100):
output_stream.write('hello world ' + str(i))
#
# if output stream is not closed, input will timeout
# Therefore, please use try-except for TimeoutError in the iterator for-loop below.
#
output_stream.close()
for block in input_stream.read(5.0):
if block is None:
log.info("EOF")
else:
log.info(block)
input_stream.close()
#
# this will keep the main thread running in the background
# so we can use Control-C or KILL signal to stop the application
platform.run_forever()
def main():
platform = Platform()
# register a route name for a pub/sub subscriber function
# setting number of instance to 1 because pub/sub subscriber is always a singleton
platform.register('hello.world', hello, 1)
# Once it connects to the network, it is ready to serve requests
platform.connect_to_cloud()
# wait until connected
while not platform.cloud_ready():
try:
time.sleep(0.1)
except KeyboardInterrupt:
# this allows us to stop the application while waiting for cloud connection
platform.stop()
return
pubsub = PubSub()
if pubsub.feature_enabled():
#
# the pub/sub topic name must be different from the subscriber function name
#
# Note:
# For kafka, the parameter list includes the following:
# client_id, group_id and optional offset number (as a string)
# e.g. ["client1", "group1"] or ["client1", "group1", "0"]
#
# In this example, it is reading from the beginning of the topic.
# For a real application, it should read without the offset so that it can fetch the latest events.
#
pubsub.subscribe("hello.topic", "hello.world",
["client1", "group1", "0"])
else:
print("Pub/Sub feature not available from the underlying event stream")
print("Did you start the language connector with Kafka?")
print(
"e.g. java -Dcloud.connector=kafka -Dcloud.services=kafka.reporter -jar language-connector-1.12.31.jar"
)
#
# this will keep the main thread running in the background
# so we can use Control-C or KILL signal to stop the application
platform.run_forever()
def main():
platform = Platform()
# this shows that we can register a route name for a function
platform.register('hello.world', hello, 10)
# Once it connects to the network, it is ready to serve requests
platform.connect_to_cloud()
# wait until connected
while not platform.cloud_ready():
try:
time.sleep(0.1)
except KeyboardInterrupt:
# this allows us to stop the application while waiting for cloud connection
platform.stop()
return
#
# this will keep the main thread running in the background
# so we can use Control-C or KILL signal to stop the application
platform.run_forever()
def main():
platform = Platform()
# we should register the custom trace processor as a singleton
platform.register('distributed.trace.processor', my_trace_processor, 1)
# Once it connects to the network, it is ready to serve requests
platform.connect_to_cloud()
# wait until connected
while not platform.cloud_ready():
try:
time.sleep(0.1)
except KeyboardInterrupt:
# this allows us to stop the application while waiting for cloud connection
platform.stop()
return
#
# this will keep the main thread running in the background
# so we can use Control-C or KILL signal to stop the application
platform.run_forever()