Esempio n. 1
0
func main() {
	// Pull in command line options or defaults if none given
	flag.Parse()

	f, err := os.OpenFile(*skylib.LogFileName, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
	if err == nil {
		defer f.Close()
		log.SetOutput(f)
	}

	skylib.Setup(sName)

	homeTmpl = template.MustParse(homeTemplate, nil)
	respTmpl = template.MustParse(responseTemplate, nil)

	rpc.HandleHTTP()

	portString := fmt.Sprintf("%s:%d", *skylib.BindIP, *skylib.Port)

	stack := new(mango.Stack)
	stack.Address = portString

	routes := make(map[string]mango.App)
	routes["/"] = homeHandler
	routes["/new"] = submitHandler
	stack.Middleware(mango.Routing(routes))
	stack.Run(nil)
}
Esempio n. 2
0
func main() {

	var err os.Error

	// Pull in command line options or defaults if none given
	flag.Parse()

	f, err := os.OpenFile(*skylib.LogFileName, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
	if err == nil {
		defer f.Close()
		log.SetOutput(f)
	}

	skylib.Setup(sName)

	homeTmpl = template.MustParse(homeTemplate, nil)
	respTmpl = template.MustParse(responseTemplate, nil)

	http.HandleFunc("/", homeHandler)
	http.HandleFunc("/new", submitHandler)

	rpc.HandleHTTP()

	portString := fmt.Sprintf("%s:%d", *skylib.BindIP, *skylib.Port)

	err = http.ListenAndServe(portString, nil)
	if err != nil {
		log.Fatal("ListenAndServe: ", err.String())
	}
}
Esempio n. 3
0
func ShowErrors(templateString string) Middleware {
	if templateString == "" {
		templateString = `
      <html>
      <body>
        <p>
          {Error|html}
        </p>
      </body>
      </html>
    `
	}

	errorTemplate := template.MustParse(templateString, nil)

	return func(env Env, app App) (status Status, headers Headers, body Body) {
		defer func() {
			if err := recover(); err != nil {
				buffer := bytes.NewBufferString("")
				errorTemplate.Execute(buffer, struct{ Error string }{err.(string)})
				status = 500
				headers = Headers{}
				body = Body(buffer.String())
			}
		}()

		return app(env)
	}
}
Esempio n. 4
0
func parseChunk(lines []string, lesson *Lesson) *Chunk {
	ret := &Chunk{Title: lines[0], ToC: make([]*ChunkSlide, 0, 10), Lesson: lesson}
	lines = lines[1:]

	ret.DescHTML, lines = parseText(lines, false, nil)
	ret.SRSItems = getSRSItems(lines)

	cont := ""
	partNum := 0
	for len(lines) != 0 && (len(lines) != 1 || lines[0] != "") {
		if lines[0][0:7] != "\\slide:" {
			log.Panicf("Error : expected '\\slide:' directive in chunk file.")
		}
		slideTitle := lines[0][7:]
		lines = lines[1:]
		slideText, nl := parseText(lines, true, ret)
		lines = nl

		partNum++
		cont += fmt.Sprintf(`
<div class="slide" id="part%v" name="part%v">
	<h1>%v</h1>
	%v
</div>
`, partNum, partNum, slideTitle, slideText)
		ret.ToC = append(ret.ToC, &ChunkSlide{partNum, slideTitle})
	}
	// fmt.Printf(cont)		//DEBUG
	ret.Contents = template.MustParse(cont, nil)

	return ret
}
Esempio n. 5
0
File: goplay.go Progetto: ssrl/go
func init() {
	frontPage = template.New(nil)
	frontPage.SetDelims("«", "»")
	if err := frontPage.Parse(frontPageText); err != nil {
		panic(err)
	}
	output = template.MustParse(outputText, nil)
}
Esempio n. 6
0
File: views.go Progetto: tung/goblog
func loadTemplate(path string) (t *template.Template, err os.Error) {
	if buf, readErr := io.ReadFile("templates/" + path); readErr == nil {
		t = template.MustParse(string(buf), template.FormatterMap{
			"html": template.HTMLFormatter
		});
	} else {
		err = readErr
	}
	return;
}
Esempio n. 7
0
func main() {
	// Pull in command line options or defaults if none given
	flag.Parse()

	skylib.NewAgent().Start()

	homeTmpl = template.MustParse(homeTemplate, nil)
	respTmpl = template.MustParse(responseTemplate, nil)

	portString := fmt.Sprintf("%s:%d", *skylib.BindIP, *skylib.Port)

	stack := new(mango.Stack)
	stack.Address = portString

	routes := make(map[string]mango.App)
	routes["/"] = homeHandler
	routes["/new"] = submitHandler
	stack.Middleware(mango.Routing(routes))
	stack.Run(nil)
}
Esempio n. 8
0
func conventionCard(c http.ResponseWriter, p Settings) {
	fmt.Fprintln(c, `<script type="text/javascript">
function submitform() {
    document.forms["catchall"].submit();
}
</script>
`)
	e := template.MustParse(cctemplate, htmlcardformatter).Execute(p.Card(), c)
	if e != nil {
		fmt.Println("Template error:", e)
	}
}
Esempio n. 9
0
func main() {

	var err os.Error

	// Pull in command line options or defaults if none given
	flag.Parse()

	skylib.NewAgent().Start()

	homeTmpl = template.MustParse(homeTemplate, nil)
	respTmpl = template.MustParse(responseTemplate, nil)

	http.HandleFunc("/", homeHandler)
	http.HandleFunc("/new", submitHandler)

	portString := fmt.Sprintf("%s:%d", *skylib.BindIP, *skylib.Port)

	err = http.ListenAndServe(portString, nil)
	if err != nil {
		log.Fatal("ListenAndServe: ", err.String())
	}
}
Esempio n. 10
0
// getTemplate returns a template at a given filepath.
func getTemplate(filepath string) *template.Template {
	if templates[filepath] == nil {
		file, err := os.Open(template_dir+filepath, os.O_RDONLY, 0666)
		if err != nil {
			log.Exit("not exist: %s", filepath)
		}
		reader := bufio.NewReader(file)
		body, _ := reader.ReadString('~')
		tmpl := template.MustParse(body, nil)
		templates[filepath] = tmpl
	}
	return templates[filepath]
}
Esempio n. 11
0
func conventionCard(p Settings) string {
	buf := bytes.NewBuffer(make([]byte, 0, 4*1024))
	fmt.Fprint(buf, `<script type="text/javascript">
function submitform() {
    document.forms["catchall"].submit();
}
</script>
`)
	e := template.MustParse(cctemplate, htmlcardformatter).Execute(p.Card(), buf)
	if e != nil {
		fmt.Fprintln(buf, "<h3>Template error:", e, `</h3>`)
	}
	return buf.String()
}
Esempio n. 12
0
File: gortfm.go Progetto: nsf/gortfm
func writePackagePage(pkgname string) {
	// TODO: I/O error checks
	pkgfilename := strings.Replace(pkgname, "/", "_", -1)
	dest := path.Join(*optOutDir, pkgfilename+".html")

	f, err := os.Create(dest)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	defer f.Close()
	bf := bufio.NewWriter(f)

	var packageTemplate = template.MustParse(packageTemplateStr, nil)

	tplparams := map[string]string{
		"pkgname":  pkgname,
		"datafile": "gortfm-" + pkgfilename + "-data.js",
	}
	packageTemplate.Execute(bf, tplparams)
	bf.Flush()
}
Esempio n. 13
0
func serveError(req *web.Request, status int, reason os.Error, header web.Header) {
	header.Set(web.HeaderContentType, "text/plain; charset=utf-8")
	w := req.Responder.Respond(status, header)
	io.WriteString(w, web.StatusText(status))
	if reason != nil {
		io.WriteString(w, "\n")
		io.WriteString(w, reason.String())
	}
}

var mainPage = template.MustParse(`<html><body>
{.repeated section gg}
{.section Author}<b>{@|html}</b>{.or}An anonymous person{.end}
wrote <blockquote>{Content|html}</blockquote>
{.end}
<form action="/sign" method="POST">
<div><input type="hidden" name="xsrf" value="{xsrf}"> <textarea name="content" rows="3" cols="60"></textarea></div>
<div><input type="submit" value="Sign Guestbook"></div>
</form></body></html>`,
	nil)

func handleMainPage(r *web.Request) {
	c := gae.Context(r)
	q := datastore.NewQuery("Greeting").Order("-Date").Limit(10)
	var gg []*Greeting
	_, err := q.GetAll(c, &gg)
	if err != nil {
		r.Error(web.StatusInternalServerError, err)
		return
	}
	w := r.Respond(200, "Content-Type", "text/html")
Esempio n. 14
0
File: make.go Progetto: ssrl/go
var makefileTemplate = template.MustParse(`
include $(GOROOT)/src/Make.inc

TARG={Targ}
TARGDIR={TargDir}

{.section GoFiles}
GOFILES=\
{.repeated section @}
	{@}\
{.end}

{.end}
{.section OFiles}
OFILES=\
{.repeated section @}
	{@}\
{.end}

{.end}
{.section CgoFiles}
CGOFILES=\
{.repeated section @}
	{@}\
{.end}

{.end}
{.section CgoOFiles}
CGO_OFILES=\
{.repeated section @}
	{@}\
{.end}

{.end}
GCIMPORTS={.repeated section Imports}-I "{@}" {.end}
LDIMPORTS={.repeated section Imports}-L "{@}" {.end}

include $(GOROOT)/src/Make.{Type}
`,
	nil)
Esempio n. 15
0
<html>
<body>
<h1>Who is on it?</h1>
<h2>Current Emails</h2>
<ul>
{.repeated section @}
  <li><a href="/show?sender={Sender}&date={RecieptDate}">{Sender} - {Subject} - {RecieptDate}</a></li>
{.or}
Nothing to do. Good job.
{.end}
</ul>
</body>
</html>
`

var rootTemplate = template.MustParse(root_template, nil)

const show_template = `
<html>
<body>
{.repeated section @}
<h1>{Subject|html}</h1>
<h2>{Sender}</h2>
<h3>Status</h3>
<p>Received: {RecieptDate}</p>
<p>Owner: {.section Owner}{Owner}</p>
<p>Accepted On: {OwnerDate}{.or}Nobody{.end}</p>
{.section ClosedDate}
<p>Closed On: {ClosedDate}</p>
{.end}
<h3>Message Content</h3>
Esempio n. 16
0
	oauthClient.Credentials.Secret = m["ClientSecret"].(string)
}

func main() {
	flag.Parse()
	readSettings()
	h := web.FormHandler(10000, true, web.NewRouter().
		Register("/", "GET", home).
		Register("/login", "GET", login).
		Register("/callback", "GET", authCallback))

	server.Run(":8080", h)
}

var fmap = template.FormatterMap{"": template.HTMLFormatter}
var homeLoggedOutTempl = template.MustParse(homeLoggedOutStr, fmap)

const homeLoggedOutStr = `
<html>
<head>
</head>
<body>
<a href="/login"><img src="http://a0.twimg.com/images/dev/buttons/sign-in-with-twitter-d.png"></a>
</body>
</html>`

var homeTempl = template.MustParse(homeStr, fmap)

const homeStr = `
<html>
<head>
Esempio n. 17
0
	files, _, err := goFiles(dir)
	if err != nil {
		return nil, err
	}

	var buf bytes.Buffer
	if err := makefileTemplate.Execute(&makedata{pkg, files}, &buf); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// makedata is the data type for the makefileTemplate.
type makedata struct {
	pkg   string   // package import path
	files []string // list of .go files
}

var makefileTemplate = template.MustParse(`
include $(GOROOT)/src/Make.$(GOARCH)

TARG={pkg}
GOFILES=\
{.repeated section files}
	{@}\
{.end}

include $(GOROOT)/src/Make.pkg
`,
	nil)
Esempio n. 18
0
		"xsrf":    req.Param.GetDef(web.XSRFParamName, ""),
	},
		req.Respond(status, web.HeaderContentType, "text/html"))
}

func coreHandler(req *web.Request) {
	coreTempl.Execute(map[string]interface{}{
		"req":     req,
		"status":  web.StatusOK,
		"message": "ok",
		"xsrf":    req.Param.GetDef(web.XSRFParamName, ""),
	},
		req.Respond(web.StatusOK, web.HeaderContentType, "text/html"))
}

var coreTempl = template.MustParse(coreStr, nil)

const coreStr = `
<html>
<head>
<title>Core</title>
</head>
<body>
<hr>
Status: {status} {message}
<hr>
<a href="/core">/core</a><br>
<a href="/core/a/blorg">/core/a/blorg</a><br>
<a href="/core/a/foo?b=bar&amp;c=quux">/core/a/foo?b=bar&amp;c=quux</a><br>
<a href="/core/a/blorg/">/core/a/blorg/</a><br>
<a href="/core/b/foo/c/bar">/core/b/foo/c/bar</a><br> 
Esempio n. 19
0
			"status":  status,
			"message": reason,
			"xsrf":    req.Param.Get(web.XSRFParamName),
		})
}

