template parsing error - "operation not permitted"

I am developing a Google App Engine Go application and need to use some HTML templates in one of my packages. The current file structure is:

GOPATH/github.com/NAME/PROJECT/
                               app/
                                   app.go
                                   app.yaml
                               package/
                                       package.go
                                       Templates/
                                                 Template.html

To include the package, I use:

import "github.com/NAME/PROJECT/package"

Inside of package.go, I try parsing my Template.html file in various ways:

//Template, err := template.ParseFiles("package/Templates/Template.html") //doesn't work - "The system cannot find the path specified."
//Template, err := template.ParseFiles("github.com/NAME/PROJECT/package/Templates/Template.html") //doesn't work - "The system cannot find the path specified."
//Template, err := template.ParseFiles("Templates/Template.html") //doesn't work - "The system cannot find the path specified."
//Template, err := template.ParseFiles("/Templates/Template.html") //doesn't work - "The system cannot find the path specified."
Template, err := template.ParseFiles("../package/Templates/Template.html") //works on desktop!

So I take the last option that works on my desktop test environment, upload that to AppEngine and I get a new error of "operation not permitted"...

How do I parse HTML templates with such file configuration as shown above that works both on App Engine and on desktop?

You need to have the app.yaml at the root of your application. App Engine uses the location of the app.yaml to figure out what files are associated with your application. You want to move this file to the top-level.

For example, let's say that we have something like:

app.go
app.yaml
templates/t1
templates/t2

where app.yaml is what you'd normally have for your application, app.go is:

package app

import (
	"html/template"
	"net/http"
)

var templates = template.Must(template.ParseGlob("templates/*"))

func init() {
	http.HandleFunc("/", rootHandler)
}

func rootHandler(w http.ResponseWriter, r *http.Request) {
	name := r.URL.Path[1:]    // drop the leading slash
	tmpl := templates.Lookup(name)
	if tmpl == nil {
		http.NotFound(w, r)
		return
	}
	tmpl.Execute(w, nil)
}

and templates/t1 and templates/t2 are appropriate template files. Then once we have this, we can visit t1/ and t2/ in the resulting webapp, and it should serve and deploy fine on App Engine.

The key is to have the app.yaml at the toplevel directory of your application. One other caveat to keep in mind: make sure that any files you're trying to read from your dynamic application are not statically served or skipped. Check your app.yaml. If a file is to be statically served, then usually only the front-end is allowed to see the file, which means your back-end won't. And skipped files are just ignored altogether during deployment.

You can't read from a directory in GAE. Either you embed the Template inside a go file or you use the google Blob Storage API. https://developers.google.com/appengine/docs/go/blobstore/