def list_topic_subscriptions(
self, topic_path: TopicPath) -> List[SubscriptionPath]:
subscription_strings = [
x for x in self._underlying.list_topic_subscriptions(
name=str(topic_path))
]
return [SubscriptionPath.parse(x) for x in subscription_strings]
def subscribe(
self,
subscription: Union[SubscriptionPath, str],
callback: Callable, # TODO(dpcollins): Change to MessageCallback,
per_partition_flow_control_settings: FlowControlSettings,
fixed_partitions: Optional[Set[Partition]] = None,
) -> StreamingPullFuture:
if isinstance(subscription, str):
subscription = SubscriptionPath.parse(subscription)
callback = cast(MessageCallback, callback)
def create_and_open():
underlying = self._underlying_factory(
subscription, fixed_partitions,
per_partition_flow_control_settings)
subscriber = SubscriberImpl(underlying, callback, self._executor)
future = StreamingPullFuture(subscriber)
subscriber.__enter__()
return future
future = self._multiplexer.create_or_fail(subscription,
create_and_open)
future.add_done_callback(
lambda fut: self._multiplexer.try_erase(subscription, future))
return future
def test_list_lite_subscriptions_in_project(subscription_path, capsys):
import list_lite_subscriptions_in_project_example
subscription_path_object = SubscriptionPath.parse(subscription_path)
list_lite_subscriptions_in_project_example.list_lite_subscriptions_in_project(
subscription_path_object.project,
subscription_path_object.location.region.name,
subscription_path_object.location.zone_id,
)
out, _ = capsys.readouterr()
assert "subscription(s) listed in your project and location." in out
def create_subscription(
self,
subscription: Subscription,
starting_offset: BacklogLocation = BacklogLocation.END,
) -> Subscription:
path = SubscriptionPath.parse(subscription.name)
return self._underlying.create_subscription(
request={
"parent": str(path.to_location_path()),
"subscription": subscription,
"subscription_id": path.name,
"skip_backlog": (starting_offset == BacklogLocation.END),
})
def test_get_lite_subscription(subscription_path, capsys):
import get_lite_subscription_example
subscription_path_object = SubscriptionPath.parse(subscription_path)
get_lite_subscription_example.get_lite_subscription(
subscription_path_object.project,
subscription_path_object.location.region.name,
subscription_path_object.location.zone_id,
subscription_path_object.name,
)
out, _ = capsys.readouterr()
assert f"{subscription_path} exists." in out
def test_update_lite_subscription_example(subscription_path, capsys):
import update_lite_subscription_example
subscription_path_object = SubscriptionPath.parse(subscription_path)
update_lite_subscription_example.update_lite_subscription(
subscription_path_object.project,
subscription_path_object.location.region.name,
subscription_path_object.location.zone_id,
subscription_path_object.name,
)
out, _ = capsys.readouterr()
assert f"{subscription_path} updated successfully." in out
def create_subscription(
self,
subscription: Subscription,
starting_offset: BacklogLocation = BacklogLocation.END,
) -> Subscription:
path = SubscriptionPath.parse(subscription.name)
return self._underlying.create_subscription(
request=CreateSubscriptionRequest(
parent=str(path.to_location_path()),
subscription=subscription,
subscription_id=path.name,
skip_backlog=(starting_offset == BacklogLocation.END),
)
)
def test_list_lite_subscriptions_in_topic(topic_path, subscription_path, capsys):
import list_lite_subscriptions_in_topic_example
subscription_path_object = SubscriptionPath.parse(subscription_path)
topic_path_object = TopicPath.parse(topic_path)
list_lite_subscriptions_in_topic_example.list_lite_subscriptions_in_topic(
subscription_path_object.project,
subscription_path_object.location.region.name,
subscription_path_object.location.zone_id,
topic_path_object.name,
)
out, _ = capsys.readouterr()
assert "subscription(s) listed in your topic." in out
def test_create_lite_subscription(subscription_path, topic_path, capsys):
import create_lite_subscription_example
subscription_path_object = SubscriptionPath.parse(subscription_path)
topic_path_object = TopicPath.parse(topic_path)
create_lite_subscription_example.create_lite_subscription(
subscription_path_object.project,
subscription_path_object.location.region.name,
subscription_path_object.location.zone_id,
topic_path_object.name,
subscription_path_object.name,
)
out, _ = capsys.readouterr()
assert f"{subscription_path} created successfully." in out
async def subscribe(
self,
subscription: Union[SubscriptionPath, str],
per_partition_flow_control_settings: FlowControlSettings,
fixed_partitions: Optional[Set[Partition]] = None,
) -> AsyncIterator[Message]:
if isinstance(subscription, str):
subscription = SubscriptionPath.parse(subscription)
subscriber = self._underlying_factory(
subscription, fixed_partitions,
per_partition_flow_control_settings)
await subscriber.__aenter__()
self._live_clients.add(subscriber)
return _SubscriberAsyncIterator(
subscriber, lambda: self._try_remove_client(subscriber))
def test_delete_lite_subscription_example(subscription_path, capsys):
import delete_lite_subscription_example
subscription_path_object = SubscriptionPath.parse(subscription_path)
@backoff.on_exception(backoff.expo, AssertionError, max_time=MAX_TIME)
def eventually_consistent_test():
delete_lite_subscription_example.delete_lite_subscription(
subscription_path_object.project,
subscription_path_object.location.region.name,
subscription_path_object.location.zone_id,
subscription_path_object.name,
)
out, _ = capsys.readouterr()
assert f"{subscription_path} deleted successfully." in out
eventually_consistent_test()
def subscribe(
self,
subscription: Union[SubscriptionPath, str],
callback: MessageCallback,
per_partition_flow_control_settings: FlowControlSettings,
fixed_partitions: Optional[Set[Partition]] = None,
) -> StreamingPullFuture:
if isinstance(subscription, str):
subscription = SubscriptionPath.parse(subscription)
underlying = self._underlying_factory(
subscription, fixed_partitions,
per_partition_flow_control_settings)
subscriber = SubscriberImpl(underlying, callback, self._executor)
future = StreamingPullFuture(subscriber)
subscriber.__enter__()
future.add_done_callback(lambda fut: self._try_remove_client(future))
return future
async def subscribe(
self,
subscription: Union[SubscriptionPath, str],
per_partition_flow_control_settings: FlowControlSettings,
fixed_partitions: Optional[Set[Partition]] = None,
) -> AsyncIterator[Message]:
if isinstance(subscription, str):
subscription = SubscriptionPath.parse(subscription)
async def create_and_open():
client = self._underlying_factory(
subscription, fixed_partitions,
per_partition_flow_control_settings)
await client.__aenter__()
return client
subscriber = await self._multiplexer.get_or_create(
subscription, create_and_open)
return _SubscriberAsyncIterator(
subscriber,
lambda: self._multiplexer.try_erase(subscription, subscriber))