func incomingImageHandler(w http.ResponseWriter, r *http.Request) error {
c := appengine.NewContext(r)
config := google.NewAppEngineConfig(c, "https://www.googleapis.com/auth/userinfo.email")
config.Transport = &urlfetch.Transport{
Context: c,
Deadline: time.Minute,
AllowInvalidServerCertificate: true,
}
client := http.Client{Transport: config.NewTransport()}
r.ParseForm()
res, err := client.PostForm(backendAddress, r.Form)
if err != nil {
return fmt.Errorf("backend: %v", err)
}
if res.StatusCode != http.StatusOK {
b, err := httputil.DumpResponse(res, true)
if err != nil {
return fmt.Errorf("dump response: %v", err)
}
c.Errorf("backend failed with code %v:\n%s", res.Status, b)
}
w.WriteHeader(res.StatusCode)
_, err = io.Copy(w, res.Body)
return err
}
// compilerProxyLogHandler handles /<path> for compiler_proxy.INFO log file in gs://chrome-goma-log/<path>
func compilerProxyLogHandler(w http.ResponseWriter, req *http.Request) {
ctx := appengine.NewContext(req)
// TODO(ukai): should we set access control like /file?
config := google.NewAppEngineConfig(ctx, []string{
"https://www.googleapis.com/auth/devstorage.read_only",
})
client := &http.Client{Transport: config.NewTransport()}
basename := path.Base(req.URL.Path)
if !strings.HasPrefix(basename, "compiler_proxy.") {
ctx.Errorf("wrong path is requested: %q", req.URL.Path)
http.Error(w, "unexpected filename", http.StatusBadRequest)
return
}
logPath := req.URL.Path
cpl, err := compilerProxyLogFetch(client, logPath)
if err != nil {
ctx.Errorf("failed to fetch %s: %v", logPath, err)
http.Error(w, err.Error(), http.StatusNotFound)
return
}
err = compilerProxyLogSummary(w, logPath, cpl)
if err != nil {
ctx.Errorf("failed to output %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
// fileHandler handles /<path> to access gs://chrome-goma-log/<path>.
func fileHandler(w http.ResponseWriter, req *http.Request) {
ctx := appengine.NewContext(req)
user := user.Current(ctx)
if user == nil {
http.Error(w, "Login required", http.StatusUnauthorized)
return
}
if !strings.HasSuffix(user.Email, "@chromium.org") && strings.HasSuffix(user.Email, "@google.com") {
http.Error(w, "Unauthorized to access", http.StatusUnauthorized)
return
}
config := google.NewAppEngineConfig(ctx, []string{
"https://www.googleapis.com/auth/devstorage.read_only",
})
client := &http.Client{Transport: config.NewTransport()}
path := req.URL.Path
resp, err := logstore.Fetch(client, path)
if err != nil {
ctx.Errorf("failed to fetch %s: %v", path, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer resp.Body.Close()
copyHeader(w.Header(), resp.Header)
w.WriteHeader(resp.StatusCode)
_, err = io.Copy(w, resp.Body)
if err != nil {
ctx.Errorf("failed to copy %s: %v", path, err)
}
}
func Example_appEngine() {
context := appengine.NewContext(nil)
config := google.NewAppEngineConfig(context, []string{
"https://www.googleapis.com/auth/bigquery",
})
// The following client will be authorized by the App Engine
// app's service account for the provided scopes.
client := http.Client{Transport: config.NewTransport()}
client.Get("...")
}
// handler is the main demo entry point that calls the GCS operations.
func handler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
http.NotFound(w, r)
return
}
c := appengine.NewContext(r)
bucketName, err := file.DefaultBucketName(c)
if err != nil {
c.Errorf("failed to get default GCS bucket name: %v", err)
return
}
config := google.NewAppEngineConfig(c, storage.ScopeFullControl)
ctx := cloud.NewContext(appengine.AppID(c), &http.Client{Transport: config.NewTransport()})
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
fmt.Fprintf(w, "Demo GCS Application running from Version: %v\n", appengine.VersionID(c))
fmt.Fprintf(w, "Using bucket name: %v\n\n", bucketName)
d := &demo{
c: c,
w: w,
ctx: ctx,
bucket: bucketName,
}
n := "demo-testfile-go"
d.createFile(n)
d.readFile(n)
d.copyFile(n)
d.statFile(n)
d.createListFiles()
d.listBucket()
d.listBucketDirMode()
d.defaultACL()
d.putDefaultACLRule()
d.deleteDefaultACLRule()
d.bucketACL()
d.putBucketACLRule()
d.deleteBucketACLRule()
d.acl(n)
d.putACLRule(n)
d.deleteACLRule(n)
d.deleteFiles()
if d.failed {
io.WriteString(w, "\nDemo failed.\n")
} else {
io.WriteString(w, "\nDemo succeeded.\n")
}
}
func ninjalogUpload(w http.ResponseWriter, req *http.Request) {
ctx := appengine.NewContext(req)
u := user.Current(ctx)
if u == nil {
http.Error(w, "unauthorized", http.StatusUnauthorized)
return
}
// TODO(ukai): allow only @google.com and @chromium.org?
ctx.Infof("upload by %s", u.Email)
f, _, err := req.FormFile("file")
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
defer f.Close()
njl, err := ninjalog.Parse("ninja_log", f)
if err != nil {
ctx.Errorf("bad format: %v", err)
http.Error(w, fmt.Sprintf("malformed ninja_log file %v", err), http.StatusBadRequest)
return
}
var data bytes.Buffer
err = ninjalog.Dump(&data, njl.Steps)
if err != nil {
ctx.Errorf("dump error: %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
config := google.NewAppEngineConfig(ctx, []string{
"https://www.googleapis.com/auth/devstorage.read_write",
})
client := &http.Client{Transport: config.NewTransport()}
logPath, err := logstore.Upload(client, "ninja_log", data.Bytes())
if err != nil {
ctx.Errorf("upload error: %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
ctx.Infof("%s upload to %s", u.Email, logPath)
if req.FormValue("trace") != "" {
http.Redirect(w, req, "/ninja_log/"+logPath+"/trace.html", http.StatusSeeOther)
return
}
http.Redirect(w, req, "/ninja_log/"+logPath, http.StatusSeeOther)
}
// ninjaLogHandler handles /<path>/<format> for ninja_log file in gs://chrome-goma-log/<path>
func ninjaLogHandler(w http.ResponseWriter, req *http.Request) {
if req.URL.Path == "" {
ninjalogForm(w, req)
return
}
ctx := appengine.NewContext(req)
// should we set access control like /file?
config := google.NewAppEngineConfig(ctx, []string{
"https://www.googleapis.com/auth/devstorage.read_only",
})
client := &http.Client{Transport: config.NewTransport()}
logPath, outFunc, err := ninjalogPath(req.URL.Path)
if err != nil {
ctx.Errorf("failed to parse request path: %s: %v", req.URL.Path, err)
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
njl, _, err := ninjalogFetch(client, logPath)
if err != nil {
ctx.Errorf("failed to fetch %s: %v", logPath, err)
http.Error(w, err.Error(), http.StatusNotFound)
return
}
err = outFunc(w, logPath, njl)
if err != nil {
ctx.Errorf("failed to output %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func queryIntoDatastore(w http.ResponseWriter, r *http.Request, m map[string]interface{}) {
limitUpper := util.MonthsBack(1)
limitLower := util.MonthsBack(25)
var q bq.QueryRequest = bq.QueryRequest{}
q.Query = `
SELECT
repository_language
, LEFT(repository_pushed_at,7) monthx
, CEIL( count(*)/1000) Tausend
FROM githubarchive:github.timeline
where 1=1
AND LEFT(repository_pushed_at,7) >= '` + limitLower + `'
AND LEFT(repository_pushed_at,7) <= '` + limitUpper + `'
AND repository_language in ('Go','go','Golang','golang','C','Java','PHP','JavaScript','C++','Python','Ruby')
AND type="PushEvent"
group by monthx, repository_language
order by repository_language , monthx
;
`
c := appengine.NewContext(r)
config := oauth2_google.NewAppEngineConfig(c, []string{
"https://www.googleapis.com/auth/bigquery",
})
// The following client will be authorized by the App Engine
// app's service account for the provided scopes.
client := http.Client{Transport: config.NewTransport()}
//client.Get("...")
//oauthHttpClient := &http.Client{}
bigqueryService, err := bq.New(&client)
util_err.Err_http(w, r, err, false)
fmt.Fprint(w, "s1<br>\n")
// Create a query statement and query request object
// query_data = {'query':'SELECT TOP(title, 10) as title, COUNT(*) as revision_count FROM [publicdata:samples.wikipedia] WHERE wp_namespace = 0;'}
// query_request = bigquery_service.jobs()
// Make a call to the BigQuery API
// query_response = query_request.query(projectId=PROJECT_NUMBER, body=query_data).execute()
js := bq.NewJobsService(bigqueryService)
jqc := js.Query("347979071940", &q)
fmt.Fprint(w, "s2 "+util.TimeMarker()+" <br>\n")
resp, err := jqc.Do()
util_err.Err_http(w, r, err, false)
rows := resp.Rows
var vVDest [][]byte = make([][]byte, len(rows))
c.Errorf("%#v", rows)
for i0, v0 := range rows {
cells := v0.F
b_row := new(bytes.Buffer)
b_row.WriteString(fmt.Sprintf("r%0.2d -- ", i0))
for i1, v1 := range cells {
val1 := v1.V
b_row.WriteString(fmt.Sprintf("c%0.2d: %v ", i1, val1))
}
vVDest[i0] = []byte(b_row.Bytes())
}
key_combi, _ := dsu.BufPut(w, r, dsu.WrapBlob{Name: "bq_res1", VVByte: vVDest}, "bq_res1")
dsObj, _ := dsu.BufGet(w, r, key_combi)
printPlaintextTable(w, r, dsObj.VVByte)
fmt.Fprint(w, "s3 "+util.TimeMarker()+" <br>\n")
}