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
|
// +build varlink
package varlinkapi
import (
"context"
"fmt"
"os"
goruntime "runtime"
"time"
"github.com/containers/image/v5/pkg/sysregistriesv2"
iopodman "github.com/containers/libpod/cmd/podman/varlink"
"github.com/containers/libpod/libpod/define"
"github.com/sirupsen/logrus"
)
// GetVersion ...
func (i *LibpodAPI) GetVersion(call iopodman.VarlinkCall) error {
versionInfo, err := define.GetVersion()
if err != nil {
return err
}
return call.ReplyGetVersion(
versionInfo.Version,
versionInfo.GoVersion,
versionInfo.GitCommit,
time.Unix(versionInfo.Built, 0).Format(time.RFC3339),
versionInfo.OsArch,
versionInfo.RemoteAPIVersion,
)
}
// GetInfo returns details about the podman host and its stores
func (i *LibpodAPI) GetInfo(call iopodman.VarlinkCall) error {
versionInfo, err := define.GetVersion()
if err != nil {
return err
}
podmanInfo := iopodman.PodmanInfo{}
info, err := i.Runtime.Info()
if err != nil {
return call.ReplyErrorOccurred(err.Error())
}
host := info[0].Data
distribution := iopodman.InfoDistribution{
Distribution: host["Distribution"].(map[string]interface{})["distribution"].(string),
Version: host["Distribution"].(map[string]interface{})["version"].(string),
}
infoHost := iopodman.InfoHost{
Buildah_version: host["BuildahVersion"].(string),
Distribution: distribution,
Mem_free: host["MemFree"].(int64),
Mem_total: host["MemTotal"].(int64),
Swap_free: host["SwapFree"].(int64),
Swap_total: host["SwapTotal"].(int64),
Arch: host["arch"].(string),
Cpus: int64(host["cpus"].(int)),
Hostname: host["hostname"].(string),
Kernel: host["kernel"].(string),
Os: host["os"].(string),
Uptime: host["uptime"].(string),
Eventlogger: host["eventlogger"].(string),
}
podmanInfo.Host = infoHost
store := info[1].Data
pmaninfo := iopodman.InfoPodmanBinary{
Compiler: goruntime.Compiler,
Go_version: goruntime.Version(),
Podman_version: versionInfo.Version,
Git_commit: versionInfo.GitCommit,
}
graphStatus := iopodman.InfoGraphStatus{
Backing_filesystem: store["GraphStatus"].(map[string]string)["Backing Filesystem"],
Native_overlay_diff: store["GraphStatus"].(map[string]string)["Native Overlay Diff"],
Supports_d_type: store["GraphStatus"].(map[string]string)["Supports d_type"],
}
infoStore := iopodman.InfoStore{
Graph_driver_name: store["GraphDriverName"].(string),
Containers: int64(store["ContainerStore"].(map[string]interface{})["number"].(int)),
Images: int64(store["ImageStore"].(map[string]interface{})["number"].(int)),
Run_root: store["RunRoot"].(string),
Graph_root: store["GraphRoot"].(string),
Graph_driver_options: fmt.Sprintf("%v", store["GraphOptions"]),
Graph_status: graphStatus,
}
// Registry information if any is stored as the second list item
if len(info) > 2 {
for key, val := range info[2].Data {
if key == "search" {
podmanInfo.Registries.Search = val.([]string)
continue
}
regData := val.(sysregistriesv2.Registry)
if regData.Insecure {
podmanInfo.Registries.Insecure = append(podmanInfo.Registries.Insecure, key)
}
if regData.Blocked {
podmanInfo.Registries.Blocked = append(podmanInfo.Registries.Blocked, key)
}
}
}
podmanInfo.Store = infoStore
podmanInfo.Podman = pmaninfo
return call.ReplyGetInfo(podmanInfo)
}
// GetVersion ...
func (i *LibpodAPI) Reset(call iopodman.VarlinkCall) error {
if err := i.Runtime.Reset(context.TODO()); err != nil {
logrus.Errorf("Reset Failed: %v", err)
if err := call.ReplyErrorOccurred(err.Error()); err != nil {
logrus.Errorf("Failed to send ReplyErrorOccurred: %v", err)
}
os.Exit(define.ExecErrorCodeGeneric)
}
if err := call.ReplyReset(); err != nil {
logrus.Errorf("Failed to send ReplyReset: %v", err)
os.Exit(define.ExecErrorCodeGeneric)
}
os.Exit(0)
return nil
}
|