func coreHandler(req *web.Request) {
	coreTempl.Execute(
		req.Respond(web.StatusOK, web.HeaderContentType, "text/html"),
		map[string]interface{}{
			"req":     req,
			"status":  web.StatusOK,
			"message": "ok",
			"xsrf":    req.Param.Get(web.XSRFParamName),
		})
}

var coreTempl = template.MustParse(coreStr, template.FormatterMap{"": template.HTMLFormatter})

const coreStr = `
<html>
<head>
<title>Gopher Times</title>
</head>
<body>
<hr>
Status: {status} {message}
We're sorry, but there was a problem fulfilling your request.
</body>
</html> `
Esempio n. 20
0
import (
	"doozer/store"
	"doozer/util"
	"http"
	"io"
	"json"
	"log"
	"net"
	"strings"
	"template"
	"websocket"
)

var Store *store.Store
var ClusterName, evPrefix string
var mainTpl = template.MustParse(main_html, nil)

type info struct {
	Path string
}

type stringHandler struct {
	contentType string
	body        string
}

func (sh stringHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.SetHeader("content-type", sh.contentType)
	io.WriteString(w, sh.body)
}
	q := datastore.NewQuery("Log").Order("-Date").Limit(10)
	greetings := make([]Log, 0, 10)
	if _, err := q.GetAll(c, &greetings); err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	}
	if err := guestbookTemplate.Execute(w, greetings); err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
	}
}

