socketd/backend_client.h at main · Droidspaces/socketd · 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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#pragma once

#include <cstdint>
#include <string>
#include <vector>

namespace droidspaces::socketd {

struct CapabilitiesResult {
  std::uint32_t mask = 0;
};

struct ContainerPortResult {
  std::uint16_t host_port = 0;
  std::uint16_t host_port_end = 0;
  std::uint16_t container_port = 0;
  std::uint16_t container_port_end = 0;
  std::uint8_t proto = 0; /* 0 = tcp, 1 = udp */
};

struct InspectEnvResult {
  std::string key;
  std::string value;
};

struct InspectBindResult {
  std::string source;
  std::string destination;
  bool read_only = false;
};

struct ContainerInspectResult {
  std::string name;
  std::string uuid;
  std::string rootfs_path;
  std::string image_ref;
  std::string hostname;
  std::string nat_ip;
  std::string custom_init;
  std::string dns_servers;
  std::int32_t pid = 0;
  std::uint8_t net_mode = 0; /* 0 = host, 1 = nat, 2 = none */
  std::int64_t started_at = 0;
  std::int64_t memory_limit = 0;
  std::int64_t cpu_quota = 0;
  std::int64_t cpu_period = 0;
  std::int64_t pids_limit = 0;
  std::int32_t privileged_mask = 0;
  bool foreground = false;
  bool volatile_mode = false;
  bool force_cgroupv1 = false;
  bool disable_ipv6 = false;
  bool android_storage = false;
  bool selinux_permissive = false;
  bool hw_access = false;
  bool gpu_mode = false;
  bool termux_x11 = false;
  bool block_nested_ns = false;
  bool is_img_mount = false;
  std::uint16_t env_total_count = 0;
  std::uint16_t bind_total_count = 0;
  std::uint16_t port_total_count = 0;
  std::vector<InspectEnvResult> env;
  std::vector<InspectBindResult> binds;
  std::vector<ContainerPortResult> ports;
};

struct ContainerRecordResult {
  std::string name;
  std::string uuid;
  std::string rootfs_path;
  std::string hostname;
  std::string nat_ip;
  std::string custom_init;
  std::int32_t pid = 0;
  std::uint8_t net_mode = 0; /* 0 = host, 1 = nat, 2 = none */
  std::int64_t started_at = 0;
  std::vector<ContainerPortResult> ports;
};

struct InfoResult {
  std::uint32_t containers_total = 0;
  std::uint32_t containers_running = 0;
  std::uint32_t containers_stopped = 0;
};

struct ImageRecordResult {
  std::string name;
  std::string rootfs_path;
  std::string uuid;
  bool is_running = false;
  std::int64_t created_at = 0;
};

struct CoreEventResult {
  std::int64_t time = 0;
  std::int64_t time_nano = 0;
  std::string type;
  std::string action;
  std::string actor_id;
  std::string actor_name;
};

struct LifecycleResult {
  bool not_found = false;
  bool already_running = false;
  bool already_stopped = false;
};

class BackendClient {
public:
  BackendClient() = default;

  bool ping(std::string &error) const;
  bool capabilities(CapabilitiesResult &out, std::string &error) const;

  bool list_containers(bool include_all,
                       std::vector<ContainerRecordResult> &out,
                       std::string &error) const;

  bool inspect_container(const std::string &ref, ContainerInspectResult &out,
                         bool &not_found, std::string &error) const;

  bool info(InfoResult &out, std::string &error) const;

  bool list_images(std::vector<ImageRecordResult> &out,
                   std::string &error) const;

  bool poll_events(std::int64_t since, std::vector<CoreEventResult> &out,
                   std::string &error) const;

  bool start_container(const std::string &ref, LifecycleResult &out,
                       std::string &error) const;
  bool stop_container(const std::string &ref, int timeout_seconds,
                      LifecycleResult &out, std::string &error) const;
  bool restart_container(const std::string &ref, int timeout_seconds,
                         LifecycleResult &out, std::string &error) const;

private:
  bool lifecycle_request(std::uint16_t opcode, const std::string &ref,
                         int timeout_seconds, LifecycleResult &out,
                         std::string &error) const;

  bool request(std::uint16_t opcode, const void *payload,
               std::uint32_t payload_len, std::uint16_t &status_out,
               std::string &payload_out, std::string &error) const;
};

} // namespace droidspaces::socketd