func common(t *template.Template) (*template.Template, error) {
return t.Parse(`
{{ define "header" }}
// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
// Package {{ .PackageName }} provides a client for {{ .FullName }}.
package {{ .PackageName }}
import (
"net/http"
"time"
"github.com/awslabs/aws-sdk-go/aws"
"github.com/awslabs/aws-sdk-go/gen/endpoints"
)
{{ end }}
{{ define "footer" }}
// avoid errors if the packages aren't referenced
var _ time.Time
{{ end }}
`)
}
func loadTemplateInto(fs vfs.Opener, tpl *template.Template, fName string) (*template.Template, error) {
src, err := templateSource(fs, fName)
if err != nil {
return nil, err
}
return tpl.Parse(src)
}
// formatErrorDescription takes a string in the default text/template
// format and converts it to a string with replacements. The fields come
// from the ErrorDetails struct and vary for each type of error.
func formatErrorDescription(s string, details ErrorDetails) string {
var tpl *template.Template
var descrAsBuffer bytes.Buffer
var err error
if errorTemplates == nil {
errorTemplates = template.New("all-errors")
}
tpl = errorTemplates.Lookup(s)
if tpl == nil {
tpl = errorTemplates.New(s)
tpl, err = tpl.Parse(s)
if err != nil {
return err.Error()
}
}
err = tpl.Execute(&descrAsBuffer, details)
if err != nil {
return err.Error()
}
return descrAsBuffer.String()
}
func parseFromFile(t *template.Template, fname string) (*template.Template, error) {
buf, err := ioutil.ReadFile(fname)
if err != nil {
return nil, err
}
return t.Parse(string(buf))
}
func Render(templateName string, options interface{}) (string, error) {
asset, err := Asset(templateName)
if err != nil {
return "", maskAny(err)
}
// parse template
var tmpl *template.Template
tmpl = template.New(templateName)
funcMap := template.FuncMap{
"escape": escape,
"quote": strconv.Quote,
"yamlPrefix": yamlPrefix,
}
tmpl.Funcs(funcMap)
_, err = tmpl.Parse(string(asset))
if err != nil {
return "", maskAny(err)
}
// write file to buffer
tmpl.Funcs(funcMap)
buffer := &bytes.Buffer{}
err = tmpl.Execute(buffer, options)
if err != nil {
return "", maskAny(err)
}
return buffer.String(), nil
}
func (ctx *TemplateContext) Transform(writer io.Writer, descriptor string) error {
var t *template.Template
if b, err := ioutil.ReadFile(descriptor); err != nil {
return err
} else {
var e error
t = template.New(descriptor).Funcs(Funcs)
t, e = t.Parse(string(b))
if e != nil {
return e
}
if matches, err := filepath.Glob("./**/*.tmpl"); err == nil && len(matches) > 0 {
if t, e = t.ParseFiles(matches...); err != nil {
return err
}
}
}
environment := viper.GetString(ENV_NAME)
m := ctx.mergeAppWithDefault(strings.ToLower(environment))
if err := t.Execute(writer, m); err != nil {
return err
}
return nil
}
// Render updates the given destinationPath according to the given template and options.
// Returns true if the file was created or changed, false if nothing has changed.
func Render(templateName, destinationPath string, options interface{}, destinationFileMode os.FileMode) (bool, error) {
asset, err := Asset(templateName)
if err != nil {
return false, maskAny(err)
}
// parse template
var tmpl *template.Template
tmpl = template.New(templateName)
funcMap := template.FuncMap{
"escape": escape,
"quote": strconv.Quote,
}
tmpl.Funcs(funcMap)
_, err = tmpl.Parse(string(asset))
if err != nil {
return false, maskAny(err)
}
// execute template to buffer
buf := &bytes.Buffer{}
tmpl.Funcs(funcMap)
err = tmpl.Execute(buf, options)
if err != nil {
return false, maskAny(err)
}
// Update file
changed, err := util.UpdateFile(destinationPath, buf.Bytes(), destinationFileMode)
return changed, maskAny(err)
}
func reload(ctx dingo.Context, t *template.Template, v []View) error {
for _, view := range v {
if err := reload(ctx, t, view.Extensions()); err != nil {
return err
} else if t, err = t.Parse(string(view.Data(ctx))); err != nil {
log.Printf("Failed to parse extension: (%s)\n%s\n", view.Name(), err)
}
}
return nil
}
// LoadText loads a template from a possibly inlined VFS as an associated template to the parent
func LoadTextOnto(fs vfs.Opener, parent *txttmpl.Template, tName, fName string) (*txttmpl.Template, error) {
src, err := templateSource(fs, fName)
if err != nil {
return nil, err
}
var tpl *txttmpl.Template
if parent == nil {
tpl = txttmpl.New(tName)
} else {
tpl = parent.New(tName)
}
return tpl.Parse(src)
}
func (m *Migrator) evalMigration(tmpl *template.Template, sql string) (string, error) {
tmpl, err := tmpl.Parse(sql)
if err != nil {
return "", err
}
var buf bytes.Buffer
err = tmpl.Execute(&buf, m.Data)
if err != nil {
return "", err
}
return buf.String(), nil
}
func addTemplate(t *template.Template, tname, fname string) (*template.Template, error) {
buf, err := ioutil.ReadFile(fname)
if err != nil {
return nil, err
}
var nt *template.Template
if t != nil {
nt = t.New(tname)
} else {
nt = template.New(tname)
}
return nt.Parse(string(buf))
}
/*
** Render a template string with given data
*/
func ParseTemplate(tmpl string, data metadata.Metamap) (string, error) {
var buf bytes.Buffer
var tpl *template.Template
tpl = createTemplate()
tpl, err := tpl.Parse(tmpl)
if err != nil {
return "", err
}
err = tpl.Execute(&buf, data)
if err != nil {
return "", err
}
return buf.String(), nil
}
// Parse parses declared templates.
func Parse(t *template.Template) (*template.Template, error) {
for name, s := range templates {
var tmpl *template.Template
if t == nil {
t = template.New(name)
}
if name == t.Name() {
tmpl = t
} else {
tmpl = t.New(name)
}
if _, err := tmpl.Parse(s); err != nil {
return nil, err
}
}
return t, nil
}
func packTemplate(tplPack *template.Template, name string) (tpl *template.Template) {
cwd, err := os.Getwd()
M.PANIC_ON_ERR(err)
f, err := os.Open(fmt.Sprintf("%s/%s.html", path.Join(cwd, "templates"), name))
M.PANIC_ON_ERR(err)
defer f.Close()
html, err := ioutil.ReadAll(f)
M.PANIC_ON_ERR(err)
tpl, err = tplPack.Parse(string(html))
M.PANIC_ON_ERR(err)
return
}
func parseData(temp *template.Template, reader io.ReadCloser) (*template.Template, error) {
data, err := ioutil.ReadAll(reader)
if err != nil {
return temp, err
}
reader.Close()
if len(data) > 0 {
if temp == nil {
x := template.New("new")
x.Parse(string(data))
return x, nil
} else {
temp.Parse(string(data))
return temp, nil
}
}
return temp, fmt.Errorf("no data")
}
func CreateTemplate(name string, allTemplates []string, funcMap template.FuncMap) (*template.Template, error) {
var (
tmpl *template.Template
err error
)
leading := regexp.MustCompile("(\n)?[ \t]*[{]{2}[-][ ]*")
trailing := regexp.MustCompile("[ ]*[-][}]{2}[ \t]*(\n)?")
tmpl = template.New(name).Funcs(funcMap)
for _, code := range allTemplates {
code = leading.ReplaceAllString(code, "{{")
code = trailing.ReplaceAllString(code, "}}")
tmpl, err = tmpl.Parse(code)
if err != nil {
return nil, err
}
}
return tmpl, nil
}
//loadTemplate 加载解析模板
func (d *dynamic) loadTemplate(currDir string) (*template.Template, error) {
if len(d.Template) == 0 {
return nil, fmt.Errorf(ErrorPageNotTemplate)
}
var (
t *template.Template = nil
filePath, fileName, content string
b []byte
err error
)
for _, filename := range d.Template {
filePath = filepath.Join(currDir, filename)
fileName = filepath.Base(filename)
b, err = ioutil.ReadFile(filePath)
if err != nil {
return nil, err
}
content = d.formatTemplate(string(b))
var tmpl *template.Template
if t == nil {
t = template.New(fileName)
}
if fileName == t.Name() {
tmpl = t
} else {
tmpl = t.New(fileName)
}
tmpl.Delims(d.Delims.Left, d.Delims.Right)
tmpl.Funcs(TemplateFuncMap)
_, err = tmpl.Parse(content)
if err != nil {
return nil, err
}
}
return t, nil
}
// GetTemplate is used to get a ready to use template based on the url and on
// other sent templates
func GetTemplate(r *http.Request, functions template.FuncMap, templates ...string) (*template.Template, error) {
// If this is a pjax request, use the minimal template to send only
// the main content
if r.Header.Get("X-PJAX") == "true" {
templates = append(templates, "base_minimal")
} else {
templates = append(templates, "base_full")
}
var tpl *template.Template
// For each template, add it to the the tpl variable
for i, t := range templates {
// Get the template from the assets
page, err := assets.Asset("templates/" + t + ".tmpl")
// Check if there is some error. If so, the template doesn't exist
if err != nil {
log.Print(err)
return new(template.Template), err
}
// If it's the first iteration, creates a new template and add the
// functions map
if i == 0 {
tpl, err = template.New(t).Funcs(functions).Parse(string(page))
} else {
tpl, err = tpl.Parse(string(page))
}
if err != nil {
log.Print(err)
return new(template.Template), err
}
}
return tpl, nil
}
// Returns a copy of the root template with the supplied template merged in.
func (ts *Templates) mergeTemplate(t *template.Template) (out *template.Template, err error) {
defer func() {
if r := recover(); r != nil {
// Seems to be a bug with cloning empty templates.
err = fmt.Errorf("Problem cloning template: %v", r)
}
}()
if ts.empty {
out = template.New("root")
} else {
if out, err = ts.root.Clone(); err != nil {
return
}
}
for _, tmpl := range t.Templates() {
ptr := out.Lookup(tmpl.Name())
if ptr == nil {
out.Parse(fmt.Sprintf(`{{define "%v"}}{{end}}`, tmpl.Name()))
ptr = out.Lookup(tmpl.Name())
}
var clone *template.Template
if clone, err = tmpl.Clone(); err != nil {
return
}
(*ptr) = *clone
// Merge existing root templates back into new template.
for _, out_tmpl := range out.Templates() {
ptr2 := clone.Lookup(out_tmpl.Name())
if ptr2 == nil {
clone.Parse(fmt.Sprintf(`{{define "%v"}}{{end}}`, out_tmpl.Name()))
ptr2 = clone.Lookup(out_tmpl.Name())
(*ptr2) = *out_tmpl
}
}
}
return
}
func jsonClient(t *template.Template) (*template.Template, error) {
return t.Parse(`
{{ define "json" }}
{{ template "header" $ }}
// {{ .Name }} is a client for {{ .FullName }}.
type {{ .Name }} struct {
client *aws.JSONClient
}
// New returns a new {{ .Name }} client.
func New(creds aws.CredentialsProvider, region string, client *http.Client) *{{ .Name }} {
if client == nil {
client = http.DefaultClient
}
endpoint, service, region := endpoints.Lookup("{{ .Metadata.EndpointPrefix }}", region)
return &{{ .Name }}{
client: &aws.JSONClient{
Context: aws.Context{
Credentials: creds,
Service: service,
Region: region,
}, Client: client,
Endpoint: endpoint,
JSONVersion: "{{ .Metadata.JSONVersion }}",
TargetPrefix: "{{ .Metadata.TargetPrefix }}",
},
}
}
{{ range $name, $op := .Operations }}
{{ godoc $name $op.Documentation }} func (c *{{ $.Name }}) {{ exportable $name }}({{ if $op.Input }}req {{ $op.Input.Type }}{{ end }}) ({{ if $op.Output }}resp {{ $op.Output.Type }},{{ end }} err error) {
{{ if $op.Output }}resp = {{ $op.Output.Literal }}{{ else }}// NRE{{ end }}
err = c.client.Do("{{ $name }}", "{{ $op.HTTP.Method }}", "{{ $op.HTTP.RequestURI }}", {{ if $op.Input }} req {{ else }} nil {{ end }}, {{ if $op.Output }} resp {{ else }} nil {{ end }})
return
}
{{ end }}
{{ range $name, $s := .Shapes }}
{{ if eq $s.ShapeType "structure" }}
{{ if not $s.Exception }}
// {{ exportable $name }} is undocumented.
type {{ exportable $name }} struct {
{{ range $name, $m := $s.Members }}
{{ exportable $name }} {{ $m.Type }} {{ $m.JSONTag }} {{ end }}
}
{{ end }}
{{ else if $s.Enum }}
// Possible values for {{ $.Name }}.
const (
{{ range $name, $value := $s.Enums }}
{{ $name }} = {{ $value }}{{ end }}
)
{{ end }}
{{ end }}
{{ template "footer" }}
{{ end }}
`)
}
func queryClient(t *template.Template) (*template.Template, error) {
return t.Parse(`
{{ define "query" }}
{{ template "header" $ }}
import (
"io"
"encoding/xml"
)
// {{ .Name }} is a client for {{ .FullName }}.
type {{ .Name }} struct {
client *aws.QueryClient
}
// New returns a new {{ .Name }} client.
func New(creds aws.CredentialsProvider, region string, client *http.Client) *{{ .Name }} {
if client == nil {
client = http.DefaultClient
}
endpoint, service, region := endpoints.Lookup("{{ .Metadata.EndpointPrefix }}", region)
return &{{ .Name }}{
client: &aws.QueryClient{
Context: aws.Context{
Credentials: creds,
Service: service,
Region: region,
},
Client: client,
Endpoint: endpoint,
APIVersion: "{{ .Metadata.APIVersion }}",
},
}
}
{{ range $name, $op := .Operations }}
{{ godoc $name $op.Documentation }} func (c *{{ $.Name }}) {{ exportable $name }}({{ if $op.InputRef }}req {{ $op.InputRef.WrappedType }}{{ end }}) ({{ if $op.OutputRef }}resp {{ $op.OutputRef.WrappedType }},{{ end }} err error) {
{{ if $op.Output }}resp = {{ $op.OutputRef.WrappedLiteral }}{{ else }}// NRE{{ end }}
err = c.client.Do("{{ $name }}", "{{ $op.HTTP.Method }}", "{{ $op.HTTP.RequestURI }}", {{ if $op.Input }} req {{ else }} nil {{ end }}, {{ if $op.Output }} resp {{ else }} nil {{ end }})
return
}
{{ end }}
{{ range $name, $s := .Shapes }}
{{ if eq $s.ShapeType "map" }}
type {{ exportable $name }} map[{{ $s.Key.ElementType }}]{{ $s.Value.ElementType }}
// UnmarshalXML implements xml.UnmarshalXML interface for map
func (m *{{ exportable $name }}) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
if *m == nil {
(*m) = make({{ exportable $name }})
}
for {
var e struct {
{{ or $s.KeyRef.LocationName "Key" }} {{ $s.Key.ElementType }} {{ $s.KeyXMLTag }}
{{ or $s.ValueRef.LocationName "Value" }} {{ $s.Value.ElementType }} {{ $s.ValueXMLTag }}
}
err := d.DecodeElement(&e, &start)
if err != nil && err != io.EOF {
return err
}
if err == io.EOF {
break
}
(*m)[e.{{ or $s.KeyRef.LocationName "Key" }}] = e.{{ or $s.ValueRef.LocationName "Value" }}
}
return nil
}
{{ end }}
{{ if eq $s.ShapeType "structure" }}
{{ if not $s.Exception }}
// {{ exportable $name }} is undocumented.
type {{ exportable $name }} struct {
{{ range $name, $m := $s.Members }}
{{ exportable $name }} {{ $m.Type }} {{ $m.QueryTag $s.ResultWrapper }} {{ end }}
}
{{ end }}
{{ else if $s.Enum }}
// Possible values for {{ $.Name }}.
const (
{{ range $name, $value := $s.Enums }}
{{ $name }} = {{ $value }}{{ end }}
)
{{ end }}
{{ end }}
{{ range $wname, $s := .Wrappers }}
// {{ exportable $wname }} is a wrapper for {{ $s.Name }}.
type {{ exportable $wname }} struct {
{{ range $name, $m := $s.Members }}
{{ exportable $name }} {{ $m.Type }} {{ $m.QueryTag $wname }} {{ end }}
}
{{ end }}
{{ template "footer" }}
var _ xml.Decoder
var _ = io.EOF
{{ end }}
`)
}
// mainLoop initiates all ports and handles the traffic
func mainLoop() {
openPorts()
defer closePorts()
waitCh := make(chan bool)
go func() {
total := 0
for {
select {
case v := <-inCh:
if !v {
log.Println("IN port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
case v := <-outCh:
if !v {
log.Println("OUT port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
}
if total >= 2 && waitCh != nil {
waitCh <- true
}
}
}()
log.Println("Waiting for port connections to establish... ")
select {
case <-waitCh:
log.Println("Ports connected")
waitCh = nil
case <-time.Tick(30 * time.Second):
log.Println("Timeout: port connections were not established within provided interval")
exitCh <- syscall.SIGTERM
return
}
log.Println("Waiting for template...")
var (
t *template.Template
ip [][]byte
)
for {
ip, err = tplPort.RecvMessageBytes(0)
if err != nil {
continue
}
if !runtime.IsValidIP(ip) {
log.Println("Invalid IP:", ip)
continue
}
t = template.New("Current template")
t, err = t.Parse(string(ip[1]))
if err != nil {
log.Println("Failed to configure component:", err.Error())
continue
}
break
}
tplPort.Close()
log.Println("Started...")
var (
buf *bytes.Buffer
data map[string]interface{}
)
for {
ip, err := inPort.RecvMessageBytes(0)
if err != nil {
continue
}
if !runtime.IsValidIP(ip) {
continue
}
err = json.Unmarshal(ip[1], &data)
if err != nil {
log.Println(err.Error())
continue
}
buf = bytes.NewBufferString("")
err = t.Execute(buf, data)
if err != nil {
log.Println(err.Error())
continue
}
outPort.SendMessage(runtime.NewPacket(buf.Bytes()))
}
}
func restCommon(t *template.Template) (*template.Template, error) {
return t.Parse(`
{{ define "rest-uri" }}
{{ if .Input }}
{{ range $name, $m := .Input.Members }}
{{ if eq $m.Location "uri" }}
if req.{{ exportable $name }} != nil {
uri = strings.Replace(uri, "{"+"{{ $m.LocationName }}"+"}", aws.EscapePath(*req.{{ exportable $name }}), -1)
uri = strings.Replace(uri, "{"+"{{ $m.LocationName }}+"+"}", aws.EscapePath(*req.{{ exportable $name }}), -1)
}
{{ end }}
{{ end }}
{{ end }}
{{ end }}
{{ define "rest-querystring" }}
q := url.Values{}
{{ if .Input }}
{{ range $name, $m := .Input.Members }}
{{ if eq $m.Location "querystring" }}
{{ if eq $m.Shape.ShapeType "string" }}
if req.{{ exportable $name }} != nil {
q.Set("{{ $m.LocationName }}", *req.{{ exportable $name }})
}
{{ else if eq $m.Shape.ShapeType "timestamp" }}
if req.{{ exportable $name }} != (time.Time{}) {
q.Set("{{ $m.LocationName }}", req.{{ exportable $name }}.Format(time.RFC822))
}
{{ else if eq $m.Shape.ShapeType "integer" }}
if req.{{ exportable $name }} != nil {
q.Set("{{ $m.LocationName }}", strconv.Itoa(*req.{{ exportable $name }}))
}
{{ else }}
if req.{{ exportable $name }} != nil {
q.Set("{{ $m.LocationName }}", fmt.Sprintf("%v", req.{{ exportable $name }}))
}
{{ end }}
{{ end }}
{{ end }}
{{ end }}
if len(q) > 0 {
uri += "?" + q.Encode()
}
{{ end }}
{{ define "rest-reqheaders" }}
{{ if .Input }}
{{ range $name, $m := .Input.Members }}
{{ if eq $m.Location "header" }}
{{ if eq $m.Shape.ShapeType "string" }}
if req.{{ exportable $name }} != nil {
httpReq.Header.Set("{{ $m.LocationName }}", *req.{{ exportable $name }})
}
{{ else if eq $m.Shape.ShapeType "timestamp" }}
if req.{{ exportable $name }} != (time.Time{}) {
httpReq.Header.Set("{{ $m.LocationName }}", req.{{ exportable $name }}.Format(time.RFC822))
}
{{ else if eq $m.Shape.ShapeType "integer" }}
{{ if eq $m.LocationName "Content-Length" }}
if req.{{ exportable $name }} != nil {
httpReq.ContentLength = *req.{{ exportable $name }}
}
{{ else }}
if req.{{ exportable $name }} != nil {
httpReq.Header.Set("{{ $m.LocationName }}", strconv.Itoa(*req.{{ exportable $name }}))
}
{{ end }}
{{ else }}
if req.{{ exportable $name }} != nil {
httpReq.Header.Set("{{ $m.LocationName }}", fmt.Sprintf("%v", req.{{ exportable $name }}))
}
{{ end }}
{{ else if eq $m.Location "headers" }}
for name, value := range req.{{ exportable $name }} {
httpReq.Header.Set(name, value)
}
{{ end }}
{{ end }}
{{ end }}
{{ end }}
{{ define "rest-respheaders" }}
{{ range $name, $m := .Output.Members }}
{{ if ne $name "Body" }}
{{ if eq $m.Location "header" }}
if s := httpResp.Header.Get("{{ $m.LocationName }}"); s != "" {
{{ if eq $m.Shape.ShapeType "string" }}
resp.{{ exportable $name }} = &s
{{ else if eq $m.Shape.ShapeType "timestamp" }}
var t time.Time
t, err = time.Parse(time.RFC1123, s)
if err != nil {
return
}
resp.{{ exportable $name }} = t
{{ else if eq $m.Shape.ShapeType "integer" }}
{{ if eq $m.Shape.Name "ContentLength" }}
var n int64
n, err = strconv.ParseInt(s, 10, 64)
{{ else }}
var n int
n, err = strconv.Atoi(s)
{{ end }}
if err != nil {
return
}
resp.{{ exportable $name }} = &n
{{ else if eq $m.Shape.ShapeType "boolean" }}
var v bool
v, err = strconv.ParseBool(s)
if err != nil {
return
}
resp.{{ exportable $name }} = &v
{{ else }}
// TODO: add support for {{ $m.Shape.ShapeType }} headers
{{ end }}
}
{{ else if eq $m.Location "headers" }}
resp.{{ exportable $name }} = {{ $m.Shape.Type }}{}
for name := range httpResp.Header {
if strings.HasPrefix(name, "X-Amz-Meta-") {
resp.{{ exportable $name }}[name] = httpResp.Header.Get(name)
}
}
{{ else if eq $m.Location "statusCode" }}
resp.{{ exportable $name }} = aws.Integer(httpResp.StatusCode)
{{ else if ne $m.Location "" }}
// TODO: add support for extracting output members from {{ $m.Location }} to support {{ exportable $name }}
{{ end }}
{{ end }}
{{ end }}
{{ end }}
`)
}
func restJSONClient(t *template.Template) (*template.Template, error) {
return t.Parse(`
{{ define "rest-json" }}
{{ template "header" $ }}
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/url"
"strconv"
"strings"
)
// {{ .Name }} is a client for {{ .FullName }}.
type {{ .Name }} struct {
client *aws.RestClient
}
// New returns a new {{ .Name }} client.
func New(creds aws.CredentialsProvider, region string, client *http.Client) *{{ .Name }} {
if client == nil {
client = http.DefaultClient
}
endpoint, service, region := endpoints.Lookup("{{ .Metadata.EndpointPrefix }}", region)
return &{{ .Name }}{
client: &aws.RestClient{
Context: aws.Context{
Credentials: creds,
Service: service,
Region: region,
},
Client: client,
Endpoint: endpoint,
APIVersion: "{{ .Metadata.APIVersion }}",
},
}
}
{{ range $name, $op := .Operations }}
{{ godoc $name $op.Documentation }} func (c *{{ $.Name }}) {{ exportable $name }}({{ if $op.Input }}req {{ $op.Input.Type }}{{ end }}) ({{ if $op.Output }}resp {{ $op.Output.Type }},{{ end }} err error) {
{{ if $op.Output }}resp = {{ $op.Output.Literal }}{{ else }}// NRE{{ end }}
var body io.Reader
var contentType string
{{ if $op.Input }}
{{ if $op.Input.Payload }}
{{ with $m := index $op.Input.Members $op.Input.Payload }}
{{ if $m.Streaming }}
body = req.{{ exportable $m.Name }}
{{ else }}
contentType = "application/json"
b, err := json.Marshal(req.{{ exportable $m.Name }})
if err != nil {
return
}
body = bytes.NewReader(b)
{{ end }}
{{ end }}
{{ end }}
{{ end }}
uri := c.client.Endpoint + "{{ $op.HTTP.RequestURI }}"
{{ template "rest-uri" $op }}
{{ template "rest-querystring" $op }}
httpReq, err := http.NewRequest("{{ $op.HTTP.Method }}", uri, body)
if err != nil {
return
}
if contentType != "" {
httpReq.Header.Set("Content-Type", contentType)
}
{{ template "rest-reqheaders" $op }}
httpResp, err := c.client.Do(httpReq)
if err != nil {
return
}
{{ if $op.Output }}
{{ with $name := "Body" }}
{{ with $m := index $op.Output.Members $name }}
{{ if $m }}
{{ if $m.Streaming }}
resp.Body = httpResp.Body
{{ else }}
defer httpResp.Body.Close()
if e := json.NewDecoder(httpResp.Body).Decode(resp); e != nil && e != io.EOF {
err = e
return
}
{{ end }}
{{ else }}
defer httpResp.Body.Close()
{{ end }}
{{ end }}
{{ template "rest-respheaders" $op }}
{{ end }}
{{ else }}
defer httpResp.Body.Close()
{{ end }}
return
}
{{ end }}
{{ range $name, $s := .Shapes }}
{{ if eq $s.ShapeType "structure" }}
{{ if not $s.Exception }}
// {{ exportable $name }} is undocumented.
type {{ exportable $name }} struct {
{{ range $name, $m := $s.Members }}
{{ exportable $name }} {{ $m.Type }} {{ $m.JSONTag }} {{ end }}
}
{{ end }}
{{ else if $s.Enum }}
// Possible values for {{ $.Name }}.
const (
{{ range $name, $value := $s.Enums }}
{{ $name }} = {{ $value }}{{ end }}
)
{{ end }}
{{ end }}
{{ template "footer" }}
var _ bytes.Reader
var _ url.URL
var _ fmt.Stringer
var _ strings.Reader
var _ strconv.NumError
var _ = ioutil.Discard
var _ json.RawMessage
{{ end }}
`)
}