func dstimeFormatter(wr io.Writer, formatter string, dstime ...interface{}) {
	io.WriteString(wr, time.SecondsToUTC(int64(dstime[0].(datastore.Time))/1000000).Format(time.RFC1123))
}

var guestbookTemplate = template.MustParse(guestbookTemplateHTML, template.FormatterMap{"dstime": dstimeFormatter})

const guestbookTemplateHTML = `
<html>
  <body>
   <ul>
    {.repeated section @}
     <li>
      {.section User}
        <b>{@|html}</b> accessed at: 
      {.or}
        An anonymous person FOOBAZED at: 
      {.end}
      {Date|dstime|html} from {RemoteAddress|html}
    {.end}
   </ul>
Esempio n. 22
0
func loadExtendedTemplate(dir, name string) *template.Template {
	t := &extendedTemplate{dir, make(map[string][]string), make(map[string]bool)}
	t.load(name)
	contents := t.resolve("main")
	return template.MustParse(contents, nil)
}
Esempio n. 23
0
func main() {
	sqlite3.Initialize()
	defer func() {
		log.Stdout("closing sqlite3")
		sqlite3.Shutdown()
	}()

	dbh := new(sqlite3.Handle)
	dbh.Open("bbs.db")
	defer dbh.Close()

	InitTables(dbh)

	flag.Parse()
	templ := func() *template.Template {
		templateStr, err := io.ReadFile("tmpl/top.tmpl")
		if err != nil {
			log.Exit(err)
		}
		return template.MustParse(string(templateStr), nil)
	}()

	http.Handle("/", http.HandlerFunc(func(c *http.Conn, req *http.Request) {
		params := new(struct{ msgs []string })
		storage := new(vector.StringVector)
		func() {
			st, err := dbh.Prepare("SELECT * from entry ORDER BY id DESC limit 30;")
			func() {
				if err != "" {
					log.Exit(err)
				}
				for {
					rv := st.Step()
					switch {
					case rv == sqlite3.SQLITE_DONE:
						return
					case rv == sqlite3.SQLITE_ROW:
						body := st.ColumnText(1)
						storage.Push(body)
					default:
						println(rv)
						log.Exit(dbh.ErrMsg())
					}
				}
			}()
			if st.Finalize() != sqlite3.SQLITE_OK {
				log.Exit(dbh.ErrMsg())
			}
		}()
		params.msgs = storage.Data()
		err := templ.Execute(params, c)
		if err != nil {
			log.Exit("templ.Execute:", err)
		}
	}))
	http.Handle("/post", http.HandlerFunc(func(c *http.Conn, req *http.Request) {
		req.ParseForm()

		body := req.Form["body"][0]
		st, err := dbh.Prepare("INSERT INTO entry (body) VALUES (?)")
		if err != "" {
			log.Exit(err)
		}
		if st.BindText(1, body) != sqlite3.SQLITE_OK {
			log.Exit("cannot bind: ", dbh.ErrMsg())
		}
		if st.Step() != sqlite3.SQLITE_DONE {
			log.Exit(dbh.ErrMsg())
		}
		if st.Finalize() != sqlite3.SQLITE_OK {
			log.Exit(dbh.ErrMsg())
		}

		http.Redirect(c, "/", 302)
	}))
	http.Handle("/css/", http.HandlerFunc(func(c *http.Conn, req *http.Request) {
		http.ServeFile(c, req, "."+req.URL.Path)
	}))

	// run httpd
	func() {
		fmt.Printf("http://%s/\n", *addr)
		err := http.ListenAndServe(*addr, nil)
		if err != nil {
			log.Exit("ListenAndServe:", err)
		}
	}()
}
Esempio n. 24
0
package main

import (
	"flag"
	"http"
	"io"
	"log"
	"template"
)

var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18
var fmap = template.FormatterMap{
	"html":     template.HTMLFormatter,
	"url+html": UrlHtmlFormatter,
}
var templ = template.MustParse(templateStr, fmap)

func main() {
	flag.Parse()
	http.Handle("/", http.HandlerFunc(QR))
	err := http.ListenAndServe(*addr, nil)
	if err != nil {
		log.Fatal("ListenAndServe:", err)
	}
}

func QR(w http.ResponseWriter, req *http.Request) {
	templ.Execute(w, req.FormValue("s"))
}

func UrlHtmlFormatter(w io.Writer, fmt string, v ...interface{}) {
Esempio n. 25
0
					Register("/core/a/<a>/", "GET", coreHandler).
					Register("/core/b/<b>/c/<c>", "GET", coreHandler).
					Register("/core/c", "POST", coreHandler)))))

	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		log.Fatal("Listen", err)
		return
	}
	defer listener.Close()
	err = (&server.Server{Listener: listener, Handler: h, Logger: server.LoggerFunc(server.VerboseLogger)}).Serve()
	if err != nil {
		log.Fatal("Server", err)
	}
}

var homeTempl = template.MustParse(homeStr, template.FormatterMap{"": template.HTMLFormatter})

const homeStr = `
<html>
<head>
</head>
<body>
<ul>
<li><a href="/core">Core functionality</a>
<li><a href="/chat">Chat using WebSockets</a>
<li><a href="/mp">Multipart Form</a>
</ul>
</body>
</html>`
Esempio n. 26
0
	"io"
	"os"
	"template"

	"appengine"
	"appengine/blobstore"
)

func serveError(c appengine.Context, w http.ResponseWriter, err os.Error) {
	w.WriteHeader(http.StatusInternalServerError)
	w.Header().Set("Content-Type", "text/plain")
	io.WriteString(w, "Internal Server Error")
	c.Errorf("%v", err)
}

var rootTemplate = template.MustParse(rootTemplateHTML, nil)

const rootTemplateHTML = `
<html><body>
<form action="{@}" method="POST" enctype="multipart/form-data">
Upload File: <input type="file" name="file"><br>
<input type="submit" name="submit" value="Submit">
</form></body></html>
`

func handleRoot(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	uploadURL, err := blobstore.UploadURL(c, "/upload", nil)
	if err != nil {
		serveError(c, w, err)
		return
Esempio n. 27
0
	Service {Name}
	<hr>
		<table>
		<th align=center>Method</th><th align=center>Calls</th>
		{.repeated section Method}
			<tr>
			<td align=left font=fixed>{Name}({Type.ArgType}, {Type.ReplyType}) os.Error</td>
			<td align=center>{Type.NumCalls}</td>
			</tr>
		{.end}
		</table>
	{.end}
	</body>
	</html>`

