php-consul-api/src/Peering/PeeringClient.php at main · dcarbone/php-consul-api · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
<?php

declare(strict_types=1);

namespace DCarbone\PHPConsulAPI\Peering;

use DCarbone\Go\HTTP;
use DCarbone\PHPConsulAPI\PHPLib\AbstractClient;
use DCarbone\PHPConsulAPI\PHPLib\Error;
use DCarbone\PHPConsulAPI\PHPLib\ValuedWriteStringResponse;
use DCarbone\PHPConsulAPI\PHPLib\WriteResponse;
use DCarbone\PHPConsulAPI\QueryOptions;
use DCarbone\PHPConsulAPI\WriteOptions;

class PeeringClient extends AbstractClient
{
    public function Read(string $name, null|QueryOptions $opts = null): PeeringReadResponse
    {
        $ret = new PeeringReadResponse();
        if ('' === $name) {
            $ret->Err = new Error('peering name cannot be empty');
            return $ret;
        }

        $resp = $this->_requireNotFoundOrOK($this->_doGet(sprintf('v1/peering/%s', urlencode($name)), $opts));
        if (null !== $resp->Err) {
            $ret->Err = $resp->Err;
            $ret->setQueryMeta($resp->buildQueryMeta());
            return $ret;
        }

        if (HTTP\StatusNotFound === $resp->Response->getStatusCode()) {
            $ret->setQueryMeta($resp->buildQueryMeta());
            $ret->Peering = null;
            return $ret;
        }

        $this->_unmarshalResponse($resp, $ret);
        return $ret;
    }

    public function Delete(string $name, null|WriteOptions $opts = null): WriteResponse
    {
        $ret = new WriteResponse();
        if ('' === $name) {
            $ret->Err = new Error('peering name cannot be empty');
            return $ret;
        }

        $resp = $this->_requireOK($this->_doDelete(sprintf('v1/peering/%s', urlencode($name)), $opts));
        $this->_unmarshalResponse($resp, $ret);
        return $ret;
    }

    public function GenerateToken(
        PeeringGenerateTokenRequest $request,
        null|WriteOptions $opts = null
    ): ValuedWriteStringResponse {
        $ret = new ValuedWriteStringResponse();
        if ('' === $request->PeerName) {
            $ret->Err = new Error('peer name cannot be empty');
            return $ret;
        }

        $resp = $this->_requireOK($this->_doPost('v1/peering/token', $request, $opts));
        if (null !== $resp->Err) {
            $ret->Err = $resp->Err;
            return $ret;
        }
        $ret->WriteMeta = $resp->buildWriteMeta();
        $dec = $this->_decodeBody($resp->Response->getBody());
        if (null !== $dec->Err) {
            $ret->Err = $dec->Err;
            return $ret;
        }
        if ($dec->Decoded instanceof \stdClass && isset($dec->Decoded->PeeringToken)) {
            $ret->Value = (string)$dec->Decoded->PeeringToken;
        } else {
            $ret->Value = '';
        }
        return $ret;
    }

    public function Establish(PeeringEstablishRequest $request, null|WriteOptions $opts = null): WriteResponse
    {
        return $this->_executePost('v1/peering/establish', $request, $opts);
    }

    public function List(null|QueryOptions $opts = null): PeeringsResponse
    {
        $resp = $this->_requireOK($this->_doGet('v1/peerings', $opts));
        $ret = new PeeringsResponse();
        $this->_unmarshalResponse($resp, $ret);
        return $ret;
    }
}