class PubSubPublisher(Publisher):
def __init__(self):
self._client = PublisherClient()
_, self._project_id = google.auth.default()
def _publish(self, topic_id, message):
logger.info("publishing message", topic_id=topic_id)
topic_path = self._client.topic_path(self._project_id, topic_id)
response: Future = self._client.publish(topic_path, message)
return response
def publish(self, topic_id, message: bytes,
fulfilment_request_transaction_id: str):
response = self._publish(topic_id, message)
try:
# Resolve the future
message_id = response.result()
logger.info( # pragma: no cover
"message published successfully",
topic_id=topic_id,
message_id=message_id,
fulfilment_request_transaction_id=
fulfilment_request_transaction_id,
)
except Exception as ex: # pylint:disable=broad-except
logger.exception(
"message publication failed",
topic_id=topic_id,
)
raise PublicationFailed(ex)
def publish_error_report(error: str):
publisher = PublisherClient()
function_name = os.environ['FUNCTION_TARGET']
error_report_topic = os.environ['ERROR_REPORT_TOPIC']
topic_name = f'projects/{project_id}/topics/{error_report_topic}'
try:
publisher.publish(
topic_name,
data=error.encode('utf-8'),
projectId=project_id,
functionName=function_name,
eventTime=str(int(time.time()))
)
except Exception as e:
# エラー時はリトライしない
print(e)
def publish_avro_records(project_id, topic_id, avsc_file):
"""Pulbish a BINARY or JSON encoded message to a topic configured with an Avro schema."""
# [START pubsub_publish_avro_records]
from avro.io import BinaryEncoder, DatumWriter
import avro
import io
import json
from google.api_core.exceptions import NotFound
from google.cloud.pubsub import PublisherClient
from google.pubsub_v1.types import Encoding
# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# avsc_file = "path/to/an/avro/schema/file/(.avsc)/formatted/in/json"
publisher_client = PublisherClient()
topic_path = publisher_client.topic_path(project_id, topic_id)
# Prepare to write Avro records to the binary output stream.
avro_schema = avro.schema.parse(open(avsc_file, "rb").read())
writer = DatumWriter(avro_schema)
bout = io.BytesIO()
# Prepare some data using a Python dictionary that matches the Avro schema
record = {"name": "Alaska", "post_abbr": "AK"}
try:
# Get the topic encoding type.
topic = publisher_client.get_topic(request={"topic": topic_path})
encoding = topic.schema_settings.encoding
# Encode the data according to the message serialization type.
if encoding == Encoding.BINARY:
encoder = BinaryEncoder(bout)
writer.write(record, encoder)
data = bout.getvalue()
print(f"Preparing a binary-encoded message:\n{data}")
elif encoding == Encoding.JSON:
data = json.dumps(record).encode("utf-8")
print(f"Preparing a JSON-encoded message:\n{data}")
else:
print(f"No encoding specified in {topic_path}. Abort.")
exit(0)
future = publisher_client.publish(topic_path, data)
print(f"Published message ID: {future.result()}")
except NotFound:
print(f"{topic_id} not found.")
def publish_proto_messages(project_id, topic_id):
"""Publish a BINARY or JSON encoded message to a topic configured with a protobuf schema."""
# [START pubsub_publish_proto_messages]
from google.api_core.exceptions import NotFound
from google.cloud.pubsub import PublisherClient
from google.protobuf.json_format import MessageToJson
from google.pubsub_v1.types import Encoding
from utilities import us_states_pb2
# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# topic_id = "your-topic-id"
publisher_client = PublisherClient()
topic_path = publisher_client.topic_path(project_id, topic_id)
try:
# Get the topic encoding type.
topic = publisher_client.get_topic(request={"topic": topic_path})
encoding = topic.schema_settings.encoding
# Instantiate a protoc-generated class defined in `us-states.proto`.
state = us_states_pb2.StateProto()
state.name = "Alaska"
state.post_abbr = "AK"
# Encode the data according to the message serialization type.
if encoding == Encoding.BINARY:
data = state.SerializeToString()
print(f"Preparing a binary-encoded message:\n{data}")
elif encoding == Encoding.JSON:
json_object = MessageToJson(state)
data = str(json_object).encode("utf-8")
print(f"Preparing a JSON-encoded message:\n{data}")
else:
print(f"No encoding specified in {topic_path}. Abort.")
exit(0)
future = publisher_client.publish(topic_path, data)
print(f"Published message ID: {future.result()}")
except NotFound:
print(f"{topic_id} not found.")
def publish(self, data):
from google.cloud.pubsub import PublisherClient
client = PublisherClient()
sub_path = client.topic_path(self.project, self._tf_name)
client.publish(sub_path, data).result()