forked from cpuguy83/dockerhub-webhook-listener
/
reload.go
126 lines (109 loc) · 3.01 KB
/
reload.go
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
package listener
import (
"encoding/json"
"fmt"
"io"
"log"
"os"
"os/exec"
"github.com/docker/docker/pkg/jsonmessage"
"github.com/docker/engine-api/client"
"github.com/docker/engine-api/types"
"github.com/docker/engine-api/types/container"
"github.com/docker/engine-api/types/network"
"github.com/docker/go-connections/nat"
"golang.org/x/net/context"
)
type Reloader struct{}
func (r *Reloader) Call(msg HubMessage) error {
log.Println("reload in progress...")
out, err := exec.Command("../reload.sh", msg.Repository.RepoName).Output()
if err != nil {
log.Println("reload error!")
log.Println(err)
return err
}
log.Println(string(out))
log.Printf("reload done.")
return nil
}
func (r *Reloader) Call2(msg HubMessage) error {
log.Println("received message to reload ...")
log.Printf("certPath %q, tls %v, host %v, api-version %v", os.Getenv("DOCKER_CERT_PATH"), os.Getenv("DOCKER_TLS_VERIFY"), os.Getenv("DOCKER_HOST"), os.Getenv("DOCKER_API_VERSION"))
cli, err := client.NewEnvClient()
//defaultHeaders := map[string]string{"User-Agent": "webhook-reloader"}
//cli, err := client.NewClient("unix:///var/run/docker.sock", "v1.22", nil, defaultHeaders)
if err != nil {
log.Print(err)
return err
}
image := msg.Repository.RepoName
tag := "latest"
log.Printf("pull image %q with tag %q ...", image, tag)
//ctx, cancel := context.WithTimeout(context.Background(), time.Duration(500) * time.Millisecond)
//defer cancel()
rc, err := cli.ImagePull(
context.Background(),
types.ImagePullOptions{
ImageID: msg.Repository.RepoName,
Tag: tag}, nil)
if err != nil {
log.Print(err)
return err
}
defer rc.Close()
dec := json.NewDecoder(rc)
for {
var message jsonmessage.JSONMessage
if err := dec.Decode(&message); err != nil {
if err == io.EOF {
break
}
log.Print(err)
return err
}
log.Printf("%s", message)
}
containerName := "test"
previousContainer := types.Container{}
psOptions := types.ContainerListOptions{All: true}
containers, err := cli.ContainerList(psOptions)
if err != nil {
log.Print(err)
return err
}
for _, c := range containers {
for _, name := range c.Names {
log.Printf("%q/%q", c.ID, name)
if name == fmt.Sprintf("/%s", containerName) {
previousContainer = c
}
}
}
log.Printf("prev container %v", previousContainer)
err = cli.ContainerStop(containerName, 10)
if err != nil {
log.Printf("stop %q: %v", containerName, err)
//return err
}
rmOptions := types.ContainerRemoveOptions{ContainerID: containerName}
err = cli.ContainerRemove(rmOptions)
if err != nil {
log.Printf("rm %q: %v", containerName, err)
//return err
}
newContainerConfig := types.ContainerCreateConfig{}
newContainerConfig.Config.Image = image
port, err := nat.NewPort("8080", "http")
exposedPorts := make(nat.PortSet)
exposedPorts[port] = struct{}{}
cli.ContainerCreate(
&container.Config{
Image: image,
ExposedPorts: exposedPorts},
&container.HostConfig{},
&network.NetworkingConfig{},
containerName)
log.Printf("done.")
return nil
}