id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c16700 | string `json:"data"`
}{Data: file}
uri := fmt.Sprintf(pathVerify, c.addr, owner, name)
return c.post(uri, &in, nil)
} | |
c16701 | string `json:"data"`
}{}
uri := fmt.Sprintf(pathEncryptSecret, c.addr, owner, name)
err := c.post(uri, secret, &out)
return out.Data, err
} | |
c16702 | c.addr, owner, name, secret)
err := c.get(uri, out)
return out, err
} | |
c16703 | := fmt.Sprintf(pathRepoSecrets, c.addr, owner, name)
err := c.get(uri, &out)
return out, err
} | |
c16704 | := fmt.Sprintf(pathRepoSecrets, c.addr, owner, name)
err := c.post(uri, in, out)
return out, err
} | |
c16705 | fmt.Sprintf(pathRepoSecret, c.addr, owner, name, in.Name)
err := c.patch(uri, in, out)
return out, err
} | |
c16706 | fmt.Sprintf(pathRepoSecret, c.addr, owner, name, secret)
return c.delete(uri)
} | |
c16707 | c.addr, namespace, name)
err := c.get(uri, &out)
return out, err
} | |
c16708 | fmt.Sprintf(pathSecretsNamespace, c.addr, namespace)
err := c.get(uri, &out)
return out, err
} | |
c16709 | fmt.Sprintf(pathSecrets, c.addr)
err := c.get(uri, &out)
return out, err
} | |
c16710 | := fmt.Sprintf(pathSecretsNamespace, c.addr, namespace)
err := c.post(uri, in, out)
return out, err
} | |
c16711 | fmt.Sprintf(pathSecretsName, c.addr, namespace, name)
return c.delete(uri)
} | |
c16712 | new(Cron)
uri := fmt.Sprintf(pathCron, c.addr, owner, name, cron)
err := c.get(uri, out)
return out, err
} | |
c16713 | out []*Cron
uri := fmt.Sprintf(pathCrons, c.addr, owner, name)
err := c.get(uri, &out)
return out, err
} | |
c16714 | := new(Cron)
uri := fmt.Sprintf(pathCrons, c.addr, owner, name)
err := c.post(uri, in, out)
return out, err
} | |
c16715 | c.addr, owner, name, cron)
err := c.patch(uri, in, out)
return out, err
} | |
c16716 | fmt.Sprintf(pathCron, c.addr, owner, name, cron)
return c.delete(uri)
} | |
c16717 | c.addr)
err := c.get(uri, &out)
return out, err
} | |
c16718 | c.addr)
err := c.post(uri, nil, nil)
return err
} | |
c16719 | fmt.Sprintf(pathQueue, c.addr)
err := c.delete(uri)
return err
} | |
c16720 | c.addr, name)
err := c.get(uri, out)
return out, err
} | |
c16721 | c.addr)
err := c.get(uri, &out)
return out, err
} | |
c16722 | c.addr)
err := c.post(uri, in, out)
return out, err
} | |
c16723 | fmt.Sprintf(pathNode, c.addr, name)
return c.delete(uri)
} | |
c16724 | out := new(Node)
uri := fmt.Sprintf(pathNode, c.addr, name)
err := c.patch(uri, in, out)
return out, err
} | |
c16725 | c.addr, name)
err := c.get(uri, &out)
return out, err
} | |
c16726 | c.addr)
err := c.get(uri, &out)
return out, err
} | |
c16727 | c.addr)
err := c.post(uri, nil, out)
return out, err
} | |
c16728 | fmt.Sprintf(pathServer, c.addr, name)
return c.delete(uri)
} | |
c16729 | fmt.Sprintf(pathScalerPause, c.addr)
return c.post(uri, nil, nil)
} | |
c16730 | fmt.Sprintf(pathScalerResume, c.addr)
return c.post(uri, nil, nil)
} | |
c16731 | c.addr)
err := c.get(uri, out)
return out, err
} | |
c16732 | c.do(rawurl, "GET", nil, out)
} | |
c16733 | return c.do(rawurl, "POST", in, out)
} | |
c16734 | c.do(rawurl, "DELETE", nil, nil)
} | |
c16735 | := url.Values{}
for key, val := range params {
values.Add(key, val)
}
return values
} | |
c16736 | client.Accept = V1
return &pluginClient{
client: client,
}
} | |
c16737 | < gcm.NonceSize() {
return nil, errors.New("malformed ciphertext")
}
return gcm.Open(nil,
ciphertext[:gcm.NonceSize()],
ciphertext[gcm.NonceSize():],
nil,
)
} | |
c16738 | nil, errInvalidKeyLength
}
var key [32]byte
copy(key[:], []byte(s))
return &key, nil
} | |
c16739 | 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}
} | |
c16740 | in high-usage scenarios.
t.mutex.RLock()
}
result, found := t.lookup(w, r)
if t.SafeAddRoutesWhileRunning {
t.mutex.RUnlock()
}
return result, found
} | |
c16741 | lr.leafHandler)
if t.SafeAddRoutesWhileRunning {
t.mutex.RUnlock()
}
} else {
t.NotFoundHandler(w, r)
}
} else {
r = t.setDefaultRequestContext(r)
lr.handler(w, r, lr.params)
}
} | |
c16742 |
w.Header().Add("Allow", m)
}
w.WriteHeader(http.StatusMethodNotAllowed)
} | |
c16743 | w.WriteHeader(http.StatusInternalServerError)
} | |
c16744 | &ContextGroup{cg.group.NewGroup(path)}
} | |
c16745 | := ctx.Value(paramsContextKey).(map[string]string); ok {
return p
}
return map[string]string{}
} | |
c16746 | context.WithValue(ctx, paramsContextKey, params)
} | |
c16747 |
TreeMux: mux,
ContextGroup: cg,
}
} | |
c16748 | err != nil {
return nil, err
}
return d.p.toml.table, nil
} | |
c16749 | *Decoder {
return &Decoder{r, cfg}
} | |
c16750 | return err
}
return d.cfg.Unmarshal(b, v)
} | |
c16751 | 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))
}
} | |
c16752 | }
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... | |
c16753 | make(chan struct{}),
}
for _, o := range opts {
o(c)
}
return c
} | |
c16754 | tag := fmt.Sprintf(c.q.Name+"-pid-%d@%s", os.Getpid(), host)
Tag(tag)(c)
}
} | |
c16755 | p.m.Unlock()
if !p.dead {
close(p.stop)
p.dead = true
}
} | |
c16756 | stop: make(chan struct{}),
}
for _, o := range opts {
o(p)
}
return p
} | |
c16757 | func(p *Publisher) {
p.tmpl = t
}
} | |
c16758 | false,
q.Args,
)
q.l.Lock()
q.Name = realQ.Name
q.l.Unlock()
return err
}
} | |
c16759 | e.Durable,
e.AutoDelete,
false,
false,
e.Args,
)
}
} | |
c16760 | b.Key,
b.Exchange.Name,
false,
b.Args,
)
}
} | |
c16761 | }
return time.Duration(jitter(b.ms[n])) * time.Millisecond
} | |
c16762 | c.channel(); err == nil {
go cons.serve(c, ch)
}
} | |
c16763 | c.channel(); err == nil {
go pub.serve(c, ch)
}
} | |
c16764 | _ := c.conn.Load().(*amqp.Connection)
if conn != nil {
conn.Close()
}
c.conn.Store((*amqp.Connection)(nil))
} | |
c16765 | error, 100),
blocking: make(chan amqp.Blocking, 10),
}
for _, o := range opts {
o(c)
}
return c
} | |
c16766 | func(c *Client) {
c.blocking = blockingChan
}
} | |
c16767 | *Client) {
c.config = config
}
} | |
c16768 | 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.Metho... | |
c16769 | r.Signature.KeyInfo.X509Data.X509Certificate.Cert = s.PublicCert()
if !s.SPSignRequest {
r.SAMLSIG = ""
r.Signature = nil
}
return r
} | |
c16770 |
q.Add("SAMLRequest", b64XML)
q.Add("RelayState", state)
u.RawQuery = q.Encode()
return u.String(), nil
} | |
c16771 | re.ReplaceAllString(cert, "")
cert = strings.Trim(cert, " \n")
cert = strings.Replace(cert, "\n", "", -1)
return cert, nil
} | |
c16772 |
if err != nil {
panic(err)
}
return "_" + u.String()
} | |
c16773 |
AttributeValues: []AttributeValue{
{
XMLName: xml.Name{
Local: "saml:AttributeValue",
},
Type: "xs:string",
Value: value,
},
},
})
} | |
c16774 | == name {
return attr.AttributeValues[0].Value
}
}
return ""
} | |
c16775 | return sign(xml, privateKeyPath, xmlRequestID)
} | |
c16776 | return sign(xml, privateKeyPath, xmlResponseID)
} | |
c16777 | return verify(xml, publicCertPath, xmlResponseID)
} | |
c16778 | return verify(xml, publicCertPath, xmlRequestID)
} | |
c16779 | err error) {
resp, err = newRequest("HEAD", url, a)
return
} | |
c16780 | = nil
req.Json = nil
req.Proxy = ""
req.BasicAuth = BasicAuth{}
req.Body = nil
return
} | |
c16781 |
return nil, err
}
return simplejson.NewJson(b)
} | |
c16782 | {
b, err := resp.Content()
s := string(b)
return s, err
} | |
c16783 | resp.Location()
if err != nil {
return nil, err
}
u = u.ResolveReference(location)
}
return u, nil
} | |
c16784 | := r.packages[:i]
tail := append([]*gocov.Package{p}, r.packages[i:]...)
r.packages = append(head, tail...)
}
} | |
c16785 | 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)
} | |
c16786 | &Client{
Cluster: NewCluster(machines),
Config: config,
}
client.initHTTPClient()
return client
} | |
c16787 | 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
} | |
c16788 | := fi.Close(); err != nil {
panic(err)
}
}()
return NewClientFromReader(fi)
} | |
c16789 | }
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
} | |
c16790 | *http.Transport) {
c.httpClient.Transport = tr
} | |
c16791 | TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
}
c.httpClient = &http.Client{Transport: tr}
} | |
c16792 | 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
} | |
c16793 | time.Duration) {
c.Config.DialTimeout = d
} | |
c16794 | }
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
} | |
c16795 | := c.internalSyncCluster(machines)
return success
} | |
c16796 |
// 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
} | |
c16797 | if err != nil {
panic(err)
}
u.Path = path.Join(u.Path, _path)
if u.Scheme == "" {
u.Scheme = "http"
}
return u.String()
} | |
c16798 | 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
} | |
c16799 | Config: c.Config,
Cluster: c.Cluster,
})
if err != nil {
return nil, err
}
return b, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.