fix timeout

.gitea/workflows/dockerimage.yaml

@@ -21,21 +21,119 @@ jobs:
     steps:
 
       - name: Login to Gitea Container Registry
-        uses: docker/login-action@v3
+        run: |
-        with:
+          mkdir -p ~/.docker
-          registry: gitea.arcodange.duckdns.org
+          cat <<EOF > /root/.docker/config.json
-          username: ${{ github.actor }}
+          {
-          password: ${{ secrets.PACKAGES_TOKEN }}
+            "auths": {
+              "gitea.arcodange.duckdns.org": {
+                "auth": "$(echo ${{ github.actor }}:${{ secrets.PACKAGES_TOKEN }} | base64)"
+              }
+            }
+          }
+          EOF
+          chmod 644 /root/.docker/config.json
+          chmod 755 /root/.docker/
       
       - name: git checkout
         uses: actions/checkout@v4
       
+      - name: prepare proxy
+        run: |
+          apt update
+          apt install python3-requests python3-socks -y
+          cat <<EOT > /tmp/pyproxy
+          import socket
+          import http.server
+          import socketserver
+          from urllib.parse import urlparse
+          import requests
+
+          PIHOLE_IP = "192.168.1.201"  # IP de Pi-hole
+          PROXY_PORT = 8888
+
+          def resolve_via_pihole(hostname):
+              """Résout un nom d'hôte via Pi-hole."""
+              try:
+                  # Force la résolution DNS via Pi-hole
+                  socket.setdefaulttimeout(5)
+                  return socket.gethostbyname(hostname)
+              except socket.gaierror:
+                  return None
+
+          class ProxyHandler(http.server.BaseHTTPRequestHandler):
+              def do_GET(self):
+                  url = urlparse(self.path)
+                  hostname = url.hostname
+                  if not hostname:
+                      self.send_error(400, "Bad Request: No hostname")
+                      return
+
+                  # Résolution DNS via Pi-hole
+                  resolved_ip = resolve_via_pihole(hostname)
+                  if not resolved_ip:
+                      self.send_error(404, f"DNS resolution failed for {hostname}")
+                      return
+
+                  # Relayer la requête vers la destination
+                  try:
+                      response = requests.get(f"http://{hostname}{url.path}", timeout=10)
+                      self.send_response(response.status_code)
+                      for header, value in response.headers.items():
+                          self.send_header(header, value)
+                      self.end_headers()
+                      self.wfile.write(response.content)
+                  except Exception as e:
+                      self.send_error(500, f"Proxy error: {str(e)}")
+
+              def do_CONNECT(self):
+                  # Gestion des requêtes HTTPS (tunnel)
+                  hostname = self.path.split(":")[0]
+                  resolved_ip = resolve_via_pihole(hostname)
+                  if not resolved_ip:
+                      self.send_error(404, f"DNS resolution failed for {hostname}")
+                      return
+
+                  try:
+                      self.send_response(200)
+                      self.end_headers()
+                      # Établir un tunnel vers la destination
+                      remote_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                      remote_socket.connect((resolved_ip, 443))
+                      self._tunnel(remote_socket)
+                  except Exception as e:
+                      self.send_error(500, f"Tunnel error: {str(e)}")
+
+              def _tunnel(self, remote_socket):
+                  """Relaye les données entre le client et le serveur distant."""
+                  while True:
+                      data = self.rfile.read(8192)
+                      if not data:
+                          break
+                      remote_socket.sendall(data)
+                      response = remote_socket.recv(8192)
+                      if not response:
+                          break
+                      self.wfile.write(response)
+
+          if __name__ == "__main__":
+              with socketserver.TCPServer(("", PROXY_PORT), ProxyHandler) as httpd:
+                  print(f"Proxy démarré sur le port {PROXY_PORT}")
+                  httpd.serve_forever()
+
+          EOT
+
+      
       - name: Build and push image to Gitea Container Registry
         run: |-
+          python3 /tmp/pyproxy &
           TAGS="latest ${{ github.ref_name }}"
           docker build -t app .
           for TAG in $TAGS; do
             docker tag app gitea.arcodange.duckdns.org/${{ github.repository }}:$TAG
+            
+            # export HTTPS_PROXY=192.168.1.201:8082
+            export HTTPS_PROXY=http://127.0.0.1:8888
             docker push gitea.arcodange.duckdns.org/${{ github.repository }}:$TAG
-          done
+            unset HTTPS_PROXY
-        
+          done