oration 0.0.2 → 0.0.3

data/templates/main.go

@@ -0,0 +1,210 @@
+// BEGIN CICERO-BOILERPLATE CODE
+package CICERO_PKG_NAME
+
+import (
+	"appengine"
+	"appengine/datastore"
+	"appengine/taskqueue"
+	"fmt"
+	"http"
+	"json"
+	"time"
+)
+
+type TaskInfo struct {
+	State     string
+	StartTime datastore.Time
+	EndTime   datastore.Time
+}
+
+type Text struct {
+	Content string
+}
+
+func init() {
+	http.HandleFunc("/task", taskRoute)
+	http.HandleFunc("/data", dataRoute)
+	http.HandleFunc("/compute", computeWorker)
+	http.HandleFunc("/", index)
+}
+
+func taskRoute(w http.ResponseWriter, r *http.Request) {
+	c := appengine.NewContext(r)
+
+	if r.Method == "GET" {
+		keyName := r.FormValue("task_id")
+		key := datastore.NewKey(c, "TaskInfo", keyName, 0, nil)
+		taskInfo := new(TaskInfo)
+		if err := datastore.Get(c, key, taskInfo); err == nil {
+			result := map[string]string{
+				"result": "success",
+				"state":  taskInfo.State,
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		} else {
+			result := map[string]string{
+				"result": "failure",
+				"state":  "not found",
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		}
+	} else if r.Method == "PUT" {
+		inputSource := r.FormValue("input1")
+		output := r.FormValue("output")
+		params := map[string][]string{
+			"input1": {inputSource},
+			"output": {output},
+		}
+
+		task := taskqueue.NewPOSTTask("/compute", params)
+		if newTask, err := taskqueue.Add(c, task, ""); err == nil {
+			result := map[string]string{
+				"result":  "success",
+				"task_id": newTask.Name,
+				"output":  output,
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		} else {
+			result := map[string]string{
+				"result": "failure",
+				"reason": err.String(),
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		}
+	} else {
+		// TODO - support deletion of tasks
+		http.Error(w, "method not supported", http.StatusInternalServerError)
+		return
+	}
+}
+
+func dataRoute(w http.ResponseWriter, r *http.Request) {
+	c := appengine.NewContext(r)
+
+	if r.Method == "GET" {
+		keyName := r.FormValue("location")
+
+		key := datastore.NewKey(c, "Text", keyName, 0, nil)
+		output := new(Text)
+		if err := datastore.Get(c, key, output); err != nil {
+			result := map[string]string{
+				"result": "failure",
+				"reason": err.String(),
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		}
+
+		if output.Content == "" {
+			result := map[string]string{
+				"result": "failure",
+				"reason": "key did not exist",
+			}
+
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		} else {
+			result := map[string]string{
+				"result": "success",
+				"output": output.Content,
+			}
+
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		}
+	} else if r.Method == "PUT" {
+		keyName := r.FormValue("location")
+		key := datastore.NewKey(c, "Text", keyName, 0, nil)
+		text := Text{
+			Content: r.FormValue("text"),
+		}
+		key, err := datastore.Put(c, key, &text)
+		if err == nil {
+			result := map[string]string{
+				"result": "success",
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		} else {
+			result := map[string]string{
+				"result": "failure",
+				"reason": err.String(),
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		}
+	} else if r.Method == "DELETE" {
+		keyName := r.FormValue("location")
+
+		key := datastore.NewKey(c, "Text", keyName, 0, nil)
+		err := datastore.Delete(c, key)
+
+		if err == nil {
+			result := map[string]string{
+				"result": "success",
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		} else {
+			result := map[string]string{
+				"result": "failure",
+				"reason": fmt.Sprintf("%s", err),
+			}
+			fmt.Fprintf(w, "%s", mapToJson(result))
+			return
+		}
+	} else {
+		http.Error(w, "method not supported", http.StatusInternalServerError)
+		return
+	}
+}
+
+func computeWorker(w http.ResponseWriter, r *http.Request) {
+	c := appengine.NewContext(r)
+
+	outputDest := r.FormValue("output")
+
+	keyName := outputDest // TODO - this should use the task id, not the output location
+	key := datastore.NewKey(c, "TaskInfo", keyName, 0, nil)
+
+	taskInfo := TaskInfo{
+		State:     "started",
+		StartTime: datastore.SecondsToTime(time.Seconds()),
+	}
+
+	datastore.Put(c, key, &taskInfo)
+
+	outputTextKeyName := outputDest
+	outputTextKey := datastore.NewKey(c, "Text", outputTextKeyName, 0, nil)
+	outputText := Text{
+		Content: CICERO_FUNCTION_NAME(),
+	}
+	datastore.Put(c, outputTextKey, &outputText)
+
+	datastore.Get(c, key, &taskInfo)
+	taskInfo.State = "finished"
+	taskInfo.EndTime = datastore.SecondsToTime(time.Seconds())
+	datastore.Put(c, key, &taskInfo)
+}
+
+func index(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprint(w, "Hello, world!")
+}
+
+func mapToJson(mapToConvert map[string]string) []byte {
+	jsonResult, err := json.Marshal(mapToConvert)
+	if err != nil {
+		fmt.Printf("json marshalling saw error: %s\n", err)
+	}
+
+	return jsonResult
+}
+
+// END CICERO-BOILERPLATE CODE
+// BEGIN USER-PROVIDED FUNCTION
+CICERO_FUNCTION_CONTENTS
+// END USER-PROVIDED FUNCTION

data/templates/main.py

@@ -0,0 +1,160 @@
+##### BEGIN CICERO-BOILERPLATE CODE  #####
+try:
+  import simplejson as json
+except ImportError:
+  import json
+
+import datetime
+import logging
+import os
+import StringIO
+import wsgiref.handlers
+
+from google.appengine.api import taskqueue
+
+from google.appengine.ext import db
+from google.appengine.ext import webapp
+from google.appengine.ext.webapp import template
+from google.appengine.ext.webapp import util
+
+import CICERO_PACKAGE_NAME
+
+
+class TaskInfo(db.Model):
+  state = db.StringProperty()
+  start_time = db.DateTimeProperty()
+  end_time = db.DateTimeProperty()
+
+
+class Text(db.Model):
+  content = db.TextProperty()
+
+
+class TaskRoute(webapp.RequestHandler):
+  def get(self):
+    key_name = self.request.get('task_id')
+    task_info = TaskInfo.get_by_key_name(key_name)
+    result = {} # TODO - see if we can remove that
+    try:
+      result = {'result':'success', 'state':task_info.state}
+    except AttributeError:
+      result = {'result':'failure', 'state':'not found'}
+
+    self.response.out.write(json.dumps(result))
+
+  def put(self):
+    allowed_routes = ['CICERO_FUNCTION_NAME']
+    function = self.request.get('f')
+    input_source = self.request.get('input1')
+    json_data = {'f':function, 'input1':input_source}
+
+    output = ''
+    if self.request.get('output') == '':
+      key_length = 16  # for now, randomly generates keys 16 chars long
+      json_data['output'] = os.urandom(key_length)  # TODO - does this work in app engine?
+    else:
+      json_data['output'] = str(self.request.get('output'))
+    output = str(json_data['output'])
+
+    if function in allowed_routes:
+      url = '/' + function
+      logging.debug('starting a request for url ' + url)
+      new_task = taskqueue.add(url=url, params={'data': json.dumps(json_data)})
+      # TODO - adding the task does not imply success - when does it not?
+      result = {'result':'success', 'task_id':new_task.name, 'output':output}
+      logging.debug('result of job with input data' + str(json_data) + ' was ' + str(result))
+      self.response.out.write(json.dumps(result))
+    else:
+      reason = 'Cannot add a task for function type ' + str(function)
+      result ={'result':'failure', 'reason':reason}
+      self.response.out.write(json.dumps(result))
+
+  def delete(self):
+    task_id = self.request.get('task_id')
+    task = taskqueue.Task(name=task_id)
+    q = taskqueue.Queue()
+    cancel_info = q.delete_tasks(task)
+    logging.debug('cancel_info is ' + str(cancel_info))
+    result = {'result':'unknown', 'reason':str(cancel_info)}
+    self.response.out.write(result)
+
+
+class DataRoute(webapp.RequestHandler):
+  def get(self):
+    key_name = self.request.get('location')
+    output = Text.get_by_key_name(key_name)
+    result = {} # TODO - see if we can remove that
+    try:
+      result = {'result':'success', 'output':output.content}
+    except AttributeError:
+      result = {'result':'failure', 'reason':'key did not exist'}
+
+    self.response.out.write(json.dumps(result))
+
+  def put(self):
+    key_name = self.request.get('location')
+    output = Text(key_name = key_name)
+    output.content = self.request.get('text')
+    output.put()
+
+    result = {'result':'success'}
+    self.response.out.write(json.dumps(result))
+
+  def delete(self):
+    key_name = self.request.get('location')
+
+    text = Text(key_name = key_name)
+    result = {}
+    try:
+      text.delete()
+      result = {'result':'success'}
+    except Exception:
+      result = {'result':'failure', 'reason':'exception was thrown'} # TODO get the name of the exception here
+
+    self.response.out.write(result)
+
+
+class ComputeWorker(webapp.RequestHandler):
+  def post(self):
+    raw_data = self.request.get('data')
+    json_data = json.loads(raw_data)
+    input_source = str(json_data['input1'])
+    output_dest = str(json_data['output'])
+
+    # TODO - this should use the task id, not the output location
+    task_info = TaskInfo(key_name = output_dest)
+    task_info.state = "started"
+    task_info.start_time = datetime.datetime.now()
+    task_info.put()
+
+    output_text = Text(key_name = output_dest)
+    output_text.content = str(CICERO_PACKAGE_AND_FUNCTION_NAME())
+    output_text.put()
+
+    task_info = TaskInfo.get_by_key_name(output_dest)
+    task_info.state = "finished"
+    task_info.end_time = datetime.datetime.now()
+    task_info.put()
+
+
+class IndexPage(webapp.RequestHandler):
+  def get(self):
+    # TODO(cgb): write something nicer about oration here!
+    self.response.out.write("hello!")
+
+def main():
+  logging.getLogger().setLevel(logging.DEBUG)
+  application = webapp.WSGIApplication([('/task', TaskRoute),
+                                        ('/data', DataRoute),
+                                        ('/CICERO_FUNCTION_NAME', ComputeWorker),
+                                        ('/', IndexPage),
+                                        ],
+                                        debug=True)
+  util.run_wsgi_app(application)
+
+
+if __name__ == '__main__':
+  main()
+
+
+##### END CICERO-BOILERPLATE CODE  #####

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: oration
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Chris Bunch
@@ -15,7 +15,7 @@ autorequire: oration
 bindir: bin
 cert_chain: []
 
-date: 2012-01-22 00:00:00 -08:00
+date: 2012-01-25 00:00:00 -08:00
 default_executable: oration
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -80,6 +80,8 @@ files:
 - test/test_generator.rb
 - test/test_oration.rb
 - test/ts_all.rb
+- templates/main.go
+- templates/main.py
 - LICENSE
 has_rdoc: true
 homepage: http://appscale.cs.ucsb.edu