_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q181700
|
AddError
|
test
|
func (f *FormErrors) AddError(e string) {
f.Errors = append(f.Errors, e)
}
|
go
|
{
"resource": ""
}
|
q181701
|
AddFieldError
|
test
|
func (f *FormErrors) AddFieldError(field, e string) {
if f.FieldErrors == nil {
f.FieldErrors = map[string][]string{}
}
if _, ok := f.FieldErrors[field]; !ok {
f.FieldErrors[field] = []string{}
}
f.FieldErrors[field] = append(f.FieldErrors[field], e)
}
|
go
|
{
"resource": ""
}
|
q181702
|
HasErrors
|
test
|
func (f FormErrors) HasErrors() bool {
if len(f.Errors) > 0 {
return true
}
for _, v := range f.FieldErrors {
if len(v) > 0 {
return true
}
}
return false
}
|
go
|
{
"resource": ""
}
|
q181703
|
NewError
|
test
|
func NewError(e string) FormErrors {
errors := FormErrors{}
errors.AddError(e)
return errors
}
|
go
|
{
"resource": ""
}
|
q181704
|
NewFieldError
|
test
|
func NewFieldError(field, e string) FormErrors {
errors := FormErrors{}
errors.AddFieldError(field, e)
return errors
}
|
go
|
{
"resource": ""
}
|
q181705
|
ChainHandlers
|
test
|
func ChainHandlers(handlers ...func(http.Handler) http.Handler) (h http.Handler) {
for i := len(handlers) - 1; i >= 0; i-- {
h = handlers[i](h)
}
return
}
|
go
|
{
"resource": ""
}
|
q181706
|
FinalHandler
|
test
|
func FinalHandler(h http.Handler) func(http.Handler) http.Handler {
return func(_ http.Handler) http.Handler {
return h
}
}
|
go
|
{
"resource": ""
}
|
q181707
|
Hash
|
test
|
func (s MD5Hasher) Hash(reader io.Reader) (string, error) {
hash := md5.New()
if _, err := io.Copy(hash, reader); err != nil {
return "", err
}
h := hash.Sum(nil)
if len(h) < s.HashLength {
return "", nil
}
return strings.TrimRight(hex.EncodeToString(h)[:s.HashLength], "="), nil
}
|
go
|
{
"resource": ""
}
|
q181708
|
IsHash
|
test
|
func (s MD5Hasher) IsHash(h string) bool {
if len(h) != s.HashLength {
return false
}
var found bool
for _, c := range h {
found = false
for _, m := range hexChars {
if c == m {
found = true
break
}
}
if !found {
return false
}
}
return true
}
|
go
|
{
"resource": ""
}
|
q181709
|
WithBaseDir
|
test
|
func WithBaseDir(dir string) Option {
return func(o *Options) {
o.fileFindFunc = func(f string) string {
return filepath.Join(dir, f)
}
}
}
|
go
|
{
"resource": ""
}
|
q181710
|
WithFileFindFunc
|
test
|
func WithFileFindFunc(fn func(filename string) string) Option {
return func(o *Options) { o.fileFindFunc = fn }
}
|
go
|
{
"resource": ""
}
|
q181711
|
WithTemplateFromFiles
|
test
|
func WithTemplateFromFiles(name string, files ...string) Option {
return func(o *Options) { o.files[name] = files }
}
|
go
|
{
"resource": ""
}
|
q181712
|
WithTemplatesFromFiles
|
test
|
func WithTemplatesFromFiles(ts map[string][]string) Option {
return func(o *Options) {
for name, files := range ts {
o.files[name] = files
}
}
}
|
go
|
{
"resource": ""
}
|
q181713
|
WithTemplateFromStrings
|
test
|
func WithTemplateFromStrings(name string, strings ...string) Option {
return func(o *Options) { o.strings[name] = strings }
}
|
go
|
{
"resource": ""
}
|
q181714
|
WithTemplatesFromStrings
|
test
|
func WithTemplatesFromStrings(ts map[string][]string) Option {
return func(o *Options) {
for name, strings := range ts {
o.strings[name] = strings
}
}
}
|
go
|
{
"resource": ""
}
|
q181715
|
WithFunction
|
test
|
func WithFunction(name string, fn interface{}) Option {
return func(o *Options) { o.functions[name] = fn }
}
|
go
|
{
"resource": ""
}
|
q181716
|
WithFunctions
|
test
|
func WithFunctions(fns template.FuncMap) Option {
return func(o *Options) {
for name, fn := range fns {
o.functions[name] = fn
}
}
}
|
go
|
{
"resource": ""
}
|
q181717
|
WithDelims
|
test
|
func WithDelims(open, close string) Option {
return func(o *Options) {
o.delimOpen = open
o.delimClose = close
}
}
|
go
|
{
"resource": ""
}
|
q181718
|
New
|
test
|
func New(opts ...Option) (t *Templates, err error) {
functions := template.FuncMap{}
for name, fn := range defaultFunctions {
functions[name] = fn
}
o := &Options{
fileFindFunc: func(f string) string {
return f
},
fileReadFunc: ioutil.ReadFile,
files: map[string][]string{},
functions: functions,
delimOpen: "{{",
delimClose: "}}",
logf: log.Printf,
}
for _, opt := range opts {
opt(o)
}
t = &Templates{
templates: map[string]*template.Template{},
contentType: o.contentType,
logf: o.logf,
}
for name, strings := range o.strings {
tpl, err := parseStrings(template.New("").Funcs(o.functions).Delims(o.delimOpen, o.delimClose), strings...)
if err != nil {
return nil, err
}
t.templates[name] = tpl
}
for name, files := range o.files {
fs := []string{}
for _, f := range files {
fs = append(fs, o.fileFindFunc(f))
}
tpl, err := parseFiles(o.fileReadFunc, template.New("").Funcs(o.functions).Delims(o.delimOpen, o.delimClose), fs...)
if err != nil {
return nil, err
}
t.templates[name] = tpl
}
return
}
|
go
|
{
"resource": ""
}
|
q181719
|
RespondWithStatus
|
test
|
func (t Templates) RespondWithStatus(w http.ResponseWriter, name string, data interface{}, status int) {
buf := bytes.Buffer{}
tpl, ok := t.templates[name]
if !ok {
panic(&Error{Err: ErrUnknownTemplate, Template: name})
}
if err := tpl.Execute(&buf, data); err != nil {
panic(err)
}
if t.contentType != "" {
w.Header().Set("Content-Type", t.contentType)
}
if status > 0 {
w.WriteHeader(status)
}
if _, err := buf.WriteTo(w); err != nil {
t.logf("respond %q: %v", name, err)
}
}
|
go
|
{
"resource": ""
}
|
q181720
|
RespondTemplate
|
test
|
func (t Templates) RespondTemplate(w http.ResponseWriter, name, templateName string, data interface{}) {
t.RespondTemplateWithStatus(w, name, templateName, data, 0)
}
|
go
|
{
"resource": ""
}
|
q181721
|
Respond
|
test
|
func (t Templates) Respond(w http.ResponseWriter, name string, data interface{}) {
t.RespondWithStatus(w, name, data, 0)
}
|
go
|
{
"resource": ""
}
|
q181722
|
RenderTemplate
|
test
|
func (t Templates) RenderTemplate(name, templateName string, data interface{}) (s string, err error) {
buf := bytes.Buffer{}
tpl, ok := t.templates[name]
if !ok {
return "", &Error{Err: ErrUnknownTemplate, Template: name}
}
if err := tpl.ExecuteTemplate(&buf, templateName, data); err != nil {
return "", err
}
return buf.String(), nil
}
|
go
|
{
"resource": ""
}
|
q181723
|
New
|
test
|
func New(handler http.Handler, opts ...Option) (s *Server) {
o := &Options{}
for _, opt := range opts {
opt(o)
}
s = &Server{
Server: &h2quic.Server{
Server: &http.Server{
Handler: handler,
TLSConfig: o.tlsConfig,
},
},
}
return
}
|
go
|
{
"resource": ""
}
|
q181724
|
ServeUDP
|
test
|
func (s *Server) ServeUDP(conn *net.UDPConn) (err error) {
s.Server.Server.Addr = conn.LocalAddr().String()
return s.Server.Serve(conn)
}
|
go
|
{
"resource": ""
}
|
q181725
|
Shutdown
|
test
|
func (s *Server) Shutdown(_ context.Context) (err error) {
return s.Server.Close()
}
|
go
|
{
"resource": ""
}
|
q181726
|
QuicHeadersHandler
|
test
|
func (s *Server) QuicHeadersHandler(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s.SetQuicHeaders(w.Header())
h.ServeHTTP(w, r)
})
}
|
go
|
{
"resource": ""
}
|
q181727
|
GetRequestIPs
|
test
|
func GetRequestIPs(r *http.Request) string {
ip, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
ip = r.RemoteAddr
}
ips := []string{ip}
xfr := r.Header.Get("X-Forwarded-For")
if xfr != "" {
ips = append(ips, xfr)
}
xri := r.Header.Get("X-Real-Ip")
if xri != "" {
ips = append(ips, xri)
}
return strings.Join(ips, ", ")
}
|
go
|
{
"resource": ""
}
|
q181728
|
DomainRedirectHandler
|
test
|
func DomainRedirectHandler(h http.Handler, domain, httpsPort string) http.Handler {
if domain == "" && httpsPort == "" {
return h
}
scheme := "http"
port := ""
if httpsPort != "" {
if _, err := strconv.Atoi(httpsPort); err == nil {
scheme = "https"
port = httpsPort
}
if _, p, err := net.SplitHostPort(httpsPort); err == nil {
scheme = "https"
port = p
}
}
if port == "443" {
port = ""
}
var altDomain string
if strings.HasPrefix("www.", domain) {
altDomain = strings.TrimPrefix(domain, "www.")
} else {
altDomain = "www." + domain
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
d, p, err := net.SplitHostPort(r.Host)
if err != nil {
d = r.Host
}
rs := r.URL.Scheme
if fs := r.Header.Get("X-Forwarded-Proto"); fs != "" {
rs = strings.ToLower(fs)
}
s := scheme
if rs == "https" {
s = "https"
}
if d == domain && rs == s {
h.ServeHTTP(w, r)
return
}
switch {
case s == "http" && p == "80":
p = ""
case s == "https" && p == "443":
p = ""
case port != "":
p = ":" + port
case p != "":
p = ":" + p
}
if d == altDomain {
http.Redirect(w, r, strings.Join([]string{s, "://", domain, p, r.RequestURI}, ""), http.StatusMovedPermanently)
return
}
http.Redirect(w, r, strings.Join([]string{s, "://", domain, p, r.RequestURI}, ""), http.StatusFound)
})
}
|
go
|
{
"resource": ""
}
|
q181729
|
New
|
test
|
func New(opts ...Option) (s *Servers) {
s = &Servers{
logger: stdLogger{},
recover: func() {},
}
for _, opt := range opts {
opt(s)
}
return
}
|
go
|
{
"resource": ""
}
|
q181730
|
Add
|
test
|
func (s *Servers) Add(name, address string, srv Server) {
s.mu.Lock()
s.servers = append(s.servers, &server{
Server: srv,
name: name,
address: address,
})
s.mu.Unlock()
}
|
go
|
{
"resource": ""
}
|
q181731
|
TCPAddr
|
test
|
func (s *Servers) TCPAddr(name string) (a *net.TCPAddr) {
s.mu.Lock()
defer s.mu.Unlock()
for _, srv := range s.servers {
if srv.name == name {
return srv.tcpAddr
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181732
|
UDPAddr
|
test
|
func (s *Servers) UDPAddr(name string) (a *net.UDPAddr) {
s.mu.Lock()
defer s.mu.Unlock()
for _, srv := range s.servers {
if srv.name == name {
return srv.udpAddr
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181733
|
Close
|
test
|
func (s *Servers) Close() {
wg := &sync.WaitGroup{}
for _, srv := range s.servers {
wg.Add(1)
go func(srv *server) {
defer s.recover()
defer wg.Done()
s.logger.Infof("%s closing", srv.label())
if err := srv.Close(); err != nil {
s.logger.Errorf("%s close: %v", srv.label(), err)
}
}(srv)
}
wg.Wait()
return
}
|
go
|
{
"resource": ""
}
|
q181734
|
Shutdown
|
test
|
func (s *Servers) Shutdown(ctx context.Context) {
wg := &sync.WaitGroup{}
for _, srv := range s.servers {
wg.Add(1)
go func(srv *server) {
defer s.recover()
defer wg.Done()
s.logger.Infof("%s shutting down", srv.label())
if err := srv.Shutdown(ctx); err != nil {
s.logger.Errorf("%s shutdown: %v", srv.label(), err)
}
}(srv)
}
wg.Wait()
return
}
|
go
|
{
"resource": ""
}
|
q181735
|
Accept
|
test
|
func (l TLSListener) Accept() (net.Conn, error) {
c, err := l.AcceptTCP()
if err != nil {
return nil, err
}
c.SetKeepAlive(true)
c.SetKeepAlivePeriod(3 * time.Minute)
b := make([]byte, 1)
_, err = c.Read(b)
if err != nil {
c.Close()
if err != io.EOF {
return nil, err
}
}
con := &conn{
Conn: c,
b: b[0],
e: err,
f: true,
}
if b[0] == 22 {
return tls.Server(con, l.TLSConfig), nil
}
return con, nil
}
|
go
|
{
"resource": ""
}
|
q181736
|
NewStaticFilesHandler
|
test
|
func NewStaticFilesHandler(h http.Handler, prefix string, fs http.FileSystem) http.Handler {
fileserver := http.StripPrefix(prefix, http.FileServer(fs))
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
filename := strings.TrimPrefix(r.URL.Path, prefix)
_, err := fs.Open(filename)
if err != nil {
h.ServeHTTP(w, r)
return
}
fileserver.ServeHTTP(w, r)
})
}
|
go
|
{
"resource": ""
}
|
q181737
|
ServeHTTP
|
test
|
func (h AuthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
valid, entity, err := h.authenticate(r)
if err != nil {
h.error(w, r, err)
return
}
if h.PostAuthFunc != nil {
rr, err := h.PostAuthFunc(w, r, valid, entity)
if err != nil {
h.error(w, r, err)
return
}
if rr != nil {
r = rr
}
}
if !valid {
h.unauthorized(w, r)
return
}
if h.Handler != nil {
h.Handler.ServeHTTP(w, r)
}
}
|
go
|
{
"resource": ""
}
|
q181738
|
MarshalJSON
|
test
|
func (o Options) MarshalJSON() ([]byte, error) {
return json.Marshal(optionsJSON{
Timeout: marshal.Duration(o.Timeout),
KeepAlive: marshal.Duration(o.KeepAlive),
TLSHandshakeTimeout: marshal.Duration(o.TLSHandshakeTimeout),
TLSSkipVerify: o.TLSSkipVerify,
RetryTimeMax: marshal.Duration(o.RetryTimeMax),
RetrySleepMax: marshal.Duration(o.RetrySleepMax),
RetrySleepBase: marshal.Duration(o.RetrySleepBase),
})
}
|
go
|
{
"resource": ""
}
|
q181739
|
UnmarshalJSON
|
test
|
func (o *Options) UnmarshalJSON(data []byte) error {
v := &optionsJSON{}
if err := json.Unmarshal(data, v); err != nil {
return err
}
*o = Options{
Timeout: v.Timeout.Duration(),
KeepAlive: v.KeepAlive.Duration(),
TLSHandshakeTimeout: v.TLSHandshakeTimeout.Duration(),
TLSSkipVerify: v.TLSSkipVerify,
RetryTimeMax: v.RetryTimeMax.Duration(),
RetrySleepMax: v.RetrySleepMax.Duration(),
RetrySleepBase: v.RetrySleepBase.Duration(),
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181740
|
MarshalYAML
|
test
|
func (o Options) MarshalYAML() (interface{}, error) {
return optionsJSON{
Timeout: marshal.Duration(o.Timeout),
KeepAlive: marshal.Duration(o.KeepAlive),
TLSHandshakeTimeout: marshal.Duration(o.TLSHandshakeTimeout),
TLSSkipVerify: o.TLSSkipVerify,
RetryTimeMax: marshal.Duration(o.RetryTimeMax),
RetrySleepMax: marshal.Duration(o.RetrySleepMax),
RetrySleepBase: marshal.Duration(o.RetrySleepBase),
}, nil
}
|
go
|
{
"resource": ""
}
|
q181741
|
UnmarshalYAML
|
test
|
func (o *Options) UnmarshalYAML(unmarshal func(interface{}) error) error {
v := &optionsJSON{}
if err := unmarshal(v); err != nil {
return err
}
*o = Options{
Timeout: v.Timeout.Duration(),
KeepAlive: v.KeepAlive.Duration(),
TLSHandshakeTimeout: v.TLSHandshakeTimeout.Duration(),
TLSSkipVerify: v.TLSSkipVerify,
RetryTimeMax: v.RetryTimeMax.Duration(),
RetrySleepMax: v.RetrySleepMax.Duration(),
RetrySleepBase: v.RetrySleepBase.Duration(),
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181742
|
NewHandler
|
test
|
func NewHandler(h http.Handler, logger *logging.Logger) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
startTime := time.Now()
rl := &responseLogger{w, 0, 0}
h.ServeHTTP(rl, r)
referrer := r.Referer()
if referrer == "" {
referrer = "-"
}
userAgent := r.UserAgent()
if userAgent == "" {
userAgent = "-"
}
ips := []string{}
xfr := r.Header.Get("X-Forwarded-For")
if xfr != "" {
ips = append(ips, xfr)
}
xri := r.Header.Get("X-Real-Ip")
if xri != "" {
ips = append(ips, xri)
}
xips := "-"
if len(ips) > 0 {
xips = strings.Join(ips, ", ")
}
var level logging.Level
switch {
case rl.status >= 500:
level = logging.ERROR
case rl.status >= 400:
level = logging.WARNING
case rl.status >= 300:
level = logging.INFO
case rl.status >= 200:
level = logging.INFO
default:
level = logging.DEBUG
}
logger.Logf(level, "%s \"%s\" \"%v %s %v\" %d %d %f \"%s\" \"%s\"", r.RemoteAddr, xips, r.Method, r.RequestURI, r.Proto, rl.status, rl.size, time.Since(startTime).Seconds(), referrer, userAgent)
})
}
|
go
|
{
"resource": ""
}
|
q181743
|
WithPanicResponse
|
test
|
func WithPanicResponse(body, contentType string) Option {
return func(o *Handler) {
o.panicBody = body
o.panicContentType = contentType
}
}
|
go
|
{
"resource": ""
}
|
q181744
|
WithPanicResponseHandler
|
test
|
func WithPanicResponseHandler(h http.Handler) Option {
return func(o *Handler) { o.panicResponseHandler = h }
}
|
go
|
{
"resource": ""
}
|
q181745
|
New
|
test
|
func New(handler http.Handler, options ...Option) (h *Handler) {
h = &Handler{
handler: handler,
logf: log.Printf,
}
for _, option := range options {
option(h)
}
return
}
|
go
|
{
"resource": ""
}
|
q181746
|
ServeHTTP
|
test
|
func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
debugMsg := fmt.Sprintf(
"%s\n\n%#v\n\n%#v",
debug.Stack(),
r.URL,
r.Header,
)
if h.label != "" {
debugMsg = h.label + "\n\n" + debugMsg
}
h.logf("http recovery handler: %s %s: %s\n%s", r.Method, r.URL.String(), err, debugMsg)
if h.notifier != nil {
go func() {
defer func() {
if err := recover(); err != nil {
h.logf("http recovery handler: notify panic: %v", err)
}
}()
if err := h.notifier.Notify(
fmt.Sprint(
"Panic ",
r.Method,
" ",
r.URL.String(),
": ", err,
),
debugMsg,
); err != nil {
h.logf("http recovery handler: notify: %v", err)
}
}()
}
if h.panicResponseHandler != nil {
h.panicResponseHandler.ServeHTTP(w, r)
return
}
if h.panicContentType != "" {
w.Header().Set("Content-Type", h.panicContentType)
}
w.WriteHeader(http.StatusInternalServerError)
if h.panicBody != "" {
fmt.Fprintln(w, h.panicBody)
}
}
}()
h.handler.ServeHTTP(w, r)
}
|
go
|
{
"resource": ""
}
|
q181747
|
NewContextFunc
|
test
|
func NewContextFunc(m map[string]interface{}) func(string) interface{} {
return func(key string) interface{} {
if value, ok := m[key]; ok {
return value
}
return nil
}
}
|
go
|
{
"resource": ""
}
|
q181748
|
NewMapErrorRegistry
|
test
|
func NewMapErrorRegistry(errors map[int]error, handlers map[int]func(body []byte) error) *MapErrorRegistry {
if errors == nil {
errors = map[int]error{}
}
if handlers == nil {
handlers = map[int]func(body []byte) error{}
}
return &MapErrorRegistry{
errors: errors,
handlers: handlers,
}
}
|
go
|
{
"resource": ""
}
|
q181749
|
AddError
|
test
|
func (r *MapErrorRegistry) AddError(code int, err error) error {
if _, ok := r.errors[code]; ok {
return ErrErrorAlreadyRegistered
}
if _, ok := r.handlers[code]; ok {
return ErrErrorAlreadyRegistered
}
r.errors[code] = err
return nil
}
|
go
|
{
"resource": ""
}
|
q181750
|
AddMessageError
|
test
|
func (r *MapErrorRegistry) AddMessageError(code int, message string) (*Error, error) {
if _, ok := r.errors[code]; ok {
return nil, ErrErrorAlreadyRegistered
}
if _, ok := r.handlers[code]; ok {
return nil, ErrErrorAlreadyRegistered
}
err := &Error{
Message: message,
Code: code,
}
r.errors[code] = err
return err, nil
}
|
go
|
{
"resource": ""
}
|
q181751
|
MustAddError
|
test
|
func (r *MapErrorRegistry) MustAddError(code int, err error) {
if e := r.AddError(code, err); e != nil {
panic(e)
}
}
|
go
|
{
"resource": ""
}
|
q181752
|
MustAddMessageError
|
test
|
func (r *MapErrorRegistry) MustAddMessageError(code int, message string) *Error {
err, e := r.AddMessageError(code, message)
if e != nil {
panic(e)
}
return err
}
|
go
|
{
"resource": ""
}
|
q181753
|
AddHandler
|
test
|
func (r *MapErrorRegistry) AddHandler(code int, handler func(body []byte) error) error {
if _, ok := r.errors[code]; ok {
return ErrErrorAlreadyRegistered
}
if _, ok := r.handlers[code]; ok {
return ErrErrorAlreadyRegistered
}
r.handlers[code] = handler
return nil
}
|
go
|
{
"resource": ""
}
|
q181754
|
MustAddHandler
|
test
|
func (r *MapErrorRegistry) MustAddHandler(code int, handler func(body []byte) error) {
if err := r.AddHandler(code, handler); err != nil {
panic(err)
}
}
|
go
|
{
"resource": ""
}
|
q181755
|
Handler
|
test
|
func (r MapErrorRegistry) Handler(code int) func(body []byte) error {
return r.handlers[code]
}
|
go
|
{
"resource": ""
}
|
q181756
|
New
|
test
|
func New(endpoint string, errorRegistry ErrorRegistry) *Client {
return &Client{
Endpoint: endpoint,
ErrorRegistry: errorRegistry,
KeyHeader: DefaultKeyHeader,
HTTPClient: http.DefaultClient,
}
}
|
go
|
{
"resource": ""
}
|
q181757
|
Request
|
test
|
func (c Client) Request(method, path string, query url.Values, body io.Reader, accept []string) (resp *http.Response, err error) {
return c.RequestContext(nil, method, path, query, body, accept)
}
|
go
|
{
"resource": ""
}
|
q181758
|
JSONContext
|
test
|
func (c Client) JSONContext(ctx context.Context, method, path string, query url.Values, body io.Reader, response interface{}) (err error) {
resp, err := c.RequestContext(ctx, method, path, query, body, []string{"application/json"})
if err != nil {
return
}
defer func() {
io.Copy(ioutil.Discard, resp.Body)
resp.Body.Close()
}()
if response != nil {
if resp.ContentLength == 0 {
return errors.New("empty response body")
}
contentType := resp.Header.Get("Content-Type")
if !strings.Contains(contentType, "application/json") {
return fmt.Errorf("unsupported content type: %s", contentType)
}
var body []byte
body, err = ioutil.ReadAll(resp.Body)
if err != nil {
return
}
if err = JSONUnmarshal(body, &response); err != nil {
return
}
}
return
}
|
go
|
{
"resource": ""
}
|
q181759
|
StreamContext
|
test
|
func (c Client) StreamContext(ctx context.Context, method, path string, query url.Values, body io.Reader, accept []string) (data io.ReadCloser, contentType string, err error) {
resp, err := c.RequestContext(ctx, method, path, query, body, accept)
if err != nil {
return
}
contentType = resp.Header.Get("Content-Type")
data = resp.Body
return
}
|
go
|
{
"resource": ""
}
|
q181760
|
Stream
|
test
|
func (c Client) Stream(method, path string, query url.Values, body io.Reader, accept []string) (data io.ReadCloser, contentType string, err error) {
return c.StreamContext(nil, method, path, query, body, accept)
}
|
go
|
{
"resource": ""
}
|
q181761
|
JSONUnmarshal
|
test
|
func JSONUnmarshal(data []byte, v interface{}) error {
if err := json.Unmarshal(data, v); err != nil {
switch e := err.(type) {
case *json.SyntaxError:
line, col := getLineColFromOffset(data, e.Offset)
return fmt.Errorf("json %s, line: %d, column: %d", e, line, col)
case *json.UnmarshalTypeError:
line, col := getLineColFromOffset(data, e.Offset)
return fmt.Errorf("expected json %s value but got %s, line: %d, column: %d", e.Type, e.Value, line, col)
}
return err
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181762
|
ServeTCP
|
test
|
func (s *Server) ServeTCP(ln net.Listener) (err error) {
if l, ok := ln.(*net.TCPListener); ok {
ln = tcpKeepAliveListener{TCPListener: l}
}
if s.TLSConfig != nil {
ln = tls.NewListener(ln, s.TLSConfig)
}
err = s.Server.Serve(ln)
if err == http.ErrServerClosed {
return nil
}
return
}
|
go
|
{
"resource": ""
}
|
q181763
|
ServeTCP
|
test
|
func (s *Server) ServeTCP(ln net.Listener) (err error) {
return s.Server.Serve(ln)
}
|
go
|
{
"resource": ""
}
|
q181764
|
Shutdown
|
test
|
func (s *Server) Shutdown(ctx context.Context) (err error) {
s.Server.GracefulStop()
return
}
|
go
|
{
"resource": ""
}
|
q181765
|
HandleMethods
|
test
|
func HandleMethods(methods map[string]http.Handler, body string, contentType string, w http.ResponseWriter, r *http.Request) {
if handler, ok := methods[r.Method]; ok {
handler.ServeHTTP(w, r)
} else {
allow := []string{}
for k := range methods {
allow = append(allow, k)
}
sort.Strings(allow)
w.Header().Set("Allow", strings.Join(allow, ", "))
if r.Method == "OPTIONS" {
w.WriteHeader(http.StatusOK)
} else {
w.Header().Set("Content-Type", contentType)
w.WriteHeader(http.StatusMethodNotAllowed)
fmt.Fprintln(w, body)
}
}
}
|
go
|
{
"resource": ""
}
|
q181766
|
NewSetHeadersHandler
|
test
|
func NewSetHeadersHandler(h http.Handler, headers map[string]string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
for header, value := range headers {
w.Header().Set(header, value)
}
h.ServeHTTP(w, r)
})
}
|
go
|
{
"resource": ""
}
|
q181767
|
New
|
test
|
func New(root, dir string, options *Options) *Server {
if options == nil {
options = &Options{}
}
return &Server{
Options: *options,
root: root,
dir: dir,
hashes: map[string]string{},
mu: &sync.RWMutex{},
}
}
|
go
|
{
"resource": ""
}
|
q181768
|
HashedPath
|
test
|
func (s *Server) HashedPath(p string) (string, error) {
if s.Hasher == nil {
return path.Join(s.root, p), nil
}
h, cont, err := s.hash(p)
if err != nil {
if cont {
h, _, err = s.hashFromFilename(p)
}
if err != nil {
return "", err
}
}
return path.Join(s.root, s.hashedPath(p, h)), nil
}
|
go
|
{
"resource": ""
}
|
q181769
|
New
|
test
|
func New(options ...Option) (s *Service) {
s = &Service{
logger: stdLogger{},
}
for _, option := range options {
option(s)
}
if s.store == nil {
s.store = NewMemoryStore()
}
return
}
|
go
|
{
"resource": ""
}
|
q181770
|
HTMLHandler
|
test
|
func (s Service) HTMLHandler(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
on, err := s.store.Status()
if err != nil {
s.logger.Errorf("maintenance status: %v", err)
}
if on || err != nil {
if s.HTML.Handler != nil {
s.HTML.Handler.ServeHTTP(w, r)
return
}
w.Header().Set("Content-Type", HTMLContentType)
w.WriteHeader(http.StatusServiceUnavailable)
fmt.Fprintln(w, s.HTML.Body)
return
}
h.ServeHTTP(w, r)
})
}
|
go
|
{
"resource": ""
}
|
q181771
|
Status
|
test
|
func (s Service) Status() (on bool, err error) {
return s.store.Status()
}
|
go
|
{
"resource": ""
}
|
q181772
|
StatusHandler
|
test
|
func (s Service) StatusHandler(w http.ResponseWriter, r *http.Request) {
on, err := s.store.Status()
if err != nil {
s.logger.Errorf("maintenance status: %s", err)
jsonInternalServerErrorResponse(w)
return
}
jsonStatusResponse(w, on)
}
|
go
|
{
"resource": ""
}
|
q181773
|
OnHandler
|
test
|
func (s Service) OnHandler(w http.ResponseWriter, r *http.Request) {
changed, err := s.store.On()
if err != nil {
s.logger.Errorf("maintenance on: %s", err)
jsonInternalServerErrorResponse(w)
return
}
if changed {
s.logger.Infof("maintenance on")
jsonCreatedResponse(w)
return
}
jsonOKResponse(w)
}
|
go
|
{
"resource": ""
}
|
q181774
|
OffHandler
|
test
|
func (s Service) OffHandler(w http.ResponseWriter, r *http.Request) {
changed, err := s.store.Off()
if err != nil {
s.logger.Errorf("maintenance off: %s", err)
jsonInternalServerErrorResponse(w)
return
}
if changed {
s.logger.Infof("maintenance off")
}
jsonOKResponse(w)
}
|
go
|
{
"resource": ""
}
|
q181775
|
MarshalJSON
|
test
|
func (this *PostIRCMessageRequest) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181776
|
MarshalJSON
|
test
|
func (this *PostArtifactRequest) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181777
|
MarshalJSON
|
test
|
func (this *PostArtifactResponse) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181778
|
MarshalJSON
|
test
|
func (this *HookChangedMessage) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181779
|
MarshalJSON
|
test
|
func (this *TriggerHookRequest) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181780
|
MarshalJSON
|
test
|
func (this *TriggerHookResponse) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181781
|
UnmarshalJSON
|
test
|
func (this *TriggerHookResponse) UnmarshalJSON(data []byte) error {
if this == nil {
return errors.New("TriggerHookResponse: UnmarshalJSON on nil pointer")
}
*this = append((*this)[0:0], data...)
return nil
}
|
go
|
{
"resource": ""
}
|
q181782
|
MarshalJSON
|
test
|
func (this *LaunchInfo) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181783
|
MarshalJSON
|
test
|
func (this *Var) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181784
|
MarshalJSON
|
test
|
func (this *Var1) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181785
|
MarshalJSON
|
test
|
func (this *Var3) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181786
|
MarshalJSON
|
test
|
func (t Time) MarshalJSON() ([]byte, error) {
if y := time.Time(t).Year(); y < 0 || y >= 10000 {
// RFC 3339 is clear that years are 4 digits exactly.
// See golang.org/issue/4556#c15 for more discussion.
return nil, errors.New("queue.Time.MarshalJSON: year outside of range [0,9999]")
}
return []byte(`"` + t.String() + `"`), nil
}
|
go
|
{
"resource": ""
}
|
q181787
|
UnmarshalJSON
|
test
|
func (t *Time) UnmarshalJSON(data []byte) (err error) {
// Fractional seconds are handled implicitly by Parse.
x := new(time.Time)
*x, err = time.Parse(`"`+time.RFC3339+`"`, string(data))
*t = Time(*x)
return
}
|
go
|
{
"resource": ""
}
|
q181788
|
Write
|
test
|
func (rws *ReadWriteSeeker) Write(p []byte) (n int, err error) {
minCap := rws.pos + len(p)
if minCap > cap(rws.buf) { // Make sure buf has enough capacity:
buf2 := make([]byte, len(rws.buf), minCap+len(p)) // add some extra
copy(buf2, rws.buf)
rws.buf = buf2
}
if minCap > len(rws.buf) {
rws.buf = rws.buf[:minCap]
}
copy(rws.buf[rws.pos:], p)
rws.pos += len(p)
return len(p), nil
}
|
go
|
{
"resource": ""
}
|
q181789
|
Seek
|
test
|
func (rws *ReadWriteSeeker) Seek(offset int64, whence int) (int64, error) {
newPos, offs := 0, int(offset)
switch whence {
case io.SeekStart:
newPos = offs
case io.SeekCurrent:
newPos = rws.pos + offs
case io.SeekEnd:
newPos = len(rws.buf) + offs
}
if newPos < 0 {
return 0, errors.New("negative result pos")
}
rws.pos = newPos
return int64(newPos), nil
}
|
go
|
{
"resource": ""
}
|
q181790
|
Read
|
test
|
func (rws *ReadWriteSeeker) Read(b []byte) (n int, err error) {
if rws.pos >= len(rws.buf) {
return 0, io.EOF
}
n = copy(b, rws.buf[rws.pos:])
rws.pos += n
return
}
|
go
|
{
"resource": ""
}
|
q181791
|
MarshalJSON
|
test
|
func (this *LaunchSpecsResponse) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181792
|
MarshalJSON
|
test
|
func (this *RegionLaunchSpec) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
}
|
go
|
{
"resource": ""
}
|
q181793
|
GenerateCode
|
test
|
func (apiDefs APIDefinitions) GenerateCode(goOutputDir, modelData string, downloaded time.Time) {
downloadedTime = downloaded
for i := range apiDefs {
apiDefs[i].PackageName = "tc" + strings.ToLower(apiDefs[i].Data.Name())
// Used throughout docs, and also methods that use the class, we need a
// variable name to be used when referencing the go type. It should not
// clash with either the package name or the go type of the principle
// member of the package (e.g. awsprovisioner.AwsProvisioner). We'll
// lowercase the name (e.g. awsProvisioner) and if that clashes with
// either package or principle member, we'll just use my<Name>. This
// results in e.g. `var myQueue queue.Queue`, but `var awsProvisioner
// awsprovisioner.AwsProvisioner`.
apiDefs[i].ExampleVarName = strings.ToLower(string(apiDefs[i].Data.Name()[0])) + apiDefs[i].Data.Name()[1:]
if apiDefs[i].ExampleVarName == apiDefs[i].Data.Name() || apiDefs[i].ExampleVarName == apiDefs[i].PackageName {
apiDefs[i].ExampleVarName = "my" + apiDefs[i].Data.Name()
}
apiDefs[i].PackagePath = filepath.Join(goOutputDir, apiDefs[i].PackageName)
err = os.MkdirAll(apiDefs[i].PackagePath, 0755)
exitOnFail(err)
fmt.Printf("Generating go types for %s\n", apiDefs[i].PackageName)
job := &jsonschema2go.Job{
Package: apiDefs[i].PackageName,
URLs: apiDefs[i].schemaURLs,
ExportTypes: true,
TypeNameBlacklist: apiDefs[i].members,
DisableNestedStructs: true,
}
result, err := job.Execute()
exitOnFail(err)
apiDefs[i].schemas = result.SchemaSet
typesSourceFile := filepath.Join(apiDefs[i].PackagePath, "types.go")
FormatSourceAndSave(typesSourceFile, result.SourceCode)
fmt.Printf("Generating functions and methods for %s\n", job.Package)
content := `
// The following code is AUTO-GENERATED. Please DO NOT edit.
// To update this generated code, run the following command:
// in the /codegenerator/model subdirectory of this project,
// making sure that ` + "`${GOPATH}/bin` is in your `PATH`" + `:
//
// go install && go generate
//
// This package was generated from the schema defined at
// ` + apiDefs[i].URL + `
`
content += apiDefs[i].generateAPICode()
sourceFile := filepath.Join(apiDefs[i].PackagePath, apiDefs[i].PackageName+".go")
FormatSourceAndSave(sourceFile, []byte(content))
}
content := "Generated: " + strconv.FormatInt(downloadedTime.Unix(), 10) + "\n"
content += "The following file is an auto-generated static dump of the API models at time of code generation.\n"
content += "It is provided here for reference purposes, but is not used by any code.\n"
content += "\n"
for i := range apiDefs {
content += text.Underline(apiDefs[i].URL)
content += apiDefs[i].Data.String() + "\n\n"
for _, url := range apiDefs[i].schemas.SortedSanitizedURLs() {
content += text.Underline(url)
content += apiDefs[i].schemas.SubSchema(url).String() + "\n\n"
}
}
exitOnFail(ioutil.WriteFile(modelData, []byte(content), 0644))
}
|
go
|
{
"resource": ""
}
|
q181794
|
postPopulate
|
test
|
func (entry *APIEntry) postPopulate(apiDef *APIDefinition) {
if x := &entry.Parent.apiDef.schemaURLs; entry.Input != "" {
entry.InputURL = tcurls.Schema(tcclient.RootURLFromEnvVars(), entry.Parent.ServiceName, entry.Input)
*x = append(*x, entry.InputURL)
}
if x := &entry.Parent.apiDef.schemaURLs; entry.Output != "" {
entry.OutputURL = tcurls.Schema(tcclient.RootURLFromEnvVars(), entry.Parent.ServiceName, entry.Output)
*x = append(*x, entry.OutputURL)
}
}
|
go
|
{
"resource": ""
}
|
q181795
|
CreateTemporaryCredentials
|
test
|
func (permaCreds *Credentials) CreateTemporaryCredentials(duration time.Duration, scopes ...string) (tempCreds *Credentials, err error) {
return permaCreds.CreateNamedTemporaryCredentials("", duration, scopes...)
}
|
go
|
{
"resource": ""
}
|
q181796
|
setURL
|
test
|
func setURL(client *Client, route string, query url.Values) (u *url.URL, err error) {
URL := client.BaseURL
// See https://bugzil.la/1484702
// Avoid double separator; routes must start with `/`, so baseURL shouldn't
// end with `/`.
if strings.HasSuffix(URL, "/") {
URL = URL[:len(URL)-1]
}
URL += route
u, err = url.Parse(URL)
if err != nil {
return nil, fmt.Errorf("Cannot parse url: '%v', is BaseURL (%v) set correctly?\n%v\n", URL, client.BaseURL, err)
}
if query != nil {
u.RawQuery = query.Encode()
}
return
}
|
go
|
{
"resource": ""
}
|
q181797
|
SignRequest
|
test
|
func (c *Credentials) SignRequest(req *http.Request) (err error) {
// s, err := c.SignHeader(req.Method, req.URL.String(), hash)
// req.Header.Set("Authorization", s)
// return err
credentials := &hawk.Credentials{
ID: c.ClientID,
Key: c.AccessToken,
Hash: sha256.New,
}
reqAuth := hawk.NewRequestAuth(req, credentials, 0)
reqAuth.Ext, err = getExtHeader(c)
if err != nil {
return fmt.Errorf("Internal error: was not able to generate hawk ext header from provided credentials:\n%s\n%s", c, err)
}
req.Header.Set("Authorization", reqAuth.RequestHeader())
return nil
}
|
go
|
{
"resource": ""
}
|
q181798
|
APICall
|
test
|
func (client *Client) APICall(payload interface{}, method, route string, result interface{}, query url.Values) (interface{}, *CallSummary, error) {
rawPayload := []byte{}
var err error
if reflect.ValueOf(payload).IsValid() && !reflect.ValueOf(payload).IsNil() {
rawPayload, err = json.Marshal(payload)
if err != nil {
cs := &CallSummary{
HTTPRequestObject: payload,
}
return result,
cs,
&APICallException{
CallSummary: cs,
RootCause: err,
}
}
}
callSummary, err := client.Request(rawPayload, method, route, query)
callSummary.HTTPRequestObject = payload
if err != nil {
// If context failed during this request, then we should just return that error
if client.Context != nil && client.Context.Err() != nil {
return result, callSummary, client.Context.Err()
}
return result,
callSummary,
&APICallException{
CallSummary: callSummary,
RootCause: err,
}
}
// if result is passed in as nil, it means the API defines no response body
// json
if reflect.ValueOf(result).IsValid() && !reflect.ValueOf(result).IsNil() {
err = json.Unmarshal([]byte(callSummary.HTTPResponseBody), &result)
}
if err != nil {
return result,
callSummary,
&APICallException{
CallSummary: callSummary,
RootCause: err,
}
}
return result, callSummary, nil
}
|
go
|
{
"resource": ""
}
|
q181799
|
SignedURL
|
test
|
func (client *Client) SignedURL(route string, query url.Values, duration time.Duration) (u *url.URL, err error) {
u, err = setURL(client, route, query)
if err != nil {
return
}
credentials := &hawk.Credentials{
ID: client.Credentials.ClientID,
Key: client.Credentials.AccessToken,
Hash: sha256.New,
}
reqAuth, err := hawk.NewURLAuth(u.String(), credentials, duration)
if err != nil {
return
}
reqAuth.Ext, err = getExtHeader(client.Credentials)
if err != nil {
return
}
bewitSignature := reqAuth.Bewit()
if query == nil {
query = url.Values{}
}
query.Set("bewit", bewitSignature)
u.RawQuery = query.Encode()
return
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.