id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
153,500 | mozilla/tls-observatory | database/stats.go | CountLast24HoursScans | func (db *DB) CountLast24HoursScans() (hourlyStats []HourlyScansCount, err error) {
rows, err := db.Query(`SELECT DATE_TRUNC('hour', "timestamp") AS hour, COUNT(*)
FROM scans
WHERE timestamp > NOW() - INTERVAL '24 hours' AND ack=true AND completion_perc=100
GROUP BY DATE_TRUNC('hour', "timestamp") ORDER BY 1 DESC`)
if err != nil {
return
}
for rows.Next() {
var hsc HourlyScansCount
err = rows.Scan(&hsc.Hour, &hsc.Count)
if err != nil {
return
}
hourlyStats = append(hourlyStats, hsc)
}
return
} | go | func (db *DB) CountLast24HoursScans() (hourlyStats []HourlyScansCount, err error) {
rows, err := db.Query(`SELECT DATE_TRUNC('hour', "timestamp") AS hour, COUNT(*)
FROM scans
WHERE timestamp > NOW() - INTERVAL '24 hours' AND ack=true AND completion_perc=100
GROUP BY DATE_TRUNC('hour', "timestamp") ORDER BY 1 DESC`)
if err != nil {
return
}
for rows.Next() {
var hsc HourlyScansCount
err = rows.Scan(&hsc.Hour, &hsc.Count)
if err != nil {
return
}
hourlyStats = append(hourlyStats, hsc)
}
return
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"CountLast24HoursScans",
"(",
")",
"(",
"hourlyStats",
"[",
"]",
"HourlyScansCount",
",",
"err",
"error",
")",
"{",
"rows",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"`SELECT DATE_TRUNC('hour', \"timestamp\") AS hour, COUNT(*) \n\t\t\t\t FROM scans\n\t\t\t\t WHERE timestamp > NOW() - INTERVAL '24 hours' AND ack=true AND completion_perc=100\n\t\t\t\t GROUP BY DATE_TRUNC('hour', \"timestamp\") ORDER BY 1 DESC`",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"var",
"hsc",
"HourlyScansCount",
"\n",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"hsc",
".",
"Hour",
",",
"&",
"hsc",
".",
"Count",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"hourlyStats",
"=",
"append",
"(",
"hourlyStats",
",",
"hsc",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // CountLast24HoursScans returns a list of hourly scans count for the last 24 hours, sorted
// from most recent the oldest | [
"CountLast24HoursScans",
"returns",
"a",
"list",
"of",
"hourly",
"scans",
"count",
"for",
"the",
"last",
"24",
"hours",
"sorted",
"from",
"most",
"recent",
"the",
"oldest"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/database/stats.go#L79-L96 |
153,501 | mozilla/tls-observatory | database/stats.go | CountTargetsLast24Hours | func (db *DB) CountTargetsLast24Hours() (count, countDistinct int64, err error) {
err = db.QueryRow(`SELECT COUNT(target), COUNT(DISTINCT(target))
FROM scans
WHERE timestamp > NOW() - INTERVAL '24 hours'
AND ack=true
AND completion_perc=100`).Scan(&count, &countDistinct)
return
} | go | func (db *DB) CountTargetsLast24Hours() (count, countDistinct int64, err error) {
err = db.QueryRow(`SELECT COUNT(target), COUNT(DISTINCT(target))
FROM scans
WHERE timestamp > NOW() - INTERVAL '24 hours'
AND ack=true
AND completion_perc=100`).Scan(&count, &countDistinct)
return
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"CountTargetsLast24Hours",
"(",
")",
"(",
"count",
",",
"countDistinct",
"int64",
",",
"err",
"error",
")",
"{",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"`SELECT COUNT(target), COUNT(DISTINCT(target))\n\t\t\t\t FROM scans\n\t\t\t\t WHERE timestamp > NOW() - INTERVAL '24 hours'\n\t\t\t\t AND ack=true\n\t\t\t\t AND completion_perc=100`",
")",
".",
"Scan",
"(",
"&",
"count",
",",
"&",
"countDistinct",
")",
"\n",
"return",
"\n",
"}"
] | // CountTargetsLast24Hours returns the number of unique targets scanned over the last 24 hours | [
"CountTargetsLast24Hours",
"returns",
"the",
"number",
"of",
"unique",
"targets",
"scanned",
"over",
"the",
"last",
"24",
"hours"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/database/stats.go#L99-L106 |
153,502 | mozilla/tls-observatory | tlsobs-scanner/analyser.go | isChainValid | func isChainValid(endEntity *x509.Certificate, intermediates []*x509.Certificate, truststore *certificate.TrustStore, domain, IP string, certmap map[string]certificate.Certificate) bool {
valInfo := &certificate.ValidationInfo{
IsValid: true,
}
// build a CA verification pool from the list of cacerts
interPool := x509.NewCertPool()
for _, entity := range intermediates {
interPool.AddCert(entity)
}
// get a list of domains this certificate is supposedly valid for
// if the end entity is a CA, use its common name
dnsName := domain
if endEntity.IsCA {
dnsName = endEntity.Subject.CommonName
}
// configure the verification logic to use the current trustore
opts := x509.VerifyOptions{
DNSName: dnsName,
Intermediates: interPool,
Roots: truststore.Certs,
}
// Verify attempts to build all the path between the end entity and the
// root in the truststore that validate the certificate
// If no valid path is found, err is not nil and the certificate is not trusted
chains, err := endEntity.Verify(opts)
if err == nil {
// the end entity is trusted, we need to go through each
// chain of trust and store them in database
for i, chain := range chains {
log.WithFields(logrus.Fields{
"trust chain no": i,
"path len": len(chain),
}).Debug("domain: " + domain)
// loop through each certificate in the chain and
for _, cert := range chain {
parentSignature := ""
parentCert := getFirstParent(cert, chain)
if parentCert != nil {
parentSignature = certificate.SHA256Hash(parentCert.Raw)
} else {
log.Println("could not retrieve parent for " + dnsName)
}
updateCert(cert, parentSignature, domain, IP, truststore.Name, valInfo, certmap)
}
}
return true
}
// the certificate is not trusted.
// we store the cert in DB with its validation error
if len(chains) > 0 {
log.WithFields(logrus.Fields{
"domain": domain,
}).Warning("Got validation error but chains are populated")
}
valInfo.ValidationError = err.Error()
valInfo.IsValid = false
parentSignature := ""
c := getFirstParent(endEntity, intermediates)
if c != nil {
parentSignature = certificate.SHA256Hash(c.Raw)
} else {
log.WithFields(logrus.Fields{
"domain": domain,
"servercert": certificate.SHA256Hash(endEntity.Raw),
}).Info("Could not get parent")
}
updateCert(endEntity, parentSignature, domain, IP, truststore.Name, valInfo, certmap)
return false
} | go | func isChainValid(endEntity *x509.Certificate, intermediates []*x509.Certificate, truststore *certificate.TrustStore, domain, IP string, certmap map[string]certificate.Certificate) bool {
valInfo := &certificate.ValidationInfo{
IsValid: true,
}
// build a CA verification pool from the list of cacerts
interPool := x509.NewCertPool()
for _, entity := range intermediates {
interPool.AddCert(entity)
}
// get a list of domains this certificate is supposedly valid for
// if the end entity is a CA, use its common name
dnsName := domain
if endEntity.IsCA {
dnsName = endEntity.Subject.CommonName
}
// configure the verification logic to use the current trustore
opts := x509.VerifyOptions{
DNSName: dnsName,
Intermediates: interPool,
Roots: truststore.Certs,
}
// Verify attempts to build all the path between the end entity and the
// root in the truststore that validate the certificate
// If no valid path is found, err is not nil and the certificate is not trusted
chains, err := endEntity.Verify(opts)
if err == nil {
// the end entity is trusted, we need to go through each
// chain of trust and store them in database
for i, chain := range chains {
log.WithFields(logrus.Fields{
"trust chain no": i,
"path len": len(chain),
}).Debug("domain: " + domain)
// loop through each certificate in the chain and
for _, cert := range chain {
parentSignature := ""
parentCert := getFirstParent(cert, chain)
if parentCert != nil {
parentSignature = certificate.SHA256Hash(parentCert.Raw)
} else {
log.Println("could not retrieve parent for " + dnsName)
}
updateCert(cert, parentSignature, domain, IP, truststore.Name, valInfo, certmap)
}
}
return true
}
// the certificate is not trusted.
// we store the cert in DB with its validation error
if len(chains) > 0 {
log.WithFields(logrus.Fields{
"domain": domain,
}).Warning("Got validation error but chains are populated")
}
valInfo.ValidationError = err.Error()
valInfo.IsValid = false
parentSignature := ""
c := getFirstParent(endEntity, intermediates)
if c != nil {
parentSignature = certificate.SHA256Hash(c.Raw)
} else {
log.WithFields(logrus.Fields{
"domain": domain,
"servercert": certificate.SHA256Hash(endEntity.Raw),
}).Info("Could not get parent")
}
updateCert(endEntity, parentSignature, domain, IP, truststore.Name, valInfo, certmap)
return false
} | [
"func",
"isChainValid",
"(",
"endEntity",
"*",
"x509",
".",
"Certificate",
",",
"intermediates",
"[",
"]",
"*",
"x509",
".",
"Certificate",
",",
"truststore",
"*",
"certificate",
".",
"TrustStore",
",",
"domain",
",",
"IP",
"string",
",",
"certmap",
"map",
"[",
"string",
"]",
"certificate",
".",
"Certificate",
")",
"bool",
"{",
"valInfo",
":=",
"&",
"certificate",
".",
"ValidationInfo",
"{",
"IsValid",
":",
"true",
",",
"}",
"\n\n",
"// build a CA verification pool from the list of cacerts",
"interPool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"for",
"_",
",",
"entity",
":=",
"range",
"intermediates",
"{",
"interPool",
".",
"AddCert",
"(",
"entity",
")",
"\n",
"}",
"\n\n",
"// get a list of domains this certificate is supposedly valid for",
"// if the end entity is a CA, use its common name",
"dnsName",
":=",
"domain",
"\n",
"if",
"endEntity",
".",
"IsCA",
"{",
"dnsName",
"=",
"endEntity",
".",
"Subject",
".",
"CommonName",
"\n",
"}",
"\n\n",
"// configure the verification logic to use the current trustore",
"opts",
":=",
"x509",
".",
"VerifyOptions",
"{",
"DNSName",
":",
"dnsName",
",",
"Intermediates",
":",
"interPool",
",",
"Roots",
":",
"truststore",
".",
"Certs",
",",
"}",
"\n\n",
"// Verify attempts to build all the path between the end entity and the",
"// root in the truststore that validate the certificate",
"// If no valid path is found, err is not nil and the certificate is not trusted",
"chains",
",",
"err",
":=",
"endEntity",
".",
"Verify",
"(",
"opts",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"// the end entity is trusted, we need to go through each",
"// chain of trust and store them in database",
"for",
"i",
",",
"chain",
":=",
"range",
"chains",
"{",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"i",
",",
"\"",
"\"",
":",
"len",
"(",
"chain",
")",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
"+",
"domain",
")",
"\n",
"// loop through each certificate in the chain and",
"for",
"_",
",",
"cert",
":=",
"range",
"chain",
"{",
"parentSignature",
":=",
"\"",
"\"",
"\n",
"parentCert",
":=",
"getFirstParent",
"(",
"cert",
",",
"chain",
")",
"\n",
"if",
"parentCert",
"!=",
"nil",
"{",
"parentSignature",
"=",
"certificate",
".",
"SHA256Hash",
"(",
"parentCert",
".",
"Raw",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
"+",
"dnsName",
")",
"\n",
"}",
"\n",
"updateCert",
"(",
"cert",
",",
"parentSignature",
",",
"domain",
",",
"IP",
",",
"truststore",
".",
"Name",
",",
"valInfo",
",",
"certmap",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
"\n\n",
"// the certificate is not trusted.",
"// we store the cert in DB with its validation error",
"if",
"len",
"(",
"chains",
")",
">",
"0",
"{",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"domain",
",",
"}",
")",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"valInfo",
".",
"ValidationError",
"=",
"err",
".",
"Error",
"(",
")",
"\n",
"valInfo",
".",
"IsValid",
"=",
"false",
"\n\n",
"parentSignature",
":=",
"\"",
"\"",
"\n",
"c",
":=",
"getFirstParent",
"(",
"endEntity",
",",
"intermediates",
")",
"\n\n",
"if",
"c",
"!=",
"nil",
"{",
"parentSignature",
"=",
"certificate",
".",
"SHA256Hash",
"(",
"c",
".",
"Raw",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"domain",
",",
"\"",
"\"",
":",
"certificate",
".",
"SHA256Hash",
"(",
"endEntity",
".",
"Raw",
")",
",",
"}",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"updateCert",
"(",
"endEntity",
",",
"parentSignature",
",",
"domain",
",",
"IP",
",",
"truststore",
".",
"Name",
",",
"valInfo",
",",
"certmap",
")",
"\n\n",
"return",
"false",
"\n\n",
"}"
] | //isChainValid creates the valid certificate chains by combining the chain retrieved with the provided truststore.
//It return true if it finds at least on validation chain or false if no valid chain of trust can be created.
//It also updates the certificate map which gets pushed at the end of each iteration. | [
"isChainValid",
"creates",
"the",
"valid",
"certificate",
"chains",
"by",
"combining",
"the",
"chain",
"retrieved",
"with",
"the",
"provided",
"truststore",
".",
"It",
"return",
"true",
"if",
"it",
"finds",
"at",
"least",
"on",
"validation",
"chain",
"or",
"false",
"if",
"no",
"valid",
"chain",
"of",
"trust",
"can",
"be",
"created",
".",
"It",
"also",
"updates",
"the",
"certificate",
"map",
"which",
"gets",
"pushed",
"at",
"the",
"end",
"of",
"each",
"iteration",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/tlsobs-scanner/analyser.go#L283-L363 |
153,503 | mozilla/tls-observatory | tlsobs-scanner/analyser.go | updateCert | func updateCert(cert *x509.Certificate, parentSignature string, domain, ip, TSName string, valInfo *certificate.ValidationInfo, certmap map[string]certificate.Certificate) {
id := certificate.SHA256Hash(cert.Raw)
if storedCert, ok := certmap[id]; !ok {
certmap[id] = certificate.CertToStored(cert, parentSignature, domain, ip, TSName, valInfo)
} else {
parentFound := false
for _, p := range storedCert.ParentSignature {
if parentSignature == p {
parentFound = true
break
}
}
if !parentFound {
storedCert.ParentSignature = append(storedCert.ParentSignature, parentSignature)
}
if !storedCert.CA {
if storedCert.ScanTarget != domain {
log.WithFields(logrus.Fields{
"domain": storedCert.ScanTarget,
"domain_input": domain,
"certificate": storedCert.Hashes.SHA256,
}).Warning("Different domain input")
}
//add IP ( single domain may be served by multiple IPs )
ipFound := false
for _, i := range storedCert.IPs {
if ip == i {
ipFound = true
break
}
}
if !ipFound {
storedCert.IPs = append(storedCert.IPs, ip)
}
}
storedCert.ValidationInfo[TSName] = *valInfo
certmap[id] = storedCert
}
} | go | func updateCert(cert *x509.Certificate, parentSignature string, domain, ip, TSName string, valInfo *certificate.ValidationInfo, certmap map[string]certificate.Certificate) {
id := certificate.SHA256Hash(cert.Raw)
if storedCert, ok := certmap[id]; !ok {
certmap[id] = certificate.CertToStored(cert, parentSignature, domain, ip, TSName, valInfo)
} else {
parentFound := false
for _, p := range storedCert.ParentSignature {
if parentSignature == p {
parentFound = true
break
}
}
if !parentFound {
storedCert.ParentSignature = append(storedCert.ParentSignature, parentSignature)
}
if !storedCert.CA {
if storedCert.ScanTarget != domain {
log.WithFields(logrus.Fields{
"domain": storedCert.ScanTarget,
"domain_input": domain,
"certificate": storedCert.Hashes.SHA256,
}).Warning("Different domain input")
}
//add IP ( single domain may be served by multiple IPs )
ipFound := false
for _, i := range storedCert.IPs {
if ip == i {
ipFound = true
break
}
}
if !ipFound {
storedCert.IPs = append(storedCert.IPs, ip)
}
}
storedCert.ValidationInfo[TSName] = *valInfo
certmap[id] = storedCert
}
} | [
"func",
"updateCert",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
",",
"parentSignature",
"string",
",",
"domain",
",",
"ip",
",",
"TSName",
"string",
",",
"valInfo",
"*",
"certificate",
".",
"ValidationInfo",
",",
"certmap",
"map",
"[",
"string",
"]",
"certificate",
".",
"Certificate",
")",
"{",
"id",
":=",
"certificate",
".",
"SHA256Hash",
"(",
"cert",
".",
"Raw",
")",
"\n\n",
"if",
"storedCert",
",",
"ok",
":=",
"certmap",
"[",
"id",
"]",
";",
"!",
"ok",
"{",
"certmap",
"[",
"id",
"]",
"=",
"certificate",
".",
"CertToStored",
"(",
"cert",
",",
"parentSignature",
",",
"domain",
",",
"ip",
",",
"TSName",
",",
"valInfo",
")",
"\n\n",
"}",
"else",
"{",
"parentFound",
":=",
"false",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"storedCert",
".",
"ParentSignature",
"{",
"if",
"parentSignature",
"==",
"p",
"{",
"parentFound",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"parentFound",
"{",
"storedCert",
".",
"ParentSignature",
"=",
"append",
"(",
"storedCert",
".",
"ParentSignature",
",",
"parentSignature",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"storedCert",
".",
"CA",
"{",
"if",
"storedCert",
".",
"ScanTarget",
"!=",
"domain",
"{",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"storedCert",
".",
"ScanTarget",
",",
"\"",
"\"",
":",
"domain",
",",
"\"",
"\"",
":",
"storedCert",
".",
"Hashes",
".",
"SHA256",
",",
"}",
")",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"//add IP ( single domain may be served by multiple IPs )",
"ipFound",
":=",
"false",
"\n\n",
"for",
"_",
",",
"i",
":=",
"range",
"storedCert",
".",
"IPs",
"{",
"if",
"ip",
"==",
"i",
"{",
"ipFound",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"ipFound",
"{",
"storedCert",
".",
"IPs",
"=",
"append",
"(",
"storedCert",
".",
"IPs",
",",
"ip",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"storedCert",
".",
"ValidationInfo",
"[",
"TSName",
"]",
"=",
"*",
"valInfo",
"\n\n",
"certmap",
"[",
"id",
"]",
"=",
"storedCert",
"\n",
"}",
"\n\n",
"}"
] | //updateCert takes the input certificate and updates the map holding all the certificates to be pushed.
//If the certificates has already been inserted it updates the existing record else it creates it. | [
"updateCert",
"takes",
"the",
"input",
"certificate",
"and",
"updates",
"the",
"map",
"holding",
"all",
"the",
"certificates",
"to",
"be",
"pushed",
".",
"If",
"the",
"certificates",
"has",
"already",
"been",
"inserted",
"it",
"updates",
"the",
"existing",
"record",
"else",
"it",
"creates",
"it",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/tlsobs-scanner/analyser.go#L525-L579 |
153,504 | mozilla/tls-observatory | tlsobs-scanner/retriever.go | handleCert | func handleCert(domain string) (int64, int64, *certificate.Chain, error) {
certs, ip, err := retrieveCertFromHost(domain, "443", true)
if err != nil {
log.WithFields(logrus.Fields{
"domain": domain,
"error": err.Error(),
}).Warning("Could not retrieve certs")
return -1, -1, nil, err
}
if certs == nil {
e := new(NoTLSCertsErr)
return -1, -1, nil, e
}
var chain = certificate.Chain{}
chain.Domain = domain
chain.IP = ip
for _, cert := range certs {
chain.Certs = append(chain.Certs, base64.StdEncoding.EncodeToString(cert.Raw))
}
rootCertId, trustId, err := handleCertChain(&chain)
if err != nil {
return -1, -1, nil, err
}
return rootCertId, trustId, &chain, nil
} | go | func handleCert(domain string) (int64, int64, *certificate.Chain, error) {
certs, ip, err := retrieveCertFromHost(domain, "443", true)
if err != nil {
log.WithFields(logrus.Fields{
"domain": domain,
"error": err.Error(),
}).Warning("Could not retrieve certs")
return -1, -1, nil, err
}
if certs == nil {
e := new(NoTLSCertsErr)
return -1, -1, nil, e
}
var chain = certificate.Chain{}
chain.Domain = domain
chain.IP = ip
for _, cert := range certs {
chain.Certs = append(chain.Certs, base64.StdEncoding.EncodeToString(cert.Raw))
}
rootCertId, trustId, err := handleCertChain(&chain)
if err != nil {
return -1, -1, nil, err
}
return rootCertId, trustId, &chain, nil
} | [
"func",
"handleCert",
"(",
"domain",
"string",
")",
"(",
"int64",
",",
"int64",
",",
"*",
"certificate",
".",
"Chain",
",",
"error",
")",
"{",
"certs",
",",
"ip",
",",
"err",
":=",
"retrieveCertFromHost",
"(",
"domain",
",",
"\"",
"\"",
",",
"true",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"domain",
",",
"\"",
"\"",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
")",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"return",
"-",
"1",
",",
"-",
"1",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"certs",
"==",
"nil",
"{",
"e",
":=",
"new",
"(",
"NoTLSCertsErr",
")",
"\n",
"return",
"-",
"1",
",",
"-",
"1",
",",
"nil",
",",
"e",
"\n",
"}",
"\n\n",
"var",
"chain",
"=",
"certificate",
".",
"Chain",
"{",
"}",
"\n\n",
"chain",
".",
"Domain",
"=",
"domain",
"\n\n",
"chain",
".",
"IP",
"=",
"ip",
"\n\n",
"for",
"_",
",",
"cert",
":=",
"range",
"certs",
"{",
"chain",
".",
"Certs",
"=",
"append",
"(",
"chain",
".",
"Certs",
",",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"cert",
".",
"Raw",
")",
")",
"\n\n",
"}",
"\n\n",
"rootCertId",
",",
"trustId",
",",
"err",
":=",
"handleCertChain",
"(",
"&",
"chain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"-",
"1",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"rootCertId",
",",
"trustId",
",",
"&",
"chain",
",",
"nil",
"\n",
"}"
] | //HandleCert is the main function called to verify certificates.
//It retrieves certificates and feeds them to handleCertChain. It then returns
//its result. | [
"HandleCert",
"is",
"the",
"main",
"function",
"called",
"to",
"verify",
"certificates",
".",
"It",
"retrieves",
"certificates",
"and",
"feeds",
"them",
"to",
"handleCertChain",
".",
"It",
"then",
"returns",
"its",
"result",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/tlsobs-scanner/retriever.go#L27-L61 |
153,505 | mozilla/tls-observatory | certificate/constraints/constraints.go | Get | func Get(cert *x509.Certificate) (*Constraints, error) {
certs, err := x509.ParseCertificates(cert.Raw)
if err != nil {
return nil, err
}
if len(certs) != 1 {
return nil, fmt.Errorf("cert.Raw must contain exactly one certificate")
}
constraintCert := certs[0]
return &Constraints{
PermittedDNSDomains: constraintCert.PermittedDNSDomains,
ExcludedDNSDomains: constraintCert.ExcludedDNSDomains,
PermittedIPRanges: constraintCert.PermittedIPRanges,
ExcludedIPRanges: constraintCert.ExcludedIPRanges,
}, nil
} | go | func Get(cert *x509.Certificate) (*Constraints, error) {
certs, err := x509.ParseCertificates(cert.Raw)
if err != nil {
return nil, err
}
if len(certs) != 1 {
return nil, fmt.Errorf("cert.Raw must contain exactly one certificate")
}
constraintCert := certs[0]
return &Constraints{
PermittedDNSDomains: constraintCert.PermittedDNSDomains,
ExcludedDNSDomains: constraintCert.ExcludedDNSDomains,
PermittedIPRanges: constraintCert.PermittedIPRanges,
ExcludedIPRanges: constraintCert.ExcludedIPRanges,
}, nil
} | [
"func",
"Get",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"(",
"*",
"Constraints",
",",
"error",
")",
"{",
"certs",
",",
"err",
":=",
"x509",
".",
"ParseCertificates",
"(",
"cert",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"certs",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"constraintCert",
":=",
"certs",
"[",
"0",
"]",
"\n\n",
"return",
"&",
"Constraints",
"{",
"PermittedDNSDomains",
":",
"constraintCert",
".",
"PermittedDNSDomains",
",",
"ExcludedDNSDomains",
":",
"constraintCert",
".",
"ExcludedDNSDomains",
",",
"PermittedIPRanges",
":",
"constraintCert",
".",
"PermittedIPRanges",
",",
"ExcludedIPRanges",
":",
"constraintCert",
".",
"ExcludedIPRanges",
",",
"}",
",",
"nil",
"\n",
"}"
] | // Get returns the Constraints for a given x509 certificate | [
"Get",
"returns",
"the",
"Constraints",
"for",
"a",
"given",
"x509",
"certificate"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/certificate/constraints/constraints.go#L19-L35 |
153,506 | mozilla/tls-observatory | worker/mozillaEvaluationWorker/mozillaEvaluationWorker.go | getConffromURL | func getConffromURL(url string) error {
r, err := http.Get(url)
if err != nil {
return err
}
defer r.Body.Close()
err = json.NewDecoder(r.Body).Decode(&sstls)
if err != nil {
return err
}
return nil
} | go | func getConffromURL(url string) error {
r, err := http.Get(url)
if err != nil {
return err
}
defer r.Body.Close()
err = json.NewDecoder(r.Body).Decode(&sstls)
if err != nil {
return err
}
return nil
} | [
"func",
"getConffromURL",
"(",
"url",
"string",
")",
"error",
"{",
"r",
",",
"err",
":=",
"http",
".",
"Get",
"(",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"r",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"r",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"sstls",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // getConffromURL retrieves the json containing the TLS configurations from the specified URL. | [
"getConffromURL",
"retrieves",
"the",
"json",
"containing",
"the",
"TLS",
"configurations",
"from",
"the",
"specified",
"URL",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/worker/mozillaEvaluationWorker/mozillaEvaluationWorker.go#L65-L79 |
153,507 | mozilla/tls-observatory | worker/mozillaEvaluationWorker/mozillaEvaluationWorker.go | contains | func contains(slice []string, entry string) bool {
for _, element := range slice {
if element == entry {
return true
}
}
return false
} | go | func contains(slice []string, entry string) bool {
for _, element := range slice {
if element == entry {
return true
}
}
return false
} | [
"func",
"contains",
"(",
"slice",
"[",
"]",
"string",
",",
"entry",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"element",
":=",
"range",
"slice",
"{",
"if",
"element",
"==",
"entry",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // contains checks if an entry exists in a slice and returns
// a booleans. | [
"contains",
"checks",
"if",
"an",
"entry",
"exists",
"in",
"a",
"slice",
"and",
"returns",
"a",
"booleans",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/worker/mozillaEvaluationWorker/mozillaEvaluationWorker.go#L664-L671 |
153,508 | mozilla/tls-observatory | worker/mozillaEvaluationWorker/mozillaEvaluationWorker.go | extra | func extra(s1, s2 []string) (extra []string) {
for _, e := range s2 {
// FIXME: https://github.com/mozilla/tls-observatory/issues/186
if e == "ECDHE-ECDSA-CHACHA20-POLY1305-OLD" || e == "ECDHE-RSA-CHACHA20-POLY1305-OLD" {
continue
}
if !contains(s1, e) {
extra = append(extra, e)
}
}
return
} | go | func extra(s1, s2 []string) (extra []string) {
for _, e := range s2 {
// FIXME: https://github.com/mozilla/tls-observatory/issues/186
if e == "ECDHE-ECDSA-CHACHA20-POLY1305-OLD" || e == "ECDHE-RSA-CHACHA20-POLY1305-OLD" {
continue
}
if !contains(s1, e) {
extra = append(extra, e)
}
}
return
} | [
"func",
"extra",
"(",
"s1",
",",
"s2",
"[",
"]",
"string",
")",
"(",
"extra",
"[",
"]",
"string",
")",
"{",
"for",
"_",
",",
"e",
":=",
"range",
"s2",
"{",
"// FIXME: https://github.com/mozilla/tls-observatory/issues/186",
"if",
"e",
"==",
"\"",
"\"",
"||",
"e",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"contains",
"(",
"s1",
",",
"e",
")",
"{",
"extra",
"=",
"append",
"(",
"extra",
",",
"e",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // extra returns a slice of strings that are present in a slice s1 but not
// in a slice s2. | [
"extra",
"returns",
"a",
"slice",
"of",
"strings",
"that",
"are",
"present",
"in",
"a",
"slice",
"s1",
"but",
"not",
"in",
"a",
"slice",
"s2",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/worker/mozillaEvaluationWorker/mozillaEvaluationWorker.go#L675-L686 |
153,509 | mozilla/tls-observatory | worker/top1m/top1m.go | analyseTargetRank | func (w ranker) analyseTargetRank(in worker.Input) (tr targetRank, err error) {
tr = targetRank{
Domain: in.Target,
Rank: certificate.Default_Cisco_Umbrella_Rank,
CiscoRank: certificate.Default_Cisco_Umbrella_Rank,
AlexaRank: certificate.Default_Cisco_Umbrella_Rank,
}
if val, ok := w.Ranks[tr.Domain]; ok {
tr.CiscoRank = rank(val)
tr.Rank = rank(val)
}
if val, ok := w.AlexaRanks[tr.Domain]; ok {
tr.AlexaRank = rank(val)
}
if tr.AlexaRank < tr.Rank {
tr.Rank = tr.AlexaRank
}
return
} | go | func (w ranker) analyseTargetRank(in worker.Input) (tr targetRank, err error) {
tr = targetRank{
Domain: in.Target,
Rank: certificate.Default_Cisco_Umbrella_Rank,
CiscoRank: certificate.Default_Cisco_Umbrella_Rank,
AlexaRank: certificate.Default_Cisco_Umbrella_Rank,
}
if val, ok := w.Ranks[tr.Domain]; ok {
tr.CiscoRank = rank(val)
tr.Rank = rank(val)
}
if val, ok := w.AlexaRanks[tr.Domain]; ok {
tr.AlexaRank = rank(val)
}
if tr.AlexaRank < tr.Rank {
tr.Rank = tr.AlexaRank
}
return
} | [
"func",
"(",
"w",
"ranker",
")",
"analyseTargetRank",
"(",
"in",
"worker",
".",
"Input",
")",
"(",
"tr",
"targetRank",
",",
"err",
"error",
")",
"{",
"tr",
"=",
"targetRank",
"{",
"Domain",
":",
"in",
".",
"Target",
",",
"Rank",
":",
"certificate",
".",
"Default_Cisco_Umbrella_Rank",
",",
"CiscoRank",
":",
"certificate",
".",
"Default_Cisco_Umbrella_Rank",
",",
"AlexaRank",
":",
"certificate",
".",
"Default_Cisco_Umbrella_Rank",
",",
"}",
"\n",
"if",
"val",
",",
"ok",
":=",
"w",
".",
"Ranks",
"[",
"tr",
".",
"Domain",
"]",
";",
"ok",
"{",
"tr",
".",
"CiscoRank",
"=",
"rank",
"(",
"val",
")",
"\n",
"tr",
".",
"Rank",
"=",
"rank",
"(",
"val",
")",
"\n",
"}",
"\n",
"if",
"val",
",",
"ok",
":=",
"w",
".",
"AlexaRanks",
"[",
"tr",
".",
"Domain",
"]",
";",
"ok",
"{",
"tr",
".",
"AlexaRank",
"=",
"rank",
"(",
"val",
")",
"\n",
"}",
"\n",
"if",
"tr",
".",
"AlexaRank",
"<",
"tr",
".",
"Rank",
"{",
"tr",
".",
"Rank",
"=",
"tr",
".",
"AlexaRank",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Find the rank of the target | [
"Find",
"the",
"rank",
"of",
"the",
"target"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/worker/top1m/top1m.go#L177-L195 |
153,510 | mozilla/tls-observatory | worker/caaWorker/caaWorker.go | Assertor | func (e eval) Assertor(caaResult, assertresults []byte) (pass bool, body []byte, err error) {
var result, assertres Result
pass = false
err = json.Unmarshal(caaResult, &result)
if err != nil {
return
}
err = json.Unmarshal(assertresults, &assertres)
if err != nil {
return
}
if result.HasCAA != assertres.HasCAA {
body = []byte("CAA mismatch")
return
}
if result.Host != assertres.Host {
body = []byte(fmt.Sprintf(`Assertion failed MatchedHost= %s`,
result.Host))
return
}
if len(result.IssueCAs) != len(assertres.IssueCAs) {
body = []byte("Issue CAs count mismatch")
return
}
for i := range result.IssueCAs {
if result.IssueCAs[i] != assertres.IssueCAs[i] {
body = []byte(fmt.Sprintf(`Issue CAs mismatch %s != %s`,
result.IssueCAs[i], assertres.IssueCAs[i]))
return
}
}
if len(result.IssueWildCAs) != len(assertres.IssueWildCAs) {
body = []byte("Issue CAs count mismatch")
return
}
for i := range result.IssueWildCAs {
if result.IssueWildCAs[i] != assertres.IssueWildCAs[i] {
body = []byte(fmt.Sprintf(`Issue CAs mismatch %s != %s`,
result.IssueWildCAs[i], assertres.IssueWildCAs[i]))
return
}
}
pass = true
return
} | go | func (e eval) Assertor(caaResult, assertresults []byte) (pass bool, body []byte, err error) {
var result, assertres Result
pass = false
err = json.Unmarshal(caaResult, &result)
if err != nil {
return
}
err = json.Unmarshal(assertresults, &assertres)
if err != nil {
return
}
if result.HasCAA != assertres.HasCAA {
body = []byte("CAA mismatch")
return
}
if result.Host != assertres.Host {
body = []byte(fmt.Sprintf(`Assertion failed MatchedHost= %s`,
result.Host))
return
}
if len(result.IssueCAs) != len(assertres.IssueCAs) {
body = []byte("Issue CAs count mismatch")
return
}
for i := range result.IssueCAs {
if result.IssueCAs[i] != assertres.IssueCAs[i] {
body = []byte(fmt.Sprintf(`Issue CAs mismatch %s != %s`,
result.IssueCAs[i], assertres.IssueCAs[i]))
return
}
}
if len(result.IssueWildCAs) != len(assertres.IssueWildCAs) {
body = []byte("Issue CAs count mismatch")
return
}
for i := range result.IssueWildCAs {
if result.IssueWildCAs[i] != assertres.IssueWildCAs[i] {
body = []byte(fmt.Sprintf(`Issue CAs mismatch %s != %s`,
result.IssueWildCAs[i], assertres.IssueWildCAs[i]))
return
}
}
pass = true
return
} | [
"func",
"(",
"e",
"eval",
")",
"Assertor",
"(",
"caaResult",
",",
"assertresults",
"[",
"]",
"byte",
")",
"(",
"pass",
"bool",
",",
"body",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"result",
",",
"assertres",
"Result",
"\n",
"pass",
"=",
"false",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"caaResult",
",",
"&",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"assertresults",
",",
"&",
"assertres",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"result",
".",
"HasCAA",
"!=",
"assertres",
".",
"HasCAA",
"{",
"body",
"=",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"result",
".",
"Host",
"!=",
"assertres",
".",
"Host",
"{",
"body",
"=",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"`Assertion failed MatchedHost= %s`",
",",
"result",
".",
"Host",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"result",
".",
"IssueCAs",
")",
"!=",
"len",
"(",
"assertres",
".",
"IssueCAs",
")",
"{",
"body",
"=",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"result",
".",
"IssueCAs",
"{",
"if",
"result",
".",
"IssueCAs",
"[",
"i",
"]",
"!=",
"assertres",
".",
"IssueCAs",
"[",
"i",
"]",
"{",
"body",
"=",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"`Issue CAs mismatch %s != %s`",
",",
"result",
".",
"IssueCAs",
"[",
"i",
"]",
",",
"assertres",
".",
"IssueCAs",
"[",
"i",
"]",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"result",
".",
"IssueWildCAs",
")",
"!=",
"len",
"(",
"assertres",
".",
"IssueWildCAs",
")",
"{",
"body",
"=",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"result",
".",
"IssueWildCAs",
"{",
"if",
"result",
".",
"IssueWildCAs",
"[",
"i",
"]",
"!=",
"assertres",
".",
"IssueWildCAs",
"[",
"i",
"]",
"{",
"body",
"=",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"`Issue CAs mismatch %s != %s`",
",",
"result",
".",
"IssueWildCAs",
"[",
"i",
"]",
",",
"assertres",
".",
"IssueWildCAs",
"[",
"i",
"]",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"pass",
"=",
"true",
"\n",
"return",
"\n",
"}"
] | // Assertor compares 2 caaResults and reports differences. | [
"Assertor",
"compares",
"2",
"caaResults",
"and",
"reports",
"differences",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/worker/caaWorker/caaWorker.go#L95-L145 |
153,511 | mozilla/tls-observatory | connection/connection.go | Stored | func (s CipherscanOutput) Stored() (Stored, error) {
c := Stored{}
var err error
c.ServerSide = stringtoBool(s.ServerSide)
c.CurvesFallback = stringtoBool(s.CurvesFallback)
c.ScanIP = s.IP
for _, cipher := range s.CipherSuites {
newcipher := Ciphersuite{}
newcipher.Cipher = cipher.Cipher
newcipher.Code = constants.CipherSuites[cipher.Cipher].Code
newcipher.OCSPStapling = stringtoBool(cipher.OCSPStapling)
newcipher.PFS = cipher.PFS
newcipher.Protocols = cipher.Protocols
if len(cipher.PubKey) > 1 {
return c, fmt.Errorf("Multiple PubKeys for %s at cipher : %s", s.Target, cipher.Cipher)
}
if len(cipher.PubKey) > 0 {
newcipher.PubKey, err = strconv.ParseFloat(cipher.PubKey[0], 64)
} else {
return c, errors.New("No Public Keys found")
}
if len(cipher.SigAlg) > 1 {
return c, fmt.Errorf("Multiple SigAlgs for %s at cipher: %s", s.Target, cipher.Cipher)
}
if len(cipher.SigAlg) > 0 {
newcipher.SigAlg = cipher.SigAlg[0]
} else {
return c, errors.New("No Signature Algorithms found")
}
newcipher.TicketHint = cipher.TicketHint
if err != nil {
return c, err
}
newcipher.Curves = append(newcipher.Curves, cipher.Curves...)
c.CipherSuite = append(c.CipherSuite, newcipher)
}
return c, nil
} | go | func (s CipherscanOutput) Stored() (Stored, error) {
c := Stored{}
var err error
c.ServerSide = stringtoBool(s.ServerSide)
c.CurvesFallback = stringtoBool(s.CurvesFallback)
c.ScanIP = s.IP
for _, cipher := range s.CipherSuites {
newcipher := Ciphersuite{}
newcipher.Cipher = cipher.Cipher
newcipher.Code = constants.CipherSuites[cipher.Cipher].Code
newcipher.OCSPStapling = stringtoBool(cipher.OCSPStapling)
newcipher.PFS = cipher.PFS
newcipher.Protocols = cipher.Protocols
if len(cipher.PubKey) > 1 {
return c, fmt.Errorf("Multiple PubKeys for %s at cipher : %s", s.Target, cipher.Cipher)
}
if len(cipher.PubKey) > 0 {
newcipher.PubKey, err = strconv.ParseFloat(cipher.PubKey[0], 64)
} else {
return c, errors.New("No Public Keys found")
}
if len(cipher.SigAlg) > 1 {
return c, fmt.Errorf("Multiple SigAlgs for %s at cipher: %s", s.Target, cipher.Cipher)
}
if len(cipher.SigAlg) > 0 {
newcipher.SigAlg = cipher.SigAlg[0]
} else {
return c, errors.New("No Signature Algorithms found")
}
newcipher.TicketHint = cipher.TicketHint
if err != nil {
return c, err
}
newcipher.Curves = append(newcipher.Curves, cipher.Curves...)
c.CipherSuite = append(c.CipherSuite, newcipher)
}
return c, nil
} | [
"func",
"(",
"s",
"CipherscanOutput",
")",
"Stored",
"(",
")",
"(",
"Stored",
",",
"error",
")",
"{",
"c",
":=",
"Stored",
"{",
"}",
"\n\n",
"var",
"err",
"error",
"\n\n",
"c",
".",
"ServerSide",
"=",
"stringtoBool",
"(",
"s",
".",
"ServerSide",
")",
"\n",
"c",
".",
"CurvesFallback",
"=",
"stringtoBool",
"(",
"s",
".",
"CurvesFallback",
")",
"\n",
"c",
".",
"ScanIP",
"=",
"s",
".",
"IP",
"\n\n",
"for",
"_",
",",
"cipher",
":=",
"range",
"s",
".",
"CipherSuites",
"{",
"newcipher",
":=",
"Ciphersuite",
"{",
"}",
"\n\n",
"newcipher",
".",
"Cipher",
"=",
"cipher",
".",
"Cipher",
"\n",
"newcipher",
".",
"Code",
"=",
"constants",
".",
"CipherSuites",
"[",
"cipher",
".",
"Cipher",
"]",
".",
"Code",
"\n",
"newcipher",
".",
"OCSPStapling",
"=",
"stringtoBool",
"(",
"cipher",
".",
"OCSPStapling",
")",
"\n",
"newcipher",
".",
"PFS",
"=",
"cipher",
".",
"PFS",
"\n\n",
"newcipher",
".",
"Protocols",
"=",
"cipher",
".",
"Protocols",
"\n\n",
"if",
"len",
"(",
"cipher",
".",
"PubKey",
")",
">",
"1",
"{",
"return",
"c",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Target",
",",
"cipher",
".",
"Cipher",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"cipher",
".",
"PubKey",
")",
">",
"0",
"{",
"newcipher",
".",
"PubKey",
",",
"err",
"=",
"strconv",
".",
"ParseFloat",
"(",
"cipher",
".",
"PubKey",
"[",
"0",
"]",
",",
"64",
")",
"\n",
"}",
"else",
"{",
"return",
"c",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"cipher",
".",
"SigAlg",
")",
">",
"1",
"{",
"return",
"c",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Target",
",",
"cipher",
".",
"Cipher",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"cipher",
".",
"SigAlg",
")",
">",
"0",
"{",
"newcipher",
".",
"SigAlg",
"=",
"cipher",
".",
"SigAlg",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"return",
"c",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"newcipher",
".",
"TicketHint",
"=",
"cipher",
".",
"TicketHint",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n\n",
"newcipher",
".",
"Curves",
"=",
"append",
"(",
"newcipher",
".",
"Curves",
",",
"cipher",
".",
"Curves",
"...",
")",
"\n",
"c",
".",
"CipherSuite",
"=",
"append",
"(",
"c",
".",
"CipherSuite",
",",
"newcipher",
")",
"\n",
"}",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] | // Stored creates a Stored struct from the CipherscanOutput struct | [
"Stored",
"creates",
"a",
"Stored",
"struct",
"from",
"the",
"CipherscanOutput",
"struct"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/connection/connection.go#L126-L178 |
153,512 | mozilla/tls-observatory | worker/worker.go | RegisterWorker | func RegisterWorker(name string, info Info) {
if _, exist := AvailableWorkers[name]; exist {
fmt.Fprintf(os.Stderr, "RegisterWorker: a worker named %q has already been registered.\nAre you trying to import the same worker twice?\n", name)
os.Exit(1)
}
AvailableWorkers[name] = info
} | go | func RegisterWorker(name string, info Info) {
if _, exist := AvailableWorkers[name]; exist {
fmt.Fprintf(os.Stderr, "RegisterWorker: a worker named %q has already been registered.\nAre you trying to import the same worker twice?\n", name)
os.Exit(1)
}
AvailableWorkers[name] = info
} | [
"func",
"RegisterWorker",
"(",
"name",
"string",
",",
"info",
"Info",
")",
"{",
"if",
"_",
",",
"exist",
":=",
"AvailableWorkers",
"[",
"name",
"]",
";",
"exist",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\\n",
"\"",
",",
"name",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"AvailableWorkers",
"[",
"name",
"]",
"=",
"info",
"\n",
"}"
] | // RegisterWorker is called by each worker in order to register itself as available. | [
"RegisterWorker",
"is",
"called",
"by",
"each",
"worker",
"in",
"order",
"to",
"register",
"itself",
"as",
"available",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/worker/worker.go#L45-L51 |
153,513 | mozilla/tls-observatory | worker/worker.go | RegisterPrinter | func RegisterPrinter(name string, info Info) {
if _, exist := AvailablePrinters[name]; exist {
fmt.Fprintf(os.Stderr, "RegisterPrinter: a printer named %q has already been registered.\nAre you trying to import the same printer twice?\n", name)
os.Exit(1)
}
AvailablePrinters[name] = info
} | go | func RegisterPrinter(name string, info Info) {
if _, exist := AvailablePrinters[name]; exist {
fmt.Fprintf(os.Stderr, "RegisterPrinter: a printer named %q has already been registered.\nAre you trying to import the same printer twice?\n", name)
os.Exit(1)
}
AvailablePrinters[name] = info
} | [
"func",
"RegisterPrinter",
"(",
"name",
"string",
",",
"info",
"Info",
")",
"{",
"if",
"_",
",",
"exist",
":=",
"AvailablePrinters",
"[",
"name",
"]",
";",
"exist",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\\n",
"\"",
",",
"name",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"AvailablePrinters",
"[",
"name",
"]",
"=",
"info",
"\n",
"}"
] | // RegisterPrinter is called by each worker in order to register itself as available. | [
"RegisterPrinter",
"is",
"called",
"by",
"each",
"worker",
"in",
"order",
"to",
"register",
"itself",
"as",
"available",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/worker/worker.go#L58-L64 |
153,514 | mozilla/tls-observatory | tlsobs-api/middleware.go | HandleMiddlewares | func HandleMiddlewares(h http.Handler, adapters ...Middleware) http.Handler {
// To make the middleware run in the order in which they are specified,
// we reverse through them in the Middleware function, rather than just
// ranging over them
for i := len(adapters) - 1; i >= 0; i-- {
h = adapters[i](h)
}
return h
} | go | func HandleMiddlewares(h http.Handler, adapters ...Middleware) http.Handler {
// To make the middleware run in the order in which they are specified,
// we reverse through them in the Middleware function, rather than just
// ranging over them
for i := len(adapters) - 1; i >= 0; i-- {
h = adapters[i](h)
}
return h
} | [
"func",
"HandleMiddlewares",
"(",
"h",
"http",
".",
"Handler",
",",
"adapters",
"...",
"Middleware",
")",
"http",
".",
"Handler",
"{",
"// To make the middleware run in the order in which they are specified,",
"// we reverse through them in the Middleware function, rather than just",
"// ranging over them",
"for",
"i",
":=",
"len",
"(",
"adapters",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"h",
"=",
"adapters",
"[",
"i",
"]",
"(",
"h",
")",
"\n",
"}",
"\n",
"return",
"h",
"\n",
"}"
] | // Run the request through all middlewares | [
"Run",
"the",
"request",
"through",
"all",
"middlewares"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/tlsobs-api/middleware.go#L69-L77 |
153,515 | mozilla/tls-observatory | tlsobs-api/middleware.go | addtoContext | func addtoContext(r *http.Request, key string, value interface{}) *http.Request {
ctx := r.Context()
return r.WithContext(context.WithValue(ctx, key, value))
} | go | func addtoContext(r *http.Request, key string, value interface{}) *http.Request {
ctx := r.Context()
return r.WithContext(context.WithValue(ctx, key, value))
} | [
"func",
"addtoContext",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"*",
"http",
".",
"Request",
"{",
"ctx",
":=",
"r",
".",
"Context",
"(",
")",
"\n",
"return",
"r",
".",
"WithContext",
"(",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"key",
",",
"value",
")",
")",
"\n",
"}"
] | // addToContext add the given key value pair to the given request's context | [
"addToContext",
"add",
"the",
"given",
"key",
"value",
"pair",
"to",
"the",
"given",
"request",
"s",
"context"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/tlsobs-api/middleware.go#L80-L83 |
153,516 | mozilla/tls-observatory | database/database.go | GetLastScanTimeForTarget | func (db *DB) GetLastScanTimeForTarget(target string) (int64, time.Time, error) {
var (
id int64
t time.Time
)
row := db.QueryRow(`SELECT id, timestamp
FROM scans
WHERE target=$1 ORDER BY timestamp DESC LIMIT 1`, target)
err := row.Scan(&id, &t)
if err != nil {
if err == sql.ErrNoRows {
return -1, time.Now(), nil
} else {
return -1, time.Now(), err
}
}
return id, t, nil
} | go | func (db *DB) GetLastScanTimeForTarget(target string) (int64, time.Time, error) {
var (
id int64
t time.Time
)
row := db.QueryRow(`SELECT id, timestamp
FROM scans
WHERE target=$1 ORDER BY timestamp DESC LIMIT 1`, target)
err := row.Scan(&id, &t)
if err != nil {
if err == sql.ErrNoRows {
return -1, time.Now(), nil
} else {
return -1, time.Now(), err
}
}
return id, t, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetLastScanTimeForTarget",
"(",
"target",
"string",
")",
"(",
"int64",
",",
"time",
".",
"Time",
",",
"error",
")",
"{",
"var",
"(",
"id",
"int64",
"\n",
"t",
"time",
".",
"Time",
"\n",
")",
"\n\n",
"row",
":=",
"db",
".",
"QueryRow",
"(",
"`SELECT id, timestamp\n\t\t\t FROM scans\n\t\t\t WHERE target=$1 ORDER BY timestamp DESC LIMIT 1`",
",",
"target",
")",
"\n\n",
"err",
":=",
"row",
".",
"Scan",
"(",
"&",
"id",
",",
"&",
"t",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"sql",
".",
"ErrNoRows",
"{",
"return",
"-",
"1",
",",
"time",
".",
"Now",
"(",
")",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"-",
"1",
",",
"time",
".",
"Now",
"(",
")",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"id",
",",
"t",
",",
"nil",
"\n",
"}"
] | // GetLastScanTimeForTarget searches the database for the latest scan for a specific target.
// It returns both the scan timestamp and the id of the scan to enable the api to
// respond to clients with just one db query. | [
"GetLastScanTimeForTarget",
"searches",
"the",
"database",
"for",
"the",
"latest",
"scan",
"for",
"a",
"specific",
"target",
".",
"It",
"returns",
"both",
"the",
"scan",
"timestamp",
"and",
"the",
"id",
"of",
"the",
"scan",
"to",
"enable",
"the",
"api",
"to",
"respond",
"to",
"clients",
"with",
"just",
"one",
"db",
"query",
"."
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/database/database.go#L99-L120 |
153,517 | mozilla/tls-observatory | metrics/metrics.go | NewCertificate | func (sender *Sender) NewCertificate() {
sender.cloudwatchSvc.PutMetricData(&cloudwatch.PutMetricDataInput{
MetricData: []*cloudwatch.MetricDatum{
&cloudwatch.MetricDatum{
MetricName: aws.String("NewCertificates"),
Unit: aws.String(cloudwatch.StandardUnitNone),
Value: aws.Float64(1.0),
Dimensions: []*cloudwatch.Dimension{},
},
},
Namespace: aws.String("tls-observatory"),
})
} | go | func (sender *Sender) NewCertificate() {
sender.cloudwatchSvc.PutMetricData(&cloudwatch.PutMetricDataInput{
MetricData: []*cloudwatch.MetricDatum{
&cloudwatch.MetricDatum{
MetricName: aws.String("NewCertificates"),
Unit: aws.String(cloudwatch.StandardUnitNone),
Value: aws.Float64(1.0),
Dimensions: []*cloudwatch.Dimension{},
},
},
Namespace: aws.String("tls-observatory"),
})
} | [
"func",
"(",
"sender",
"*",
"Sender",
")",
"NewCertificate",
"(",
")",
"{",
"sender",
".",
"cloudwatchSvc",
".",
"PutMetricData",
"(",
"&",
"cloudwatch",
".",
"PutMetricDataInput",
"{",
"MetricData",
":",
"[",
"]",
"*",
"cloudwatch",
".",
"MetricDatum",
"{",
"&",
"cloudwatch",
".",
"MetricDatum",
"{",
"MetricName",
":",
"aws",
".",
"String",
"(",
"\"",
"\"",
")",
",",
"Unit",
":",
"aws",
".",
"String",
"(",
"cloudwatch",
".",
"StandardUnitNone",
")",
",",
"Value",
":",
"aws",
".",
"Float64",
"(",
"1.0",
")",
",",
"Dimensions",
":",
"[",
"]",
"*",
"cloudwatch",
".",
"Dimension",
"{",
"}",
",",
"}",
",",
"}",
",",
"Namespace",
":",
"aws",
".",
"String",
"(",
"\"",
"\"",
")",
",",
"}",
")",
"\n",
"}"
] | // NewCertificate informs Cloudwatch that a new certificate has been created | [
"NewCertificate",
"informs",
"Cloudwatch",
"that",
"a",
"new",
"certificate",
"has",
"been",
"created"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/metrics/metrics.go#L39-L51 |
153,518 | mozilla/tls-observatory | worker/crlWorker/crlWorker.go | getCRLResponses | func getCRLResponses(cert certificate.Certificate) ([][]byte, error) {
var wg sync.WaitGroup
var out [][]byte
crlPoints := cert.X509v3Extensions.CRLDistributionPoints
wg.Add(len(crlPoints))
for i := range crlPoints {
go func(point string, wg *sync.WaitGroup) {
defer wg.Done()
resp, err := httpClient.Get(point)
if err != nil {
return
}
defer resp.Body.Close()
bs, err := ioutil.ReadAll(resp.Body)
if err != nil {
return
}
out = append(out, bs)
}(crlPoints[i], &wg)
}
wg.Wait()
if len(out) > 0 {
return out, nil
}
return nil, fmt.Errorf("Unable to load CRL data for certificate %s", cert.Subject)
} | go | func getCRLResponses(cert certificate.Certificate) ([][]byte, error) {
var wg sync.WaitGroup
var out [][]byte
crlPoints := cert.X509v3Extensions.CRLDistributionPoints
wg.Add(len(crlPoints))
for i := range crlPoints {
go func(point string, wg *sync.WaitGroup) {
defer wg.Done()
resp, err := httpClient.Get(point)
if err != nil {
return
}
defer resp.Body.Close()
bs, err := ioutil.ReadAll(resp.Body)
if err != nil {
return
}
out = append(out, bs)
}(crlPoints[i], &wg)
}
wg.Wait()
if len(out) > 0 {
return out, nil
}
return nil, fmt.Errorf("Unable to load CRL data for certificate %s", cert.Subject)
} | [
"func",
"getCRLResponses",
"(",
"cert",
"certificate",
".",
"Certificate",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"var",
"out",
"[",
"]",
"[",
"]",
"byte",
"\n\n",
"crlPoints",
":=",
"cert",
".",
"X509v3Extensions",
".",
"CRLDistributionPoints",
"\n",
"wg",
".",
"Add",
"(",
"len",
"(",
"crlPoints",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"crlPoints",
"{",
"go",
"func",
"(",
"point",
"string",
",",
"wg",
"*",
"sync",
".",
"WaitGroup",
")",
"{",
"defer",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"resp",
",",
"err",
":=",
"httpClient",
".",
"Get",
"(",
"point",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"bs",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"bs",
")",
"\n",
"}",
"(",
"crlPoints",
"[",
"i",
"]",
",",
"&",
"wg",
")",
"\n",
"}",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n\n",
"if",
"len",
"(",
"out",
")",
">",
"0",
"{",
"return",
"out",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cert",
".",
"Subject",
")",
"\n",
"}"
] | // Grab the first CRL response and return it in raw bytes | [
"Grab",
"the",
"first",
"CRL",
"response",
"and",
"return",
"it",
"in",
"raw",
"bytes"
] | a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c | https://github.com/mozilla/tls-observatory/blob/a3c1b6cfecfd7a0cf8f64c6bdc2b1e1d6a87e06c/worker/crlWorker/crlWorker.go#L168-L196 |
153,519 | juju/juju | cmd/juju/storage/detach.go | NewDetachStorageCommandWithAPI | func NewDetachStorageCommandWithAPI() cmd.Command {
command := &detachStorageCommand{}
command.newEntityDetacherCloser = func() (EntityDetacherCloser, error) {
return command.NewStorageAPI()
}
return modelcmd.Wrap(command)
} | go | func NewDetachStorageCommandWithAPI() cmd.Command {
command := &detachStorageCommand{}
command.newEntityDetacherCloser = func() (EntityDetacherCloser, error) {
return command.NewStorageAPI()
}
return modelcmd.Wrap(command)
} | [
"func",
"NewDetachStorageCommandWithAPI",
"(",
")",
"cmd",
".",
"Command",
"{",
"command",
":=",
"&",
"detachStorageCommand",
"{",
"}",
"\n",
"command",
".",
"newEntityDetacherCloser",
"=",
"func",
"(",
")",
"(",
"EntityDetacherCloser",
",",
"error",
")",
"{",
"return",
"command",
".",
"NewStorageAPI",
"(",
")",
"\n",
"}",
"\n",
"return",
"modelcmd",
".",
"Wrap",
"(",
"command",
")",
"\n",
"}"
] | // NewDetachStorageCommandWithAPI returns a command
// used to detach storage from application units. | [
"NewDetachStorageCommandWithAPI",
"returns",
"a",
"command",
"used",
"to",
"detach",
"storage",
"from",
"application",
"units",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/storage/detach.go#L21-L27 |
153,520 | juju/juju | cmd/juju/storage/detach.go | NewDetachStorageCommand | func NewDetachStorageCommand(new NewEntityDetacherCloserFunc) cmd.Command {
command := &detachStorageCommand{}
command.newEntityDetacherCloser = new
return modelcmd.Wrap(command)
} | go | func NewDetachStorageCommand(new NewEntityDetacherCloserFunc) cmd.Command {
command := &detachStorageCommand{}
command.newEntityDetacherCloser = new
return modelcmd.Wrap(command)
} | [
"func",
"NewDetachStorageCommand",
"(",
"new",
"NewEntityDetacherCloserFunc",
")",
"cmd",
".",
"Command",
"{",
"command",
":=",
"&",
"detachStorageCommand",
"{",
"}",
"\n",
"command",
".",
"newEntityDetacherCloser",
"=",
"new",
"\n",
"return",
"modelcmd",
".",
"Wrap",
"(",
"command",
")",
"\n",
"}"
] | // NewDetachStorageCommand returns a command used to
// detach storage from application units. | [
"NewDetachStorageCommand",
"returns",
"a",
"command",
"used",
"to",
"detach",
"storage",
"from",
"application",
"units",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/storage/detach.go#L31-L35 |
153,521 | juju/juju | worker/caasunitprovisioner/worker.go | NewWorker | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
p := &provisioner{config: config}
err := catacomb.Invoke(catacomb.Plan{
Site: &p.catacomb,
Work: p.loop,
})
return p, err
} | go | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
p := &provisioner{config: config}
err := catacomb.Invoke(catacomb.Plan{
Site: &p.catacomb,
Work: p.loop,
})
return p, err
} | [
"func",
"NewWorker",
"(",
"config",
"Config",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"p",
":=",
"&",
"provisioner",
"{",
"config",
":",
"config",
"}",
"\n",
"err",
":=",
"catacomb",
".",
"Invoke",
"(",
"catacomb",
".",
"Plan",
"{",
"Site",
":",
"&",
"p",
".",
"catacomb",
",",
"Work",
":",
"p",
".",
"loop",
",",
"}",
")",
"\n",
"return",
"p",
",",
"err",
"\n",
"}"
] | // NewWorker starts and returns a new CAAS unit provisioner worker. | [
"NewWorker",
"starts",
"and",
"returns",
"a",
"new",
"CAAS",
"unit",
"provisioner",
"worker",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/caasunitprovisioner/worker.go#L62-L72 |
153,522 | juju/juju | worker/caasunitprovisioner/worker.go | saveApplicationWorker | func (p *provisioner) saveApplicationWorker(appName string, aw *applicationWorker) {
p.mu.Lock()
defer p.mu.Unlock()
if p.appWorkers == nil {
p.appWorkers = make(map[string]*applicationWorker)
}
p.appWorkers[appName] = aw
} | go | func (p *provisioner) saveApplicationWorker(appName string, aw *applicationWorker) {
p.mu.Lock()
defer p.mu.Unlock()
if p.appWorkers == nil {
p.appWorkers = make(map[string]*applicationWorker)
}
p.appWorkers[appName] = aw
} | [
"func",
"(",
"p",
"*",
"provisioner",
")",
"saveApplicationWorker",
"(",
"appName",
"string",
",",
"aw",
"*",
"applicationWorker",
")",
"{",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"p",
".",
"appWorkers",
"==",
"nil",
"{",
"p",
".",
"appWorkers",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"applicationWorker",
")",
"\n",
"}",
"\n",
"p",
".",
"appWorkers",
"[",
"appName",
"]",
"=",
"aw",
"\n",
"}"
] | // These helper methods protect the appWorkers map so we can access for testing. | [
"These",
"helper",
"methods",
"protect",
"the",
"appWorkers",
"map",
"so",
"we",
"can",
"access",
"for",
"testing",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/caasunitprovisioner/worker.go#L96-L104 |
153,523 | juju/juju | cmd/juju/controller/addmodel.go | NewAddModelCommand | func NewAddModelCommand() cmd.Command {
command := &addModelCommand{
newAddModelAPI: func(caller base.APICallCloser) AddModelAPI {
return modelmanager.NewClient(caller)
},
newCloudAPI: func(caller base.APICallCloser) CloudAPI {
return cloudapi.NewClient(caller)
},
providerRegistry: environs.GlobalProviderRegistry(),
}
command.CanClearCurrentModel = true
return modelcmd.WrapController(command)
} | go | func NewAddModelCommand() cmd.Command {
command := &addModelCommand{
newAddModelAPI: func(caller base.APICallCloser) AddModelAPI {
return modelmanager.NewClient(caller)
},
newCloudAPI: func(caller base.APICallCloser) CloudAPI {
return cloudapi.NewClient(caller)
},
providerRegistry: environs.GlobalProviderRegistry(),
}
command.CanClearCurrentModel = true
return modelcmd.WrapController(command)
} | [
"func",
"NewAddModelCommand",
"(",
")",
"cmd",
".",
"Command",
"{",
"command",
":=",
"&",
"addModelCommand",
"{",
"newAddModelAPI",
":",
"func",
"(",
"caller",
"base",
".",
"APICallCloser",
")",
"AddModelAPI",
"{",
"return",
"modelmanager",
".",
"NewClient",
"(",
"caller",
")",
"\n",
"}",
",",
"newCloudAPI",
":",
"func",
"(",
"caller",
"base",
".",
"APICallCloser",
")",
"CloudAPI",
"{",
"return",
"cloudapi",
".",
"NewClient",
"(",
"caller",
")",
"\n",
"}",
",",
"providerRegistry",
":",
"environs",
".",
"GlobalProviderRegistry",
"(",
")",
",",
"}",
"\n",
"command",
".",
"CanClearCurrentModel",
"=",
"true",
"\n",
"return",
"modelcmd",
".",
"WrapController",
"(",
"command",
")",
"\n",
"}"
] | // NewAddModelCommand returns a command to add a model. | [
"NewAddModelCommand",
"returns",
"a",
"command",
"to",
"add",
"a",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/addmodel.go#L36-L48 |
153,524 | juju/juju | cmd/juju/controller/addmodel.go | findCredential | func (c *addModelCommand) findCredential(ctx *cmd.Context, cloudClient CloudAPI, p *findCredentialParams) (_ *jujucloud.Credential, _ names.CloudCredentialTag, cloudRegion string, _ error) {
if c.CredentialName == "" {
return c.findUnspecifiedCredential(ctx, cloudClient, p)
}
return c.findSpecifiedCredential(ctx, cloudClient, p)
} | go | func (c *addModelCommand) findCredential(ctx *cmd.Context, cloudClient CloudAPI, p *findCredentialParams) (_ *jujucloud.Credential, _ names.CloudCredentialTag, cloudRegion string, _ error) {
if c.CredentialName == "" {
return c.findUnspecifiedCredential(ctx, cloudClient, p)
}
return c.findSpecifiedCredential(ctx, cloudClient, p)
} | [
"func",
"(",
"c",
"*",
"addModelCommand",
")",
"findCredential",
"(",
"ctx",
"*",
"cmd",
".",
"Context",
",",
"cloudClient",
"CloudAPI",
",",
"p",
"*",
"findCredentialParams",
")",
"(",
"_",
"*",
"jujucloud",
".",
"Credential",
",",
"_",
"names",
".",
"CloudCredentialTag",
",",
"cloudRegion",
"string",
",",
"_",
"error",
")",
"{",
"if",
"c",
".",
"CredentialName",
"==",
"\"",
"\"",
"{",
"return",
"c",
".",
"findUnspecifiedCredential",
"(",
"ctx",
",",
"cloudClient",
",",
"p",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"findSpecifiedCredential",
"(",
"ctx",
",",
"cloudClient",
",",
"p",
")",
"\n",
"}"
] | // findCredential finds a suitable credential to use for the new model.
// The credential will first be searched for locally and then on the
// controller. If a credential is found locally then it's value will be
// returned as the first return value. If it is found on the controller
// this will be nil as there is no need to upload it in that case. | [
"findCredential",
"finds",
"a",
"suitable",
"credential",
"to",
"use",
"for",
"the",
"new",
"model",
".",
"The",
"credential",
"will",
"first",
"be",
"searched",
"for",
"locally",
"and",
"then",
"on",
"the",
"controller",
".",
"If",
"a",
"credential",
"is",
"found",
"locally",
"then",
"it",
"s",
"value",
"will",
"be",
"returned",
"as",
"the",
"first",
"return",
"value",
".",
"If",
"it",
"is",
"found",
"on",
"the",
"controller",
"this",
"will",
"be",
"nil",
"as",
"there",
"is",
"no",
"need",
"to",
"upload",
"it",
"in",
"that",
"case",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/addmodel.go#L465-L470 |
153,525 | juju/juju | worker/pubsub/messagewriter.go | NewMessageWriter | func NewMessageWriter(info *api.Info) (MessageWriter, error) {
conn, err := api.Open(info, dialOpts)
if err != nil {
return nil, errors.Trace(err)
}
a := pubsubapi.NewAPI(conn)
writer, err := a.OpenMessageWriter()
if err != nil {
conn.Close()
return nil, errors.Trace(err)
}
return &remoteConnection{connection: conn, MessageWriter: writer}, nil
} | go | func NewMessageWriter(info *api.Info) (MessageWriter, error) {
conn, err := api.Open(info, dialOpts)
if err != nil {
return nil, errors.Trace(err)
}
a := pubsubapi.NewAPI(conn)
writer, err := a.OpenMessageWriter()
if err != nil {
conn.Close()
return nil, errors.Trace(err)
}
return &remoteConnection{connection: conn, MessageWriter: writer}, nil
} | [
"func",
"NewMessageWriter",
"(",
"info",
"*",
"api",
".",
"Info",
")",
"(",
"MessageWriter",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"api",
".",
"Open",
"(",
"info",
",",
"dialOpts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
":=",
"pubsubapi",
".",
"NewAPI",
"(",
"conn",
")",
"\n",
"writer",
",",
"err",
":=",
"a",
".",
"OpenMessageWriter",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"remoteConnection",
"{",
"connection",
":",
"conn",
",",
"MessageWriter",
":",
"writer",
"}",
",",
"nil",
"\n",
"}"
] | // NewMessageWriter will connect to the remote defined by the info,
// and return a MessageWriter. | [
"NewMessageWriter",
"will",
"connect",
"to",
"the",
"remote",
"defined",
"by",
"the",
"info",
"and",
"return",
"a",
"MessageWriter",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/pubsub/messagewriter.go#L36-L48 |
153,526 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockEventInterface | func NewMockEventInterface(ctrl *gomock.Controller) *MockEventInterface {
mock := &MockEventInterface{ctrl: ctrl}
mock.recorder = &MockEventInterfaceMockRecorder{mock}
return mock
} | go | func NewMockEventInterface(ctrl *gomock.Controller) *MockEventInterface {
mock := &MockEventInterface{ctrl: ctrl}
mock.recorder = &MockEventInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockEventInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockEventInterface",
"{",
"mock",
":=",
"&",
"MockEventInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockEventInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockEventInterface creates a new mock instance | [
"NewMockEventInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L33-L37 |
153,527 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | GetFieldSelector | func (m *MockEventInterface) GetFieldSelector(arg0, arg1, arg2, arg3 *string) fields.Selector {
ret := m.ctrl.Call(m, "GetFieldSelector", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(fields.Selector)
return ret0
} | go | func (m *MockEventInterface) GetFieldSelector(arg0, arg1, arg2, arg3 *string) fields.Selector {
ret := m.ctrl.Call(m, "GetFieldSelector", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(fields.Selector)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockEventInterface",
")",
"GetFieldSelector",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
"*",
"string",
")",
"fields",
".",
"Selector",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"fields",
".",
"Selector",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetFieldSelector mocks base method | [
"GetFieldSelector",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L108-L112 |
153,528 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | GetFieldSelector | func (mr *MockEventInterfaceMockRecorder) GetFieldSelector(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFieldSelector", reflect.TypeOf((*MockEventInterface)(nil).GetFieldSelector), arg0, arg1, arg2, arg3)
} | go | func (mr *MockEventInterfaceMockRecorder) GetFieldSelector(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFieldSelector", reflect.TypeOf((*MockEventInterface)(nil).GetFieldSelector), arg0, arg1, arg2, arg3)
} | [
"func",
"(",
"mr",
"*",
"MockEventInterfaceMockRecorder",
")",
"GetFieldSelector",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockEventInterface",
")",
"(",
"nil",
")",
".",
"GetFieldSelector",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
")",
"\n",
"}"
] | // GetFieldSelector indicates an expected call of GetFieldSelector | [
"GetFieldSelector",
"indicates",
"an",
"expected",
"call",
"of",
"GetFieldSelector"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L115-L117 |
153,529 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | PatchWithEventNamespace | func (m *MockEventInterface) PatchWithEventNamespace(arg0 *v1.Event, arg1 []byte) (*v1.Event, error) {
ret := m.ctrl.Call(m, "PatchWithEventNamespace", arg0, arg1)
ret0, _ := ret[0].(*v1.Event)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockEventInterface) PatchWithEventNamespace(arg0 *v1.Event, arg1 []byte) (*v1.Event, error) {
ret := m.ctrl.Call(m, "PatchWithEventNamespace", arg0, arg1)
ret0, _ := ret[0].(*v1.Event)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockEventInterface",
")",
"PatchWithEventNamespace",
"(",
"arg0",
"*",
"v1",
".",
"Event",
",",
"arg1",
"[",
"]",
"byte",
")",
"(",
"*",
"v1",
".",
"Event",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"v1",
".",
"Event",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // PatchWithEventNamespace mocks base method | [
"PatchWithEventNamespace",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L151-L156 |
153,530 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Search | func (m *MockEventInterface) Search(arg0 *runtime.Scheme, arg1 runtime.Object) (*v1.EventList, error) {
ret := m.ctrl.Call(m, "Search", arg0, arg1)
ret0, _ := ret[0].(*v1.EventList)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockEventInterface) Search(arg0 *runtime.Scheme, arg1 runtime.Object) (*v1.EventList, error) {
ret := m.ctrl.Call(m, "Search", arg0, arg1)
ret0, _ := ret[0].(*v1.EventList)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockEventInterface",
")",
"Search",
"(",
"arg0",
"*",
"runtime",
".",
"Scheme",
",",
"arg1",
"runtime",
".",
"Object",
")",
"(",
"*",
"v1",
".",
"EventList",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"v1",
".",
"EventList",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // Search mocks base method | [
"Search",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L164-L169 |
153,531 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | UpdateWithEventNamespace | func (m *MockEventInterface) UpdateWithEventNamespace(arg0 *v1.Event) (*v1.Event, error) {
ret := m.ctrl.Call(m, "UpdateWithEventNamespace", arg0)
ret0, _ := ret[0].(*v1.Event)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockEventInterface) UpdateWithEventNamespace(arg0 *v1.Event) (*v1.Event, error) {
ret := m.ctrl.Call(m, "UpdateWithEventNamespace", arg0)
ret0, _ := ret[0].(*v1.Event)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockEventInterface",
")",
"UpdateWithEventNamespace",
"(",
"arg0",
"*",
"v1",
".",
"Event",
")",
"(",
"*",
"v1",
".",
"Event",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"v1",
".",
"Event",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateWithEventNamespace mocks base method | [
"UpdateWithEventNamespace",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L190-L195 |
153,532 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockCoreV1Interface | func NewMockCoreV1Interface(ctrl *gomock.Controller) *MockCoreV1Interface {
mock := &MockCoreV1Interface{ctrl: ctrl}
mock.recorder = &MockCoreV1InterfaceMockRecorder{mock}
return mock
} | go | func NewMockCoreV1Interface(ctrl *gomock.Controller) *MockCoreV1Interface {
mock := &MockCoreV1Interface{ctrl: ctrl}
mock.recorder = &MockCoreV1InterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockCoreV1Interface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockCoreV1Interface",
"{",
"mock",
":=",
"&",
"MockCoreV1Interface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockCoreV1InterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockCoreV1Interface creates a new mock instance | [
"NewMockCoreV1Interface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L227-L231 |
153,533 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | ComponentStatuses | func (m *MockCoreV1Interface) ComponentStatuses() v11.ComponentStatusInterface {
ret := m.ctrl.Call(m, "ComponentStatuses")
ret0, _ := ret[0].(v11.ComponentStatusInterface)
return ret0
} | go | func (m *MockCoreV1Interface) ComponentStatuses() v11.ComponentStatusInterface {
ret := m.ctrl.Call(m, "ComponentStatuses")
ret0, _ := ret[0].(v11.ComponentStatusInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"ComponentStatuses",
"(",
")",
"v11",
".",
"ComponentStatusInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"ComponentStatusInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ComponentStatuses mocks base method | [
"ComponentStatuses",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L239-L243 |
153,534 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | ConfigMaps | func (m *MockCoreV1Interface) ConfigMaps(arg0 string) v11.ConfigMapInterface {
ret := m.ctrl.Call(m, "ConfigMaps", arg0)
ret0, _ := ret[0].(v11.ConfigMapInterface)
return ret0
} | go | func (m *MockCoreV1Interface) ConfigMaps(arg0 string) v11.ConfigMapInterface {
ret := m.ctrl.Call(m, "ConfigMaps", arg0)
ret0, _ := ret[0].(v11.ConfigMapInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"ConfigMaps",
"(",
"arg0",
"string",
")",
"v11",
".",
"ConfigMapInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"ConfigMapInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ConfigMaps mocks base method | [
"ConfigMaps",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L251-L255 |
153,535 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Endpoints | func (m *MockCoreV1Interface) Endpoints(arg0 string) v11.EndpointsInterface {
ret := m.ctrl.Call(m, "Endpoints", arg0)
ret0, _ := ret[0].(v11.EndpointsInterface)
return ret0
} | go | func (m *MockCoreV1Interface) Endpoints(arg0 string) v11.EndpointsInterface {
ret := m.ctrl.Call(m, "Endpoints", arg0)
ret0, _ := ret[0].(v11.EndpointsInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"Endpoints",
"(",
"arg0",
"string",
")",
"v11",
".",
"EndpointsInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"EndpointsInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Endpoints mocks base method | [
"Endpoints",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L263-L267 |
153,536 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | LimitRanges | func (m *MockCoreV1Interface) LimitRanges(arg0 string) v11.LimitRangeInterface {
ret := m.ctrl.Call(m, "LimitRanges", arg0)
ret0, _ := ret[0].(v11.LimitRangeInterface)
return ret0
} | go | func (m *MockCoreV1Interface) LimitRanges(arg0 string) v11.LimitRangeInterface {
ret := m.ctrl.Call(m, "LimitRanges", arg0)
ret0, _ := ret[0].(v11.LimitRangeInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"LimitRanges",
"(",
"arg0",
"string",
")",
"v11",
".",
"LimitRangeInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"LimitRangeInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // LimitRanges mocks base method | [
"LimitRanges",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L287-L291 |
153,537 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Namespaces | func (m *MockCoreV1Interface) Namespaces() v11.NamespaceInterface {
ret := m.ctrl.Call(m, "Namespaces")
ret0, _ := ret[0].(v11.NamespaceInterface)
return ret0
} | go | func (m *MockCoreV1Interface) Namespaces() v11.NamespaceInterface {
ret := m.ctrl.Call(m, "Namespaces")
ret0, _ := ret[0].(v11.NamespaceInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"Namespaces",
"(",
")",
"v11",
".",
"NamespaceInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"NamespaceInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Namespaces mocks base method | [
"Namespaces",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L299-L303 |
153,538 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Nodes | func (m *MockCoreV1Interface) Nodes() v11.NodeInterface {
ret := m.ctrl.Call(m, "Nodes")
ret0, _ := ret[0].(v11.NodeInterface)
return ret0
} | go | func (m *MockCoreV1Interface) Nodes() v11.NodeInterface {
ret := m.ctrl.Call(m, "Nodes")
ret0, _ := ret[0].(v11.NodeInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"Nodes",
"(",
")",
"v11",
".",
"NodeInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"NodeInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Nodes mocks base method | [
"Nodes",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L311-L315 |
153,539 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | PersistentVolumeClaims | func (m *MockCoreV1Interface) PersistentVolumeClaims(arg0 string) v11.PersistentVolumeClaimInterface {
ret := m.ctrl.Call(m, "PersistentVolumeClaims", arg0)
ret0, _ := ret[0].(v11.PersistentVolumeClaimInterface)
return ret0
} | go | func (m *MockCoreV1Interface) PersistentVolumeClaims(arg0 string) v11.PersistentVolumeClaimInterface {
ret := m.ctrl.Call(m, "PersistentVolumeClaims", arg0)
ret0, _ := ret[0].(v11.PersistentVolumeClaimInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"PersistentVolumeClaims",
"(",
"arg0",
"string",
")",
"v11",
".",
"PersistentVolumeClaimInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"PersistentVolumeClaimInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // PersistentVolumeClaims mocks base method | [
"PersistentVolumeClaims",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L323-L327 |
153,540 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | PersistentVolumes | func (m *MockCoreV1Interface) PersistentVolumes() v11.PersistentVolumeInterface {
ret := m.ctrl.Call(m, "PersistentVolumes")
ret0, _ := ret[0].(v11.PersistentVolumeInterface)
return ret0
} | go | func (m *MockCoreV1Interface) PersistentVolumes() v11.PersistentVolumeInterface {
ret := m.ctrl.Call(m, "PersistentVolumes")
ret0, _ := ret[0].(v11.PersistentVolumeInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"PersistentVolumes",
"(",
")",
"v11",
".",
"PersistentVolumeInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"PersistentVolumeInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // PersistentVolumes mocks base method | [
"PersistentVolumes",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L335-L339 |
153,541 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | PersistentVolumes | func (mr *MockCoreV1InterfaceMockRecorder) PersistentVolumes() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PersistentVolumes", reflect.TypeOf((*MockCoreV1Interface)(nil).PersistentVolumes))
} | go | func (mr *MockCoreV1InterfaceMockRecorder) PersistentVolumes() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PersistentVolumes", reflect.TypeOf((*MockCoreV1Interface)(nil).PersistentVolumes))
} | [
"func",
"(",
"mr",
"*",
"MockCoreV1InterfaceMockRecorder",
")",
"PersistentVolumes",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCoreV1Interface",
")",
"(",
"nil",
")",
".",
"PersistentVolumes",
")",
")",
"\n",
"}"
] | // PersistentVolumes indicates an expected call of PersistentVolumes | [
"PersistentVolumes",
"indicates",
"an",
"expected",
"call",
"of",
"PersistentVolumes"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L342-L344 |
153,542 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | PodTemplates | func (m *MockCoreV1Interface) PodTemplates(arg0 string) v11.PodTemplateInterface {
ret := m.ctrl.Call(m, "PodTemplates", arg0)
ret0, _ := ret[0].(v11.PodTemplateInterface)
return ret0
} | go | func (m *MockCoreV1Interface) PodTemplates(arg0 string) v11.PodTemplateInterface {
ret := m.ctrl.Call(m, "PodTemplates", arg0)
ret0, _ := ret[0].(v11.PodTemplateInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"PodTemplates",
"(",
"arg0",
"string",
")",
"v11",
".",
"PodTemplateInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"PodTemplateInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // PodTemplates mocks base method | [
"PodTemplates",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L347-L351 |
153,543 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | PodTemplates | func (mr *MockCoreV1InterfaceMockRecorder) PodTemplates(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PodTemplates", reflect.TypeOf((*MockCoreV1Interface)(nil).PodTemplates), arg0)
} | go | func (mr *MockCoreV1InterfaceMockRecorder) PodTemplates(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PodTemplates", reflect.TypeOf((*MockCoreV1Interface)(nil).PodTemplates), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockCoreV1InterfaceMockRecorder",
")",
"PodTemplates",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCoreV1Interface",
")",
"(",
"nil",
")",
".",
"PodTemplates",
")",
",",
"arg0",
")",
"\n",
"}"
] | // PodTemplates indicates an expected call of PodTemplates | [
"PodTemplates",
"indicates",
"an",
"expected",
"call",
"of",
"PodTemplates"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L354-L356 |
153,544 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Pods | func (m *MockCoreV1Interface) Pods(arg0 string) v11.PodInterface {
ret := m.ctrl.Call(m, "Pods", arg0)
ret0, _ := ret[0].(v11.PodInterface)
return ret0
} | go | func (m *MockCoreV1Interface) Pods(arg0 string) v11.PodInterface {
ret := m.ctrl.Call(m, "Pods", arg0)
ret0, _ := ret[0].(v11.PodInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"Pods",
"(",
"arg0",
"string",
")",
"v11",
".",
"PodInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"PodInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Pods mocks base method | [
"Pods",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L359-L363 |
153,545 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | ReplicationControllers | func (m *MockCoreV1Interface) ReplicationControllers(arg0 string) v11.ReplicationControllerInterface {
ret := m.ctrl.Call(m, "ReplicationControllers", arg0)
ret0, _ := ret[0].(v11.ReplicationControllerInterface)
return ret0
} | go | func (m *MockCoreV1Interface) ReplicationControllers(arg0 string) v11.ReplicationControllerInterface {
ret := m.ctrl.Call(m, "ReplicationControllers", arg0)
ret0, _ := ret[0].(v11.ReplicationControllerInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"ReplicationControllers",
"(",
"arg0",
"string",
")",
"v11",
".",
"ReplicationControllerInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"ReplicationControllerInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ReplicationControllers mocks base method | [
"ReplicationControllers",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L383-L387 |
153,546 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | ResourceQuotas | func (m *MockCoreV1Interface) ResourceQuotas(arg0 string) v11.ResourceQuotaInterface {
ret := m.ctrl.Call(m, "ResourceQuotas", arg0)
ret0, _ := ret[0].(v11.ResourceQuotaInterface)
return ret0
} | go | func (m *MockCoreV1Interface) ResourceQuotas(arg0 string) v11.ResourceQuotaInterface {
ret := m.ctrl.Call(m, "ResourceQuotas", arg0)
ret0, _ := ret[0].(v11.ResourceQuotaInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"ResourceQuotas",
"(",
"arg0",
"string",
")",
"v11",
".",
"ResourceQuotaInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"ResourceQuotaInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ResourceQuotas mocks base method | [
"ResourceQuotas",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L395-L399 |
153,547 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Secrets | func (m *MockCoreV1Interface) Secrets(arg0 string) v11.SecretInterface {
ret := m.ctrl.Call(m, "Secrets", arg0)
ret0, _ := ret[0].(v11.SecretInterface)
return ret0
} | go | func (m *MockCoreV1Interface) Secrets(arg0 string) v11.SecretInterface {
ret := m.ctrl.Call(m, "Secrets", arg0)
ret0, _ := ret[0].(v11.SecretInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"Secrets",
"(",
"arg0",
"string",
")",
"v11",
".",
"SecretInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"SecretInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Secrets mocks base method | [
"Secrets",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L407-L411 |
153,548 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | ServiceAccounts | func (m *MockCoreV1Interface) ServiceAccounts(arg0 string) v11.ServiceAccountInterface {
ret := m.ctrl.Call(m, "ServiceAccounts", arg0)
ret0, _ := ret[0].(v11.ServiceAccountInterface)
return ret0
} | go | func (m *MockCoreV1Interface) ServiceAccounts(arg0 string) v11.ServiceAccountInterface {
ret := m.ctrl.Call(m, "ServiceAccounts", arg0)
ret0, _ := ret[0].(v11.ServiceAccountInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"ServiceAccounts",
"(",
"arg0",
"string",
")",
"v11",
".",
"ServiceAccountInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"ServiceAccountInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ServiceAccounts mocks base method | [
"ServiceAccounts",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L419-L423 |
153,549 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Services | func (m *MockCoreV1Interface) Services(arg0 string) v11.ServiceInterface {
ret := m.ctrl.Call(m, "Services", arg0)
ret0, _ := ret[0].(v11.ServiceInterface)
return ret0
} | go | func (m *MockCoreV1Interface) Services(arg0 string) v11.ServiceInterface {
ret := m.ctrl.Call(m, "Services", arg0)
ret0, _ := ret[0].(v11.ServiceInterface)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCoreV1Interface",
")",
"Services",
"(",
"arg0",
"string",
")",
"v11",
".",
"ServiceInterface",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"v11",
".",
"ServiceInterface",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Services mocks base method | [
"Services",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L431-L435 |
153,550 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockNamespaceInterface | func NewMockNamespaceInterface(ctrl *gomock.Controller) *MockNamespaceInterface {
mock := &MockNamespaceInterface{ctrl: ctrl}
mock.recorder = &MockNamespaceInterfaceMockRecorder{mock}
return mock
} | go | func NewMockNamespaceInterface(ctrl *gomock.Controller) *MockNamespaceInterface {
mock := &MockNamespaceInterface{ctrl: ctrl}
mock.recorder = &MockNamespaceInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockNamespaceInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockNamespaceInterface",
"{",
"mock",
":=",
"&",
"MockNamespaceInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockNamespaceInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockNamespaceInterface creates a new mock instance | [
"NewMockNamespaceInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L454-L458 |
153,551 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockPodInterface | func NewMockPodInterface(ctrl *gomock.Controller) *MockPodInterface {
mock := &MockPodInterface{ctrl: ctrl}
mock.recorder = &MockPodInterfaceMockRecorder{mock}
return mock
} | go | func NewMockPodInterface(ctrl *gomock.Controller) *MockPodInterface {
mock := &MockPodInterface{ctrl: ctrl}
mock.recorder = &MockPodInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockPodInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockPodInterface",
"{",
"mock",
":=",
"&",
"MockPodInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockPodInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockPodInterface creates a new mock instance | [
"NewMockPodInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L598-L602 |
153,552 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Bind | func (m *MockPodInterface) Bind(arg0 *v1.Binding) error {
ret := m.ctrl.Call(m, "Bind", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockPodInterface) Bind(arg0 *v1.Binding) error {
ret := m.ctrl.Call(m, "Bind", arg0)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockPodInterface",
")",
"Bind",
"(",
"arg0",
"*",
"v1",
".",
"Binding",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Bind mocks base method | [
"Bind",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L610-L614 |
153,553 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Bind | func (mr *MockPodInterfaceMockRecorder) Bind(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bind", reflect.TypeOf((*MockPodInterface)(nil).Bind), arg0)
} | go | func (mr *MockPodInterfaceMockRecorder) Bind(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bind", reflect.TypeOf((*MockPodInterface)(nil).Bind), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockPodInterfaceMockRecorder",
")",
"Bind",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockPodInterface",
")",
"(",
"nil",
")",
".",
"Bind",
")",
",",
"arg0",
")",
"\n",
"}"
] | // Bind indicates an expected call of Bind | [
"Bind",
"indicates",
"an",
"expected",
"call",
"of",
"Bind"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L617-L619 |
153,554 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | Evict | func (m *MockPodInterface) Evict(arg0 *v1beta1.Eviction) error {
ret := m.ctrl.Call(m, "Evict", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockPodInterface) Evict(arg0 *v1beta1.Eviction) error {
ret := m.ctrl.Call(m, "Evict", arg0)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockPodInterface",
")",
"Evict",
"(",
"arg0",
"*",
"v1beta1",
".",
"Eviction",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Evict mocks base method | [
"Evict",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L659-L663 |
153,555 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | GetLogs | func (m *MockPodInterface) GetLogs(arg0 string, arg1 *v1.PodLogOptions) *rest.Request {
ret := m.ctrl.Call(m, "GetLogs", arg0, arg1)
ret0, _ := ret[0].(*rest.Request)
return ret0
} | go | func (m *MockPodInterface) GetLogs(arg0 string, arg1 *v1.PodLogOptions) *rest.Request {
ret := m.ctrl.Call(m, "GetLogs", arg0, arg1)
ret0, _ := ret[0].(*rest.Request)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockPodInterface",
")",
"GetLogs",
"(",
"arg0",
"string",
",",
"arg1",
"*",
"v1",
".",
"PodLogOptions",
")",
"*",
"rest",
".",
"Request",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"rest",
".",
"Request",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetLogs mocks base method | [
"GetLogs",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L684-L688 |
153,556 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockServiceInterface | func NewMockServiceInterface(ctrl *gomock.Controller) *MockServiceInterface {
mock := &MockServiceInterface{ctrl: ctrl}
mock.recorder = &MockServiceInterfaceMockRecorder{mock}
return mock
} | go | func NewMockServiceInterface(ctrl *gomock.Controller) *MockServiceInterface {
mock := &MockServiceInterface{ctrl: ctrl}
mock.recorder = &MockServiceInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockServiceInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockServiceInterface",
"{",
"mock",
":=",
"&",
"MockServiceInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockServiceInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockServiceInterface creates a new mock instance | [
"NewMockServiceInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L777-L781 |
153,557 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | ProxyGet | func (m *MockServiceInterface) ProxyGet(arg0, arg1, arg2, arg3 string, arg4 map[string]string) rest.ResponseWrapper {
ret := m.ctrl.Call(m, "ProxyGet", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(rest.ResponseWrapper)
return ret0
} | go | func (m *MockServiceInterface) ProxyGet(arg0, arg1, arg2, arg3 string, arg4 map[string]string) rest.ResponseWrapper {
ret := m.ctrl.Call(m, "ProxyGet", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(rest.ResponseWrapper)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockServiceInterface",
")",
"ProxyGet",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
"string",
",",
"arg4",
"map",
"[",
"string",
"]",
"string",
")",
"rest",
".",
"ResponseWrapper",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"rest",
".",
"ResponseWrapper",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ProxyGet mocks base method | [
"ProxyGet",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L858-L862 |
153,558 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | ProxyGet | func (mr *MockServiceInterfaceMockRecorder) ProxyGet(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProxyGet", reflect.TypeOf((*MockServiceInterface)(nil).ProxyGet), arg0, arg1, arg2, arg3, arg4)
} | go | func (mr *MockServiceInterfaceMockRecorder) ProxyGet(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProxyGet", reflect.TypeOf((*MockServiceInterface)(nil).ProxyGet), arg0, arg1, arg2, arg3, arg4)
} | [
"func",
"(",
"mr",
"*",
"MockServiceInterfaceMockRecorder",
")",
"ProxyGet",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockServiceInterface",
")",
"(",
"nil",
")",
".",
"ProxyGet",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"}"
] | // ProxyGet indicates an expected call of ProxyGet | [
"ProxyGet",
"indicates",
"an",
"expected",
"call",
"of",
"ProxyGet"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L865-L867 |
153,559 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockConfigMapInterface | func NewMockConfigMapInterface(ctrl *gomock.Controller) *MockConfigMapInterface {
mock := &MockConfigMapInterface{ctrl: ctrl}
mock.recorder = &MockConfigMapInterfaceMockRecorder{mock}
return mock
} | go | func NewMockConfigMapInterface(ctrl *gomock.Controller) *MockConfigMapInterface {
mock := &MockConfigMapInterface{ctrl: ctrl}
mock.recorder = &MockConfigMapInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockConfigMapInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockConfigMapInterface",
"{",
"mock",
":=",
"&",
"MockConfigMapInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockConfigMapInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockConfigMapInterface creates a new mock instance | [
"NewMockConfigMapInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L920-L924 |
153,560 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockPersistentVolumeInterface | func NewMockPersistentVolumeInterface(ctrl *gomock.Controller) *MockPersistentVolumeInterface {
mock := &MockPersistentVolumeInterface{ctrl: ctrl}
mock.recorder = &MockPersistentVolumeInterfaceMockRecorder{mock}
return mock
} | go | func NewMockPersistentVolumeInterface(ctrl *gomock.Controller) *MockPersistentVolumeInterface {
mock := &MockPersistentVolumeInterface{ctrl: ctrl}
mock.recorder = &MockPersistentVolumeInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockPersistentVolumeInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockPersistentVolumeInterface",
"{",
"mock",
":=",
"&",
"MockPersistentVolumeInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockPersistentVolumeInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockPersistentVolumeInterface creates a new mock instance | [
"NewMockPersistentVolumeInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L1050-L1054 |
153,561 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockPersistentVolumeClaimInterface | func NewMockPersistentVolumeClaimInterface(ctrl *gomock.Controller) *MockPersistentVolumeClaimInterface {
mock := &MockPersistentVolumeClaimInterface{ctrl: ctrl}
mock.recorder = &MockPersistentVolumeClaimInterfaceMockRecorder{mock}
return mock
} | go | func NewMockPersistentVolumeClaimInterface(ctrl *gomock.Controller) *MockPersistentVolumeClaimInterface {
mock := &MockPersistentVolumeClaimInterface{ctrl: ctrl}
mock.recorder = &MockPersistentVolumeClaimInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockPersistentVolumeClaimInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockPersistentVolumeClaimInterface",
"{",
"mock",
":=",
"&",
"MockPersistentVolumeClaimInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockPersistentVolumeClaimInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockPersistentVolumeClaimInterface creates a new mock instance | [
"NewMockPersistentVolumeClaimInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L1193-L1197 |
153,562 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | DeleteCollection | func (mr *MockPersistentVolumeClaimInterfaceMockRecorder) DeleteCollection(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCollection", reflect.TypeOf((*MockPersistentVolumeClaimInterface)(nil).DeleteCollection), arg0, arg1)
} | go | func (mr *MockPersistentVolumeClaimInterfaceMockRecorder) DeleteCollection(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCollection", reflect.TypeOf((*MockPersistentVolumeClaimInterface)(nil).DeleteCollection), arg0, arg1)
} | [
"func",
"(",
"mr",
"*",
"MockPersistentVolumeClaimInterfaceMockRecorder",
")",
"DeleteCollection",
"(",
"arg0",
",",
"arg1",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockPersistentVolumeClaimInterface",
")",
"(",
"nil",
")",
".",
"DeleteCollection",
")",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // DeleteCollection indicates an expected call of DeleteCollection | [
"DeleteCollection",
"indicates",
"an",
"expected",
"call",
"of",
"DeleteCollection"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L1237-L1239 |
153,563 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockSecretInterface | func NewMockSecretInterface(ctrl *gomock.Controller) *MockSecretInterface {
mock := &MockSecretInterface{ctrl: ctrl}
mock.recorder = &MockSecretInterfaceMockRecorder{mock}
return mock
} | go | func NewMockSecretInterface(ctrl *gomock.Controller) *MockSecretInterface {
mock := &MockSecretInterface{ctrl: ctrl}
mock.recorder = &MockSecretInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockSecretInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockSecretInterface",
"{",
"mock",
":=",
"&",
"MockSecretInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockSecretInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockSecretInterface creates a new mock instance | [
"NewMockSecretInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L1336-L1340 |
153,564 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | NewMockNodeInterface | func NewMockNodeInterface(ctrl *gomock.Controller) *MockNodeInterface {
mock := &MockNodeInterface{ctrl: ctrl}
mock.recorder = &MockNodeInterfaceMockRecorder{mock}
return mock
} | go | func NewMockNodeInterface(ctrl *gomock.Controller) *MockNodeInterface {
mock := &MockNodeInterface{ctrl: ctrl}
mock.recorder = &MockNodeInterfaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockNodeInterface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockNodeInterface",
"{",
"mock",
":=",
"&",
"MockNodeInterface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockNodeInterfaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockNodeInterface creates a new mock instance | [
"NewMockNodeInterface",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L1466-L1470 |
153,565 | juju/juju | caas/kubernetes/provider/mocks/corev1_mock.go | PatchStatus | func (m *MockNodeInterface) PatchStatus(arg0 string, arg1 []byte) (*v1.Node, error) {
ret := m.ctrl.Call(m, "PatchStatus", arg0, arg1)
ret0, _ := ret[0].(*v1.Node)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockNodeInterface) PatchStatus(arg0 string, arg1 []byte) (*v1.Node, error) {
ret := m.ctrl.Call(m, "PatchStatus", arg0, arg1)
ret0, _ := ret[0].(*v1.Node)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockNodeInterface",
")",
"PatchStatus",
"(",
"arg0",
"string",
",",
"arg1",
"[",
"]",
"byte",
")",
"(",
"*",
"v1",
".",
"Node",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"v1",
".",
"Node",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // PatchStatus mocks base method | [
"PatchStatus",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/mocks/corev1_mock.go#L1559-L1564 |
153,566 | juju/juju | provider/azure/internal/tracing/tracing.go | PrepareDecorator | func PrepareDecorator(logger loggo.Logger) autorest.PrepareDecorator {
return func(p autorest.Preparer) autorest.Preparer {
return autorest.PreparerFunc(func(r *http.Request) (*http.Request, error) {
if logger.IsTraceEnabled() {
dump, err := httputil.DumpRequest(r, true)
if err != nil {
logger.Tracef("failed to dump request: %v", err)
logger.Tracef("%+v", r)
} else {
logger.Tracef("%s", dump)
}
}
return p.Prepare(r)
})
}
} | go | func PrepareDecorator(logger loggo.Logger) autorest.PrepareDecorator {
return func(p autorest.Preparer) autorest.Preparer {
return autorest.PreparerFunc(func(r *http.Request) (*http.Request, error) {
if logger.IsTraceEnabled() {
dump, err := httputil.DumpRequest(r, true)
if err != nil {
logger.Tracef("failed to dump request: %v", err)
logger.Tracef("%+v", r)
} else {
logger.Tracef("%s", dump)
}
}
return p.Prepare(r)
})
}
} | [
"func",
"PrepareDecorator",
"(",
"logger",
"loggo",
".",
"Logger",
")",
"autorest",
".",
"PrepareDecorator",
"{",
"return",
"func",
"(",
"p",
"autorest",
".",
"Preparer",
")",
"autorest",
".",
"Preparer",
"{",
"return",
"autorest",
".",
"PreparerFunc",
"(",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"if",
"logger",
".",
"IsTraceEnabled",
"(",
")",
"{",
"dump",
",",
"err",
":=",
"httputil",
".",
"DumpRequest",
"(",
"r",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"logger",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"dump",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"p",
".",
"Prepare",
"(",
"r",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // PrepareDecorator returns an autorest.PrepareDecorator that
// logs requests at trace level. | [
"PrepareDecorator",
"returns",
"an",
"autorest",
".",
"PrepareDecorator",
"that",
"logs",
"requests",
"at",
"trace",
"level",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/azure/internal/tracing/tracing.go#L16-L31 |
153,567 | juju/juju | provider/azure/internal/tracing/tracing.go | RespondDecorator | func RespondDecorator(logger loggo.Logger) autorest.RespondDecorator {
return func(r autorest.Responder) autorest.Responder {
return autorest.ResponderFunc(func(resp *http.Response) error {
if logger.IsTraceEnabled() {
dump, err := httputil.DumpResponse(resp, true)
if err != nil {
logger.Tracef("failed to dump response: %v", err)
logger.Tracef("%+v", resp)
} else {
logger.Tracef("%s", dump)
}
}
return r.Respond(resp)
})
}
} | go | func RespondDecorator(logger loggo.Logger) autorest.RespondDecorator {
return func(r autorest.Responder) autorest.Responder {
return autorest.ResponderFunc(func(resp *http.Response) error {
if logger.IsTraceEnabled() {
dump, err := httputil.DumpResponse(resp, true)
if err != nil {
logger.Tracef("failed to dump response: %v", err)
logger.Tracef("%+v", resp)
} else {
logger.Tracef("%s", dump)
}
}
return r.Respond(resp)
})
}
} | [
"func",
"RespondDecorator",
"(",
"logger",
"loggo",
".",
"Logger",
")",
"autorest",
".",
"RespondDecorator",
"{",
"return",
"func",
"(",
"r",
"autorest",
".",
"Responder",
")",
"autorest",
".",
"Responder",
"{",
"return",
"autorest",
".",
"ResponderFunc",
"(",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"if",
"logger",
".",
"IsTraceEnabled",
"(",
")",
"{",
"dump",
",",
"err",
":=",
"httputil",
".",
"DumpResponse",
"(",
"resp",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"logger",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"resp",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"dump",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"r",
".",
"Respond",
"(",
"resp",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // RespondDecorator returns an autorest.RespondDecorator that
// logs responses at trace level. | [
"RespondDecorator",
"returns",
"an",
"autorest",
".",
"RespondDecorator",
"that",
"logs",
"responses",
"at",
"trace",
"level",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/azure/internal/tracing/tracing.go#L35-L50 |
153,568 | juju/juju | caas/kubernetes/provider/metadata.go | newLabelRequirements | func newLabelRequirements(rs ...requirementParams) k8slabels.Selector {
s := k8slabels.NewSelector()
for _, r := range rs {
l, err := k8slabels.NewRequirement(r.key, r.operator, r.strValues)
if err != nil {
// this panic only happens if the compiled code is wrong.
panic(errors.Annotatef(err, "incorrect requirement config %v", r))
}
s = s.Add(*l)
}
return s
} | go | func newLabelRequirements(rs ...requirementParams) k8slabels.Selector {
s := k8slabels.NewSelector()
for _, r := range rs {
l, err := k8slabels.NewRequirement(r.key, r.operator, r.strValues)
if err != nil {
// this panic only happens if the compiled code is wrong.
panic(errors.Annotatef(err, "incorrect requirement config %v", r))
}
s = s.Add(*l)
}
return s
} | [
"func",
"newLabelRequirements",
"(",
"rs",
"...",
"requirementParams",
")",
"k8slabels",
".",
"Selector",
"{",
"s",
":=",
"k8slabels",
".",
"NewSelector",
"(",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"rs",
"{",
"l",
",",
"err",
":=",
"k8slabels",
".",
"NewRequirement",
"(",
"r",
".",
"key",
",",
"r",
".",
"operator",
",",
"r",
".",
"strValues",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// this panic only happens if the compiled code is wrong.",
"panic",
"(",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"r",
")",
")",
"\n",
"}",
"\n",
"s",
"=",
"s",
".",
"Add",
"(",
"*",
"l",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // newLabelRequirements creates a list of k8s node label requirements.
// This should be called inside package init function to panic earlier
// if there is a invalid requirement definition. | [
"newLabelRequirements",
"creates",
"a",
"list",
"of",
"k8s",
"node",
"label",
"requirements",
".",
"This",
"should",
"be",
"called",
"inside",
"package",
"init",
"function",
"to",
"panic",
"earlier",
"if",
"there",
"is",
"a",
"invalid",
"requirement",
"definition",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/metadata.go#L25-L36 |
153,569 | juju/juju | caas/kubernetes/provider/metadata.go | CheckDefaultWorkloadStorage | func (k *kubernetesClient) CheckDefaultWorkloadStorage(cluster string, storageProvisioner *caas.StorageProvisioner) error {
preferredStorage, ok := jujuPreferredWorkloadStorage[cluster]
if !ok {
return errors.NotFoundf("cluster %q", cluster)
}
return storageClassMatches(preferredStorage, storageProvisioner)
} | go | func (k *kubernetesClient) CheckDefaultWorkloadStorage(cluster string, storageProvisioner *caas.StorageProvisioner) error {
preferredStorage, ok := jujuPreferredWorkloadStorage[cluster]
if !ok {
return errors.NotFoundf("cluster %q", cluster)
}
return storageClassMatches(preferredStorage, storageProvisioner)
} | [
"func",
"(",
"k",
"*",
"kubernetesClient",
")",
"CheckDefaultWorkloadStorage",
"(",
"cluster",
"string",
",",
"storageProvisioner",
"*",
"caas",
".",
"StorageProvisioner",
")",
"error",
"{",
"preferredStorage",
",",
"ok",
":=",
"jujuPreferredWorkloadStorage",
"[",
"cluster",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"cluster",
")",
"\n",
"}",
"\n",
"return",
"storageClassMatches",
"(",
"preferredStorage",
",",
"storageProvisioner",
")",
"\n",
"}"
] | // CheckDefaultWorkloadStorage implements ClusterMetadataChecker. | [
"CheckDefaultWorkloadStorage",
"implements",
"ClusterMetadataChecker",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/provider/metadata.go#L197-L203 |
153,570 | juju/juju | state/userpermission.go | userPermission | func (st *State) userPermission(objectGlobalKey, subjectGlobalKey string) (*userPermission, error) {
result := &userPermission{}
permissions, closer := st.db().GetCollection(permissionsC)
defer closer()
id := permissionID(objectGlobalKey, subjectGlobalKey)
err := permissions.FindId(id).One(&result.doc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("user permission for %q on %q", subjectGlobalKey, objectGlobalKey)
}
return result, nil
} | go | func (st *State) userPermission(objectGlobalKey, subjectGlobalKey string) (*userPermission, error) {
result := &userPermission{}
permissions, closer := st.db().GetCollection(permissionsC)
defer closer()
id := permissionID(objectGlobalKey, subjectGlobalKey)
err := permissions.FindId(id).One(&result.doc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("user permission for %q on %q", subjectGlobalKey, objectGlobalKey)
}
return result, nil
} | [
"func",
"(",
"st",
"*",
"State",
")",
"userPermission",
"(",
"objectGlobalKey",
",",
"subjectGlobalKey",
"string",
")",
"(",
"*",
"userPermission",
",",
"error",
")",
"{",
"result",
":=",
"&",
"userPermission",
"{",
"}",
"\n",
"permissions",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"permissionsC",
")",
"\n",
"defer",
"closer",
"(",
")",
"\n\n",
"id",
":=",
"permissionID",
"(",
"objectGlobalKey",
",",
"subjectGlobalKey",
")",
"\n",
"err",
":=",
"permissions",
".",
"FindId",
"(",
"id",
")",
".",
"One",
"(",
"&",
"result",
".",
"doc",
")",
"\n",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"errors",
".",
"NotFoundf",
"(",
"\"",
"\"",
",",
"subjectGlobalKey",
",",
"objectGlobalKey",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // userPermission returns a Permission for the given Subject and User. | [
"userPermission",
"returns",
"a",
"Permission",
"for",
"the",
"given",
"Subject",
"and",
"User",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/userpermission.go#L43-L54 |
153,571 | juju/juju | state/userpermission.go | usersPermissions | func (st *State) usersPermissions(objectGlobalKey string) ([]*userPermission, error) {
permissions, closer := st.db().GetCollection(permissionsC)
defer closer()
var matchingPermissions []permissionDoc
findExpr := fmt.Sprintf("^%s#.*$", objectGlobalKey)
if err := permissions.Find(
bson.D{{"_id", bson.D{{"$regex", findExpr}}}},
).All(&matchingPermissions); err != nil {
return nil, err
}
var result []*userPermission
for _, pDoc := range matchingPermissions {
result = append(result, &userPermission{doc: pDoc})
}
return result, nil
} | go | func (st *State) usersPermissions(objectGlobalKey string) ([]*userPermission, error) {
permissions, closer := st.db().GetCollection(permissionsC)
defer closer()
var matchingPermissions []permissionDoc
findExpr := fmt.Sprintf("^%s#.*$", objectGlobalKey)
if err := permissions.Find(
bson.D{{"_id", bson.D{{"$regex", findExpr}}}},
).All(&matchingPermissions); err != nil {
return nil, err
}
var result []*userPermission
for _, pDoc := range matchingPermissions {
result = append(result, &userPermission{doc: pDoc})
}
return result, nil
} | [
"func",
"(",
"st",
"*",
"State",
")",
"usersPermissions",
"(",
"objectGlobalKey",
"string",
")",
"(",
"[",
"]",
"*",
"userPermission",
",",
"error",
")",
"{",
"permissions",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"permissionsC",
")",
"\n",
"defer",
"closer",
"(",
")",
"\n\n",
"var",
"matchingPermissions",
"[",
"]",
"permissionDoc",
"\n",
"findExpr",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"objectGlobalKey",
")",
"\n",
"if",
"err",
":=",
"permissions",
".",
"Find",
"(",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"bson",
".",
"D",
"{",
"{",
"\"",
"\"",
",",
"findExpr",
"}",
"}",
"}",
"}",
",",
")",
".",
"All",
"(",
"&",
"matchingPermissions",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"result",
"[",
"]",
"*",
"userPermission",
"\n",
"for",
"_",
",",
"pDoc",
":=",
"range",
"matchingPermissions",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"&",
"userPermission",
"{",
"doc",
":",
"pDoc",
"}",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // usersPermissions returns all permissions for a given object. | [
"usersPermissions",
"returns",
"all",
"permissions",
"for",
"a",
"given",
"object",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/userpermission.go#L57-L73 |
153,572 | juju/juju | mongo/oplog.go | UnmarshalObject | func (d *OplogDoc) UnmarshalObject(out interface{}) error {
return d.unmarshal(d.Object, out)
} | go | func (d *OplogDoc) UnmarshalObject(out interface{}) error {
return d.unmarshal(d.Object, out)
} | [
"func",
"(",
"d",
"*",
"OplogDoc",
")",
"UnmarshalObject",
"(",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"d",
".",
"unmarshal",
"(",
"d",
".",
"Object",
",",
"out",
")",
"\n",
"}"
] | // UnmarshalObject unmarshals the Object field into out. The out
// argument should be a pointer or a suitable map. | [
"UnmarshalObject",
"unmarshals",
"the",
"Object",
"field",
"into",
"out",
".",
"The",
"out",
"argument",
"should",
"be",
"a",
"pointer",
"or",
"a",
"suitable",
"map",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/mongo/oplog.go#L34-L36 |
153,573 | juju/juju | mongo/oplog.go | UnmarshalUpdate | func (d *OplogDoc) UnmarshalUpdate(out interface{}) error {
return d.unmarshal(d.UpdateObject, out)
} | go | func (d *OplogDoc) UnmarshalUpdate(out interface{}) error {
return d.unmarshal(d.UpdateObject, out)
} | [
"func",
"(",
"d",
"*",
"OplogDoc",
")",
"UnmarshalUpdate",
"(",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"d",
".",
"unmarshal",
"(",
"d",
".",
"UpdateObject",
",",
"out",
")",
"\n",
"}"
] | // UnmarshalUpdate unmarshals the UpdateObject field into out. The out
// argument should be a pointer or a suitable map. | [
"UnmarshalUpdate",
"unmarshals",
"the",
"UpdateObject",
"field",
"into",
"out",
".",
"The",
"out",
"argument",
"should",
"be",
"a",
"pointer",
"or",
"a",
"suitable",
"map",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/mongo/oplog.go#L40-L42 |
153,574 | juju/juju | mongo/oplog.go | Stop | func (t *OplogTailer) Stop() error {
t.tomb.Kill(nil)
return t.tomb.Wait()
} | go | func (t *OplogTailer) Stop() error {
t.tomb.Kill(nil)
return t.tomb.Wait()
} | [
"func",
"(",
"t",
"*",
"OplogTailer",
")",
"Stop",
"(",
")",
"error",
"{",
"t",
".",
"tomb",
".",
"Kill",
"(",
"nil",
")",
"\n",
"return",
"t",
".",
"tomb",
".",
"Wait",
"(",
")",
"\n",
"}"
] | // Stop shuts down the OplogTailer. It will block until shutdown is
// complete. | [
"Stop",
"shuts",
"down",
"the",
"OplogTailer",
".",
"It",
"will",
"block",
"until",
"shutdown",
"is",
"complete",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/mongo/oplog.go#L201-L204 |
153,575 | juju/juju | worker/metrics/sender/sender.go | Do | func (s *sender) Do(stop <-chan struct{}) (err error) {
defer func() {
// See bug https://pad/lv/1733469
// If this function which is run by a PeriodicWorker
// exits with an error, we need to call stop() to
// ensure the sender socket is closed.
if err != nil {
s.stop()
}
}()
reader, err := s.factory.Reader()
if err != nil {
return errors.Trace(err)
}
defer reader.Close()
err = s.sendMetrics(reader)
if spool.IsMetricsDataError(err) {
logger.Debugf("cannot send metrics: %v", err)
return nil
}
return err
} | go | func (s *sender) Do(stop <-chan struct{}) (err error) {
defer func() {
// See bug https://pad/lv/1733469
// If this function which is run by a PeriodicWorker
// exits with an error, we need to call stop() to
// ensure the sender socket is closed.
if err != nil {
s.stop()
}
}()
reader, err := s.factory.Reader()
if err != nil {
return errors.Trace(err)
}
defer reader.Close()
err = s.sendMetrics(reader)
if spool.IsMetricsDataError(err) {
logger.Debugf("cannot send metrics: %v", err)
return nil
}
return err
} | [
"func",
"(",
"s",
"*",
"sender",
")",
"Do",
"(",
"stop",
"<-",
"chan",
"struct",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"// See bug https://pad/lv/1733469",
"// If this function which is run by a PeriodicWorker",
"// exits with an error, we need to call stop() to",
"// ensure the sender socket is closed.",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"stop",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"reader",
",",
"err",
":=",
"s",
".",
"factory",
".",
"Reader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"reader",
".",
"Close",
"(",
")",
"\n",
"err",
"=",
"s",
".",
"sendMetrics",
"(",
"reader",
")",
"\n",
"if",
"spool",
".",
"IsMetricsDataError",
"(",
"err",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Do sends metrics from the metric spool to the
// controller via an api call. | [
"Do",
"sends",
"metrics",
"from",
"the",
"metric",
"spool",
"to",
"the",
"controller",
"via",
"an",
"api",
"call",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/sender/sender.go#L38-L60 |
153,576 | juju/juju | worker/metrics/sender/sender.go | Handle | func (s *sender) Handle(c net.Conn, _ <-chan struct{}) (err error) {
defer func() {
if err != nil {
fmt.Fprintf(c, "%v\n", err)
} else {
fmt.Fprintf(c, "ok\n")
}
c.Close()
}()
// TODO(fwereade): 2016-03-17 lp:1558657
if err := c.SetDeadline(time.Now().Add(spool.DefaultTimeout)); err != nil {
return errors.Annotate(err, "failed to set the deadline")
}
reader, err := s.factory.Reader()
if err != nil {
return errors.Trace(err)
}
defer reader.Close()
return s.sendMetrics(reader)
} | go | func (s *sender) Handle(c net.Conn, _ <-chan struct{}) (err error) {
defer func() {
if err != nil {
fmt.Fprintf(c, "%v\n", err)
} else {
fmt.Fprintf(c, "ok\n")
}
c.Close()
}()
// TODO(fwereade): 2016-03-17 lp:1558657
if err := c.SetDeadline(time.Now().Add(spool.DefaultTimeout)); err != nil {
return errors.Annotate(err, "failed to set the deadline")
}
reader, err := s.factory.Reader()
if err != nil {
return errors.Trace(err)
}
defer reader.Close()
return s.sendMetrics(reader)
} | [
"func",
"(",
"s",
"*",
"sender",
")",
"Handle",
"(",
"c",
"net",
".",
"Conn",
",",
"_",
"<-",
"chan",
"struct",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"c",
",",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Fprintf",
"(",
"c",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"\n",
"c",
".",
"Close",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"// TODO(fwereade): 2016-03-17 lp:1558657",
"if",
"err",
":=",
"c",
".",
"SetDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"spool",
".",
"DefaultTimeout",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"reader",
",",
"err",
":=",
"s",
".",
"factory",
".",
"Reader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"reader",
".",
"Close",
"(",
")",
"\n",
"return",
"s",
".",
"sendMetrics",
"(",
"reader",
")",
"\n",
"}"
] | // Handle sends metrics from the spool directory to the
// controller. | [
"Handle",
"sends",
"metrics",
"from",
"the",
"spool",
"directory",
"to",
"the",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/metrics/sender/sender.go#L93-L112 |
153,577 | juju/juju | apiserver/common/modeluser.go | ModelUserInfo | func ModelUserInfo(user permission.UserAccess, st modelConnectionAbleBackend) (params.ModelUserInfo, error) {
access, err := StateToParamsUserAccessPermission(user.Access)
if err != nil {
return params.ModelUserInfo{}, errors.Trace(err)
}
userLastConn, err := st.LastModelConnection(user.UserTag)
if err != nil && !state.IsNeverConnectedError(err) {
return params.ModelUserInfo{}, errors.Trace(err)
}
var lastConn *time.Time
if err == nil {
lastConn = &userLastConn
}
userInfo := params.ModelUserInfo{
UserName: user.UserName,
DisplayName: user.DisplayName,
LastConnection: lastConn,
Access: access,
}
return userInfo, nil
} | go | func ModelUserInfo(user permission.UserAccess, st modelConnectionAbleBackend) (params.ModelUserInfo, error) {
access, err := StateToParamsUserAccessPermission(user.Access)
if err != nil {
return params.ModelUserInfo{}, errors.Trace(err)
}
userLastConn, err := st.LastModelConnection(user.UserTag)
if err != nil && !state.IsNeverConnectedError(err) {
return params.ModelUserInfo{}, errors.Trace(err)
}
var lastConn *time.Time
if err == nil {
lastConn = &userLastConn
}
userInfo := params.ModelUserInfo{
UserName: user.UserName,
DisplayName: user.DisplayName,
LastConnection: lastConn,
Access: access,
}
return userInfo, nil
} | [
"func",
"ModelUserInfo",
"(",
"user",
"permission",
".",
"UserAccess",
",",
"st",
"modelConnectionAbleBackend",
")",
"(",
"params",
".",
"ModelUserInfo",
",",
"error",
")",
"{",
"access",
",",
"err",
":=",
"StateToParamsUserAccessPermission",
"(",
"user",
".",
"Access",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"params",
".",
"ModelUserInfo",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"userLastConn",
",",
"err",
":=",
"st",
".",
"LastModelConnection",
"(",
"user",
".",
"UserTag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"state",
".",
"IsNeverConnectedError",
"(",
"err",
")",
"{",
"return",
"params",
".",
"ModelUserInfo",
"{",
"}",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"lastConn",
"*",
"time",
".",
"Time",
"\n",
"if",
"err",
"==",
"nil",
"{",
"lastConn",
"=",
"&",
"userLastConn",
"\n",
"}",
"\n\n",
"userInfo",
":=",
"params",
".",
"ModelUserInfo",
"{",
"UserName",
":",
"user",
".",
"UserName",
",",
"DisplayName",
":",
"user",
".",
"DisplayName",
",",
"LastConnection",
":",
"lastConn",
",",
"Access",
":",
"access",
",",
"}",
"\n",
"return",
"userInfo",
",",
"nil",
"\n",
"}"
] | // ModelUserInfo converts permission.UserAccess to params.ModelUserInfo. | [
"ModelUserInfo",
"converts",
"permission",
".",
"UserAccess",
"to",
"params",
".",
"ModelUserInfo",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/modeluser.go#L22-L44 |
153,578 | juju/juju | apiserver/common/modeluser.go | StateToParamsUserAccessPermission | func StateToParamsUserAccessPermission(descriptionAccess permission.Access) (params.UserAccessPermission, error) {
switch descriptionAccess {
case permission.ReadAccess:
return params.ModelReadAccess, nil
case permission.WriteAccess:
return params.ModelWriteAccess, nil
case permission.AdminAccess:
return params.ModelAdminAccess, nil
}
return "", errors.NotValidf("model access permission %q", descriptionAccess)
} | go | func StateToParamsUserAccessPermission(descriptionAccess permission.Access) (params.UserAccessPermission, error) {
switch descriptionAccess {
case permission.ReadAccess:
return params.ModelReadAccess, nil
case permission.WriteAccess:
return params.ModelWriteAccess, nil
case permission.AdminAccess:
return params.ModelAdminAccess, nil
}
return "", errors.NotValidf("model access permission %q", descriptionAccess)
} | [
"func",
"StateToParamsUserAccessPermission",
"(",
"descriptionAccess",
"permission",
".",
"Access",
")",
"(",
"params",
".",
"UserAccessPermission",
",",
"error",
")",
"{",
"switch",
"descriptionAccess",
"{",
"case",
"permission",
".",
"ReadAccess",
":",
"return",
"params",
".",
"ModelReadAccess",
",",
"nil",
"\n",
"case",
"permission",
".",
"WriteAccess",
":",
"return",
"params",
".",
"ModelWriteAccess",
",",
"nil",
"\n",
"case",
"permission",
".",
"AdminAccess",
":",
"return",
"params",
".",
"ModelAdminAccess",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
",",
"descriptionAccess",
")",
"\n\n",
"}"
] | // StateToParamsUserAccessPermission converts permission.Access to params.AccessPermission. | [
"StateToParamsUserAccessPermission",
"converts",
"permission",
".",
"Access",
"to",
"params",
".",
"AccessPermission",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/common/modeluser.go#L47-L59 |
153,579 | juju/juju | worker/upgradeseries/service.go | DiscoverService | func (s *serviceAccess) DiscoverService(name string) (AgentService, error) {
return service.DiscoverService(name, common.Conf{})
} | go | func (s *serviceAccess) DiscoverService(name string) (AgentService, error) {
return service.DiscoverService(name, common.Conf{})
} | [
"func",
"(",
"s",
"*",
"serviceAccess",
")",
"DiscoverService",
"(",
"name",
"string",
")",
"(",
"AgentService",
",",
"error",
")",
"{",
"return",
"service",
".",
"DiscoverService",
"(",
"name",
",",
"common",
".",
"Conf",
"{",
"}",
")",
"\n",
"}"
] | // DiscoverService returns the interface for a service running on a the machine. | [
"DiscoverService",
"returns",
"the",
"interface",
"for",
"a",
"service",
"running",
"on",
"a",
"the",
"machine",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/upgradeseries/service.go#L42-L44 |
153,580 | juju/juju | cmd/juju/caas/remove.go | NewRemoveCAASCommand | func NewRemoveCAASCommand(cloudMetadataStore CloudMetadataStore) cmd.Command {
store := jujuclient.NewFileClientStore()
cmd := &RemoveCAASCommand{
OptionalControllerCommand: modelcmd.OptionalControllerCommand{Store: store},
cloudMetadataStore: cloudMetadataStore,
store: store,
}
cmd.apiFunc = func() (RemoveCloudAPI, error) {
root, err := cmd.NewAPIRoot(cmd.store, cmd.controllerName, "")
if err != nil {
return nil, errors.Trace(err)
}
return cloudapi.NewClient(root), nil
}
return modelcmd.WrapBase(cmd)
} | go | func NewRemoveCAASCommand(cloudMetadataStore CloudMetadataStore) cmd.Command {
store := jujuclient.NewFileClientStore()
cmd := &RemoveCAASCommand{
OptionalControllerCommand: modelcmd.OptionalControllerCommand{Store: store},
cloudMetadataStore: cloudMetadataStore,
store: store,
}
cmd.apiFunc = func() (RemoveCloudAPI, error) {
root, err := cmd.NewAPIRoot(cmd.store, cmd.controllerName, "")
if err != nil {
return nil, errors.Trace(err)
}
return cloudapi.NewClient(root), nil
}
return modelcmd.WrapBase(cmd)
} | [
"func",
"NewRemoveCAASCommand",
"(",
"cloudMetadataStore",
"CloudMetadataStore",
")",
"cmd",
".",
"Command",
"{",
"store",
":=",
"jujuclient",
".",
"NewFileClientStore",
"(",
")",
"\n",
"cmd",
":=",
"&",
"RemoveCAASCommand",
"{",
"OptionalControllerCommand",
":",
"modelcmd",
".",
"OptionalControllerCommand",
"{",
"Store",
":",
"store",
"}",
",",
"cloudMetadataStore",
":",
"cloudMetadataStore",
",",
"store",
":",
"store",
",",
"}",
"\n",
"cmd",
".",
"apiFunc",
"=",
"func",
"(",
")",
"(",
"RemoveCloudAPI",
",",
"error",
")",
"{",
"root",
",",
"err",
":=",
"cmd",
".",
"NewAPIRoot",
"(",
"cmd",
".",
"store",
",",
"cmd",
".",
"controllerName",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cloudapi",
".",
"NewClient",
"(",
"root",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"modelcmd",
".",
"WrapBase",
"(",
"cmd",
")",
"\n",
"}"
] | // NewRemoveCAASCommand returns a command to add caas information. | [
"NewRemoveCAASCommand",
"returns",
"a",
"command",
"to",
"add",
"caas",
"information",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/caas/remove.go#L57-L72 |
153,581 | juju/juju | apiserver/admin.go | Admin | func (a *admin) Admin(id string) (*admin, error) {
if id != "" {
// Safeguard id for possible future use.
return nil, common.ErrBadId
}
return a, nil
} | go | func (a *admin) Admin(id string) (*admin, error) {
if id != "" {
// Safeguard id for possible future use.
return nil, common.ErrBadId
}
return a, nil
} | [
"func",
"(",
"a",
"*",
"admin",
")",
"Admin",
"(",
"id",
"string",
")",
"(",
"*",
"admin",
",",
"error",
")",
"{",
"if",
"id",
"!=",
"\"",
"\"",
"{",
"// Safeguard id for possible future use.",
"return",
"nil",
",",
"common",
".",
"ErrBadId",
"\n",
"}",
"\n",
"return",
"a",
",",
"nil",
"\n",
"}"
] | // Admin returns an object that provides API access to methods that can be
// called even when not authenticated. | [
"Admin",
"returns",
"an",
"object",
"that",
"provides",
"API",
"access",
"to",
"methods",
"that",
"can",
"be",
"called",
"even",
"when",
"not",
"authenticated",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/admin.go#L55-L61 |
153,582 | juju/juju | apiserver/admin.go | Login | func (a *admin) Login(req params.LoginRequest) (params.LoginResult, error) {
return a.login(req, 3)
} | go | func (a *admin) Login(req params.LoginRequest) (params.LoginResult, error) {
return a.login(req, 3)
} | [
"func",
"(",
"a",
"*",
"admin",
")",
"Login",
"(",
"req",
"params",
".",
"LoginRequest",
")",
"(",
"params",
".",
"LoginResult",
",",
"error",
")",
"{",
"return",
"a",
".",
"login",
"(",
"req",
",",
"3",
")",
"\n",
"}"
] | // Login logs in with the provided credentials. All subsequent requests on the
// connection will act as the authenticated user. | [
"Login",
"logs",
"in",
"with",
"the",
"provided",
"credentials",
".",
"All",
"subsequent",
"requests",
"on",
"the",
"connection",
"will",
"act",
"as",
"the",
"authenticated",
"user",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/admin.go#L65-L67 |
153,583 | juju/juju | apiserver/admin.go | RedirectInfo | func (a *admin) RedirectInfo() (params.RedirectInfoResult, error) {
return params.RedirectInfoResult{}, fmt.Errorf("not redirected")
} | go | func (a *admin) RedirectInfo() (params.RedirectInfoResult, error) {
return params.RedirectInfoResult{}, fmt.Errorf("not redirected")
} | [
"func",
"(",
"a",
"*",
"admin",
")",
"RedirectInfo",
"(",
")",
"(",
"params",
".",
"RedirectInfoResult",
",",
"error",
")",
"{",
"return",
"params",
".",
"RedirectInfoResult",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // RedirectInfo returns redirected host information for the model.
// In Juju it always returns an error because the Juju controller
// does not multiplex controllers. | [
"RedirectInfo",
"returns",
"redirected",
"host",
"information",
"for",
"the",
"model",
".",
"In",
"Juju",
"it",
"always",
"returns",
"an",
"error",
"because",
"the",
"Juju",
"controller",
"does",
"not",
"multiplex",
"controllers",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/admin.go#L72-L74 |
153,584 | juju/juju | apiserver/admin.go | Start | func (shim presenceShim) Start() (presence.Pinger, error) {
pinger, err := shim.agent.SetAgentPresence()
if err != nil {
return nil, errors.Trace(err)
}
return pinger, nil
} | go | func (shim presenceShim) Start() (presence.Pinger, error) {
pinger, err := shim.agent.SetAgentPresence()
if err != nil {
return nil, errors.Trace(err)
}
return pinger, nil
} | [
"func",
"(",
"shim",
"presenceShim",
")",
"Start",
"(",
")",
"(",
"presence",
".",
"Pinger",
",",
"error",
")",
"{",
"pinger",
",",
"err",
":=",
"shim",
".",
"agent",
".",
"SetAgentPresence",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"pinger",
",",
"nil",
"\n",
"}"
] | // Start starts and returns a running presence.Pinger. The caller is
// responsible for stopping it when no longer required, and for handling
// any errors returned from Wait. | [
"Start",
"starts",
"and",
"returns",
"a",
"running",
"presence",
".",
"Pinger",
".",
"The",
"caller",
"is",
"responsible",
"for",
"stopping",
"it",
"when",
"no",
"longer",
"required",
"and",
"for",
"handling",
"any",
"errors",
"returned",
"from",
"Wait",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/admin.go#L520-L526 |
153,585 | juju/juju | cmd/juju/model/configcommand.go | parseSetKeys | func (c *configCommand) parseSetKeys(args []string) error {
for _, arg := range args {
if err := c.setOptions.Set(arg); err != nil {
return errors.Trace(err)
}
}
c.action = c.setConfig
return nil
} | go | func (c *configCommand) parseSetKeys(args []string) error {
for _, arg := range args {
if err := c.setOptions.Set(arg); err != nil {
return errors.Trace(err)
}
}
c.action = c.setConfig
return nil
} | [
"func",
"(",
"c",
"*",
"configCommand",
")",
"parseSetKeys",
"(",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"for",
"_",
",",
"arg",
":=",
"range",
"args",
"{",
"if",
"err",
":=",
"c",
".",
"setOptions",
".",
"Set",
"(",
"arg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"c",
".",
"action",
"=",
"c",
".",
"setConfig",
"\n",
"return",
"nil",
"\n",
"}"
] | // parseSetKeys iterates over the args and make sure that the key=value pairs
// are valid. | [
"parseSetKeys",
"iterates",
"over",
"the",
"args",
"and",
"make",
"sure",
"that",
"the",
"key",
"=",
"value",
"pairs",
"are",
"valid",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/model/configcommand.go#L188-L196 |
153,586 | juju/juju | cmd/juju/model/configcommand.go | getAPI | func (c *configCommand) getAPI() (configCommandAPI, error) {
if c.api != nil {
return c.api, nil
}
api, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Annotate(err, "opening API connection")
}
client := modelconfig.NewClient(api)
return client, nil
} | go | func (c *configCommand) getAPI() (configCommandAPI, error) {
if c.api != nil {
return c.api, nil
}
api, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Annotate(err, "opening API connection")
}
client := modelconfig.NewClient(api)
return client, nil
} | [
"func",
"(",
"c",
"*",
"configCommand",
")",
"getAPI",
"(",
")",
"(",
"configCommandAPI",
",",
"error",
")",
"{",
"if",
"c",
".",
"api",
"!=",
"nil",
"{",
"return",
"c",
".",
"api",
",",
"nil",
"\n",
"}",
"\n",
"api",
",",
"err",
":=",
"c",
".",
"NewAPIRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Annotate",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"client",
":=",
"modelconfig",
".",
"NewClient",
"(",
"api",
")",
"\n",
"return",
"client",
",",
"nil",
"\n",
"}"
] | // getAPI returns the API. This allows passing in a test configCommandAPI
// implementation. | [
"getAPI",
"returns",
"the",
"API",
".",
"This",
"allows",
"passing",
"in",
"a",
"test",
"configCommandAPI",
"implementation",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/model/configcommand.go#L226-L236 |
153,587 | juju/juju | cmd/juju/model/configcommand.go | resetConfig | func (c *configCommand) resetConfig(client configCommandAPI, ctx *cmd.Context) error {
// ctx unused in this method
if err := c.verifyKnownKeys(client, c.resetKeys); err != nil {
return errors.Trace(err)
}
return block.ProcessBlockedError(client.ModelUnset(c.resetKeys...), block.BlockChange)
} | go | func (c *configCommand) resetConfig(client configCommandAPI, ctx *cmd.Context) error {
// ctx unused in this method
if err := c.verifyKnownKeys(client, c.resetKeys); err != nil {
return errors.Trace(err)
}
return block.ProcessBlockedError(client.ModelUnset(c.resetKeys...), block.BlockChange)
} | [
"func",
"(",
"c",
"*",
"configCommand",
")",
"resetConfig",
"(",
"client",
"configCommandAPI",
",",
"ctx",
"*",
"cmd",
".",
"Context",
")",
"error",
"{",
"// ctx unused in this method",
"if",
"err",
":=",
"c",
".",
"verifyKnownKeys",
"(",
"client",
",",
"c",
".",
"resetKeys",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"block",
".",
"ProcessBlockedError",
"(",
"client",
".",
"ModelUnset",
"(",
"c",
".",
"resetKeys",
"...",
")",
",",
"block",
".",
"BlockChange",
")",
"\n",
"}"
] | // reset unsets the keys provided to the command. | [
"reset",
"unsets",
"the",
"keys",
"provided",
"to",
"the",
"command",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/model/configcommand.go#L263-L270 |
153,588 | juju/juju | cmd/juju/model/configcommand.go | getConfig | func (c *configCommand) getConfig(client configCommandAPI, ctx *cmd.Context) error {
if len(c.keys) == 1 && certBytes != nil {
ctx.Stdout.Write(certBytes)
return nil
}
attrs, err := client.ModelGetWithMetadata()
if err != nil {
return err
}
for attrName := range attrs {
// We don't want model attributes included, these are available
// via show-model.
if c.isModelAttribute(attrName) {
delete(attrs, attrName)
}
}
if len(c.keys) == 1 {
key := c.keys[0]
if value, found := attrs[key]; found {
if c.out.Name() == "tabular" {
// The user has not specified that they want
// YAML or JSON formatting, so we print out
// the value unadorned.
return c.out.WriteFormatter(
ctx,
cmd.FormatSmart,
value.Value,
)
}
attrs = config.ConfigValues{
key: config.ConfigValue{
Source: value.Source,
Value: value.Value,
},
}
} else {
return errors.Errorf("key %q not found in %q model.", key, attrs["name"])
}
} else {
// In tabular format, don't print "cloudinit-userdata" it can be very long,
// instead give instructions on how to print specifically.
if value, ok := attrs[config.CloudInitUserDataKey]; ok && c.out.Name() == "tabular" {
if value.Value.(string) != "" {
value.Value = "<value set, see juju model-config cloudinit-userdata>"
attrs["cloudinit-userdata"] = value
}
}
}
return c.out.Write(ctx, attrs)
} | go | func (c *configCommand) getConfig(client configCommandAPI, ctx *cmd.Context) error {
if len(c.keys) == 1 && certBytes != nil {
ctx.Stdout.Write(certBytes)
return nil
}
attrs, err := client.ModelGetWithMetadata()
if err != nil {
return err
}
for attrName := range attrs {
// We don't want model attributes included, these are available
// via show-model.
if c.isModelAttribute(attrName) {
delete(attrs, attrName)
}
}
if len(c.keys) == 1 {
key := c.keys[0]
if value, found := attrs[key]; found {
if c.out.Name() == "tabular" {
// The user has not specified that they want
// YAML or JSON formatting, so we print out
// the value unadorned.
return c.out.WriteFormatter(
ctx,
cmd.FormatSmart,
value.Value,
)
}
attrs = config.ConfigValues{
key: config.ConfigValue{
Source: value.Source,
Value: value.Value,
},
}
} else {
return errors.Errorf("key %q not found in %q model.", key, attrs["name"])
}
} else {
// In tabular format, don't print "cloudinit-userdata" it can be very long,
// instead give instructions on how to print specifically.
if value, ok := attrs[config.CloudInitUserDataKey]; ok && c.out.Name() == "tabular" {
if value.Value.(string) != "" {
value.Value = "<value set, see juju model-config cloudinit-userdata>"
attrs["cloudinit-userdata"] = value
}
}
}
return c.out.Write(ctx, attrs)
} | [
"func",
"(",
"c",
"*",
"configCommand",
")",
"getConfig",
"(",
"client",
"configCommandAPI",
",",
"ctx",
"*",
"cmd",
".",
"Context",
")",
"error",
"{",
"if",
"len",
"(",
"c",
".",
"keys",
")",
"==",
"1",
"&&",
"certBytes",
"!=",
"nil",
"{",
"ctx",
".",
"Stdout",
".",
"Write",
"(",
"certBytes",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"attrs",
",",
"err",
":=",
"client",
".",
"ModelGetWithMetadata",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"attrName",
":=",
"range",
"attrs",
"{",
"// We don't want model attributes included, these are available",
"// via show-model.",
"if",
"c",
".",
"isModelAttribute",
"(",
"attrName",
")",
"{",
"delete",
"(",
"attrs",
",",
"attrName",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"c",
".",
"keys",
")",
"==",
"1",
"{",
"key",
":=",
"c",
".",
"keys",
"[",
"0",
"]",
"\n",
"if",
"value",
",",
"found",
":=",
"attrs",
"[",
"key",
"]",
";",
"found",
"{",
"if",
"c",
".",
"out",
".",
"Name",
"(",
")",
"==",
"\"",
"\"",
"{",
"// The user has not specified that they want",
"// YAML or JSON formatting, so we print out",
"// the value unadorned.",
"return",
"c",
".",
"out",
".",
"WriteFormatter",
"(",
"ctx",
",",
"cmd",
".",
"FormatSmart",
",",
"value",
".",
"Value",
",",
")",
"\n",
"}",
"\n",
"attrs",
"=",
"config",
".",
"ConfigValues",
"{",
"key",
":",
"config",
".",
"ConfigValue",
"{",
"Source",
":",
"value",
".",
"Source",
",",
"Value",
":",
"value",
".",
"Value",
",",
"}",
",",
"}",
"\n",
"}",
"else",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"key",
",",
"attrs",
"[",
"\"",
"\"",
"]",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// In tabular format, don't print \"cloudinit-userdata\" it can be very long,",
"// instead give instructions on how to print specifically.",
"if",
"value",
",",
"ok",
":=",
"attrs",
"[",
"config",
".",
"CloudInitUserDataKey",
"]",
";",
"ok",
"&&",
"c",
".",
"out",
".",
"Name",
"(",
")",
"==",
"\"",
"\"",
"{",
"if",
"value",
".",
"Value",
".",
"(",
"string",
")",
"!=",
"\"",
"\"",
"{",
"value",
".",
"Value",
"=",
"\"",
"\"",
"\n",
"attrs",
"[",
"\"",
"\"",
"]",
"=",
"value",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"out",
".",
"Write",
"(",
"ctx",
",",
"attrs",
")",
"\n",
"}"
] | // get writes the value of a single key or the full output for the model to the cmd.Context. | [
"get",
"writes",
"the",
"value",
"of",
"a",
"single",
"key",
"or",
"the",
"full",
"output",
"for",
"the",
"model",
"to",
"the",
"cmd",
".",
"Context",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/model/configcommand.go#L302-L354 |
153,589 | juju/juju | cmd/juju/model/configcommand.go | isModelAttribute | func (c *configCommand) isModelAttribute(attr string) bool {
switch attr {
case config.NameKey, config.TypeKey, config.UUIDKey:
return true
}
return false
} | go | func (c *configCommand) isModelAttribute(attr string) bool {
switch attr {
case config.NameKey, config.TypeKey, config.UUIDKey:
return true
}
return false
} | [
"func",
"(",
"c",
"*",
"configCommand",
")",
"isModelAttribute",
"(",
"attr",
"string",
")",
"bool",
"{",
"switch",
"attr",
"{",
"case",
"config",
".",
"NameKey",
",",
"config",
".",
"TypeKey",
",",
"config",
".",
"UUIDKey",
":",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // isModelAttribute returns if the supplied attribute is a valid model
// attribute. | [
"isModelAttribute",
"returns",
"if",
"the",
"supplied",
"attribute",
"is",
"a",
"valid",
"model",
"attribute",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/model/configcommand.go#L378-L384 |
153,590 | juju/juju | cmd/juju/model/configcommand.go | formatConfigTabular | func formatConfigTabular(writer io.Writer, value interface{}) error {
configValues, ok := value.(config.ConfigValues)
if !ok {
return errors.Errorf("expected value of type %T, got %T", configValues, value)
}
tw := output.TabWriter(writer)
w := output.Wrapper{tw}
var valueNames []string
for name := range configValues {
valueNames = append(valueNames, name)
}
sort.Strings(valueNames)
w.Println("Attribute", "From", "Value")
for _, name := range valueNames {
info := configValues[name]
out := &bytes.Buffer{}
err := cmd.FormatYaml(out, info.Value)
if err != nil {
return errors.Annotatef(err, "formatting value for %q", name)
}
// Some attribute values have a newline appended
// which makes the output messy.
valString := strings.TrimSuffix(out.String(), "\n")
w.Println(name, info.Source, valString)
}
tw.Flush()
return nil
} | go | func formatConfigTabular(writer io.Writer, value interface{}) error {
configValues, ok := value.(config.ConfigValues)
if !ok {
return errors.Errorf("expected value of type %T, got %T", configValues, value)
}
tw := output.TabWriter(writer)
w := output.Wrapper{tw}
var valueNames []string
for name := range configValues {
valueNames = append(valueNames, name)
}
sort.Strings(valueNames)
w.Println("Attribute", "From", "Value")
for _, name := range valueNames {
info := configValues[name]
out := &bytes.Buffer{}
err := cmd.FormatYaml(out, info.Value)
if err != nil {
return errors.Annotatef(err, "formatting value for %q", name)
}
// Some attribute values have a newline appended
// which makes the output messy.
valString := strings.TrimSuffix(out.String(), "\n")
w.Println(name, info.Source, valString)
}
tw.Flush()
return nil
} | [
"func",
"formatConfigTabular",
"(",
"writer",
"io",
".",
"Writer",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"configValues",
",",
"ok",
":=",
"value",
".",
"(",
"config",
".",
"ConfigValues",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"configValues",
",",
"value",
")",
"\n",
"}",
"\n\n",
"tw",
":=",
"output",
".",
"TabWriter",
"(",
"writer",
")",
"\n",
"w",
":=",
"output",
".",
"Wrapper",
"{",
"tw",
"}",
"\n\n",
"var",
"valueNames",
"[",
"]",
"string",
"\n",
"for",
"name",
":=",
"range",
"configValues",
"{",
"valueNames",
"=",
"append",
"(",
"valueNames",
",",
"name",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"valueNames",
")",
"\n",
"w",
".",
"Println",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"for",
"_",
",",
"name",
":=",
"range",
"valueNames",
"{",
"info",
":=",
"configValues",
"[",
"name",
"]",
"\n",
"out",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"err",
":=",
"cmd",
".",
"FormatYaml",
"(",
"out",
",",
"info",
".",
"Value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"// Some attribute values have a newline appended",
"// which makes the output messy.",
"valString",
":=",
"strings",
".",
"TrimSuffix",
"(",
"out",
".",
"String",
"(",
")",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"w",
".",
"Println",
"(",
"name",
",",
"info",
".",
"Source",
",",
"valString",
")",
"\n",
"}",
"\n\n",
"tw",
".",
"Flush",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // formatConfigTabular writes a tabular summary of config information. | [
"formatConfigTabular",
"writes",
"a",
"tabular",
"summary",
"of",
"config",
"information",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/model/configcommand.go#L387-L418 |
153,591 | juju/juju | cmd/juju/model/configcommand.go | modelConfigDetails | func (c *configCommand) modelConfigDetails() (map[string]interface{}, error) {
defaultSchema, err := config.Schema(nil)
if err != nil {
return nil, err
}
specifics := make(map[string]interface{})
for key, attr := range defaultSchema {
if attr.Secret || c.isModelAttribute(key) ||
attr.Group != environschema.EnvironGroup {
continue
}
specifics[key] = common.PrintConfigSchema{
Description: attr.Description,
Type: fmt.Sprintf("%s", attr.Type),
}
}
return specifics, nil
} | go | func (c *configCommand) modelConfigDetails() (map[string]interface{}, error) {
defaultSchema, err := config.Schema(nil)
if err != nil {
return nil, err
}
specifics := make(map[string]interface{})
for key, attr := range defaultSchema {
if attr.Secret || c.isModelAttribute(key) ||
attr.Group != environschema.EnvironGroup {
continue
}
specifics[key] = common.PrintConfigSchema{
Description: attr.Description,
Type: fmt.Sprintf("%s", attr.Type),
}
}
return specifics, nil
} | [
"func",
"(",
"c",
"*",
"configCommand",
")",
"modelConfigDetails",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"defaultSchema",
",",
"err",
":=",
"config",
".",
"Schema",
"(",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"specifics",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"key",
",",
"attr",
":=",
"range",
"defaultSchema",
"{",
"if",
"attr",
".",
"Secret",
"||",
"c",
".",
"isModelAttribute",
"(",
"key",
")",
"||",
"attr",
".",
"Group",
"!=",
"environschema",
".",
"EnvironGroup",
"{",
"continue",
"\n",
"}",
"\n",
"specifics",
"[",
"key",
"]",
"=",
"common",
".",
"PrintConfigSchema",
"{",
"Description",
":",
"attr",
".",
"Description",
",",
"Type",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"attr",
".",
"Type",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"specifics",
",",
"nil",
"\n",
"}"
] | // modelConfigDetails gets ModelDetails when a model is not available
// to use. | [
"modelConfigDetails",
"gets",
"ModelDetails",
"when",
"a",
"model",
"is",
"not",
"available",
"to",
"use",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/model/configcommand.go#L422-L440 |
153,592 | juju/juju | cmd/juju/application/mocks/deploystepapi_mock.go | NewMockDeployStepAPI | func NewMockDeployStepAPI(ctrl *gomock.Controller) *MockDeployStepAPI {
mock := &MockDeployStepAPI{ctrl: ctrl}
mock.recorder = &MockDeployStepAPIMockRecorder{mock}
return mock
} | go | func NewMockDeployStepAPI(ctrl *gomock.Controller) *MockDeployStepAPI {
mock := &MockDeployStepAPI{ctrl: ctrl}
mock.recorder = &MockDeployStepAPIMockRecorder{mock}
return mock
} | [
"func",
"NewMockDeployStepAPI",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockDeployStepAPI",
"{",
"mock",
":=",
"&",
"MockDeployStepAPI",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockDeployStepAPIMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockDeployStepAPI creates a new mock instance | [
"NewMockDeployStepAPI",
"creates",
"a",
"new",
"mock",
"instance"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/application/mocks/deploystepapi_mock.go#L25-L29 |
153,593 | juju/juju | cmd/juju/application/mocks/deploystepapi_mock.go | IsMetered | func (m *MockDeployStepAPI) IsMetered(arg0 string) (bool, error) {
ret := m.ctrl.Call(m, "IsMetered", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockDeployStepAPI) IsMetered(arg0 string) (bool, error) {
ret := m.ctrl.Call(m, "IsMetered", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockDeployStepAPI",
")",
"IsMetered",
"(",
"arg0",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // IsMetered mocks base method | [
"IsMetered",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/application/mocks/deploystepapi_mock.go#L37-L42 |
153,594 | juju/juju | cmd/juju/application/mocks/deploystepapi_mock.go | SetMetricCredentials | func (m *MockDeployStepAPI) SetMetricCredentials(arg0 string, arg1 []byte) error {
ret := m.ctrl.Call(m, "SetMetricCredentials", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockDeployStepAPI) SetMetricCredentials(arg0 string, arg1 []byte) error {
ret := m.ctrl.Call(m, "SetMetricCredentials", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockDeployStepAPI",
")",
"SetMetricCredentials",
"(",
"arg0",
"string",
",",
"arg1",
"[",
"]",
"byte",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // SetMetricCredentials mocks base method | [
"SetMetricCredentials",
"mocks",
"base",
"method"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/application/mocks/deploystepapi_mock.go#L50-L54 |
153,595 | juju/juju | cmd/juju/application/mocks/deploystepapi_mock.go | SetMetricCredentials | func (mr *MockDeployStepAPIMockRecorder) SetMetricCredentials(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetricCredentials", reflect.TypeOf((*MockDeployStepAPI)(nil).SetMetricCredentials), arg0, arg1)
} | go | func (mr *MockDeployStepAPIMockRecorder) SetMetricCredentials(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetricCredentials", reflect.TypeOf((*MockDeployStepAPI)(nil).SetMetricCredentials), arg0, arg1)
} | [
"func",
"(",
"mr",
"*",
"MockDeployStepAPIMockRecorder",
")",
"SetMetricCredentials",
"(",
"arg0",
",",
"arg1",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockDeployStepAPI",
")",
"(",
"nil",
")",
".",
"SetMetricCredentials",
")",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // SetMetricCredentials indicates an expected call of SetMetricCredentials | [
"SetMetricCredentials",
"indicates",
"an",
"expected",
"call",
"of",
"SetMetricCredentials"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/application/mocks/deploystepapi_mock.go#L57-L59 |
153,596 | juju/juju | mongo/admin.go | SetAdminMongoPassword | func SetAdminMongoPassword(session *mgo.Session, user, password string) error {
admin := session.DB("admin")
if password != "" {
if err := admin.UpsertUser(&mgo.User{
Username: user,
Password: password,
Roles: []mgo.Role{mgo.RoleDBAdminAny, mgo.RoleUserAdminAny, mgo.RoleClusterAdmin, mgo.RoleReadWriteAny},
}); err != nil {
return fmt.Errorf("cannot set admin password: %v", err)
}
} else {
if err := admin.RemoveUser(user); err != nil && err != mgo.ErrNotFound {
return fmt.Errorf("cannot disable admin password: %v", err)
}
}
return nil
} | go | func SetAdminMongoPassword(session *mgo.Session, user, password string) error {
admin := session.DB("admin")
if password != "" {
if err := admin.UpsertUser(&mgo.User{
Username: user,
Password: password,
Roles: []mgo.Role{mgo.RoleDBAdminAny, mgo.RoleUserAdminAny, mgo.RoleClusterAdmin, mgo.RoleReadWriteAny},
}); err != nil {
return fmt.Errorf("cannot set admin password: %v", err)
}
} else {
if err := admin.RemoveUser(user); err != nil && err != mgo.ErrNotFound {
return fmt.Errorf("cannot disable admin password: %v", err)
}
}
return nil
} | [
"func",
"SetAdminMongoPassword",
"(",
"session",
"*",
"mgo",
".",
"Session",
",",
"user",
",",
"password",
"string",
")",
"error",
"{",
"admin",
":=",
"session",
".",
"DB",
"(",
"\"",
"\"",
")",
"\n",
"if",
"password",
"!=",
"\"",
"\"",
"{",
"if",
"err",
":=",
"admin",
".",
"UpsertUser",
"(",
"&",
"mgo",
".",
"User",
"{",
"Username",
":",
"user",
",",
"Password",
":",
"password",
",",
"Roles",
":",
"[",
"]",
"mgo",
".",
"Role",
"{",
"mgo",
".",
"RoleDBAdminAny",
",",
"mgo",
".",
"RoleUserAdminAny",
",",
"mgo",
".",
"RoleClusterAdmin",
",",
"mgo",
".",
"RoleReadWriteAny",
"}",
",",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"admin",
".",
"RemoveUser",
"(",
"user",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"mgo",
".",
"ErrNotFound",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetAdminMongoPassword sets the administrative password
// to access a mongo database. If the password is non-empty,
// all subsequent attempts to access the database must
// be authorized; otherwise no authorization is required. | [
"SetAdminMongoPassword",
"sets",
"the",
"administrative",
"password",
"to",
"access",
"a",
"mongo",
"database",
".",
"If",
"the",
"password",
"is",
"non",
"-",
"empty",
"all",
"subsequent",
"attempts",
"to",
"access",
"the",
"database",
"must",
"be",
"authorized",
";",
"otherwise",
"no",
"authorization",
"is",
"required",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/mongo/admin.go#L24-L40 |
153,597 | juju/juju | caas/kubernetes/clientconfig/types.go | NewClientConfigReader | func NewClientConfigReader(cloudType string) (ClientConfigFunc, error) {
switch cloudType {
case "kubernetes":
return NewK8sClientConfig, nil
default:
return nil, errors.Errorf("Cannot read local config: unsupported cloud type '%s'", cloudType)
}
} | go | func NewClientConfigReader(cloudType string) (ClientConfigFunc, error) {
switch cloudType {
case "kubernetes":
return NewK8sClientConfig, nil
default:
return nil, errors.Errorf("Cannot read local config: unsupported cloud type '%s'", cloudType)
}
} | [
"func",
"NewClientConfigReader",
"(",
"cloudType",
"string",
")",
"(",
"ClientConfigFunc",
",",
"error",
")",
"{",
"switch",
"cloudType",
"{",
"case",
"\"",
"\"",
":",
"return",
"NewK8sClientConfig",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cloudType",
")",
"\n",
"}",
"\n",
"}"
] | // NewClientConfigReader returns a function of type ClientConfigFunc to read the client config for a given cloud type. | [
"NewClientConfigReader",
"returns",
"a",
"function",
"of",
"type",
"ClientConfigFunc",
"to",
"read",
"the",
"client",
"config",
"for",
"a",
"given",
"cloud",
"type",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/caas/kubernetes/clientconfig/types.go#L53-L60 |
153,598 | juju/juju | agent/tools/toolsdir.go | SharedToolsDir | func SharedToolsDir(dataDir string, vers version.Binary) string {
return path.Join(dataDir, "tools", vers.String())
} | go | func SharedToolsDir(dataDir string, vers version.Binary) string {
return path.Join(dataDir, "tools", vers.String())
} | [
"func",
"SharedToolsDir",
"(",
"dataDir",
"string",
",",
"vers",
"version",
".",
"Binary",
")",
"string",
"{",
"return",
"path",
".",
"Join",
"(",
"dataDir",
",",
"\"",
"\"",
",",
"vers",
".",
"String",
"(",
")",
")",
"\n",
"}"
] | // SharedToolsDir returns the directory that is used to
// store binaries for the given version of the juju tools
// within the dataDir directory. | [
"SharedToolsDir",
"returns",
"the",
"directory",
"that",
"is",
"used",
"to",
"store",
"binaries",
"for",
"the",
"given",
"version",
"of",
"the",
"juju",
"tools",
"within",
"the",
"dataDir",
"directory",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/agent/tools/toolsdir.go#L35-L37 |
153,599 | juju/juju | agent/tools/toolsdir.go | UnpackTools | func UnpackTools(dataDir string, tools *coretools.Tools, r io.Reader) (err error) {
// Unpack the gzip file and compute the checksum.
sha256hash := sha256.New()
zr, err := gzip.NewReader(io.TeeReader(r, sha256hash))
if err != nil {
return err
}
defer zr.Close()
f, err := ioutil.TempFile(os.TempDir(), "tools-tar")
if err != nil {
return err
}
_, err = io.Copy(f, zr)
if err != nil {
return err
}
defer os.Remove(f.Name())
gzipSHA256 := fmt.Sprintf("%x", sha256hash.Sum(nil))
if tools.SHA256 != gzipSHA256 {
return fmt.Errorf("tarball sha256 mismatch, expected %s, got %s", tools.SHA256, gzipSHA256)
}
// Make a temporary directory in the tools directory,
// first ensuring that the tools directory exists.
toolsDir := path.Join(dataDir, "tools")
err = os.MkdirAll(toolsDir, dirPerm)
if err != nil {
return err
}
dir, err := ioutil.TempDir(toolsDir, "unpacking-")
if err != nil {
return err
}
defer removeAll(dir)
// Checksum matches, now reset the file and untar it.
_, err = f.Seek(0, 0)
if err != nil {
return err
}
tr := tar.NewReader(f)
for {
hdr, err := tr.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
if strings.ContainsAny(hdr.Name, "/\\") {
return fmt.Errorf("bad name %q in agent binary archive", hdr.Name)
}
if hdr.Typeflag != tar.TypeReg {
return fmt.Errorf("bad file type %c in file %q in agent binary archive", hdr.Typeflag, hdr.Name)
}
name := path.Join(dir, hdr.Name)
if err := writeFile(name, os.FileMode(hdr.Mode&0777), tr); err != nil {
return errors.Annotatef(err, "tar extract %q failed", name)
}
}
if err = WriteToolsMetadataData(dir, tools); err != nil {
return err
}
// The tempdir is created with 0700, so we need to make it more
// accessible for juju-run.
err = os.Chmod(dir, dirPerm)
if err != nil {
return err
}
err = os.Rename(dir, SharedToolsDir(dataDir, tools.Version))
// If we've failed to rename the directory, it may be because
// the directory already exists - if ReadTools succeeds, we
// assume all's ok.
if err != nil {
if _, err := ReadTools(dataDir, tools.Version); err == nil {
return nil
}
}
return err
} | go | func UnpackTools(dataDir string, tools *coretools.Tools, r io.Reader) (err error) {
// Unpack the gzip file and compute the checksum.
sha256hash := sha256.New()
zr, err := gzip.NewReader(io.TeeReader(r, sha256hash))
if err != nil {
return err
}
defer zr.Close()
f, err := ioutil.TempFile(os.TempDir(), "tools-tar")
if err != nil {
return err
}
_, err = io.Copy(f, zr)
if err != nil {
return err
}
defer os.Remove(f.Name())
gzipSHA256 := fmt.Sprintf("%x", sha256hash.Sum(nil))
if tools.SHA256 != gzipSHA256 {
return fmt.Errorf("tarball sha256 mismatch, expected %s, got %s", tools.SHA256, gzipSHA256)
}
// Make a temporary directory in the tools directory,
// first ensuring that the tools directory exists.
toolsDir := path.Join(dataDir, "tools")
err = os.MkdirAll(toolsDir, dirPerm)
if err != nil {
return err
}
dir, err := ioutil.TempDir(toolsDir, "unpacking-")
if err != nil {
return err
}
defer removeAll(dir)
// Checksum matches, now reset the file and untar it.
_, err = f.Seek(0, 0)
if err != nil {
return err
}
tr := tar.NewReader(f)
for {
hdr, err := tr.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
if strings.ContainsAny(hdr.Name, "/\\") {
return fmt.Errorf("bad name %q in agent binary archive", hdr.Name)
}
if hdr.Typeflag != tar.TypeReg {
return fmt.Errorf("bad file type %c in file %q in agent binary archive", hdr.Typeflag, hdr.Name)
}
name := path.Join(dir, hdr.Name)
if err := writeFile(name, os.FileMode(hdr.Mode&0777), tr); err != nil {
return errors.Annotatef(err, "tar extract %q failed", name)
}
}
if err = WriteToolsMetadataData(dir, tools); err != nil {
return err
}
// The tempdir is created with 0700, so we need to make it more
// accessible for juju-run.
err = os.Chmod(dir, dirPerm)
if err != nil {
return err
}
err = os.Rename(dir, SharedToolsDir(dataDir, tools.Version))
// If we've failed to rename the directory, it may be because
// the directory already exists - if ReadTools succeeds, we
// assume all's ok.
if err != nil {
if _, err := ReadTools(dataDir, tools.Version); err == nil {
return nil
}
}
return err
} | [
"func",
"UnpackTools",
"(",
"dataDir",
"string",
",",
"tools",
"*",
"coretools",
".",
"Tools",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"err",
"error",
")",
"{",
"// Unpack the gzip file and compute the checksum.",
"sha256hash",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"zr",
",",
"err",
":=",
"gzip",
".",
"NewReader",
"(",
"io",
".",
"TeeReader",
"(",
"r",
",",
"sha256hash",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"zr",
".",
"Close",
"(",
")",
"\n",
"f",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"os",
".",
"TempDir",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"f",
",",
"zr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"os",
".",
"Remove",
"(",
"f",
".",
"Name",
"(",
")",
")",
"\n",
"gzipSHA256",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"sha256hash",
".",
"Sum",
"(",
"nil",
")",
")",
"\n",
"if",
"tools",
".",
"SHA256",
"!=",
"gzipSHA256",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tools",
".",
"SHA256",
",",
"gzipSHA256",
")",
"\n",
"}",
"\n\n",
"// Make a temporary directory in the tools directory,",
"// first ensuring that the tools directory exists.",
"toolsDir",
":=",
"path",
".",
"Join",
"(",
"dataDir",
",",
"\"",
"\"",
")",
"\n",
"err",
"=",
"os",
".",
"MkdirAll",
"(",
"toolsDir",
",",
"dirPerm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"dir",
",",
"err",
":=",
"ioutil",
".",
"TempDir",
"(",
"toolsDir",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"removeAll",
"(",
"dir",
")",
"\n\n",
"// Checksum matches, now reset the file and untar it.",
"_",
",",
"err",
"=",
"f",
".",
"Seek",
"(",
"0",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"tr",
":=",
"tar",
".",
"NewReader",
"(",
"f",
")",
"\n",
"for",
"{",
"hdr",
",",
"err",
":=",
"tr",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"break",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"strings",
".",
"ContainsAny",
"(",
"hdr",
".",
"Name",
",",
"\"",
"\\\\",
"\"",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"hdr",
".",
"Name",
")",
"\n",
"}",
"\n",
"if",
"hdr",
".",
"Typeflag",
"!=",
"tar",
".",
"TypeReg",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"hdr",
".",
"Typeflag",
",",
"hdr",
".",
"Name",
")",
"\n",
"}",
"\n",
"name",
":=",
"path",
".",
"Join",
"(",
"dir",
",",
"hdr",
".",
"Name",
")",
"\n",
"if",
"err",
":=",
"writeFile",
"(",
"name",
",",
"os",
".",
"FileMode",
"(",
"hdr",
".",
"Mode",
"&",
"0777",
")",
",",
"tr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Annotatef",
"(",
"err",
",",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"=",
"WriteToolsMetadataData",
"(",
"dir",
",",
"tools",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// The tempdir is created with 0700, so we need to make it more",
"// accessible for juju-run.",
"err",
"=",
"os",
".",
"Chmod",
"(",
"dir",
",",
"dirPerm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"os",
".",
"Rename",
"(",
"dir",
",",
"SharedToolsDir",
"(",
"dataDir",
",",
"tools",
".",
"Version",
")",
")",
"\n",
"// If we've failed to rename the directory, it may be because",
"// the directory already exists - if ReadTools succeeds, we",
"// assume all's ok.",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"err",
":=",
"ReadTools",
"(",
"dataDir",
",",
"tools",
".",
"Version",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // UnpackTools reads a set of juju tools in gzipped tar-archive
// format and unpacks them into the appropriate tools directory
// within dataDir. If a valid tools directory already exists,
// UnpackTools returns without error. | [
"UnpackTools",
"reads",
"a",
"set",
"of",
"juju",
"tools",
"in",
"gzipped",
"tar",
"-",
"archive",
"format",
"and",
"unpacks",
"them",
"into",
"the",
"appropriate",
"tools",
"directory",
"within",
"dataDir",
".",
"If",
"a",
"valid",
"tools",
"directory",
"already",
"exists",
"UnpackTools",
"returns",
"without",
"error",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/agent/tools/toolsdir.go#L60-L141 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.