IssueTracker

Please provide as much information as possible. At least, this should include a description of your issue and steps to reproduce the problem. If possible please provide a summary of what steps or workarounds you have already tried, and any docs or articles you found (un)helpful.

Problem you have encountered:

I would like to

1. Structure my application as described in the article "Migrating your App Engine app from Go 1.9 to Go 1.11" under "Structuring your files" (https://cloud.google.com/appengine/docs/standard/go111/go-differences#structuring_your_files):
myapp/
|- bar.go
|- foo.go
|- web/
  |-app.yaml
  |- main.go
2. Reference the files in my application at runtime. Given the following directory structure,
```
myapp/
|- data1.json
|- index1.html
|- foo.go
|- go.mod
|- go.sum
|- web/
  |- app.yaml
  |- main.go
  |- data.json
  |- index.html
```
I  would like to reference `web/index.html` from `web/app.yaml` and `web/data.json` from `web/main.go` like this:

In main.go, I load `data.json` using `os.Open("data.json")`

In `app.yaml`, I use
```
handlers:
  - url: /$
    static_files: index.html
    upload: index.html
    secure: always
```
to serve `web/index.html` statically under `/`.

However, at runtime, `data.json` is not found and `/` returns a 404 not found.

What you expected to happen:

I can refer to `data.json` and `index.html` relative to the location of `app.yaml`.

This is the behaviour when running under `dev_appserver web/app.yaml`.

Steps to reproduce:

Create a Go 1.11 application using Go modules for dependency management with the main package and app.yaml in a subdirectory, and try to refer to files in the same folder as the main package and app.yaml.

Sample project structure:
myapp/
|- go.mod
|- go.sum
|- version.go
|- web/
  |- app.yaml
  |- main.go
  |- hello.txt

web/hello.txt:
```
Hello, World
```

version.go:
```
package myapp

const Version = "VERSION"
```

web/main.go
```
package main

import (
        "fmt"
        "io/ioutil"
        "log"
        "net/http"
        "os"
        "strings"
)

func handler(w http.ResponseWriter, r *http.Request) {
        b, err := ioutil.ReadFile("hello.txt")
        if err != nil {
                fmt.Fprintf(w, "error reading hello.txt: %v\n", err)
        } else {
                fmt.Fprintf(w, "Contents of hello.txt: %s\n", string(b))
        }
        b, err = ioutil.ReadFile("version.go")
        if err != nil {
                fmt.Fprintf(w, "error reading version.go: %v\n", err)
        } else {
                fmt.Fprintf(w, "First line of version.go: %s\n", strings.SplitN(string(b), "\n", 2))
        }
}

func main() {
        port := os.Getenv("PORT")
        if port == "" {
                port = "8080"
                log.Printf("Defaulting to port %s", port)
        }

        log.Printf("Listening on port %s", port)
        log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), http.HandlerFunc(handler)))
}
```

Output under `dev_appserver web/app.yaml`:
```
Contents of hello.txt: Hello, World

error reading goodbye.txt: open goodbye.txt: no such file or directory
```

Output when deployed:
```
error reading hello.txt: open hello.txt: no such file or directory
Contents of goodbye.txt: Goodbye, World
```

Other information (workarounds you have tried, documentation consulted, etc):

Workaround:
When deployed, the app appears to be running from the `myapp` directory instead of `myapp/web`, so I can place my files there instead.