298 lines
7.2 KiB
Go
298 lines
7.2 KiB
Go
package host
|
|
|
|
import (
|
|
"archive/tar"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/docker/docker/api/types/container"
|
|
"github.com/docker/docker/client"
|
|
cfg "github.com/rony5394/blazena/config"
|
|
"github.com/rony5394/blazena/shared"
|
|
)
|
|
|
|
var token string = "12345";
|
|
|
|
type aService struct{
|
|
ServiceId string `json:"serviceId"`;
|
|
VolumeNames []string `json:"volumeNames"`;
|
|
Node string `json:"node"`;
|
|
}
|
|
|
|
func Run(Config cfg.Config) {
|
|
DockerClient, err := client.NewClientWithOpts(client.FromEnv);
|
|
if err != nil {
|
|
panic("Failed to create DockerClient.");
|
|
}
|
|
|
|
_, err = DockerClient.Ping(context.Background())
|
|
if err != nil {
|
|
panic("Failed to ping DockerClient.");
|
|
}
|
|
|
|
sshKeyPair := shared.GenerateSSHKeypair();
|
|
sshHostPkPem := exchangeKeys(Config, string(sshKeyPair.Public));
|
|
createStorageContainer(Config, DockerClient, sshKeyPair.Private, sshHostPkPem);
|
|
|
|
services := getServices(Config);
|
|
|
|
for _, service := range services {
|
|
|
|
slog.Info("Scaling Down", slog.String("serviceId", service.ServiceId));
|
|
scale(Config, service.ServiceId, false);
|
|
slog.Info("Done");
|
|
|
|
for _, volume := range service.VolumeNames{
|
|
slog.Info("Preparing", slog.String("serviceId", service.ServiceId), slog.String("volumeId", volume));
|
|
if !prepareService(Config, service, volume) {continue}
|
|
slog.Info("Done");
|
|
|
|
targetStoragePath, _ := generateStoragePath(Config, service.Node, volume, DockerClient);
|
|
sourceStoragePath := "root@tasks."+ Config.Constants.HelperServiceName +":/volume";
|
|
|
|
slog.Debug("targetStoragePath", slog.String("value", targetStoragePath), slog.String("serviceId", service.ServiceId));
|
|
slog.Debug("sourceStoragePath", slog.String("value", sourceStoragePath), slog.String("serviceId", service.ServiceId));
|
|
|
|
command := `rsync -avz --delete -e "ssh -i /ssh-key -p 2222 -o StrictHostKeyChecking=yes -o UserKnownHostsFile=/expected-host-key" \
|
|
`+ sourceStoragePath +" "+ targetStoragePath;
|
|
|
|
exec, err := DockerClient.ContainerExecCreate(context.Background(), Config.Constants.StorageContainerName, container.ExecOptions{
|
|
Cmd: []string{"sh", "-c", command},
|
|
AttachStdout: true,
|
|
AttachStderr: true,
|
|
Tty: false,
|
|
});
|
|
if err != nil {
|
|
slog.Error("Failed to create rsync exec!", slog.Any("propagatedError", err));
|
|
os.Exit(1);
|
|
}
|
|
|
|
|
|
resp, err := DockerClient.ContainerExecAttach(context.Background(), exec.ID, container.ExecStartOptions{});
|
|
if err != nil {
|
|
slog.Error("Failed to create container exec!", slog.Any("propagatedError", err));
|
|
}
|
|
defer resp.Close();
|
|
|
|
io.Copy(os.Stdout, resp.Reader)
|
|
|
|
time.Sleep(30*time.Second);
|
|
slog.Info("Cleaning Up", slog.String("serviceId", service.ServiceId), slog.String("volumeId", volume));
|
|
cleanupService(Config, service);
|
|
slog.Info("Done!");
|
|
}
|
|
slog.Info("Scaling Up", slog.String("serviceId", service.ServiceId));
|
|
scale(Config, service.ServiceId, true);
|
|
slog.Info("Done!");
|
|
}
|
|
|
|
DockerClient.ContainerRemove(context.Background(), Config.Constants.StorageContainerName, container.RemoveOptions{
|
|
Force: true,
|
|
});
|
|
|
|
if !shutdown(Config){
|
|
slog.Error("Failed to shutdown docker api!");
|
|
os.Exit(1);
|
|
}
|
|
|
|
slog.Info("Finished whole backup run.");
|
|
}
|
|
|
|
func getServices(Config cfg.Config)[]aService{
|
|
req, err := http.NewRequest("GET", Config.DockerManagerBaseUrl + "/services", nil);
|
|
if err != nil {
|
|
panic("Failed to create request."+ err.Error());
|
|
}
|
|
|
|
req.Header.Add("Authorization", "Bearer "+ token);
|
|
|
|
res, err := http.DefaultClient.Do(req);
|
|
if err != nil {
|
|
panic("Failed to send request."+ err.Error());
|
|
}
|
|
reader, err := io.ReadAll(res.Body);
|
|
if err != nil {
|
|
panic("Failed to decode response body."+err.Error());
|
|
}
|
|
var services []aService;
|
|
err = json.Unmarshal(reader, &services);
|
|
if err != nil {
|
|
panic("Failed to unmarshal response.");
|
|
}
|
|
return services;
|
|
}
|
|
|
|
func cleanupService(Config cfg.Config, service aService)bool{
|
|
_, ok := Config.Nodes[service.Node];
|
|
if !ok {
|
|
fmt.Println("Node", service.Node, "refferenced in", service.ServiceId ,"service does not exists!");
|
|
return false;
|
|
}
|
|
|
|
var body struct{
|
|
ServiceId string `json:"serviceId"`
|
|
VolumeId string `json:"volumeId"`
|
|
} = struct{ServiceId string "json:\"serviceId\""; VolumeId string "json:\"volumeId\""}{
|
|
ServiceId: service.ServiceId,
|
|
}
|
|
|
|
bodyEncoded, err := json.Marshal(body);
|
|
|
|
if err != nil {
|
|
panic("Failed to marshal body."+ err.Error());
|
|
}
|
|
|
|
rq, err := http.NewRequest("POST", Config.DockerManagerBaseUrl + "/cleanup", bytes.NewBuffer(bodyEncoded));
|
|
|
|
if err != nil{
|
|
panic("Failed to create http request"+ err.Error());
|
|
}
|
|
|
|
rq.Header.Set("Authorization", "Bearer "+ token);
|
|
rq.Close = true;
|
|
rs, err := http.DefaultClient.Do(rq);
|
|
defer rs.Body.Close();
|
|
|
|
if err != nil{
|
|
panic("Failed to send http request"+ err.Error());
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
func shutdown(Config cfg.Config)bool{
|
|
rq, err := http.NewRequest("POST", Config.DockerManagerBaseUrl + "/shutdown", nil);
|
|
|
|
if err != nil{
|
|
panic("Failed to create http request"+ err.Error());
|
|
}
|
|
|
|
rq.Header.Set("Authorization", "Bearer "+ token);
|
|
rq.Close = true;
|
|
_, err = http.DefaultClient.Do(rq);
|
|
|
|
// if err != nil{
|
|
// panic("Failed to send http request"+ err.Error());
|
|
// }
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
func addToTar(tw *tar.Writer, filename string, content string) error{
|
|
hdr := &tar.Header{
|
|
Name: filename,
|
|
Mode: 0600,
|
|
Size: int64(len([]byte(content))),
|
|
};
|
|
|
|
if err := tw.WriteHeader(hdr); err != nil{
|
|
return err;
|
|
}
|
|
|
|
_, err := tw.Write([]byte(content))
|
|
|
|
return err;
|
|
}
|
|
|
|
func createIfMissing(targetPath string, DockerClient *client.Client, cfg cfg.Config) error{
|
|
const cmd = `#!/bin/sh
|
|
set -e
|
|
|
|
TARGET_PATH=$1
|
|
|
|
# Remove trailing slash
|
|
TARGET_PATH=${TARGET_PATH%/}
|
|
|
|
CURRENT=""
|
|
|
|
case "$TARGET_PATH" in
|
|
/*) CURRENT="/" ;;
|
|
esac
|
|
|
|
OLD_IFS=$IFS
|
|
IFS='/'
|
|
|
|
for PART in $TARGET_PATH; do
|
|
[ -z "$PART" ] && continue
|
|
|
|
if [ "$CURRENT" = "/" ]; then
|
|
NEXT="${CURRENT}${PART}"
|
|
else
|
|
NEXT="${CURRENT}/${PART}"
|
|
fi
|
|
|
|
if [ ! -e "$NEXT" ]; then
|
|
case "$PART" in
|
|
@*)
|
|
echo "Creating Btrfs subvolume: $NEXT"
|
|
btrfs subvolume create "$NEXT"
|
|
;;
|
|
*)
|
|
echo "Creating directory: $NEXT"
|
|
mkdir "$NEXT"
|
|
;;
|
|
esac
|
|
else
|
|
echo "Already exists: $NEXT"
|
|
fi
|
|
|
|
CURRENT="$NEXT"
|
|
done
|
|
|
|
IFS=$OLD_IFS`;
|
|
|
|
exec, err := DockerClient.ContainerExecCreate(context.Background(), cfg.Constants.StorageContainerName, container.ExecOptions{
|
|
Cmd: []string{"sh", "-c", cmd, "_", targetPath},
|
|
AttachStdout: true,
|
|
AttachStderr: true,
|
|
Tty: false,
|
|
});
|
|
|
|
if err != nil {
|
|
panic("Failed to create execute!"+err.Error());
|
|
}
|
|
|
|
resp, err := DockerClient.ContainerExecAttach(context.Background(), exec.ID, container.ExecStartOptions{});
|
|
defer resp.Close();
|
|
|
|
if err != nil {
|
|
panic("Failed to atach to exec!"+err.Error());
|
|
}
|
|
|
|
inspect, err := DockerClient.ContainerExecInspect(context.Background(), exec.ID);
|
|
|
|
if(inspect.ExitCode != 0){
|
|
fmt.Println("<resp>");
|
|
io.Copy(os.Stdout, resp.Reader);
|
|
fmt.Println("</resp>");
|
|
return errors.New("Execution did return non zero code!");
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
func generateStoragePath(cfg cfg.Config, node string, volumeId string, DockerClient *client.Client) (string, error){
|
|
var path string;
|
|
path += "/volume";
|
|
|
|
path += "/@"+ node +"/@"+ volumeId;
|
|
|
|
err := createIfMissing(path, DockerClient, cfg);
|
|
|
|
if err != nil {
|
|
return "", err;
|
|
}
|
|
|
|
return path, nil;
|
|
}
|