243 lines
7.6 KiB
Python
243 lines
7.6 KiB
Python
# Copyright (c) ZeroC, Inc.
|
|
|
|
# slice2py version 3.8.1
|
|
|
|
from __future__ import annotations
|
|
import IcePy
|
|
|
|
from Ice.Object import Object
|
|
|
|
from Ice.ObjectPrx import ObjectPrx
|
|
from Ice.ObjectPrx import checkedCast
|
|
from Ice.ObjectPrx import checkedCastAsync
|
|
from Ice.ObjectPrx import uncheckedCast
|
|
|
|
from Ice.OperationMode import OperationMode
|
|
|
|
from MumbleServer.MetaCallback_forward import _MumbleServer_MetaCallbackPrx_t
|
|
|
|
from MumbleServer.Server_forward import _MumbleServer_ServerPrx_t
|
|
|
|
from abc import ABC
|
|
from abc import abstractmethod
|
|
|
|
from typing import TYPE_CHECKING
|
|
from typing import overload
|
|
|
|
if TYPE_CHECKING:
|
|
from Ice.Current import Current
|
|
from MumbleServer.Server import ServerPrx
|
|
from collections.abc import Awaitable
|
|
from collections.abc import Sequence
|
|
|
|
|
|
class MetaCallbackPrx(ObjectPrx):
|
|
"""
|
|
Callback interface for Meta. You can supply an implementation of this to receive notifications
|
|
when servers are stopped or started.
|
|
If an added callback ever throws an exception or goes away, it will be automatically removed.
|
|
Please note that all callbacks are done asynchronously; the server does not wait for the callback to
|
|
complete before continuing processing.
|
|
|
|
Notes
|
|
-----
|
|
The Slice compiler generated this proxy class from Slice interface ``::MumbleServer::MetaCallback``.
|
|
|
|
See Also
|
|
--------
|
|
:class:`MumbleServer.ServerCallbackPrx`
|
|
``Meta.addCallback``
|
|
"""
|
|
|
|
def started(self, srv: ServerPrx | None, context: dict[str, str] | None = None) -> None:
|
|
"""
|
|
Called when a server is started. The server is up and running when this event is sent, so all methods that
|
|
need a running server will work.
|
|
|
|
Parameters
|
|
----------
|
|
srv : ServerPrx | None
|
|
Interface for started server.
|
|
context : dict[str, str]
|
|
The request context for the invocation.
|
|
"""
|
|
return MetaCallback._op_started.invoke(self, ((srv, ), context))
|
|
|
|
def startedAsync(self, srv: ServerPrx | None, context: dict[str, str] | None = None) -> Awaitable[None]:
|
|
"""
|
|
Called when a server is started. The server is up and running when this event is sent, so all methods that
|
|
need a running server will work.
|
|
|
|
Parameters
|
|
----------
|
|
srv : ServerPrx | None
|
|
Interface for started server.
|
|
context : dict[str, str]
|
|
The request context for the invocation.
|
|
|
|
Returns
|
|
-------
|
|
Awaitable[None]
|
|
An awaitable that is completed when the invocation completes.
|
|
"""
|
|
return MetaCallback._op_started.invokeAsync(self, ((srv, ), context))
|
|
|
|
def stopped(self, srv: ServerPrx | None, context: dict[str, str] | None = None) -> None:
|
|
"""
|
|
Called when a server is stopped. The server is already stopped when this event is sent, so no methods that
|
|
need a running server will work.
|
|
|
|
Parameters
|
|
----------
|
|
srv : ServerPrx | None
|
|
Interface for started server.
|
|
context : dict[str, str]
|
|
The request context for the invocation.
|
|
"""
|
|
return MetaCallback._op_stopped.invoke(self, ((srv, ), context))
|
|
|
|
def stoppedAsync(self, srv: ServerPrx | None, context: dict[str, str] | None = None) -> Awaitable[None]:
|
|
"""
|
|
Called when a server is stopped. The server is already stopped when this event is sent, so no methods that
|
|
need a running server will work.
|
|
|
|
Parameters
|
|
----------
|
|
srv : ServerPrx | None
|
|
Interface for started server.
|
|
context : dict[str, str]
|
|
The request context for the invocation.
|
|
|
|
Returns
|
|
-------
|
|
Awaitable[None]
|
|
An awaitable that is completed when the invocation completes.
|
|
"""
|
|
return MetaCallback._op_stopped.invokeAsync(self, ((srv, ), context))
|
|
|
|
@staticmethod
|
|
def checkedCast(
|
|
proxy: ObjectPrx | None,
|
|
facet: str | None = None,
|
|
context: dict[str, str] | None = None
|
|
) -> MetaCallbackPrx | None:
|
|
return checkedCast(MetaCallbackPrx, proxy, facet, context)
|
|
|
|
@staticmethod
|
|
def checkedCastAsync(
|
|
proxy: ObjectPrx | None,
|
|
facet: str | None = None,
|
|
context: dict[str, str] | None = None
|
|
) -> Awaitable[MetaCallbackPrx | None ]:
|
|
return checkedCastAsync(MetaCallbackPrx, proxy, facet, context)
|
|
|
|
@overload
|
|
@staticmethod
|
|
def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> MetaCallbackPrx:
|
|
...
|
|
|
|
@overload
|
|
@staticmethod
|
|
def uncheckedCast(proxy: None, facet: str | None = None) -> None:
|
|
...
|
|
|
|
@staticmethod
|
|
def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> MetaCallbackPrx | None:
|
|
return uncheckedCast(MetaCallbackPrx, proxy, facet)
|
|
|
|
@staticmethod
|
|
def ice_staticId() -> str:
|
|
return "::MumbleServer::MetaCallback"
|
|
|
|
IcePy.defineProxy("::MumbleServer::MetaCallback", MetaCallbackPrx)
|
|
|
|
class MetaCallback(Object, ABC):
|
|
"""
|
|
Callback interface for Meta. You can supply an implementation of this to receive notifications
|
|
when servers are stopped or started.
|
|
If an added callback ever throws an exception or goes away, it will be automatically removed.
|
|
Please note that all callbacks are done asynchronously; the server does not wait for the callback to
|
|
complete before continuing processing.
|
|
|
|
Notes
|
|
-----
|
|
The Slice compiler generated this skeleton class from Slice interface ``::MumbleServer::MetaCallback``.
|
|
|
|
See Also
|
|
--------
|
|
:class:`MumbleServer.ServerCallbackPrx`
|
|
``Meta.addCallback``
|
|
"""
|
|
|
|
_ice_ids: Sequence[str] = ("::Ice::Object", "::MumbleServer::MetaCallback", )
|
|
_op_started: IcePy.Operation
|
|
_op_stopped: IcePy.Operation
|
|
|
|
@staticmethod
|
|
def ice_staticId() -> str:
|
|
return "::MumbleServer::MetaCallback"
|
|
|
|
@abstractmethod
|
|
def started(self, srv: ServerPrx | None, current: Current) -> None | Awaitable[None]:
|
|
"""
|
|
Called when a server is started. The server is up and running when this event is sent, so all methods that
|
|
need a running server will work.
|
|
|
|
Parameters
|
|
----------
|
|
srv : ServerPrx | None
|
|
Interface for started server.
|
|
current : Ice.Current
|
|
The Current object for the dispatch.
|
|
|
|
Returns
|
|
-------
|
|
None | Awaitable[None]
|
|
None or an awaitable that completes when the dispatch completes.
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def stopped(self, srv: ServerPrx | None, current: Current) -> None | Awaitable[None]:
|
|
"""
|
|
Called when a server is stopped. The server is already stopped when this event is sent, so no methods that
|
|
need a running server will work.
|
|
|
|
Parameters
|
|
----------
|
|
srv : ServerPrx | None
|
|
Interface for started server.
|
|
current : Ice.Current
|
|
The Current object for the dispatch.
|
|
|
|
Returns
|
|
-------
|
|
None | Awaitable[None]
|
|
None or an awaitable that completes when the dispatch completes.
|
|
"""
|
|
pass
|
|
|
|
MetaCallback._op_started = IcePy.Operation(
|
|
"started",
|
|
"started",
|
|
OperationMode.Normal,
|
|
None,
|
|
(),
|
|
(((), _MumbleServer_ServerPrx_t, False, 0),),
|
|
(),
|
|
None,
|
|
())
|
|
|
|
MetaCallback._op_stopped = IcePy.Operation(
|
|
"stopped",
|
|
"stopped",
|
|
OperationMode.Normal,
|
|
None,
|
|
(),
|
|
(((), _MumbleServer_ServerPrx_t, False, 0),),
|
|
(),
|
|
None,
|
|
())
|
|
|
|
__all__ = ["MetaCallback", "MetaCallbackPrx", "_MumbleServer_MetaCallbackPrx_t"]
|