var debug = template.MustParse(debugText, nil)

type debugMethod struct {
	Type *methodType
	Name string
}

type methodArray []debugMethod

type debugService struct {
	Service *service
	Name    string
	Method  methodArray
}

type serviceArray []debugService
Esempio n. 28
0
	"http"
	"io"
	"json"
	"log"
	"net"
	"runtime"
	"strings"
	"template"
	"websocket"
)

var Store *store.Store
var ClusterName string

var (
	mainTpl  = template.MustParse(main_html, nil)
	statsTpl = template.MustParse(stats_html, nil)
)

type info struct {
	Name string
	Path string
}

type stringHandler struct {
	contentType string
	body        string
}

func (sh stringHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("content-type", sh.contentType)
Esempio n. 29
0
// TODO: cache strategy
// TODO: learn best practice for reading template file into string and parsing
// TODO: check error from ReadFile
// TODO: synchronized cache for multithreading
func get_template(s string) *template.Template {
	var templateBytes, _ = io.ReadFile(s);
	var templateBuffer = bytes.NewBuffer(templateBytes);
	var templateStr = templateBuffer.String();
	return template.MustParse(templateStr, fmap);
}
Esempio n. 30
0
var homePage = template.MustParse(
	page(
		"Go Paste!",
		Div(
			Form(
				Fieldset(
					Textarea("").Attrs(As{
						"class": "paste-input",
						"rows":  "30",
						"name":  "code",
					}),
					Ul(
						Li(
							A("All Pastes").Attrs(As{
								"href": "/all",
							})),
						Li(
							A("Source Code").Attrs(As{
								"href": "http://github.com/vito/go-play/tree/master/gopaste",
							})),
						Li(""),
						Li("Tab key inserts tabstops."),
						Li("Seperate content with ---."),
						Li("Mod+S to submit."),
						Li(
							Input().Attrs(As{
								"type":  "checkbox",
								"class": "paste-private",
								"name":  "private",
							}),
							"Private")).Attrs(As{
						"class": "paste-notes",
					}),
					Input().Attrs(As{
						"class":     "paste-submit",
						"type":      "submit",
						"value":     "Go Paste!",
						"accesskey": "s",
					}))).Attrs(As{
				"action": "/add",
				"method": "POST",
			})).Attrs(As{
			"id": "home",
		})),
	fmap)