func accessLog(handler http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
bufbody := new(bytes.Buffer)
bufbody.ReadFrom(req.Body)
body := bufbody.String()
line := accessLogLine{
req.RemoteAddr,
req.Header.Get("Content-Type"),
req.URL.Path,
req.URL.RawQuery,
req.Method, body, req.UserAgent(),
}
tmpl, err := template.New("line").Parse(accessLogTemplate)
if err != nil {
panic(err)
}
bufline := new(bytes.Buffer)
err = tmpl.Execute(bufline, line)
if err != nil {
panic(err)
}
logFile := fmt.Sprintf("./log/access/%d%02d%02d.log", accessTime.Year(), accessTime.Month(), accessTime.Day())
f, err := os.OpenFile(logFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
panic(err)
}
log.SetOutput(f)
log.Printf(bufline.String())
handler.ServeHTTP(w, req)
})
}
func ExampleTemplate() {
// Define a template.
const letter = `
Dear {{.Name}},
{{if .Attended}}
It was a pleasure to see you at the wedding.{{else}}
It is a shame you couldn't make it to the wedding.{{end}}
{{with .Gift}}Thank you for the lovely {{.}}.
{{end}}
Best wishes,
Josie
`
// Prepare some data to insert into the template.
type Recipient struct {
Name, Gift string
Attended bool
}
var recipients = []Recipient{
{"Aunt Mildred", "bone china tea set", true},
{"Uncle John", "moleskin pants", false},
{"Cousin Rodney", "", false},
}
// Create a new template and parse the letter into it.
t := template.Must(template.New("letter").Parse(letter))
// Execute the template for each recipient.
for _, r := range recipients {
err := t.Execute(os.Stdout, r)
if err != nil {
log.Println("executing template:", err)
}
}
// Output:
// Dear Aunt Mildred,
//
// It was a pleasure to see you at the wedding.
// Thank you for the lovely bone china tea set.
//
// Best wishes,
// Josie
//
// Dear Uncle John,
//
// It is a shame you couldn't make it to the wedding.
// Thank you for the lovely moleskin pants.
//
// Best wishes,
// Josie
//
// Dear Cousin Rodney,
//
// It is a shame you couldn't make it to the wedding.
//
// Best wishes,
// Josie
}
func uploadHandler(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case "GET":
temp, err := template.New("upload").ParseGlob("templates/*")
if err != nil {
fmt.Fprintf(w, "Error: ", err)
return
}
temp.ExecuteTemplate(w, "upload", nil)
case "POST":
fmt.Fprintf(w, "Not implemented")
}
}
func main() {
r, err := os.Open("values.json")
fatalIfError(err)
defer r.Close()
v := []Value{}
err = json.NewDecoder(r).Decode(&v)
fatalIfError(err)
valueName := func(v *Value) string {
if v.Name != "" {
return v.Name
}
return strings.Title(v.Type)
}
t, err := template.New("genvalues").Funcs(template.FuncMap{
"Lower": strings.ToLower,
"Format": func(v *Value) string {
if v.Format != "" {
return v.Format
}
return "fmt.Sprintf(\"%v\", *f)"
},
"ValueName": func(v *Value) string {
name := valueName(v)
return strings.ToLower(name[0:1]) + name[1:] + "Value"
},
"Name": valueName,
"Plural": func(v *Value) string {
if v.Plural != "" {
return v.Plural
}
return valueName(v) + "List"
},
}).Parse(tmpl)
fatalIfError(err)
w, err := os.Create("values_generated.go")
fatalIfError(err)
defer w.Close()
err = t.Execute(w, v)
fatalIfError(err)
err = exec.Command("goimports", "-w", "values_generated.go").Run()
fatalIfError(err)
}
// ConfigureMaster configures the master node.
func (k *K8s) ConfigureMaster(sshFingerprint string) error {
f, err := ioutil.TempFile("", "mcc")
if err != nil {
return err
}
t, err := template.New("cloud config").Parse(masterCloudConfig)
if err != nil {
return err
}
err = t.Execute(f, nil)
if err != nil {
return err
}
err = f.Close()
if err != nil {
return err
}
defer func() {
os.Remove(f.Name())
}()
name := fmt.Sprintf("cs-%s-master-%s", k.name, k.region)
log.Printf("booting master: %s", name)
out, err := k.doit("droplet", "create", name,
"--output", "json",
"--image", nodeImage,
"--region", k.region,
"--size", nodeSize,
"--ssh-keys", sshFingerprint,
"--user-data-file", f.Name(),
"--wait")
if err != nil {
return err
}
log.Printf("output %s\n", out)
return nil
}
// CreateWorkerKeyPair creates key pairs for workers.
func (ca *CA) CreateWorkerKeyPair(workerFQDN, workerIP string) error {
p := filepath.Join(ca.dir, "worker-openssl.cnf")
f, err := os.Create(p)
if err != nil {
return err
}
t, err := template.New("worker openssl config").Parse(workerOpensslConfig)
if err != nil {
return err
}
args := map[string]interface{}{
"WorkerIP": workerIP,
}
err = t.Execute(f, args)
if err != nil {
return err
}
key := fmt.Sprintf("%s-worker-key.pem", workerFQDN)
csr := fmt.Sprintf("%s-worker.csr", workerFQDN)
crt := fmt.Sprintf("%s-worker.pem", workerFQDN)
err = ca.openssl("genrsa", "-out", key, "2048")
if err != nil {
return err
}
err = ca.openssl("req", "-new", "-key", key,
"-out", csr, "-subj", "/CN=${WORKER_FQDN}",
"-config", "worker-openssl.cnf")
if err != nil {
return err
}
return ca.openssl("x509", "-req", "-in", csr,
"-CA", "ca.pem", "-CAkey", "ca-key.pem", "-CAcreateserial",
"-out", crt, "-days", "365",
"-extensions", "v3_req", "-extfile", "worker-openssl.cnf")
}
// This example demonstrates a custom function to process template text.
// It installs the strings.Title function and uses it to
// Make Title Text Look Good In Our Template's Output.
func ExampleTemplate_func() {
// First we create a FuncMap with which to register the function.
funcMap := template.FuncMap{
// The name "title" is what the function will be called in the template text.
"title": strings.Title,
}
// A simple template definition to test our function.
// We print the input text several ways:
// - the original
// - title-cased
// - title-cased and then printed with %q
// - printed with %q and then title-cased.
const templateText = `
Input: {{printf "%q" .}}
Output 0: {{title .}}
Output 1: {{title . | printf "%q"}}
Output 2: {{printf "%q" . | title}}
`
// Create a template, add the function map, and parse the text.
tmpl, err := template.New("titleTest").Funcs(funcMap).Parse(templateText)
if err != nil {
log.Fatalf("parsing: %s", err)
}
// Run the template to verify the output.
err = tmpl.Execute(os.Stdout, "the go programming language")
if err != nil {
log.Fatalf("execution: %s", err)
}
// Output:
// Input: "the go programming language"
// Output 0: The Go Programming Language
// Output 1: "The Go Programming Language"
// Output 2: "The Go Programming Language"
}
// CreateAPIServerKeyPair creates a keypair for the api server.
func (ca *CA) CreateAPIServerKeyPair(masterIP string) error {
p := filepath.Join(ca.dir, "openssl.cnf")
f, err := os.Create(p)
if err != nil {
return err
}
t, err := template.New("openssl config").Parse(opensslConfig)
if err != nil {
return err
}
args := map[string]interface{}{
"ServiceIP": ca.serviceIP,
"MasterHost": masterIP,
}
err = t.Execute(f, args)
if err != nil {
return err
}
err = ca.openssl("genrsa", "-out", "apiserver-key.pem", "2048")
if err != nil {
return err
}
err = ca.openssl("req", "-new", "-key", "apiserver-key.pem", "-out", "apiserver.csr",
"-subj", "/CN=kube-apiserver", "-config", "openssl.cnf")
if err != nil {
return err
}
return ca.openssl("x509", "-req", "-in", "apiserver.csr", "-CA", "ca.pem",
"-CAkey", "ca-key.pem", "-CAcreateserial", "-out", "apiserver.pem",
"-days", "365", "-extensions", "v3_req", "-extfile", "openssl.cnf")
}
// UsageForContextWithTemplate is the base usage function. You generally don't need to use this.
func (a *Application) UsageForContextWithTemplate(context *ParseContext, indent int, tmpl string) error {
width := guessWidth(a.writer)
funcs := template.FuncMap{
"Indent": func(level int) string {
return strings.Repeat(" ", level*indent)
},
"Wrap": func(indent int, s string) string {
buf := bytes.NewBuffer(nil)
indentText := strings.Repeat(" ", indent)
doc.ToText(buf, s, indentText, indentText, width-indent)
return buf.String()
},
"FormatFlag": formatFlag,
"FlagsToTwoColumns": func(f []*FlagModel) [][2]string {
rows := [][2]string{}
haveShort := false
for _, flag := range f {
if flag.Short != 0 {
haveShort = true
break
}
}
for _, flag := range f {
if !flag.Hidden {
rows = append(rows, [2]string{formatFlag(haveShort, flag), flag.Help})
}
}
return rows
},
"RequiredFlags": func(f []*FlagModel) []*FlagModel {
requiredFlags := []*FlagModel{}
for _, flag := range f {
if flag.Required == true {
requiredFlags = append(requiredFlags, flag)
}
}
return requiredFlags
},
"OptionalFlags": func(f []*FlagModel) []*FlagModel {
optionalFlags := []*FlagModel{}
for _, flag := range f {
if flag.Required == false {
optionalFlags = append(optionalFlags, flag)
}
}
return optionalFlags
},
"ArgsToTwoColumns": func(a []*ArgModel) [][2]string {
rows := [][2]string{}
for _, arg := range a {
s := "<" + arg.Name + ">"
if !arg.Required {
s = "[" + s + "]"
}
rows = append(rows, [2]string{s, arg.Help})
}
return rows
},
"FormatTwoColumns": func(rows [][2]string) string {
buf := bytes.NewBuffer(nil)
formatTwoColumns(buf, indent, indent, width, rows)
return buf.String()
},
"FormatTwoColumnsWithIndent": func(rows [][2]string, indent, padding int) string {
buf := bytes.NewBuffer(nil)
formatTwoColumns(buf, indent, padding, width, rows)
return buf.String()
},
"FormatAppUsage": formatAppUsage,
"FormatCommandUsage": formatCmdUsage,
"IsCumulative": func(value Value) bool {
r, ok := value.(remainderArg)
return ok && r.IsCumulative()
},
"Char": func(c rune) string {
return string(c)
},
}
t, err := template.New("usage").Funcs(funcs).Parse(tmpl)
if err != nil {
return err
}
var selectedCommand *CmdModel
if context.SelectedCommand != nil {
selectedCommand = context.SelectedCommand.Model()
}
ctx := templateContext{
App: a.Model(),
Width: width,
Context: &templateParseContext{
SelectedCommand: selectedCommand,
FlagGroupModel: context.flags.Model(),
ArgGroupModel: context.arguments.Model(),
},
}
return t.Execute(a.writer, ctx)
}
func main() {
kingpin.Parse()
t := template.Must(template.New("react").Funcs(template.FuncMap{
"TypeName": func(s string) string {
st, err := parser.ParseExpr(s)
kingpin.FatalIfError(err, "invalid type %q", s)
return strings.Join(typeName(st), "")
},
"IsNumeric": func(v string) bool {
switch v {
case "byte", "uint", "int", "uint8", "int8", "uint16", "int16", "uint32",
"int32", "uint64", "int64", "float32", "float64":
return true
}
return false
},
}).Parse(reactTemplate))
// We always include int. As an aside, this kind of verbosity is my
// biggest peeve with Go. 10 lines compared to basically any other
// language:
//
// if *typesArg.Contains("int") { ... }
//
// Super annoying.
found := false
for _, s := range *typesArg {
if s == "int" {
found = true
break
}
}
if !found {
*typesArg = append(*typesArg, "int")
}
cmd := exec.Command("goimports")
if *debugFlag {
cmd = exec.Command("cat")
}
outputFile := os.Stdout
if *outputFlag != "" {
dir := filepath.Dir(*outputFlag)
var err error
outputFile, err = ioutil.TempFile(dir, ".gorx-")
kingpin.FatalIfError(err, "")
defer os.Remove(outputFile.Name())
}
cmd.Stdout = outputFile
stdin, err := cmd.StdinPipe()
kingpin.FatalIfError(err, "")
kingpin.FatalIfError(cmd.Start(), "")
err = t.Execute(stdin, &Context{
Package: *packageArg,
Types: *typesArg,
Imports: *importsFlag,
MaxReplaySize: *maxReplayFlag,
})
kingpin.FatalIfError(err, "")
stdin.Close()
kingpin.FatalIfError(cmd.Wait(), "")
outputFile.Close()
if *outputFlag != "" {
kingpin.FatalIfError(os.Rename(outputFile.Name(), *outputFlag), "")
}
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, usage, os.Args[0], os.Args[0])
flag.PrintDefaults()
}
flag.Parse()
if *source == "" || *rpcType == "" {
fatalf("expected --source and --type")
}
if *target == "" {
parts := strings.Split(*source, ".")
parts = parts[:len(parts)-1]
*target = strings.Join(parts, ".") + "rpc.go"
}
fileset := token.NewFileSet()
f, err := parser.ParseFile(fileset, *source, nil, 0)
if err != nil {
fatalf("failed to parse %s: %s", *source, err)
}
imports := map[string]bool{}
if *importsFlag != "" {
for _, imp := range strings.Split(*importsFlag, ",") {
imports[imp] = true
}
}
if *packageFlag == "" {
*packageFlag = f.Name.Name
}
if *serviceName == "" {
*serviceName = *rpcType
}
gen := &RPCGen{
Service: *serviceName,
Type: *rpcType,
RPCType: *rpcClientTypeFlag,
Package: *packageFlag,
Imports: imports,
fileset: fileset,
}
ast.Walk(gen, f)
funcs := map[string]interface{}{
"publicfields": func(fields []*Type) string { return FieldList(fields, "", "\n\t", true, true) },
"refswithprefix": func(prefix string, fields []*Type) string { return FieldList(fields, prefix, ", ", false, false) },
"publicrefswithprefix": func(prefix string, fields []*Type) string { return FieldList(fields, prefix, ", ", false, true) },
"functionargs": func(fields []*Type) string { return FieldList(fields, "", ", ", true, false) },
}
t, err := template.New("rpc").Funcs(funcs).Parse(rpcTemplate)
if err != nil {
fatalf("failed to parse template: %s", err)
}
out, err := os.Create(*target)
if err != nil {
fatalf("failed to create output file %s: %s", *target, err)
}
err = t.Execute(out, gen)
if err != nil {
fatalf("failed to execute template: %s", err)
}
fmt.Printf("%s: wrote RPC stubs for %s to %s\n", os.Args[0], *rpcType, *target)
if out, err := exec.Command("go", "fmt", *target).CombinedOutput(); err != nil {
fatalf("failed to run go fmt on %s: %s: %s", *target, err, string(out))
}
}
package movieinfo
import "github.com/alecthomas/template"
var tpl = template.Must(
template.New("").
Funcs(template.FuncMap{}).
ParseGlob("templates/*.gohtml"),
)
func main() {
fmt.Printf("\n%v\n", "Starting..")
http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
w.Header().Add("Content Type", "text/html")
myTemplate := template.New("Template")
myTemplate.New("header").Parse(header)
myTemplate.New("footer").Parse(footer)
myTemplate.New("docForIteration").Parse(doc)
things := Things{
Title: "Title of MyList",
Details: []string{"A thing", "B thing", "C thing", "D thing"},
}
myTemplate.Lookup("docForIteration").Execute(w, things)
/*
if (err == nil) {
context := struct {Name string
SurName string
Url string}{Name:"Eralp", SurName:"Erat", Url:req.URL.Path}
temp.Execute(w, context)
} else {
w.Header().Add("Content Type", "text/plain")
//w.WriteHeader(404)
w.Write([]byte("Fantastic an error occured!"))
}
*/
})
go func() {
fmt.Printf("\n%v", "Started!")
}()
http.ListenAndServe(":9002", nil)
return
// it's super simple built-in file server!
http.ListenAndServe(":9001", http.FileServer(http.Dir("Public")))
return
http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
path := "Public/" + req.URL.Path
fmt.Printf("\nPATH : %v\n", path)
//try to read each calling
//data, err := ioutil.ReadFile(string(path))
//for buffering
data, err := os.Open(string(path))
if err == nil {
buffer := bufio.NewReader(data)
contentType := "text/plain"
if strings.HasSuffix(path, ".css") {
contentType = "text/css"
} else if strings.HasSuffix(path, ".html") {
contentType = "text/html"
} else if strings.HasSuffix(path, ".js") {
contentType = "application/javascript"
} else if strings.HasSuffix(path, ".png") {
contentType = "image/png"
} else if strings.HasSuffix(path, ".mp4") {
contentType = "video/mp4"
} else if strings.HasSuffix(path, ".pdf") {
contentType = "application/pdf"
}
w.Header().Add(
"Content Type", contentType,
)
//w.Write([]byte(data))
buffer.WriteTo(w)
} else {
w.WriteHeader(404)
w.Write([]byte("404 Error - Page Not Found!"))
}
})
/*
http.HandleFunc("/",new(MyHandler))
*/
http.ListenAndServe(":9001", nil)
}