1# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
   2"""Client and server classes corresponding to protobuf-defined services."""
   3import grpc
   4import warnings
   5
   6from glclient import greenlight_pb2 as glclient_dot_greenlight__pb2
   7from glclient import scheduler_pb2 as glclient_dot_scheduler__pb2
   8
   9GRPC_GENERATED_VERSION = '1.64.1'
  10GRPC_VERSION = grpc.__version__
  11EXPECTED_ERROR_RELEASE = '1.65.0'
  12SCHEDULED_RELEASE_DATE = 'June 25, 2024'
  13_version_not_supported = False
  14
  15try:
  16    from grpc._utilities import first_version_is_lower
  17    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
  18except ImportError:
  19    _version_not_supported = True
  20
  21if _version_not_supported:
  22    warnings.warn(
  23        f'The grpc package installed is at version {GRPC_VERSION},'
  24        + f' but the generated code in glclient/scheduler_pb2_grpc.py depends on'
  25        + f' grpcio>={GRPC_GENERATED_VERSION}.'
  26        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
  27        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
  28        + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},'
  29        + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.',
  30        RuntimeWarning
  31    )
  32
  33
  34class SchedulerStub(object):
  35    """The scheduler service is the endpoint which allows users to
  36    register a new node with greenlight, recover access to an existing
  37    node if the owner lost its credentials, schedule the node to be run
  38    on greenlight's infrastructure, and retrieve metadata about the
  39    node.
  40
  41    Node
  42    ====
  43
  44    A node is the basic object representing an account on
  45    greenlight. Each node corresponds to a c-lightning instance bound
  46    to a specific network that can be scheduled on greenlight, and must
  47    have a unique `node_id`.
  48
  49    Nodes are scheduled on-demand onto the infrastructure, but the time
  50    to schedule a node is almost instantaneous.
  51
  52    Authentication
  53    ==============
  54
  55    Users are authenticated using mTLS authentication. Applications are
  56    provisioned with an anonymous keypair that is not bound to a node,
  57    allowing access only to the unauthenticated endpoints
  58    `Scheduler.GetChallenge`, `Scheduler.Register` and
  59    `Scheduler.Recover`. This allows them to register or recover a
  60    node, but doesn't give access to the node itself. Upon registering
  61    or recovering an account the user receives a keypair that is bound
  62    to the specific node. Once the user receives their personal mTLS
  63    keypair they may use it to connect to greenlight, and thus get
  64    access to the node-specific functionality. Please refer to the
  65    documentation of your grpc library to learn how to configure grpc
  66    to use the node-specific mTLS keypair.
  67
  68    """
  69
  70    def __init__(self, channel):
  71        """Constructor.
  72
  73        Args:
  74            channel: A grpc.Channel.
  75        """
  76        self.Register = channel.unary_unary(
  77                '/scheduler.Scheduler/Register',
  78                request_serializer=glclient_dot_scheduler__pb2.RegistrationRequest.SerializeToString,
  79                response_deserializer=glclient_dot_scheduler__pb2.RegistrationResponse.FromString,
  80                _registered_method=True)
  81        self.Recover = channel.unary_unary(
  82                '/scheduler.Scheduler/Recover',
  83                request_serializer=glclient_dot_scheduler__pb2.RecoveryRequest.SerializeToString,
  84                response_deserializer=glclient_dot_scheduler__pb2.RecoveryResponse.FromString,
  85                _registered_method=True)
  86        self.GetChallenge = channel.unary_unary(
  87                '/scheduler.Scheduler/GetChallenge',
  88                request_serializer=glclient_dot_scheduler__pb2.ChallengeRequest.SerializeToString,
  89                response_deserializer=glclient_dot_scheduler__pb2.ChallengeResponse.FromString,
  90                _registered_method=True)
  91        self.Schedule = channel.unary_unary(
  92                '/scheduler.Scheduler/Schedule',
  93                request_serializer=glclient_dot_scheduler__pb2.ScheduleRequest.SerializeToString,
  94                response_deserializer=glclient_dot_scheduler__pb2.NodeInfoResponse.FromString,
  95                _registered_method=True)
  96        self.GetNodeInfo = channel.unary_unary(
  97                '/scheduler.Scheduler/GetNodeInfo',
  98                request_serializer=glclient_dot_scheduler__pb2.NodeInfoRequest.SerializeToString,
  99                response_deserializer=glclient_dot_scheduler__pb2.NodeInfoResponse.FromString,
 100                _registered_method=True)
 101        self.MaybeUpgrade = channel.unary_unary(
 102                '/scheduler.Scheduler/MaybeUpgrade',
 103                request_serializer=glclient_dot_scheduler__pb2.UpgradeRequest.SerializeToString,
 104                response_deserializer=glclient_dot_scheduler__pb2.UpgradeResponse.FromString,
 105                _registered_method=True)
 106        self.ListInviteCodes = channel.unary_unary(
 107                '/scheduler.Scheduler/ListInviteCodes',
 108                request_serializer=glclient_dot_scheduler__pb2.ListInviteCodesRequest.SerializeToString,
 109                response_deserializer=glclient_dot_scheduler__pb2.ListInviteCodesResponse.FromString,
 110                _registered_method=True)
 111        self.ExportNode = channel.unary_unary(
 112                '/scheduler.Scheduler/ExportNode',
 113                request_serializer=glclient_dot_scheduler__pb2.ExportNodeRequest.SerializeToString,
 114                response_deserializer=glclient_dot_scheduler__pb2.ExportNodeResponse.FromString,
 115                _registered_method=True)
 116        self.AddOutgoingWebhook = channel.unary_unary(
 117                '/scheduler.Scheduler/AddOutgoingWebhook',
 118                request_serializer=glclient_dot_scheduler__pb2.AddOutgoingWebhookRequest.SerializeToString,
 119                response_deserializer=glclient_dot_scheduler__pb2.AddOutgoingWebhookResponse.FromString,
 120                _registered_method=True)
 121        self.ListOutgoingWebhooks = channel.unary_unary(
 122                '/scheduler.Scheduler/ListOutgoingWebhooks',
 123                request_serializer=glclient_dot_scheduler__pb2.ListOutgoingWebhooksRequest.SerializeToString,
 124                response_deserializer=glclient_dot_scheduler__pb2.ListOutgoingWebhooksResponse.FromString,
 125                _registered_method=True)
 126        self.DeleteWebhooks = channel.unary_unary(
 127                '/scheduler.Scheduler/DeleteWebhooks',
 128                request_serializer=glclient_dot_scheduler__pb2.DeleteOutgoingWebhooksRequest.SerializeToString,
 129                response_deserializer=glclient_dot_greenlight__pb2.Empty.FromString,
 130                _registered_method=True)
 131        self.RotateOutgoingWebhookSecret = channel.unary_unary(
 132                '/scheduler.Scheduler/RotateOutgoingWebhookSecret',
 133                request_serializer=glclient_dot_scheduler__pb2.RotateOutgoingWebhookSecretRequest.SerializeToString,
 134                response_deserializer=glclient_dot_scheduler__pb2.WebhookSecretResponse.FromString,
 135                _registered_method=True)
 136        self.SignerRequestsStream = channel.stream_stream(
 137                '/scheduler.Scheduler/SignerRequestsStream',
 138                request_serializer=glclient_dot_scheduler__pb2.SignerResponse.SerializeToString,
 139                response_deserializer=glclient_dot_scheduler__pb2.SignerRequest.FromString,
 140                _registered_method=True)
 141
 142
 143class SchedulerServicer(object):
 144    """The scheduler service is the endpoint which allows users to
 145    register a new node with greenlight, recover access to an existing
 146    node if the owner lost its credentials, schedule the node to be run
 147    on greenlight's infrastructure, and retrieve metadata about the
 148    node.
 149
 150    Node
 151    ====
 152
 153    A node is the basic object representing an account on
 154    greenlight. Each node corresponds to a c-lightning instance bound
 155    to a specific network that can be scheduled on greenlight, and must
 156    have a unique `node_id`.
 157
 158    Nodes are scheduled on-demand onto the infrastructure, but the time
 159    to schedule a node is almost instantaneous.
 160
 161    Authentication
 162    ==============
 163
 164    Users are authenticated using mTLS authentication. Applications are
 165    provisioned with an anonymous keypair that is not bound to a node,
 166    allowing access only to the unauthenticated endpoints
 167    `Scheduler.GetChallenge`, `Scheduler.Register` and
 168    `Scheduler.Recover`. This allows them to register or recover a
 169    node, but doesn't give access to the node itself. Upon registering
 170    or recovering an account the user receives a keypair that is bound
 171    to the specific node. Once the user receives their personal mTLS
 172    keypair they may use it to connect to greenlight, and thus get
 173    access to the node-specific functionality. Please refer to the
 174    documentation of your grpc library to learn how to configure grpc
 175    to use the node-specific mTLS keypair.
 176
 177    """
 178
 179    def Register(self, request, context):
 180        """A user may register a new node with greenlight by providing
 181        some basic metadata and proving that they have access to
 182        the corresponding private key (see challenge-response
 183        mechanism below). This means that in order to register a
 184        new node the user must have access to the corresponding
 185        private keys to prove ownership, and prevent users from
 186        just registering arbitrary node_ids without actually
 187        knowing the corresponding secrets.
 188
 189        Upon successful registration an mTLS certificate and
 190        private key are returned. These can be used to authenticate
 191        future connections to the scheduler or the node.
 192
 193        Each node may be registered once, any later attempt will
 194        result in an error being returned. If the user lost its
 195        credentials it can make use of the Recover RPC method to
 196        recover the credentials. Notice that this also means that
 197        the same node_id cannot be reused for different networks.
 198        """
 199        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 200        context.set_details('Method not implemented!')
 201        raise NotImplementedError('Method not implemented!')
 202
 203    def Recover(self, request, context):
 204        """Should a user have lost its credentials (mTLS keypair) for
 205        any reason, they may regain access to their node using the
 206        Recover RPC method. Similar to the initial registration the
 207        caller needs to authenticate the call by proving access to
 208        the node's secret. This also uses the challenge-response
 209        mechanism.
 210
 211        Upon success a newly generated mTLS certificate and private
 212        key are returned, allowing the user to authenticate going
 213        forward. Existing keypairs are not revoked, in order to
 214        avoid locking out other authenticated applications.
 215        """
 216        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 217        context.set_details('Method not implemented!')
 218        raise NotImplementedError('Method not implemented!')
 219
 220    def GetChallenge(self, request, context):
 221        """Challenges are one-time values issued by the server, used
 222        to authenticate a user/device against the server. A user or
 223        device can authenticate to the server by signing the
 224        challenge and returning the signed message as part of the
 225        request that is to be authenticated.
 226
 227        Challenges may not be reused, and are bound to the scope
 228        they have been issued for. Attempting to reuse a challenge
 229        or use a challenge with a different scope will result in an
 230        error being returned.
 231        """
 232        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 233        context.set_details('Method not implemented!')
 234        raise NotImplementedError('Method not implemented!')
 235
 236    def Schedule(self, request, context):
 237        """Scheduling takes a previously registered node, locates a
 238        free slot in greenlight's infrastructure and allocates it
 239        to run the node. The node then goes through the startup
 240        sequence, synchronizing with the blockchain, and finally
 241        binding its grpc interface (see Node service below) to a
 242        public IP address and port. Access is authenticated via the
 243        mTLS keypair the user received from registering or
 244        recovering the node.
 245
 246        Upon success a NodeInfoResponse containing the grpc
 247        connection details and some metadata is returned. The
 248        application must use the grpc details and its node-specific
 249        mTLS keypair to interact with the node directly.
 250        """
 251        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 252        context.set_details('Method not implemented!')
 253        raise NotImplementedError('Method not implemented!')
 254
 255    def GetNodeInfo(self, request, context):
 256        """Much like `Schedule` this call is used to retrieve the
 257        metadata and grpc details of a node. Unlike the other call
 258        however it is passive, and will not result in the node
 259        being scheduled if it isn't already running. This can be
 260        used to check if a node is already scheduled, or to wait
 261        for it to be scheduled (e.g., if the caller is an `hsmd`
 262        that signs off on changes, but doesn't want to keep the
 263        node itself scheduled).
 264        """
 265        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 266        context.set_details('Method not implemented!')
 267        raise NotImplementedError('Method not implemented!')
 268
 269    def MaybeUpgrade(self, request, context):
 270        """The signer may want to trigger an upgrade of the node
 271        before waiting for the node to be scheduled. This ensures
 272        that the signer version is in sync with the node
 273        version. The scheduler may decide to defer upgrading if the
 274        protocols are compatible. Please do not use this directly,
 275        rather use the Signer in the client library to trigger this
 276        automatically when required. Posting an incomplete or
 277        non-functional UpgradeRequest may result in unschedulable
 278        nodes.
 279        """
 280        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 281        context.set_details('Method not implemented!')
 282        raise NotImplementedError('Method not implemented!')
 283
 284    def ListInviteCodes(self, request, context):
 285        """This call is used to fetch a list of invite codes associated
 286        with the node id of the client. These invite codes can be used
 287        for further registration of new nodes.
 288        """
 289        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 290        context.set_details('Method not implemented!')
 291        raise NotImplementedError('Method not implemented!')
 292
 293    def ExportNode(self, request, context):
 294        """Exporting a node allows users to take control of their node
 295
 296        This method initiates the node export on Greenlight,
 297        allowing users to offboard from GL into their own
 298        infrastructure. After calling this method the node will no
 299        longer be schedulable on Greenlight, since it is never safe
 300        to assume there haven't been changes in the node's state
 301        (see CLN Backups documentation for details). `ExportNode`
 302        marks the node as `Exporting`, then generates an encryption
 303        secret which is then used to encrypt a database
 304        backup. This encrypted database backup is then made
 305        accessible through an HTTP server, and a link to it is
 306        returned as a response to `ExportNode`. After the export
 307        completes the node is marked as `Exported`. The encryption
 308        key can then be derived using the signer, using ECDH,
 309        allowing only users with the node secret to decrypt it.
 310
 311        `ExportNode` is idempotent and may be called multiple
 312        times, without causing the node to be re-exported multiple
 313        times, should the call or the download be interrupted. DO
 314        NOT import the backup multiple times into your
 315        infrastructure, as that can lead to dataloss (old state
 316        being replayed) and loss of funds (see CLN Backups
 317        documentation for more information)
 318        """
 319        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 320        context.set_details('Method not implemented!')
 321        raise NotImplementedError('Method not implemented!')
 322
 323    def AddOutgoingWebhook(self, request, context):
 324        """Missing associated documentation comment in .proto file."""
 325        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 326        context.set_details('Method not implemented!')
 327        raise NotImplementedError('Method not implemented!')
 328
 329    def ListOutgoingWebhooks(self, request, context):
 330        """Missing associated documentation comment in .proto file."""
 331        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 332        context.set_details('Method not implemented!')
 333        raise NotImplementedError('Method not implemented!')
 334
 335    def DeleteWebhooks(self, request, context):
 336        """Missing associated documentation comment in .proto file."""
 337        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 338        context.set_details('Method not implemented!')
 339        raise NotImplementedError('Method not implemented!')
 340
 341    def RotateOutgoingWebhookSecret(self, request, context):
 342        """Missing associated documentation comment in .proto file."""
 343        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 344        context.set_details('Method not implemented!')
 345        raise NotImplementedError('Method not implemented!')
 346
 347    def SignerRequestsStream(self, request_iterator, context):
 348        """Attaches a Signer  via a bidirectional stream to the scheduler. 
 349        This is a communication channel between greenlight and the signing
 350        device that is used for requests that are not part of the node api.
 351
 352        The stream is used to hand out the ApprovePairingRequests that
 353        the signer answers with a ApprovePairingResponse.
 354        """
 355        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 356        context.set_details('Method not implemented!')
 357        raise NotImplementedError('Method not implemented!')
 358
 359
 360def add_SchedulerServicer_to_server(servicer, server):
 361    rpc_method_handlers = {
 362            'Register': grpc.unary_unary_rpc_method_handler(
 363                    servicer.Register,
 364                    request_deserializer=glclient_dot_scheduler__pb2.RegistrationRequest.FromString,
 365                    response_serializer=glclient_dot_scheduler__pb2.RegistrationResponse.SerializeToString,
 366            ),
 367            'Recover': grpc.unary_unary_rpc_method_handler(
 368                    servicer.Recover,
 369                    request_deserializer=glclient_dot_scheduler__pb2.RecoveryRequest.FromString,
 370                    response_serializer=glclient_dot_scheduler__pb2.RecoveryResponse.SerializeToString,
 371            ),
 372            'GetChallenge': grpc.unary_unary_rpc_method_handler(
 373                    servicer.GetChallenge,
 374                    request_deserializer=glclient_dot_scheduler__pb2.ChallengeRequest.FromString,
 375                    response_serializer=glclient_dot_scheduler__pb2.ChallengeResponse.SerializeToString,
 376            ),
 377            'Schedule': grpc.unary_unary_rpc_method_handler(
 378                    servicer.Schedule,
 379                    request_deserializer=glclient_dot_scheduler__pb2.ScheduleRequest.FromString,
 380                    response_serializer=glclient_dot_scheduler__pb2.NodeInfoResponse.SerializeToString,
 381            ),
 382            'GetNodeInfo': grpc.unary_unary_rpc_method_handler(
 383                    servicer.GetNodeInfo,
 384                    request_deserializer=glclient_dot_scheduler__pb2.NodeInfoRequest.FromString,
 385                    response_serializer=glclient_dot_scheduler__pb2.NodeInfoResponse.SerializeToString,
 386            ),
 387            'MaybeUpgrade': grpc.unary_unary_rpc_method_handler(
 388                    servicer.MaybeUpgrade,
 389                    request_deserializer=glclient_dot_scheduler__pb2.UpgradeRequest.FromString,
 390                    response_serializer=glclient_dot_scheduler__pb2.UpgradeResponse.SerializeToString,
 391            ),
 392            'ListInviteCodes': grpc.unary_unary_rpc_method_handler(
 393                    servicer.ListInviteCodes,
 394                    request_deserializer=glclient_dot_scheduler__pb2.ListInviteCodesRequest.FromString,
 395                    response_serializer=glclient_dot_scheduler__pb2.ListInviteCodesResponse.SerializeToString,
 396            ),
 397            'ExportNode': grpc.unary_unary_rpc_method_handler(
 398                    servicer.ExportNode,
 399                    request_deserializer=glclient_dot_scheduler__pb2.ExportNodeRequest.FromString,
 400                    response_serializer=glclient_dot_scheduler__pb2.ExportNodeResponse.SerializeToString,
 401            ),
 402            'AddOutgoingWebhook': grpc.unary_unary_rpc_method_handler(
 403                    servicer.AddOutgoingWebhook,
 404                    request_deserializer=glclient_dot_scheduler__pb2.AddOutgoingWebhookRequest.FromString,
 405                    response_serializer=glclient_dot_scheduler__pb2.AddOutgoingWebhookResponse.SerializeToString,
 406            ),
 407            'ListOutgoingWebhooks': grpc.unary_unary_rpc_method_handler(
 408                    servicer.ListOutgoingWebhooks,
 409                    request_deserializer=glclient_dot_scheduler__pb2.ListOutgoingWebhooksRequest.FromString,
 410                    response_serializer=glclient_dot_scheduler__pb2.ListOutgoingWebhooksResponse.SerializeToString,
 411            ),
 412            'DeleteWebhooks': grpc.unary_unary_rpc_method_handler(
 413                    servicer.DeleteWebhooks,
 414                    request_deserializer=glclient_dot_scheduler__pb2.DeleteOutgoingWebhooksRequest.FromString,
 415                    response_serializer=glclient_dot_greenlight__pb2.Empty.SerializeToString,
 416            ),
 417            'RotateOutgoingWebhookSecret': grpc.unary_unary_rpc_method_handler(
 418                    servicer.RotateOutgoingWebhookSecret,
 419                    request_deserializer=glclient_dot_scheduler__pb2.RotateOutgoingWebhookSecretRequest.FromString,
 420                    response_serializer=glclient_dot_scheduler__pb2.WebhookSecretResponse.SerializeToString,
 421            ),
 422            'SignerRequestsStream': grpc.stream_stream_rpc_method_handler(
 423                    servicer.SignerRequestsStream,
 424                    request_deserializer=glclient_dot_scheduler__pb2.SignerResponse.FromString,
 425                    response_serializer=glclient_dot_scheduler__pb2.SignerRequest.SerializeToString,
 426            ),
 427    }
 428    generic_handler = grpc.method_handlers_generic_handler(
 429            'scheduler.Scheduler', rpc_method_handlers)
 430    server.add_generic_rpc_handlers((generic_handler,))
 431    server.add_registered_method_handlers('scheduler.Scheduler', rpc_method_handlers)
 432
 433
 434 # This class is part of an EXPERIMENTAL API.
 435class Scheduler(object):
 436    """The scheduler service is the endpoint which allows users to
 437    register a new node with greenlight, recover access to an existing
 438    node if the owner lost its credentials, schedule the node to be run
 439    on greenlight's infrastructure, and retrieve metadata about the
 440    node.
 441
 442    Node
 443    ====
 444
 445    A node is the basic object representing an account on
 446    greenlight. Each node corresponds to a c-lightning instance bound
 447    to a specific network that can be scheduled on greenlight, and must
 448    have a unique `node_id`.
 449
 450    Nodes are scheduled on-demand onto the infrastructure, but the time
 451    to schedule a node is almost instantaneous.
 452
 453    Authentication
 454    ==============
 455
 456    Users are authenticated using mTLS authentication. Applications are
 457    provisioned with an anonymous keypair that is not bound to a node,
 458    allowing access only to the unauthenticated endpoints
 459    `Scheduler.GetChallenge`, `Scheduler.Register` and
 460    `Scheduler.Recover`. This allows them to register or recover a
 461    node, but doesn't give access to the node itself. Upon registering
 462    or recovering an account the user receives a keypair that is bound
 463    to the specific node. Once the user receives their personal mTLS
 464    keypair they may use it to connect to greenlight, and thus get
 465    access to the node-specific functionality. Please refer to the
 466    documentation of your grpc library to learn how to configure grpc
 467    to use the node-specific mTLS keypair.
 468
 469    """
 470
 471    @staticmethod
 472    def Register(request,
 473            target,
 474            options=(),
 475            channel_credentials=None,
 476            call_credentials=None,
 477            insecure=False,
 478            compression=None,
 479            wait_for_ready=None,
 480            timeout=None,
 481            metadata=None):
 482        return grpc.experimental.unary_unary(
 483            request,
 484            target,
 485            '/scheduler.Scheduler/Register',
 486            glclient_dot_scheduler__pb2.RegistrationRequest.SerializeToString,
 487            glclient_dot_scheduler__pb2.RegistrationResponse.FromString,
 488            options,
 489            channel_credentials,
 490            insecure,
 491            call_credentials,
 492            compression,
 493            wait_for_ready,
 494            timeout,
 495            metadata,
 496            _registered_method=True)
 497
 498    @staticmethod
 499    def Recover(request,
 500            target,
 501            options=(),
 502            channel_credentials=None,
 503            call_credentials=None,
 504            insecure=False,
 505            compression=None,
 506            wait_for_ready=None,
 507            timeout=None,
 508            metadata=None):
 509        return grpc.experimental.unary_unary(
 510            request,
 511            target,
 512            '/scheduler.Scheduler/Recover',
 513            glclient_dot_scheduler__pb2.RecoveryRequest.SerializeToString,
 514            glclient_dot_scheduler__pb2.RecoveryResponse.FromString,
 515            options,
 516            channel_credentials,
 517            insecure,
 518            call_credentials,
 519            compression,
 520            wait_for_ready,
 521            timeout,
 522            metadata,
 523            _registered_method=True)
 524
 525    @staticmethod
 526    def GetChallenge(request,
 527            target,
 528            options=(),
 529            channel_credentials=None,
 530            call_credentials=None,
 531            insecure=False,
 532            compression=None,
 533            wait_for_ready=None,
 534            timeout=None,
 535            metadata=None):
 536        return grpc.experimental.unary_unary(
 537            request,
 538            target,
 539            '/scheduler.Scheduler/GetChallenge',
 540            glclient_dot_scheduler__pb2.ChallengeRequest.SerializeToString,
 541            glclient_dot_scheduler__pb2.ChallengeResponse.FromString,
 542            options,
 543            channel_credentials,
 544            insecure,
 545            call_credentials,
 546            compression,
 547            wait_for_ready,
 548            timeout,
 549            metadata,
 550            _registered_method=True)
 551
 552    @staticmethod
 553    def Schedule(request,
 554            target,
 555            options=(),
 556            channel_credentials=None,
 557            call_credentials=None,
 558            insecure=False,
 559            compression=None,
 560            wait_for_ready=None,
 561            timeout=None,
 562            metadata=None):
 563        return grpc.experimental.unary_unary(
 564            request,
 565            target,
 566            '/scheduler.Scheduler/Schedule',
 567            glclient_dot_scheduler__pb2.ScheduleRequest.SerializeToString,
 568            glclient_dot_scheduler__pb2.NodeInfoResponse.FromString,
 569            options,
 570            channel_credentials,
 571            insecure,
 572            call_credentials,
 573            compression,
 574            wait_for_ready,
 575            timeout,
 576            metadata,
 577            _registered_method=True)
 578
 579    @staticmethod
 580    def GetNodeInfo(request,
 581            target,
 582            options=(),
 583            channel_credentials=None,
 584            call_credentials=None,
 585            insecure=False,
 586            compression=None,
 587            wait_for_ready=None,
 588            timeout=None,
 589            metadata=None):
 590        return grpc.experimental.unary_unary(
 591            request,
 592            target,
 593            '/scheduler.Scheduler/GetNodeInfo',
 594            glclient_dot_scheduler__pb2.NodeInfoRequest.SerializeToString,
 595            glclient_dot_scheduler__pb2.NodeInfoResponse.FromString,
 596            options,
 597            channel_credentials,
 598            insecure,
 599            call_credentials,
 600            compression,
 601            wait_for_ready,
 602            timeout,
 603            metadata,
 604            _registered_method=True)
 605
 606    @staticmethod
 607    def MaybeUpgrade(request,
 608            target,
 609            options=(),
 610            channel_credentials=None,
 611            call_credentials=None,
 612            insecure=False,
 613            compression=None,
 614            wait_for_ready=None,
 615            timeout=None,
 616            metadata=None):
 617        return grpc.experimental.unary_unary(
 618            request,
 619            target,
 620            '/scheduler.Scheduler/MaybeUpgrade',
 621            glclient_dot_scheduler__pb2.UpgradeRequest.SerializeToString,
 622            glclient_dot_scheduler__pb2.UpgradeResponse.FromString,
 623            options,
 624            channel_credentials,
 625            insecure,
 626            call_credentials,
 627            compression,
 628            wait_for_ready,
 629            timeout,
 630            metadata,
 631            _registered_method=True)
 632
 633    @staticmethod
 634    def ListInviteCodes(request,
 635            target,
 636            options=(),
 637            channel_credentials=None,
 638            call_credentials=None,
 639            insecure=False,
 640            compression=None,
 641            wait_for_ready=None,
 642            timeout=None,
 643            metadata=None):
 644        return grpc.experimental.unary_unary(
 645            request,
 646            target,
 647            '/scheduler.Scheduler/ListInviteCodes',
 648            glclient_dot_scheduler__pb2.ListInviteCodesRequest.SerializeToString,
 649            glclient_dot_scheduler__pb2.ListInviteCodesResponse.FromString,
 650            options,
 651            channel_credentials,
 652            insecure,
 653            call_credentials,
 654            compression,
 655            wait_for_ready,
 656            timeout,
 657            metadata,
 658            _registered_method=True)
 659
 660    @staticmethod
 661    def ExportNode(request,
 662            target,
 663            options=(),
 664            channel_credentials=None,
 665            call_credentials=None,
 666            insecure=False,
 667            compression=None,
 668            wait_for_ready=None,
 669            timeout=None,
 670            metadata=None):
 671        return grpc.experimental.unary_unary(
 672            request,
 673            target,
 674            '/scheduler.Scheduler/ExportNode',
 675            glclient_dot_scheduler__pb2.ExportNodeRequest.SerializeToString,
 676            glclient_dot_scheduler__pb2.ExportNodeResponse.FromString,
 677            options,
 678            channel_credentials,
 679            insecure,
 680            call_credentials,
 681            compression,
 682            wait_for_ready,
 683            timeout,
 684            metadata,
 685            _registered_method=True)
 686
 687    @staticmethod
 688    def AddOutgoingWebhook(request,
 689            target,
 690            options=(),
 691            channel_credentials=None,
 692            call_credentials=None,
 693            insecure=False,
 694            compression=None,
 695            wait_for_ready=None,
 696            timeout=None,
 697            metadata=None):
 698        return grpc.experimental.unary_unary(
 699            request,
 700            target,
 701            '/scheduler.Scheduler/AddOutgoingWebhook',
 702            glclient_dot_scheduler__pb2.AddOutgoingWebhookRequest.SerializeToString,
 703            glclient_dot_scheduler__pb2.AddOutgoingWebhookResponse.FromString,
 704            options,
 705            channel_credentials,
 706            insecure,
 707            call_credentials,
 708            compression,
 709            wait_for_ready,
 710            timeout,
 711            metadata,
 712            _registered_method=True)
 713
 714    @staticmethod
 715    def ListOutgoingWebhooks(request,
 716            target,
 717            options=(),
 718            channel_credentials=None,
 719            call_credentials=None,
 720            insecure=False,
 721            compression=None,
 722            wait_for_ready=None,
 723            timeout=None,
 724            metadata=None):
 725        return grpc.experimental.unary_unary(
 726            request,
 727            target,
 728            '/scheduler.Scheduler/ListOutgoingWebhooks',
 729            glclient_dot_scheduler__pb2.ListOutgoingWebhooksRequest.SerializeToString,
 730            glclient_dot_scheduler__pb2.ListOutgoingWebhooksResponse.FromString,
 731            options,
 732            channel_credentials,
 733            insecure,
 734            call_credentials,
 735            compression,
 736            wait_for_ready,
 737            timeout,
 738            metadata,
 739            _registered_method=True)
 740
 741    @staticmethod
 742    def DeleteWebhooks(request,
 743            target,
 744            options=(),
 745            channel_credentials=None,
 746            call_credentials=None,
 747            insecure=False,
 748            compression=None,
 749            wait_for_ready=None,
 750            timeout=None,
 751            metadata=None):
 752        return grpc.experimental.unary_unary(
 753            request,
 754            target,
 755            '/scheduler.Scheduler/DeleteWebhooks',
 756            glclient_dot_scheduler__pb2.DeleteOutgoingWebhooksRequest.SerializeToString,
 757            glclient_dot_greenlight__pb2.Empty.FromString,
 758            options,
 759            channel_credentials,
 760            insecure,
 761            call_credentials,
 762            compression,
 763            wait_for_ready,
 764            timeout,
 765            metadata,
 766            _registered_method=True)
 767
 768    @staticmethod
 769    def RotateOutgoingWebhookSecret(request,
 770            target,
 771            options=(),
 772            channel_credentials=None,
 773            call_credentials=None,
 774            insecure=False,
 775            compression=None,
 776            wait_for_ready=None,
 777            timeout=None,
 778            metadata=None):
 779        return grpc.experimental.unary_unary(
 780            request,
 781            target,
 782            '/scheduler.Scheduler/RotateOutgoingWebhookSecret',
 783            glclient_dot_scheduler__pb2.RotateOutgoingWebhookSecretRequest.SerializeToString,
 784            glclient_dot_scheduler__pb2.WebhookSecretResponse.FromString,
 785            options,
 786            channel_credentials,
 787            insecure,
 788            call_credentials,
 789            compression,
 790            wait_for_ready,
 791            timeout,
 792            metadata,
 793            _registered_method=True)
 794
 795    @staticmethod
 796    def SignerRequestsStream(request_iterator,
 797            target,
 798            options=(),
 799            channel_credentials=None,
 800            call_credentials=None,
 801            insecure=False,
 802            compression=None,
 803            wait_for_ready=None,
 804            timeout=None,
 805            metadata=None):
 806        return grpc.experimental.stream_stream(
 807            request_iterator,
 808            target,
 809            '/scheduler.Scheduler/SignerRequestsStream',
 810            glclient_dot_scheduler__pb2.SignerResponse.SerializeToString,
 811            glclient_dot_scheduler__pb2.SignerRequest.FromString,
 812            options,
 813            channel_credentials,
 814            insecure,
 815            call_credentials,
 816            compression,
 817            wait_for_ready,
 818            timeout,
 819            metadata,
 820            _registered_method=True)
 821
 822
 823class DebugStub(object):
 824    """A service to collect debugging information from clients.
 825    """
 826
 827    def __init__(self, channel):
 828        """Constructor.
 829
 830        Args:
 831            channel: A grpc.Channel.
 832        """
 833        self.ReportSignerRejection = channel.unary_unary(
 834                '/scheduler.Debug/ReportSignerRejection',
 835                request_serializer=glclient_dot_scheduler__pb2.SignerRejection.SerializeToString,
 836                response_deserializer=glclient_dot_greenlight__pb2.Empty.FromString,
 837                _registered_method=True)
 838
 839
 840class DebugServicer(object):
 841    """A service to collect debugging information from clients.
 842    """
 843
 844    def ReportSignerRejection(self, request, context):
 845        """The signer is designed to fail closed, i.e., we reject requests
 846        that do not resolve or that go against one of its policies. This
 847        comes with some issues, such as false negatives, where we reject
 848        despite the request being valid. As more apps use the API we need
 849        to debug these false negatives, hence why we report rejections,
 850        so we can investigate the validity of the rejection, and to
 851        fine-tine the signer's ruleset.
 852        """
 853        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 854        context.set_details('Method not implemented!')
 855        raise NotImplementedError('Method not implemented!')
 856
 857
 858def add_DebugServicer_to_server(servicer, server):
 859    rpc_method_handlers = {
 860            'ReportSignerRejection': grpc.unary_unary_rpc_method_handler(
 861                    servicer.ReportSignerRejection,
 862                    request_deserializer=glclient_dot_scheduler__pb2.SignerRejection.FromString,
 863                    response_serializer=glclient_dot_greenlight__pb2.Empty.SerializeToString,
 864            ),
 865    }
 866    generic_handler = grpc.method_handlers_generic_handler(
 867            'scheduler.Debug', rpc_method_handlers)
 868    server.add_generic_rpc_handlers((generic_handler,))
 869    server.add_registered_method_handlers('scheduler.Debug', rpc_method_handlers)
 870
 871
 872 # This class is part of an EXPERIMENTAL API.
 873class Debug(object):
 874    """A service to collect debugging information from clients.
 875    """
 876
 877    @staticmethod
 878    def ReportSignerRejection(request,
 879            target,
 880            options=(),
 881            channel_credentials=None,
 882            call_credentials=None,
 883            insecure=False,
 884            compression=None,
 885            wait_for_ready=None,
 886            timeout=None,
 887            metadata=None):
 888        return grpc.experimental.unary_unary(
 889            request,
 890            target,
 891            '/scheduler.Debug/ReportSignerRejection',
 892            glclient_dot_scheduler__pb2.SignerRejection.SerializeToString,
 893            glclient_dot_greenlight__pb2.Empty.FromString,
 894            options,
 895            channel_credentials,
 896            insecure,
 897            call_credentials,
 898            compression,
 899            wait_for_ready,
 900            timeout,
 901            metadata,
 902            _registered_method=True)
 903
 904
 905class PairingStub(object):
 906    """A service to pair signer-less clients with an existing signer.
 907    """
 908
 909    def __init__(self, channel):
 910        """Constructor.
 911
 912        Args:
 913            channel: A grpc.Channel.
 914        """
 915        self.PairDevice = channel.unary_unary(
 916                '/scheduler.Pairing/PairDevice',
 917                request_serializer=glclient_dot_scheduler__pb2.PairDeviceRequest.SerializeToString,
 918                response_deserializer=glclient_dot_scheduler__pb2.PairDeviceResponse.FromString,
 919                _registered_method=True)
 920        self.GetPairingData = channel.unary_unary(
 921                '/scheduler.Pairing/GetPairingData',
 922                request_serializer=glclient_dot_scheduler__pb2.GetPairingDataRequest.SerializeToString,
 923                response_deserializer=glclient_dot_scheduler__pb2.GetPairingDataResponse.FromString,
 924                _registered_method=True)
 925        self.ApprovePairing = channel.unary_unary(
 926                '/scheduler.Pairing/ApprovePairing',
 927                request_serializer=glclient_dot_scheduler__pb2.ApprovePairingRequest.SerializeToString,
 928                response_deserializer=glclient_dot_greenlight__pb2.Empty.FromString,
 929                _registered_method=True)
 930
 931
 932class PairingServicer(object):
 933    """A service to pair signer-less clients with an existing signer.
 934    """
 935
 936    def PairDevice(self, request, context):
 937        """Initiates a new Pairing Sessions. This is called by the new
 938        device that wants to request a pairing from an existing device.
 939        The session lifetime is bound to the stream so closing the
 940        stream destroys the session.
 941        """
 942        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 943        context.set_details('Method not implemented!')
 944        raise NotImplementedError('Method not implemented!')
 945
 946    def GetPairingData(self, request, context):
 947        """Returns the pairing related data that belongs to a pairing
 948        session. This is meant to be called from a device that can
 949        approve a pairing request, we sometimes call it "old device".
 950        """
 951        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 952        context.set_details('Method not implemented!')
 953        raise NotImplementedError('Method not implemented!')
 954
 955    def ApprovePairing(self, request, context):
 956        """Approves a pairing request. The ApprovePairingRequest is
 957        forwarded to a signer for further processing.
 958        """
 959        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
 960        context.set_details('Method not implemented!')
 961        raise NotImplementedError('Method not implemented!')
 962
 963
 964def add_PairingServicer_to_server(servicer, server):
 965    rpc_method_handlers = {
 966            'PairDevice': grpc.unary_unary_rpc_method_handler(
 967                    servicer.PairDevice,
 968                    request_deserializer=glclient_dot_scheduler__pb2.PairDeviceRequest.FromString,
 969                    response_serializer=glclient_dot_scheduler__pb2.PairDeviceResponse.SerializeToString,
 970            ),
 971            'GetPairingData': grpc.unary_unary_rpc_method_handler(
 972                    servicer.GetPairingData,
 973                    request_deserializer=glclient_dot_scheduler__pb2.GetPairingDataRequest.FromString,
 974                    response_serializer=glclient_dot_scheduler__pb2.GetPairingDataResponse.SerializeToString,
 975            ),
 976            'ApprovePairing': grpc.unary_unary_rpc_method_handler(
 977                    servicer.ApprovePairing,
 978                    request_deserializer=glclient_dot_scheduler__pb2.ApprovePairingRequest.FromString,
 979                    response_serializer=glclient_dot_greenlight__pb2.Empty.SerializeToString,
 980            ),
 981    }
 982    generic_handler = grpc.method_handlers_generic_handler(
 983            'scheduler.Pairing', rpc_method_handlers)
 984    server.add_generic_rpc_handlers((generic_handler,))
 985    server.add_registered_method_handlers('scheduler.Pairing', rpc_method_handlers)
 986
 987
 988 # This class is part of an EXPERIMENTAL API.
 989class Pairing(object):
 990    """A service to pair signer-less clients with an existing signer.
 991    """
 992
 993    @staticmethod
 994    def PairDevice(request,
 995            target,
 996            options=(),
 997            channel_credentials=None,
 998            call_credentials=None,
 999            insecure=False,
1000            compression=None,
1001            wait_for_ready=None,
1002            timeout=None,
1003            metadata=None):
1004        return grpc.experimental.unary_unary(
1005            request,
1006            target,
1007            '/scheduler.Pairing/PairDevice',
1008            glclient_dot_scheduler__pb2.PairDeviceRequest.SerializeToString,
1009            glclient_dot_scheduler__pb2.PairDeviceResponse.FromString,
1010            options,
1011            channel_credentials,
1012            insecure,
1013            call_credentials,
1014            compression,
1015            wait_for_ready,
1016            timeout,
1017            metadata,
1018            _registered_method=True)
1019
1020    @staticmethod
1021    def GetPairingData(request,
1022            target,
1023            options=(),
1024            channel_credentials=None,
1025            call_credentials=None,
1026            insecure=False,
1027            compression=None,
1028            wait_for_ready=None,
1029            timeout=None,
1030            metadata=None):
1031        return grpc.experimental.unary_unary(
1032            request,
1033            target,
1034            '/scheduler.Pairing/GetPairingData',
1035            glclient_dot_scheduler__pb2.GetPairingDataRequest.SerializeToString,
1036            glclient_dot_scheduler__pb2.GetPairingDataResponse.FromString,
1037            options,
1038            channel_credentials,
1039            insecure,
1040            call_credentials,
1041            compression,
1042            wait_for_ready,
1043            timeout,
1044            metadata,
1045            _registered_method=True)
1046
1047    @staticmethod
1048    def ApprovePairing(request,
1049            target,
1050            options=(),
1051            channel_credentials=None,
1052            call_credentials=None,
1053            insecure=False,
1054            compression=None,
1055            wait_for_ready=None,
1056            timeout=None,
1057            metadata=None):
1058        return grpc.experimental.unary_unary(
1059            request,
1060            target,
1061            '/scheduler.Pairing/ApprovePairing',
1062            glclient_dot_scheduler__pb2.ApprovePairingRequest.SerializeToString,
1063            glclient_dot_greenlight__pb2.Empty.FromString,
1064            options,
1065            channel_credentials,
1066            insecure,
1067            call_credentials,
1068            compression,
1069            wait_for_ready,
1070            timeout,
1071            metadata,
1072            _registered_method=True)