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
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
go-acme/lego
|
providers/dns/pdns/pdns.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("pdns: the configuration of the DNS provider is nil")
}
if config.APIKey == "" {
return nil, fmt.Errorf("pdns: API key missing")
}
if config.Host == nil || config.Host.Host == "" {
return nil, fmt.Errorf("pdns: API URL missing")
}
d := &DNSProvider{config: config}
apiVersion, err := d.getAPIVersion()
if err != nil {
log.Warnf("pdns: failed to get API version %v", err)
}
d.apiVersion = apiVersion
return d, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("pdns: the configuration of the DNS provider is nil")
}
if config.APIKey == "" {
return nil, fmt.Errorf("pdns: API key missing")
}
if config.Host == nil || config.Host.Host == "" {
return nil, fmt.Errorf("pdns: API URL missing")
}
d := &DNSProvider{config: config}
apiVersion, err := d.getAPIVersion()
if err != nil {
log.Warnf("pdns: failed to get API version %v", err)
}
d.apiVersion = apiVersion
return d, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"pdns: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"APIKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"pdns: API key missing\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"Host",
"==",
"nil",
"||",
"config",
".",
"Host",
".",
"Host",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"pdns: API URL missing\"",
")",
"\n",
"}",
"\n",
"d",
":=",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
"}",
"\n",
"apiVersion",
",",
"err",
":=",
"d",
".",
"getAPIVersion",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"pdns: failed to get API version %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"d",
".",
"apiVersion",
"=",
"apiVersion",
"\n",
"return",
"d",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for pdns.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"pdns",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/pdns/pdns.go#L68-L90
|
train
|
go-acme/lego
|
providers/dns/bluecat/client.go
|
login
|
func (d *DNSProvider) login() error {
queryArgs := map[string]string{
"username": d.config.UserName,
"password": d.config.Password,
}
resp, err := d.sendRequest(http.MethodGet, "login", nil, queryArgs)
if err != nil {
return err
}
defer resp.Body.Close()
authBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
return fmt.Errorf("bluecat: %v", err)
}
authResp := string(authBytes)
if strings.Contains(authResp, "Authentication Error") {
msg := strings.Trim(authResp, "\"")
return fmt.Errorf("bluecat: request failed: %s", msg)
}
// Upon success, API responds with "Session Token-> BAMAuthToken: dQfuRMTUxNjc3MjcyNDg1ODppcGFybXM= <- for User : username"
d.token = regexp.MustCompile("BAMAuthToken: [^ ]+").FindString(authResp)
return nil
}
|
go
|
func (d *DNSProvider) login() error {
queryArgs := map[string]string{
"username": d.config.UserName,
"password": d.config.Password,
}
resp, err := d.sendRequest(http.MethodGet, "login", nil, queryArgs)
if err != nil {
return err
}
defer resp.Body.Close()
authBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
return fmt.Errorf("bluecat: %v", err)
}
authResp := string(authBytes)
if strings.Contains(authResp, "Authentication Error") {
msg := strings.Trim(authResp, "\"")
return fmt.Errorf("bluecat: request failed: %s", msg)
}
// Upon success, API responds with "Session Token-> BAMAuthToken: dQfuRMTUxNjc3MjcyNDg1ODppcGFybXM= <- for User : username"
d.token = regexp.MustCompile("BAMAuthToken: [^ ]+").FindString(authResp)
return nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"login",
"(",
")",
"error",
"{",
"queryArgs",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"username\"",
":",
"d",
".",
"config",
".",
"UserName",
",",
"\"password\"",
":",
"d",
".",
"config",
".",
"Password",
",",
"}",
"\n",
"resp",
",",
"err",
":=",
"d",
".",
"sendRequest",
"(",
"http",
".",
"MethodGet",
",",
"\"login\"",
",",
"nil",
",",
"queryArgs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"authBytes",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"authResp",
":=",
"string",
"(",
"authBytes",
")",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"authResp",
",",
"\"Authentication Error\"",
")",
"{",
"msg",
":=",
"strings",
".",
"Trim",
"(",
"authResp",
",",
"\"\\\"\"",
")",
"\n",
"\\\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: request failed: %s\"",
",",
"msg",
")",
"\n",
"d",
".",
"token",
"=",
"regexp",
".",
"MustCompile",
"(",
"\"BAMAuthToken: [^ ]+\"",
")",
".",
"FindString",
"(",
"authResp",
")",
"\n",
"}"
] |
// Starts a new Bluecat API Session. Authenticates using customerName, userName,
// password and receives a token to be used in for subsequent requests.
|
[
"Starts",
"a",
"new",
"Bluecat",
"API",
"Session",
".",
"Authenticates",
"using",
"customerName",
"userName",
"password",
"and",
"receives",
"a",
"token",
"to",
"be",
"used",
"in",
"for",
"subsequent",
"requests",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/bluecat/client.go#L31-L57
|
train
|
go-acme/lego
|
providers/dns/bluecat/client.go
|
logout
|
func (d *DNSProvider) logout() error {
if len(d.token) == 0 {
// nothing to do
return nil
}
resp, err := d.sendRequest(http.MethodGet, "logout", nil, nil)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return fmt.Errorf("bluecat: request failed to delete session with HTTP status code %d", resp.StatusCode)
}
authBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
authResp := string(authBytes)
if !strings.Contains(authResp, "successfully") {
msg := strings.Trim(authResp, "\"")
return fmt.Errorf("bluecat: request failed to delete session: %s", msg)
}
d.token = ""
return nil
}
|
go
|
func (d *DNSProvider) logout() error {
if len(d.token) == 0 {
// nothing to do
return nil
}
resp, err := d.sendRequest(http.MethodGet, "logout", nil, nil)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return fmt.Errorf("bluecat: request failed to delete session with HTTP status code %d", resp.StatusCode)
}
authBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
authResp := string(authBytes)
if !strings.Contains(authResp, "successfully") {
msg := strings.Trim(authResp, "\"")
return fmt.Errorf("bluecat: request failed to delete session: %s", msg)
}
d.token = ""
return nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"logout",
"(",
")",
"error",
"{",
"if",
"len",
"(",
"d",
".",
"token",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"resp",
",",
"err",
":=",
"d",
".",
"sendRequest",
"(",
"http",
".",
"MethodGet",
",",
"\"logout\"",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"200",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: request failed to delete session with HTTP status code %d\"",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"}",
"\n",
"authBytes",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"authResp",
":=",
"string",
"(",
"authBytes",
")",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"authResp",
",",
"\"successfully\"",
")",
"{",
"msg",
":=",
"strings",
".",
"Trim",
"(",
"authResp",
",",
"\"\\\"\"",
")",
"\n",
"\\\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: request failed to delete session: %s\"",
",",
"msg",
")",
"\n",
"d",
".",
"token",
"=",
"\"\"",
"\n",
"}"
] |
// Destroys Bluecat Session
|
[
"Destroys",
"Bluecat",
"Session"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/bluecat/client.go#L60-L90
|
train
|
go-acme/lego
|
providers/dns/bluecat/client.go
|
lookupConfID
|
func (d *DNSProvider) lookupConfID() (uint, error) {
queryArgs := map[string]string{
"parentId": strconv.Itoa(0),
"name": d.config.ConfigName,
"type": configType,
}
resp, err := d.sendRequest(http.MethodGet, "getEntityByName", nil, queryArgs)
if err != nil {
return 0, err
}
defer resp.Body.Close()
var conf entityResponse
err = json.NewDecoder(resp.Body).Decode(&conf)
if err != nil {
return 0, fmt.Errorf("bluecat: %v", err)
}
return conf.ID, nil
}
|
go
|
func (d *DNSProvider) lookupConfID() (uint, error) {
queryArgs := map[string]string{
"parentId": strconv.Itoa(0),
"name": d.config.ConfigName,
"type": configType,
}
resp, err := d.sendRequest(http.MethodGet, "getEntityByName", nil, queryArgs)
if err != nil {
return 0, err
}
defer resp.Body.Close()
var conf entityResponse
err = json.NewDecoder(resp.Body).Decode(&conf)
if err != nil {
return 0, fmt.Errorf("bluecat: %v", err)
}
return conf.ID, nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"lookupConfID",
"(",
")",
"(",
"uint",
",",
"error",
")",
"{",
"queryArgs",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"parentId\"",
":",
"strconv",
".",
"Itoa",
"(",
"0",
")",
",",
"\"name\"",
":",
"d",
".",
"config",
".",
"ConfigName",
",",
"\"type\"",
":",
"configType",
",",
"}",
"\n",
"resp",
",",
"err",
":=",
"d",
".",
"sendRequest",
"(",
"http",
".",
"MethodGet",
",",
"\"getEntityByName\"",
",",
"nil",
",",
"queryArgs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"var",
"conf",
"entityResponse",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"conf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"conf",
".",
"ID",
",",
"nil",
"\n",
"}"
] |
// Lookup the entity ID of the configuration named in our properties
|
[
"Lookup",
"the",
"entity",
"ID",
"of",
"the",
"configuration",
"named",
"in",
"our",
"properties"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/bluecat/client.go#L93-L112
|
train
|
go-acme/lego
|
providers/dns/bluecat/client.go
|
lookupViewID
|
func (d *DNSProvider) lookupViewID(viewName string) (uint, error) {
confID, err := d.lookupConfID()
if err != nil {
return 0, err
}
queryArgs := map[string]string{
"parentId": strconv.FormatUint(uint64(confID), 10),
"name": viewName,
"type": viewType,
}
resp, err := d.sendRequest(http.MethodGet, "getEntityByName", nil, queryArgs)
if err != nil {
return 0, err
}
defer resp.Body.Close()
var view entityResponse
err = json.NewDecoder(resp.Body).Decode(&view)
if err != nil {
return 0, fmt.Errorf("bluecat: %v", err)
}
return view.ID, nil
}
|
go
|
func (d *DNSProvider) lookupViewID(viewName string) (uint, error) {
confID, err := d.lookupConfID()
if err != nil {
return 0, err
}
queryArgs := map[string]string{
"parentId": strconv.FormatUint(uint64(confID), 10),
"name": viewName,
"type": viewType,
}
resp, err := d.sendRequest(http.MethodGet, "getEntityByName", nil, queryArgs)
if err != nil {
return 0, err
}
defer resp.Body.Close()
var view entityResponse
err = json.NewDecoder(resp.Body).Decode(&view)
if err != nil {
return 0, fmt.Errorf("bluecat: %v", err)
}
return view.ID, nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"lookupViewID",
"(",
"viewName",
"string",
")",
"(",
"uint",
",",
"error",
")",
"{",
"confID",
",",
"err",
":=",
"d",
".",
"lookupConfID",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"queryArgs",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"parentId\"",
":",
"strconv",
".",
"FormatUint",
"(",
"uint64",
"(",
"confID",
")",
",",
"10",
")",
",",
"\"name\"",
":",
"viewName",
",",
"\"type\"",
":",
"viewType",
",",
"}",
"\n",
"resp",
",",
"err",
":=",
"d",
".",
"sendRequest",
"(",
"http",
".",
"MethodGet",
",",
"\"getEntityByName\"",
",",
"nil",
",",
"queryArgs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"var",
"view",
"entityResponse",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"view",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"view",
".",
"ID",
",",
"nil",
"\n",
"}"
] |
// Find the DNS view with the given name within
|
[
"Find",
"the",
"DNS",
"view",
"with",
"the",
"given",
"name",
"within"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/bluecat/client.go#L115-L140
|
train
|
go-acme/lego
|
providers/dns/bluecat/client.go
|
lookupParentZoneID
|
func (d *DNSProvider) lookupParentZoneID(viewID uint, fqdn string) (uint, string, error) {
parentViewID := viewID
name := ""
if fqdn != "" {
zones := strings.Split(strings.Trim(fqdn, "."), ".")
last := len(zones) - 1
name = zones[0]
for i := last; i > -1; i-- {
zoneID, err := d.getZone(parentViewID, zones[i])
if err != nil || zoneID == 0 {
return parentViewID, name, err
}
if i > 0 {
name = strings.Join(zones[0:i], ".")
}
parentViewID = zoneID
}
}
return parentViewID, name, nil
}
|
go
|
func (d *DNSProvider) lookupParentZoneID(viewID uint, fqdn string) (uint, string, error) {
parentViewID := viewID
name := ""
if fqdn != "" {
zones := strings.Split(strings.Trim(fqdn, "."), ".")
last := len(zones) - 1
name = zones[0]
for i := last; i > -1; i-- {
zoneID, err := d.getZone(parentViewID, zones[i])
if err != nil || zoneID == 0 {
return parentViewID, name, err
}
if i > 0 {
name = strings.Join(zones[0:i], ".")
}
parentViewID = zoneID
}
}
return parentViewID, name, nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"lookupParentZoneID",
"(",
"viewID",
"uint",
",",
"fqdn",
"string",
")",
"(",
"uint",
",",
"string",
",",
"error",
")",
"{",
"parentViewID",
":=",
"viewID",
"\n",
"name",
":=",
"\"\"",
"\n",
"if",
"fqdn",
"!=",
"\"\"",
"{",
"zones",
":=",
"strings",
".",
"Split",
"(",
"strings",
".",
"Trim",
"(",
"fqdn",
",",
"\".\"",
")",
",",
"\".\"",
")",
"\n",
"last",
":=",
"len",
"(",
"zones",
")",
"-",
"1",
"\n",
"name",
"=",
"zones",
"[",
"0",
"]",
"\n",
"for",
"i",
":=",
"last",
";",
"i",
">",
"-",
"1",
";",
"i",
"--",
"{",
"zoneID",
",",
"err",
":=",
"d",
".",
"getZone",
"(",
"parentViewID",
",",
"zones",
"[",
"i",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"zoneID",
"==",
"0",
"{",
"return",
"parentViewID",
",",
"name",
",",
"err",
"\n",
"}",
"\n",
"if",
"i",
">",
"0",
"{",
"name",
"=",
"strings",
".",
"Join",
"(",
"zones",
"[",
"0",
":",
"i",
"]",
",",
"\".\"",
")",
"\n",
"}",
"\n",
"parentViewID",
"=",
"zoneID",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"parentViewID",
",",
"name",
",",
"nil",
"\n",
"}"
] |
// Return the entityId of the parent zone by recursing from the root view
// Also return the simple name of the host
|
[
"Return",
"the",
"entityId",
"of",
"the",
"parent",
"zone",
"by",
"recursing",
"from",
"the",
"root",
"view",
"Also",
"return",
"the",
"simple",
"name",
"of",
"the",
"host"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/bluecat/client.go#L144-L166
|
train
|
go-acme/lego
|
providers/dns/bluecat/client.go
|
getZone
|
func (d *DNSProvider) getZone(parentID uint, name string) (uint, error) {
queryArgs := map[string]string{
"parentId": strconv.FormatUint(uint64(parentID), 10),
"name": name,
"type": zoneType,
}
resp, err := d.sendRequest(http.MethodGet, "getEntityByName", nil, queryArgs)
// Return an empty zone if the named zone doesn't exist
if resp != nil && resp.StatusCode == http.StatusNotFound {
return 0, fmt.Errorf("bluecat: could not find zone named %s", name)
}
if err != nil {
return 0, err
}
defer resp.Body.Close()
var zone entityResponse
err = json.NewDecoder(resp.Body).Decode(&zone)
if err != nil {
return 0, fmt.Errorf("bluecat: %v", err)
}
return zone.ID, nil
}
|
go
|
func (d *DNSProvider) getZone(parentID uint, name string) (uint, error) {
queryArgs := map[string]string{
"parentId": strconv.FormatUint(uint64(parentID), 10),
"name": name,
"type": zoneType,
}
resp, err := d.sendRequest(http.MethodGet, "getEntityByName", nil, queryArgs)
// Return an empty zone if the named zone doesn't exist
if resp != nil && resp.StatusCode == http.StatusNotFound {
return 0, fmt.Errorf("bluecat: could not find zone named %s", name)
}
if err != nil {
return 0, err
}
defer resp.Body.Close()
var zone entityResponse
err = json.NewDecoder(resp.Body).Decode(&zone)
if err != nil {
return 0, fmt.Errorf("bluecat: %v", err)
}
return zone.ID, nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"getZone",
"(",
"parentID",
"uint",
",",
"name",
"string",
")",
"(",
"uint",
",",
"error",
")",
"{",
"queryArgs",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"parentId\"",
":",
"strconv",
".",
"FormatUint",
"(",
"uint64",
"(",
"parentID",
")",
",",
"10",
")",
",",
"\"name\"",
":",
"name",
",",
"\"type\"",
":",
"zoneType",
",",
"}",
"\n",
"resp",
",",
"err",
":=",
"d",
".",
"sendRequest",
"(",
"http",
".",
"MethodGet",
",",
"\"getEntityByName\"",
",",
"nil",
",",
"queryArgs",
")",
"\n",
"if",
"resp",
"!=",
"nil",
"&&",
"resp",
".",
"StatusCode",
"==",
"http",
".",
"StatusNotFound",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: could not find zone named %s\"",
",",
"name",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"var",
"zone",
"entityResponse",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"zone",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"zone",
".",
"ID",
",",
"nil",
"\n",
"}"
] |
// Get the DNS zone with the specified name under the parentId
|
[
"Get",
"the",
"DNS",
"zone",
"with",
"the",
"specified",
"name",
"under",
"the",
"parentId"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/bluecat/client.go#L169-L194
|
train
|
go-acme/lego
|
providers/dns/bluecat/client.go
|
deploy
|
func (d *DNSProvider) deploy(entityID uint) error {
queryArgs := map[string]string{
"entityId": strconv.FormatUint(uint64(entityID), 10),
}
resp, err := d.sendRequest(http.MethodPost, "quickDeploy", nil, queryArgs)
if err != nil {
return err
}
defer resp.Body.Close()
return nil
}
|
go
|
func (d *DNSProvider) deploy(entityID uint) error {
queryArgs := map[string]string{
"entityId": strconv.FormatUint(uint64(entityID), 10),
}
resp, err := d.sendRequest(http.MethodPost, "quickDeploy", nil, queryArgs)
if err != nil {
return err
}
defer resp.Body.Close()
return nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"deploy",
"(",
"entityID",
"uint",
")",
"error",
"{",
"queryArgs",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"entityId\"",
":",
"strconv",
".",
"FormatUint",
"(",
"uint64",
"(",
"entityID",
")",
",",
"10",
")",
",",
"}",
"\n",
"resp",
",",
"err",
":=",
"d",
".",
"sendRequest",
"(",
"http",
".",
"MethodPost",
",",
"\"quickDeploy\"",
",",
"nil",
",",
"queryArgs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Deploy the DNS config for the specified entity to the authoritative servers
|
[
"Deploy",
"the",
"DNS",
"config",
"for",
"the",
"specified",
"entity",
"to",
"the",
"authoritative",
"servers"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/bluecat/client.go#L197-L209
|
train
|
go-acme/lego
|
providers/dns/bluecat/client.go
|
sendRequest
|
func (d *DNSProvider) sendRequest(method, resource string, payload interface{}, queryArgs map[string]string) (*http.Response, error) {
url := fmt.Sprintf("%s/Services/REST/v1/%s", d.config.BaseURL, resource)
body, err := json.Marshal(payload)
if err != nil {
return nil, fmt.Errorf("bluecat: %v", err)
}
req, err := http.NewRequest(method, url, bytes.NewReader(body))
if err != nil {
return nil, fmt.Errorf("bluecat: %v", err)
}
req.Header.Set("Content-Type", "application/json")
if len(d.token) > 0 {
req.Header.Set("Authorization", d.token)
}
// Add all query parameters
q := req.URL.Query()
for argName, argVal := range queryArgs {
q.Add(argName, argVal)
}
req.URL.RawQuery = q.Encode()
resp, err := d.config.HTTPClient.Do(req)
if err != nil {
return nil, fmt.Errorf("bluecat: %v", err)
}
if resp.StatusCode >= 400 {
errBytes, _ := ioutil.ReadAll(resp.Body)
errResp := string(errBytes)
return nil, fmt.Errorf("bluecat: request failed with HTTP status code %d\n Full message: %s",
resp.StatusCode, errResp)
}
return resp, nil
}
|
go
|
func (d *DNSProvider) sendRequest(method, resource string, payload interface{}, queryArgs map[string]string) (*http.Response, error) {
url := fmt.Sprintf("%s/Services/REST/v1/%s", d.config.BaseURL, resource)
body, err := json.Marshal(payload)
if err != nil {
return nil, fmt.Errorf("bluecat: %v", err)
}
req, err := http.NewRequest(method, url, bytes.NewReader(body))
if err != nil {
return nil, fmt.Errorf("bluecat: %v", err)
}
req.Header.Set("Content-Type", "application/json")
if len(d.token) > 0 {
req.Header.Set("Authorization", d.token)
}
// Add all query parameters
q := req.URL.Query()
for argName, argVal := range queryArgs {
q.Add(argName, argVal)
}
req.URL.RawQuery = q.Encode()
resp, err := d.config.HTTPClient.Do(req)
if err != nil {
return nil, fmt.Errorf("bluecat: %v", err)
}
if resp.StatusCode >= 400 {
errBytes, _ := ioutil.ReadAll(resp.Body)
errResp := string(errBytes)
return nil, fmt.Errorf("bluecat: request failed with HTTP status code %d\n Full message: %s",
resp.StatusCode, errResp)
}
return resp, nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"sendRequest",
"(",
"method",
",",
"resource",
"string",
",",
"payload",
"interface",
"{",
"}",
",",
"queryArgs",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"url",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s/Services/REST/v1/%s\"",
",",
"d",
".",
"config",
".",
"BaseURL",
",",
"resource",
")",
"\n",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"payload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"method",
",",
"url",
",",
"bytes",
".",
"NewReader",
"(",
"body",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"\"application/json\"",
")",
"\n",
"if",
"len",
"(",
"d",
".",
"token",
")",
">",
"0",
"{",
"req",
".",
"Header",
".",
"Set",
"(",
"\"Authorization\"",
",",
"d",
".",
"token",
")",
"\n",
"}",
"\n",
"q",
":=",
"req",
".",
"URL",
".",
"Query",
"(",
")",
"\n",
"for",
"argName",
",",
"argVal",
":=",
"range",
"queryArgs",
"{",
"q",
".",
"Add",
"(",
"argName",
",",
"argVal",
")",
"\n",
"}",
"\n",
"req",
".",
"URL",
".",
"RawQuery",
"=",
"q",
".",
"Encode",
"(",
")",
"\n",
"resp",
",",
"err",
":=",
"d",
".",
"config",
".",
"HTTPClient",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"resp",
".",
"StatusCode",
">=",
"400",
"{",
"errBytes",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"errResp",
":=",
"string",
"(",
"errBytes",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"bluecat: request failed with HTTP status code %d\\n Full message: %s\"",
",",
"\\n",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"}",
"\n",
"errResp",
"\n",
"}"
] |
// Send a REST request, using query parameters specified. The Authorization
// header will be set if we have an active auth token
|
[
"Send",
"a",
"REST",
"request",
"using",
"query",
"parameters",
"specified",
".",
"The",
"Authorization",
"header",
"will",
"be",
"set",
"if",
"we",
"have",
"an",
"active",
"auth",
"token"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/bluecat/client.go#L213-L249
|
train
|
go-acme/lego
|
acme/api/internal/sender/sender.go
|
NewDoer
|
func NewDoer(client *http.Client, userAgent string) *Doer {
return &Doer{
httpClient: client,
userAgent: userAgent,
}
}
|
go
|
func NewDoer(client *http.Client, userAgent string) *Doer {
return &Doer{
httpClient: client,
userAgent: userAgent,
}
}
|
[
"func",
"NewDoer",
"(",
"client",
"*",
"http",
".",
"Client",
",",
"userAgent",
"string",
")",
"*",
"Doer",
"{",
"return",
"&",
"Doer",
"{",
"httpClient",
":",
"client",
",",
"userAgent",
":",
"userAgent",
",",
"}",
"\n",
"}"
] |
// NewDoer Creates a new Doer.
|
[
"NewDoer",
"Creates",
"a",
"new",
"Doer",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/sender/sender.go#L30-L35
|
train
|
go-acme/lego
|
acme/api/internal/sender/sender.go
|
Get
|
func (d *Doer) Get(url string, response interface{}) (*http.Response, error) {
req, err := d.newRequest(http.MethodGet, url, nil)
if err != nil {
return nil, err
}
return d.do(req, response)
}
|
go
|
func (d *Doer) Get(url string, response interface{}) (*http.Response, error) {
req, err := d.newRequest(http.MethodGet, url, nil)
if err != nil {
return nil, err
}
return d.do(req, response)
}
|
[
"func",
"(",
"d",
"*",
"Doer",
")",
"Get",
"(",
"url",
"string",
",",
"response",
"interface",
"{",
"}",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"d",
".",
"newRequest",
"(",
"http",
".",
"MethodGet",
",",
"url",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"d",
".",
"do",
"(",
"req",
",",
"response",
")",
"\n",
"}"
] |
// Get performs a GET request with a proper User-Agent string.
// If "response" is not provided, callers should close resp.Body when done reading from it.
|
[
"Get",
"performs",
"a",
"GET",
"request",
"with",
"a",
"proper",
"User",
"-",
"Agent",
"string",
".",
"If",
"response",
"is",
"not",
"provided",
"callers",
"should",
"close",
"resp",
".",
"Body",
"when",
"done",
"reading",
"from",
"it",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/sender/sender.go#L39-L46
|
train
|
go-acme/lego
|
acme/api/internal/sender/sender.go
|
Post
|
func (d *Doer) Post(url string, body io.Reader, bodyType string, response interface{}) (*http.Response, error) {
req, err := d.newRequest(http.MethodPost, url, body, contentType(bodyType))
if err != nil {
return nil, err
}
return d.do(req, response)
}
|
go
|
func (d *Doer) Post(url string, body io.Reader, bodyType string, response interface{}) (*http.Response, error) {
req, err := d.newRequest(http.MethodPost, url, body, contentType(bodyType))
if err != nil {
return nil, err
}
return d.do(req, response)
}
|
[
"func",
"(",
"d",
"*",
"Doer",
")",
"Post",
"(",
"url",
"string",
",",
"body",
"io",
".",
"Reader",
",",
"bodyType",
"string",
",",
"response",
"interface",
"{",
"}",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"d",
".",
"newRequest",
"(",
"http",
".",
"MethodPost",
",",
"url",
",",
"body",
",",
"contentType",
"(",
"bodyType",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"d",
".",
"do",
"(",
"req",
",",
"response",
")",
"\n",
"}"
] |
// Post performs a POST request with a proper User-Agent string.
// If "response" is not provided, callers should close resp.Body when done reading from it.
|
[
"Post",
"performs",
"a",
"POST",
"request",
"with",
"a",
"proper",
"User",
"-",
"Agent",
"string",
".",
"If",
"response",
"is",
"not",
"provided",
"callers",
"should",
"close",
"resp",
".",
"Body",
"when",
"done",
"reading",
"from",
"it",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/sender/sender.go#L61-L68
|
train
|
go-acme/lego
|
acme/api/internal/sender/sender.go
|
formatUserAgent
|
func (d *Doer) formatUserAgent() string {
ua := fmt.Sprintf("%s %s (%s; %s; %s)", d.userAgent, ourUserAgent, ourUserAgentComment, runtime.GOOS, runtime.GOARCH)
return strings.TrimSpace(ua)
}
|
go
|
func (d *Doer) formatUserAgent() string {
ua := fmt.Sprintf("%s %s (%s; %s; %s)", d.userAgent, ourUserAgent, ourUserAgentComment, runtime.GOOS, runtime.GOARCH)
return strings.TrimSpace(ua)
}
|
[
"func",
"(",
"d",
"*",
"Doer",
")",
"formatUserAgent",
"(",
")",
"string",
"{",
"ua",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s %s (%s; %s; %s)\"",
",",
"d",
".",
"userAgent",
",",
"ourUserAgent",
",",
"ourUserAgentComment",
",",
"runtime",
".",
"GOOS",
",",
"runtime",
".",
"GOARCH",
")",
"\n",
"return",
"strings",
".",
"TrimSpace",
"(",
"ua",
")",
"\n",
"}"
] |
// formatUserAgent builds and returns the User-Agent string to use in requests.
|
[
"formatUserAgent",
"builds",
"and",
"returns",
"the",
"User",
"-",
"Agent",
"string",
"to",
"use",
"in",
"requests",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/sender/sender.go#L116-L119
|
train
|
go-acme/lego
|
providers/dns/dode/dode.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("do.de: the configuration of the DNS provider is nil")
}
if config.Token == "" {
return nil, errors.New("do.de: credentials missing")
}
return &DNSProvider{config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("do.de: the configuration of the DNS provider is nil")
}
if config.Token == "" {
return nil, errors.New("do.de: credentials missing")
}
return &DNSProvider{config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"do.de: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"Token",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"do.de: credentials missing\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for do.de.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"do",
".",
"de",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/dode/dode.go#L55-L65
|
train
|
go-acme/lego
|
providers/dns/dode/dode.go
|
CleanUp
|
func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, _ := dns01.GetRecord(domain, keyAuth)
return d.updateTxtRecord(fqdn, d.config.Token, "", true)
}
|
go
|
func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, _ := dns01.GetRecord(domain, keyAuth)
return d.updateTxtRecord(fqdn, d.config.Token, "", true)
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"CleanUp",
"(",
"domain",
",",
"token",
",",
"keyAuth",
"string",
")",
"error",
"{",
"fqdn",
",",
"_",
":=",
"dns01",
".",
"GetRecord",
"(",
"domain",
",",
"keyAuth",
")",
"\n",
"return",
"d",
".",
"updateTxtRecord",
"(",
"fqdn",
",",
"d",
".",
"config",
".",
"Token",
",",
"\"\"",
",",
"true",
")",
"\n",
"}"
] |
// CleanUp clears TXT record
|
[
"CleanUp",
"clears",
"TXT",
"record"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/dode/dode.go#L74-L77
|
train
|
go-acme/lego
|
providers/dns/dnsmadeeasy/internal/client.go
|
NewClient
|
func NewClient(apiKey string, apiSecret string) (*Client, error) {
if apiKey == "" {
return nil, fmt.Errorf("credentials missing: API key")
}
if apiSecret == "" {
return nil, fmt.Errorf("credentials missing: API secret")
}
return &Client{
apiKey: apiKey,
apiSecret: apiSecret,
HTTPClient: &http.Client{},
}, nil
}
|
go
|
func NewClient(apiKey string, apiSecret string) (*Client, error) {
if apiKey == "" {
return nil, fmt.Errorf("credentials missing: API key")
}
if apiSecret == "" {
return nil, fmt.Errorf("credentials missing: API secret")
}
return &Client{
apiKey: apiKey,
apiSecret: apiSecret,
HTTPClient: &http.Client{},
}, nil
}
|
[
"func",
"NewClient",
"(",
"apiKey",
"string",
",",
"apiSecret",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"if",
"apiKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"credentials missing: API key\"",
")",
"\n",
"}",
"\n",
"if",
"apiSecret",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"credentials missing: API secret\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"Client",
"{",
"apiKey",
":",
"apiKey",
",",
"apiSecret",
":",
"apiSecret",
",",
"HTTPClient",
":",
"&",
"http",
".",
"Client",
"{",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewClient creates a DNSMadeEasy client
|
[
"NewClient",
"creates",
"a",
"DNSMadeEasy",
"client"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/dnsmadeeasy/internal/client.go#L44-L58
|
train
|
go-acme/lego
|
providers/dns/dnsmadeeasy/internal/client.go
|
GetDomain
|
func (c *Client) GetDomain(authZone string) (*Domain, error) {
domainName := authZone[0 : len(authZone)-1]
resource := fmt.Sprintf("%s%s", "/dns/managed/name?domainname=", domainName)
resp, err := c.sendRequest(http.MethodGet, resource, nil)
if err != nil {
return nil, err
}
defer resp.Body.Close()
domain := &Domain{}
err = json.NewDecoder(resp.Body).Decode(&domain)
if err != nil {
return nil, err
}
return domain, nil
}
|
go
|
func (c *Client) GetDomain(authZone string) (*Domain, error) {
domainName := authZone[0 : len(authZone)-1]
resource := fmt.Sprintf("%s%s", "/dns/managed/name?domainname=", domainName)
resp, err := c.sendRequest(http.MethodGet, resource, nil)
if err != nil {
return nil, err
}
defer resp.Body.Close()
domain := &Domain{}
err = json.NewDecoder(resp.Body).Decode(&domain)
if err != nil {
return nil, err
}
return domain, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"GetDomain",
"(",
"authZone",
"string",
")",
"(",
"*",
"Domain",
",",
"error",
")",
"{",
"domainName",
":=",
"authZone",
"[",
"0",
":",
"len",
"(",
"authZone",
")",
"-",
"1",
"]",
"\n",
"resource",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s%s\"",
",",
"\"/dns/managed/name?domainname=\"",
",",
"domainName",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"sendRequest",
"(",
"http",
".",
"MethodGet",
",",
"resource",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"domain",
":=",
"&",
"Domain",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"domain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"domain",
",",
"nil",
"\n",
"}"
] |
// GetDomain gets a domain
|
[
"GetDomain",
"gets",
"a",
"domain"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/dnsmadeeasy/internal/client.go#L61-L78
|
train
|
go-acme/lego
|
providers/dns/dnsmadeeasy/internal/client.go
|
GetRecords
|
func (c *Client) GetRecords(domain *Domain, recordName, recordType string) (*[]Record, error) {
resource := fmt.Sprintf("%s/%d/%s%s%s%s", "/dns/managed", domain.ID, "records?recordName=", recordName, "&type=", recordType)
resp, err := c.sendRequest(http.MethodGet, resource, nil)
if err != nil {
return nil, err
}
defer resp.Body.Close()
records := &recordsResponse{}
err = json.NewDecoder(resp.Body).Decode(&records)
if err != nil {
return nil, err
}
return records.Records, nil
}
|
go
|
func (c *Client) GetRecords(domain *Domain, recordName, recordType string) (*[]Record, error) {
resource := fmt.Sprintf("%s/%d/%s%s%s%s", "/dns/managed", domain.ID, "records?recordName=", recordName, "&type=", recordType)
resp, err := c.sendRequest(http.MethodGet, resource, nil)
if err != nil {
return nil, err
}
defer resp.Body.Close()
records := &recordsResponse{}
err = json.NewDecoder(resp.Body).Decode(&records)
if err != nil {
return nil, err
}
return records.Records, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"GetRecords",
"(",
"domain",
"*",
"Domain",
",",
"recordName",
",",
"recordType",
"string",
")",
"(",
"*",
"[",
"]",
"Record",
",",
"error",
")",
"{",
"resource",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s/%d/%s%s%s%s\"",
",",
"\"/dns/managed\"",
",",
"domain",
".",
"ID",
",",
"\"records?recordName=\"",
",",
"recordName",
",",
"\"&type=\"",
",",
"recordType",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"sendRequest",
"(",
"http",
".",
"MethodGet",
",",
"resource",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"records",
":=",
"&",
"recordsResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"records",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"records",
".",
"Records",
",",
"nil",
"\n",
"}"
] |
// GetRecords gets all TXT records
|
[
"GetRecords",
"gets",
"all",
"TXT",
"records"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/dnsmadeeasy/internal/client.go#L81-L97
|
train
|
go-acme/lego
|
providers/dns/dnsmadeeasy/internal/client.go
|
CreateRecord
|
func (c *Client) CreateRecord(domain *Domain, record *Record) error {
url := fmt.Sprintf("%s/%d/%s", "/dns/managed", domain.ID, "records")
resp, err := c.sendRequest(http.MethodPost, url, record)
if err != nil {
return err
}
defer resp.Body.Close()
return nil
}
|
go
|
func (c *Client) CreateRecord(domain *Domain, record *Record) error {
url := fmt.Sprintf("%s/%d/%s", "/dns/managed", domain.ID, "records")
resp, err := c.sendRequest(http.MethodPost, url, record)
if err != nil {
return err
}
defer resp.Body.Close()
return nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"CreateRecord",
"(",
"domain",
"*",
"Domain",
",",
"record",
"*",
"Record",
")",
"error",
"{",
"url",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s/%d/%s\"",
",",
"\"/dns/managed\"",
",",
"domain",
".",
"ID",
",",
"\"records\"",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"sendRequest",
"(",
"http",
".",
"MethodPost",
",",
"url",
",",
"record",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CreateRecord creates a TXT records
|
[
"CreateRecord",
"creates",
"a",
"TXT",
"records"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/dnsmadeeasy/internal/client.go#L100-L110
|
train
|
go-acme/lego
|
providers/dns/dnsmadeeasy/internal/client.go
|
DeleteRecord
|
func (c *Client) DeleteRecord(record Record) error {
resource := fmt.Sprintf("%s/%d/%s/%d", "/dns/managed", record.SourceID, "records", record.ID)
resp, err := c.sendRequest(http.MethodDelete, resource, nil)
if err != nil {
return err
}
defer resp.Body.Close()
return nil
}
|
go
|
func (c *Client) DeleteRecord(record Record) error {
resource := fmt.Sprintf("%s/%d/%s/%d", "/dns/managed", record.SourceID, "records", record.ID)
resp, err := c.sendRequest(http.MethodDelete, resource, nil)
if err != nil {
return err
}
defer resp.Body.Close()
return nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteRecord",
"(",
"record",
"Record",
")",
"error",
"{",
"resource",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s/%d/%s/%d\"",
",",
"\"/dns/managed\"",
",",
"record",
".",
"SourceID",
",",
"\"records\"",
",",
"record",
".",
"ID",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"sendRequest",
"(",
"http",
".",
"MethodDelete",
",",
"resource",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DeleteRecord deletes a TXT records
|
[
"DeleteRecord",
"deletes",
"a",
"TXT",
"records"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/dnsmadeeasy/internal/client.go#L113-L123
|
train
|
go-acme/lego
|
challenge/dns01/cname.go
|
updateDomainWithCName
|
func updateDomainWithCName(r *dns.Msg, fqdn string) string {
for _, rr := range r.Answer {
if cn, ok := rr.(*dns.CNAME); ok {
if cn.Hdr.Name == fqdn {
return cn.Target
}
}
}
return fqdn
}
|
go
|
func updateDomainWithCName(r *dns.Msg, fqdn string) string {
for _, rr := range r.Answer {
if cn, ok := rr.(*dns.CNAME); ok {
if cn.Hdr.Name == fqdn {
return cn.Target
}
}
}
return fqdn
}
|
[
"func",
"updateDomainWithCName",
"(",
"r",
"*",
"dns",
".",
"Msg",
",",
"fqdn",
"string",
")",
"string",
"{",
"for",
"_",
",",
"rr",
":=",
"range",
"r",
".",
"Answer",
"{",
"if",
"cn",
",",
"ok",
":=",
"rr",
".",
"(",
"*",
"dns",
".",
"CNAME",
")",
";",
"ok",
"{",
"if",
"cn",
".",
"Hdr",
".",
"Name",
"==",
"fqdn",
"{",
"return",
"cn",
".",
"Target",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fqdn",
"\n",
"}"
] |
// Update FQDN with CNAME if any
|
[
"Update",
"FQDN",
"with",
"CNAME",
"if",
"any"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/challenge/dns01/cname.go#L6-L16
|
train
|
go-acme/lego
|
acme/api/service.go
|
getLink
|
func getLink(header http.Header, rel string) string {
var linkExpr = regexp.MustCompile(`<(.+?)>;\s*rel="(.+?)"`)
for _, link := range header["Link"] {
for _, m := range linkExpr.FindAllStringSubmatch(link, -1) {
if len(m) != 3 {
continue
}
if m[2] == rel {
return m[1]
}
}
}
return ""
}
|
go
|
func getLink(header http.Header, rel string) string {
var linkExpr = regexp.MustCompile(`<(.+?)>;\s*rel="(.+?)"`)
for _, link := range header["Link"] {
for _, m := range linkExpr.FindAllStringSubmatch(link, -1) {
if len(m) != 3 {
continue
}
if m[2] == rel {
return m[1]
}
}
}
return ""
}
|
[
"func",
"getLink",
"(",
"header",
"http",
".",
"Header",
",",
"rel",
"string",
")",
"string",
"{",
"var",
"linkExpr",
"=",
"regexp",
".",
"MustCompile",
"(",
"`<(.+?)>;\\s*rel=\"(.+?)\"`",
")",
"\n",
"for",
"_",
",",
"link",
":=",
"range",
"header",
"[",
"\"Link\"",
"]",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"linkExpr",
".",
"FindAllStringSubmatch",
"(",
"link",
",",
"-",
"1",
")",
"{",
"if",
"len",
"(",
"m",
")",
"!=",
"3",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"m",
"[",
"2",
"]",
"==",
"rel",
"{",
"return",
"m",
"[",
"1",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"\"",
"\n",
"}"
] |
// getLink get a rel into the Link header
|
[
"getLink",
"get",
"a",
"rel",
"into",
"the",
"Link",
"header"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/service.go#L13-L27
|
train
|
go-acme/lego
|
acme/api/service.go
|
getLocation
|
func getLocation(resp *http.Response) string {
if resp == nil {
return ""
}
return resp.Header.Get("Location")
}
|
go
|
func getLocation(resp *http.Response) string {
if resp == nil {
return ""
}
return resp.Header.Get("Location")
}
|
[
"func",
"getLocation",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"string",
"{",
"if",
"resp",
"==",
"nil",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Header",
".",
"Get",
"(",
"\"Location\"",
")",
"\n",
"}"
] |
// getLocation get the value of the header Location
|
[
"getLocation",
"get",
"the",
"value",
"of",
"the",
"header",
"Location"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/service.go#L30-L36
|
train
|
go-acme/lego
|
acme/api/service.go
|
getRetryAfter
|
func getRetryAfter(resp *http.Response) string {
if resp == nil {
return ""
}
return resp.Header.Get("Retry-After")
}
|
go
|
func getRetryAfter(resp *http.Response) string {
if resp == nil {
return ""
}
return resp.Header.Get("Retry-After")
}
|
[
"func",
"getRetryAfter",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"string",
"{",
"if",
"resp",
"==",
"nil",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Header",
".",
"Get",
"(",
"\"Retry-After\"",
")",
"\n",
"}"
] |
// getRetryAfter get the value of the header Retry-After
|
[
"getRetryAfter",
"get",
"the",
"value",
"of",
"the",
"header",
"Retry",
"-",
"After"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/service.go#L39-L45
|
train
|
go-acme/lego
|
providers/http/webroot/webroot.go
|
NewHTTPProvider
|
func NewHTTPProvider(path string) (*HTTPProvider, error) {
if _, err := os.Stat(path); os.IsNotExist(err) {
return nil, fmt.Errorf("webroot path does not exist")
}
return &HTTPProvider{path: path}, nil
}
|
go
|
func NewHTTPProvider(path string) (*HTTPProvider, error) {
if _, err := os.Stat(path); os.IsNotExist(err) {
return nil, fmt.Errorf("webroot path does not exist")
}
return &HTTPProvider{path: path}, nil
}
|
[
"func",
"NewHTTPProvider",
"(",
"path",
"string",
")",
"(",
"*",
"HTTPProvider",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"path",
")",
";",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"webroot path does not exist\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"HTTPProvider",
"{",
"path",
":",
"path",
"}",
",",
"nil",
"\n",
"}"
] |
// NewHTTPProvider returns a HTTPProvider instance with a configured webroot path
|
[
"NewHTTPProvider",
"returns",
"a",
"HTTPProvider",
"instance",
"with",
"a",
"configured",
"webroot",
"path"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/http/webroot/webroot.go#L19-L25
|
train
|
go-acme/lego
|
providers/http/webroot/webroot.go
|
CleanUp
|
func (w *HTTPProvider) CleanUp(domain, token, keyAuth string) error {
err := os.Remove(filepath.Join(w.path, http01.ChallengePath(token)))
if err != nil {
return fmt.Errorf("could not remove file in webroot after HTTP challenge -> %v", err)
}
return nil
}
|
go
|
func (w *HTTPProvider) CleanUp(domain, token, keyAuth string) error {
err := os.Remove(filepath.Join(w.path, http01.ChallengePath(token)))
if err != nil {
return fmt.Errorf("could not remove file in webroot after HTTP challenge -> %v", err)
}
return nil
}
|
[
"func",
"(",
"w",
"*",
"HTTPProvider",
")",
"CleanUp",
"(",
"domain",
",",
"token",
",",
"keyAuth",
"string",
")",
"error",
"{",
"err",
":=",
"os",
".",
"Remove",
"(",
"filepath",
".",
"Join",
"(",
"w",
".",
"path",
",",
"http01",
".",
"ChallengePath",
"(",
"token",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"could not remove file in webroot after HTTP challenge -> %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CleanUp removes the file created for the challenge
|
[
"CleanUp",
"removes",
"the",
"file",
"created",
"for",
"the",
"challenge"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/http/webroot/webroot.go#L46-L53
|
train
|
go-acme/lego
|
providers/dns/netcup/netcup.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("netcup: the configuration of the DNS provider is nil")
}
client, err := internal.NewClient(config.Customer, config.Key, config.Password)
if err != nil {
return nil, fmt.Errorf("netcup: %v", err)
}
client.HTTPClient = config.HTTPClient
return &DNSProvider{client: client, config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("netcup: the configuration of the DNS provider is nil")
}
client, err := internal.NewClient(config.Customer, config.Key, config.Password)
if err != nil {
return nil, fmt.Errorf("netcup: %v", err)
}
client.HTTPClient = config.HTTPClient
return &DNSProvider{client: client, config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"netcup: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"internal",
".",
"NewClient",
"(",
"config",
".",
"Customer",
",",
"config",
".",
"Key",
",",
"config",
".",
"Password",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"netcup: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"client",
".",
"HTTPClient",
"=",
"config",
".",
"HTTPClient",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"client",
",",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for netcup.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"netcup",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/netcup/netcup.go#L65-L78
|
train
|
go-acme/lego
|
providers/dns/stackpath/stackpath.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("stackpath: the configuration of the DNS provider is nil")
}
if len(config.ClientID) == 0 || len(config.ClientSecret) == 0 {
return nil, errors.New("stackpath: credentials missing")
}
if len(config.StackID) == 0 {
return nil, errors.New("stackpath: stack id missing")
}
baseURL, _ := url.Parse(defaultBaseURL)
return &DNSProvider{
BaseURL: baseURL,
client: getOathClient(config),
config: config,
}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("stackpath: the configuration of the DNS provider is nil")
}
if len(config.ClientID) == 0 || len(config.ClientSecret) == 0 {
return nil, errors.New("stackpath: credentials missing")
}
if len(config.StackID) == 0 {
return nil, errors.New("stackpath: stack id missing")
}
baseURL, _ := url.Parse(defaultBaseURL)
return &DNSProvider{
BaseURL: baseURL,
client: getOathClient(config),
config: config,
}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"stackpath: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"ClientID",
")",
"==",
"0",
"||",
"len",
"(",
"config",
".",
"ClientSecret",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"stackpath: credentials missing\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"StackID",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"stackpath: stack id missing\"",
")",
"\n",
"}",
"\n",
"baseURL",
",",
"_",
":=",
"url",
".",
"Parse",
"(",
"defaultBaseURL",
")",
"\n",
"return",
"&",
"DNSProvider",
"{",
"BaseURL",
":",
"baseURL",
",",
"client",
":",
"getOathClient",
"(",
"config",
")",
",",
"config",
":",
"config",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for Stackpath.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"Stackpath",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/stackpath/stackpath.go#L69-L89
|
train
|
go-acme/lego
|
providers/dns/ovh/ovh.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("ovh: the configuration of the DNS provider is nil")
}
if config.APIEndpoint == "" || config.ApplicationKey == "" || config.ApplicationSecret == "" || config.ConsumerKey == "" {
return nil, fmt.Errorf("ovh: credentials missing")
}
client, err := ovh.NewClient(
config.APIEndpoint,
config.ApplicationKey,
config.ApplicationSecret,
config.ConsumerKey,
)
if err != nil {
return nil, fmt.Errorf("ovh: %v", err)
}
client.Client = config.HTTPClient
return &DNSProvider{
config: config,
client: client,
recordIDs: make(map[string]int),
}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("ovh: the configuration of the DNS provider is nil")
}
if config.APIEndpoint == "" || config.ApplicationKey == "" || config.ApplicationSecret == "" || config.ConsumerKey == "" {
return nil, fmt.Errorf("ovh: credentials missing")
}
client, err := ovh.NewClient(
config.APIEndpoint,
config.ApplicationKey,
config.ApplicationSecret,
config.ConsumerKey,
)
if err != nil {
return nil, fmt.Errorf("ovh: %v", err)
}
client.Client = config.HTTPClient
return &DNSProvider{
config: config,
client: client,
recordIDs: make(map[string]int),
}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"ovh: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"APIEndpoint",
"==",
"\"\"",
"||",
"config",
".",
"ApplicationKey",
"==",
"\"\"",
"||",
"config",
".",
"ApplicationSecret",
"==",
"\"\"",
"||",
"config",
".",
"ConsumerKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"ovh: credentials missing\"",
")",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"ovh",
".",
"NewClient",
"(",
"config",
".",
"APIEndpoint",
",",
"config",
".",
"ApplicationKey",
",",
"config",
".",
"ApplicationSecret",
",",
"config",
".",
"ConsumerKey",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"ovh: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"client",
".",
"Client",
"=",
"config",
".",
"HTTPClient",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"client",
":",
"client",
",",
"recordIDs",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for OVH.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"OVH",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/ovh/ovh.go#L85-L111
|
train
|
go-acme/lego
|
providers/dns/auroradns/auroradns.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("aurora: the configuration of the DNS provider is nil")
}
if config.UserID == "" || config.Key == "" {
return nil, errors.New("aurora: some credentials information are missing")
}
if config.BaseURL == "" {
config.BaseURL = defaultBaseURL
}
tr, err := auroradns.NewTokenTransport(config.UserID, config.Key)
if err != nil {
return nil, fmt.Errorf("aurora: %v", err)
}
client, err := auroradns.NewClient(tr.Client(), auroradns.WithBaseURL(config.BaseURL))
if err != nil {
return nil, fmt.Errorf("aurora: %v", err)
}
return &DNSProvider{
config: config,
client: client,
recordIDs: make(map[string]string),
}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("aurora: the configuration of the DNS provider is nil")
}
if config.UserID == "" || config.Key == "" {
return nil, errors.New("aurora: some credentials information are missing")
}
if config.BaseURL == "" {
config.BaseURL = defaultBaseURL
}
tr, err := auroradns.NewTokenTransport(config.UserID, config.Key)
if err != nil {
return nil, fmt.Errorf("aurora: %v", err)
}
client, err := auroradns.NewClient(tr.Client(), auroradns.WithBaseURL(config.BaseURL))
if err != nil {
return nil, fmt.Errorf("aurora: %v", err)
}
return &DNSProvider{
config: config,
client: client,
recordIDs: make(map[string]string),
}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"aurora: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"UserID",
"==",
"\"\"",
"||",
"config",
".",
"Key",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"aurora: some credentials information are missing\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"BaseURL",
"==",
"\"\"",
"{",
"config",
".",
"BaseURL",
"=",
"defaultBaseURL",
"\n",
"}",
"\n",
"tr",
",",
"err",
":=",
"auroradns",
".",
"NewTokenTransport",
"(",
"config",
".",
"UserID",
",",
"config",
".",
"Key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"aurora: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"auroradns",
".",
"NewClient",
"(",
"tr",
".",
"Client",
"(",
")",
",",
"auroradns",
".",
"WithBaseURL",
"(",
"config",
".",
"BaseURL",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"aurora: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"client",
":",
"client",
",",
"recordIDs",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for AuroraDNS.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"AuroraDNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/auroradns/auroradns.go#L62-L90
|
train
|
go-acme/lego
|
providers/dns/auroradns/auroradns.go
|
Present
|
func (d *DNSProvider) Present(domain, token, keyAuth string) error {
fqdn, value := dns01.GetRecord(domain, keyAuth)
authZone, err := dns01.FindZoneByFqdn(dns01.ToFqdn(domain))
if err != nil {
return fmt.Errorf("aurora: could not determine zone for domain: '%s'. %s", domain, err)
}
// 1. Aurora will happily create the TXT record when it is provided a fqdn,
// but it will only appear in the control panel and will not be
// propagated to DNS servers. Extract and use subdomain instead.
// 2. A trailing dot in the fqdn will cause Aurora to add a trailing dot to
// the subdomain, resulting in _acme-challenge..<domain> rather
// than _acme-challenge.<domain>
subdomain := fqdn[0 : len(fqdn)-len(authZone)-1]
authZone = dns01.UnFqdn(authZone)
zone, err := d.getZoneInformationByName(authZone)
if err != nil {
return fmt.Errorf("aurora: could not create record: %v", err)
}
record := auroradns.Record{
RecordType: "TXT",
Name: subdomain,
Content: value,
TTL: d.config.TTL,
}
newRecord, _, err := d.client.CreateRecord(zone.ID, record)
if err != nil {
return fmt.Errorf("aurora: could not create record: %v", err)
}
d.recordIDsMu.Lock()
d.recordIDs[fqdn] = newRecord.ID
d.recordIDsMu.Unlock()
return nil
}
|
go
|
func (d *DNSProvider) Present(domain, token, keyAuth string) error {
fqdn, value := dns01.GetRecord(domain, keyAuth)
authZone, err := dns01.FindZoneByFqdn(dns01.ToFqdn(domain))
if err != nil {
return fmt.Errorf("aurora: could not determine zone for domain: '%s'. %s", domain, err)
}
// 1. Aurora will happily create the TXT record when it is provided a fqdn,
// but it will only appear in the control panel and will not be
// propagated to DNS servers. Extract and use subdomain instead.
// 2. A trailing dot in the fqdn will cause Aurora to add a trailing dot to
// the subdomain, resulting in _acme-challenge..<domain> rather
// than _acme-challenge.<domain>
subdomain := fqdn[0 : len(fqdn)-len(authZone)-1]
authZone = dns01.UnFqdn(authZone)
zone, err := d.getZoneInformationByName(authZone)
if err != nil {
return fmt.Errorf("aurora: could not create record: %v", err)
}
record := auroradns.Record{
RecordType: "TXT",
Name: subdomain,
Content: value,
TTL: d.config.TTL,
}
newRecord, _, err := d.client.CreateRecord(zone.ID, record)
if err != nil {
return fmt.Errorf("aurora: could not create record: %v", err)
}
d.recordIDsMu.Lock()
d.recordIDs[fqdn] = newRecord.ID
d.recordIDsMu.Unlock()
return nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"Present",
"(",
"domain",
",",
"token",
",",
"keyAuth",
"string",
")",
"error",
"{",
"fqdn",
",",
"value",
":=",
"dns01",
".",
"GetRecord",
"(",
"domain",
",",
"keyAuth",
")",
"\n",
"authZone",
",",
"err",
":=",
"dns01",
".",
"FindZoneByFqdn",
"(",
"dns01",
".",
"ToFqdn",
"(",
"domain",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"aurora: could not determine zone for domain: '%s'. %s\"",
",",
"domain",
",",
"err",
")",
"\n",
"}",
"\n",
"subdomain",
":=",
"fqdn",
"[",
"0",
":",
"len",
"(",
"fqdn",
")",
"-",
"len",
"(",
"authZone",
")",
"-",
"1",
"]",
"\n",
"authZone",
"=",
"dns01",
".",
"UnFqdn",
"(",
"authZone",
")",
"\n",
"zone",
",",
"err",
":=",
"d",
".",
"getZoneInformationByName",
"(",
"authZone",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"aurora: could not create record: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"record",
":=",
"auroradns",
".",
"Record",
"{",
"RecordType",
":",
"\"TXT\"",
",",
"Name",
":",
"subdomain",
",",
"Content",
":",
"value",
",",
"TTL",
":",
"d",
".",
"config",
".",
"TTL",
",",
"}",
"\n",
"newRecord",
",",
"_",
",",
"err",
":=",
"d",
".",
"client",
".",
"CreateRecord",
"(",
"zone",
".",
"ID",
",",
"record",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"aurora: could not create record: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"d",
".",
"recordIDsMu",
".",
"Lock",
"(",
")",
"\n",
"d",
".",
"recordIDs",
"[",
"fqdn",
"]",
"=",
"newRecord",
".",
"ID",
"\n",
"d",
".",
"recordIDsMu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Present creates a record with a secret
|
[
"Present",
"creates",
"a",
"record",
"with",
"a",
"secret"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/auroradns/auroradns.go#L93-L134
|
train
|
go-acme/lego
|
providers/dns/auroradns/auroradns.go
|
CleanUp
|
func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, _ := dns01.GetRecord(domain, keyAuth)
d.recordIDsMu.Lock()
recordID, ok := d.recordIDs[fqdn]
d.recordIDsMu.Unlock()
if !ok {
return fmt.Errorf("unknown recordID for %q", fqdn)
}
authZone, err := dns01.FindZoneByFqdn(dns01.ToFqdn(domain))
if err != nil {
return fmt.Errorf("could not determine zone for domain: %q. %v", domain, err)
}
authZone = dns01.UnFqdn(authZone)
zone, err := d.getZoneInformationByName(authZone)
if err != nil {
return err
}
_, _, err = d.client.DeleteRecord(zone.ID, recordID)
if err != nil {
return err
}
d.recordIDsMu.Lock()
delete(d.recordIDs, fqdn)
d.recordIDsMu.Unlock()
return nil
}
|
go
|
func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, _ := dns01.GetRecord(domain, keyAuth)
d.recordIDsMu.Lock()
recordID, ok := d.recordIDs[fqdn]
d.recordIDsMu.Unlock()
if !ok {
return fmt.Errorf("unknown recordID for %q", fqdn)
}
authZone, err := dns01.FindZoneByFqdn(dns01.ToFqdn(domain))
if err != nil {
return fmt.Errorf("could not determine zone for domain: %q. %v", domain, err)
}
authZone = dns01.UnFqdn(authZone)
zone, err := d.getZoneInformationByName(authZone)
if err != nil {
return err
}
_, _, err = d.client.DeleteRecord(zone.ID, recordID)
if err != nil {
return err
}
d.recordIDsMu.Lock()
delete(d.recordIDs, fqdn)
d.recordIDsMu.Unlock()
return nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"CleanUp",
"(",
"domain",
",",
"token",
",",
"keyAuth",
"string",
")",
"error",
"{",
"fqdn",
",",
"_",
":=",
"dns01",
".",
"GetRecord",
"(",
"domain",
",",
"keyAuth",
")",
"\n",
"d",
".",
"recordIDsMu",
".",
"Lock",
"(",
")",
"\n",
"recordID",
",",
"ok",
":=",
"d",
".",
"recordIDs",
"[",
"fqdn",
"]",
"\n",
"d",
".",
"recordIDsMu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"unknown recordID for %q\"",
",",
"fqdn",
")",
"\n",
"}",
"\n",
"authZone",
",",
"err",
":=",
"dns01",
".",
"FindZoneByFqdn",
"(",
"dns01",
".",
"ToFqdn",
"(",
"domain",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"could not determine zone for domain: %q. %v\"",
",",
"domain",
",",
"err",
")",
"\n",
"}",
"\n",
"authZone",
"=",
"dns01",
".",
"UnFqdn",
"(",
"authZone",
")",
"\n",
"zone",
",",
"err",
":=",
"d",
".",
"getZoneInformationByName",
"(",
"authZone",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"_",
",",
"err",
"=",
"d",
".",
"client",
".",
"DeleteRecord",
"(",
"zone",
".",
"ID",
",",
"recordID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"d",
".",
"recordIDsMu",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"d",
".",
"recordIDs",
",",
"fqdn",
")",
"\n",
"d",
".",
"recordIDsMu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CleanUp removes a given record that was generated by Present
|
[
"CleanUp",
"removes",
"a",
"given",
"record",
"that",
"was",
"generated",
"by",
"Present"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/auroradns/auroradns.go#L137-L170
|
train
|
go-acme/lego
|
providers/dns/namedotcom/namedotcom.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("namedotcom: the configuration of the DNS provider is nil")
}
if config.Username == "" {
return nil, fmt.Errorf("namedotcom: username is required")
}
if config.APIToken == "" {
return nil, fmt.Errorf("namedotcom: API token is required")
}
if config.TTL < minTTL {
return nil, fmt.Errorf("namedotcom: invalid TTL, TTL (%d) must be greater than %d", config.TTL, minTTL)
}
client := namecom.New(config.Username, config.APIToken)
client.Client = config.HTTPClient
if config.Server != "" {
client.Server = config.Server
}
return &DNSProvider{client: client, config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("namedotcom: the configuration of the DNS provider is nil")
}
if config.Username == "" {
return nil, fmt.Errorf("namedotcom: username is required")
}
if config.APIToken == "" {
return nil, fmt.Errorf("namedotcom: API token is required")
}
if config.TTL < minTTL {
return nil, fmt.Errorf("namedotcom: invalid TTL, TTL (%d) must be greater than %d", config.TTL, minTTL)
}
client := namecom.New(config.Username, config.APIToken)
client.Client = config.HTTPClient
if config.Server != "" {
client.Server = config.Server
}
return &DNSProvider{client: client, config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"namedotcom: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"Username",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"namedotcom: username is required\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"APIToken",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"namedotcom: API token is required\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"TTL",
"<",
"minTTL",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"namedotcom: invalid TTL, TTL (%d) must be greater than %d\"",
",",
"config",
".",
"TTL",
",",
"minTTL",
")",
"\n",
"}",
"\n",
"client",
":=",
"namecom",
".",
"New",
"(",
"config",
".",
"Username",
",",
"config",
".",
"APIToken",
")",
"\n",
"client",
".",
"Client",
"=",
"config",
".",
"HTTPClient",
"\n",
"if",
"config",
".",
"Server",
"!=",
"\"\"",
"{",
"client",
".",
"Server",
"=",
"config",
".",
"Server",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"client",
",",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for namedotcom.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"namedotcom",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/namedotcom/namedotcom.go#L66-L91
|
train
|
go-acme/lego
|
providers/dns/azure/azure.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("azure: the configuration of the DNS provider is nil")
}
if config.HTTPClient == nil {
config.HTTPClient = http.DefaultClient
}
authorizer, err := getAuthorizer(config)
if err != nil {
return nil, err
}
if config.SubscriptionID == "" {
subsID, err := getMetadata(config, "subscriptionId")
if err != nil {
return nil, fmt.Errorf("azure: %v", err)
}
if subsID == "" {
return nil, errors.New("azure: SubscriptionID is missing")
}
config.SubscriptionID = subsID
}
if config.ResourceGroup == "" {
resGroup, err := getMetadata(config, "resourceGroupName")
if err != nil {
return nil, fmt.Errorf("azure: %v", err)
}
if resGroup == "" {
return nil, errors.New("azure: ResourceGroup is missing")
}
config.ResourceGroup = resGroup
}
return &DNSProvider{config: config, authorizer: authorizer}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("azure: the configuration of the DNS provider is nil")
}
if config.HTTPClient == nil {
config.HTTPClient = http.DefaultClient
}
authorizer, err := getAuthorizer(config)
if err != nil {
return nil, err
}
if config.SubscriptionID == "" {
subsID, err := getMetadata(config, "subscriptionId")
if err != nil {
return nil, fmt.Errorf("azure: %v", err)
}
if subsID == "" {
return nil, errors.New("azure: SubscriptionID is missing")
}
config.SubscriptionID = subsID
}
if config.ResourceGroup == "" {
resGroup, err := getMetadata(config, "resourceGroupName")
if err != nil {
return nil, fmt.Errorf("azure: %v", err)
}
if resGroup == "" {
return nil, errors.New("azure: ResourceGroup is missing")
}
config.ResourceGroup = resGroup
}
return &DNSProvider{config: config, authorizer: authorizer}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"azure: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"HTTPClient",
"==",
"nil",
"{",
"config",
".",
"HTTPClient",
"=",
"http",
".",
"DefaultClient",
"\n",
"}",
"\n",
"authorizer",
",",
"err",
":=",
"getAuthorizer",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"config",
".",
"SubscriptionID",
"==",
"\"\"",
"{",
"subsID",
",",
"err",
":=",
"getMetadata",
"(",
"config",
",",
"\"subscriptionId\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"azure: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"subsID",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"azure: SubscriptionID is missing\"",
")",
"\n",
"}",
"\n",
"config",
".",
"SubscriptionID",
"=",
"subsID",
"\n",
"}",
"\n",
"if",
"config",
".",
"ResourceGroup",
"==",
"\"\"",
"{",
"resGroup",
",",
"err",
":=",
"getMetadata",
"(",
"config",
",",
"\"resourceGroupName\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"azure: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"resGroup",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"azure: ResourceGroup is missing\"",
")",
"\n",
"}",
"\n",
"config",
".",
"ResourceGroup",
"=",
"resGroup",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"authorizer",
":",
"authorizer",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for Azure.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"Azure",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/azure/azure.go#L75-L114
|
train
|
go-acme/lego
|
providers/dns/azure/azure.go
|
getHostedZoneID
|
func (d *DNSProvider) getHostedZoneID(ctx context.Context, fqdn string) (string, error) {
authZone, err := dns01.FindZoneByFqdn(fqdn)
if err != nil {
return "", err
}
dc := dns.NewZonesClient(d.config.SubscriptionID)
dc.Authorizer = d.authorizer
zone, err := dc.Get(ctx, d.config.ResourceGroup, dns01.UnFqdn(authZone))
if err != nil {
return "", err
}
// zone.Name shouldn't have a trailing dot(.)
return to.String(zone.Name), nil
}
|
go
|
func (d *DNSProvider) getHostedZoneID(ctx context.Context, fqdn string) (string, error) {
authZone, err := dns01.FindZoneByFqdn(fqdn)
if err != nil {
return "", err
}
dc := dns.NewZonesClient(d.config.SubscriptionID)
dc.Authorizer = d.authorizer
zone, err := dc.Get(ctx, d.config.ResourceGroup, dns01.UnFqdn(authZone))
if err != nil {
return "", err
}
// zone.Name shouldn't have a trailing dot(.)
return to.String(zone.Name), nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"getHostedZoneID",
"(",
"ctx",
"context",
".",
"Context",
",",
"fqdn",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"authZone",
",",
"err",
":=",
"dns01",
".",
"FindZoneByFqdn",
"(",
"fqdn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"dc",
":=",
"dns",
".",
"NewZonesClient",
"(",
"d",
".",
"config",
".",
"SubscriptionID",
")",
"\n",
"dc",
".",
"Authorizer",
"=",
"d",
".",
"authorizer",
"\n",
"zone",
",",
"err",
":=",
"dc",
".",
"Get",
"(",
"ctx",
",",
"d",
".",
"config",
".",
"ResourceGroup",
",",
"dns01",
".",
"UnFqdn",
"(",
"authZone",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"to",
".",
"String",
"(",
"zone",
".",
"Name",
")",
",",
"nil",
"\n",
"}"
] |
// Checks that azure has a zone for this domain name.
|
[
"Checks",
"that",
"azure",
"has",
"a",
"zone",
"for",
"this",
"domain",
"name",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/azure/azure.go#L199-L215
|
train
|
go-acme/lego
|
providers/dns/azure/azure.go
|
toRelativeRecord
|
func toRelativeRecord(domain, zone string) string {
return dns01.UnFqdn(strings.TrimSuffix(domain, zone))
}
|
go
|
func toRelativeRecord(domain, zone string) string {
return dns01.UnFqdn(strings.TrimSuffix(domain, zone))
}
|
[
"func",
"toRelativeRecord",
"(",
"domain",
",",
"zone",
"string",
")",
"string",
"{",
"return",
"dns01",
".",
"UnFqdn",
"(",
"strings",
".",
"TrimSuffix",
"(",
"domain",
",",
"zone",
")",
")",
"\n",
"}"
] |
// Returns the relative record to the domain
|
[
"Returns",
"the",
"relative",
"record",
"to",
"the",
"domain"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/azure/azure.go#L218-L220
|
train
|
go-acme/lego
|
acme/api/account.go
|
New
|
func (a *AccountService) New(req acme.Account) (acme.ExtendedAccount, error) {
var account acme.Account
resp, err := a.core.post(a.core.GetDirectory().NewAccountURL, req, &account)
location := getLocation(resp)
if len(location) > 0 {
a.core.jws.SetKid(location)
}
if err != nil {
return acme.ExtendedAccount{Location: location}, err
}
return acme.ExtendedAccount{Account: account, Location: location}, nil
}
|
go
|
func (a *AccountService) New(req acme.Account) (acme.ExtendedAccount, error) {
var account acme.Account
resp, err := a.core.post(a.core.GetDirectory().NewAccountURL, req, &account)
location := getLocation(resp)
if len(location) > 0 {
a.core.jws.SetKid(location)
}
if err != nil {
return acme.ExtendedAccount{Location: location}, err
}
return acme.ExtendedAccount{Account: account, Location: location}, nil
}
|
[
"func",
"(",
"a",
"*",
"AccountService",
")",
"New",
"(",
"req",
"acme",
".",
"Account",
")",
"(",
"acme",
".",
"ExtendedAccount",
",",
"error",
")",
"{",
"var",
"account",
"acme",
".",
"Account",
"\n",
"resp",
",",
"err",
":=",
"a",
".",
"core",
".",
"post",
"(",
"a",
".",
"core",
".",
"GetDirectory",
"(",
")",
".",
"NewAccountURL",
",",
"req",
",",
"&",
"account",
")",
"\n",
"location",
":=",
"getLocation",
"(",
"resp",
")",
"\n",
"if",
"len",
"(",
"location",
")",
">",
"0",
"{",
"a",
".",
"core",
".",
"jws",
".",
"SetKid",
"(",
"location",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"acme",
".",
"ExtendedAccount",
"{",
"Location",
":",
"location",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"acme",
".",
"ExtendedAccount",
"{",
"Account",
":",
"account",
",",
"Location",
":",
"location",
"}",
",",
"nil",
"\n",
"}"
] |
// New Creates a new account.
|
[
"New",
"Creates",
"a",
"new",
"account",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/account.go#L14-L28
|
train
|
go-acme/lego
|
acme/api/account.go
|
NewEAB
|
func (a *AccountService) NewEAB(accMsg acme.Account, kid string, hmacEncoded string) (acme.ExtendedAccount, error) {
hmac, err := base64.RawURLEncoding.DecodeString(hmacEncoded)
if err != nil {
return acme.ExtendedAccount{}, fmt.Errorf("acme: could not decode hmac key: %v", err)
}
eabJWS, err := a.core.signEABContent(a.core.GetDirectory().NewAccountURL, kid, hmac)
if err != nil {
return acme.ExtendedAccount{}, fmt.Errorf("acme: error signing eab content: %v", err)
}
accMsg.ExternalAccountBinding = eabJWS
return a.New(accMsg)
}
|
go
|
func (a *AccountService) NewEAB(accMsg acme.Account, kid string, hmacEncoded string) (acme.ExtendedAccount, error) {
hmac, err := base64.RawURLEncoding.DecodeString(hmacEncoded)
if err != nil {
return acme.ExtendedAccount{}, fmt.Errorf("acme: could not decode hmac key: %v", err)
}
eabJWS, err := a.core.signEABContent(a.core.GetDirectory().NewAccountURL, kid, hmac)
if err != nil {
return acme.ExtendedAccount{}, fmt.Errorf("acme: error signing eab content: %v", err)
}
accMsg.ExternalAccountBinding = eabJWS
return a.New(accMsg)
}
|
[
"func",
"(",
"a",
"*",
"AccountService",
")",
"NewEAB",
"(",
"accMsg",
"acme",
".",
"Account",
",",
"kid",
"string",
",",
"hmacEncoded",
"string",
")",
"(",
"acme",
".",
"ExtendedAccount",
",",
"error",
")",
"{",
"hmac",
",",
"err",
":=",
"base64",
".",
"RawURLEncoding",
".",
"DecodeString",
"(",
"hmacEncoded",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"acme",
".",
"ExtendedAccount",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"acme: could not decode hmac key: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"eabJWS",
",",
"err",
":=",
"a",
".",
"core",
".",
"signEABContent",
"(",
"a",
".",
"core",
".",
"GetDirectory",
"(",
")",
".",
"NewAccountURL",
",",
"kid",
",",
"hmac",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"acme",
".",
"ExtendedAccount",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"acme: error signing eab content: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"accMsg",
".",
"ExternalAccountBinding",
"=",
"eabJWS",
"\n",
"return",
"a",
".",
"New",
"(",
"accMsg",
")",
"\n",
"}"
] |
// NewEAB Creates a new account with an External Account Binding.
|
[
"NewEAB",
"Creates",
"a",
"new",
"account",
"with",
"an",
"External",
"Account",
"Binding",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/account.go#L31-L44
|
train
|
go-acme/lego
|
acme/api/account.go
|
Get
|
func (a *AccountService) Get(accountURL string) (acme.Account, error) {
if len(accountURL) == 0 {
return acme.Account{}, errors.New("account[get]: empty URL")
}
var account acme.Account
_, err := a.core.post(accountURL, acme.Account{}, &account)
if err != nil {
return acme.Account{}, err
}
return account, nil
}
|
go
|
func (a *AccountService) Get(accountURL string) (acme.Account, error) {
if len(accountURL) == 0 {
return acme.Account{}, errors.New("account[get]: empty URL")
}
var account acme.Account
_, err := a.core.post(accountURL, acme.Account{}, &account)
if err != nil {
return acme.Account{}, err
}
return account, nil
}
|
[
"func",
"(",
"a",
"*",
"AccountService",
")",
"Get",
"(",
"accountURL",
"string",
")",
"(",
"acme",
".",
"Account",
",",
"error",
")",
"{",
"if",
"len",
"(",
"accountURL",
")",
"==",
"0",
"{",
"return",
"acme",
".",
"Account",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"account[get]: empty URL\"",
")",
"\n",
"}",
"\n",
"var",
"account",
"acme",
".",
"Account",
"\n",
"_",
",",
"err",
":=",
"a",
".",
"core",
".",
"post",
"(",
"accountURL",
",",
"acme",
".",
"Account",
"{",
"}",
",",
"&",
"account",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"acme",
".",
"Account",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"account",
",",
"nil",
"\n",
"}"
] |
// Get Retrieves an account.
|
[
"Get",
"Retrieves",
"an",
"account",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/account.go#L47-L58
|
train
|
go-acme/lego
|
acme/api/account.go
|
Deactivate
|
func (a *AccountService) Deactivate(accountURL string) error {
if len(accountURL) == 0 {
return errors.New("account[deactivate]: empty URL")
}
req := acme.Account{Status: acme.StatusDeactivated}
_, err := a.core.post(accountURL, req, nil)
return err
}
|
go
|
func (a *AccountService) Deactivate(accountURL string) error {
if len(accountURL) == 0 {
return errors.New("account[deactivate]: empty URL")
}
req := acme.Account{Status: acme.StatusDeactivated}
_, err := a.core.post(accountURL, req, nil)
return err
}
|
[
"func",
"(",
"a",
"*",
"AccountService",
")",
"Deactivate",
"(",
"accountURL",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"accountURL",
")",
"==",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"account[deactivate]: empty URL\"",
")",
"\n",
"}",
"\n",
"req",
":=",
"acme",
".",
"Account",
"{",
"Status",
":",
"acme",
".",
"StatusDeactivated",
"}",
"\n",
"_",
",",
"err",
":=",
"a",
".",
"core",
".",
"post",
"(",
"accountURL",
",",
"req",
",",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Deactivate Deactivates an account.
|
[
"Deactivate",
"Deactivates",
"an",
"account",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/account.go#L61-L69
|
train
|
go-acme/lego
|
acme/api/certificate.go
|
Get
|
func (c *CertificateService) Get(certURL string, bundle bool) ([]byte, []byte, error) {
cert, up, err := c.get(certURL)
if err != nil {
return nil, nil, err
}
// Get issuerCert from bundled response from Let's Encrypt
// See https://community.letsencrypt.org/t/acme-v2-no-up-link-in-response/64962
_, issuer := pem.Decode(cert)
if issuer != nil {
return cert, issuer, nil
}
issuer, err = c.getIssuerFromLink(up)
if err != nil {
// If we fail to acquire the issuer cert, return the issued certificate - do not fail.
log.Warnf("acme: Could not bundle issuer certificate [%s]: %v", certURL, err)
} else if len(issuer) > 0 {
// If bundle is true, we want to return a certificate bundle.
// To do this, we append the issuer cert to the issued cert.
if bundle {
cert = append(cert, issuer...)
}
}
return cert, issuer, nil
}
|
go
|
func (c *CertificateService) Get(certURL string, bundle bool) ([]byte, []byte, error) {
cert, up, err := c.get(certURL)
if err != nil {
return nil, nil, err
}
// Get issuerCert from bundled response from Let's Encrypt
// See https://community.letsencrypt.org/t/acme-v2-no-up-link-in-response/64962
_, issuer := pem.Decode(cert)
if issuer != nil {
return cert, issuer, nil
}
issuer, err = c.getIssuerFromLink(up)
if err != nil {
// If we fail to acquire the issuer cert, return the issued certificate - do not fail.
log.Warnf("acme: Could not bundle issuer certificate [%s]: %v", certURL, err)
} else if len(issuer) > 0 {
// If bundle is true, we want to return a certificate bundle.
// To do this, we append the issuer cert to the issued cert.
if bundle {
cert = append(cert, issuer...)
}
}
return cert, issuer, nil
}
|
[
"func",
"(",
"c",
"*",
"CertificateService",
")",
"Get",
"(",
"certURL",
"string",
",",
"bundle",
"bool",
")",
"(",
"[",
"]",
"byte",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cert",
",",
"up",
",",
"err",
":=",
"c",
".",
"get",
"(",
"certURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"issuer",
":=",
"pem",
".",
"Decode",
"(",
"cert",
")",
"\n",
"if",
"issuer",
"!=",
"nil",
"{",
"return",
"cert",
",",
"issuer",
",",
"nil",
"\n",
"}",
"\n",
"issuer",
",",
"err",
"=",
"c",
".",
"getIssuerFromLink",
"(",
"up",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"acme: Could not bundle issuer certificate [%s]: %v\"",
",",
"certURL",
",",
"err",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"issuer",
")",
">",
"0",
"{",
"if",
"bundle",
"{",
"cert",
"=",
"append",
"(",
"cert",
",",
"issuer",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"cert",
",",
"issuer",
",",
"nil",
"\n",
"}"
] |
// Get Returns the certificate and the issuer certificate.
// 'bundle' is only applied if the issuer is provided by the 'up' link.
|
[
"Get",
"Returns",
"the",
"certificate",
"and",
"the",
"issuer",
"certificate",
".",
"bundle",
"is",
"only",
"applied",
"if",
"the",
"issuer",
"is",
"provided",
"by",
"the",
"up",
"link",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/certificate.go#L22-L48
|
train
|
go-acme/lego
|
acme/api/certificate.go
|
Revoke
|
func (c *CertificateService) Revoke(req acme.RevokeCertMessage) error {
_, err := c.core.post(c.core.GetDirectory().RevokeCertURL, req, nil)
return err
}
|
go
|
func (c *CertificateService) Revoke(req acme.RevokeCertMessage) error {
_, err := c.core.post(c.core.GetDirectory().RevokeCertURL, req, nil)
return err
}
|
[
"func",
"(",
"c",
"*",
"CertificateService",
")",
"Revoke",
"(",
"req",
"acme",
".",
"RevokeCertMessage",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"core",
".",
"post",
"(",
"c",
".",
"core",
".",
"GetDirectory",
"(",
")",
".",
"RevokeCertURL",
",",
"req",
",",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Revoke Revokes a certificate.
|
[
"Revoke",
"Revokes",
"a",
"certificate",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/certificate.go#L51-L54
|
train
|
go-acme/lego
|
acme/api/certificate.go
|
get
|
func (c *CertificateService) get(certURL string) ([]byte, string, error) {
if len(certURL) == 0 {
return nil, "", errors.New("certificate[get]: empty URL")
}
resp, err := c.core.postAsGet(certURL, nil)
if err != nil {
return nil, "", err
}
cert, err := ioutil.ReadAll(http.MaxBytesReader(nil, resp.Body, maxBodySize))
if err != nil {
return nil, "", err
}
// The issuer certificate link may be supplied via an "up" link
// in the response headers of a new certificate.
// See https://tools.ietf.org/html/draft-ietf-acme-acme-12#section-7.4.2
up := getLink(resp.Header, "up")
return cert, up, err
}
|
go
|
func (c *CertificateService) get(certURL string) ([]byte, string, error) {
if len(certURL) == 0 {
return nil, "", errors.New("certificate[get]: empty URL")
}
resp, err := c.core.postAsGet(certURL, nil)
if err != nil {
return nil, "", err
}
cert, err := ioutil.ReadAll(http.MaxBytesReader(nil, resp.Body, maxBodySize))
if err != nil {
return nil, "", err
}
// The issuer certificate link may be supplied via an "up" link
// in the response headers of a new certificate.
// See https://tools.ietf.org/html/draft-ietf-acme-acme-12#section-7.4.2
up := getLink(resp.Header, "up")
return cert, up, err
}
|
[
"func",
"(",
"c",
"*",
"CertificateService",
")",
"get",
"(",
"certURL",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"string",
",",
"error",
")",
"{",
"if",
"len",
"(",
"certURL",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"\"\"",
",",
"errors",
".",
"New",
"(",
"\"certificate[get]: empty URL\"",
")",
"\n",
"}",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"core",
".",
"postAsGet",
"(",
"certURL",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"cert",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"http",
".",
"MaxBytesReader",
"(",
"nil",
",",
"resp",
".",
"Body",
",",
"maxBodySize",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"up",
":=",
"getLink",
"(",
"resp",
".",
"Header",
",",
"\"up\"",
")",
"\n",
"return",
"cert",
",",
"up",
",",
"err",
"\n",
"}"
] |
// get Returns the certificate and the "up" link.
|
[
"get",
"Returns",
"the",
"certificate",
"and",
"the",
"up",
"link",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/certificate.go#L57-L78
|
train
|
go-acme/lego
|
acme/api/certificate.go
|
getIssuerFromLink
|
func (c *CertificateService) getIssuerFromLink(up string) ([]byte, error) {
if len(up) == 0 {
return nil, nil
}
log.Infof("acme: Requesting issuer cert from %s", up)
cert, _, err := c.get(up)
if err != nil {
return nil, err
}
_, err = x509.ParseCertificate(cert)
if err != nil {
return nil, err
}
return certcrypto.PEMEncode(certcrypto.DERCertificateBytes(cert)), nil
}
|
go
|
func (c *CertificateService) getIssuerFromLink(up string) ([]byte, error) {
if len(up) == 0 {
return nil, nil
}
log.Infof("acme: Requesting issuer cert from %s", up)
cert, _, err := c.get(up)
if err != nil {
return nil, err
}
_, err = x509.ParseCertificate(cert)
if err != nil {
return nil, err
}
return certcrypto.PEMEncode(certcrypto.DERCertificateBytes(cert)), nil
}
|
[
"func",
"(",
"c",
"*",
"CertificateService",
")",
"getIssuerFromLink",
"(",
"up",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"up",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"acme: Requesting issuer cert from %s\"",
",",
"up",
")",
"\n",
"cert",
",",
"_",
",",
"err",
":=",
"c",
".",
"get",
"(",
"up",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"x509",
".",
"ParseCertificate",
"(",
"cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"certcrypto",
".",
"PEMEncode",
"(",
"certcrypto",
".",
"DERCertificateBytes",
"(",
"cert",
")",
")",
",",
"nil",
"\n",
"}"
] |
// getIssuerFromLink requests the issuer certificate
|
[
"getIssuerFromLink",
"requests",
"the",
"issuer",
"certificate"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/certificate.go#L81-L99
|
train
|
go-acme/lego
|
providers/dns/cloudns/cloudns.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("ClouDNS: the configuration of the DNS provider is nil")
}
client, err := internal.NewClient(config.AuthID, config.AuthPassword)
if err != nil {
return nil, fmt.Errorf("ClouDNS: %v", err)
}
client.HTTPClient = config.HTTPClient
return &DNSProvider{client: client, config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("ClouDNS: the configuration of the DNS provider is nil")
}
client, err := internal.NewClient(config.AuthID, config.AuthPassword)
if err != nil {
return nil, fmt.Errorf("ClouDNS: %v", err)
}
client.HTTPClient = config.HTTPClient
return &DNSProvider{client: client, config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"ClouDNS: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"internal",
".",
"NewClient",
"(",
"config",
".",
"AuthID",
",",
"config",
".",
"AuthPassword",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"ClouDNS: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"client",
".",
"HTTPClient",
"=",
"config",
".",
"HTTPClient",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"client",
",",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for ClouDNS.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"ClouDNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/cloudns/cloudns.go#L60-L73
|
train
|
go-acme/lego
|
providers/dns/vscale/vscale.go
|
NewDefaultConfig
|
func NewDefaultConfig() *Config {
return &Config{
BaseURL: env.GetOrDefaultString(baseURLEnvVar, defaultBaseURL),
TTL: env.GetOrDefaultInt(ttlEnvVar, minTTL),
PropagationTimeout: env.GetOrDefaultSecond(propagationTimeoutEnvVar, 120*time.Second),
PollingInterval: env.GetOrDefaultSecond(pollingIntervalEnvVar, 2*time.Second),
HTTPClient: &http.Client{
Timeout: env.GetOrDefaultSecond(httpTimeoutEnvVar, 30*time.Second),
},
}
}
|
go
|
func NewDefaultConfig() *Config {
return &Config{
BaseURL: env.GetOrDefaultString(baseURLEnvVar, defaultBaseURL),
TTL: env.GetOrDefaultInt(ttlEnvVar, minTTL),
PropagationTimeout: env.GetOrDefaultSecond(propagationTimeoutEnvVar, 120*time.Second),
PollingInterval: env.GetOrDefaultSecond(pollingIntervalEnvVar, 2*time.Second),
HTTPClient: &http.Client{
Timeout: env.GetOrDefaultSecond(httpTimeoutEnvVar, 30*time.Second),
},
}
}
|
[
"func",
"NewDefaultConfig",
"(",
")",
"*",
"Config",
"{",
"return",
"&",
"Config",
"{",
"BaseURL",
":",
"env",
".",
"GetOrDefaultString",
"(",
"baseURLEnvVar",
",",
"defaultBaseURL",
")",
",",
"TTL",
":",
"env",
".",
"GetOrDefaultInt",
"(",
"ttlEnvVar",
",",
"minTTL",
")",
",",
"PropagationTimeout",
":",
"env",
".",
"GetOrDefaultSecond",
"(",
"propagationTimeoutEnvVar",
",",
"120",
"*",
"time",
".",
"Second",
")",
",",
"PollingInterval",
":",
"env",
".",
"GetOrDefaultSecond",
"(",
"pollingIntervalEnvVar",
",",
"2",
"*",
"time",
".",
"Second",
")",
",",
"HTTPClient",
":",
"&",
"http",
".",
"Client",
"{",
"Timeout",
":",
"env",
".",
"GetOrDefaultSecond",
"(",
"httpTimeoutEnvVar",
",",
"30",
"*",
"time",
".",
"Second",
")",
",",
"}",
",",
"}",
"\n",
"}"
] |
// NewDefaultConfig returns a default configuration for the DNSProvider.
|
[
"NewDefaultConfig",
"returns",
"a",
"default",
"configuration",
"for",
"the",
"DNSProvider",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/vscale/vscale.go#L44-L54
|
train
|
go-acme/lego
|
providers/dns/vscale/vscale.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("vscale: the configuration of the DNS provider is nil")
}
if config.Token == "" {
return nil, errors.New("vscale: credentials missing")
}
if config.TTL < minTTL {
return nil, fmt.Errorf("vscale: invalid TTL, TTL (%d) must be greater than %d", config.TTL, minTTL)
}
client := internal.NewClient(internal.ClientOpts{
BaseURL: config.BaseURL,
Token: config.Token,
HTTPClient: config.HTTPClient,
})
return &DNSProvider{config: config, client: client}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("vscale: the configuration of the DNS provider is nil")
}
if config.Token == "" {
return nil, errors.New("vscale: credentials missing")
}
if config.TTL < minTTL {
return nil, fmt.Errorf("vscale: invalid TTL, TTL (%d) must be greater than %d", config.TTL, minTTL)
}
client := internal.NewClient(internal.ClientOpts{
BaseURL: config.BaseURL,
Token: config.Token,
HTTPClient: config.HTTPClient,
})
return &DNSProvider{config: config, client: client}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"vscale: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"Token",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"vscale: credentials missing\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"TTL",
"<",
"minTTL",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"vscale: invalid TTL, TTL (%d) must be greater than %d\"",
",",
"config",
".",
"TTL",
",",
"minTTL",
")",
"\n",
"}",
"\n",
"client",
":=",
"internal",
".",
"NewClient",
"(",
"internal",
".",
"ClientOpts",
"{",
"BaseURL",
":",
"config",
".",
"BaseURL",
",",
"Token",
":",
"config",
".",
"Token",
",",
"HTTPClient",
":",
"config",
".",
"HTTPClient",
",",
"}",
")",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"client",
":",
"client",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for Vscale.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"Vscale",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/vscale/vscale.go#L77-L97
|
train
|
go-acme/lego
|
providers/dns/vscale/vscale.go
|
Present
|
func (d *DNSProvider) Present(domain, token, keyAuth string) error {
fqdn, value := dns01.GetRecord(domain, keyAuth)
domainObj, err := d.client.GetDomainByName(domain)
if err != nil {
return fmt.Errorf("vscale: %v", err)
}
txtRecord := internal.Record{
Type: "TXT",
TTL: d.config.TTL,
Name: fqdn,
Content: value,
}
_, err = d.client.AddRecord(domainObj.ID, txtRecord)
if err != nil {
return fmt.Errorf("vscale: %v", err)
}
return nil
}
|
go
|
func (d *DNSProvider) Present(domain, token, keyAuth string) error {
fqdn, value := dns01.GetRecord(domain, keyAuth)
domainObj, err := d.client.GetDomainByName(domain)
if err != nil {
return fmt.Errorf("vscale: %v", err)
}
txtRecord := internal.Record{
Type: "TXT",
TTL: d.config.TTL,
Name: fqdn,
Content: value,
}
_, err = d.client.AddRecord(domainObj.ID, txtRecord)
if err != nil {
return fmt.Errorf("vscale: %v", err)
}
return nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"Present",
"(",
"domain",
",",
"token",
",",
"keyAuth",
"string",
")",
"error",
"{",
"fqdn",
",",
"value",
":=",
"dns01",
".",
"GetRecord",
"(",
"domain",
",",
"keyAuth",
")",
"\n",
"domainObj",
",",
"err",
":=",
"d",
".",
"client",
".",
"GetDomainByName",
"(",
"domain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"vscale: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"txtRecord",
":=",
"internal",
".",
"Record",
"{",
"Type",
":",
"\"TXT\"",
",",
"TTL",
":",
"d",
".",
"config",
".",
"TTL",
",",
"Name",
":",
"fqdn",
",",
"Content",
":",
"value",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"d",
".",
"client",
".",
"AddRecord",
"(",
"domainObj",
".",
"ID",
",",
"txtRecord",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"vscale: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Present creates a TXT record to fulfill DNS-01 challenge.
|
[
"Present",
"creates",
"a",
"TXT",
"record",
"to",
"fulfill",
"DNS",
"-",
"01",
"challenge",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/vscale/vscale.go#L106-L126
|
train
|
go-acme/lego
|
providers/dns/vscale/vscale.go
|
CleanUp
|
func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, _ := dns01.GetRecord(domain, keyAuth)
recordName := dns01.UnFqdn(fqdn)
domainObj, err := d.client.GetDomainByName(domain)
if err != nil {
return fmt.Errorf("vscale: %v", err)
}
records, err := d.client.ListRecords(domainObj.ID)
if err != nil {
return fmt.Errorf("vscale: %v", err)
}
// Delete records with specific FQDN
var lastErr error
for _, record := range records {
if record.Name == recordName {
err = d.client.DeleteRecord(domainObj.ID, record.ID)
if err != nil {
lastErr = fmt.Errorf("vscale: %v", err)
}
}
}
return lastErr
}
|
go
|
func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, _ := dns01.GetRecord(domain, keyAuth)
recordName := dns01.UnFqdn(fqdn)
domainObj, err := d.client.GetDomainByName(domain)
if err != nil {
return fmt.Errorf("vscale: %v", err)
}
records, err := d.client.ListRecords(domainObj.ID)
if err != nil {
return fmt.Errorf("vscale: %v", err)
}
// Delete records with specific FQDN
var lastErr error
for _, record := range records {
if record.Name == recordName {
err = d.client.DeleteRecord(domainObj.ID, record.ID)
if err != nil {
lastErr = fmt.Errorf("vscale: %v", err)
}
}
}
return lastErr
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"CleanUp",
"(",
"domain",
",",
"token",
",",
"keyAuth",
"string",
")",
"error",
"{",
"fqdn",
",",
"_",
":=",
"dns01",
".",
"GetRecord",
"(",
"domain",
",",
"keyAuth",
")",
"\n",
"recordName",
":=",
"dns01",
".",
"UnFqdn",
"(",
"fqdn",
")",
"\n",
"domainObj",
",",
"err",
":=",
"d",
".",
"client",
".",
"GetDomainByName",
"(",
"domain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"vscale: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"records",
",",
"err",
":=",
"d",
".",
"client",
".",
"ListRecords",
"(",
"domainObj",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"vscale: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"lastErr",
"error",
"\n",
"for",
"_",
",",
"record",
":=",
"range",
"records",
"{",
"if",
"record",
".",
"Name",
"==",
"recordName",
"{",
"err",
"=",
"d",
".",
"client",
".",
"DeleteRecord",
"(",
"domainObj",
".",
"ID",
",",
"record",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"lastErr",
"=",
"fmt",
".",
"Errorf",
"(",
"\"vscale: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"lastErr",
"\n",
"}"
] |
// CleanUp removes a TXT record used for DNS-01 challenge.
|
[
"CleanUp",
"removes",
"a",
"TXT",
"record",
"used",
"for",
"DNS",
"-",
"01",
"challenge",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/vscale/vscale.go#L129-L155
|
train
|
go-acme/lego
|
providers/dns/alidns/alidns.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("alicloud: the configuration of the DNS provider is nil")
}
if config.APIKey == "" || config.SecretKey == "" {
return nil, fmt.Errorf("alicloud: credentials missing")
}
if len(config.RegionID) == 0 {
config.RegionID = defaultRegionID
}
conf := sdk.NewConfig().WithTimeout(config.HTTPTimeout)
credential := credentials.NewAccessKeyCredential(config.APIKey, config.SecretKey)
client, err := alidns.NewClientWithOptions(config.RegionID, conf, credential)
if err != nil {
return nil, fmt.Errorf("alicloud: credentials failed: %v", err)
}
return &DNSProvider{config: config, client: client}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("alicloud: the configuration of the DNS provider is nil")
}
if config.APIKey == "" || config.SecretKey == "" {
return nil, fmt.Errorf("alicloud: credentials missing")
}
if len(config.RegionID) == 0 {
config.RegionID = defaultRegionID
}
conf := sdk.NewConfig().WithTimeout(config.HTTPTimeout)
credential := credentials.NewAccessKeyCredential(config.APIKey, config.SecretKey)
client, err := alidns.NewClientWithOptions(config.RegionID, conf, credential)
if err != nil {
return nil, fmt.Errorf("alicloud: credentials failed: %v", err)
}
return &DNSProvider{config: config, client: client}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"alicloud: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"APIKey",
"==",
"\"\"",
"||",
"config",
".",
"SecretKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"alicloud: credentials missing\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"RegionID",
")",
"==",
"0",
"{",
"config",
".",
"RegionID",
"=",
"defaultRegionID",
"\n",
"}",
"\n",
"conf",
":=",
"sdk",
".",
"NewConfig",
"(",
")",
".",
"WithTimeout",
"(",
"config",
".",
"HTTPTimeout",
")",
"\n",
"credential",
":=",
"credentials",
".",
"NewAccessKeyCredential",
"(",
"config",
".",
"APIKey",
",",
"config",
".",
"SecretKey",
")",
"\n",
"client",
",",
"err",
":=",
"alidns",
".",
"NewClientWithOptions",
"(",
"config",
".",
"RegionID",
",",
"conf",
",",
"credential",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"alicloud: credentials failed: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"client",
":",
"client",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for alidns.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"alidns",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/alidns/alidns.go#L64-L86
|
train
|
go-acme/lego
|
providers/dns/cloudxns/cloudxns.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("CloudXNS: the configuration of the DNS provider is nil")
}
client, err := internal.NewClient(config.APIKey, config.SecretKey)
if err != nil {
return nil, err
}
client.HTTPClient = config.HTTPClient
return &DNSProvider{client: client, config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("CloudXNS: the configuration of the DNS provider is nil")
}
client, err := internal.NewClient(config.APIKey, config.SecretKey)
if err != nil {
return nil, err
}
client.HTTPClient = config.HTTPClient
return &DNSProvider{client: client, config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"CloudXNS: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"internal",
".",
"NewClient",
"(",
"config",
".",
"APIKey",
",",
"config",
".",
"SecretKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"client",
".",
"HTTPClient",
"=",
"config",
".",
"HTTPClient",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"client",
",",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for CloudXNS.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"CloudXNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/cloudxns/cloudxns.go#L60-L73
|
train
|
go-acme/lego
|
acme/api/internal/nonces/nonce_manager.go
|
NewManager
|
func NewManager(do *sender.Doer, nonceURL string) *Manager {
return &Manager{
do: do,
nonceURL: nonceURL,
}
}
|
go
|
func NewManager(do *sender.Doer, nonceURL string) *Manager {
return &Manager{
do: do,
nonceURL: nonceURL,
}
}
|
[
"func",
"NewManager",
"(",
"do",
"*",
"sender",
".",
"Doer",
",",
"nonceURL",
"string",
")",
"*",
"Manager",
"{",
"return",
"&",
"Manager",
"{",
"do",
":",
"do",
",",
"nonceURL",
":",
"nonceURL",
",",
"}",
"\n",
"}"
] |
// NewManager Creates a new Manager.
|
[
"NewManager",
"Creates",
"a",
"new",
"Manager",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/nonces/nonce_manager.go#L21-L26
|
train
|
go-acme/lego
|
acme/api/internal/nonces/nonce_manager.go
|
Pop
|
func (n *Manager) Pop() (string, bool) {
n.Lock()
defer n.Unlock()
if len(n.nonces) == 0 {
return "", false
}
nonce := n.nonces[len(n.nonces)-1]
n.nonces = n.nonces[:len(n.nonces)-1]
return nonce, true
}
|
go
|
func (n *Manager) Pop() (string, bool) {
n.Lock()
defer n.Unlock()
if len(n.nonces) == 0 {
return "", false
}
nonce := n.nonces[len(n.nonces)-1]
n.nonces = n.nonces[:len(n.nonces)-1]
return nonce, true
}
|
[
"func",
"(",
"n",
"*",
"Manager",
")",
"Pop",
"(",
")",
"(",
"string",
",",
"bool",
")",
"{",
"n",
".",
"Lock",
"(",
")",
"\n",
"defer",
"n",
".",
"Unlock",
"(",
")",
"\n",
"if",
"len",
"(",
"n",
".",
"nonces",
")",
"==",
"0",
"{",
"return",
"\"\"",
",",
"false",
"\n",
"}",
"\n",
"nonce",
":=",
"n",
".",
"nonces",
"[",
"len",
"(",
"n",
".",
"nonces",
")",
"-",
"1",
"]",
"\n",
"n",
".",
"nonces",
"=",
"n",
".",
"nonces",
"[",
":",
"len",
"(",
"n",
".",
"nonces",
")",
"-",
"1",
"]",
"\n",
"return",
"nonce",
",",
"true",
"\n",
"}"
] |
// Pop Pops a nonce.
|
[
"Pop",
"Pops",
"a",
"nonce",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/nonces/nonce_manager.go#L29-L40
|
train
|
go-acme/lego
|
acme/api/internal/nonces/nonce_manager.go
|
Push
|
func (n *Manager) Push(nonce string) {
n.Lock()
defer n.Unlock()
n.nonces = append(n.nonces, nonce)
}
|
go
|
func (n *Manager) Push(nonce string) {
n.Lock()
defer n.Unlock()
n.nonces = append(n.nonces, nonce)
}
|
[
"func",
"(",
"n",
"*",
"Manager",
")",
"Push",
"(",
"nonce",
"string",
")",
"{",
"n",
".",
"Lock",
"(",
")",
"\n",
"defer",
"n",
".",
"Unlock",
"(",
")",
"\n",
"n",
".",
"nonces",
"=",
"append",
"(",
"n",
".",
"nonces",
",",
"nonce",
")",
"\n",
"}"
] |
// Push Pushes a nonce.
|
[
"Push",
"Pushes",
"a",
"nonce",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/nonces/nonce_manager.go#L43-L47
|
train
|
go-acme/lego
|
acme/api/internal/nonces/nonce_manager.go
|
Nonce
|
func (n *Manager) Nonce() (string, error) {
if nonce, ok := n.Pop(); ok {
return nonce, nil
}
return n.getNonce()
}
|
go
|
func (n *Manager) Nonce() (string, error) {
if nonce, ok := n.Pop(); ok {
return nonce, nil
}
return n.getNonce()
}
|
[
"func",
"(",
"n",
"*",
"Manager",
")",
"Nonce",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"nonce",
",",
"ok",
":=",
"n",
".",
"Pop",
"(",
")",
";",
"ok",
"{",
"return",
"nonce",
",",
"nil",
"\n",
"}",
"\n",
"return",
"n",
".",
"getNonce",
"(",
")",
"\n",
"}"
] |
// Nonce implement jose.NonceSource
|
[
"Nonce",
"implement",
"jose",
".",
"NonceSource"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/nonces/nonce_manager.go#L50-L55
|
train
|
go-acme/lego
|
acme/api/internal/nonces/nonce_manager.go
|
GetFromResponse
|
func GetFromResponse(resp *http.Response) (string, error) {
if resp == nil {
return "", errors.New("nil response")
}
nonce := resp.Header.Get("Replay-Nonce")
if nonce == "" {
return "", fmt.Errorf("server did not respond with a proper nonce header")
}
return nonce, nil
}
|
go
|
func GetFromResponse(resp *http.Response) (string, error) {
if resp == nil {
return "", errors.New("nil response")
}
nonce := resp.Header.Get("Replay-Nonce")
if nonce == "" {
return "", fmt.Errorf("server did not respond with a proper nonce header")
}
return nonce, nil
}
|
[
"func",
"GetFromResponse",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"resp",
"==",
"nil",
"{",
"return",
"\"\"",
",",
"errors",
".",
"New",
"(",
"\"nil response\"",
")",
"\n",
"}",
"\n",
"nonce",
":=",
"resp",
".",
"Header",
".",
"Get",
"(",
"\"Replay-Nonce\"",
")",
"\n",
"if",
"nonce",
"==",
"\"\"",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"server did not respond with a proper nonce header\"",
")",
"\n",
"}",
"\n",
"return",
"nonce",
",",
"nil",
"\n",
"}"
] |
// GetFromResponse Extracts a nonce from a HTTP response.
|
[
"GetFromResponse",
"Extracts",
"a",
"nonce",
"from",
"a",
"HTTP",
"response",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/internal/nonces/nonce_manager.go#L67-L78
|
train
|
go-acme/lego
|
providers/dns/acmedns/acmedns.go
|
NewDNSProvider
|
func NewDNSProvider() (*DNSProvider, error) {
values, err := env.Get(apiBaseEnvVar, storagePathEnvVar)
if err != nil {
return nil, fmt.Errorf("acme-dns: %v", err)
}
client := goacmedns.NewClient(values[apiBaseEnvVar])
storage := goacmedns.NewFileStorage(values[storagePathEnvVar], 0600)
return NewDNSProviderClient(client, storage)
}
|
go
|
func NewDNSProvider() (*DNSProvider, error) {
values, err := env.Get(apiBaseEnvVar, storagePathEnvVar)
if err != nil {
return nil, fmt.Errorf("acme-dns: %v", err)
}
client := goacmedns.NewClient(values[apiBaseEnvVar])
storage := goacmedns.NewFileStorage(values[storagePathEnvVar], 0600)
return NewDNSProviderClient(client, storage)
}
|
[
"func",
"NewDNSProvider",
"(",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"values",
",",
"err",
":=",
"env",
".",
"Get",
"(",
"apiBaseEnvVar",
",",
"storagePathEnvVar",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"acme-dns: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"client",
":=",
"goacmedns",
".",
"NewClient",
"(",
"values",
"[",
"apiBaseEnvVar",
"]",
")",
"\n",
"storage",
":=",
"goacmedns",
".",
"NewFileStorage",
"(",
"values",
"[",
"storagePathEnvVar",
"]",
",",
"0600",
")",
"\n",
"return",
"NewDNSProviderClient",
"(",
"client",
",",
"storage",
")",
"\n",
"}"
] |
// NewDNSProvider creates an ACME-DNS provider using file based account storage.
// Its configuration is loaded from the environment by reading apiBaseEnvVar and storagePathEnvVar.
|
[
"NewDNSProvider",
"creates",
"an",
"ACME",
"-",
"DNS",
"provider",
"using",
"file",
"based",
"account",
"storage",
".",
"Its",
"configuration",
"is",
"loaded",
"from",
"the",
"environment",
"by",
"reading",
"apiBaseEnvVar",
"and",
"storagePathEnvVar",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/acmedns/acmedns.go#L45-L54
|
train
|
go-acme/lego
|
providers/dns/acmedns/acmedns.go
|
NewDNSProviderClient
|
func NewDNSProviderClient(client acmeDNSClient, storage goacmedns.Storage) (*DNSProvider, error) {
if client == nil {
return nil, errors.New("ACME-DNS Client must be not nil")
}
if storage == nil {
return nil, errors.New("ACME-DNS Storage must be not nil")
}
return &DNSProvider{
client: client,
storage: storage,
}, nil
}
|
go
|
func NewDNSProviderClient(client acmeDNSClient, storage goacmedns.Storage) (*DNSProvider, error) {
if client == nil {
return nil, errors.New("ACME-DNS Client must be not nil")
}
if storage == nil {
return nil, errors.New("ACME-DNS Storage must be not nil")
}
return &DNSProvider{
client: client,
storage: storage,
}, nil
}
|
[
"func",
"NewDNSProviderClient",
"(",
"client",
"acmeDNSClient",
",",
"storage",
"goacmedns",
".",
"Storage",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"client",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"ACME-DNS Client must be not nil\"",
")",
"\n",
"}",
"\n",
"if",
"storage",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"ACME-DNS Storage must be not nil\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"client",
",",
"storage",
":",
"storage",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderClient creates an ACME-DNS DNSProvider with the given acmeDNSClient and goacmedns.Storage.
|
[
"NewDNSProviderClient",
"creates",
"an",
"ACME",
"-",
"DNS",
"DNSProvider",
"with",
"the",
"given",
"acmeDNSClient",
"and",
"goacmedns",
".",
"Storage",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/acmedns/acmedns.go#L57-L70
|
train
|
go-acme/lego
|
providers/dns/acmedns/acmedns.go
|
Present
|
func (d *DNSProvider) Present(domain, _, keyAuth string) error {
// Compute the challenge response FQDN and TXT value for the domain based
// on the keyAuth.
fqdn, value := dns01.GetRecord(domain, keyAuth)
// Check if credentials were previously saved for this domain.
account, err := d.storage.Fetch(domain)
// Errors other than goacmeDNS.ErrDomainNotFound are unexpected.
if err != nil && err != goacmedns.ErrDomainNotFound {
return err
}
if err == goacmedns.ErrDomainNotFound {
// The account did not exist. Create a new one and return an error
// indicating the required one-time manual CNAME setup.
return d.register(domain, fqdn)
}
// Update the acme-dns TXT record.
return d.client.UpdateTXTRecord(account, value)
}
|
go
|
func (d *DNSProvider) Present(domain, _, keyAuth string) error {
// Compute the challenge response FQDN and TXT value for the domain based
// on the keyAuth.
fqdn, value := dns01.GetRecord(domain, keyAuth)
// Check if credentials were previously saved for this domain.
account, err := d.storage.Fetch(domain)
// Errors other than goacmeDNS.ErrDomainNotFound are unexpected.
if err != nil && err != goacmedns.ErrDomainNotFound {
return err
}
if err == goacmedns.ErrDomainNotFound {
// The account did not exist. Create a new one and return an error
// indicating the required one-time manual CNAME setup.
return d.register(domain, fqdn)
}
// Update the acme-dns TXT record.
return d.client.UpdateTXTRecord(account, value)
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"Present",
"(",
"domain",
",",
"_",
",",
"keyAuth",
"string",
")",
"error",
"{",
"fqdn",
",",
"value",
":=",
"dns01",
".",
"GetRecord",
"(",
"domain",
",",
"keyAuth",
")",
"\n",
"account",
",",
"err",
":=",
"d",
".",
"storage",
".",
"Fetch",
"(",
"domain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"goacmedns",
".",
"ErrDomainNotFound",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"==",
"goacmedns",
".",
"ErrDomainNotFound",
"{",
"return",
"d",
".",
"register",
"(",
"domain",
",",
"fqdn",
")",
"\n",
"}",
"\n",
"return",
"d",
".",
"client",
".",
"UpdateTXTRecord",
"(",
"account",
",",
"value",
")",
"\n",
"}"
] |
// Present creates a TXT record to fulfill the DNS-01 challenge.
// If there is an existing account for the domain in the provider's storage
// then it will be used to set the challenge response TXT record with the ACME-DNS server and issuance will continue.
// If there is not an account for the given domain present in the DNSProvider storage
// one will be created and registered with the ACME DNS server and an ErrCNAMERequired error is returned.
// This will halt issuance and indicate to the user that a one-time manual setup is required for the domain.
|
[
"Present",
"creates",
"a",
"TXT",
"record",
"to",
"fulfill",
"the",
"DNS",
"-",
"01",
"challenge",
".",
"If",
"there",
"is",
"an",
"existing",
"account",
"for",
"the",
"domain",
"in",
"the",
"provider",
"s",
"storage",
"then",
"it",
"will",
"be",
"used",
"to",
"set",
"the",
"challenge",
"response",
"TXT",
"record",
"with",
"the",
"ACME",
"-",
"DNS",
"server",
"and",
"issuance",
"will",
"continue",
".",
"If",
"there",
"is",
"not",
"an",
"account",
"for",
"the",
"given",
"domain",
"present",
"in",
"the",
"DNSProvider",
"storage",
"one",
"will",
"be",
"created",
"and",
"registered",
"with",
"the",
"ACME",
"DNS",
"server",
"and",
"an",
"ErrCNAMERequired",
"error",
"is",
"returned",
".",
"This",
"will",
"halt",
"issuance",
"and",
"indicate",
"to",
"the",
"user",
"that",
"a",
"one",
"-",
"time",
"manual",
"setup",
"is",
"required",
"for",
"the",
"domain",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/acmedns/acmedns.go#L104-L123
|
train
|
go-acme/lego
|
providers/dns/acmedns/acmedns.go
|
register
|
func (d *DNSProvider) register(domain, fqdn string) error {
// TODO(@cpu): Read CIDR whitelists from the environment
newAcct, err := d.client.RegisterAccount(nil)
if err != nil {
return err
}
// Store the new account in the storage and call save to persist the data.
err = d.storage.Put(domain, newAcct)
if err != nil {
return err
}
err = d.storage.Save()
if err != nil {
return err
}
// Stop issuance by returning an error.
// The user needs to perform a manual one-time CNAME setup in their DNS zone
// to complete the setup of the new account we created.
return ErrCNAMERequired{
Domain: domain,
FQDN: fqdn,
Target: newAcct.FullDomain,
}
}
|
go
|
func (d *DNSProvider) register(domain, fqdn string) error {
// TODO(@cpu): Read CIDR whitelists from the environment
newAcct, err := d.client.RegisterAccount(nil)
if err != nil {
return err
}
// Store the new account in the storage and call save to persist the data.
err = d.storage.Put(domain, newAcct)
if err != nil {
return err
}
err = d.storage.Save()
if err != nil {
return err
}
// Stop issuance by returning an error.
// The user needs to perform a manual one-time CNAME setup in their DNS zone
// to complete the setup of the new account we created.
return ErrCNAMERequired{
Domain: domain,
FQDN: fqdn,
Target: newAcct.FullDomain,
}
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"register",
"(",
"domain",
",",
"fqdn",
"string",
")",
"error",
"{",
"newAcct",
",",
"err",
":=",
"d",
".",
"client",
".",
"RegisterAccount",
"(",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"d",
".",
"storage",
".",
"Put",
"(",
"domain",
",",
"newAcct",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"d",
".",
"storage",
".",
"Save",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"ErrCNAMERequired",
"{",
"Domain",
":",
"domain",
",",
"FQDN",
":",
"fqdn",
",",
"Target",
":",
"newAcct",
".",
"FullDomain",
",",
"}",
"\n",
"}"
] |
// register creates a new ACME-DNS account for the given domain.
// If account creation works as expected a ErrCNAMERequired error is returned describing
// the one-time manual CNAME setup required to complete setup of the ACME-DNS hook for the domain.
// If any other error occurs it is returned as-is.
|
[
"register",
"creates",
"a",
"new",
"ACME",
"-",
"DNS",
"account",
"for",
"the",
"given",
"domain",
".",
"If",
"account",
"creation",
"works",
"as",
"expected",
"a",
"ErrCNAMERequired",
"error",
"is",
"returned",
"describing",
"the",
"one",
"-",
"time",
"manual",
"CNAME",
"setup",
"required",
"to",
"complete",
"setup",
"of",
"the",
"ACME",
"-",
"DNS",
"hook",
"for",
"the",
"domain",
".",
"If",
"any",
"other",
"error",
"occurs",
"it",
"is",
"returned",
"as",
"-",
"is",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/acmedns/acmedns.go#L137-L162
|
train
|
go-acme/lego
|
registration/registar.go
|
Register
|
func (r *Registrar) Register(options RegisterOptions) (*Resource, error) {
if r == nil || r.user == nil {
return nil, errors.New("acme: cannot register a nil client or user")
}
accMsg := acme.Account{
TermsOfServiceAgreed: options.TermsOfServiceAgreed,
Contact: []string{},
}
if r.user.GetEmail() != "" {
log.Infof("acme: Registering account for %s", r.user.GetEmail())
accMsg.Contact = []string{"mailto:" + r.user.GetEmail()}
}
account, err := r.core.Accounts.New(accMsg)
if err != nil {
// FIXME seems impossible
errorDetails, ok := err.(acme.ProblemDetails)
if !ok || errorDetails.HTTPStatus != http.StatusConflict {
return nil, err
}
}
return &Resource{URI: account.Location, Body: account.Account}, nil
}
|
go
|
func (r *Registrar) Register(options RegisterOptions) (*Resource, error) {
if r == nil || r.user == nil {
return nil, errors.New("acme: cannot register a nil client or user")
}
accMsg := acme.Account{
TermsOfServiceAgreed: options.TermsOfServiceAgreed,
Contact: []string{},
}
if r.user.GetEmail() != "" {
log.Infof("acme: Registering account for %s", r.user.GetEmail())
accMsg.Contact = []string{"mailto:" + r.user.GetEmail()}
}
account, err := r.core.Accounts.New(accMsg)
if err != nil {
// FIXME seems impossible
errorDetails, ok := err.(acme.ProblemDetails)
if !ok || errorDetails.HTTPStatus != http.StatusConflict {
return nil, err
}
}
return &Resource{URI: account.Location, Body: account.Account}, nil
}
|
[
"func",
"(",
"r",
"*",
"Registrar",
")",
"Register",
"(",
"options",
"RegisterOptions",
")",
"(",
"*",
"Resource",
",",
"error",
")",
"{",
"if",
"r",
"==",
"nil",
"||",
"r",
".",
"user",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"acme: cannot register a nil client or user\"",
")",
"\n",
"}",
"\n",
"accMsg",
":=",
"acme",
".",
"Account",
"{",
"TermsOfServiceAgreed",
":",
"options",
".",
"TermsOfServiceAgreed",
",",
"Contact",
":",
"[",
"]",
"string",
"{",
"}",
",",
"}",
"\n",
"if",
"r",
".",
"user",
".",
"GetEmail",
"(",
")",
"!=",
"\"\"",
"{",
"log",
".",
"Infof",
"(",
"\"acme: Registering account for %s\"",
",",
"r",
".",
"user",
".",
"GetEmail",
"(",
")",
")",
"\n",
"accMsg",
".",
"Contact",
"=",
"[",
"]",
"string",
"{",
"\"mailto:\"",
"+",
"r",
".",
"user",
".",
"GetEmail",
"(",
")",
"}",
"\n",
"}",
"\n",
"account",
",",
"err",
":=",
"r",
".",
"core",
".",
"Accounts",
".",
"New",
"(",
"accMsg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errorDetails",
",",
"ok",
":=",
"err",
".",
"(",
"acme",
".",
"ProblemDetails",
")",
"\n",
"if",
"!",
"ok",
"||",
"errorDetails",
".",
"HTTPStatus",
"!=",
"http",
".",
"StatusConflict",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"Resource",
"{",
"URI",
":",
"account",
".",
"Location",
",",
"Body",
":",
"account",
".",
"Account",
"}",
",",
"nil",
"\n",
"}"
] |
// Register the current account to the ACME server.
|
[
"Register",
"the",
"current",
"account",
"to",
"the",
"ACME",
"server",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/registration/registar.go#L43-L68
|
train
|
go-acme/lego
|
registration/registar.go
|
RegisterWithExternalAccountBinding
|
func (r *Registrar) RegisterWithExternalAccountBinding(options RegisterEABOptions) (*Resource, error) {
accMsg := acme.Account{
TermsOfServiceAgreed: options.TermsOfServiceAgreed,
Contact: []string{},
}
if r.user.GetEmail() != "" {
log.Infof("acme: Registering account for %s", r.user.GetEmail())
accMsg.Contact = []string{"mailto:" + r.user.GetEmail()}
}
account, err := r.core.Accounts.NewEAB(accMsg, options.Kid, options.HmacEncoded)
if err != nil {
errorDetails, ok := err.(acme.ProblemDetails)
// FIXME seems impossible
if !ok || errorDetails.HTTPStatus != http.StatusConflict {
return nil, err
}
}
return &Resource{URI: account.Location, Body: account.Account}, nil
}
|
go
|
func (r *Registrar) RegisterWithExternalAccountBinding(options RegisterEABOptions) (*Resource, error) {
accMsg := acme.Account{
TermsOfServiceAgreed: options.TermsOfServiceAgreed,
Contact: []string{},
}
if r.user.GetEmail() != "" {
log.Infof("acme: Registering account for %s", r.user.GetEmail())
accMsg.Contact = []string{"mailto:" + r.user.GetEmail()}
}
account, err := r.core.Accounts.NewEAB(accMsg, options.Kid, options.HmacEncoded)
if err != nil {
errorDetails, ok := err.(acme.ProblemDetails)
// FIXME seems impossible
if !ok || errorDetails.HTTPStatus != http.StatusConflict {
return nil, err
}
}
return &Resource{URI: account.Location, Body: account.Account}, nil
}
|
[
"func",
"(",
"r",
"*",
"Registrar",
")",
"RegisterWithExternalAccountBinding",
"(",
"options",
"RegisterEABOptions",
")",
"(",
"*",
"Resource",
",",
"error",
")",
"{",
"accMsg",
":=",
"acme",
".",
"Account",
"{",
"TermsOfServiceAgreed",
":",
"options",
".",
"TermsOfServiceAgreed",
",",
"Contact",
":",
"[",
"]",
"string",
"{",
"}",
",",
"}",
"\n",
"if",
"r",
".",
"user",
".",
"GetEmail",
"(",
")",
"!=",
"\"\"",
"{",
"log",
".",
"Infof",
"(",
"\"acme: Registering account for %s\"",
",",
"r",
".",
"user",
".",
"GetEmail",
"(",
")",
")",
"\n",
"accMsg",
".",
"Contact",
"=",
"[",
"]",
"string",
"{",
"\"mailto:\"",
"+",
"r",
".",
"user",
".",
"GetEmail",
"(",
")",
"}",
"\n",
"}",
"\n",
"account",
",",
"err",
":=",
"r",
".",
"core",
".",
"Accounts",
".",
"NewEAB",
"(",
"accMsg",
",",
"options",
".",
"Kid",
",",
"options",
".",
"HmacEncoded",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errorDetails",
",",
"ok",
":=",
"err",
".",
"(",
"acme",
".",
"ProblemDetails",
")",
"\n",
"if",
"!",
"ok",
"||",
"errorDetails",
".",
"HTTPStatus",
"!=",
"http",
".",
"StatusConflict",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"Resource",
"{",
"URI",
":",
"account",
".",
"Location",
",",
"Body",
":",
"account",
".",
"Account",
"}",
",",
"nil",
"\n",
"}"
] |
// RegisterWithExternalAccountBinding Register the current account to the ACME server.
|
[
"RegisterWithExternalAccountBinding",
"Register",
"the",
"current",
"account",
"to",
"the",
"ACME",
"server",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/registration/registar.go#L71-L92
|
train
|
go-acme/lego
|
registration/registar.go
|
QueryRegistration
|
func (r *Registrar) QueryRegistration() (*Resource, error) {
if r == nil || r.user == nil {
return nil, errors.New("acme: cannot query the registration of a nil client or user")
}
// Log the URL here instead of the email as the email may not be set
log.Infof("acme: Querying account for %s", r.user.GetRegistration().URI)
account, err := r.core.Accounts.Get(r.user.GetRegistration().URI)
if err != nil {
return nil, err
}
return &Resource{
Body: account,
// Location: header is not returned so this needs to be populated off of existing URI
URI: r.user.GetRegistration().URI,
}, nil
}
|
go
|
func (r *Registrar) QueryRegistration() (*Resource, error) {
if r == nil || r.user == nil {
return nil, errors.New("acme: cannot query the registration of a nil client or user")
}
// Log the URL here instead of the email as the email may not be set
log.Infof("acme: Querying account for %s", r.user.GetRegistration().URI)
account, err := r.core.Accounts.Get(r.user.GetRegistration().URI)
if err != nil {
return nil, err
}
return &Resource{
Body: account,
// Location: header is not returned so this needs to be populated off of existing URI
URI: r.user.GetRegistration().URI,
}, nil
}
|
[
"func",
"(",
"r",
"*",
"Registrar",
")",
"QueryRegistration",
"(",
")",
"(",
"*",
"Resource",
",",
"error",
")",
"{",
"if",
"r",
"==",
"nil",
"||",
"r",
".",
"user",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"acme: cannot query the registration of a nil client or user\"",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"acme: Querying account for %s\"",
",",
"r",
".",
"user",
".",
"GetRegistration",
"(",
")",
".",
"URI",
")",
"\n",
"account",
",",
"err",
":=",
"r",
".",
"core",
".",
"Accounts",
".",
"Get",
"(",
"r",
".",
"user",
".",
"GetRegistration",
"(",
")",
".",
"URI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Resource",
"{",
"Body",
":",
"account",
",",
"URI",
":",
"r",
".",
"user",
".",
"GetRegistration",
"(",
")",
".",
"URI",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// QueryRegistration runs a POST request on the client's registration and returns the result.
//
// This is similar to the Register function,
// but acting on an existing registration link and resource.
|
[
"QueryRegistration",
"runs",
"a",
"POST",
"request",
"on",
"the",
"client",
"s",
"registration",
"and",
"returns",
"the",
"result",
".",
"This",
"is",
"similar",
"to",
"the",
"Register",
"function",
"but",
"acting",
"on",
"an",
"existing",
"registration",
"link",
"and",
"resource",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/registration/registar.go#L98-L116
|
train
|
go-acme/lego
|
registration/registar.go
|
DeleteRegistration
|
func (r *Registrar) DeleteRegistration() error {
if r == nil || r.user == nil {
return errors.New("acme: cannot unregister a nil client or user")
}
log.Infof("acme: Deleting account for %s", r.user.GetEmail())
return r.core.Accounts.Deactivate(r.user.GetRegistration().URI)
}
|
go
|
func (r *Registrar) DeleteRegistration() error {
if r == nil || r.user == nil {
return errors.New("acme: cannot unregister a nil client or user")
}
log.Infof("acme: Deleting account for %s", r.user.GetEmail())
return r.core.Accounts.Deactivate(r.user.GetRegistration().URI)
}
|
[
"func",
"(",
"r",
"*",
"Registrar",
")",
"DeleteRegistration",
"(",
")",
"error",
"{",
"if",
"r",
"==",
"nil",
"||",
"r",
".",
"user",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"acme: cannot unregister a nil client or user\"",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"acme: Deleting account for %s\"",
",",
"r",
".",
"user",
".",
"GetEmail",
"(",
")",
")",
"\n",
"return",
"r",
".",
"core",
".",
"Accounts",
".",
"Deactivate",
"(",
"r",
".",
"user",
".",
"GetRegistration",
"(",
")",
".",
"URI",
")",
"\n",
"}"
] |
// DeleteRegistration deletes the client's user registration from the ACME server.
|
[
"DeleteRegistration",
"deletes",
"the",
"client",
"s",
"user",
"registration",
"from",
"the",
"ACME",
"server",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/registration/registar.go#L119-L127
|
train
|
go-acme/lego
|
registration/registar.go
|
ResolveAccountByKey
|
func (r *Registrar) ResolveAccountByKey() (*Resource, error) {
log.Infof("acme: Trying to resolve account by key")
accMsg := acme.Account{OnlyReturnExisting: true}
accountTransit, err := r.core.Accounts.New(accMsg)
if err != nil {
return nil, err
}
account, err := r.core.Accounts.Get(accountTransit.Location)
if err != nil {
return nil, err
}
return &Resource{URI: accountTransit.Location, Body: account}, nil
}
|
go
|
func (r *Registrar) ResolveAccountByKey() (*Resource, error) {
log.Infof("acme: Trying to resolve account by key")
accMsg := acme.Account{OnlyReturnExisting: true}
accountTransit, err := r.core.Accounts.New(accMsg)
if err != nil {
return nil, err
}
account, err := r.core.Accounts.Get(accountTransit.Location)
if err != nil {
return nil, err
}
return &Resource{URI: accountTransit.Location, Body: account}, nil
}
|
[
"func",
"(",
"r",
"*",
"Registrar",
")",
"ResolveAccountByKey",
"(",
")",
"(",
"*",
"Resource",
",",
"error",
")",
"{",
"log",
".",
"Infof",
"(",
"\"acme: Trying to resolve account by key\"",
")",
"\n",
"accMsg",
":=",
"acme",
".",
"Account",
"{",
"OnlyReturnExisting",
":",
"true",
"}",
"\n",
"accountTransit",
",",
"err",
":=",
"r",
".",
"core",
".",
"Accounts",
".",
"New",
"(",
"accMsg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"account",
",",
"err",
":=",
"r",
".",
"core",
".",
"Accounts",
".",
"Get",
"(",
"accountTransit",
".",
"Location",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Resource",
"{",
"URI",
":",
"accountTransit",
".",
"Location",
",",
"Body",
":",
"account",
"}",
",",
"nil",
"\n",
"}"
] |
// ResolveAccountByKey will attempt to look up an account using the given account key
// and return its registration resource.
|
[
"ResolveAccountByKey",
"will",
"attempt",
"to",
"look",
"up",
"an",
"account",
"using",
"the",
"given",
"account",
"key",
"and",
"return",
"its",
"registration",
"resource",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/registration/registar.go#L131-L146
|
train
|
go-acme/lego
|
challenge/resolver/solver_manager.go
|
SetHTTP01Provider
|
func (c *SolverManager) SetHTTP01Provider(p challenge.Provider) error {
c.solvers[challenge.HTTP01] = http01.NewChallenge(c.core, validate, p)
return nil
}
|
go
|
func (c *SolverManager) SetHTTP01Provider(p challenge.Provider) error {
c.solvers[challenge.HTTP01] = http01.NewChallenge(c.core, validate, p)
return nil
}
|
[
"func",
"(",
"c",
"*",
"SolverManager",
")",
"SetHTTP01Provider",
"(",
"p",
"challenge",
".",
"Provider",
")",
"error",
"{",
"c",
".",
"solvers",
"[",
"challenge",
".",
"HTTP01",
"]",
"=",
"http01",
".",
"NewChallenge",
"(",
"c",
".",
"core",
",",
"validate",
",",
"p",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SetHTTP01Provider specifies a custom provider p that can solve the given HTTP-01 challenge.
|
[
"SetHTTP01Provider",
"specifies",
"a",
"custom",
"provider",
"p",
"that",
"can",
"solve",
"the",
"given",
"HTTP",
"-",
"01",
"challenge",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/challenge/resolver/solver_manager.go#L40-L43
|
train
|
go-acme/lego
|
challenge/resolver/solver_manager.go
|
SetTLSALPN01Provider
|
func (c *SolverManager) SetTLSALPN01Provider(p challenge.Provider) error {
c.solvers[challenge.TLSALPN01] = tlsalpn01.NewChallenge(c.core, validate, p)
return nil
}
|
go
|
func (c *SolverManager) SetTLSALPN01Provider(p challenge.Provider) error {
c.solvers[challenge.TLSALPN01] = tlsalpn01.NewChallenge(c.core, validate, p)
return nil
}
|
[
"func",
"(",
"c",
"*",
"SolverManager",
")",
"SetTLSALPN01Provider",
"(",
"p",
"challenge",
".",
"Provider",
")",
"error",
"{",
"c",
".",
"solvers",
"[",
"challenge",
".",
"TLSALPN01",
"]",
"=",
"tlsalpn01",
".",
"NewChallenge",
"(",
"c",
".",
"core",
",",
"validate",
",",
"p",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SetTLSALPN01Provider specifies a custom provider p that can solve the given TLS-ALPN-01 challenge.
|
[
"SetTLSALPN01Provider",
"specifies",
"a",
"custom",
"provider",
"p",
"that",
"can",
"solve",
"the",
"given",
"TLS",
"-",
"ALPN",
"-",
"01",
"challenge",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/challenge/resolver/solver_manager.go#L46-L49
|
train
|
go-acme/lego
|
challenge/resolver/solver_manager.go
|
SetDNS01Provider
|
func (c *SolverManager) SetDNS01Provider(p challenge.Provider, opts ...dns01.ChallengeOption) error {
c.solvers[challenge.DNS01] = dns01.NewChallenge(c.core, validate, p, opts...)
return nil
}
|
go
|
func (c *SolverManager) SetDNS01Provider(p challenge.Provider, opts ...dns01.ChallengeOption) error {
c.solvers[challenge.DNS01] = dns01.NewChallenge(c.core, validate, p, opts...)
return nil
}
|
[
"func",
"(",
"c",
"*",
"SolverManager",
")",
"SetDNS01Provider",
"(",
"p",
"challenge",
".",
"Provider",
",",
"opts",
"...",
"dns01",
".",
"ChallengeOption",
")",
"error",
"{",
"c",
".",
"solvers",
"[",
"challenge",
".",
"DNS01",
"]",
"=",
"dns01",
".",
"NewChallenge",
"(",
"c",
".",
"core",
",",
"validate",
",",
"p",
",",
"opts",
"...",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SetDNS01Provider specifies a custom provider p that can solve the given DNS-01 challenge.
|
[
"SetDNS01Provider",
"specifies",
"a",
"custom",
"provider",
"p",
"that",
"can",
"solve",
"the",
"given",
"DNS",
"-",
"01",
"challenge",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/challenge/resolver/solver_manager.go#L52-L55
|
train
|
go-acme/lego
|
challenge/resolver/solver_manager.go
|
Remove
|
func (c *SolverManager) Remove(chlgType challenge.Type) {
delete(c.solvers, chlgType)
}
|
go
|
func (c *SolverManager) Remove(chlgType challenge.Type) {
delete(c.solvers, chlgType)
}
|
[
"func",
"(",
"c",
"*",
"SolverManager",
")",
"Remove",
"(",
"chlgType",
"challenge",
".",
"Type",
")",
"{",
"delete",
"(",
"c",
".",
"solvers",
",",
"chlgType",
")",
"\n",
"}"
] |
// Remove Remove a challenge type from the available solvers.
|
[
"Remove",
"Remove",
"a",
"challenge",
"type",
"from",
"the",
"available",
"solvers",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/challenge/resolver/solver_manager.go#L58-L60
|
train
|
go-acme/lego
|
challenge/resolver/solver_manager.go
|
chooseSolver
|
func (c *SolverManager) chooseSolver(authz acme.Authorization) solver {
// Allow to have a deterministic challenge order
sort.Sort(byType(authz.Challenges))
domain := challenge.GetTargetedDomain(authz)
for _, chlg := range authz.Challenges {
if solvr, ok := c.solvers[challenge.Type(chlg.Type)]; ok {
log.Infof("[%s] acme: use %s solver", domain, chlg.Type)
return solvr
}
log.Infof("[%s] acme: Could not find solver for: %s", domain, chlg.Type)
}
return nil
}
|
go
|
func (c *SolverManager) chooseSolver(authz acme.Authorization) solver {
// Allow to have a deterministic challenge order
sort.Sort(byType(authz.Challenges))
domain := challenge.GetTargetedDomain(authz)
for _, chlg := range authz.Challenges {
if solvr, ok := c.solvers[challenge.Type(chlg.Type)]; ok {
log.Infof("[%s] acme: use %s solver", domain, chlg.Type)
return solvr
}
log.Infof("[%s] acme: Could not find solver for: %s", domain, chlg.Type)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"SolverManager",
")",
"chooseSolver",
"(",
"authz",
"acme",
".",
"Authorization",
")",
"solver",
"{",
"sort",
".",
"Sort",
"(",
"byType",
"(",
"authz",
".",
"Challenges",
")",
")",
"\n",
"domain",
":=",
"challenge",
".",
"GetTargetedDomain",
"(",
"authz",
")",
"\n",
"for",
"_",
",",
"chlg",
":=",
"range",
"authz",
".",
"Challenges",
"{",
"if",
"solvr",
",",
"ok",
":=",
"c",
".",
"solvers",
"[",
"challenge",
".",
"Type",
"(",
"chlg",
".",
"Type",
")",
"]",
";",
"ok",
"{",
"log",
".",
"Infof",
"(",
"\"[%s] acme: use %s solver\"",
",",
"domain",
",",
"chlg",
".",
"Type",
")",
"\n",
"return",
"solvr",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"[%s] acme: Could not find solver for: %s\"",
",",
"domain",
",",
"chlg",
".",
"Type",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Checks all challenges from the server in order and returns the first matching solver.
|
[
"Checks",
"all",
"challenges",
"from",
"the",
"server",
"in",
"order",
"and",
"returns",
"the",
"first",
"matching",
"solver",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/challenge/resolver/solver_manager.go#L63-L77
|
train
|
go-acme/lego
|
providers/dns/nifcloud/nifcloud.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("nifcloud: the configuration of the DNS provider is nil")
}
client, err := internal.NewClient(config.AccessKey, config.SecretKey)
if err != nil {
return nil, fmt.Errorf("nifcloud: %v", err)
}
if config.HTTPClient != nil {
client.HTTPClient = config.HTTPClient
}
if len(config.BaseURL) > 0 {
client.BaseURL = config.BaseURL
}
return &DNSProvider{client: client, config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("nifcloud: the configuration of the DNS provider is nil")
}
client, err := internal.NewClient(config.AccessKey, config.SecretKey)
if err != nil {
return nil, fmt.Errorf("nifcloud: %v", err)
}
if config.HTTPClient != nil {
client.HTTPClient = config.HTTPClient
}
if len(config.BaseURL) > 0 {
client.BaseURL = config.BaseURL
}
return &DNSProvider{client: client, config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"nifcloud: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"internal",
".",
"NewClient",
"(",
"config",
".",
"AccessKey",
",",
"config",
".",
"SecretKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"nifcloud: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"HTTPClient",
"!=",
"nil",
"{",
"client",
".",
"HTTPClient",
"=",
"config",
".",
"HTTPClient",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"BaseURL",
")",
">",
"0",
"{",
"client",
".",
"BaseURL",
"=",
"config",
".",
"BaseURL",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"client",
",",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for NIFCLOUD.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"NIFCLOUD",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/nifcloud/nifcloud.go#L64-L83
|
train
|
go-acme/lego
|
providers/dns/otc/otc.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("otc: the configuration of the DNS provider is nil")
}
if config.DomainName == "" || config.UserName == "" || config.Password == "" || config.ProjectName == "" {
return nil, fmt.Errorf("otc: credentials missing")
}
if config.TTL < minTTL {
return nil, fmt.Errorf("otc: invalid TTL, TTL (%d) must be greater than %d", config.TTL, minTTL)
}
if config.IdentityEndpoint == "" {
config.IdentityEndpoint = defaultIdentityEndpoint
}
return &DNSProvider{config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("otc: the configuration of the DNS provider is nil")
}
if config.DomainName == "" || config.UserName == "" || config.Password == "" || config.ProjectName == "" {
return nil, fmt.Errorf("otc: credentials missing")
}
if config.TTL < minTTL {
return nil, fmt.Errorf("otc: invalid TTL, TTL (%d) must be greater than %d", config.TTL, minTTL)
}
if config.IdentityEndpoint == "" {
config.IdentityEndpoint = defaultIdentityEndpoint
}
return &DNSProvider{config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"otc: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"DomainName",
"==",
"\"\"",
"||",
"config",
".",
"UserName",
"==",
"\"\"",
"||",
"config",
".",
"Password",
"==",
"\"\"",
"||",
"config",
".",
"ProjectName",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"otc: credentials missing\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"TTL",
"<",
"minTTL",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"otc: invalid TTL, TTL (%d) must be greater than %d\"",
",",
"config",
".",
"TTL",
",",
"minTTL",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"IdentityEndpoint",
"==",
"\"\"",
"{",
"config",
".",
"IdentityEndpoint",
"=",
"defaultIdentityEndpoint",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for OTC DNS.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"OTC",
"DNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/otc/otc.go#L88-L106
|
train
|
go-acme/lego
|
providers/dns/mydnsjp/mydnsjp.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("mydnsjp: the configuration of the DNS provider is nil")
}
if config.MasterID == "" || config.Password == "" {
return nil, errors.New("mydnsjp: some credentials information are missing")
}
return &DNSProvider{config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("mydnsjp: the configuration of the DNS provider is nil")
}
if config.MasterID == "" || config.Password == "" {
return nil, errors.New("mydnsjp: some credentials information are missing")
}
return &DNSProvider{config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"mydnsjp: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"MasterID",
"==",
"\"\"",
"||",
"config",
".",
"Password",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"mydnsjp: some credentials information are missing\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for MyDNS.jp.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"MyDNS",
".",
"jp",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/mydnsjp/mydnsjp.go#L57-L67
|
train
|
go-acme/lego
|
certcrypto/crypto.go
|
ParsePEMBundle
|
func ParsePEMBundle(bundle []byte) ([]*x509.Certificate, error) {
var certificates []*x509.Certificate
var certDERBlock *pem.Block
for {
certDERBlock, bundle = pem.Decode(bundle)
if certDERBlock == nil {
break
}
if certDERBlock.Type == "CERTIFICATE" {
cert, err := x509.ParseCertificate(certDERBlock.Bytes)
if err != nil {
return nil, err
}
certificates = append(certificates, cert)
}
}
if len(certificates) == 0 {
return nil, errors.New("no certificates were found while parsing the bundle")
}
return certificates, nil
}
|
go
|
func ParsePEMBundle(bundle []byte) ([]*x509.Certificate, error) {
var certificates []*x509.Certificate
var certDERBlock *pem.Block
for {
certDERBlock, bundle = pem.Decode(bundle)
if certDERBlock == nil {
break
}
if certDERBlock.Type == "CERTIFICATE" {
cert, err := x509.ParseCertificate(certDERBlock.Bytes)
if err != nil {
return nil, err
}
certificates = append(certificates, cert)
}
}
if len(certificates) == 0 {
return nil, errors.New("no certificates were found while parsing the bundle")
}
return certificates, nil
}
|
[
"func",
"ParsePEMBundle",
"(",
"bundle",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"*",
"x509",
".",
"Certificate",
",",
"error",
")",
"{",
"var",
"certificates",
"[",
"]",
"*",
"x509",
".",
"Certificate",
"\n",
"var",
"certDERBlock",
"*",
"pem",
".",
"Block",
"\n",
"for",
"{",
"certDERBlock",
",",
"bundle",
"=",
"pem",
".",
"Decode",
"(",
"bundle",
")",
"\n",
"if",
"certDERBlock",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"if",
"certDERBlock",
".",
"Type",
"==",
"\"CERTIFICATE\"",
"{",
"cert",
",",
"err",
":=",
"x509",
".",
"ParseCertificate",
"(",
"certDERBlock",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"certificates",
"=",
"append",
"(",
"certificates",
",",
"cert",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"certificates",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"no certificates were found while parsing the bundle\"",
")",
"\n",
"}",
"\n",
"return",
"certificates",
",",
"nil",
"\n",
"}"
] |
// ParsePEMBundle parses a certificate bundle from top to bottom and returns
// a slice of x509 certificates. This function will error if no certificates are found.
|
[
"ParsePEMBundle",
"parses",
"a",
"certificate",
"bundle",
"from",
"top",
"to",
"bottom",
"and",
"returns",
"a",
"slice",
"of",
"x509",
"certificates",
".",
"This",
"function",
"will",
"error",
"if",
"no",
"certificates",
"are",
"found",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/certcrypto/crypto.go#L54-L78
|
train
|
go-acme/lego
|
certcrypto/crypto.go
|
ParsePEMCertificate
|
func ParsePEMCertificate(cert []byte) (*x509.Certificate, error) {
pemBlock, err := pemDecode(cert)
if pemBlock == nil {
return nil, err
}
// from a DER encoded certificate
return x509.ParseCertificate(pemBlock.Bytes)
}
|
go
|
func ParsePEMCertificate(cert []byte) (*x509.Certificate, error) {
pemBlock, err := pemDecode(cert)
if pemBlock == nil {
return nil, err
}
// from a DER encoded certificate
return x509.ParseCertificate(pemBlock.Bytes)
}
|
[
"func",
"ParsePEMCertificate",
"(",
"cert",
"[",
"]",
"byte",
")",
"(",
"*",
"x509",
".",
"Certificate",
",",
"error",
")",
"{",
"pemBlock",
",",
"err",
":=",
"pemDecode",
"(",
"cert",
")",
"\n",
"if",
"pemBlock",
"==",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"x509",
".",
"ParseCertificate",
"(",
"pemBlock",
".",
"Bytes",
")",
"\n",
"}"
] |
// ParsePEMCertificate returns Certificate from a PEM encoded certificate.
// The certificate has to be PEM encoded. Any other encodings like DER will fail.
|
[
"ParsePEMCertificate",
"returns",
"Certificate",
"from",
"a",
"PEM",
"encoded",
"certificate",
".",
"The",
"certificate",
"has",
"to",
"be",
"PEM",
"encoded",
".",
"Any",
"other",
"encodings",
"like",
"DER",
"will",
"fail",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/certcrypto/crypto.go#L171-L179
|
train
|
go-acme/lego
|
acme/api/challenge.go
|
New
|
func (c *ChallengeService) New(chlgURL string) (acme.ExtendedChallenge, error) {
if len(chlgURL) == 0 {
return acme.ExtendedChallenge{}, errors.New("challenge[new]: empty URL")
}
// Challenge initiation is done by sending a JWS payload containing the trivial JSON object `{}`.
// We use an empty struct instance as the postJSON payload here to achieve this result.
var chlng acme.ExtendedChallenge
resp, err := c.core.post(chlgURL, struct{}{}, &chlng)
if err != nil {
return acme.ExtendedChallenge{}, err
}
chlng.AuthorizationURL = getLink(resp.Header, "up")
chlng.RetryAfter = getRetryAfter(resp)
return chlng, nil
}
|
go
|
func (c *ChallengeService) New(chlgURL string) (acme.ExtendedChallenge, error) {
if len(chlgURL) == 0 {
return acme.ExtendedChallenge{}, errors.New("challenge[new]: empty URL")
}
// Challenge initiation is done by sending a JWS payload containing the trivial JSON object `{}`.
// We use an empty struct instance as the postJSON payload here to achieve this result.
var chlng acme.ExtendedChallenge
resp, err := c.core.post(chlgURL, struct{}{}, &chlng)
if err != nil {
return acme.ExtendedChallenge{}, err
}
chlng.AuthorizationURL = getLink(resp.Header, "up")
chlng.RetryAfter = getRetryAfter(resp)
return chlng, nil
}
|
[
"func",
"(",
"c",
"*",
"ChallengeService",
")",
"New",
"(",
"chlgURL",
"string",
")",
"(",
"acme",
".",
"ExtendedChallenge",
",",
"error",
")",
"{",
"if",
"len",
"(",
"chlgURL",
")",
"==",
"0",
"{",
"return",
"acme",
".",
"ExtendedChallenge",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"challenge[new]: empty URL\"",
")",
"\n",
"}",
"\n",
"var",
"chlng",
"acme",
".",
"ExtendedChallenge",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"core",
".",
"post",
"(",
"chlgURL",
",",
"struct",
"{",
"}",
"{",
"}",
",",
"&",
"chlng",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"acme",
".",
"ExtendedChallenge",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"chlng",
".",
"AuthorizationURL",
"=",
"getLink",
"(",
"resp",
".",
"Header",
",",
"\"up\"",
")",
"\n",
"chlng",
".",
"RetryAfter",
"=",
"getRetryAfter",
"(",
"resp",
")",
"\n",
"return",
"chlng",
",",
"nil",
"\n",
"}"
] |
// New Creates a challenge.
|
[
"New",
"Creates",
"a",
"challenge",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/challenge.go#L12-L28
|
train
|
go-acme/lego
|
providers/dns/lightsail/lightsail.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("lightsail: the configuration of the DNS provider is nil")
}
retryer := customRetryer{}
retryer.NumMaxRetries = maxRetries
conf := aws.NewConfig().WithRegion(config.Region)
sess, err := session.NewSession(request.WithRetryer(conf, retryer))
if err != nil {
return nil, err
}
return &DNSProvider{
config: config,
client: lightsail.New(sess),
}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("lightsail: the configuration of the DNS provider is nil")
}
retryer := customRetryer{}
retryer.NumMaxRetries = maxRetries
conf := aws.NewConfig().WithRegion(config.Region)
sess, err := session.NewSession(request.WithRetryer(conf, retryer))
if err != nil {
return nil, err
}
return &DNSProvider{
config: config,
client: lightsail.New(sess),
}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"lightsail: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"retryer",
":=",
"customRetryer",
"{",
"}",
"\n",
"retryer",
".",
"NumMaxRetries",
"=",
"maxRetries",
"\n",
"conf",
":=",
"aws",
".",
"NewConfig",
"(",
")",
".",
"WithRegion",
"(",
"config",
".",
"Region",
")",
"\n",
"sess",
",",
"err",
":=",
"session",
".",
"NewSession",
"(",
"request",
".",
"WithRetryer",
"(",
"conf",
",",
"retryer",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"client",
":",
"lightsail",
".",
"New",
"(",
"sess",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for AWS Lightsail.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"AWS",
"Lightsail",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/lightsail/lightsail.go#L85-L103
|
train
|
go-acme/lego
|
providers/dns/route53/route53.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("route53: the configuration of the Route53 DNS provider is nil")
}
retry := customRetryer{}
retry.NumMaxRetries = config.MaxRetries
sessionCfg := request.WithRetryer(aws.NewConfig(), retry)
sess, err := session.NewSessionWithOptions(session.Options{Config: *sessionCfg})
if err != nil {
return nil, err
}
cl := route53.New(sess)
return &DNSProvider{client: cl, config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("route53: the configuration of the Route53 DNS provider is nil")
}
retry := customRetryer{}
retry.NumMaxRetries = config.MaxRetries
sessionCfg := request.WithRetryer(aws.NewConfig(), retry)
sess, err := session.NewSessionWithOptions(session.Options{Config: *sessionCfg})
if err != nil {
return nil, err
}
cl := route53.New(sess)
return &DNSProvider{client: cl, config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"route53: the configuration of the Route53 DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"retry",
":=",
"customRetryer",
"{",
"}",
"\n",
"retry",
".",
"NumMaxRetries",
"=",
"config",
".",
"MaxRetries",
"\n",
"sessionCfg",
":=",
"request",
".",
"WithRetryer",
"(",
"aws",
".",
"NewConfig",
"(",
")",
",",
"retry",
")",
"\n",
"sess",
",",
"err",
":=",
"session",
".",
"NewSessionWithOptions",
"(",
"session",
".",
"Options",
"{",
"Config",
":",
"*",
"sessionCfg",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cl",
":=",
"route53",
".",
"New",
"(",
"sess",
")",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"cl",
",",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig takes a given config ans returns a custom configured DNSProvider instance
|
[
"NewDNSProviderConfig",
"takes",
"a",
"given",
"config",
"ans",
"returns",
"a",
"custom",
"configured",
"DNSProvider",
"instance"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/route53/route53.go#L84-L100
|
train
|
go-acme/lego
|
providers/dns/cloudxns/internal/client.go
|
NewClient
|
func NewClient(apiKey string, secretKey string) (*Client, error) {
if apiKey == "" {
return nil, fmt.Errorf("CloudXNS: credentials missing: apiKey")
}
if secretKey == "" {
return nil, fmt.Errorf("CloudXNS: credentials missing: secretKey")
}
return &Client{
apiKey: apiKey,
secretKey: secretKey,
HTTPClient: &http.Client{},
BaseURL: defaultBaseURL,
}, nil
}
|
go
|
func NewClient(apiKey string, secretKey string) (*Client, error) {
if apiKey == "" {
return nil, fmt.Errorf("CloudXNS: credentials missing: apiKey")
}
if secretKey == "" {
return nil, fmt.Errorf("CloudXNS: credentials missing: secretKey")
}
return &Client{
apiKey: apiKey,
secretKey: secretKey,
HTTPClient: &http.Client{},
BaseURL: defaultBaseURL,
}, nil
}
|
[
"func",
"NewClient",
"(",
"apiKey",
"string",
",",
"secretKey",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"if",
"apiKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"CloudXNS: credentials missing: apiKey\"",
")",
"\n",
"}",
"\n",
"if",
"secretKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"CloudXNS: credentials missing: secretKey\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"Client",
"{",
"apiKey",
":",
"apiKey",
",",
"secretKey",
":",
"secretKey",
",",
"HTTPClient",
":",
"&",
"http",
".",
"Client",
"{",
"}",
",",
"BaseURL",
":",
"defaultBaseURL",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewClient creates a CloudXNS client
|
[
"NewClient",
"creates",
"a",
"CloudXNS",
"client"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/cloudxns/internal/client.go#L46-L61
|
train
|
go-acme/lego
|
providers/dns/cloudxns/internal/client.go
|
GetDomainInformation
|
func (c *Client) GetDomainInformation(fqdn string) (*Data, error) {
authZone, err := dns01.FindZoneByFqdn(fqdn)
if err != nil {
return nil, err
}
result, err := c.doRequest(http.MethodGet, "domain", nil)
if err != nil {
return nil, err
}
var domains []Data
if len(result) > 0 {
err = json.Unmarshal(result, &domains)
if err != nil {
return nil, fmt.Errorf("CloudXNS: domains unmarshaling error: %v", err)
}
}
for _, data := range domains {
if data.Domain == authZone {
return &data, nil
}
}
return nil, fmt.Errorf("CloudXNS: zone %s not found for domain %s", authZone, fqdn)
}
|
go
|
func (c *Client) GetDomainInformation(fqdn string) (*Data, error) {
authZone, err := dns01.FindZoneByFqdn(fqdn)
if err != nil {
return nil, err
}
result, err := c.doRequest(http.MethodGet, "domain", nil)
if err != nil {
return nil, err
}
var domains []Data
if len(result) > 0 {
err = json.Unmarshal(result, &domains)
if err != nil {
return nil, fmt.Errorf("CloudXNS: domains unmarshaling error: %v", err)
}
}
for _, data := range domains {
if data.Domain == authZone {
return &data, nil
}
}
return nil, fmt.Errorf("CloudXNS: zone %s not found for domain %s", authZone, fqdn)
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"GetDomainInformation",
"(",
"fqdn",
"string",
")",
"(",
"*",
"Data",
",",
"error",
")",
"{",
"authZone",
",",
"err",
":=",
"dns01",
".",
"FindZoneByFqdn",
"(",
"fqdn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"result",
",",
"err",
":=",
"c",
".",
"doRequest",
"(",
"http",
".",
"MethodGet",
",",
"\"domain\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"domains",
"[",
"]",
"Data",
"\n",
"if",
"len",
"(",
"result",
")",
">",
"0",
"{",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"result",
",",
"&",
"domains",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"CloudXNS: domains unmarshaling error: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"data",
":=",
"range",
"domains",
"{",
"if",
"data",
".",
"Domain",
"==",
"authZone",
"{",
"return",
"&",
"data",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"CloudXNS: zone %s not found for domain %s\"",
",",
"authZone",
",",
"fqdn",
")",
"\n",
"}"
] |
// GetDomainInformation Get domain name information for a FQDN
|
[
"GetDomainInformation",
"Get",
"domain",
"name",
"information",
"for",
"a",
"FQDN"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/cloudxns/internal/client.go#L72-L98
|
train
|
go-acme/lego
|
providers/dns/conoha/conoha.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("conoha: the configuration of the DNS provider is nil")
}
if config.TenantID == "" || config.Username == "" || config.Password == "" {
return nil, errors.New("conoha: some credentials information are missing")
}
auth := internal.Auth{
TenantID: config.TenantID,
PasswordCredentials: internal.PasswordCredentials{
Username: config.Username,
Password: config.Password,
},
}
client, err := internal.NewClient(config.Region, auth, config.HTTPClient)
if err != nil {
return nil, fmt.Errorf("conoha: failed to create client: %v", err)
}
return &DNSProvider{config: config, client: client}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("conoha: the configuration of the DNS provider is nil")
}
if config.TenantID == "" || config.Username == "" || config.Password == "" {
return nil, errors.New("conoha: some credentials information are missing")
}
auth := internal.Auth{
TenantID: config.TenantID,
PasswordCredentials: internal.PasswordCredentials{
Username: config.Username,
Password: config.Password,
},
}
client, err := internal.NewClient(config.Region, auth, config.HTTPClient)
if err != nil {
return nil, fmt.Errorf("conoha: failed to create client: %v", err)
}
return &DNSProvider{config: config, client: client}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"conoha: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"TenantID",
"==",
"\"\"",
"||",
"config",
".",
"Username",
"==",
"\"\"",
"||",
"config",
".",
"Password",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"conoha: some credentials information are missing\"",
")",
"\n",
"}",
"\n",
"auth",
":=",
"internal",
".",
"Auth",
"{",
"TenantID",
":",
"config",
".",
"TenantID",
",",
"PasswordCredentials",
":",
"internal",
".",
"PasswordCredentials",
"{",
"Username",
":",
"config",
".",
"Username",
",",
"Password",
":",
"config",
".",
"Password",
",",
"}",
",",
"}",
"\n",
"client",
",",
"err",
":=",
"internal",
".",
"NewClient",
"(",
"config",
".",
"Region",
",",
"auth",
",",
"config",
".",
"HTTPClient",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"conoha: failed to create client: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"client",
":",
"client",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for ConoHa DNS.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"ConoHa",
"DNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/conoha/conoha.go#L63-L86
|
train
|
go-acme/lego
|
providers/dns/conoha/conoha.go
|
CleanUp
|
func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, value := dns01.GetRecord(domain, keyAuth)
authZone, err := dns01.FindZoneByFqdn(fqdn)
if err != nil {
return err
}
domID, err := d.client.GetDomainID(authZone)
if err != nil {
return fmt.Errorf("conoha: failed to get domain ID: %v", err)
}
recID, err := d.client.GetRecordID(domID, fqdn, "TXT", value)
if err != nil {
return fmt.Errorf("conoha: failed to get record ID: %v", err)
}
err = d.client.DeleteRecord(domID, recID)
if err != nil {
return fmt.Errorf("conoha: failed to delete record: %v", err)
}
return nil
}
|
go
|
func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, value := dns01.GetRecord(domain, keyAuth)
authZone, err := dns01.FindZoneByFqdn(fqdn)
if err != nil {
return err
}
domID, err := d.client.GetDomainID(authZone)
if err != nil {
return fmt.Errorf("conoha: failed to get domain ID: %v", err)
}
recID, err := d.client.GetRecordID(domID, fqdn, "TXT", value)
if err != nil {
return fmt.Errorf("conoha: failed to get record ID: %v", err)
}
err = d.client.DeleteRecord(domID, recID)
if err != nil {
return fmt.Errorf("conoha: failed to delete record: %v", err)
}
return nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"CleanUp",
"(",
"domain",
",",
"token",
",",
"keyAuth",
"string",
")",
"error",
"{",
"fqdn",
",",
"value",
":=",
"dns01",
".",
"GetRecord",
"(",
"domain",
",",
"keyAuth",
")",
"\n",
"authZone",
",",
"err",
":=",
"dns01",
".",
"FindZoneByFqdn",
"(",
"fqdn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"domID",
",",
"err",
":=",
"d",
".",
"client",
".",
"GetDomainID",
"(",
"authZone",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"conoha: failed to get domain ID: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"recID",
",",
"err",
":=",
"d",
".",
"client",
".",
"GetRecordID",
"(",
"domID",
",",
"fqdn",
",",
"\"TXT\"",
",",
"value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"conoha: failed to get record ID: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"d",
".",
"client",
".",
"DeleteRecord",
"(",
"domID",
",",
"recID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"conoha: failed to delete record: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CleanUp clears ConoHa DNS TXT record
|
[
"CleanUp",
"clears",
"ConoHa",
"DNS",
"TXT",
"record"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/conoha/conoha.go#L118-L142
|
train
|
go-acme/lego
|
cmd/certs_storage.go
|
NewCertificatesStorage
|
func NewCertificatesStorage(ctx *cli.Context) *CertificatesStorage {
return &CertificatesStorage{
rootPath: filepath.Join(ctx.GlobalString("path"), baseCertificatesFolderName),
archivePath: filepath.Join(ctx.GlobalString("path"), baseArchivesFolderName),
pem: ctx.GlobalBool("pem"),
filename: ctx.GlobalString("filename"),
}
}
|
go
|
func NewCertificatesStorage(ctx *cli.Context) *CertificatesStorage {
return &CertificatesStorage{
rootPath: filepath.Join(ctx.GlobalString("path"), baseCertificatesFolderName),
archivePath: filepath.Join(ctx.GlobalString("path"), baseArchivesFolderName),
pem: ctx.GlobalBool("pem"),
filename: ctx.GlobalString("filename"),
}
}
|
[
"func",
"NewCertificatesStorage",
"(",
"ctx",
"*",
"cli",
".",
"Context",
")",
"*",
"CertificatesStorage",
"{",
"return",
"&",
"CertificatesStorage",
"{",
"rootPath",
":",
"filepath",
".",
"Join",
"(",
"ctx",
".",
"GlobalString",
"(",
"\"path\"",
")",
",",
"baseCertificatesFolderName",
")",
",",
"archivePath",
":",
"filepath",
".",
"Join",
"(",
"ctx",
".",
"GlobalString",
"(",
"\"path\"",
")",
",",
"baseArchivesFolderName",
")",
",",
"pem",
":",
"ctx",
".",
"GlobalBool",
"(",
"\"pem\"",
")",
",",
"filename",
":",
"ctx",
".",
"GlobalString",
"(",
"\"filename\"",
")",
",",
"}",
"\n",
"}"
] |
// NewCertificatesStorage create a new certificates storage.
|
[
"NewCertificatesStorage",
"create",
"a",
"new",
"certificates",
"storage",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/cmd/certs_storage.go#L48-L55
|
train
|
go-acme/lego
|
acme/api/authorization.go
|
Get
|
func (c *AuthorizationService) Get(authzURL string) (acme.Authorization, error) {
if len(authzURL) == 0 {
return acme.Authorization{}, errors.New("authorization[get]: empty URL")
}
var authz acme.Authorization
_, err := c.core.postAsGet(authzURL, &authz)
if err != nil {
return acme.Authorization{}, err
}
return authz, nil
}
|
go
|
func (c *AuthorizationService) Get(authzURL string) (acme.Authorization, error) {
if len(authzURL) == 0 {
return acme.Authorization{}, errors.New("authorization[get]: empty URL")
}
var authz acme.Authorization
_, err := c.core.postAsGet(authzURL, &authz)
if err != nil {
return acme.Authorization{}, err
}
return authz, nil
}
|
[
"func",
"(",
"c",
"*",
"AuthorizationService",
")",
"Get",
"(",
"authzURL",
"string",
")",
"(",
"acme",
".",
"Authorization",
",",
"error",
")",
"{",
"if",
"len",
"(",
"authzURL",
")",
"==",
"0",
"{",
"return",
"acme",
".",
"Authorization",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"authorization[get]: empty URL\"",
")",
"\n",
"}",
"\n",
"var",
"authz",
"acme",
".",
"Authorization",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"core",
".",
"postAsGet",
"(",
"authzURL",
",",
"&",
"authz",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"acme",
".",
"Authorization",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"authz",
",",
"nil",
"\n",
"}"
] |
// Get Gets an authorization.
|
[
"Get",
"Gets",
"an",
"authorization",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/authorization.go#L12-L23
|
train
|
go-acme/lego
|
acme/api/authorization.go
|
Deactivate
|
func (c *AuthorizationService) Deactivate(authzURL string) error {
if len(authzURL) == 0 {
return errors.New("authorization[deactivate]: empty URL")
}
var disabledAuth acme.Authorization
_, err := c.core.post(authzURL, acme.Authorization{Status: acme.StatusDeactivated}, &disabledAuth)
return err
}
|
go
|
func (c *AuthorizationService) Deactivate(authzURL string) error {
if len(authzURL) == 0 {
return errors.New("authorization[deactivate]: empty URL")
}
var disabledAuth acme.Authorization
_, err := c.core.post(authzURL, acme.Authorization{Status: acme.StatusDeactivated}, &disabledAuth)
return err
}
|
[
"func",
"(",
"c",
"*",
"AuthorizationService",
")",
"Deactivate",
"(",
"authzURL",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"authzURL",
")",
"==",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"authorization[deactivate]: empty URL\"",
")",
"\n",
"}",
"\n",
"var",
"disabledAuth",
"acme",
".",
"Authorization",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"core",
".",
"post",
"(",
"authzURL",
",",
"acme",
".",
"Authorization",
"{",
"Status",
":",
"acme",
".",
"StatusDeactivated",
"}",
",",
"&",
"disabledAuth",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Deactivate Deactivates an authorization.
|
[
"Deactivate",
"Deactivates",
"an",
"authorization",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/acme/api/authorization.go#L26-L34
|
train
|
go-acme/lego
|
providers/dns/hostingde/hostingde.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("hostingde: the configuration of the DNS provider is nil")
}
if config.APIKey == "" {
return nil, errors.New("hostingde: API key missing")
}
if config.ZoneName == "" {
return nil, errors.New("hostingde: Zone Name missing")
}
return &DNSProvider{
config: config,
recordIDs: make(map[string]string),
}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("hostingde: the configuration of the DNS provider is nil")
}
if config.APIKey == "" {
return nil, errors.New("hostingde: API key missing")
}
if config.ZoneName == "" {
return nil, errors.New("hostingde: Zone Name missing")
}
return &DNSProvider{
config: config,
recordIDs: make(map[string]string),
}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"hostingde: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"APIKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"hostingde: API key missing\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"ZoneName",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"hostingde: Zone Name missing\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"recordIDs",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for hosting.de.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"hosting",
".",
"de",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/hostingde/hostingde.go#L61-L78
|
train
|
go-acme/lego
|
providers/dns/exoscale/exoscale.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("the configuration of the DNS provider is nil")
}
if config.APIKey == "" || config.APISecret == "" {
return nil, fmt.Errorf("exoscale: credentials missing")
}
if config.Endpoint == "" {
config.Endpoint = defaultBaseURL
}
client := egoscale.NewClient(config.Endpoint, config.APIKey, config.APISecret)
client.HTTPClient = config.HTTPClient
return &DNSProvider{client: client, config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("the configuration of the DNS provider is nil")
}
if config.APIKey == "" || config.APISecret == "" {
return nil, fmt.Errorf("exoscale: credentials missing")
}
if config.Endpoint == "" {
config.Endpoint = defaultBaseURL
}
client := egoscale.NewClient(config.Endpoint, config.APIKey, config.APISecret)
client.HTTPClient = config.HTTPClient
return &DNSProvider{client: client, config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"APIKey",
"==",
"\"\"",
"||",
"config",
".",
"APISecret",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"exoscale: credentials missing\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"Endpoint",
"==",
"\"\"",
"{",
"config",
".",
"Endpoint",
"=",
"defaultBaseURL",
"\n",
"}",
"\n",
"client",
":=",
"egoscale",
".",
"NewClient",
"(",
"config",
".",
"Endpoint",
",",
"config",
".",
"APIKey",
",",
"config",
".",
"APISecret",
")",
"\n",
"client",
".",
"HTTPClient",
"=",
"config",
".",
"HTTPClient",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"client",
",",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for Exoscale.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"Exoscale",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/exoscale/exoscale.go#L64-L81
|
train
|
go-acme/lego
|
providers/dns/exoscale/exoscale.go
|
FindExistingRecordID
|
func (d *DNSProvider) FindExistingRecordID(zone, recordName string) (int64, error) {
ctx := context.Background()
records, err := d.client.GetRecords(ctx, zone)
if err != nil {
return -1, errors.New("Error while retrievening DNS records: " + err.Error())
}
for _, record := range records {
if record.Name == recordName {
return record.ID, nil
}
}
return 0, nil
}
|
go
|
func (d *DNSProvider) FindExistingRecordID(zone, recordName string) (int64, error) {
ctx := context.Background()
records, err := d.client.GetRecords(ctx, zone)
if err != nil {
return -1, errors.New("Error while retrievening DNS records: " + err.Error())
}
for _, record := range records {
if record.Name == recordName {
return record.ID, nil
}
}
return 0, nil
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"FindExistingRecordID",
"(",
"zone",
",",
"recordName",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"records",
",",
"err",
":=",
"d",
".",
"client",
".",
"GetRecords",
"(",
"ctx",
",",
"zone",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"errors",
".",
"New",
"(",
"\"Error while retrievening DNS records: \"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"record",
":=",
"range",
"records",
"{",
"if",
"record",
".",
"Name",
"==",
"recordName",
"{",
"return",
"record",
".",
"ID",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"0",
",",
"nil",
"\n",
"}"
] |
// FindExistingRecordID Query Exoscale to find an existing record for this name.
// Returns nil if no record could be found
|
[
"FindExistingRecordID",
"Query",
"Exoscale",
"to",
"find",
"an",
"existing",
"record",
"for",
"this",
"name",
".",
"Returns",
"nil",
"if",
"no",
"record",
"could",
"be",
"found"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/exoscale/exoscale.go#L159-L171
|
train
|
go-acme/lego
|
challenge/resolver/prober.go
|
Solve
|
func (p *Prober) Solve(authorizations []acme.Authorization) error {
failures := make(obtainError)
var authSolvers []*selectedAuthSolver
var authSolversSequential []*selectedAuthSolver
// Loop through the resources, basically through the domains.
// First pass just selects a solver for each authz.
for _, authz := range authorizations {
domain := challenge.GetTargetedDomain(authz)
if authz.Status == acme.StatusValid {
// Boulder might recycle recent validated authz (see issue #267)
log.Infof("[%s] acme: authorization already valid; skipping challenge", domain)
continue
}
if solvr := p.solverManager.chooseSolver(authz); solvr != nil {
authSolver := &selectedAuthSolver{authz: authz, solver: solvr}
switch s := solvr.(type) {
case sequential:
if ok, _ := s.Sequential(); ok {
authSolversSequential = append(authSolversSequential, authSolver)
} else {
authSolvers = append(authSolvers, authSolver)
}
default:
authSolvers = append(authSolvers, authSolver)
}
} else {
failures[domain] = fmt.Errorf("[%s] acme: could not determine solvers", domain)
}
}
parallelSolve(authSolvers, failures)
sequentialSolve(authSolversSequential, failures)
// Be careful not to return an empty failures map,
// for even an empty obtainError is a non-nil error value
if len(failures) > 0 {
return failures
}
return nil
}
|
go
|
func (p *Prober) Solve(authorizations []acme.Authorization) error {
failures := make(obtainError)
var authSolvers []*selectedAuthSolver
var authSolversSequential []*selectedAuthSolver
// Loop through the resources, basically through the domains.
// First pass just selects a solver for each authz.
for _, authz := range authorizations {
domain := challenge.GetTargetedDomain(authz)
if authz.Status == acme.StatusValid {
// Boulder might recycle recent validated authz (see issue #267)
log.Infof("[%s] acme: authorization already valid; skipping challenge", domain)
continue
}
if solvr := p.solverManager.chooseSolver(authz); solvr != nil {
authSolver := &selectedAuthSolver{authz: authz, solver: solvr}
switch s := solvr.(type) {
case sequential:
if ok, _ := s.Sequential(); ok {
authSolversSequential = append(authSolversSequential, authSolver)
} else {
authSolvers = append(authSolvers, authSolver)
}
default:
authSolvers = append(authSolvers, authSolver)
}
} else {
failures[domain] = fmt.Errorf("[%s] acme: could not determine solvers", domain)
}
}
parallelSolve(authSolvers, failures)
sequentialSolve(authSolversSequential, failures)
// Be careful not to return an empty failures map,
// for even an empty obtainError is a non-nil error value
if len(failures) > 0 {
return failures
}
return nil
}
|
[
"func",
"(",
"p",
"*",
"Prober",
")",
"Solve",
"(",
"authorizations",
"[",
"]",
"acme",
".",
"Authorization",
")",
"error",
"{",
"failures",
":=",
"make",
"(",
"obtainError",
")",
"\n",
"var",
"authSolvers",
"[",
"]",
"*",
"selectedAuthSolver",
"\n",
"var",
"authSolversSequential",
"[",
"]",
"*",
"selectedAuthSolver",
"\n",
"for",
"_",
",",
"authz",
":=",
"range",
"authorizations",
"{",
"domain",
":=",
"challenge",
".",
"GetTargetedDomain",
"(",
"authz",
")",
"\n",
"if",
"authz",
".",
"Status",
"==",
"acme",
".",
"StatusValid",
"{",
"log",
".",
"Infof",
"(",
"\"[%s] acme: authorization already valid; skipping challenge\"",
",",
"domain",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"solvr",
":=",
"p",
".",
"solverManager",
".",
"chooseSolver",
"(",
"authz",
")",
";",
"solvr",
"!=",
"nil",
"{",
"authSolver",
":=",
"&",
"selectedAuthSolver",
"{",
"authz",
":",
"authz",
",",
"solver",
":",
"solvr",
"}",
"\n",
"switch",
"s",
":=",
"solvr",
".",
"(",
"type",
")",
"{",
"case",
"sequential",
":",
"if",
"ok",
",",
"_",
":=",
"s",
".",
"Sequential",
"(",
")",
";",
"ok",
"{",
"authSolversSequential",
"=",
"append",
"(",
"authSolversSequential",
",",
"authSolver",
")",
"\n",
"}",
"else",
"{",
"authSolvers",
"=",
"append",
"(",
"authSolvers",
",",
"authSolver",
")",
"\n",
"}",
"\n",
"default",
":",
"authSolvers",
"=",
"append",
"(",
"authSolvers",
",",
"authSolver",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"failures",
"[",
"domain",
"]",
"=",
"fmt",
".",
"Errorf",
"(",
"\"[%s] acme: could not determine solvers\"",
",",
"domain",
")",
"\n",
"}",
"\n",
"}",
"\n",
"parallelSolve",
"(",
"authSolvers",
",",
"failures",
")",
"\n",
"sequentialSolve",
"(",
"authSolversSequential",
",",
"failures",
")",
"\n",
"if",
"len",
"(",
"failures",
")",
">",
"0",
"{",
"return",
"failures",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Solve Looks through the challenge combinations to find a solvable match.
// Then solves the challenges in series and returns.
|
[
"Solve",
"Looks",
"through",
"the",
"challenge",
"combinations",
"to",
"find",
"a",
"solvable",
"match",
".",
"Then",
"solves",
"the",
"challenges",
"in",
"series",
"and",
"returns",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/challenge/resolver/prober.go#L50-L94
|
train
|
go-acme/lego
|
providers/dns/ns1/ns1.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("ns1: the configuration of the DNS provider is nil")
}
if config.APIKey == "" {
return nil, fmt.Errorf("ns1: credentials missing")
}
client := rest.NewClient(config.HTTPClient, rest.SetAPIKey(config.APIKey))
return &DNSProvider{client: client, config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("ns1: the configuration of the DNS provider is nil")
}
if config.APIKey == "" {
return nil, fmt.Errorf("ns1: credentials missing")
}
client := rest.NewClient(config.HTTPClient, rest.SetAPIKey(config.APIKey))
return &DNSProvider{client: client, config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"ns1: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"APIKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"ns1: credentials missing\"",
")",
"\n",
"}",
"\n",
"client",
":=",
"rest",
".",
"NewClient",
"(",
"config",
".",
"HTTPClient",
",",
"rest",
".",
"SetAPIKey",
"(",
"config",
".",
"APIKey",
")",
")",
"\n",
"return",
"&",
"DNSProvider",
"{",
"client",
":",
"client",
",",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for NS1.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"NS1",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/ns1/ns1.go#L60-L72
|
train
|
go-acme/lego
|
providers/dns/gcloud/googlecloud.go
|
NewDNSProviderCredentials
|
func NewDNSProviderCredentials(project string) (*DNSProvider, error) {
if project == "" {
return nil, fmt.Errorf("googlecloud: project name missing")
}
client, err := google.DefaultClient(context.Background(), dns.NdevClouddnsReadwriteScope)
if err != nil {
return nil, fmt.Errorf("googlecloud: unable to get Google Cloud client: %v", err)
}
config := NewDefaultConfig()
config.Project = project
config.HTTPClient = client
return NewDNSProviderConfig(config)
}
|
go
|
func NewDNSProviderCredentials(project string) (*DNSProvider, error) {
if project == "" {
return nil, fmt.Errorf("googlecloud: project name missing")
}
client, err := google.DefaultClient(context.Background(), dns.NdevClouddnsReadwriteScope)
if err != nil {
return nil, fmt.Errorf("googlecloud: unable to get Google Cloud client: %v", err)
}
config := NewDefaultConfig()
config.Project = project
config.HTTPClient = client
return NewDNSProviderConfig(config)
}
|
[
"func",
"NewDNSProviderCredentials",
"(",
"project",
"string",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"project",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: project name missing\"",
")",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"google",
".",
"DefaultClient",
"(",
"context",
".",
"Background",
"(",
")",
",",
"dns",
".",
"NdevClouddnsReadwriteScope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: unable to get Google Cloud client: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"config",
":=",
"NewDefaultConfig",
"(",
")",
"\n",
"config",
".",
"Project",
"=",
"project",
"\n",
"config",
".",
"HTTPClient",
"=",
"client",
"\n",
"return",
"NewDNSProviderConfig",
"(",
"config",
")",
"\n",
"}"
] |
// NewDNSProviderCredentials uses the supplied credentials
// to return a DNSProvider instance configured for Google Cloud DNS.
|
[
"NewDNSProviderCredentials",
"uses",
"the",
"supplied",
"credentials",
"to",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"Google",
"Cloud",
"DNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/gcloud/googlecloud.go#L71-L86
|
train
|
go-acme/lego
|
providers/dns/gcloud/googlecloud.go
|
NewDNSProviderServiceAccountKey
|
func NewDNSProviderServiceAccountKey(saKey []byte) (*DNSProvider, error) {
if len(saKey) == 0 {
return nil, fmt.Errorf("googlecloud: Service Account is missing")
}
// If GCE_PROJECT is non-empty it overrides the project in the service
// account file.
project := env.GetOrDefaultString("GCE_PROJECT", "")
if project == "" {
// read project id from service account file
var datJSON struct {
ProjectID string `json:"project_id"`
}
err := json.Unmarshal(saKey, &datJSON)
if err != nil || datJSON.ProjectID == "" {
return nil, fmt.Errorf("googlecloud: project ID not found in Google Cloud Service Account file")
}
project = datJSON.ProjectID
}
conf, err := google.JWTConfigFromJSON(saKey, dns.NdevClouddnsReadwriteScope)
if err != nil {
return nil, fmt.Errorf("googlecloud: unable to acquire config: %v", err)
}
client := conf.Client(context.Background())
config := NewDefaultConfig()
config.Project = project
config.HTTPClient = client
return NewDNSProviderConfig(config)
}
|
go
|
func NewDNSProviderServiceAccountKey(saKey []byte) (*DNSProvider, error) {
if len(saKey) == 0 {
return nil, fmt.Errorf("googlecloud: Service Account is missing")
}
// If GCE_PROJECT is non-empty it overrides the project in the service
// account file.
project := env.GetOrDefaultString("GCE_PROJECT", "")
if project == "" {
// read project id from service account file
var datJSON struct {
ProjectID string `json:"project_id"`
}
err := json.Unmarshal(saKey, &datJSON)
if err != nil || datJSON.ProjectID == "" {
return nil, fmt.Errorf("googlecloud: project ID not found in Google Cloud Service Account file")
}
project = datJSON.ProjectID
}
conf, err := google.JWTConfigFromJSON(saKey, dns.NdevClouddnsReadwriteScope)
if err != nil {
return nil, fmt.Errorf("googlecloud: unable to acquire config: %v", err)
}
client := conf.Client(context.Background())
config := NewDefaultConfig()
config.Project = project
config.HTTPClient = client
return NewDNSProviderConfig(config)
}
|
[
"func",
"NewDNSProviderServiceAccountKey",
"(",
"saKey",
"[",
"]",
"byte",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"len",
"(",
"saKey",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: Service Account is missing\"",
")",
"\n",
"}",
"\n",
"project",
":=",
"env",
".",
"GetOrDefaultString",
"(",
"\"GCE_PROJECT\"",
",",
"\"\"",
")",
"\n",
"if",
"project",
"==",
"\"\"",
"{",
"var",
"datJSON",
"struct",
"{",
"ProjectID",
"string",
"`json:\"project_id\"`",
"\n",
"}",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"saKey",
",",
"&",
"datJSON",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"datJSON",
".",
"ProjectID",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: project ID not found in Google Cloud Service Account file\"",
")",
"\n",
"}",
"\n",
"project",
"=",
"datJSON",
".",
"ProjectID",
"\n",
"}",
"\n",
"conf",
",",
"err",
":=",
"google",
".",
"JWTConfigFromJSON",
"(",
"saKey",
",",
"dns",
".",
"NdevClouddnsReadwriteScope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: unable to acquire config: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"client",
":=",
"conf",
".",
"Client",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"config",
":=",
"NewDefaultConfig",
"(",
")",
"\n",
"config",
".",
"Project",
"=",
"project",
"\n",
"config",
".",
"HTTPClient",
"=",
"client",
"\n",
"return",
"NewDNSProviderConfig",
"(",
"config",
")",
"\n",
"}"
] |
// NewDNSProviderServiceAccountKey uses the supplied service account JSON
// to return a DNSProvider instance configured for Google Cloud DNS.
|
[
"NewDNSProviderServiceAccountKey",
"uses",
"the",
"supplied",
"service",
"account",
"JSON",
"to",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"Google",
"Cloud",
"DNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/gcloud/googlecloud.go#L90-L121
|
train
|
go-acme/lego
|
providers/dns/gcloud/googlecloud.go
|
NewDNSProviderServiceAccount
|
func NewDNSProviderServiceAccount(saFile string) (*DNSProvider, error) {
if saFile == "" {
return nil, fmt.Errorf("googlecloud: Service Account file missing")
}
saKey, err := ioutil.ReadFile(saFile)
if err != nil {
return nil, fmt.Errorf("googlecloud: unable to read Service Account file: %v", err)
}
return NewDNSProviderServiceAccountKey(saKey)
}
|
go
|
func NewDNSProviderServiceAccount(saFile string) (*DNSProvider, error) {
if saFile == "" {
return nil, fmt.Errorf("googlecloud: Service Account file missing")
}
saKey, err := ioutil.ReadFile(saFile)
if err != nil {
return nil, fmt.Errorf("googlecloud: unable to read Service Account file: %v", err)
}
return NewDNSProviderServiceAccountKey(saKey)
}
|
[
"func",
"NewDNSProviderServiceAccount",
"(",
"saFile",
"string",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"saFile",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: Service Account file missing\"",
")",
"\n",
"}",
"\n",
"saKey",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"saFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: unable to read Service Account file: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"NewDNSProviderServiceAccountKey",
"(",
"saKey",
")",
"\n",
"}"
] |
// NewDNSProviderServiceAccount uses the supplied service account JSON file
// to return a DNSProvider instance configured for Google Cloud DNS.
|
[
"NewDNSProviderServiceAccount",
"uses",
"the",
"supplied",
"service",
"account",
"JSON",
"file",
"to",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"Google",
"Cloud",
"DNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/gcloud/googlecloud.go#L125-L136
|
train
|
go-acme/lego
|
providers/dns/gcloud/googlecloud.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("googlecloud: the configuration of the DNS provider is nil")
}
if config.HTTPClient == nil {
return nil, fmt.Errorf("googlecloud: unable to create Google Cloud DNS service: client is nil")
}
svc, err := dns.NewService(context.Background(), option.WithHTTPClient(config.HTTPClient))
if err != nil {
return nil, fmt.Errorf("googlecloud: unable to create Google Cloud DNS service: %v", err)
}
return &DNSProvider{config: config, client: svc}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("googlecloud: the configuration of the DNS provider is nil")
}
if config.HTTPClient == nil {
return nil, fmt.Errorf("googlecloud: unable to create Google Cloud DNS service: client is nil")
}
svc, err := dns.NewService(context.Background(), option.WithHTTPClient(config.HTTPClient))
if err != nil {
return nil, fmt.Errorf("googlecloud: unable to create Google Cloud DNS service: %v", err)
}
return &DNSProvider{config: config, client: svc}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"googlecloud: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"HTTPClient",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: unable to create Google Cloud DNS service: client is nil\"",
")",
"\n",
"}",
"\n",
"svc",
",",
"err",
":=",
"dns",
".",
"NewService",
"(",
"context",
".",
"Background",
"(",
")",
",",
"option",
".",
"WithHTTPClient",
"(",
"config",
".",
"HTTPClient",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"googlecloud: unable to create Google Cloud DNS service: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
",",
"client",
":",
"svc",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for Google Cloud DNS.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"Google",
"Cloud",
"DNS",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/gcloud/googlecloud.go#L139-L153
|
train
|
go-acme/lego
|
providers/dns/gcloud/googlecloud.go
|
getHostedZone
|
func (d *DNSProvider) getHostedZone(domain string) (string, error) {
authZone, err := dns01.FindZoneByFqdn(dns01.ToFqdn(domain))
if err != nil {
return "", err
}
zones, err := d.client.ManagedZones.
List(d.config.Project).
DnsName(authZone).
Do()
if err != nil {
return "", fmt.Errorf("API call failed: %v", err)
}
if len(zones.ManagedZones) == 0 {
return "", fmt.Errorf("no matching domain found for domain %s", authZone)
}
for _, z := range zones.ManagedZones {
if z.Visibility == "public" || z.Visibility == "" {
return z.Name, nil
}
}
return "", fmt.Errorf("no public zone found for domain %s", authZone)
}
|
go
|
func (d *DNSProvider) getHostedZone(domain string) (string, error) {
authZone, err := dns01.FindZoneByFqdn(dns01.ToFqdn(domain))
if err != nil {
return "", err
}
zones, err := d.client.ManagedZones.
List(d.config.Project).
DnsName(authZone).
Do()
if err != nil {
return "", fmt.Errorf("API call failed: %v", err)
}
if len(zones.ManagedZones) == 0 {
return "", fmt.Errorf("no matching domain found for domain %s", authZone)
}
for _, z := range zones.ManagedZones {
if z.Visibility == "public" || z.Visibility == "" {
return z.Name, nil
}
}
return "", fmt.Errorf("no public zone found for domain %s", authZone)
}
|
[
"func",
"(",
"d",
"*",
"DNSProvider",
")",
"getHostedZone",
"(",
"domain",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"authZone",
",",
"err",
":=",
"dns01",
".",
"FindZoneByFqdn",
"(",
"dns01",
".",
"ToFqdn",
"(",
"domain",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"zones",
",",
"err",
":=",
"d",
".",
"client",
".",
"ManagedZones",
".",
"List",
"(",
"d",
".",
"config",
".",
"Project",
")",
".",
"DnsName",
"(",
"authZone",
")",
".",
"Do",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"API call failed: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"zones",
".",
"ManagedZones",
")",
"==",
"0",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"no matching domain found for domain %s\"",
",",
"authZone",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"z",
":=",
"range",
"zones",
".",
"ManagedZones",
"{",
"if",
"z",
".",
"Visibility",
"==",
"\"public\"",
"||",
"z",
".",
"Visibility",
"==",
"\"\"",
"{",
"return",
"z",
".",
"Name",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"no public zone found for domain %s\"",
",",
"authZone",
")",
"\n",
"}"
] |
// getHostedZone returns the managed-zone
|
[
"getHostedZone",
"returns",
"the",
"managed",
"-",
"zone"
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/gcloud/googlecloud.go#L295-L320
|
train
|
go-acme/lego
|
providers/dns/namecheap/namecheap.go
|
NewDNSProviderConfig
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("namecheap: the configuration of the DNS provider is nil")
}
if config.APIUser == "" || config.APIKey == "" {
return nil, fmt.Errorf("namecheap: credentials missing")
}
if len(config.ClientIP) == 0 {
clientIP, err := getClientIP(config.HTTPClient, config.Debug)
if err != nil {
return nil, fmt.Errorf("namecheap: %v", err)
}
config.ClientIP = clientIP
}
return &DNSProvider{config: config}, nil
}
|
go
|
func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
if config == nil {
return nil, errors.New("namecheap: the configuration of the DNS provider is nil")
}
if config.APIUser == "" || config.APIKey == "" {
return nil, fmt.Errorf("namecheap: credentials missing")
}
if len(config.ClientIP) == 0 {
clientIP, err := getClientIP(config.HTTPClient, config.Debug)
if err != nil {
return nil, fmt.Errorf("namecheap: %v", err)
}
config.ClientIP = clientIP
}
return &DNSProvider{config: config}, nil
}
|
[
"func",
"NewDNSProviderConfig",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"DNSProvider",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"namecheap: the configuration of the DNS provider is nil\"",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"APIUser",
"==",
"\"\"",
"||",
"config",
".",
"APIKey",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"namecheap: credentials missing\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"ClientIP",
")",
"==",
"0",
"{",
"clientIP",
",",
"err",
":=",
"getClientIP",
"(",
"config",
".",
"HTTPClient",
",",
"config",
".",
"Debug",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"namecheap: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"config",
".",
"ClientIP",
"=",
"clientIP",
"\n",
"}",
"\n",
"return",
"&",
"DNSProvider",
"{",
"config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDNSProviderConfig return a DNSProvider instance configured for namecheap.
|
[
"NewDNSProviderConfig",
"return",
"a",
"DNSProvider",
"instance",
"configured",
"for",
"namecheap",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/namecheap/namecheap.go#L98-L116
|
train
|
go-acme/lego
|
providers/dns/namecheap/namecheap.go
|
getClientIP
|
func getClientIP(client *http.Client, debug bool) (addr string, err error) {
resp, err := client.Get(getIPURL)
if err != nil {
return "", err
}
defer resp.Body.Close()
clientIP, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
if debug {
log.Println("Client IP:", string(clientIP))
}
return string(clientIP), nil
}
|
go
|
func getClientIP(client *http.Client, debug bool) (addr string, err error) {
resp, err := client.Get(getIPURL)
if err != nil {
return "", err
}
defer resp.Body.Close()
clientIP, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
if debug {
log.Println("Client IP:", string(clientIP))
}
return string(clientIP), nil
}
|
[
"func",
"getClientIP",
"(",
"client",
"*",
"http",
".",
"Client",
",",
"debug",
"bool",
")",
"(",
"addr",
"string",
",",
"err",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"client",
".",
"Get",
"(",
"getIPURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"clientIP",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"debug",
"{",
"log",
".",
"Println",
"(",
"\"Client IP:\"",
",",
"string",
"(",
"clientIP",
")",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"clientIP",
")",
",",
"nil",
"\n",
"}"
] |
// getClientIP returns the client's public IP address.
// It uses namecheap's IP discovery service to perform the lookup.
|
[
"getClientIP",
"returns",
"the",
"client",
"s",
"public",
"IP",
"address",
".",
"It",
"uses",
"namecheap",
"s",
"IP",
"discovery",
"service",
"to",
"perform",
"the",
"lookup",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/namecheap/namecheap.go#L205-L221
|
train
|
go-acme/lego
|
providers/dns/namecheap/namecheap.go
|
newChallenge
|
func newChallenge(domain, keyAuth string, tlds map[string]string) (*challenge, error) {
domain = dns01.UnFqdn(domain)
parts := strings.Split(domain, ".")
// Find the longest matching TLD.
longest := -1
for i := len(parts); i > 0; i-- {
t := strings.Join(parts[i-1:], ".")
if _, found := tlds[t]; found {
longest = i - 1
}
}
if longest < 1 {
return nil, fmt.Errorf("invalid domain name %q", domain)
}
tld := strings.Join(parts[longest:], ".")
sld := parts[longest-1]
var host string
if longest >= 1 {
host = strings.Join(parts[:longest-1], ".")
}
fqdn, value := dns01.GetRecord(domain, keyAuth)
return &challenge{
domain: domain,
key: "_acme-challenge." + host,
keyFqdn: fqdn,
keyValue: value,
tld: tld,
sld: sld,
host: host,
}, nil
}
|
go
|
func newChallenge(domain, keyAuth string, tlds map[string]string) (*challenge, error) {
domain = dns01.UnFqdn(domain)
parts := strings.Split(domain, ".")
// Find the longest matching TLD.
longest := -1
for i := len(parts); i > 0; i-- {
t := strings.Join(parts[i-1:], ".")
if _, found := tlds[t]; found {
longest = i - 1
}
}
if longest < 1 {
return nil, fmt.Errorf("invalid domain name %q", domain)
}
tld := strings.Join(parts[longest:], ".")
sld := parts[longest-1]
var host string
if longest >= 1 {
host = strings.Join(parts[:longest-1], ".")
}
fqdn, value := dns01.GetRecord(domain, keyAuth)
return &challenge{
domain: domain,
key: "_acme-challenge." + host,
keyFqdn: fqdn,
keyValue: value,
tld: tld,
sld: sld,
host: host,
}, nil
}
|
[
"func",
"newChallenge",
"(",
"domain",
",",
"keyAuth",
"string",
",",
"tlds",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"*",
"challenge",
",",
"error",
")",
"{",
"domain",
"=",
"dns01",
".",
"UnFqdn",
"(",
"domain",
")",
"\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"domain",
",",
"\".\"",
")",
"\n",
"longest",
":=",
"-",
"1",
"\n",
"for",
"i",
":=",
"len",
"(",
"parts",
")",
";",
"i",
">",
"0",
";",
"i",
"--",
"{",
"t",
":=",
"strings",
".",
"Join",
"(",
"parts",
"[",
"i",
"-",
"1",
":",
"]",
",",
"\".\"",
")",
"\n",
"if",
"_",
",",
"found",
":=",
"tlds",
"[",
"t",
"]",
";",
"found",
"{",
"longest",
"=",
"i",
"-",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"longest",
"<",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"invalid domain name %q\"",
",",
"domain",
")",
"\n",
"}",
"\n",
"tld",
":=",
"strings",
".",
"Join",
"(",
"parts",
"[",
"longest",
":",
"]",
",",
"\".\"",
")",
"\n",
"sld",
":=",
"parts",
"[",
"longest",
"-",
"1",
"]",
"\n",
"var",
"host",
"string",
"\n",
"if",
"longest",
">=",
"1",
"{",
"host",
"=",
"strings",
".",
"Join",
"(",
"parts",
"[",
":",
"longest",
"-",
"1",
"]",
",",
"\".\"",
")",
"\n",
"}",
"\n",
"fqdn",
",",
"value",
":=",
"dns01",
".",
"GetRecord",
"(",
"domain",
",",
"keyAuth",
")",
"\n",
"return",
"&",
"challenge",
"{",
"domain",
":",
"domain",
",",
"key",
":",
"\"_acme-challenge.\"",
"+",
"host",
",",
"keyFqdn",
":",
"fqdn",
",",
"keyValue",
":",
"value",
",",
"tld",
":",
"tld",
",",
"sld",
":",
"sld",
",",
"host",
":",
"host",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// newChallenge builds a challenge record from a domain name, a challenge
// authentication key, and a map of available TLDs.
|
[
"newChallenge",
"builds",
"a",
"challenge",
"record",
"from",
"a",
"domain",
"name",
"a",
"challenge",
"authentication",
"key",
"and",
"a",
"map",
"of",
"available",
"TLDs",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/providers/dns/namecheap/namecheap.go#L225-L260
|
train
|
go-acme/lego
|
certificate/certificates.go
|
NewCertifier
|
func NewCertifier(core *api.Core, resolver resolver, options CertifierOptions) *Certifier {
return &Certifier{
core: core,
resolver: resolver,
options: options,
}
}
|
go
|
func NewCertifier(core *api.Core, resolver resolver, options CertifierOptions) *Certifier {
return &Certifier{
core: core,
resolver: resolver,
options: options,
}
}
|
[
"func",
"NewCertifier",
"(",
"core",
"*",
"api",
".",
"Core",
",",
"resolver",
"resolver",
",",
"options",
"CertifierOptions",
")",
"*",
"Certifier",
"{",
"return",
"&",
"Certifier",
"{",
"core",
":",
"core",
",",
"resolver",
":",
"resolver",
",",
"options",
":",
"options",
",",
"}",
"\n",
"}"
] |
// NewCertifier creates a Certifier.
|
[
"NewCertifier",
"creates",
"a",
"Certifier",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/certificate/certificates.go#L77-L83
|
train
|
go-acme/lego
|
certificate/certificates.go
|
Obtain
|
func (c *Certifier) Obtain(request ObtainRequest) (*Resource, error) {
if len(request.Domains) == 0 {
return nil, errors.New("no domains to obtain a certificate for")
}
domains := sanitizeDomain(request.Domains)
if request.Bundle {
log.Infof("[%s] acme: Obtaining bundled SAN certificate", strings.Join(domains, ", "))
} else {
log.Infof("[%s] acme: Obtaining SAN certificate", strings.Join(domains, ", "))
}
order, err := c.core.Orders.New(domains)
if err != nil {
return nil, err
}
authz, err := c.getAuthorizations(order)
if err != nil {
// If any challenge fails, return. Do not generate partial SAN certificates.
c.deactivateAuthorizations(order)
return nil, err
}
err = c.resolver.Solve(authz)
if err != nil {
// If any challenge fails, return. Do not generate partial SAN certificates.
c.deactivateAuthorizations(order)
return nil, err
}
log.Infof("[%s] acme: Validations succeeded; requesting certificates", strings.Join(domains, ", "))
failures := make(obtainError)
cert, err := c.getForOrder(domains, order, request.Bundle, request.PrivateKey, request.MustStaple)
if err != nil {
for _, auth := range authz {
failures[challenge.GetTargetedDomain(auth)] = err
}
}
// Do not return an empty failures map, because
// it would still be a non-nil error value
if len(failures) > 0 {
return cert, failures
}
return cert, nil
}
|
go
|
func (c *Certifier) Obtain(request ObtainRequest) (*Resource, error) {
if len(request.Domains) == 0 {
return nil, errors.New("no domains to obtain a certificate for")
}
domains := sanitizeDomain(request.Domains)
if request.Bundle {
log.Infof("[%s] acme: Obtaining bundled SAN certificate", strings.Join(domains, ", "))
} else {
log.Infof("[%s] acme: Obtaining SAN certificate", strings.Join(domains, ", "))
}
order, err := c.core.Orders.New(domains)
if err != nil {
return nil, err
}
authz, err := c.getAuthorizations(order)
if err != nil {
// If any challenge fails, return. Do not generate partial SAN certificates.
c.deactivateAuthorizations(order)
return nil, err
}
err = c.resolver.Solve(authz)
if err != nil {
// If any challenge fails, return. Do not generate partial SAN certificates.
c.deactivateAuthorizations(order)
return nil, err
}
log.Infof("[%s] acme: Validations succeeded; requesting certificates", strings.Join(domains, ", "))
failures := make(obtainError)
cert, err := c.getForOrder(domains, order, request.Bundle, request.PrivateKey, request.MustStaple)
if err != nil {
for _, auth := range authz {
failures[challenge.GetTargetedDomain(auth)] = err
}
}
// Do not return an empty failures map, because
// it would still be a non-nil error value
if len(failures) > 0 {
return cert, failures
}
return cert, nil
}
|
[
"func",
"(",
"c",
"*",
"Certifier",
")",
"Obtain",
"(",
"request",
"ObtainRequest",
")",
"(",
"*",
"Resource",
",",
"error",
")",
"{",
"if",
"len",
"(",
"request",
".",
"Domains",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"no domains to obtain a certificate for\"",
")",
"\n",
"}",
"\n",
"domains",
":=",
"sanitizeDomain",
"(",
"request",
".",
"Domains",
")",
"\n",
"if",
"request",
".",
"Bundle",
"{",
"log",
".",
"Infof",
"(",
"\"[%s] acme: Obtaining bundled SAN certificate\"",
",",
"strings",
".",
"Join",
"(",
"domains",
",",
"\", \"",
")",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Infof",
"(",
"\"[%s] acme: Obtaining SAN certificate\"",
",",
"strings",
".",
"Join",
"(",
"domains",
",",
"\", \"",
")",
")",
"\n",
"}",
"\n",
"order",
",",
"err",
":=",
"c",
".",
"core",
".",
"Orders",
".",
"New",
"(",
"domains",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"authz",
",",
"err",
":=",
"c",
".",
"getAuthorizations",
"(",
"order",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"deactivateAuthorizations",
"(",
"order",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"c",
".",
"resolver",
".",
"Solve",
"(",
"authz",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"deactivateAuthorizations",
"(",
"order",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"[%s] acme: Validations succeeded; requesting certificates\"",
",",
"strings",
".",
"Join",
"(",
"domains",
",",
"\", \"",
")",
")",
"\n",
"failures",
":=",
"make",
"(",
"obtainError",
")",
"\n",
"cert",
",",
"err",
":=",
"c",
".",
"getForOrder",
"(",
"domains",
",",
"order",
",",
"request",
".",
"Bundle",
",",
"request",
".",
"PrivateKey",
",",
"request",
".",
"MustStaple",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"for",
"_",
",",
"auth",
":=",
"range",
"authz",
"{",
"failures",
"[",
"challenge",
".",
"GetTargetedDomain",
"(",
"auth",
")",
"]",
"=",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"failures",
")",
">",
"0",
"{",
"return",
"cert",
",",
"failures",
"\n",
"}",
"\n",
"return",
"cert",
",",
"nil",
"\n",
"}"
] |
// Obtain tries to obtain a single certificate using all domains passed into it.
//
// This function will never return a partial certificate.
// If one domain in the list fails, the whole certificate will fail.
|
[
"Obtain",
"tries",
"to",
"obtain",
"a",
"single",
"certificate",
"using",
"all",
"domains",
"passed",
"into",
"it",
".",
"This",
"function",
"will",
"never",
"return",
"a",
"partial",
"certificate",
".",
"If",
"one",
"domain",
"in",
"the",
"list",
"fails",
"the",
"whole",
"certificate",
"will",
"fail",
"."
] |
29c63545ce6fffd8289c55c39d81c4fde993533d
|
https://github.com/go-acme/lego/blob/29c63545ce6fffd8289c55c39d81c4fde993533d/certificate/certificates.go#L89-L137
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.