_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q16700 | Verify | train | func (c *client) Verify(owner, name, file string) error {
in := struct {
Data string `json:"data"`
}{Data: file}
uri := fmt.Sprintf(pathVerify, c.addr, owner, name)
return c.post(uri, &in, nil)
} | go | {
"resource": ""
} |
q16701 | Encrypt | train | func (c *client) Encrypt(owner, name string, secret *Secret) (string, error) {
out := struct {
Data string `json:"data"`
}{}
uri := fmt.Sprintf(pathEncryptSecret, c.addr, owner, name)
err := c.post(uri, secret, &out)
return out.Data, err
} | go | {
"resource": ""
} |
q16702 | Secret | train | func (c *client) Secret(owner, name, secret string) (*Secret, error) {
out := new(Secret)
uri := fmt.Sprintf(pathRepoSecret, c.addr, owner, name, secret)
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16703 | SecretList | train | func (c *client) SecretList(owner string, name string) ([]*Secret, error) {
var out []*Secret
uri := fmt.Sprintf(pathRepoSecrets, c.addr, owner, name)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16704 | SecretCreate | train | func (c *client) SecretCreate(owner, name string, in *Secret) (*Secret, error) {
out := new(Secret)
uri := fmt.Sprintf(pathRepoSecrets, c.addr, owner, name)
err := c.post(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16705 | SecretUpdate | train | func (c *client) SecretUpdate(owner, name string, in *Secret) (*Secret, error) {
out := new(Secret)
uri := fmt.Sprintf(pathRepoSecret, c.addr, owner, name, in.Name)
err := c.patch(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16706 | SecretDelete | train | func (c *client) SecretDelete(owner, name, secret string) error {
uri := fmt.Sprintf(pathRepoSecret, c.addr, owner, name, secret)
return c.delete(uri)
} | go | {
"resource": ""
} |
q16707 | OrgSecret | train | func (c *client) OrgSecret(namespace, name string) (*Secret, error) {
out := new(Secret)
uri := fmt.Sprintf(pathSecretsName, c.addr, namespace, name)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16708 | OrgSecretList | train | func (c *client) OrgSecretList(namespace string) ([]*Secret, error) {
var out []*Secret
uri := fmt.Sprintf(pathSecretsNamespace, c.addr, namespace)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16709 | OrgSecretListAll | train | func (c *client) OrgSecretListAll() ([]*Secret, error) {
var out []*Secret
uri := fmt.Sprintf(pathSecrets, c.addr)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16710 | OrgSecretCreate | train | func (c *client) OrgSecretCreate(namespace string, in *Secret) (*Secret, error) {
out := new(Secret)
uri := fmt.Sprintf(pathSecretsNamespace, c.addr, namespace)
err := c.post(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16711 | OrgSecretDelete | train | func (c *client) OrgSecretDelete(namespace, name string) error {
uri := fmt.Sprintf(pathSecretsName, c.addr, namespace, name)
return c.delete(uri)
} | go | {
"resource": ""
} |
q16712 | Cron | train | func (c *client) Cron(owner, name, cron string) (*Cron, error) {
out := new(Cron)
uri := fmt.Sprintf(pathCron, c.addr, owner, name, cron)
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16713 | CronList | train | func (c *client) CronList(owner string, name string) ([]*Cron, error) {
var out []*Cron
uri := fmt.Sprintf(pathCrons, c.addr, owner, name)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16714 | CronCreate | train | func (c *client) CronCreate(owner, name string, in *Cron) (*Cron, error) {
out := new(Cron)
uri := fmt.Sprintf(pathCrons, c.addr, owner, name)
err := c.post(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16715 | CronUpdate | train | func (c *client) CronUpdate(owner, name, cron string, in *CronPatch) (*Cron, error) {
out := new(Cron)
uri := fmt.Sprintf(pathCron, c.addr, owner, name, cron)
err := c.patch(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16716 | CronDelete | train | func (c *client) CronDelete(owner, name, cron string) error {
uri := fmt.Sprintf(pathCron, c.addr, owner, name, cron)
return c.delete(uri)
} | go | {
"resource": ""
} |
q16717 | Queue | train | func (c *client) Queue() ([]*Stage, error) {
var out []*Stage
uri := fmt.Sprintf(pathQueue, c.addr)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16718 | QueueResume | train | func (c *client) QueueResume() error {
uri := fmt.Sprintf(pathQueue, c.addr)
err := c.post(uri, nil, nil)
return err
} | go | {
"resource": ""
} |
q16719 | QueuePause | train | func (c *client) QueuePause() error {
uri := fmt.Sprintf(pathQueue, c.addr)
err := c.delete(uri)
return err
} | go | {
"resource": ""
} |
q16720 | Node | train | func (c *client) Node(name string) (*Node, error) {
out := new(Node)
uri := fmt.Sprintf(pathNode, c.addr, name)
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16721 | NodeList | train | func (c *client) NodeList() ([]*Node, error) {
var out []*Node
uri := fmt.Sprintf(pathNodes, c.addr)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16722 | NodeCreate | train | func (c *client) NodeCreate(in *Node) (*Node, error) {
out := new(Node)
uri := fmt.Sprintf(pathNodes, c.addr)
err := c.post(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16723 | NodeDelete | train | func (c *client) NodeDelete(name string) error {
uri := fmt.Sprintf(pathNode, c.addr, name)
return c.delete(uri)
} | go | {
"resource": ""
} |
q16724 | NodeUpdate | train | func (c *client) NodeUpdate(name string, in *NodePatch) (*Node, error) {
out := new(Node)
uri := fmt.Sprintf(pathNode, c.addr, name)
err := c.patch(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16725 | Server | train | func (c *client) Server(name string) (*Server, error) {
out := new(Server)
uri := fmt.Sprintf(pathServer, c.addr, name)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16726 | ServerList | train | func (c *client) ServerList() ([]*Server, error) {
var out []*Server
uri := fmt.Sprintf(pathServers, c.addr)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16727 | ServerCreate | train | func (c *client) ServerCreate() (*Server, error) {
out := new(Server)
uri := fmt.Sprintf(pathServers, c.addr)
err := c.post(uri, nil, out)
return out, err
} | go | {
"resource": ""
} |
q16728 | ServerDelete | train | func (c *client) ServerDelete(name string) error {
uri := fmt.Sprintf(pathServer, c.addr, name)
return c.delete(uri)
} | go | {
"resource": ""
} |
q16729 | AutoscalePause | train | func (c *client) AutoscalePause() error {
uri := fmt.Sprintf(pathScalerPause, c.addr)
return c.post(uri, nil, nil)
} | go | {
"resource": ""
} |
q16730 | AutoscaleResume | train | func (c *client) AutoscaleResume() error {
uri := fmt.Sprintf(pathScalerResume, c.addr)
return c.post(uri, nil, nil)
} | go | {
"resource": ""
} |
q16731 | AutoscaleVersion | train | func (c *client) AutoscaleVersion() (*Version, error) {
out := new(Version)
uri := fmt.Sprintf(pathVersion, c.addr)
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16732 | get | train | func (c *client) get(rawurl string, out interface{}) error {
return c.do(rawurl, "GET", nil, out)
} | go | {
"resource": ""
} |
q16733 | post | train | func (c *client) post(rawurl string, in, out interface{}) error {
return c.do(rawurl, "POST", in, out)
} | go | {
"resource": ""
} |
q16734 | delete | train | func (c *client) delete(rawurl string) error {
return c.do(rawurl, "DELETE", nil, nil)
} | go | {
"resource": ""
} |
q16735 | mapValues | train | func mapValues(params map[string]string) url.Values {
values := url.Values{}
for key, val := range params {
values.Add(key, val)
}
return values
} | go | {
"resource": ""
} |
q16736 | Client | train | func Client(endpoint, secret string, skipverify bool) Plugin {
client := client.New(endpoint, secret, skipverify)
client.Accept = V1
return &pluginClient{
client: client,
}
} | go | {
"resource": ""
} |
q16737 | Decrypt | train | func Decrypt(ciphertext []byte, key *[32]byte) (plaintext []byte, err error) {
block, err := aes.NewCipher(key[:])
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
if len(ciphertext) < gcm.NonceSize() {
return nil, errors.New("malformed ciphertext")
}
return gcm.Open(nil,
ciphertext[:gcm.NonceSize()],
ciphertext[gcm.NonceSize():],
nil,
)
} | go | {
"resource": ""
} |
q16738 | Key | train | func Key(s string) (*[32]byte, error) {
if len(s) < 32 {
return nil, errInvalidKeyLength
}
var key [32]byte
copy(key[:], []byte(s))
return &key, nil
} | go | {
"resource": ""
} |
q16739 | NewGroup | train | func (g *Group) NewGroup(path string) *Group {
if len(path) < 1 {
panic("Group path must not be empty")
}
checkPath(path)
path = g.path + path
//Don't want trailing slash as all sub-paths start with slash
if path[len(path)-1] == '/' {
path = path[:len(path)-1]
}
return &Group{path, g.mux}
} | go | {
"resource": ""
} |
q16740 | Lookup | train | func (t *TreeMux) Lookup(w http.ResponseWriter, r *http.Request) (LookupResult, bool) {
if t.SafeAddRoutesWhileRunning {
// In concurrency safe mode, we acquire a read lock on the mutex for any access.
// This is optional to avoid potential performance loss in high-usage scenarios.
t.mutex.RLock()
}
result, found := t.lookup(w, r)
if t.SafeAddRoutesWhileRunning {
t.mutex.RUnlock()
}
return result, found
} | go | {
"resource": ""
} |
q16741 | ServeLookupResult | train | func (t *TreeMux) ServeLookupResult(w http.ResponseWriter, r *http.Request, lr LookupResult) {
if lr.handler == nil {
if lr.StatusCode == http.StatusMethodNotAllowed && lr.leafHandler != nil {
if t.SafeAddRoutesWhileRunning {
t.mutex.RLock()
}
t.MethodNotAllowedHandler(w, r, lr.leafHandler)
if t.SafeAddRoutesWhileRunning {
t.mutex.RUnlock()
}
} else {
t.NotFoundHandler(w, r)
}
} else {
r = t.setDefaultRequestContext(r)
lr.handler(w, r, lr.params)
}
} | go | {
"resource": ""
} |
q16742 | MethodNotAllowedHandler | train | func MethodNotAllowedHandler(w http.ResponseWriter, r *http.Request,
methods map[string]HandlerFunc) {
for m := range methods {
w.Header().Add("Allow", m)
}
w.WriteHeader(http.StatusMethodNotAllowed)
} | go | {
"resource": ""
} |
q16743 | SimplePanicHandler | train | func SimplePanicHandler(w http.ResponseWriter, r *http.Request, err interface{}) {
w.WriteHeader(http.StatusInternalServerError)
} | go | {
"resource": ""
} |
q16744 | NewContextGroup | train | func (cg *ContextGroup) NewContextGroup(path string) *ContextGroup {
return &ContextGroup{cg.group.NewGroup(path)}
} | go | {
"resource": ""
} |
q16745 | ContextParams | train | func ContextParams(ctx context.Context) map[string]string {
if p, ok := ctx.Value(paramsContextKey).(map[string]string); ok {
return p
}
return map[string]string{}
} | go | {
"resource": ""
} |
q16746 | AddParamsToContext | train | func AddParamsToContext(ctx context.Context, params map[string]string) context.Context {
return context.WithValue(ctx, paramsContextKey, params)
} | go | {
"resource": ""
} |
q16747 | NewContextMux | train | func NewContextMux() *ContextMux {
mux := New()
cg := mux.UsingContext()
return &ContextMux{
TreeMux: mux,
ContextGroup: cg,
}
} | go | {
"resource": ""
} |
q16748 | Parse | train | func Parse(data []byte) (*ast.Table, error) {
d := &parseState{p: &tomlParser{Buffer: string(data)}}
d.init()
if err := d.parse(); err != nil {
return nil, err
}
return d.p.toml.table, nil
} | go | {
"resource": ""
} |
q16749 | NewDecoder | train | func (cfg *Config) NewDecoder(r io.Reader) *Decoder {
return &Decoder{r, cfg}
} | go | {
"resource": ""
} |
q16750 | Decode | train | func (d *Decoder) Decode(v interface{}) error {
b, err := ioutil.ReadAll(d.r)
if err != nil {
return err
}
return d.cfg.Unmarshal(b, v)
} | go | {
"resource": ""
} |
q16751 | unmarshalTableOrValue | train | func unmarshalTableOrValue(cfg *Config, rv reflect.Value, av interface{}) error {
if (rv.Kind() != reflect.Ptr && rv.Kind() != reflect.Map) || rv.IsNil() {
return &invalidUnmarshalError{rv.Type()}
}
rv = indirect(rv)
switch av.(type) {
case *ast.KeyValue, *ast.Table, []*ast.Table:
if err := unmarshalField(cfg, rv, av); err != nil {
return lineError(fieldLineNumber(av), err)
}
return nil
case ast.Value:
return setValue(cfg, rv, av.(ast.Value))
default:
panic(fmt.Sprintf("BUG: unhandled AST node type %T", av))
}
} | go | {
"resource": ""
} |
q16752 | Encode | train | func (e *Encoder) Encode(v interface{}) error {
var (
buf = &tableBuf{typ: ast.TableTypeNormal}
rv = reflect.ValueOf(v)
err error
)
for rv.Kind() == reflect.Ptr {
if rv.IsNil() {
return &marshalNilError{rv.Type()}
}
rv = rv.Elem()
}
switch rv.Kind() {
case reflect.Struct:
err = buf.structFields(e.cfg, rv)
case reflect.Map:
err = buf.mapFields(e.cfg, rv)
case reflect.Interface:
return e.Encode(rv.Interface())
default:
err = &marshalTableError{rv.Type()}
}
if err != nil {
return err
}
return buf.writeTo(e.w, "")
} | go | {
"resource": ""
} |
q16753 | NewConsumer | train | func NewConsumer(q *Queue, opts ...ConsumerOpt) *Consumer {
c := &Consumer{
q: q,
deliveries: make(chan amqp.Delivery),
errs: make(chan error, 100),
stop: make(chan struct{}),
}
for _, o := range opts {
o(c)
}
return c
} | go | {
"resource": ""
} |
q16754 | AutoTag | train | func AutoTag() ConsumerOpt {
return func(c *Consumer) {
host, _ := os.Hostname()
tag := fmt.Sprintf(c.q.Name+"-pid-%d@%s", os.Getpid(), host)
Tag(tag)(c)
}
} | go | {
"resource": ""
} |
q16755 | Cancel | train | func (p *Publisher) Cancel() {
p.m.Lock()
defer p.m.Unlock()
if !p.dead {
close(p.stop)
p.dead = true
}
} | go | {
"resource": ""
} |
q16756 | NewPublisher | train | func NewPublisher(exchange string, key string, opts ...PublisherOpt) *Publisher {
p := &Publisher{
exchange: exchange,
key: key,
pubChan: make(chan publishMaybeErr),
stop: make(chan struct{}),
}
for _, o := range opts {
o(p)
}
return p
} | go | {
"resource": ""
} |
q16757 | PublishingTemplate | train | func PublishingTemplate(t amqp.Publishing) PublisherOpt {
return func(p *Publisher) {
p.tmpl = t
}
} | go | {
"resource": ""
} |
q16758 | DeclareQueue | train | func DeclareQueue(q *Queue) Declaration {
name := q.Name
return func(c Declarer) error {
q.Name = name
realQ, err := c.QueueDeclare(q.Name,
q.Durable,
q.AutoDelete,
q.Exclusive,
false,
q.Args,
)
q.l.Lock()
q.Name = realQ.Name
q.l.Unlock()
return err
}
} | go | {
"resource": ""
} |
q16759 | DeclareExchange | train | func DeclareExchange(e Exchange) Declaration {
return func(c Declarer) error {
return c.ExchangeDeclare(e.Name,
e.Kind,
e.Durable,
e.AutoDelete,
false,
false,
e.Args,
)
}
} | go | {
"resource": ""
} |
q16760 | DeclareBinding | train | func DeclareBinding(b Binding) Declaration {
return func(c Declarer) error {
return c.QueueBind(b.Queue.Name,
b.Key,
b.Exchange.Name,
false,
b.Args,
)
}
} | go | {
"resource": ""
} |
q16761 | Backoff | train | func (b BackoffPolicy) Backoff(n int) time.Duration {
if n >= len(b.ms) {
n = len(b.ms) - 1
}
return time.Duration(jitter(b.ms[n])) * time.Millisecond
} | go | {
"resource": ""
} |
q16762 | Consume | train | func (c *Client) Consume(cons *Consumer) {
c.l.Lock()
defer c.l.Unlock()
c.consumers[cons] = struct{}{}
if ch, err := c.channel(); err == nil {
go cons.serve(c, ch)
}
} | go | {
"resource": ""
} |
q16763 | Publish | train | func (c *Client) Publish(pub *Publisher) {
c.l.Lock()
defer c.l.Unlock()
c.publishers[pub] = struct{}{}
if ch, err := c.channel(); err == nil {
go pub.serve(c, ch)
}
} | go | {
"resource": ""
} |
q16764 | Close | train | func (c *Client) Close() {
atomic.StoreInt32(&c.run, noRun) // c.run = false
conn, _ := c.conn.Load().(*amqp.Connection)
if conn != nil {
conn.Close()
}
c.conn.Store((*amqp.Connection)(nil))
} | go | {
"resource": ""
} |
q16765 | NewClient | train | func NewClient(opts ...ClientOpt) *Client {
c := &Client{
run: run,
declarations: make([]Declaration, 0),
consumers: make(map[*Consumer]struct{}),
publishers: make(map[*Publisher]struct{}),
errs: make(chan error, 100),
blocking: make(chan amqp.Blocking, 10),
}
for _, o := range opts {
o(c)
}
return c
} | go | {
"resource": ""
} |
q16766 | BlockingChan | train | func BlockingChan(blockingChan chan amqp.Blocking) ClientOpt {
return func(c *Client) {
c.blocking = blockingChan
}
} | go | {
"resource": ""
} |
q16767 | Config | train | func Config(config amqp.Config) ClientOpt {
return func(c *Client) {
c.config = config
}
} | go | {
"resource": ""
} |
q16768 | Logger | train | func Logger(log *logrus.Logger) gin.HandlerFunc {
hostname, err := os.Hostname()
if err != nil {
hostname = "unknow"
}
return func(c *gin.Context) {
// other handler can change c.Path so:
path := c.Request.URL.Path
start := time.Now()
c.Next()
stop := time.Since(start)
latency := int(math.Ceil(float64(stop.Nanoseconds()) / 1000000.0))
statusCode := c.Writer.Status()
clientIP := c.ClientIP()
clientUserAgent := c.Request.UserAgent()
referer := c.Request.Referer()
dataLength := c.Writer.Size()
if dataLength < 0 {
dataLength = 0
}
entry := logrus.NewEntry(log).WithFields(logrus.Fields{
"hostname": hostname,
"statusCode": statusCode,
"latency": latency, // time to process
"clientIP": clientIP,
"method": c.Request.Method,
"path": path,
"referer": referer,
"dataLength": dataLength,
"userAgent": clientUserAgent,
})
if len(c.Errors) > 0 {
entry.Error(c.Errors.ByType(gin.ErrorTypePrivate).String())
} else {
msg := fmt.Sprintf("%s - %s [%s] \"%s %s\" %d %d \"%s\" \"%s\" (%dms)", clientIP, hostname, time.Now().Format(timeFormat), c.Request.Method, path, statusCode, dataLength, referer, clientUserAgent, latency)
if statusCode > 499 {
entry.Error(msg)
} else if statusCode > 399 {
entry.Warn(msg)
} else {
entry.Info(msg)
}
}
}
} | go | {
"resource": ""
} |
q16769 | GetAuthnRequest | train | func (s *ServiceProviderSettings) GetAuthnRequest() *AuthnRequest {
r := NewAuthnRequest()
r.AssertionConsumerServiceURL = s.AssertionConsumerServiceURL
r.Destination = s.IDPSSOURL
r.Issuer.Url = s.IDPSSODescriptorURL
r.Signature.KeyInfo.X509Data.X509Certificate.Cert = s.PublicCert()
if !s.SPSignRequest {
r.SAMLSIG = ""
r.Signature = nil
}
return r
} | go | {
"resource": ""
} |
q16770 | GetAuthnRequestURL | train | func GetAuthnRequestURL(baseURL string, b64XML string, state string) (string, error) {
u, err := url.Parse(baseURL)
if err != nil {
return "", err
}
q := u.Query()
q.Add("SAMLRequest", b64XML)
q.Add("RelayState", state)
u.RawQuery = q.Encode()
return u.String(), nil
} | go | {
"resource": ""
} |
q16771 | LoadCertificate | train | func LoadCertificate(certPath string) (string, error) {
b, err := ioutil.ReadFile(certPath)
if err != nil {
return "", err
}
cert := string(b)
re := regexp.MustCompile("---(.*)CERTIFICATE(.*)---")
cert = re.ReplaceAllString(cert, "")
cert = strings.Trim(cert, " \n")
cert = strings.Replace(cert, "\n", "", -1)
return cert, nil
} | go | {
"resource": ""
} |
q16772 | ID | train | func ID() string {
u, err := uuid.NewV4()
if err != nil {
panic(err)
}
return "_" + u.String()
} | go | {
"resource": ""
} |
q16773 | AddAttribute | train | func (r *Response) AddAttribute(name, value string) {
r.Assertion.AttributeStatement.Attributes = append(r.Assertion.AttributeStatement.Attributes, Attribute{
XMLName: xml.Name{
Local: "saml:Attribute",
},
Name: name,
NameFormat: "urn:oasis:names:tc:SAML:2.0:attrname-format:basic",
AttributeValues: []AttributeValue{
{
XMLName: xml.Name{
Local: "saml:AttributeValue",
},
Type: "xs:string",
Value: value,
},
},
})
} | go | {
"resource": ""
} |
q16774 | GetAttribute | train | func (r *Response) GetAttribute(name string) string {
for _, attr := range r.Assertion.AttributeStatement.Attributes {
if attr.Name == name || attr.FriendlyName == name {
return attr.AttributeValues[0].Value
}
}
return ""
} | go | {
"resource": ""
} |
q16775 | SignRequest | train | func SignRequest(xml string, privateKeyPath string) (string, error) {
return sign(xml, privateKeyPath, xmlRequestID)
} | go | {
"resource": ""
} |
q16776 | SignResponse | train | func SignResponse(xml string, privateKeyPath string) (string, error) {
return sign(xml, privateKeyPath, xmlResponseID)
} | go | {
"resource": ""
} |
q16777 | VerifyResponseSignature | train | func VerifyResponseSignature(xml string, publicCertPath string) error {
return verify(xml, publicCertPath, xmlResponseID)
} | go | {
"resource": ""
} |
q16778 | VerifyRequestSignature | train | func VerifyRequestSignature(xml string, publicCertPath string) error {
return verify(xml, publicCertPath, xmlRequestID)
} | go | {
"resource": ""
} |
q16779 | Head | train | func Head(url string, a *Args) (resp *Response, err error) {
resp, err = newRequest("HEAD", url, a)
return
} | go | {
"resource": ""
} |
q16780 | Reset | train | func (req *Request) Reset() {
req.Headers = map[string]string{}
for k, v := range DefaultHeaders {
req.Headers[k] = v
}
req.Cookies = nil
req.Data = nil
req.Params = nil
req.Files = nil
req.Json = nil
req.Proxy = ""
req.BasicAuth = BasicAuth{}
req.Body = nil
return
} | go | {
"resource": ""
} |
q16781 | Json | train | func (resp *Response) Json() (*simplejson.Json, error) {
b, err := resp.Content()
if err != nil {
return nil, err
}
return simplejson.NewJson(b)
} | go | {
"resource": ""
} |
q16782 | Text | train | func (resp *Response) Text() (string, error) {
b, err := resp.Content()
s := string(b)
return s, err
} | go | {
"resource": ""
} |
q16783 | URL | train | func (resp *Response) URL() (*url.URL, error) {
u := resp.Request.URL
switch resp.StatusCode {
case http.StatusMovedPermanently, http.StatusFound,
http.StatusSeeOther, http.StatusTemporaryRedirect:
location, err := resp.Location()
if err != nil {
return nil, err
}
u = u.ResolveReference(location)
}
return u, nil
} | go | {
"resource": ""
} |
q16784 | addPackage | train | func (r *report) addPackage(p *gocov.Package) {
i := sort.Search(len(r.packages), func(i int) bool {
return r.packages[i].Name >= p.Name
})
if i < len(r.packages) && r.packages[i].Name == p.Name {
r.packages[i].Accumulate(p)
} else {
head := r.packages[:i]
tail := append([]*gocov.Package{p}, r.packages[i:]...)
r.packages = append(head, tail...)
}
} | go | {
"resource": ""
} |
q16785 | printReport | train | func printReport(w io.Writer, r *report) {
css := defaultCSS
if len(r.stylesheet) > 0 {
css = fmt.Sprintf("<link rel=\"stylesheet\" href=\"%s\" />", r.stylesheet)
}
fmt.Fprintf(w, htmlHeader, css)
reportPackages := make(reportPackageList, len(r.packages))
for i, pkg := range r.packages {
reportPackages[i] = buildReportPackage(pkg)
}
if len(reportPackages) == 0 {
fmt.Fprintf(w, "<p>no test files in package.</p>")
fmt.Fprintf(w, htmlFooter)
return
}
summaryPackage := reportPackages[0]
fmt.Fprintf(w, "<div id=\"about\">Generated on %s with <a href=\"%s\">gocov-html</a></div>",
time.Now().Format(time.RFC822Z), ProjectUrl)
if len(reportPackages) > 1 {
summaryPackage = printReportOverview(w, reportPackages)
}
w = tabwriter.NewWriter(w, 0, 8, 0, '\t', 0)
for _, rp := range reportPackages {
printPackage(w, r, rp)
fmt.Fprintln(w)
}
printReportSummary(w, summaryPackage)
fmt.Fprintf(w, htmlFooter)
} | go | {
"resource": ""
} |
q16786 | NewClient | train | func NewClient(machines []string) *Client {
config := Config{
// default timeout is one second
DialTimeout: time.Second,
}
client := &Client{
Cluster: NewCluster(machines),
Config: config,
}
client.initHTTPClient()
return client
} | go | {
"resource": ""
} |
q16787 | NewTLSClient | train | func NewTLSClient(machines []string, cert string, key string, caCerts []string) (*Client, error) {
// overwrite the default machine to use https
if len(machines) == 0 {
machines = []string{"https://127.0.0.1:4001"}
}
config := Config{
// default timeout is one second
DialTimeout: time.Second,
CertFile: cert,
KeyFile: key,
CaCertFile: make([]string, 0),
}
client := &Client{
Cluster: NewCluster(machines),
Config: config,
}
err := client.initHTTPSClient(cert, key)
if err != nil {
return nil, err
}
for _, caCert := range caCerts {
if err := client.AddRootCA(caCert); err != nil {
return nil, err
}
}
return client, nil
} | go | {
"resource": ""
} |
q16788 | NewClientFromFile | train | func NewClientFromFile(fpath string) (*Client, error) {
fi, err := os.Open(fpath)
if err != nil {
return nil, err
}
defer func() {
if err := fi.Close(); err != nil {
panic(err)
}
}()
return NewClientFromReader(fi)
} | go | {
"resource": ""
} |
q16789 | NewClientFromReader | train | func NewClientFromReader(reader io.Reader) (*Client, error) {
c := new(Client)
b, err := ioutil.ReadAll(reader)
if err != nil {
return nil, err
}
err = json.Unmarshal(b, c)
if err != nil {
return nil, err
}
if c.Config.CertFile == "" {
c.initHTTPClient()
} else {
err = c.initHTTPSClient(c.Config.CertFile, c.Config.KeyFile)
}
if err != nil {
return nil, err
}
for _, caCert := range c.Config.CaCertFile {
if err := c.AddRootCA(caCert); err != nil {
return nil, err
}
}
return c, nil
} | go | {
"resource": ""
} |
q16790 | SetTransport | train | func (c *Client) SetTransport(tr *http.Transport) {
c.httpClient.Transport = tr
} | go | {
"resource": ""
} |
q16791 | initHTTPClient | train | func (c *Client) initHTTPClient() {
tr := &http.Transport{
Dial: c.dial,
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
}
c.httpClient = &http.Client{Transport: tr}
} | go | {
"resource": ""
} |
q16792 | initHTTPSClient | train | func (c *Client) initHTTPSClient(cert, key string) error {
if cert == "" || key == "" {
return errors.New("Require both cert and key path")
}
tlsCert, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
return err
}
tlsConfig := &tls.Config{
Certificates: []tls.Certificate{tlsCert},
InsecureSkipVerify: true,
}
tr := &http.Transport{
TLSClientConfig: tlsConfig,
Dial: c.dial,
}
c.httpClient = &http.Client{Transport: tr}
return nil
} | go | {
"resource": ""
} |
q16793 | SetDialTimeout | train | func (c *Client) SetDialTimeout(d time.Duration) {
c.Config.DialTimeout = d
} | go | {
"resource": ""
} |
q16794 | AddRootCA | train | func (c *Client) AddRootCA(caCert string) error {
if c.httpClient == nil {
return errors.New("Client has not been initialized yet!")
}
certBytes, err := ioutil.ReadFile(caCert)
if err != nil {
return err
}
tr, ok := c.httpClient.Transport.(*http.Transport)
if !ok {
panic("AddRootCA(): Transport type assert should not fail")
}
if tr.TLSClientConfig.RootCAs == nil {
caCertPool := x509.NewCertPool()
ok = caCertPool.AppendCertsFromPEM(certBytes)
if ok {
tr.TLSClientConfig.RootCAs = caCertPool
}
tr.TLSClientConfig.InsecureSkipVerify = false
} else {
ok = tr.TLSClientConfig.RootCAs.AppendCertsFromPEM(certBytes)
}
if !ok {
err = errors.New("Unable to load caCert")
}
c.Config.CaCertFile = append(c.Config.CaCertFile, caCert)
return err
} | go | {
"resource": ""
} |
q16795 | SetCluster | train | func (c *Client) SetCluster(machines []string) bool {
success := c.internalSyncCluster(machines)
return success
} | go | {
"resource": ""
} |
q16796 | internalSyncCluster | train | func (c *Client) internalSyncCluster(machines []string) bool {
for _, machine := range machines {
httpPath := c.createHttpPath(machine, "machines")
resp, err := c.httpClient.Get(httpPath)
if err != nil {
// try another machine in the cluster
continue
} else {
b, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
// try another machine in the cluster
continue
}
// update Machines List
c.Cluster.updateFromStr(string(b))
// update leader
// the first one in the machine list is the leader
c.Cluster.switchLeader(0)
logger.Debug("sync.machines " + strings.Join(c.Cluster.Machines, ", "))
return true
}
}
return false
} | go | {
"resource": ""
} |
q16797 | createHttpPath | train | func (c *Client) createHttpPath(serverName string, _path string) string {
u, err := url.Parse(serverName)
if err != nil {
panic(err)
}
u.Path = path.Join(u.Path, _path)
if u.Scheme == "" {
u.Scheme = "http"
}
return u.String()
} | go | {
"resource": ""
} |
q16798 | dial | train | func (c *Client) dial(network, addr string) (net.Conn, error) {
conn, err := net.DialTimeout(network, addr, c.Config.DialTimeout)
if err != nil {
return nil, err
}
tcpConn, ok := conn.(*net.TCPConn)
if !ok {
return nil, errors.New("Failed type-assertion of net.Conn as *net.TCPConn")
}
// Keep TCP alive to check whether or not the remote machine is down
if err = tcpConn.SetKeepAlive(true); err != nil {
return nil, err
}
if err = tcpConn.SetKeepAlivePeriod(time.Second); err != nil {
return nil, err
}
return tcpConn, nil
} | go | {
"resource": ""
} |
q16799 | MarshalJSON | train | func (c *Client) MarshalJSON() ([]byte, error) {
b, err := json.Marshal(struct {
Config Config `json:"config"`
Cluster *Cluster `json:"cluster"`
}{
Config: c.Config,
Cluster: c.Cluster,
})
if err != nil {
return nil, err
}
return b, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.