Ethan

If every possible action is going to piss off a large portion of the user base, doing nothing is the sanest option IMO.

They weren’t looking for universal approval. They were looking for widespread/majority approval.

So you think they should have picked a solution that pissed off a large portion of the user base, just so they could say they “solved” it? The entire problem is that they tried, repeatedly, and none of their proposals had wide support.

Sorry, I forgot about this. I’ve attached my full configuration at the end. The steps are:

1. If the container is on a server, SSH to it or whatever.
2. Execute docker exec --privileged -it container_name bash.
   • --privileged is required to make delve work. I don’t entirely remember why.
   • -it is something like --interactive and --terminal, it’s what you need to get a proper interactive shell.
   • container_name is the name of your container.
   • bash can also be sh or pwsh or whatever shell your container has (hopefully it has one).
3. Launch delve dlv attach PID --headless --listen=:2345 --accept-multiclient --api-version=2.
   • PID is the ID of the process you want to debug. This should be 1 if you’re debugging the main process of the container.
   • --listen=:2345 says to listen on (TCP) port 2345 on all interfaces (0.0.0.0)
   • The other flags are the one that vscode-go expects.
4. If the container is on a server, forward ports ssh ${USER}@${SERVER} -NL LOCAL:2345:REMOTE:2345.
   • LOCAL is the local IP to listen on, usually localhost. When a process connects to your local IP, it will be forwarded to the remote.
   • REMOTE is the remote IP to connect to, this should be the IP of your container. When a connection is forwarded from your local machine, this is where it is forwarded to. My containers are set up with --net host so I can use localhost as REMOTE but that’s not the default so you may have to use docker inspect to figure out your container’s IP.

I also included the path substitution configs I use. I generally debug these by pausing the target, clicking on something in the stack trace, seeing what path it tries to load, then adjusting the substitute path so that it loads the correct file.

{
  "name": "Attach to a docker container",
  // Get a shell in the container: `docker exec --privileged -it ${NAME} bash`
  // Launch delve:                 `dlv attach 1 --headless --listen=:2345 --accept-multiclient --api-version=2`
  // Forward the port (if remote): `ssh ${USER}@${SERVER} -NL localhost:2345:localhost:2345`
  // Then run this debug config
  "presentation": {
    "group": "99-Miscellaneous",
  },
  "type": "go",
  "request": "attach",
  "mode": "remote",
  "remotePath": "${workspaceFolder}",
  "port": 2345,
  "host": "127.0.0.1",
  "substitutePath": [
    // // Full paths (GitLab Docker build)
    // {
    //   "to": "/go/",
    //   "from": "${env:HOME}/go/", // <-- MODIFY THIS if you're not using the default GOPATH
    // },
    // {
    //   "to": "/root/",
    //   "from": "${workspaceFolder}",
    // },
    // Trimmed paths
    {
      "to": "gitlab.com/accumulatenetwork/accumulate/",
      "from": "${workspaceFolder}/",
    },
    {
      "to": "github.com/AccumulateNetwork/",
      "from": "${env:HOME}/go/pkg/mod/github.com/!accumulate!network/", // <-- MODIFY THIS if you're not using the default GOPATH
    },
    // {
    //   "to": "",
    //   "from": "${env:HOME}/go/pkg/mod/", // <-- MODIFY THIS if you're not using the default GOPATH
    // },
  ],
}

The TL;DR is that you have to exec —privileged and execute dlv attach within the container then tell VSCode to connect. I’ll look up my notes tomorrow and post more details.

Attaching to and debugging a process most certainly does work. I did it yesterday. Your issue is that Go doesn’t have any way of telling the process to pause until a debugger attaches. Which is frustrating but not the same issue.

Specifically for debugging stdin, by far the easiest way to do that (in VSCode) is "console": "integratedTerminal". Another comment links a stack overflow answer that includes other options.

You are correct, Go doesn’t have enums. The const thing is a widely accepted pattern for approximating enums.

Who uses struct tags for comments? I’ve never used or seen them used as anything except annotations as in tag:"value". And linters (go vet?) will tell you if you’re formatting them wrong.