Sync main with reliability fixes

.gitignore

@@ -1 +1,2 @@
-bin/
+bin/
+.DS_Store

README.md

@@ -80,7 +80,12 @@ The main version of the plugin supports the creation of docker containers with G
 CGO_ENABLED=1 GOOS=linux go build -o bin/docker-sd cmd/main.go
 ```
 As you can see, the CGO_ENABLED flag is set to 1, which means that the plugin will be built to allow the GO program to use C code. This is necessary to use the Nvidia GPU libraries.
-In the second case, the command is the following:
+In the second case, it is first necessary to change the branch of the repository with the following command:
+
+```bash
+git checkout 2-light-version-no-gpu
+```
+Then, the command to build the binary executable of the plugin without GPU support is the following:
 
 ```bash
 CGO_ENABLED=0 GOOS=linux go build -o bin/docker-sd cmd/main.go

cmd/main.go

@@ -163,6 +163,9 @@ func main() {
 		log.G(context.Background()).Fatal(err)
 	}
 
+	// log the interlinkconfig
+	log.G(context.Background()).Info("\u2705 InterLinkConfig: ", interLinkConfig)
+
 	if interLinkConfig.VerboseLogging {
 		logger.SetLevel(logrus.DebugLevel)
 	} else if interLinkConfig.ErrorsOnlyLogging {
@@ -178,35 +181,67 @@ func main() {
 	if availableDinds == "" {
 		availableDinds = "2"
 	}
-	var dindHandler dindmanager.DindManagerInterface = &dindmanager.DindManager{
-		DindList: []dindmanager.DindSpecs{},
-		Ctx:      ctx,
-	}
 	availableDindsInt, err := strconv.ParseInt(availableDinds, 10, 8)
 	if err != nil {
-		log.G(ctx).Info("\u2705 Error parsing availableDinds")
+		log.G(ctx).Fatal("Error parsing AVAILABLEDINDS: ", err)
+	}
+
+	// Build the subnet pool from the config (empty slice = no pool).
+	subnetPool, err := dindmanager.InitSubnetPool(interLinkConfig.DockerNetworkSubnet)
+	if err != nil {
+		log.G(ctx).Fatal("Error initialising subnet pool: ", err)
+	}
+	if len(subnetPool) > 0 {
+		log.G(ctx).Info(fmt.Sprintf(
+			"\u2705 Subnet pool initialised: %d /24 subnets available from %v",
+			len(subnetPool), interLinkConfig.DockerNetworkSubnet,
+		))
+	} else {
+		log.G(ctx).Info("\u2705 No DockerNetworkSubnet configured — Docker will assign subnets automatically")
 	}
+
+	var dindHandler dindmanager.DindManagerInterface = &dindmanager.DindManager{
+		DindList:        []dindmanager.DindSpecs{},
+		Ctx:             ctx,
+		FPGAEnabled:     interLinkConfig.FPGAEnabled,
+		XilinxToolsPath: interLinkConfig.XilinxToolsPath,
+		SubnetPool:      subnetPool,
+	}
+
+	dindHandler.(*dindmanager.DindManager).InitialPoolSz = len(subnetPool)
+
 	dindHandler.CleanDindContainers()
 	dindHandler.BuildDindContainers(int8(availableDindsInt))
 
+	// Periodically reclaim orphan DIND networks left behind by failed creates, so
+	// a single failure cannot permanently exhaust the subnet pool. Only networks
+	// with no attached container are removed, and never while a build is running.
+	go func() {
+		ticker := time.NewTicker(5 * time.Minute)
+		defer ticker.Stop()
+		for range ticker.C {
+			dindHandler.ReapOrphanNetworks()
+		}
+	}()
+
 	var gpuManager gpustrategies.GPUManagerInterface = &gpustrategies.GPUManager{
 		GPUSpecsList: []gpustrategies.GPUSpecs{},
 		Ctx:          ctx,
 	}
 
 	err = gpuManager.Init()
 	if err != nil {
-		log.G(ctx).Info("\u274C Init of GPUs failed, error", err)
+		log.G(ctx).Info("❌ Init of GPUs failed, error", err)
 	}
 
 	err = gpuManager.Discover()
 	if err != nil {
-		log.G(ctx).Info("\u274C Discover of GPUs failed, error: ", err)
+		log.G(ctx).Info("❌ Discover of GPUs failed, error: ", err)
 	}
 
 	err = gpuManager.Check()
 	if err != nil {
-		log.G(ctx).Info("\u274C Check of GPUs failed, error: ", err)
+		log.G(ctx).Info("❌ Check of GPUs failed, error: ", err)
 	}
 
 	SidecarAPIs := docker.SidecarHandler{
@@ -236,10 +271,12 @@ func main() {
 		log.G(ctx).Info("\u2705 Tracing is disabled")
 	}
 
-	if os.Getenv("FPGAENABLED") == "1" {
+	if interLinkConfig.FPGAEnabled {
 		fpgaManager := &fpgastrategies.FPGAManager{
 			FPGASpecsList: []fpgastrategies.FPGASpecs{},
 			Ctx:           ctx,
+			VitisPath:     interLinkConfig.VitisPath,
+			XRTPath:       interLinkConfig.XRTPath,
 		}
 		err = fpgaManager.Init()
 		if err != nil {
@@ -271,7 +308,7 @@ func main() {
 
 		// Cleanup the sockfile.
 		c := make(chan os.Signal, 1)
-		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+		signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
 		go func() {
 			<-c
 			os.Remove(strings.ReplaceAll(interLinkConfig.Socket, "unix://", ""))

docker/Dockerfile.sidecar-docker

@@ -7,30 +7,26 @@ RUN CGO_ENABLED=0 GOOS=linux go build -o bin/docker-sidecar cmd/main.go
 FROM bash:latest as bash-stage
 
 # Deploy the application binary into a lean image
-FROM docker:24.0-dind-rootless AS build-release-stage
+FROM docker:26.1.3-dind AS build-release-stage
 
 WORKDIR /
 
+USER root:root
+
+RUN mkdir -p /sidecar
+
 COPY --from=build-stage /app/bin/docker-sidecar /sidecar/docker-sidecar
 
 # adding bash binary to be able to perform commands within the sidecar binary
 COPY --from=bash-stage /usr/local/bin/bash /bin 
 
-USER root:root
+ENV INTERLINKCONFIGPATH=/InterLinkConfig.yaml
 
 ENV PATH "$PATH:/bin"
 
 #creating a simple startup script to start both docker rootless and the sidecar
-RUN echo -e '#!/bin/bash\ndockerd-entrypoint.sh & /sidecar/docker-sidecar' > /sidecar/startup-docker.sh
+RUN echo -e '#!/bin/bash\ndockerd --mtu=1350 & /sidecar/docker-sidecar' > /sidecar/startup-docker.sh
 RUN chmod +x /sidecar/startup-docker.sh
-RUN chmod -R 777 /sidecar
-
-ENV INTERLINKCONFIGPATH=/InterLinkConfig.yaml
-
-USER 1000:1000
-
-#setting up the path for the docker daemon
-ENV DOCKER_HOST=unix:///run/user/1000/docker.sock
 
 WORKDIR /sidecar
 

pkg/common/types.go

@@ -54,31 +54,32 @@ type RetrievedContainer struct {
 
 // InterLinkConfig holds the whole configuration
 type InterLinkConfig struct {
-	VKConfigPath      string `yaml:"VKConfigPath"`
-	VKTokenFile       string `yaml:"VKTokenFile"`
-	Interlinkurl      string `yaml:"InterlinkURL"`
-	Sidecarurl        string `yaml:"SidecarURL"`
-	Sbatchpath        string `yaml:"SbatchPath"`
-	Scancelpath       string `yaml:"ScancelPath"`
-	Squeuepath        string `yaml:"SqueuePath"`
-	Interlinkport     string `yaml:"InterlinkPort"`
-	Socket            string `yaml:"Socket"`
-	Sidecarport       string `yaml:"SidecarPort"`
-	Commandprefix     string `yaml:"CommandPrefix"`
-	ExportPodData     bool   `yaml:"ExportPodData"`
-	DataRootFolder    string `yaml:"DataRootFolder"`
-	ServiceAccount    string `yaml:"ServiceAccount"`
-	Namespace         string `yaml:"Namespace"`
-	Tsocks            bool   `yaml:"Tsocks"`
-	Tsockspath        string `yaml:"TsocksPath"`
-	Tsocksconfig      string `yaml:"TsocksConfig"`
-	Tsockslogin       string `yaml:"TsocksLoginNode"`
-	BashPath          string `yaml:"BashPath"`
-	VerboseLogging    bool   `yaml:"VerboseLogging"`
-	ErrorsOnlyLogging bool   `yaml:"ErrorsOnlyLogging"`
-	PodIP             string `yaml:"PodIP"`
-	SingularityPrefix string `yaml:"SingularityPrefix"`
-	set               bool
+	VKConfigPath        string   `yaml:"VKConfigPath"`
+	VKTokenFile         string   `yaml:"VKTokenFile"`
+	Interlinkurl        string   `yaml:"InterlinkURL"`
+	Sidecarurl          string   `yaml:"SidecarURL"`
+	Sbatchpath          string   `yaml:"SbatchPath"`
+	Scancelpath         string   `yaml:"ScancelPath"`
+	Squeuepath          string   `yaml:"SqueuePath"`
+	Interlinkport       string   `yaml:"InterlinkPort"`
+	Socket              string   `yaml:"Socket"`
+	Sidecarport         string   `yaml:"SidecarPort"`
+	Commandprefix       string   `yaml:"CommandPrefix"`
+	ExportPodData       bool     `yaml:"ExportPodData"`
+	DataRootFolder      string   `yaml:"DataRootFolder"`
+	ServiceAccount      string   `yaml:"ServiceAccount"`
+	Namespace           string   `yaml:"Namespace"`
+	Tsocks              bool     `yaml:"Tsocks"`
+	Tsockspath          string   `yaml:"TsocksPath"`
+	Tsocksconfig        string   `yaml:"TsocksConfig"`
+	Tsockslogin         string   `yaml:"TsocksLoginNode"`
+	BashPath            string   `yaml:"BashPath"`
+	VerboseLogging      bool     `yaml:"VerboseLogging"`
+	ErrorsOnlyLogging   bool     `yaml:"ErrorsOnlyLogging"`
+	PodIP               string   `yaml:"PodIP"`
+	SingularityPrefix   string   `yaml:"SingularityPrefix"`
+	DockerNetworkSubnet []string `yaml:"DockerNetworkSubnet"`
+	set                 bool
 }
 
 // ContainerLogOpts is a struct in which it is possible to specify options to retrieve logs from the sidecar