id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
152,500 | Azure/go-autorest | autorest/responder.go | ByIgnoring | func ByIgnoring() RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
return r.Respond(resp)
})
}
} | go | func ByIgnoring() RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
return r.Respond(resp)
})
}
} | [
"func",
"ByIgnoring",
"(",
")",
"RespondDecorator",
"{",
"return",
"func",
"(",
"r",
"Responder",
")",
"Responder",
"{",
"return",
"ResponderFunc",
"(",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"return",
"r",
".",
"Respond",
"(",
"resp",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // ByIgnoring returns a RespondDecorator that ignores the passed http.Response passing it unexamined
// to the next RespondDecorator. | [
"ByIgnoring",
"returns",
"a",
"RespondDecorator",
"that",
"ignores",
"the",
"passed",
"http",
".",
"Response",
"passing",
"it",
"unexamined",
"to",
"the",
"next",
"RespondDecorator",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/responder.go#L83-L89 |
152,501 | Azure/go-autorest | autorest/responder.go | ByCopying | func ByCopying(b *bytes.Buffer) RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil && resp != nil && resp.Body != nil {
resp.Body = TeeReadCloser(resp.Body, b)
}
return err
})
}
} | go | func ByCopying(b *bytes.Buffer) RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil && resp != nil && resp.Body != nil {
resp.Body = TeeReadCloser(resp.Body, b)
}
return err
})
}
} | [
"func",
"ByCopying",
"(",
"b",
"*",
"bytes",
".",
"Buffer",
")",
"RespondDecorator",
"{",
"return",
"func",
"(",
"r",
"Responder",
")",
"Responder",
"{",
"return",
"ResponderFunc",
"(",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"err",
":=",
"r",
".",
"Respond",
"(",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"resp",
"!=",
"nil",
"&&",
"resp",
".",
"Body",
"!=",
"nil",
"{",
"resp",
".",
"Body",
"=",
"TeeReadCloser",
"(",
"resp",
".",
"Body",
",",
"b",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // ByCopying copies the contents of the http.Response Body into the passed bytes.Buffer as
// the Body is read. | [
"ByCopying",
"copies",
"the",
"contents",
"of",
"the",
"http",
".",
"Response",
"Body",
"into",
"the",
"passed",
"bytes",
".",
"Buffer",
"as",
"the",
"Body",
"is",
"read",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/responder.go#L93-L103 |
152,502 | Azure/go-autorest | autorest/responder.go | ByClosing | func ByClosing() RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if resp != nil && resp.Body != nil {
if err := resp.Body.Close(); err != nil {
return fmt.Errorf("Error closing the response body: %v", err)
}
}
return err
})
}
} | go | func ByClosing() RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if resp != nil && resp.Body != nil {
if err := resp.Body.Close(); err != nil {
return fmt.Errorf("Error closing the response body: %v", err)
}
}
return err
})
}
} | [
"func",
"ByClosing",
"(",
")",
"RespondDecorator",
"{",
"return",
"func",
"(",
"r",
"Responder",
")",
"Responder",
"{",
"return",
"ResponderFunc",
"(",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"err",
":=",
"r",
".",
"Respond",
"(",
"resp",
")",
"\n",
"if",
"resp",
"!=",
"nil",
"&&",
"resp",
".",
"Body",
"!=",
"nil",
"{",
"if",
"err",
":=",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // ByClosing returns a RespondDecorator that first invokes the passed Responder after which it
// closes the response body. Since the passed Responder is invoked prior to closing the response
// body, the decorator may occur anywhere within the set. | [
"ByClosing",
"returns",
"a",
"RespondDecorator",
"that",
"first",
"invokes",
"the",
"passed",
"Responder",
"after",
"which",
"it",
"closes",
"the",
"response",
"body",
".",
"Since",
"the",
"passed",
"Responder",
"is",
"invoked",
"prior",
"to",
"closing",
"the",
"response",
"body",
"the",
"decorator",
"may",
"occur",
"anywhere",
"within",
"the",
"set",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/responder.go#L126-L138 |
152,503 | Azure/go-autorest | autorest/responder.go | ByUnmarshallingJSON | func ByUnmarshallingJSON(v interface{}) RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil {
b, errInner := ioutil.ReadAll(resp.Body)
// Some responses might include a BOM, remove for successful unmarshalling
b = bytes.TrimPrefix(b, []byte("\xef\xbb\xbf"))
if errInner != nil {
err = fmt.Errorf("Error occurred reading http.Response#Body - Error = '%v'", errInner)
} else if len(strings.Trim(string(b), " ")) > 0 {
errInner = json.Unmarshal(b, v)
if errInner != nil {
err = fmt.Errorf("Error occurred unmarshalling JSON - Error = '%v' JSON = '%s'", errInner, string(b))
}
}
}
return err
})
}
} | go | func ByUnmarshallingJSON(v interface{}) RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil {
b, errInner := ioutil.ReadAll(resp.Body)
// Some responses might include a BOM, remove for successful unmarshalling
b = bytes.TrimPrefix(b, []byte("\xef\xbb\xbf"))
if errInner != nil {
err = fmt.Errorf("Error occurred reading http.Response#Body - Error = '%v'", errInner)
} else if len(strings.Trim(string(b), " ")) > 0 {
errInner = json.Unmarshal(b, v)
if errInner != nil {
err = fmt.Errorf("Error occurred unmarshalling JSON - Error = '%v' JSON = '%s'", errInner, string(b))
}
}
}
return err
})
}
} | [
"func",
"ByUnmarshallingJSON",
"(",
"v",
"interface",
"{",
"}",
")",
"RespondDecorator",
"{",
"return",
"func",
"(",
"r",
"Responder",
")",
"Responder",
"{",
"return",
"ResponderFunc",
"(",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"err",
":=",
"r",
".",
"Respond",
"(",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"b",
",",
"errInner",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"// Some responses might include a BOM, remove for successful unmarshalling",
"b",
"=",
"bytes",
".",
"TrimPrefix",
"(",
"b",
",",
"[",
"]",
"byte",
"(",
"\"",
"\\xef",
"\\xbb",
"\\xbf",
"\"",
")",
")",
"\n",
"if",
"errInner",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errInner",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"strings",
".",
"Trim",
"(",
"string",
"(",
"b",
")",
",",
"\"",
"\"",
")",
")",
">",
"0",
"{",
"errInner",
"=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"v",
")",
"\n",
"if",
"errInner",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errInner",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // ByUnmarshallingJSON returns a RespondDecorator that decodes a JSON document returned in the
// response Body into the value pointed to by v. | [
"ByUnmarshallingJSON",
"returns",
"a",
"RespondDecorator",
"that",
"decodes",
"a",
"JSON",
"document",
"returned",
"in",
"the",
"response",
"Body",
"into",
"the",
"value",
"pointed",
"to",
"by",
"v",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/responder.go#L158-L178 |
152,504 | Azure/go-autorest | autorest/responder.go | ByUnmarshallingXML | func ByUnmarshallingXML(v interface{}) RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil {
b, errInner := ioutil.ReadAll(resp.Body)
if errInner != nil {
err = fmt.Errorf("Error occurred reading http.Response#Body - Error = '%v'", errInner)
} else {
errInner = xml.Unmarshal(b, v)
if errInner != nil {
err = fmt.Errorf("Error occurred unmarshalling Xml - Error = '%v' Xml = '%s'", errInner, string(b))
}
}
}
return err
})
}
} | go | func ByUnmarshallingXML(v interface{}) RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil {
b, errInner := ioutil.ReadAll(resp.Body)
if errInner != nil {
err = fmt.Errorf("Error occurred reading http.Response#Body - Error = '%v'", errInner)
} else {
errInner = xml.Unmarshal(b, v)
if errInner != nil {
err = fmt.Errorf("Error occurred unmarshalling Xml - Error = '%v' Xml = '%s'", errInner, string(b))
}
}
}
return err
})
}
} | [
"func",
"ByUnmarshallingXML",
"(",
"v",
"interface",
"{",
"}",
")",
"RespondDecorator",
"{",
"return",
"func",
"(",
"r",
"Responder",
")",
"Responder",
"{",
"return",
"ResponderFunc",
"(",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"err",
":=",
"r",
".",
"Respond",
"(",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"b",
",",
"errInner",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"errInner",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errInner",
")",
"\n",
"}",
"else",
"{",
"errInner",
"=",
"xml",
".",
"Unmarshal",
"(",
"b",
",",
"v",
")",
"\n",
"if",
"errInner",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errInner",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // ByUnmarshallingXML returns a RespondDecorator that decodes a XML document returned in the
// response Body into the value pointed to by v. | [
"ByUnmarshallingXML",
"returns",
"a",
"RespondDecorator",
"that",
"decodes",
"a",
"XML",
"document",
"returned",
"in",
"the",
"response",
"Body",
"into",
"the",
"value",
"pointed",
"to",
"by",
"v",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/responder.go#L182-L200 |
152,505 | Azure/go-autorest | autorest/responder.go | WithErrorUnlessStatusCode | func WithErrorUnlessStatusCode(codes ...int) RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil && !ResponseHasStatusCode(resp, codes...) {
derr := NewErrorWithResponse("autorest", "WithErrorUnlessStatusCode", resp, "%v %v failed with %s",
resp.Request.Method,
resp.Request.URL,
resp.Status)
if resp.Body != nil {
defer resp.Body.Close()
b, _ := ioutil.ReadAll(resp.Body)
derr.ServiceError = b
resp.Body = ioutil.NopCloser(bytes.NewReader(b))
}
err = derr
}
return err
})
}
} | go | func WithErrorUnlessStatusCode(codes ...int) RespondDecorator {
return func(r Responder) Responder {
return ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil && !ResponseHasStatusCode(resp, codes...) {
derr := NewErrorWithResponse("autorest", "WithErrorUnlessStatusCode", resp, "%v %v failed with %s",
resp.Request.Method,
resp.Request.URL,
resp.Status)
if resp.Body != nil {
defer resp.Body.Close()
b, _ := ioutil.ReadAll(resp.Body)
derr.ServiceError = b
resp.Body = ioutil.NopCloser(bytes.NewReader(b))
}
err = derr
}
return err
})
}
} | [
"func",
"WithErrorUnlessStatusCode",
"(",
"codes",
"...",
"int",
")",
"RespondDecorator",
"{",
"return",
"func",
"(",
"r",
"Responder",
")",
"Responder",
"{",
"return",
"ResponderFunc",
"(",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"err",
":=",
"r",
".",
"Respond",
"(",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"!",
"ResponseHasStatusCode",
"(",
"resp",
",",
"codes",
"...",
")",
"{",
"derr",
":=",
"NewErrorWithResponse",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"resp",
",",
"\"",
"\"",
",",
"resp",
".",
"Request",
".",
"Method",
",",
"resp",
".",
"Request",
".",
"URL",
",",
"resp",
".",
"Status",
")",
"\n",
"if",
"resp",
".",
"Body",
"!=",
"nil",
"{",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"b",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"derr",
".",
"ServiceError",
"=",
"b",
"\n",
"resp",
".",
"Body",
"=",
"ioutil",
".",
"NopCloser",
"(",
"bytes",
".",
"NewReader",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"err",
"=",
"derr",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // WithErrorUnlessStatusCode returns a RespondDecorator that emits an error unless the response
// StatusCode is among the set passed. On error, response body is fully read into a buffer and
// presented in the returned error, as well as in the response body. | [
"WithErrorUnlessStatusCode",
"returns",
"a",
"RespondDecorator",
"that",
"emits",
"an",
"error",
"unless",
"the",
"response",
"StatusCode",
"is",
"among",
"the",
"set",
"passed",
".",
"On",
"error",
"response",
"body",
"is",
"fully",
"read",
"into",
"a",
"buffer",
"and",
"presented",
"in",
"the",
"returned",
"error",
"as",
"well",
"as",
"in",
"the",
"response",
"body",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/responder.go#L205-L225 |
152,506 | Azure/go-autorest | autorest/responder.go | ExtractHeader | func ExtractHeader(header string, resp *http.Response) []string {
if resp != nil && resp.Header != nil {
return resp.Header[http.CanonicalHeaderKey(header)]
}
return nil
} | go | func ExtractHeader(header string, resp *http.Response) []string {
if resp != nil && resp.Header != nil {
return resp.Header[http.CanonicalHeaderKey(header)]
}
return nil
} | [
"func",
"ExtractHeader",
"(",
"header",
"string",
",",
"resp",
"*",
"http",
".",
"Response",
")",
"[",
"]",
"string",
"{",
"if",
"resp",
"!=",
"nil",
"&&",
"resp",
".",
"Header",
"!=",
"nil",
"{",
"return",
"resp",
".",
"Header",
"[",
"http",
".",
"CanonicalHeaderKey",
"(",
"header",
")",
"]",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ExtractHeader extracts all values of the specified header from the http.Response. It returns an
// empty string slice if the passed http.Response is nil or the header does not exist. | [
"ExtractHeader",
"extracts",
"all",
"values",
"of",
"the",
"specified",
"header",
"from",
"the",
"http",
".",
"Response",
".",
"It",
"returns",
"an",
"empty",
"string",
"slice",
"if",
"the",
"passed",
"http",
".",
"Response",
"is",
"nil",
"or",
"the",
"header",
"does",
"not",
"exist",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/responder.go#L235-L240 |
152,507 | Azure/go-autorest | autorest/responder.go | ExtractHeaderValue | func ExtractHeaderValue(header string, resp *http.Response) string {
h := ExtractHeader(header, resp)
if len(h) > 0 {
return h[0]
}
return ""
} | go | func ExtractHeaderValue(header string, resp *http.Response) string {
h := ExtractHeader(header, resp)
if len(h) > 0 {
return h[0]
}
return ""
} | [
"func",
"ExtractHeaderValue",
"(",
"header",
"string",
",",
"resp",
"*",
"http",
".",
"Response",
")",
"string",
"{",
"h",
":=",
"ExtractHeader",
"(",
"header",
",",
"resp",
")",
"\n",
"if",
"len",
"(",
"h",
")",
">",
"0",
"{",
"return",
"h",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // ExtractHeaderValue extracts the first value of the specified header from the http.Response. It
// returns an empty string if the passed http.Response is nil or the header does not exist. | [
"ExtractHeaderValue",
"extracts",
"the",
"first",
"value",
"of",
"the",
"specified",
"header",
"from",
"the",
"http",
".",
"Response",
".",
"It",
"returns",
"an",
"empty",
"string",
"if",
"the",
"passed",
"http",
".",
"Response",
"is",
"nil",
"or",
"the",
"header",
"does",
"not",
"exist",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/responder.go#L244-L250 |
152,508 | Azure/go-autorest | autorest/azure/azure.go | UnmarshalJSON | func (se *ServiceError) UnmarshalJSON(b []byte) error {
// per the OData v4 spec the details field must be an array of JSON objects.
// unfortunately not all services adhear to the spec and just return a single
// object instead of an array with one object. so we have to perform some
// shenanigans to accommodate both cases.
// http://docs.oasis-open.org/odata/odata-json-format/v4.0/os/odata-json-format-v4.0-os.html#_Toc372793091
type serviceError1 struct {
Code string `json:"code"`
Message string `json:"message"`
Target *string `json:"target"`
Details []map[string]interface{} `json:"details"`
InnerError map[string]interface{} `json:"innererror"`
AdditionalInfo []map[string]interface{} `json:"additionalInfo"`
}
type serviceError2 struct {
Code string `json:"code"`
Message string `json:"message"`
Target *string `json:"target"`
Details map[string]interface{} `json:"details"`
InnerError map[string]interface{} `json:"innererror"`
AdditionalInfo []map[string]interface{} `json:"additionalInfo"`
}
se1 := serviceError1{}
err := json.Unmarshal(b, &se1)
if err == nil {
se.populate(se1.Code, se1.Message, se1.Target, se1.Details, se1.InnerError, se1.AdditionalInfo)
return nil
}
se2 := serviceError2{}
err = json.Unmarshal(b, &se2)
if err == nil {
se.populate(se2.Code, se2.Message, se2.Target, nil, se2.InnerError, se2.AdditionalInfo)
se.Details = append(se.Details, se2.Details)
return nil
}
return err
} | go | func (se *ServiceError) UnmarshalJSON(b []byte) error {
// per the OData v4 spec the details field must be an array of JSON objects.
// unfortunately not all services adhear to the spec and just return a single
// object instead of an array with one object. so we have to perform some
// shenanigans to accommodate both cases.
// http://docs.oasis-open.org/odata/odata-json-format/v4.0/os/odata-json-format-v4.0-os.html#_Toc372793091
type serviceError1 struct {
Code string `json:"code"`
Message string `json:"message"`
Target *string `json:"target"`
Details []map[string]interface{} `json:"details"`
InnerError map[string]interface{} `json:"innererror"`
AdditionalInfo []map[string]interface{} `json:"additionalInfo"`
}
type serviceError2 struct {
Code string `json:"code"`
Message string `json:"message"`
Target *string `json:"target"`
Details map[string]interface{} `json:"details"`
InnerError map[string]interface{} `json:"innererror"`
AdditionalInfo []map[string]interface{} `json:"additionalInfo"`
}
se1 := serviceError1{}
err := json.Unmarshal(b, &se1)
if err == nil {
se.populate(se1.Code, se1.Message, se1.Target, se1.Details, se1.InnerError, se1.AdditionalInfo)
return nil
}
se2 := serviceError2{}
err = json.Unmarshal(b, &se2)
if err == nil {
se.populate(se2.Code, se2.Message, se2.Target, nil, se2.InnerError, se2.AdditionalInfo)
se.Details = append(se.Details, se2.Details)
return nil
}
return err
} | [
"func",
"(",
"se",
"*",
"ServiceError",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"// per the OData v4 spec the details field must be an array of JSON objects.",
"// unfortunately not all services adhear to the spec and just return a single",
"// object instead of an array with one object. so we have to perform some",
"// shenanigans to accommodate both cases.",
"// http://docs.oasis-open.org/odata/odata-json-format/v4.0/os/odata-json-format-v4.0-os.html#_Toc372793091",
"type",
"serviceError1",
"struct",
"{",
"Code",
"string",
"`json:\"code\"`",
"\n",
"Message",
"string",
"`json:\"message\"`",
"\n",
"Target",
"*",
"string",
"`json:\"target\"`",
"\n",
"Details",
"[",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"`json:\"details\"`",
"\n",
"InnerError",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"`json:\"innererror\"`",
"\n",
"AdditionalInfo",
"[",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"`json:\"additionalInfo\"`",
"\n",
"}",
"\n\n",
"type",
"serviceError2",
"struct",
"{",
"Code",
"string",
"`json:\"code\"`",
"\n",
"Message",
"string",
"`json:\"message\"`",
"\n",
"Target",
"*",
"string",
"`json:\"target\"`",
"\n",
"Details",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"`json:\"details\"`",
"\n",
"InnerError",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"`json:\"innererror\"`",
"\n",
"AdditionalInfo",
"[",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"`json:\"additionalInfo\"`",
"\n",
"}",
"\n\n",
"se1",
":=",
"serviceError1",
"{",
"}",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"se1",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"se",
".",
"populate",
"(",
"se1",
".",
"Code",
",",
"se1",
".",
"Message",
",",
"se1",
".",
"Target",
",",
"se1",
".",
"Details",
",",
"se1",
".",
"InnerError",
",",
"se1",
".",
"AdditionalInfo",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"se2",
":=",
"serviceError2",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"se2",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"se",
".",
"populate",
"(",
"se2",
".",
"Code",
",",
"se2",
".",
"Message",
",",
"se2",
".",
"Target",
",",
"nil",
",",
"se2",
".",
"InnerError",
",",
"se2",
".",
"AdditionalInfo",
")",
"\n",
"se",
".",
"Details",
"=",
"append",
"(",
"se",
".",
"Details",
",",
"se2",
".",
"Details",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // UnmarshalJSON implements the json.Unmarshaler interface for the ServiceError type. | [
"UnmarshalJSON",
"implements",
"the",
"json",
".",
"Unmarshaler",
"interface",
"for",
"the",
"ServiceError",
"type",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/azure.go#L90-L130 |
152,509 | Azure/go-autorest | autorest/azure/azure.go | Error | func (e RequestError) Error() string {
return fmt.Sprintf("autorest/azure: Service returned an error. Status=%v %v",
e.StatusCode, e.ServiceError)
} | go | func (e RequestError) Error() string {
return fmt.Sprintf("autorest/azure: Service returned an error. Status=%v %v",
e.StatusCode, e.ServiceError)
} | [
"func",
"(",
"e",
"RequestError",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"StatusCode",
",",
"e",
".",
"ServiceError",
")",
"\n",
"}"
] | // Error returns a human-friendly error message from service error. | [
"Error",
"returns",
"a",
"human",
"-",
"friendly",
"error",
"message",
"from",
"service",
"error",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/azure.go#L153-L156 |
152,510 | Azure/go-autorest | autorest/azure/azure.go | WithReturnClientID | func WithReturnClientID(b bool) autorest.PrepareDecorator {
return autorest.WithHeader(HeaderReturnClientID, strconv.FormatBool(b))
} | go | func WithReturnClientID(b bool) autorest.PrepareDecorator {
return autorest.WithHeader(HeaderReturnClientID, strconv.FormatBool(b))
} | [
"func",
"WithReturnClientID",
"(",
"b",
"bool",
")",
"autorest",
".",
"PrepareDecorator",
"{",
"return",
"autorest",
".",
"WithHeader",
"(",
"HeaderReturnClientID",
",",
"strconv",
".",
"FormatBool",
"(",
"b",
")",
")",
"\n",
"}"
] | // WithReturnClientID returns a PrepareDecorator that adds an HTTP extension header of
// x-ms-return-client-request-id whose boolean value indicates if the value of the
// x-ms-client-request-id header should be included in the http.Response. | [
"WithReturnClientID",
"returns",
"a",
"PrepareDecorator",
"that",
"adds",
"an",
"HTTP",
"extension",
"header",
"of",
"x",
"-",
"ms",
"-",
"return",
"-",
"client",
"-",
"request",
"-",
"id",
"whose",
"boolean",
"value",
"indicates",
"if",
"the",
"value",
"of",
"the",
"x",
"-",
"ms",
"-",
"client",
"-",
"request",
"-",
"id",
"header",
"should",
"be",
"included",
"in",
"the",
"http",
".",
"Response",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/azure.go#L253-L255 |
152,511 | Azure/go-autorest | autorest/azure/azure.go | WithErrorUnlessStatusCode | func WithErrorUnlessStatusCode(codes ...int) autorest.RespondDecorator {
return func(r autorest.Responder) autorest.Responder {
return autorest.ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil && !autorest.ResponseHasStatusCode(resp, codes...) {
var e RequestError
defer resp.Body.Close()
// Copy and replace the Body in case it does not contain an error object.
// This will leave the Body available to the caller.
b, decodeErr := autorest.CopyAndDecode(autorest.EncodedAsJSON, resp.Body, &e)
resp.Body = ioutil.NopCloser(&b)
if decodeErr != nil {
return fmt.Errorf("autorest/azure: error response cannot be parsed: %q error: %v", b.String(), decodeErr)
}
if e.ServiceError == nil {
// Check if error is unwrapped ServiceError
if err := json.Unmarshal(b.Bytes(), &e.ServiceError); err != nil {
return err
}
}
if e.ServiceError.Message == "" {
// if we're here it means the returned error wasn't OData v4 compliant.
// try to unmarshal the body as raw JSON in hopes of getting something.
rawBody := map[string]interface{}{}
if err := json.Unmarshal(b.Bytes(), &rawBody); err != nil {
return err
}
e.ServiceError = &ServiceError{
Code: "Unknown",
Message: "Unknown service error",
}
if len(rawBody) > 0 {
e.ServiceError.Details = []map[string]interface{}{rawBody}
}
}
e.Response = resp
e.RequestID = ExtractRequestID(resp)
if e.StatusCode == nil {
e.StatusCode = resp.StatusCode
}
err = &e
}
return err
})
}
} | go | func WithErrorUnlessStatusCode(codes ...int) autorest.RespondDecorator {
return func(r autorest.Responder) autorest.Responder {
return autorest.ResponderFunc(func(resp *http.Response) error {
err := r.Respond(resp)
if err == nil && !autorest.ResponseHasStatusCode(resp, codes...) {
var e RequestError
defer resp.Body.Close()
// Copy and replace the Body in case it does not contain an error object.
// This will leave the Body available to the caller.
b, decodeErr := autorest.CopyAndDecode(autorest.EncodedAsJSON, resp.Body, &e)
resp.Body = ioutil.NopCloser(&b)
if decodeErr != nil {
return fmt.Errorf("autorest/azure: error response cannot be parsed: %q error: %v", b.String(), decodeErr)
}
if e.ServiceError == nil {
// Check if error is unwrapped ServiceError
if err := json.Unmarshal(b.Bytes(), &e.ServiceError); err != nil {
return err
}
}
if e.ServiceError.Message == "" {
// if we're here it means the returned error wasn't OData v4 compliant.
// try to unmarshal the body as raw JSON in hopes of getting something.
rawBody := map[string]interface{}{}
if err := json.Unmarshal(b.Bytes(), &rawBody); err != nil {
return err
}
e.ServiceError = &ServiceError{
Code: "Unknown",
Message: "Unknown service error",
}
if len(rawBody) > 0 {
e.ServiceError.Details = []map[string]interface{}{rawBody}
}
}
e.Response = resp
e.RequestID = ExtractRequestID(resp)
if e.StatusCode == nil {
e.StatusCode = resp.StatusCode
}
err = &e
}
return err
})
}
} | [
"func",
"WithErrorUnlessStatusCode",
"(",
"codes",
"...",
"int",
")",
"autorest",
".",
"RespondDecorator",
"{",
"return",
"func",
"(",
"r",
"autorest",
".",
"Responder",
")",
"autorest",
".",
"Responder",
"{",
"return",
"autorest",
".",
"ResponderFunc",
"(",
"func",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"err",
":=",
"r",
".",
"Respond",
"(",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"!",
"autorest",
".",
"ResponseHasStatusCode",
"(",
"resp",
",",
"codes",
"...",
")",
"{",
"var",
"e",
"RequestError",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"// Copy and replace the Body in case it does not contain an error object.",
"// This will leave the Body available to the caller.",
"b",
",",
"decodeErr",
":=",
"autorest",
".",
"CopyAndDecode",
"(",
"autorest",
".",
"EncodedAsJSON",
",",
"resp",
".",
"Body",
",",
"&",
"e",
")",
"\n",
"resp",
".",
"Body",
"=",
"ioutil",
".",
"NopCloser",
"(",
"&",
"b",
")",
"\n",
"if",
"decodeErr",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"b",
".",
"String",
"(",
")",
",",
"decodeErr",
")",
"\n",
"}",
"\n",
"if",
"e",
".",
"ServiceError",
"==",
"nil",
"{",
"// Check if error is unwrapped ServiceError",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
".",
"Bytes",
"(",
")",
",",
"&",
"e",
".",
"ServiceError",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"e",
".",
"ServiceError",
".",
"Message",
"==",
"\"",
"\"",
"{",
"// if we're here it means the returned error wasn't OData v4 compliant.",
"// try to unmarshal the body as raw JSON in hopes of getting something.",
"rawBody",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
".",
"Bytes",
"(",
")",
",",
"&",
"rawBody",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"e",
".",
"ServiceError",
"=",
"&",
"ServiceError",
"{",
"Code",
":",
"\"",
"\"",
",",
"Message",
":",
"\"",
"\"",
",",
"}",
"\n",
"if",
"len",
"(",
"rawBody",
")",
">",
"0",
"{",
"e",
".",
"ServiceError",
".",
"Details",
"=",
"[",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"rawBody",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"e",
".",
"Response",
"=",
"resp",
"\n",
"e",
".",
"RequestID",
"=",
"ExtractRequestID",
"(",
"resp",
")",
"\n",
"if",
"e",
".",
"StatusCode",
"==",
"nil",
"{",
"e",
".",
"StatusCode",
"=",
"resp",
".",
"StatusCode",
"\n",
"}",
"\n",
"err",
"=",
"&",
"e",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // WithErrorUnlessStatusCode returns a RespondDecorator that emits an
// azure.RequestError by reading the response body unless the response HTTP status code
// is among the set passed.
//
// If there is a chance service may return responses other than the Azure error
// format and the response cannot be parsed into an error, a decoding error will
// be returned containing the response body. In any case, the Responder will
// return an error if the status code is not satisfied.
//
// If this Responder returns an error, the response body will be replaced with
// an in-memory reader, which needs no further closing. | [
"WithErrorUnlessStatusCode",
"returns",
"a",
"RespondDecorator",
"that",
"emits",
"an",
"azure",
".",
"RequestError",
"by",
"reading",
"the",
"response",
"body",
"unless",
"the",
"response",
"HTTP",
"status",
"code",
"is",
"among",
"the",
"set",
"passed",
".",
"If",
"there",
"is",
"a",
"chance",
"service",
"may",
"return",
"responses",
"other",
"than",
"the",
"Azure",
"error",
"format",
"and",
"the",
"response",
"cannot",
"be",
"parsed",
"into",
"an",
"error",
"a",
"decoding",
"error",
"will",
"be",
"returned",
"containing",
"the",
"response",
"body",
".",
"In",
"any",
"case",
"the",
"Responder",
"will",
"return",
"an",
"error",
"if",
"the",
"status",
"code",
"is",
"not",
"satisfied",
".",
"If",
"this",
"Responder",
"returns",
"an",
"error",
"the",
"response",
"body",
"will",
"be",
"replaced",
"with",
"an",
"in",
"-",
"memory",
"reader",
"which",
"needs",
"no",
"further",
"closing",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/azure.go#L280-L326 |
152,512 | Azure/go-autorest | autorest/azure/auth/auth.go | GetSettingsFromEnvironment | func GetSettingsFromEnvironment() (s EnvironmentSettings, err error) {
s = EnvironmentSettings{
Values: map[string]string{},
}
s.setValue(SubscriptionID)
s.setValue(TenantID)
s.setValue(ClientID)
s.setValue(ClientSecret)
s.setValue(CertificatePath)
s.setValue(CertificatePassword)
s.setValue(Username)
s.setValue(Password)
s.setValue(EnvironmentName)
s.setValue(Resource)
if v := s.Values[EnvironmentName]; v == "" {
s.Environment = azure.PublicCloud
} else {
s.Environment, err = azure.EnvironmentFromName(v)
}
if s.Values[Resource] == "" {
s.Values[Resource] = s.Environment.ResourceManagerEndpoint
}
return
} | go | func GetSettingsFromEnvironment() (s EnvironmentSettings, err error) {
s = EnvironmentSettings{
Values: map[string]string{},
}
s.setValue(SubscriptionID)
s.setValue(TenantID)
s.setValue(ClientID)
s.setValue(ClientSecret)
s.setValue(CertificatePath)
s.setValue(CertificatePassword)
s.setValue(Username)
s.setValue(Password)
s.setValue(EnvironmentName)
s.setValue(Resource)
if v := s.Values[EnvironmentName]; v == "" {
s.Environment = azure.PublicCloud
} else {
s.Environment, err = azure.EnvironmentFromName(v)
}
if s.Values[Resource] == "" {
s.Values[Resource] = s.Environment.ResourceManagerEndpoint
}
return
} | [
"func",
"GetSettingsFromEnvironment",
"(",
")",
"(",
"s",
"EnvironmentSettings",
",",
"err",
"error",
")",
"{",
"s",
"=",
"EnvironmentSettings",
"{",
"Values",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"}",
"\n",
"s",
".",
"setValue",
"(",
"SubscriptionID",
")",
"\n",
"s",
".",
"setValue",
"(",
"TenantID",
")",
"\n",
"s",
".",
"setValue",
"(",
"ClientID",
")",
"\n",
"s",
".",
"setValue",
"(",
"ClientSecret",
")",
"\n",
"s",
".",
"setValue",
"(",
"CertificatePath",
")",
"\n",
"s",
".",
"setValue",
"(",
"CertificatePassword",
")",
"\n",
"s",
".",
"setValue",
"(",
"Username",
")",
"\n",
"s",
".",
"setValue",
"(",
"Password",
")",
"\n",
"s",
".",
"setValue",
"(",
"EnvironmentName",
")",
"\n",
"s",
".",
"setValue",
"(",
"Resource",
")",
"\n",
"if",
"v",
":=",
"s",
".",
"Values",
"[",
"EnvironmentName",
"]",
";",
"v",
"==",
"\"",
"\"",
"{",
"s",
".",
"Environment",
"=",
"azure",
".",
"PublicCloud",
"\n",
"}",
"else",
"{",
"s",
".",
"Environment",
",",
"err",
"=",
"azure",
".",
"EnvironmentFromName",
"(",
"v",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"Values",
"[",
"Resource",
"]",
"==",
"\"",
"\"",
"{",
"s",
".",
"Values",
"[",
"Resource",
"]",
"=",
"s",
".",
"Environment",
".",
"ResourceManagerEndpoint",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // GetSettingsFromEnvironment returns the available authentication settings from the environment. | [
"GetSettingsFromEnvironment",
"returns",
"the",
"available",
"authentication",
"settings",
"from",
"the",
"environment",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L93-L116 |
152,513 | Azure/go-autorest | autorest/azure/auth/auth.go | setValue | func (settings EnvironmentSettings) setValue(key string) {
if v := os.Getenv(key); v != "" {
settings.Values[key] = v
}
} | go | func (settings EnvironmentSettings) setValue(key string) {
if v := os.Getenv(key); v != "" {
settings.Values[key] = v
}
} | [
"func",
"(",
"settings",
"EnvironmentSettings",
")",
"setValue",
"(",
"key",
"string",
")",
"{",
"if",
"v",
":=",
"os",
".",
"Getenv",
"(",
"key",
")",
";",
"v",
"!=",
"\"",
"\"",
"{",
"settings",
".",
"Values",
"[",
"key",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}"
] | // adds the specified environment variable value to the Values map if it exists | [
"adds",
"the",
"specified",
"environment",
"variable",
"value",
"to",
"the",
"Values",
"map",
"if",
"it",
"exists"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L124-L128 |
152,514 | Azure/go-autorest | autorest/azure/auth/auth.go | getClientAndTenant | func (settings EnvironmentSettings) getClientAndTenant() (string, string) {
clientID := settings.Values[ClientID]
tenantID := settings.Values[TenantID]
return clientID, tenantID
} | go | func (settings EnvironmentSettings) getClientAndTenant() (string, string) {
clientID := settings.Values[ClientID]
tenantID := settings.Values[TenantID]
return clientID, tenantID
} | [
"func",
"(",
"settings",
"EnvironmentSettings",
")",
"getClientAndTenant",
"(",
")",
"(",
"string",
",",
"string",
")",
"{",
"clientID",
":=",
"settings",
".",
"Values",
"[",
"ClientID",
"]",
"\n",
"tenantID",
":=",
"settings",
".",
"Values",
"[",
"TenantID",
"]",
"\n",
"return",
"clientID",
",",
"tenantID",
"\n",
"}"
] | // helper to return client and tenant IDs | [
"helper",
"to",
"return",
"client",
"and",
"tenant",
"IDs"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L131-L135 |
152,515 | Azure/go-autorest | autorest/azure/auth/auth.go | GetClientCredentials | func (settings EnvironmentSettings) GetClientCredentials() (ClientCredentialsConfig, error) {
secret := settings.Values[ClientSecret]
if secret == "" {
return ClientCredentialsConfig{}, errors.New("missing client secret")
}
clientID, tenantID := settings.getClientAndTenant()
config := NewClientCredentialsConfig(clientID, secret, tenantID)
config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
config.Resource = settings.Values[Resource]
return config, nil
} | go | func (settings EnvironmentSettings) GetClientCredentials() (ClientCredentialsConfig, error) {
secret := settings.Values[ClientSecret]
if secret == "" {
return ClientCredentialsConfig{}, errors.New("missing client secret")
}
clientID, tenantID := settings.getClientAndTenant()
config := NewClientCredentialsConfig(clientID, secret, tenantID)
config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
config.Resource = settings.Values[Resource]
return config, nil
} | [
"func",
"(",
"settings",
"EnvironmentSettings",
")",
"GetClientCredentials",
"(",
")",
"(",
"ClientCredentialsConfig",
",",
"error",
")",
"{",
"secret",
":=",
"settings",
".",
"Values",
"[",
"ClientSecret",
"]",
"\n",
"if",
"secret",
"==",
"\"",
"\"",
"{",
"return",
"ClientCredentialsConfig",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"clientID",
",",
"tenantID",
":=",
"settings",
".",
"getClientAndTenant",
"(",
")",
"\n",
"config",
":=",
"NewClientCredentialsConfig",
"(",
"clientID",
",",
"secret",
",",
"tenantID",
")",
"\n",
"config",
".",
"AADEndpoint",
"=",
"settings",
".",
"Environment",
".",
"ActiveDirectoryEndpoint",
"\n",
"config",
".",
"Resource",
"=",
"settings",
".",
"Values",
"[",
"Resource",
"]",
"\n",
"return",
"config",
",",
"nil",
"\n",
"}"
] | // GetClientCredentials creates a config object from the available client credentials.
// An error is returned if no client credentials are available. | [
"GetClientCredentials",
"creates",
"a",
"config",
"object",
"from",
"the",
"available",
"client",
"credentials",
".",
"An",
"error",
"is",
"returned",
"if",
"no",
"client",
"credentials",
"are",
"available",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L139-L149 |
152,516 | Azure/go-autorest | autorest/azure/auth/auth.go | GetClientCertificate | func (settings EnvironmentSettings) GetClientCertificate() (ClientCertificateConfig, error) {
certPath := settings.Values[CertificatePath]
if certPath == "" {
return ClientCertificateConfig{}, errors.New("missing certificate path")
}
certPwd := settings.Values[CertificatePassword]
clientID, tenantID := settings.getClientAndTenant()
config := NewClientCertificateConfig(certPath, certPwd, clientID, tenantID)
config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
config.Resource = settings.Values[Resource]
return config, nil
} | go | func (settings EnvironmentSettings) GetClientCertificate() (ClientCertificateConfig, error) {
certPath := settings.Values[CertificatePath]
if certPath == "" {
return ClientCertificateConfig{}, errors.New("missing certificate path")
}
certPwd := settings.Values[CertificatePassword]
clientID, tenantID := settings.getClientAndTenant()
config := NewClientCertificateConfig(certPath, certPwd, clientID, tenantID)
config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
config.Resource = settings.Values[Resource]
return config, nil
} | [
"func",
"(",
"settings",
"EnvironmentSettings",
")",
"GetClientCertificate",
"(",
")",
"(",
"ClientCertificateConfig",
",",
"error",
")",
"{",
"certPath",
":=",
"settings",
".",
"Values",
"[",
"CertificatePath",
"]",
"\n",
"if",
"certPath",
"==",
"\"",
"\"",
"{",
"return",
"ClientCertificateConfig",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"certPwd",
":=",
"settings",
".",
"Values",
"[",
"CertificatePassword",
"]",
"\n",
"clientID",
",",
"tenantID",
":=",
"settings",
".",
"getClientAndTenant",
"(",
")",
"\n",
"config",
":=",
"NewClientCertificateConfig",
"(",
"certPath",
",",
"certPwd",
",",
"clientID",
",",
"tenantID",
")",
"\n",
"config",
".",
"AADEndpoint",
"=",
"settings",
".",
"Environment",
".",
"ActiveDirectoryEndpoint",
"\n",
"config",
".",
"Resource",
"=",
"settings",
".",
"Values",
"[",
"Resource",
"]",
"\n",
"return",
"config",
",",
"nil",
"\n",
"}"
] | // GetClientCertificate creates a config object from the available certificate credentials.
// An error is returned if no certificate credentials are available. | [
"GetClientCertificate",
"creates",
"a",
"config",
"object",
"from",
"the",
"available",
"certificate",
"credentials",
".",
"An",
"error",
"is",
"returned",
"if",
"no",
"certificate",
"credentials",
"are",
"available",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L153-L164 |
152,517 | Azure/go-autorest | autorest/azure/auth/auth.go | GetMSI | func (settings EnvironmentSettings) GetMSI() MSIConfig {
config := NewMSIConfig()
config.Resource = settings.Values[Resource]
config.ClientID = settings.Values[ClientID]
return config
} | go | func (settings EnvironmentSettings) GetMSI() MSIConfig {
config := NewMSIConfig()
config.Resource = settings.Values[Resource]
config.ClientID = settings.Values[ClientID]
return config
} | [
"func",
"(",
"settings",
"EnvironmentSettings",
")",
"GetMSI",
"(",
")",
"MSIConfig",
"{",
"config",
":=",
"NewMSIConfig",
"(",
")",
"\n",
"config",
".",
"Resource",
"=",
"settings",
".",
"Values",
"[",
"Resource",
"]",
"\n",
"config",
".",
"ClientID",
"=",
"settings",
".",
"Values",
"[",
"ClientID",
"]",
"\n",
"return",
"config",
"\n",
"}"
] | // GetMSI creates a MSI config object from the available client ID. | [
"GetMSI",
"creates",
"a",
"MSI",
"config",
"object",
"from",
"the",
"available",
"client",
"ID",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L182-L187 |
152,518 | Azure/go-autorest | autorest/azure/auth/auth.go | GetDeviceFlow | func (settings EnvironmentSettings) GetDeviceFlow() DeviceFlowConfig {
clientID, tenantID := settings.getClientAndTenant()
config := NewDeviceFlowConfig(clientID, tenantID)
config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
config.Resource = settings.Values[Resource]
return config
} | go | func (settings EnvironmentSettings) GetDeviceFlow() DeviceFlowConfig {
clientID, tenantID := settings.getClientAndTenant()
config := NewDeviceFlowConfig(clientID, tenantID)
config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
config.Resource = settings.Values[Resource]
return config
} | [
"func",
"(",
"settings",
"EnvironmentSettings",
")",
"GetDeviceFlow",
"(",
")",
"DeviceFlowConfig",
"{",
"clientID",
",",
"tenantID",
":=",
"settings",
".",
"getClientAndTenant",
"(",
")",
"\n",
"config",
":=",
"NewDeviceFlowConfig",
"(",
"clientID",
",",
"tenantID",
")",
"\n",
"config",
".",
"AADEndpoint",
"=",
"settings",
".",
"Environment",
".",
"ActiveDirectoryEndpoint",
"\n",
"config",
".",
"Resource",
"=",
"settings",
".",
"Values",
"[",
"Resource",
"]",
"\n",
"return",
"config",
"\n",
"}"
] | // GetDeviceFlow creates a device-flow config object from the available client and tenant IDs. | [
"GetDeviceFlow",
"creates",
"a",
"device",
"-",
"flow",
"config",
"object",
"from",
"the",
"available",
"client",
"and",
"tenant",
"IDs",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L190-L196 |
152,519 | Azure/go-autorest | autorest/azure/auth/auth.go | NewAuthorizerFromFile | func NewAuthorizerFromFile(baseURI string) (autorest.Authorizer, error) {
settings, err := GetSettingsFromFile()
if err != nil {
return nil, err
}
if a, err := settings.ClientCredentialsAuthorizer(baseURI); err == nil {
return a, err
}
if a, err := settings.ClientCertificateAuthorizer(baseURI); err == nil {
return a, err
}
return nil, errors.New("auth file missing client and certificate credentials")
} | go | func NewAuthorizerFromFile(baseURI string) (autorest.Authorizer, error) {
settings, err := GetSettingsFromFile()
if err != nil {
return nil, err
}
if a, err := settings.ClientCredentialsAuthorizer(baseURI); err == nil {
return a, err
}
if a, err := settings.ClientCertificateAuthorizer(baseURI); err == nil {
return a, err
}
return nil, errors.New("auth file missing client and certificate credentials")
} | [
"func",
"NewAuthorizerFromFile",
"(",
"baseURI",
"string",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"settings",
",",
"err",
":=",
"GetSettingsFromFile",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"a",
",",
"err",
":=",
"settings",
".",
"ClientCredentialsAuthorizer",
"(",
"baseURI",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"a",
",",
"err",
"\n",
"}",
"\n",
"if",
"a",
",",
"err",
":=",
"settings",
".",
"ClientCertificateAuthorizer",
"(",
"baseURI",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"a",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // NewAuthorizerFromFile creates an Authorizer configured from a configuration file in the following order.
// 1. Client credentials
// 2. Client certificate | [
"NewAuthorizerFromFile",
"creates",
"an",
"Authorizer",
"configured",
"from",
"a",
"configuration",
"file",
"in",
"the",
"following",
"order",
".",
"1",
".",
"Client",
"credentials",
"2",
".",
"Client",
"certificate"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L226-L238 |
152,520 | Azure/go-autorest | autorest/azure/auth/auth.go | NewAuthorizerFromFileWithResource | func NewAuthorizerFromFileWithResource(resource string) (autorest.Authorizer, error) {
s, err := GetSettingsFromFile()
if err != nil {
return nil, err
}
if a, err := s.ClientCredentialsAuthorizerWithResource(resource); err == nil {
return a, err
}
if a, err := s.ClientCertificateAuthorizerWithResource(resource); err == nil {
return a, err
}
return nil, errors.New("auth file missing client and certificate credentials")
} | go | func NewAuthorizerFromFileWithResource(resource string) (autorest.Authorizer, error) {
s, err := GetSettingsFromFile()
if err != nil {
return nil, err
}
if a, err := s.ClientCredentialsAuthorizerWithResource(resource); err == nil {
return a, err
}
if a, err := s.ClientCertificateAuthorizerWithResource(resource); err == nil {
return a, err
}
return nil, errors.New("auth file missing client and certificate credentials")
} | [
"func",
"NewAuthorizerFromFileWithResource",
"(",
"resource",
"string",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"GetSettingsFromFile",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"a",
",",
"err",
":=",
"s",
".",
"ClientCredentialsAuthorizerWithResource",
"(",
"resource",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"a",
",",
"err",
"\n",
"}",
"\n",
"if",
"a",
",",
"err",
":=",
"s",
".",
"ClientCertificateAuthorizerWithResource",
"(",
"resource",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"a",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // NewAuthorizerFromFileWithResource creates an Authorizer configured from a configuration file in the following order.
// 1. Client credentials
// 2. Client certificate | [
"NewAuthorizerFromFileWithResource",
"creates",
"an",
"Authorizer",
"configured",
"from",
"a",
"configuration",
"file",
"in",
"the",
"following",
"order",
".",
"1",
".",
"Client",
"credentials",
"2",
".",
"Client",
"certificate"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L243-L255 |
152,521 | Azure/go-autorest | autorest/azure/auth/auth.go | NewAuthorizerFromCLI | func NewAuthorizerFromCLI() (autorest.Authorizer, error) {
settings, err := GetSettingsFromEnvironment()
if err != nil {
return nil, err
}
if settings.Values[Resource] == "" {
settings.Values[Resource] = settings.Environment.ResourceManagerEndpoint
}
return NewAuthorizerFromCLIWithResource(settings.Values[Resource])
} | go | func NewAuthorizerFromCLI() (autorest.Authorizer, error) {
settings, err := GetSettingsFromEnvironment()
if err != nil {
return nil, err
}
if settings.Values[Resource] == "" {
settings.Values[Resource] = settings.Environment.ResourceManagerEndpoint
}
return NewAuthorizerFromCLIWithResource(settings.Values[Resource])
} | [
"func",
"NewAuthorizerFromCLI",
"(",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"settings",
",",
"err",
":=",
"GetSettingsFromEnvironment",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"settings",
".",
"Values",
"[",
"Resource",
"]",
"==",
"\"",
"\"",
"{",
"settings",
".",
"Values",
"[",
"Resource",
"]",
"=",
"settings",
".",
"Environment",
".",
"ResourceManagerEndpoint",
"\n",
"}",
"\n\n",
"return",
"NewAuthorizerFromCLIWithResource",
"(",
"settings",
".",
"Values",
"[",
"Resource",
"]",
")",
"\n",
"}"
] | // NewAuthorizerFromCLI creates an Authorizer configured from Azure CLI 2.0 for local development scenarios. | [
"NewAuthorizerFromCLI",
"creates",
"an",
"Authorizer",
"configured",
"from",
"Azure",
"CLI",
"2",
".",
"0",
"for",
"local",
"development",
"scenarios",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L258-L269 |
152,522 | Azure/go-autorest | autorest/azure/auth/auth.go | NewAuthorizerFromCLIWithResource | func NewAuthorizerFromCLIWithResource(resource string) (autorest.Authorizer, error) {
token, err := cli.GetTokenFromCLI(resource)
if err != nil {
return nil, err
}
adalToken, err := token.ToADALToken()
if err != nil {
return nil, err
}
return autorest.NewBearerAuthorizer(&adalToken), nil
} | go | func NewAuthorizerFromCLIWithResource(resource string) (autorest.Authorizer, error) {
token, err := cli.GetTokenFromCLI(resource)
if err != nil {
return nil, err
}
adalToken, err := token.ToADALToken()
if err != nil {
return nil, err
}
return autorest.NewBearerAuthorizer(&adalToken), nil
} | [
"func",
"NewAuthorizerFromCLIWithResource",
"(",
"resource",
"string",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"token",
",",
"err",
":=",
"cli",
".",
"GetTokenFromCLI",
"(",
"resource",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"adalToken",
",",
"err",
":=",
"token",
".",
"ToADALToken",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"autorest",
".",
"NewBearerAuthorizer",
"(",
"&",
"adalToken",
")",
",",
"nil",
"\n",
"}"
] | // NewAuthorizerFromCLIWithResource creates an Authorizer configured from Azure CLI 2.0 for local development scenarios. | [
"NewAuthorizerFromCLIWithResource",
"creates",
"an",
"Authorizer",
"configured",
"from",
"Azure",
"CLI",
"2",
".",
"0",
"for",
"local",
"development",
"scenarios",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L272-L284 |
152,523 | Azure/go-autorest | autorest/azure/auth/auth.go | GetSettingsFromFile | func GetSettingsFromFile() (FileSettings, error) {
s := FileSettings{}
fileLocation := os.Getenv("AZURE_AUTH_LOCATION")
if fileLocation == "" {
return s, errors.New("environment variable AZURE_AUTH_LOCATION is not set")
}
contents, err := ioutil.ReadFile(fileLocation)
if err != nil {
return s, err
}
// Auth file might be encoded
decoded, err := decode(contents)
if err != nil {
return s, err
}
authFile := map[string]interface{}{}
err = json.Unmarshal(decoded, &authFile)
if err != nil {
return s, err
}
s.Values = map[string]string{}
s.setKeyValue(ClientID, authFile["clientId"])
s.setKeyValue(ClientSecret, authFile["clientSecret"])
s.setKeyValue(CertificatePath, authFile["clientCertificate"])
s.setKeyValue(CertificatePassword, authFile["clientCertificatePassword"])
s.setKeyValue(SubscriptionID, authFile["subscriptionId"])
s.setKeyValue(TenantID, authFile["tenantId"])
s.setKeyValue(ActiveDirectoryEndpoint, authFile["activeDirectoryEndpointUrl"])
s.setKeyValue(ResourceManagerEndpoint, authFile["resourceManagerEndpointUrl"])
s.setKeyValue(GraphResourceID, authFile["activeDirectoryGraphResourceId"])
s.setKeyValue(SQLManagementEndpoint, authFile["sqlManagementEndpointUrl"])
s.setKeyValue(GalleryEndpoint, authFile["galleryEndpointUrl"])
s.setKeyValue(ManagementEndpoint, authFile["managementEndpointUrl"])
return s, nil
} | go | func GetSettingsFromFile() (FileSettings, error) {
s := FileSettings{}
fileLocation := os.Getenv("AZURE_AUTH_LOCATION")
if fileLocation == "" {
return s, errors.New("environment variable AZURE_AUTH_LOCATION is not set")
}
contents, err := ioutil.ReadFile(fileLocation)
if err != nil {
return s, err
}
// Auth file might be encoded
decoded, err := decode(contents)
if err != nil {
return s, err
}
authFile := map[string]interface{}{}
err = json.Unmarshal(decoded, &authFile)
if err != nil {
return s, err
}
s.Values = map[string]string{}
s.setKeyValue(ClientID, authFile["clientId"])
s.setKeyValue(ClientSecret, authFile["clientSecret"])
s.setKeyValue(CertificatePath, authFile["clientCertificate"])
s.setKeyValue(CertificatePassword, authFile["clientCertificatePassword"])
s.setKeyValue(SubscriptionID, authFile["subscriptionId"])
s.setKeyValue(TenantID, authFile["tenantId"])
s.setKeyValue(ActiveDirectoryEndpoint, authFile["activeDirectoryEndpointUrl"])
s.setKeyValue(ResourceManagerEndpoint, authFile["resourceManagerEndpointUrl"])
s.setKeyValue(GraphResourceID, authFile["activeDirectoryGraphResourceId"])
s.setKeyValue(SQLManagementEndpoint, authFile["sqlManagementEndpointUrl"])
s.setKeyValue(GalleryEndpoint, authFile["galleryEndpointUrl"])
s.setKeyValue(ManagementEndpoint, authFile["managementEndpointUrl"])
return s, nil
} | [
"func",
"GetSettingsFromFile",
"(",
")",
"(",
"FileSettings",
",",
"error",
")",
"{",
"s",
":=",
"FileSettings",
"{",
"}",
"\n",
"fileLocation",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"fileLocation",
"==",
"\"",
"\"",
"{",
"return",
"s",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"contents",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"fileLocation",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"s",
",",
"err",
"\n",
"}",
"\n\n",
"// Auth file might be encoded",
"decoded",
",",
"err",
":=",
"decode",
"(",
"contents",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"s",
",",
"err",
"\n",
"}",
"\n\n",
"authFile",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"decoded",
",",
"&",
"authFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"s",
",",
"err",
"\n",
"}",
"\n\n",
"s",
".",
"Values",
"=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"s",
".",
"setKeyValue",
"(",
"ClientID",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"ClientSecret",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"CertificatePath",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"CertificatePassword",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"SubscriptionID",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"TenantID",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"ActiveDirectoryEndpoint",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"ResourceManagerEndpoint",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"GraphResourceID",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"SQLManagementEndpoint",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"GalleryEndpoint",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"s",
".",
"setKeyValue",
"(",
"ManagementEndpoint",
",",
"authFile",
"[",
"\"",
"\"",
"]",
")",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] | // GetSettingsFromFile returns the available authentication settings from an Azure CLI authentication file. | [
"GetSettingsFromFile",
"returns",
"the",
"available",
"authentication",
"settings",
"from",
"an",
"Azure",
"CLI",
"authentication",
"file",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L287-L325 |
152,524 | Azure/go-autorest | autorest/azure/auth/auth.go | setKeyValue | func (settings FileSettings) setKeyValue(key string, val interface{}) {
if val != nil {
settings.Values[key] = val.(string)
}
} | go | func (settings FileSettings) setKeyValue(key string, val interface{}) {
if val != nil {
settings.Values[key] = val.(string)
}
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"setKeyValue",
"(",
"key",
"string",
",",
"val",
"interface",
"{",
"}",
")",
"{",
"if",
"val",
"!=",
"nil",
"{",
"settings",
".",
"Values",
"[",
"key",
"]",
"=",
"val",
".",
"(",
"string",
")",
"\n",
"}",
"\n",
"}"
] | // adds the specified value to the Values map if it isn't nil | [
"adds",
"the",
"specified",
"value",
"to",
"the",
"Values",
"map",
"if",
"it",
"isn",
"t",
"nil"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L338-L342 |
152,525 | Azure/go-autorest | autorest/azure/auth/auth.go | getAADEndpoint | func (settings FileSettings) getAADEndpoint() string {
if v, ok := settings.Values[ActiveDirectoryEndpoint]; ok {
return v
}
return azure.PublicCloud.ActiveDirectoryEndpoint
} | go | func (settings FileSettings) getAADEndpoint() string {
if v, ok := settings.Values[ActiveDirectoryEndpoint]; ok {
return v
}
return azure.PublicCloud.ActiveDirectoryEndpoint
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"getAADEndpoint",
"(",
")",
"string",
"{",
"if",
"v",
",",
"ok",
":=",
"settings",
".",
"Values",
"[",
"ActiveDirectoryEndpoint",
"]",
";",
"ok",
"{",
"return",
"v",
"\n",
"}",
"\n",
"return",
"azure",
".",
"PublicCloud",
".",
"ActiveDirectoryEndpoint",
"\n",
"}"
] | // returns the specified AAD endpoint or the public cloud endpoint if unspecified | [
"returns",
"the",
"specified",
"AAD",
"endpoint",
"or",
"the",
"public",
"cloud",
"endpoint",
"if",
"unspecified"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L345-L350 |
152,526 | Azure/go-autorest | autorest/azure/auth/auth.go | ServicePrincipalTokenFromClientCredentials | func (settings FileSettings) ServicePrincipalTokenFromClientCredentials(baseURI string) (*adal.ServicePrincipalToken, error) {
resource, err := settings.getResourceForToken(baseURI)
if err != nil {
return nil, err
}
return settings.ServicePrincipalTokenFromClientCredentialsWithResource(resource)
} | go | func (settings FileSettings) ServicePrincipalTokenFromClientCredentials(baseURI string) (*adal.ServicePrincipalToken, error) {
resource, err := settings.getResourceForToken(baseURI)
if err != nil {
return nil, err
}
return settings.ServicePrincipalTokenFromClientCredentialsWithResource(resource)
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"ServicePrincipalTokenFromClientCredentials",
"(",
"baseURI",
"string",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"resource",
",",
"err",
":=",
"settings",
".",
"getResourceForToken",
"(",
"baseURI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"settings",
".",
"ServicePrincipalTokenFromClientCredentialsWithResource",
"(",
"resource",
")",
"\n",
"}"
] | // ServicePrincipalTokenFromClientCredentials creates a ServicePrincipalToken from the available client credentials. | [
"ServicePrincipalTokenFromClientCredentials",
"creates",
"a",
"ServicePrincipalToken",
"from",
"the",
"available",
"client",
"credentials",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L353-L359 |
152,527 | Azure/go-autorest | autorest/azure/auth/auth.go | ClientCredentialsAuthorizer | func (settings FileSettings) ClientCredentialsAuthorizer(baseURI string) (autorest.Authorizer, error) {
resource, err := settings.getResourceForToken(baseURI)
if err != nil {
return nil, err
}
return settings.ClientCredentialsAuthorizerWithResource(resource)
} | go | func (settings FileSettings) ClientCredentialsAuthorizer(baseURI string) (autorest.Authorizer, error) {
resource, err := settings.getResourceForToken(baseURI)
if err != nil {
return nil, err
}
return settings.ClientCredentialsAuthorizerWithResource(resource)
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"ClientCredentialsAuthorizer",
"(",
"baseURI",
"string",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"resource",
",",
"err",
":=",
"settings",
".",
"getResourceForToken",
"(",
"baseURI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"settings",
".",
"ClientCredentialsAuthorizerWithResource",
"(",
"resource",
")",
"\n",
"}"
] | // ClientCredentialsAuthorizer creates an authorizer from the available client credentials. | [
"ClientCredentialsAuthorizer",
"creates",
"an",
"authorizer",
"from",
"the",
"available",
"client",
"credentials",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L362-L368 |
152,528 | Azure/go-autorest | autorest/azure/auth/auth.go | ServicePrincipalTokenFromClientCredentialsWithResource | func (settings FileSettings) ServicePrincipalTokenFromClientCredentialsWithResource(resource string) (*adal.ServicePrincipalToken, error) {
if _, ok := settings.Values[ClientSecret]; !ok {
return nil, errors.New("missing client secret")
}
config, err := adal.NewOAuthConfig(settings.getAADEndpoint(), settings.Values[TenantID])
if err != nil {
return nil, err
}
return adal.NewServicePrincipalToken(*config, settings.Values[ClientID], settings.Values[ClientSecret], resource)
} | go | func (settings FileSettings) ServicePrincipalTokenFromClientCredentialsWithResource(resource string) (*adal.ServicePrincipalToken, error) {
if _, ok := settings.Values[ClientSecret]; !ok {
return nil, errors.New("missing client secret")
}
config, err := adal.NewOAuthConfig(settings.getAADEndpoint(), settings.Values[TenantID])
if err != nil {
return nil, err
}
return adal.NewServicePrincipalToken(*config, settings.Values[ClientID], settings.Values[ClientSecret], resource)
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"ServicePrincipalTokenFromClientCredentialsWithResource",
"(",
"resource",
"string",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"settings",
".",
"Values",
"[",
"ClientSecret",
"]",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"config",
",",
"err",
":=",
"adal",
".",
"NewOAuthConfig",
"(",
"settings",
".",
"getAADEndpoint",
"(",
")",
",",
"settings",
".",
"Values",
"[",
"TenantID",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"adal",
".",
"NewServicePrincipalToken",
"(",
"*",
"config",
",",
"settings",
".",
"Values",
"[",
"ClientID",
"]",
",",
"settings",
".",
"Values",
"[",
"ClientSecret",
"]",
",",
"resource",
")",
"\n",
"}"
] | // ServicePrincipalTokenFromClientCredentialsWithResource creates a ServicePrincipalToken
// from the available client credentials and the specified resource. | [
"ServicePrincipalTokenFromClientCredentialsWithResource",
"creates",
"a",
"ServicePrincipalToken",
"from",
"the",
"available",
"client",
"credentials",
"and",
"the",
"specified",
"resource",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L372-L381 |
152,529 | Azure/go-autorest | autorest/azure/auth/auth.go | ClientCredentialsAuthorizerWithResource | func (settings FileSettings) ClientCredentialsAuthorizerWithResource(resource string) (autorest.Authorizer, error) {
spToken, err := settings.ServicePrincipalTokenFromClientCredentialsWithResource(resource)
if err != nil {
return nil, err
}
return autorest.NewBearerAuthorizer(spToken), nil
} | go | func (settings FileSettings) ClientCredentialsAuthorizerWithResource(resource string) (autorest.Authorizer, error) {
spToken, err := settings.ServicePrincipalTokenFromClientCredentialsWithResource(resource)
if err != nil {
return nil, err
}
return autorest.NewBearerAuthorizer(spToken), nil
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"ClientCredentialsAuthorizerWithResource",
"(",
"resource",
"string",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"spToken",
",",
"err",
":=",
"settings",
".",
"ServicePrincipalTokenFromClientCredentialsWithResource",
"(",
"resource",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"autorest",
".",
"NewBearerAuthorizer",
"(",
"spToken",
")",
",",
"nil",
"\n",
"}"
] | // ClientCredentialsAuthorizerWithResource creates an authorizer from the available client credentials and the specified resource. | [
"ClientCredentialsAuthorizerWithResource",
"creates",
"an",
"authorizer",
"from",
"the",
"available",
"client",
"credentials",
"and",
"the",
"specified",
"resource",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L394-L400 |
152,530 | Azure/go-autorest | autorest/azure/auth/auth.go | ServicePrincipalTokenFromClientCertificate | func (settings FileSettings) ServicePrincipalTokenFromClientCertificate(baseURI string) (*adal.ServicePrincipalToken, error) {
resource, err := settings.getResourceForToken(baseURI)
if err != nil {
return nil, err
}
return settings.ServicePrincipalTokenFromClientCertificateWithResource(resource)
} | go | func (settings FileSettings) ServicePrincipalTokenFromClientCertificate(baseURI string) (*adal.ServicePrincipalToken, error) {
resource, err := settings.getResourceForToken(baseURI)
if err != nil {
return nil, err
}
return settings.ServicePrincipalTokenFromClientCertificateWithResource(resource)
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"ServicePrincipalTokenFromClientCertificate",
"(",
"baseURI",
"string",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"resource",
",",
"err",
":=",
"settings",
".",
"getResourceForToken",
"(",
"baseURI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"settings",
".",
"ServicePrincipalTokenFromClientCertificateWithResource",
"(",
"resource",
")",
"\n",
"}"
] | // ServicePrincipalTokenFromClientCertificate creates a ServicePrincipalToken from the available certificate credentials. | [
"ServicePrincipalTokenFromClientCertificate",
"creates",
"a",
"ServicePrincipalToken",
"from",
"the",
"available",
"certificate",
"credentials",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L403-L409 |
152,531 | Azure/go-autorest | autorest/azure/auth/auth.go | ClientCertificateAuthorizer | func (settings FileSettings) ClientCertificateAuthorizer(baseURI string) (autorest.Authorizer, error) {
resource, err := settings.getResourceForToken(baseURI)
if err != nil {
return nil, err
}
return settings.ClientCertificateAuthorizerWithResource(resource)
} | go | func (settings FileSettings) ClientCertificateAuthorizer(baseURI string) (autorest.Authorizer, error) {
resource, err := settings.getResourceForToken(baseURI)
if err != nil {
return nil, err
}
return settings.ClientCertificateAuthorizerWithResource(resource)
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"ClientCertificateAuthorizer",
"(",
"baseURI",
"string",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"resource",
",",
"err",
":=",
"settings",
".",
"getResourceForToken",
"(",
"baseURI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"settings",
".",
"ClientCertificateAuthorizerWithResource",
"(",
"resource",
")",
"\n",
"}"
] | // ClientCertificateAuthorizer creates an authorizer from the available certificate credentials. | [
"ClientCertificateAuthorizer",
"creates",
"an",
"authorizer",
"from",
"the",
"available",
"certificate",
"credentials",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L412-L418 |
152,532 | Azure/go-autorest | autorest/azure/auth/auth.go | ServicePrincipalTokenFromClientCertificateWithResource | func (settings FileSettings) ServicePrincipalTokenFromClientCertificateWithResource(resource string) (*adal.ServicePrincipalToken, error) {
cfg, err := settings.clientCertificateConfigWithResource(resource)
if err != nil {
return nil, err
}
return cfg.ServicePrincipalToken()
} | go | func (settings FileSettings) ServicePrincipalTokenFromClientCertificateWithResource(resource string) (*adal.ServicePrincipalToken, error) {
cfg, err := settings.clientCertificateConfigWithResource(resource)
if err != nil {
return nil, err
}
return cfg.ServicePrincipalToken()
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"ServicePrincipalTokenFromClientCertificateWithResource",
"(",
"resource",
"string",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"settings",
".",
"clientCertificateConfigWithResource",
"(",
"resource",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"cfg",
".",
"ServicePrincipalToken",
"(",
")",
"\n",
"}"
] | // ServicePrincipalTokenFromClientCertificateWithResource creates a ServicePrincipalToken from the available certificate credentials. | [
"ServicePrincipalTokenFromClientCertificateWithResource",
"creates",
"a",
"ServicePrincipalToken",
"from",
"the",
"available",
"certificate",
"credentials",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L421-L427 |
152,533 | Azure/go-autorest | autorest/azure/auth/auth.go | ClientCertificateAuthorizerWithResource | func (settings FileSettings) ClientCertificateAuthorizerWithResource(resource string) (autorest.Authorizer, error) {
cfg, err := settings.clientCertificateConfigWithResource(resource)
if err != nil {
return nil, err
}
return cfg.Authorizer()
} | go | func (settings FileSettings) ClientCertificateAuthorizerWithResource(resource string) (autorest.Authorizer, error) {
cfg, err := settings.clientCertificateConfigWithResource(resource)
if err != nil {
return nil, err
}
return cfg.Authorizer()
} | [
"func",
"(",
"settings",
"FileSettings",
")",
"ClientCertificateAuthorizerWithResource",
"(",
"resource",
"string",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"settings",
".",
"clientCertificateConfigWithResource",
"(",
"resource",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"cfg",
".",
"Authorizer",
"(",
")",
"\n",
"}"
] | // ClientCertificateAuthorizerWithResource creates an authorizer from the available certificate credentials and the specified resource. | [
"ClientCertificateAuthorizerWithResource",
"creates",
"an",
"authorizer",
"from",
"the",
"available",
"certificate",
"credentials",
"and",
"the",
"specified",
"resource",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L430-L436 |
152,534 | Azure/go-autorest | autorest/azure/auth/auth.go | NewClientCredentialsConfig | func NewClientCredentialsConfig(clientID string, clientSecret string, tenantID string) ClientCredentialsConfig {
return ClientCredentialsConfig{
ClientID: clientID,
ClientSecret: clientSecret,
TenantID: tenantID,
Resource: azure.PublicCloud.ResourceManagerEndpoint,
AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
}
} | go | func NewClientCredentialsConfig(clientID string, clientSecret string, tenantID string) ClientCredentialsConfig {
return ClientCredentialsConfig{
ClientID: clientID,
ClientSecret: clientSecret,
TenantID: tenantID,
Resource: azure.PublicCloud.ResourceManagerEndpoint,
AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
}
} | [
"func",
"NewClientCredentialsConfig",
"(",
"clientID",
"string",
",",
"clientSecret",
"string",
",",
"tenantID",
"string",
")",
"ClientCredentialsConfig",
"{",
"return",
"ClientCredentialsConfig",
"{",
"ClientID",
":",
"clientID",
",",
"ClientSecret",
":",
"clientSecret",
",",
"TenantID",
":",
"tenantID",
",",
"Resource",
":",
"azure",
".",
"PublicCloud",
".",
"ResourceManagerEndpoint",
",",
"AADEndpoint",
":",
"azure",
".",
"PublicCloud",
".",
"ActiveDirectoryEndpoint",
",",
"}",
"\n",
"}"
] | // NewClientCredentialsConfig creates an AuthorizerConfig object configured to obtain an Authorizer through Client Credentials.
// Defaults to Public Cloud and Resource Manager Endpoint. | [
"NewClientCredentialsConfig",
"creates",
"an",
"AuthorizerConfig",
"object",
"configured",
"to",
"obtain",
"an",
"Authorizer",
"through",
"Client",
"Credentials",
".",
"Defaults",
"to",
"Public",
"Cloud",
"and",
"Resource",
"Manager",
"Endpoint",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L485-L493 |
152,535 | Azure/go-autorest | autorest/azure/auth/auth.go | NewClientCertificateConfig | func NewClientCertificateConfig(certificatePath string, certificatePassword string, clientID string, tenantID string) ClientCertificateConfig {
return ClientCertificateConfig{
CertificatePath: certificatePath,
CertificatePassword: certificatePassword,
ClientID: clientID,
TenantID: tenantID,
Resource: azure.PublicCloud.ResourceManagerEndpoint,
AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
}
} | go | func NewClientCertificateConfig(certificatePath string, certificatePassword string, clientID string, tenantID string) ClientCertificateConfig {
return ClientCertificateConfig{
CertificatePath: certificatePath,
CertificatePassword: certificatePassword,
ClientID: clientID,
TenantID: tenantID,
Resource: azure.PublicCloud.ResourceManagerEndpoint,
AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
}
} | [
"func",
"NewClientCertificateConfig",
"(",
"certificatePath",
"string",
",",
"certificatePassword",
"string",
",",
"clientID",
"string",
",",
"tenantID",
"string",
")",
"ClientCertificateConfig",
"{",
"return",
"ClientCertificateConfig",
"{",
"CertificatePath",
":",
"certificatePath",
",",
"CertificatePassword",
":",
"certificatePassword",
",",
"ClientID",
":",
"clientID",
",",
"TenantID",
":",
"tenantID",
",",
"Resource",
":",
"azure",
".",
"PublicCloud",
".",
"ResourceManagerEndpoint",
",",
"AADEndpoint",
":",
"azure",
".",
"PublicCloud",
".",
"ActiveDirectoryEndpoint",
",",
"}",
"\n",
"}"
] | // NewClientCertificateConfig creates a ClientCertificateConfig object configured to obtain an Authorizer through client certificate.
// Defaults to Public Cloud and Resource Manager Endpoint. | [
"NewClientCertificateConfig",
"creates",
"a",
"ClientCertificateConfig",
"object",
"configured",
"to",
"obtain",
"an",
"Authorizer",
"through",
"client",
"certificate",
".",
"Defaults",
"to",
"Public",
"Cloud",
"and",
"Resource",
"Manager",
"Endpoint",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L497-L506 |
152,536 | Azure/go-autorest | autorest/azure/auth/auth.go | NewUsernamePasswordConfig | func NewUsernamePasswordConfig(username string, password string, clientID string, tenantID string) UsernamePasswordConfig {
return UsernamePasswordConfig{
Username: username,
Password: password,
ClientID: clientID,
TenantID: tenantID,
Resource: azure.PublicCloud.ResourceManagerEndpoint,
AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
}
} | go | func NewUsernamePasswordConfig(username string, password string, clientID string, tenantID string) UsernamePasswordConfig {
return UsernamePasswordConfig{
Username: username,
Password: password,
ClientID: clientID,
TenantID: tenantID,
Resource: azure.PublicCloud.ResourceManagerEndpoint,
AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
}
} | [
"func",
"NewUsernamePasswordConfig",
"(",
"username",
"string",
",",
"password",
"string",
",",
"clientID",
"string",
",",
"tenantID",
"string",
")",
"UsernamePasswordConfig",
"{",
"return",
"UsernamePasswordConfig",
"{",
"Username",
":",
"username",
",",
"Password",
":",
"password",
",",
"ClientID",
":",
"clientID",
",",
"TenantID",
":",
"tenantID",
",",
"Resource",
":",
"azure",
".",
"PublicCloud",
".",
"ResourceManagerEndpoint",
",",
"AADEndpoint",
":",
"azure",
".",
"PublicCloud",
".",
"ActiveDirectoryEndpoint",
",",
"}",
"\n",
"}"
] | // NewUsernamePasswordConfig creates an UsernamePasswordConfig object configured to obtain an Authorizer through username and password.
// Defaults to Public Cloud and Resource Manager Endpoint. | [
"NewUsernamePasswordConfig",
"creates",
"an",
"UsernamePasswordConfig",
"object",
"configured",
"to",
"obtain",
"an",
"Authorizer",
"through",
"username",
"and",
"password",
".",
"Defaults",
"to",
"Public",
"Cloud",
"and",
"Resource",
"Manager",
"Endpoint",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L510-L519 |
152,537 | Azure/go-autorest | autorest/azure/auth/auth.go | NewDeviceFlowConfig | func NewDeviceFlowConfig(clientID string, tenantID string) DeviceFlowConfig {
return DeviceFlowConfig{
ClientID: clientID,
TenantID: tenantID,
Resource: azure.PublicCloud.ResourceManagerEndpoint,
AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
}
} | go | func NewDeviceFlowConfig(clientID string, tenantID string) DeviceFlowConfig {
return DeviceFlowConfig{
ClientID: clientID,
TenantID: tenantID,
Resource: azure.PublicCloud.ResourceManagerEndpoint,
AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
}
} | [
"func",
"NewDeviceFlowConfig",
"(",
"clientID",
"string",
",",
"tenantID",
"string",
")",
"DeviceFlowConfig",
"{",
"return",
"DeviceFlowConfig",
"{",
"ClientID",
":",
"clientID",
",",
"TenantID",
":",
"tenantID",
",",
"Resource",
":",
"azure",
".",
"PublicCloud",
".",
"ResourceManagerEndpoint",
",",
"AADEndpoint",
":",
"azure",
".",
"PublicCloud",
".",
"ActiveDirectoryEndpoint",
",",
"}",
"\n",
"}"
] | // NewDeviceFlowConfig creates a DeviceFlowConfig object configured to obtain an Authorizer through device flow.
// Defaults to Public Cloud and Resource Manager Endpoint. | [
"NewDeviceFlowConfig",
"creates",
"a",
"DeviceFlowConfig",
"object",
"configured",
"to",
"obtain",
"an",
"Authorizer",
"through",
"device",
"flow",
".",
"Defaults",
"to",
"Public",
"Cloud",
"and",
"Resource",
"Manager",
"Endpoint",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L530-L537 |
152,538 | Azure/go-autorest | autorest/azure/auth/auth.go | ServicePrincipalToken | func (ccc ClientCredentialsConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
oauthConfig, err := adal.NewOAuthConfig(ccc.AADEndpoint, ccc.TenantID)
if err != nil {
return nil, err
}
return adal.NewServicePrincipalToken(*oauthConfig, ccc.ClientID, ccc.ClientSecret, ccc.Resource)
} | go | func (ccc ClientCredentialsConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
oauthConfig, err := adal.NewOAuthConfig(ccc.AADEndpoint, ccc.TenantID)
if err != nil {
return nil, err
}
return adal.NewServicePrincipalToken(*oauthConfig, ccc.ClientID, ccc.ClientSecret, ccc.Resource)
} | [
"func",
"(",
"ccc",
"ClientCredentialsConfig",
")",
"ServicePrincipalToken",
"(",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"oauthConfig",
",",
"err",
":=",
"adal",
".",
"NewOAuthConfig",
"(",
"ccc",
".",
"AADEndpoint",
",",
"ccc",
".",
"TenantID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"adal",
".",
"NewServicePrincipalToken",
"(",
"*",
"oauthConfig",
",",
"ccc",
".",
"ClientID",
",",
"ccc",
".",
"ClientSecret",
",",
"ccc",
".",
"Resource",
")",
"\n",
"}"
] | // ServicePrincipalToken creates a ServicePrincipalToken from client credentials. | [
"ServicePrincipalToken",
"creates",
"a",
"ServicePrincipalToken",
"from",
"client",
"credentials",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L554-L560 |
152,539 | Azure/go-autorest | autorest/azure/auth/auth.go | Authorizer | func (ccc ClientCredentialsConfig) Authorizer() (autorest.Authorizer, error) {
spToken, err := ccc.ServicePrincipalToken()
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from client credentials: %v", err)
}
return autorest.NewBearerAuthorizer(spToken), nil
} | go | func (ccc ClientCredentialsConfig) Authorizer() (autorest.Authorizer, error) {
spToken, err := ccc.ServicePrincipalToken()
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from client credentials: %v", err)
}
return autorest.NewBearerAuthorizer(spToken), nil
} | [
"func",
"(",
"ccc",
"ClientCredentialsConfig",
")",
"Authorizer",
"(",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"spToken",
",",
"err",
":=",
"ccc",
".",
"ServicePrincipalToken",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"autorest",
".",
"NewBearerAuthorizer",
"(",
"spToken",
")",
",",
"nil",
"\n",
"}"
] | // Authorizer gets the authorizer from client credentials. | [
"Authorizer",
"gets",
"the",
"authorizer",
"from",
"client",
"credentials",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L563-L569 |
152,540 | Azure/go-autorest | autorest/azure/auth/auth.go | ServicePrincipalToken | func (ccc ClientCertificateConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
oauthConfig, err := adal.NewOAuthConfig(ccc.AADEndpoint, ccc.TenantID)
if err != nil {
return nil, err
}
certData, err := ioutil.ReadFile(ccc.CertificatePath)
if err != nil {
return nil, fmt.Errorf("failed to read the certificate file (%s): %v", ccc.CertificatePath, err)
}
certificate, rsaPrivateKey, err := decodePkcs12(certData, ccc.CertificatePassword)
if err != nil {
return nil, fmt.Errorf("failed to decode pkcs12 certificate while creating spt: %v", err)
}
return adal.NewServicePrincipalTokenFromCertificate(*oauthConfig, ccc.ClientID, certificate, rsaPrivateKey, ccc.Resource)
} | go | func (ccc ClientCertificateConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
oauthConfig, err := adal.NewOAuthConfig(ccc.AADEndpoint, ccc.TenantID)
if err != nil {
return nil, err
}
certData, err := ioutil.ReadFile(ccc.CertificatePath)
if err != nil {
return nil, fmt.Errorf("failed to read the certificate file (%s): %v", ccc.CertificatePath, err)
}
certificate, rsaPrivateKey, err := decodePkcs12(certData, ccc.CertificatePassword)
if err != nil {
return nil, fmt.Errorf("failed to decode pkcs12 certificate while creating spt: %v", err)
}
return adal.NewServicePrincipalTokenFromCertificate(*oauthConfig, ccc.ClientID, certificate, rsaPrivateKey, ccc.Resource)
} | [
"func",
"(",
"ccc",
"ClientCertificateConfig",
")",
"ServicePrincipalToken",
"(",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"oauthConfig",
",",
"err",
":=",
"adal",
".",
"NewOAuthConfig",
"(",
"ccc",
".",
"AADEndpoint",
",",
"ccc",
".",
"TenantID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"certData",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"ccc",
".",
"CertificatePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ccc",
".",
"CertificatePath",
",",
"err",
")",
"\n",
"}",
"\n",
"certificate",
",",
"rsaPrivateKey",
",",
"err",
":=",
"decodePkcs12",
"(",
"certData",
",",
"ccc",
".",
"CertificatePassword",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"adal",
".",
"NewServicePrincipalTokenFromCertificate",
"(",
"*",
"oauthConfig",
",",
"ccc",
".",
"ClientID",
",",
"certificate",
",",
"rsaPrivateKey",
",",
"ccc",
".",
"Resource",
")",
"\n",
"}"
] | // ServicePrincipalToken creates a ServicePrincipalToken from client certificate. | [
"ServicePrincipalToken",
"creates",
"a",
"ServicePrincipalToken",
"from",
"client",
"certificate",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L582-L596 |
152,541 | Azure/go-autorest | autorest/azure/auth/auth.go | Authorizer | func (dfc DeviceFlowConfig) Authorizer() (autorest.Authorizer, error) {
spToken, err := dfc.ServicePrincipalToken()
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from device flow: %v", err)
}
return autorest.NewBearerAuthorizer(spToken), nil
} | go | func (dfc DeviceFlowConfig) Authorizer() (autorest.Authorizer, error) {
spToken, err := dfc.ServicePrincipalToken()
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from device flow: %v", err)
}
return autorest.NewBearerAuthorizer(spToken), nil
} | [
"func",
"(",
"dfc",
"DeviceFlowConfig",
")",
"Authorizer",
"(",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"spToken",
",",
"err",
":=",
"dfc",
".",
"ServicePrincipalToken",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"autorest",
".",
"NewBearerAuthorizer",
"(",
"spToken",
")",
",",
"nil",
"\n",
"}"
] | // Authorizer gets the authorizer from device flow. | [
"Authorizer",
"gets",
"the",
"authorizer",
"from",
"device",
"flow",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L616-L622 |
152,542 | Azure/go-autorest | autorest/azure/auth/auth.go | ServicePrincipalToken | func (dfc DeviceFlowConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
oauthConfig, err := adal.NewOAuthConfig(dfc.AADEndpoint, dfc.TenantID)
if err != nil {
return nil, err
}
oauthClient := &autorest.Client{}
deviceCode, err := adal.InitiateDeviceAuth(oauthClient, *oauthConfig, dfc.ClientID, dfc.Resource)
if err != nil {
return nil, fmt.Errorf("failed to start device auth flow: %s", err)
}
log.Println(*deviceCode.Message)
token, err := adal.WaitForUserCompletion(oauthClient, deviceCode)
if err != nil {
return nil, fmt.Errorf("failed to finish device auth flow: %s", err)
}
return adal.NewServicePrincipalTokenFromManualToken(*oauthConfig, dfc.ClientID, dfc.Resource, *token)
} | go | func (dfc DeviceFlowConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
oauthConfig, err := adal.NewOAuthConfig(dfc.AADEndpoint, dfc.TenantID)
if err != nil {
return nil, err
}
oauthClient := &autorest.Client{}
deviceCode, err := adal.InitiateDeviceAuth(oauthClient, *oauthConfig, dfc.ClientID, dfc.Resource)
if err != nil {
return nil, fmt.Errorf("failed to start device auth flow: %s", err)
}
log.Println(*deviceCode.Message)
token, err := adal.WaitForUserCompletion(oauthClient, deviceCode)
if err != nil {
return nil, fmt.Errorf("failed to finish device auth flow: %s", err)
}
return adal.NewServicePrincipalTokenFromManualToken(*oauthConfig, dfc.ClientID, dfc.Resource, *token)
} | [
"func",
"(",
"dfc",
"DeviceFlowConfig",
")",
"ServicePrincipalToken",
"(",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"oauthConfig",
",",
"err",
":=",
"adal",
".",
"NewOAuthConfig",
"(",
"dfc",
".",
"AADEndpoint",
",",
"dfc",
".",
"TenantID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"oauthClient",
":=",
"&",
"autorest",
".",
"Client",
"{",
"}",
"\n",
"deviceCode",
",",
"err",
":=",
"adal",
".",
"InitiateDeviceAuth",
"(",
"oauthClient",
",",
"*",
"oauthConfig",
",",
"dfc",
".",
"ClientID",
",",
"dfc",
".",
"Resource",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Println",
"(",
"*",
"deviceCode",
".",
"Message",
")",
"\n",
"token",
",",
"err",
":=",
"adal",
".",
"WaitForUserCompletion",
"(",
"oauthClient",
",",
"deviceCode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"adal",
".",
"NewServicePrincipalTokenFromManualToken",
"(",
"*",
"oauthConfig",
",",
"dfc",
".",
"ClientID",
",",
"dfc",
".",
"Resource",
",",
"*",
"token",
")",
"\n",
"}"
] | // ServicePrincipalToken gets the service principal token from device flow. | [
"ServicePrincipalToken",
"gets",
"the",
"service",
"principal",
"token",
"from",
"device",
"flow",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L625-L641 |
152,543 | Azure/go-autorest | autorest/azure/auth/auth.go | ServicePrincipalToken | func (ups UsernamePasswordConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
oauthConfig, err := adal.NewOAuthConfig(ups.AADEndpoint, ups.TenantID)
if err != nil {
return nil, err
}
return adal.NewServicePrincipalTokenFromUsernamePassword(*oauthConfig, ups.ClientID, ups.Username, ups.Password, ups.Resource)
} | go | func (ups UsernamePasswordConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
oauthConfig, err := adal.NewOAuthConfig(ups.AADEndpoint, ups.TenantID)
if err != nil {
return nil, err
}
return adal.NewServicePrincipalTokenFromUsernamePassword(*oauthConfig, ups.ClientID, ups.Username, ups.Password, ups.Resource)
} | [
"func",
"(",
"ups",
"UsernamePasswordConfig",
")",
"ServicePrincipalToken",
"(",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"oauthConfig",
",",
"err",
":=",
"adal",
".",
"NewOAuthConfig",
"(",
"ups",
".",
"AADEndpoint",
",",
"ups",
".",
"TenantID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"adal",
".",
"NewServicePrincipalTokenFromUsernamePassword",
"(",
"*",
"oauthConfig",
",",
"ups",
".",
"ClientID",
",",
"ups",
".",
"Username",
",",
"ups",
".",
"Password",
",",
"ups",
".",
"Resource",
")",
"\n",
"}"
] | // ServicePrincipalToken creates a ServicePrincipalToken from username and password. | [
"ServicePrincipalToken",
"creates",
"a",
"ServicePrincipalToken",
"from",
"username",
"and",
"password",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L668-L674 |
152,544 | Azure/go-autorest | autorest/azure/auth/auth.go | Authorizer | func (ups UsernamePasswordConfig) Authorizer() (autorest.Authorizer, error) {
spToken, err := ups.ServicePrincipalToken()
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from username and password auth: %v", err)
}
return autorest.NewBearerAuthorizer(spToken), nil
} | go | func (ups UsernamePasswordConfig) Authorizer() (autorest.Authorizer, error) {
spToken, err := ups.ServicePrincipalToken()
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from username and password auth: %v", err)
}
return autorest.NewBearerAuthorizer(spToken), nil
} | [
"func",
"(",
"ups",
"UsernamePasswordConfig",
")",
"Authorizer",
"(",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"spToken",
",",
"err",
":=",
"ups",
".",
"ServicePrincipalToken",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"autorest",
".",
"NewBearerAuthorizer",
"(",
"spToken",
")",
",",
"nil",
"\n",
"}"
] | // Authorizer gets the authorizer from a username and a password. | [
"Authorizer",
"gets",
"the",
"authorizer",
"from",
"a",
"username",
"and",
"a",
"password",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L677-L683 |
152,545 | Azure/go-autorest | autorest/azure/auth/auth.go | Authorizer | func (mc MSIConfig) Authorizer() (autorest.Authorizer, error) {
msiEndpoint, err := adal.GetMSIVMEndpoint()
if err != nil {
return nil, err
}
var spToken *adal.ServicePrincipalToken
if mc.ClientID == "" {
spToken, err = adal.NewServicePrincipalTokenFromMSI(msiEndpoint, mc.Resource)
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from MSI: %v", err)
}
} else {
spToken, err = adal.NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint, mc.Resource, mc.ClientID)
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from MSI for user assigned identity: %v", err)
}
}
return autorest.NewBearerAuthorizer(spToken), nil
} | go | func (mc MSIConfig) Authorizer() (autorest.Authorizer, error) {
msiEndpoint, err := adal.GetMSIVMEndpoint()
if err != nil {
return nil, err
}
var spToken *adal.ServicePrincipalToken
if mc.ClientID == "" {
spToken, err = adal.NewServicePrincipalTokenFromMSI(msiEndpoint, mc.Resource)
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from MSI: %v", err)
}
} else {
spToken, err = adal.NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint, mc.Resource, mc.ClientID)
if err != nil {
return nil, fmt.Errorf("failed to get oauth token from MSI for user assigned identity: %v", err)
}
}
return autorest.NewBearerAuthorizer(spToken), nil
} | [
"func",
"(",
"mc",
"MSIConfig",
")",
"Authorizer",
"(",
")",
"(",
"autorest",
".",
"Authorizer",
",",
"error",
")",
"{",
"msiEndpoint",
",",
"err",
":=",
"adal",
".",
"GetMSIVMEndpoint",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"spToken",
"*",
"adal",
".",
"ServicePrincipalToken",
"\n",
"if",
"mc",
".",
"ClientID",
"==",
"\"",
"\"",
"{",
"spToken",
",",
"err",
"=",
"adal",
".",
"NewServicePrincipalTokenFromMSI",
"(",
"msiEndpoint",
",",
"mc",
".",
"Resource",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"spToken",
",",
"err",
"=",
"adal",
".",
"NewServicePrincipalTokenFromMSIWithUserAssignedID",
"(",
"msiEndpoint",
",",
"mc",
".",
"Resource",
",",
"mc",
".",
"ClientID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"autorest",
".",
"NewBearerAuthorizer",
"(",
"spToken",
")",
",",
"nil",
"\n",
"}"
] | // Authorizer gets the authorizer from MSI. | [
"Authorizer",
"gets",
"the",
"authorizer",
"from",
"MSI",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/auth/auth.go#L692-L712 |
152,546 | Azure/go-autorest | tracing/tracing.go | NewTransport | func NewTransport() *ochttp.Transport {
return &ochttp.Transport{
Propagation: &tracecontext.HTTPFormat{},
GetStartOptions: getStartOptions,
}
} | go | func NewTransport() *ochttp.Transport {
return &ochttp.Transport{
Propagation: &tracecontext.HTTPFormat{},
GetStartOptions: getStartOptions,
}
} | [
"func",
"NewTransport",
"(",
")",
"*",
"ochttp",
".",
"Transport",
"{",
"return",
"&",
"ochttp",
".",
"Transport",
"{",
"Propagation",
":",
"&",
"tracecontext",
".",
"HTTPFormat",
"{",
"}",
",",
"GetStartOptions",
":",
"getStartOptions",
",",
"}",
"\n",
"}"
] | // NewTransport returns a new instance of a tracing-aware RoundTripper. | [
"NewTransport",
"returns",
"a",
"new",
"instance",
"of",
"a",
"tracing",
"-",
"aware",
"RoundTripper",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/tracing/tracing.go#L68-L73 |
152,547 | Azure/go-autorest | tracing/tracing.go | Disable | func Disable() {
disableStats()
sampler = trace.NeverSample()
if traceExporter != nil {
trace.UnregisterExporter(traceExporter)
}
enabled = false
} | go | func Disable() {
disableStats()
sampler = trace.NeverSample()
if traceExporter != nil {
trace.UnregisterExporter(traceExporter)
}
enabled = false
} | [
"func",
"Disable",
"(",
")",
"{",
"disableStats",
"(",
")",
"\n",
"sampler",
"=",
"trace",
".",
"NeverSample",
"(",
")",
"\n",
"if",
"traceExporter",
"!=",
"nil",
"{",
"trace",
".",
"UnregisterExporter",
"(",
"traceExporter",
")",
"\n",
"}",
"\n",
"enabled",
"=",
"false",
"\n",
"}"
] | // Disable will disable instrumentation for metrics and traces. | [
"Disable",
"will",
"disable",
"instrumentation",
"for",
"metrics",
"and",
"traces",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/tracing/tracing.go#L90-L97 |
152,548 | Azure/go-autorest | tracing/tracing.go | EnableWithAIForwarding | func EnableWithAIForwarding(agentEndpoint string) (err error) {
err = Enable()
if err != nil {
return err
}
traceExporter, err := ocagent.NewExporter(ocagent.WithInsecure(), ocagent.WithAddress(agentEndpoint))
if err != nil {
return err
}
trace.RegisterExporter(traceExporter)
return
} | go | func EnableWithAIForwarding(agentEndpoint string) (err error) {
err = Enable()
if err != nil {
return err
}
traceExporter, err := ocagent.NewExporter(ocagent.WithInsecure(), ocagent.WithAddress(agentEndpoint))
if err != nil {
return err
}
trace.RegisterExporter(traceExporter)
return
} | [
"func",
"EnableWithAIForwarding",
"(",
"agentEndpoint",
"string",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"Enable",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"traceExporter",
",",
"err",
":=",
"ocagent",
".",
"NewExporter",
"(",
"ocagent",
".",
"WithInsecure",
"(",
")",
",",
"ocagent",
".",
"WithAddress",
"(",
"agentEndpoint",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"trace",
".",
"RegisterExporter",
"(",
"traceExporter",
")",
"\n",
"return",
"\n",
"}"
] | // EnableWithAIForwarding will start instrumentation and will connect to app insights forwarder
// exporter making the metrics and traces available in app insights. | [
"EnableWithAIForwarding",
"will",
"start",
"instrumentation",
"and",
"will",
"connect",
"to",
"app",
"insights",
"forwarder",
"exporter",
"making",
"the",
"metrics",
"and",
"traces",
"available",
"in",
"app",
"insights",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/tracing/tracing.go#L101-L113 |
152,549 | Azure/go-autorest | tracing/tracing.go | initStats | func initStats() (err error) {
clientViews := []*view.View{
ochttp.ClientCompletedCount,
ochttp.ClientRoundtripLatencyDistribution,
ochttp.ClientReceivedBytesDistribution,
ochttp.ClientSentBytesDistribution,
}
for _, cv := range clientViews {
vn := fmt.Sprintf("Azure/go-autorest/tracing-%s", cv.Name)
views[vn] = cv.WithName(vn)
err = view.Register(views[vn])
if err != nil {
return err
}
}
return
} | go | func initStats() (err error) {
clientViews := []*view.View{
ochttp.ClientCompletedCount,
ochttp.ClientRoundtripLatencyDistribution,
ochttp.ClientReceivedBytesDistribution,
ochttp.ClientSentBytesDistribution,
}
for _, cv := range clientViews {
vn := fmt.Sprintf("Azure/go-autorest/tracing-%s", cv.Name)
views[vn] = cv.WithName(vn)
err = view.Register(views[vn])
if err != nil {
return err
}
}
return
} | [
"func",
"initStats",
"(",
")",
"(",
"err",
"error",
")",
"{",
"clientViews",
":=",
"[",
"]",
"*",
"view",
".",
"View",
"{",
"ochttp",
".",
"ClientCompletedCount",
",",
"ochttp",
".",
"ClientRoundtripLatencyDistribution",
",",
"ochttp",
".",
"ClientReceivedBytesDistribution",
",",
"ochttp",
".",
"ClientSentBytesDistribution",
",",
"}",
"\n",
"for",
"_",
",",
"cv",
":=",
"range",
"clientViews",
"{",
"vn",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cv",
".",
"Name",
")",
"\n",
"views",
"[",
"vn",
"]",
"=",
"cv",
".",
"WithName",
"(",
"vn",
")",
"\n",
"err",
"=",
"view",
".",
"Register",
"(",
"views",
"[",
"vn",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // initStats registers the views for the http metrics | [
"initStats",
"registers",
"the",
"views",
"for",
"the",
"http",
"metrics"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/tracing/tracing.go#L123-L139 |
152,550 | Azure/go-autorest | tracing/tracing.go | StartSpan | func StartSpan(ctx context.Context, name string) context.Context {
ctx, _ = trace.StartSpan(ctx, name, trace.WithSampler(sampler))
return ctx
} | go | func StartSpan(ctx context.Context, name string) context.Context {
ctx, _ = trace.StartSpan(ctx, name, trace.WithSampler(sampler))
return ctx
} | [
"func",
"StartSpan",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"context",
".",
"Context",
"{",
"ctx",
",",
"_",
"=",
"trace",
".",
"StartSpan",
"(",
"ctx",
",",
"name",
",",
"trace",
".",
"WithSampler",
"(",
"sampler",
")",
")",
"\n",
"return",
"ctx",
"\n",
"}"
] | // StartSpan starts a trace span | [
"StartSpan",
"starts",
"a",
"trace",
"span"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/tracing/tracing.go#L149-L152 |
152,551 | Azure/go-autorest | tracing/tracing.go | EndSpan | func EndSpan(ctx context.Context, httpStatusCode int, err error) {
span := trace.FromContext(ctx)
if span == nil {
return
}
if err != nil {
span.SetStatus(trace.Status{Message: err.Error(), Code: toTraceStatusCode(httpStatusCode)})
}
span.End()
} | go | func EndSpan(ctx context.Context, httpStatusCode int, err error) {
span := trace.FromContext(ctx)
if span == nil {
return
}
if err != nil {
span.SetStatus(trace.Status{Message: err.Error(), Code: toTraceStatusCode(httpStatusCode)})
}
span.End()
} | [
"func",
"EndSpan",
"(",
"ctx",
"context",
".",
"Context",
",",
"httpStatusCode",
"int",
",",
"err",
"error",
")",
"{",
"span",
":=",
"trace",
".",
"FromContext",
"(",
"ctx",
")",
"\n\n",
"if",
"span",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"span",
".",
"SetStatus",
"(",
"trace",
".",
"Status",
"{",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"Code",
":",
"toTraceStatusCode",
"(",
"httpStatusCode",
")",
"}",
")",
"\n",
"}",
"\n",
"span",
".",
"End",
"(",
")",
"\n",
"}"
] | // EndSpan ends a previously started span stored in the context | [
"EndSpan",
"ends",
"a",
"previously",
"started",
"span",
"stored",
"in",
"the",
"context"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/tracing/tracing.go#L155-L166 |
152,552 | Azure/go-autorest | autorest/adal/persist.go | SaveToken | func SaveToken(path string, mode os.FileMode, token Token) error {
dir := filepath.Dir(path)
err := os.MkdirAll(dir, os.ModePerm)
if err != nil {
return fmt.Errorf("failed to create directory (%s) to store token in: %v", dir, err)
}
newFile, err := ioutil.TempFile(dir, "token")
if err != nil {
return fmt.Errorf("failed to create the temp file to write the token: %v", err)
}
tempPath := newFile.Name()
if err := json.NewEncoder(newFile).Encode(token); err != nil {
return fmt.Errorf("failed to encode token to file (%s) while saving token: %v", tempPath, err)
}
if err := newFile.Close(); err != nil {
return fmt.Errorf("failed to close temp file %s: %v", tempPath, err)
}
// Atomic replace to avoid multi-writer file corruptions
if err := os.Rename(tempPath, path); err != nil {
return fmt.Errorf("failed to move temporary token to desired output location. src=%s dst=%s: %v", tempPath, path, err)
}
if err := os.Chmod(path, mode); err != nil {
return fmt.Errorf("failed to chmod the token file %s: %v", path, err)
}
return nil
} | go | func SaveToken(path string, mode os.FileMode, token Token) error {
dir := filepath.Dir(path)
err := os.MkdirAll(dir, os.ModePerm)
if err != nil {
return fmt.Errorf("failed to create directory (%s) to store token in: %v", dir, err)
}
newFile, err := ioutil.TempFile(dir, "token")
if err != nil {
return fmt.Errorf("failed to create the temp file to write the token: %v", err)
}
tempPath := newFile.Name()
if err := json.NewEncoder(newFile).Encode(token); err != nil {
return fmt.Errorf("failed to encode token to file (%s) while saving token: %v", tempPath, err)
}
if err := newFile.Close(); err != nil {
return fmt.Errorf("failed to close temp file %s: %v", tempPath, err)
}
// Atomic replace to avoid multi-writer file corruptions
if err := os.Rename(tempPath, path); err != nil {
return fmt.Errorf("failed to move temporary token to desired output location. src=%s dst=%s: %v", tempPath, path, err)
}
if err := os.Chmod(path, mode); err != nil {
return fmt.Errorf("failed to chmod the token file %s: %v", path, err)
}
return nil
} | [
"func",
"SaveToken",
"(",
"path",
"string",
",",
"mode",
"os",
".",
"FileMode",
",",
"token",
"Token",
")",
"error",
"{",
"dir",
":=",
"filepath",
".",
"Dir",
"(",
"path",
")",
"\n",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"dir",
",",
"os",
".",
"ModePerm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"dir",
",",
"err",
")",
"\n",
"}",
"\n\n",
"newFile",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"dir",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"tempPath",
":=",
"newFile",
".",
"Name",
"(",
")",
"\n\n",
"if",
"err",
":=",
"json",
".",
"NewEncoder",
"(",
"newFile",
")",
".",
"Encode",
"(",
"token",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tempPath",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"newFile",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tempPath",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Atomic replace to avoid multi-writer file corruptions",
"if",
"err",
":=",
"os",
".",
"Rename",
"(",
"tempPath",
",",
"path",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tempPath",
",",
"path",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"os",
".",
"Chmod",
"(",
"path",
",",
"mode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SaveToken persists an oauth token at the given location on disk.
// It moves the new file into place so it can safely be used to replace an existing file
// that maybe accessed by multiple processes. | [
"SaveToken",
"persists",
"an",
"oauth",
"token",
"at",
"the",
"given",
"location",
"on",
"disk",
".",
"It",
"moves",
"the",
"new",
"file",
"into",
"place",
"so",
"it",
"can",
"safely",
"be",
"used",
"to",
"replace",
"an",
"existing",
"file",
"that",
"maybe",
"accessed",
"by",
"multiple",
"processes",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/persist.go#L45-L73 |
152,553 | Azure/go-autorest | autorest/authorization.go | NewAPIKeyAuthorizer | func NewAPIKeyAuthorizer(headers map[string]interface{}, queryParameters map[string]interface{}) *APIKeyAuthorizer {
return &APIKeyAuthorizer{headers: headers, queryParameters: queryParameters}
} | go | func NewAPIKeyAuthorizer(headers map[string]interface{}, queryParameters map[string]interface{}) *APIKeyAuthorizer {
return &APIKeyAuthorizer{headers: headers, queryParameters: queryParameters}
} | [
"func",
"NewAPIKeyAuthorizer",
"(",
"headers",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"queryParameters",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"*",
"APIKeyAuthorizer",
"{",
"return",
"&",
"APIKeyAuthorizer",
"{",
"headers",
":",
"headers",
",",
"queryParameters",
":",
"queryParameters",
"}",
"\n",
"}"
] | // NewAPIKeyAuthorizer creates an ApiKeyAuthorizer with headers. | [
"NewAPIKeyAuthorizer",
"creates",
"an",
"ApiKeyAuthorizer",
"with",
"headers",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/authorization.go#L71-L73 |
152,554 | Azure/go-autorest | autorest/authorization.go | WithAuthorization | func (aka *APIKeyAuthorizer) WithAuthorization() PrepareDecorator {
return func(p Preparer) Preparer {
return DecoratePreparer(p, WithHeaders(aka.headers), WithQueryParameters(aka.queryParameters))
}
} | go | func (aka *APIKeyAuthorizer) WithAuthorization() PrepareDecorator {
return func(p Preparer) Preparer {
return DecoratePreparer(p, WithHeaders(aka.headers), WithQueryParameters(aka.queryParameters))
}
} | [
"func",
"(",
"aka",
"*",
"APIKeyAuthorizer",
")",
"WithAuthorization",
"(",
")",
"PrepareDecorator",
"{",
"return",
"func",
"(",
"p",
"Preparer",
")",
"Preparer",
"{",
"return",
"DecoratePreparer",
"(",
"p",
",",
"WithHeaders",
"(",
"aka",
".",
"headers",
")",
",",
"WithQueryParameters",
"(",
"aka",
".",
"queryParameters",
")",
")",
"\n",
"}",
"\n",
"}"
] | // WithAuthorization returns a PrepareDecorator that adds an HTTP headers and Query Parameters. | [
"WithAuthorization",
"returns",
"a",
"PrepareDecorator",
"that",
"adds",
"an",
"HTTP",
"headers",
"and",
"Query",
"Parameters",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/authorization.go#L76-L80 |
152,555 | Azure/go-autorest | autorest/authorization.go | WithAuthorization | func (ba *BearerAuthorizer) WithAuthorization() PrepareDecorator {
return func(p Preparer) Preparer {
return PreparerFunc(func(r *http.Request) (*http.Request, error) {
r, err := p.Prepare(r)
if err == nil {
// the ordering is important here, prefer RefresherWithContext if available
if refresher, ok := ba.tokenProvider.(adal.RefresherWithContext); ok {
err = refresher.EnsureFreshWithContext(r.Context())
} else if refresher, ok := ba.tokenProvider.(adal.Refresher); ok {
err = refresher.EnsureFresh()
}
if err != nil {
var resp *http.Response
if tokError, ok := err.(adal.TokenRefreshError); ok {
resp = tokError.Response()
}
return r, NewErrorWithError(err, "azure.BearerAuthorizer", "WithAuthorization", resp,
"Failed to refresh the Token for request to %s", r.URL)
}
return Prepare(r, WithHeader(headerAuthorization, fmt.Sprintf("Bearer %s", ba.tokenProvider.OAuthToken())))
}
return r, err
})
}
} | go | func (ba *BearerAuthorizer) WithAuthorization() PrepareDecorator {
return func(p Preparer) Preparer {
return PreparerFunc(func(r *http.Request) (*http.Request, error) {
r, err := p.Prepare(r)
if err == nil {
// the ordering is important here, prefer RefresherWithContext if available
if refresher, ok := ba.tokenProvider.(adal.RefresherWithContext); ok {
err = refresher.EnsureFreshWithContext(r.Context())
} else if refresher, ok := ba.tokenProvider.(adal.Refresher); ok {
err = refresher.EnsureFresh()
}
if err != nil {
var resp *http.Response
if tokError, ok := err.(adal.TokenRefreshError); ok {
resp = tokError.Response()
}
return r, NewErrorWithError(err, "azure.BearerAuthorizer", "WithAuthorization", resp,
"Failed to refresh the Token for request to %s", r.URL)
}
return Prepare(r, WithHeader(headerAuthorization, fmt.Sprintf("Bearer %s", ba.tokenProvider.OAuthToken())))
}
return r, err
})
}
} | [
"func",
"(",
"ba",
"*",
"BearerAuthorizer",
")",
"WithAuthorization",
"(",
")",
"PrepareDecorator",
"{",
"return",
"func",
"(",
"p",
"Preparer",
")",
"Preparer",
"{",
"return",
"PreparerFunc",
"(",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"p",
".",
"Prepare",
"(",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"// the ordering is important here, prefer RefresherWithContext if available",
"if",
"refresher",
",",
"ok",
":=",
"ba",
".",
"tokenProvider",
".",
"(",
"adal",
".",
"RefresherWithContext",
")",
";",
"ok",
"{",
"err",
"=",
"refresher",
".",
"EnsureFreshWithContext",
"(",
"r",
".",
"Context",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"refresher",
",",
"ok",
":=",
"ba",
".",
"tokenProvider",
".",
"(",
"adal",
".",
"Refresher",
")",
";",
"ok",
"{",
"err",
"=",
"refresher",
".",
"EnsureFresh",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"var",
"resp",
"*",
"http",
".",
"Response",
"\n",
"if",
"tokError",
",",
"ok",
":=",
"err",
".",
"(",
"adal",
".",
"TokenRefreshError",
")",
";",
"ok",
"{",
"resp",
"=",
"tokError",
".",
"Response",
"(",
")",
"\n",
"}",
"\n",
"return",
"r",
",",
"NewErrorWithError",
"(",
"err",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"resp",
",",
"\"",
"\"",
",",
"r",
".",
"URL",
")",
"\n",
"}",
"\n",
"return",
"Prepare",
"(",
"r",
",",
"WithHeader",
"(",
"headerAuthorization",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ba",
".",
"tokenProvider",
".",
"OAuthToken",
"(",
")",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"r",
",",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // WithAuthorization returns a PrepareDecorator that adds an HTTP Authorization header whose
// value is "Bearer " followed by the token.
//
// By default, the token will be automatically refreshed through the Refresher interface. | [
"WithAuthorization",
"returns",
"a",
"PrepareDecorator",
"that",
"adds",
"an",
"HTTP",
"Authorization",
"header",
"whose",
"value",
"is",
"Bearer",
"followed",
"by",
"the",
"token",
".",
"By",
"default",
"the",
"token",
"will",
"be",
"automatically",
"refreshed",
"through",
"the",
"Refresher",
"interface",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/authorization.go#L115-L139 |
152,556 | Azure/go-autorest | autorest/authorization.go | NewBearerAuthorizerCallback | func NewBearerAuthorizerCallback(sender Sender, callback BearerAuthorizerCallbackFunc) *BearerAuthorizerCallback {
if sender == nil {
sender = &http.Client{Transport: tracing.Transport}
}
return &BearerAuthorizerCallback{sender: sender, callback: callback}
} | go | func NewBearerAuthorizerCallback(sender Sender, callback BearerAuthorizerCallbackFunc) *BearerAuthorizerCallback {
if sender == nil {
sender = &http.Client{Transport: tracing.Transport}
}
return &BearerAuthorizerCallback{sender: sender, callback: callback}
} | [
"func",
"NewBearerAuthorizerCallback",
"(",
"sender",
"Sender",
",",
"callback",
"BearerAuthorizerCallbackFunc",
")",
"*",
"BearerAuthorizerCallback",
"{",
"if",
"sender",
"==",
"nil",
"{",
"sender",
"=",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"tracing",
".",
"Transport",
"}",
"\n",
"}",
"\n",
"return",
"&",
"BearerAuthorizerCallback",
"{",
"sender",
":",
"sender",
",",
"callback",
":",
"callback",
"}",
"\n",
"}"
] | // NewBearerAuthorizerCallback creates a bearer authorization callback. The callback
// is invoked when the HTTP request is submitted. | [
"NewBearerAuthorizerCallback",
"creates",
"a",
"bearer",
"authorization",
"callback",
".",
"The",
"callback",
"is",
"invoked",
"when",
"the",
"HTTP",
"request",
"is",
"submitted",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/authorization.go#L152-L157 |
152,557 | Azure/go-autorest | autorest/authorization.go | WithAuthorization | func (bacb *BearerAuthorizerCallback) WithAuthorization() PrepareDecorator {
return func(p Preparer) Preparer {
return PreparerFunc(func(r *http.Request) (*http.Request, error) {
r, err := p.Prepare(r)
if err == nil {
// make a copy of the request and remove the body as it's not
// required and avoids us having to create a copy of it.
rCopy := *r
removeRequestBody(&rCopy)
resp, err := bacb.sender.Do(&rCopy)
if err == nil && resp.StatusCode == 401 {
defer resp.Body.Close()
if hasBearerChallenge(resp) {
bc, err := newBearerChallenge(resp)
if err != nil {
return r, err
}
if bacb.callback != nil {
ba, err := bacb.callback(bc.values[tenantID], bc.values["resource"])
if err != nil {
return r, err
}
return Prepare(r, ba.WithAuthorization())
}
}
}
}
return r, err
})
}
} | go | func (bacb *BearerAuthorizerCallback) WithAuthorization() PrepareDecorator {
return func(p Preparer) Preparer {
return PreparerFunc(func(r *http.Request) (*http.Request, error) {
r, err := p.Prepare(r)
if err == nil {
// make a copy of the request and remove the body as it's not
// required and avoids us having to create a copy of it.
rCopy := *r
removeRequestBody(&rCopy)
resp, err := bacb.sender.Do(&rCopy)
if err == nil && resp.StatusCode == 401 {
defer resp.Body.Close()
if hasBearerChallenge(resp) {
bc, err := newBearerChallenge(resp)
if err != nil {
return r, err
}
if bacb.callback != nil {
ba, err := bacb.callback(bc.values[tenantID], bc.values["resource"])
if err != nil {
return r, err
}
return Prepare(r, ba.WithAuthorization())
}
}
}
}
return r, err
})
}
} | [
"func",
"(",
"bacb",
"*",
"BearerAuthorizerCallback",
")",
"WithAuthorization",
"(",
")",
"PrepareDecorator",
"{",
"return",
"func",
"(",
"p",
"Preparer",
")",
"Preparer",
"{",
"return",
"PreparerFunc",
"(",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"p",
".",
"Prepare",
"(",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"// make a copy of the request and remove the body as it's not",
"// required and avoids us having to create a copy of it.",
"rCopy",
":=",
"*",
"r",
"\n",
"removeRequestBody",
"(",
"&",
"rCopy",
")",
"\n\n",
"resp",
",",
"err",
":=",
"bacb",
".",
"sender",
".",
"Do",
"(",
"&",
"rCopy",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"resp",
".",
"StatusCode",
"==",
"401",
"{",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"hasBearerChallenge",
"(",
"resp",
")",
"{",
"bc",
",",
"err",
":=",
"newBearerChallenge",
"(",
"resp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"r",
",",
"err",
"\n",
"}",
"\n",
"if",
"bacb",
".",
"callback",
"!=",
"nil",
"{",
"ba",
",",
"err",
":=",
"bacb",
".",
"callback",
"(",
"bc",
".",
"values",
"[",
"tenantID",
"]",
",",
"bc",
".",
"values",
"[",
"\"",
"\"",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"Prepare",
"(",
"r",
",",
"ba",
".",
"WithAuthorization",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"r",
",",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // WithAuthorization returns a PrepareDecorator that adds an HTTP Authorization header whose value
// is "Bearer " followed by the token. The BearerAuthorizer is obtained via a user-supplied callback.
//
// By default, the token will be automatically refreshed through the Refresher interface. | [
"WithAuthorization",
"returns",
"a",
"PrepareDecorator",
"that",
"adds",
"an",
"HTTP",
"Authorization",
"header",
"whose",
"value",
"is",
"Bearer",
"followed",
"by",
"the",
"token",
".",
"The",
"BearerAuthorizer",
"is",
"obtained",
"via",
"a",
"user",
"-",
"supplied",
"callback",
".",
"By",
"default",
"the",
"token",
"will",
"be",
"automatically",
"refreshed",
"through",
"the",
"Refresher",
"interface",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/authorization.go#L163-L194 |
152,558 | Azure/go-autorest | autorest/authorization.go | hasBearerChallenge | func hasBearerChallenge(resp *http.Response) bool {
authHeader := resp.Header.Get(bearerChallengeHeader)
if len(authHeader) == 0 || strings.Index(authHeader, bearer) < 0 {
return false
}
return true
} | go | func hasBearerChallenge(resp *http.Response) bool {
authHeader := resp.Header.Get(bearerChallengeHeader)
if len(authHeader) == 0 || strings.Index(authHeader, bearer) < 0 {
return false
}
return true
} | [
"func",
"hasBearerChallenge",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"bool",
"{",
"authHeader",
":=",
"resp",
".",
"Header",
".",
"Get",
"(",
"bearerChallengeHeader",
")",
"\n",
"if",
"len",
"(",
"authHeader",
")",
"==",
"0",
"||",
"strings",
".",
"Index",
"(",
"authHeader",
",",
"bearer",
")",
"<",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // returns true if the HTTP response contains a bearer challenge | [
"returns",
"true",
"if",
"the",
"HTTP",
"response",
"contains",
"a",
"bearer",
"challenge"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/authorization.go#L197-L203 |
152,559 | Azure/go-autorest | autorest/authorization.go | WithAuthorization | func (egta EventGridKeyAuthorizer) WithAuthorization() PrepareDecorator {
headers := map[string]interface{}{
"aeg-sas-key": egta.topicKey,
}
return NewAPIKeyAuthorizerWithHeaders(headers).WithAuthorization()
} | go | func (egta EventGridKeyAuthorizer) WithAuthorization() PrepareDecorator {
headers := map[string]interface{}{
"aeg-sas-key": egta.topicKey,
}
return NewAPIKeyAuthorizerWithHeaders(headers).WithAuthorization()
} | [
"func",
"(",
"egta",
"EventGridKeyAuthorizer",
")",
"WithAuthorization",
"(",
")",
"PrepareDecorator",
"{",
"headers",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"egta",
".",
"topicKey",
",",
"}",
"\n",
"return",
"NewAPIKeyAuthorizerWithHeaders",
"(",
"headers",
")",
".",
"WithAuthorization",
"(",
")",
"\n",
"}"
] | // WithAuthorization returns a PrepareDecorator that adds the aeg-sas-key authentication header. | [
"WithAuthorization",
"returns",
"a",
"PrepareDecorator",
"that",
"adds",
"the",
"aeg",
"-",
"sas",
"-",
"key",
"authentication",
"header",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/authorization.go#L258-L263 |
152,560 | Azure/go-autorest | autorest/authorization.go | NewBasicAuthorizer | func NewBasicAuthorizer(userName, password string) *BasicAuthorizer {
return &BasicAuthorizer{
userName: userName,
password: password,
}
} | go | func NewBasicAuthorizer(userName, password string) *BasicAuthorizer {
return &BasicAuthorizer{
userName: userName,
password: password,
}
} | [
"func",
"NewBasicAuthorizer",
"(",
"userName",
",",
"password",
"string",
")",
"*",
"BasicAuthorizer",
"{",
"return",
"&",
"BasicAuthorizer",
"{",
"userName",
":",
"userName",
",",
"password",
":",
"password",
",",
"}",
"\n",
"}"
] | // NewBasicAuthorizer creates a new BasicAuthorizer with the specified username and password. | [
"NewBasicAuthorizer",
"creates",
"a",
"new",
"BasicAuthorizer",
"with",
"the",
"specified",
"username",
"and",
"password",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/authorization.go#L273-L278 |
152,561 | Azure/go-autorest | autorest/client.go | Do | func (c Client) Do(r *http.Request) (*http.Response, error) {
if r.UserAgent() == "" {
r, _ = Prepare(r,
WithUserAgent(c.UserAgent))
}
// NOTE: c.WithInspection() must be last in the list so that it can inspect all preceding operations
r, err := Prepare(r,
c.WithAuthorization(),
c.WithInspection())
if err != nil {
var resp *http.Response
if detErr, ok := err.(DetailedError); ok {
// if the authorization failed (e.g. invalid credentials) there will
// be a response associated with the error, be sure to return it.
resp = detErr.Response
}
return resp, NewErrorWithError(err, "autorest/Client", "Do", nil, "Preparing request failed")
}
logger.Instance.WriteRequest(r, logger.Filter{
Header: func(k string, v []string) (bool, []string) {
// remove the auth token from the log
if strings.EqualFold(k, "Authorization") || strings.EqualFold(k, "Ocp-Apim-Subscription-Key") {
v = []string{"**REDACTED**"}
}
return true, v
},
})
resp, err := SendWithSender(c.sender(tls.RenegotiateNever), r)
logger.Instance.WriteResponse(resp, logger.Filter{})
Respond(resp, c.ByInspecting())
return resp, err
} | go | func (c Client) Do(r *http.Request) (*http.Response, error) {
if r.UserAgent() == "" {
r, _ = Prepare(r,
WithUserAgent(c.UserAgent))
}
// NOTE: c.WithInspection() must be last in the list so that it can inspect all preceding operations
r, err := Prepare(r,
c.WithAuthorization(),
c.WithInspection())
if err != nil {
var resp *http.Response
if detErr, ok := err.(DetailedError); ok {
// if the authorization failed (e.g. invalid credentials) there will
// be a response associated with the error, be sure to return it.
resp = detErr.Response
}
return resp, NewErrorWithError(err, "autorest/Client", "Do", nil, "Preparing request failed")
}
logger.Instance.WriteRequest(r, logger.Filter{
Header: func(k string, v []string) (bool, []string) {
// remove the auth token from the log
if strings.EqualFold(k, "Authorization") || strings.EqualFold(k, "Ocp-Apim-Subscription-Key") {
v = []string{"**REDACTED**"}
}
return true, v
},
})
resp, err := SendWithSender(c.sender(tls.RenegotiateNever), r)
logger.Instance.WriteResponse(resp, logger.Filter{})
Respond(resp, c.ByInspecting())
return resp, err
} | [
"func",
"(",
"c",
"Client",
")",
"Do",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"if",
"r",
".",
"UserAgent",
"(",
")",
"==",
"\"",
"\"",
"{",
"r",
",",
"_",
"=",
"Prepare",
"(",
"r",
",",
"WithUserAgent",
"(",
"c",
".",
"UserAgent",
")",
")",
"\n",
"}",
"\n",
"// NOTE: c.WithInspection() must be last in the list so that it can inspect all preceding operations",
"r",
",",
"err",
":=",
"Prepare",
"(",
"r",
",",
"c",
".",
"WithAuthorization",
"(",
")",
",",
"c",
".",
"WithInspection",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"var",
"resp",
"*",
"http",
".",
"Response",
"\n",
"if",
"detErr",
",",
"ok",
":=",
"err",
".",
"(",
"DetailedError",
")",
";",
"ok",
"{",
"// if the authorization failed (e.g. invalid credentials) there will",
"// be a response associated with the error, be sure to return it.",
"resp",
"=",
"detErr",
".",
"Response",
"\n",
"}",
"\n",
"return",
"resp",
",",
"NewErrorWithError",
"(",
"err",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"nil",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"logger",
".",
"Instance",
".",
"WriteRequest",
"(",
"r",
",",
"logger",
".",
"Filter",
"{",
"Header",
":",
"func",
"(",
"k",
"string",
",",
"v",
"[",
"]",
"string",
")",
"(",
"bool",
",",
"[",
"]",
"string",
")",
"{",
"// remove the auth token from the log",
"if",
"strings",
".",
"EqualFold",
"(",
"k",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"EqualFold",
"(",
"k",
",",
"\"",
"\"",
")",
"{",
"v",
"=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
"\n",
"}",
"\n",
"return",
"true",
",",
"v",
"\n",
"}",
",",
"}",
")",
"\n",
"resp",
",",
"err",
":=",
"SendWithSender",
"(",
"c",
".",
"sender",
"(",
"tls",
".",
"RenegotiateNever",
")",
",",
"r",
")",
"\n",
"logger",
".",
"Instance",
".",
"WriteResponse",
"(",
"resp",
",",
"logger",
".",
"Filter",
"{",
"}",
")",
"\n",
"Respond",
"(",
"resp",
",",
"c",
".",
"ByInspecting",
"(",
")",
")",
"\n",
"return",
"resp",
",",
"err",
"\n",
"}"
] | // Do implements the Sender interface by invoking the active Sender after applying authorization.
// If Sender is not set, it uses a new instance of http.Client. In both cases it will, if UserAgent
// is set, apply set the User-Agent header. | [
"Do",
"implements",
"the",
"Sender",
"interface",
"by",
"invoking",
"the",
"active",
"Sender",
"after",
"applying",
"authorization",
".",
"If",
"Sender",
"is",
"not",
"set",
"it",
"uses",
"a",
"new",
"instance",
"of",
"http",
".",
"Client",
".",
"In",
"both",
"cases",
"it",
"will",
"if",
"UserAgent",
"is",
"set",
"apply",
"set",
"the",
"User",
"-",
"Agent",
"header",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/client.go#L215-L246 |
152,562 | Azure/go-autorest | autorest/client.go | sender | func (c Client) sender(renengotiation tls.RenegotiationSupport) Sender {
if c.Sender == nil {
// Use behaviour compatible with DefaultTransport, but require TLS minimum version.
var defaultTransport = http.DefaultTransport.(*http.Transport)
transport := tracing.Transport
// for non-default values of TLS renegotiation create a new tracing transport.
// updating tracing.Transport affects all clients which is not what we want.
if renengotiation != tls.RenegotiateNever {
transport = tracing.NewTransport()
}
transport.Base = &http.Transport{
Proxy: defaultTransport.Proxy,
DialContext: defaultTransport.DialContext,
MaxIdleConns: defaultTransport.MaxIdleConns,
IdleConnTimeout: defaultTransport.IdleConnTimeout,
TLSHandshakeTimeout: defaultTransport.TLSHandshakeTimeout,
ExpectContinueTimeout: defaultTransport.ExpectContinueTimeout,
TLSClientConfig: &tls.Config{
MinVersion: tls.VersionTLS12,
Renegotiation: renengotiation,
},
}
j, _ := cookiejar.New(nil)
return &http.Client{Jar: j, Transport: transport}
}
return c.Sender
} | go | func (c Client) sender(renengotiation tls.RenegotiationSupport) Sender {
if c.Sender == nil {
// Use behaviour compatible with DefaultTransport, but require TLS minimum version.
var defaultTransport = http.DefaultTransport.(*http.Transport)
transport := tracing.Transport
// for non-default values of TLS renegotiation create a new tracing transport.
// updating tracing.Transport affects all clients which is not what we want.
if renengotiation != tls.RenegotiateNever {
transport = tracing.NewTransport()
}
transport.Base = &http.Transport{
Proxy: defaultTransport.Proxy,
DialContext: defaultTransport.DialContext,
MaxIdleConns: defaultTransport.MaxIdleConns,
IdleConnTimeout: defaultTransport.IdleConnTimeout,
TLSHandshakeTimeout: defaultTransport.TLSHandshakeTimeout,
ExpectContinueTimeout: defaultTransport.ExpectContinueTimeout,
TLSClientConfig: &tls.Config{
MinVersion: tls.VersionTLS12,
Renegotiation: renengotiation,
},
}
j, _ := cookiejar.New(nil)
return &http.Client{Jar: j, Transport: transport}
}
return c.Sender
} | [
"func",
"(",
"c",
"Client",
")",
"sender",
"(",
"renengotiation",
"tls",
".",
"RenegotiationSupport",
")",
"Sender",
"{",
"if",
"c",
".",
"Sender",
"==",
"nil",
"{",
"// Use behaviour compatible with DefaultTransport, but require TLS minimum version.",
"var",
"defaultTransport",
"=",
"http",
".",
"DefaultTransport",
".",
"(",
"*",
"http",
".",
"Transport",
")",
"\n",
"transport",
":=",
"tracing",
".",
"Transport",
"\n",
"// for non-default values of TLS renegotiation create a new tracing transport.",
"// updating tracing.Transport affects all clients which is not what we want.",
"if",
"renengotiation",
"!=",
"tls",
".",
"RenegotiateNever",
"{",
"transport",
"=",
"tracing",
".",
"NewTransport",
"(",
")",
"\n",
"}",
"\n",
"transport",
".",
"Base",
"=",
"&",
"http",
".",
"Transport",
"{",
"Proxy",
":",
"defaultTransport",
".",
"Proxy",
",",
"DialContext",
":",
"defaultTransport",
".",
"DialContext",
",",
"MaxIdleConns",
":",
"defaultTransport",
".",
"MaxIdleConns",
",",
"IdleConnTimeout",
":",
"defaultTransport",
".",
"IdleConnTimeout",
",",
"TLSHandshakeTimeout",
":",
"defaultTransport",
".",
"TLSHandshakeTimeout",
",",
"ExpectContinueTimeout",
":",
"defaultTransport",
".",
"ExpectContinueTimeout",
",",
"TLSClientConfig",
":",
"&",
"tls",
".",
"Config",
"{",
"MinVersion",
":",
"tls",
".",
"VersionTLS12",
",",
"Renegotiation",
":",
"renengotiation",
",",
"}",
",",
"}",
"\n",
"j",
",",
"_",
":=",
"cookiejar",
".",
"New",
"(",
"nil",
")",
"\n",
"return",
"&",
"http",
".",
"Client",
"{",
"Jar",
":",
"j",
",",
"Transport",
":",
"transport",
"}",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"Sender",
"\n",
"}"
] | // sender returns the Sender to which to send requests. | [
"sender",
"returns",
"the",
"Sender",
"to",
"which",
"to",
"send",
"requests",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/client.go#L249-L276 |
152,563 | Azure/go-autorest | autorest/client.go | authorizer | func (c Client) authorizer() Authorizer {
if c.Authorizer == nil {
return NullAuthorizer{}
}
return c.Authorizer
} | go | func (c Client) authorizer() Authorizer {
if c.Authorizer == nil {
return NullAuthorizer{}
}
return c.Authorizer
} | [
"func",
"(",
"c",
"Client",
")",
"authorizer",
"(",
")",
"Authorizer",
"{",
"if",
"c",
".",
"Authorizer",
"==",
"nil",
"{",
"return",
"NullAuthorizer",
"{",
"}",
"\n",
"}",
"\n",
"return",
"c",
".",
"Authorizer",
"\n",
"}"
] | // authorizer returns the Authorizer to use. | [
"authorizer",
"returns",
"the",
"Authorizer",
"to",
"use",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/client.go#L285-L290 |
152,564 | Azure/go-autorest | autorest/client.go | WithInspection | func (c Client) WithInspection() PrepareDecorator {
if c.RequestInspector == nil {
return WithNothing()
}
return c.RequestInspector
} | go | func (c Client) WithInspection() PrepareDecorator {
if c.RequestInspector == nil {
return WithNothing()
}
return c.RequestInspector
} | [
"func",
"(",
"c",
"Client",
")",
"WithInspection",
"(",
")",
"PrepareDecorator",
"{",
"if",
"c",
".",
"RequestInspector",
"==",
"nil",
"{",
"return",
"WithNothing",
"(",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"RequestInspector",
"\n",
"}"
] | // WithInspection is a convenience method that passes the request to the supplied RequestInspector,
// if present, or returns the WithNothing PrepareDecorator otherwise. | [
"WithInspection",
"is",
"a",
"convenience",
"method",
"that",
"passes",
"the",
"request",
"to",
"the",
"supplied",
"RequestInspector",
"if",
"present",
"or",
"returns",
"the",
"WithNothing",
"PrepareDecorator",
"otherwise",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/client.go#L294-L299 |
152,565 | Azure/go-autorest | autorest/client.go | ByInspecting | func (c Client) ByInspecting() RespondDecorator {
if c.ResponseInspector == nil {
return ByIgnoring()
}
return c.ResponseInspector
} | go | func (c Client) ByInspecting() RespondDecorator {
if c.ResponseInspector == nil {
return ByIgnoring()
}
return c.ResponseInspector
} | [
"func",
"(",
"c",
"Client",
")",
"ByInspecting",
"(",
")",
"RespondDecorator",
"{",
"if",
"c",
".",
"ResponseInspector",
"==",
"nil",
"{",
"return",
"ByIgnoring",
"(",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"ResponseInspector",
"\n",
"}"
] | // ByInspecting is a convenience method that passes the response to the supplied ResponseInspector,
// if present, or returns the ByIgnoring RespondDecorator otherwise. | [
"ByInspecting",
"is",
"a",
"convenience",
"method",
"that",
"passes",
"the",
"response",
"to",
"the",
"supplied",
"ResponseInspector",
"if",
"present",
"or",
"returns",
"the",
"ByIgnoring",
"RespondDecorator",
"otherwise",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/client.go#L303-L308 |
152,566 | Azure/go-autorest | logger/logger.go | ParseLevel | func ParseLevel(s string) (lt LevelType, err error) {
switch strings.ToUpper(s) {
case logFatal:
lt = LogFatal
case logPanic:
lt = LogPanic
case logError:
lt = LogError
case logWarning:
lt = LogWarning
case logInfo:
lt = LogInfo
case logDebug:
lt = LogDebug
default:
err = fmt.Errorf("bad log level '%s'", s)
}
return
} | go | func ParseLevel(s string) (lt LevelType, err error) {
switch strings.ToUpper(s) {
case logFatal:
lt = LogFatal
case logPanic:
lt = LogPanic
case logError:
lt = LogError
case logWarning:
lt = LogWarning
case logInfo:
lt = LogInfo
case logDebug:
lt = LogDebug
default:
err = fmt.Errorf("bad log level '%s'", s)
}
return
} | [
"func",
"ParseLevel",
"(",
"s",
"string",
")",
"(",
"lt",
"LevelType",
",",
"err",
"error",
")",
"{",
"switch",
"strings",
".",
"ToUpper",
"(",
"s",
")",
"{",
"case",
"logFatal",
":",
"lt",
"=",
"LogFatal",
"\n",
"case",
"logPanic",
":",
"lt",
"=",
"LogPanic",
"\n",
"case",
"logError",
":",
"lt",
"=",
"LogError",
"\n",
"case",
"logWarning",
":",
"lt",
"=",
"LogWarning",
"\n",
"case",
"logInfo",
":",
"lt",
"=",
"LogInfo",
"\n",
"case",
"logDebug",
":",
"lt",
"=",
"LogDebug",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // ParseLevel converts the specified string into the corresponding LevelType. | [
"ParseLevel",
"converts",
"the",
"specified",
"string",
"into",
"the",
"corresponding",
"LevelType",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/logger/logger.go#L72-L90 |
152,567 | Azure/go-autorest | logger/logger.go | String | func (lt LevelType) String() string {
switch lt {
case LogNone:
return logNone
case LogFatal:
return logFatal
case LogPanic:
return logPanic
case LogError:
return logError
case LogWarning:
return logWarning
case LogInfo:
return logInfo
case LogDebug:
return logDebug
default:
return logUnknown
}
} | go | func (lt LevelType) String() string {
switch lt {
case LogNone:
return logNone
case LogFatal:
return logFatal
case LogPanic:
return logPanic
case LogError:
return logError
case LogWarning:
return logWarning
case LogInfo:
return logInfo
case LogDebug:
return logDebug
default:
return logUnknown
}
} | [
"func",
"(",
"lt",
"LevelType",
")",
"String",
"(",
")",
"string",
"{",
"switch",
"lt",
"{",
"case",
"LogNone",
":",
"return",
"logNone",
"\n",
"case",
"LogFatal",
":",
"return",
"logFatal",
"\n",
"case",
"LogPanic",
":",
"return",
"logPanic",
"\n",
"case",
"LogError",
":",
"return",
"logError",
"\n",
"case",
"LogWarning",
":",
"return",
"logWarning",
"\n",
"case",
"LogInfo",
":",
"return",
"logInfo",
"\n",
"case",
"LogDebug",
":",
"return",
"logDebug",
"\n",
"default",
":",
"return",
"logUnknown",
"\n",
"}",
"\n",
"}"
] | // String implements the stringer interface for LevelType. | [
"String",
"implements",
"the",
"stringer",
"interface",
"for",
"LevelType",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/logger/logger.go#L93-L112 |
152,568 | Azure/go-autorest | logger/logger.go | shouldLogBody | func (fl fileLogger) shouldLogBody(header http.Header, body io.ReadCloser) bool {
ct := header.Get("Content-Type")
return fl.logLevel >= LogDebug && body != nil && !strings.Contains(ct, "application/octet-stream")
} | go | func (fl fileLogger) shouldLogBody(header http.Header, body io.ReadCloser) bool {
ct := header.Get("Content-Type")
return fl.logLevel >= LogDebug && body != nil && !strings.Contains(ct, "application/octet-stream")
} | [
"func",
"(",
"fl",
"fileLogger",
")",
"shouldLogBody",
"(",
"header",
"http",
".",
"Header",
",",
"body",
"io",
".",
"ReadCloser",
")",
"bool",
"{",
"ct",
":=",
"header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"return",
"fl",
".",
"logLevel",
">=",
"LogDebug",
"&&",
"body",
"!=",
"nil",
"&&",
"!",
"strings",
".",
"Contains",
"(",
"ct",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // returns true if the provided body should be included in the log | [
"returns",
"true",
"if",
"the",
"provided",
"body",
"should",
"be",
"included",
"in",
"the",
"log"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/logger/logger.go#L319-L322 |
152,569 | Azure/go-autorest | logger/logger.go | entryHeader | func entryHeader(level LevelType) string {
// this format provides a fixed number of digits so the size of the timestamp is constant
return fmt.Sprintf("(%s) %s:", time.Now().Format("2006-01-02T15:04:05.0000000Z07:00"), level.String())
} | go | func entryHeader(level LevelType) string {
// this format provides a fixed number of digits so the size of the timestamp is constant
return fmt.Sprintf("(%s) %s:", time.Now().Format("2006-01-02T15:04:05.0000000Z07:00"), level.String())
} | [
"func",
"entryHeader",
"(",
"level",
"LevelType",
")",
"string",
"{",
"// this format provides a fixed number of digits so the size of the timestamp is constant",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"time",
".",
"Now",
"(",
")",
".",
"Format",
"(",
"\"",
"\"",
")",
",",
"level",
".",
"String",
"(",
")",
")",
"\n",
"}"
] | // creates standard header for log entries, it contains a timestamp and the log level | [
"creates",
"standard",
"header",
"for",
"log",
"entries",
"it",
"contains",
"a",
"timestamp",
"and",
"the",
"log",
"level"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/logger/logger.go#L325-L328 |
152,570 | Azure/go-autorest | autorest/azure/rp.go | DoRetryWithRegistration | func DoRetryWithRegistration(client autorest.Client) autorest.SendDecorator {
return func(s autorest.Sender) autorest.Sender {
return autorest.SenderFunc(func(r *http.Request) (resp *http.Response, err error) {
rr := autorest.NewRetriableRequest(r)
for currentAttempt := 0; currentAttempt < client.RetryAttempts; currentAttempt++ {
err = rr.Prepare()
if err != nil {
return resp, err
}
resp, err = autorest.SendWithSender(s, rr.Request(),
autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...),
)
if err != nil {
return resp, err
}
if resp.StatusCode != http.StatusConflict || client.SkipResourceProviderRegistration {
return resp, err
}
var re RequestError
err = autorest.Respond(
resp,
autorest.ByUnmarshallingJSON(&re),
)
if err != nil {
return resp, err
}
err = re
if re.ServiceError != nil && re.ServiceError.Code == "MissingSubscriptionRegistration" {
regErr := register(client, r, re)
if regErr != nil {
return resp, fmt.Errorf("failed auto registering Resource Provider: %s. Original error: %s", regErr, err)
}
}
}
return resp, err
})
}
} | go | func DoRetryWithRegistration(client autorest.Client) autorest.SendDecorator {
return func(s autorest.Sender) autorest.Sender {
return autorest.SenderFunc(func(r *http.Request) (resp *http.Response, err error) {
rr := autorest.NewRetriableRequest(r)
for currentAttempt := 0; currentAttempt < client.RetryAttempts; currentAttempt++ {
err = rr.Prepare()
if err != nil {
return resp, err
}
resp, err = autorest.SendWithSender(s, rr.Request(),
autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...),
)
if err != nil {
return resp, err
}
if resp.StatusCode != http.StatusConflict || client.SkipResourceProviderRegistration {
return resp, err
}
var re RequestError
err = autorest.Respond(
resp,
autorest.ByUnmarshallingJSON(&re),
)
if err != nil {
return resp, err
}
err = re
if re.ServiceError != nil && re.ServiceError.Code == "MissingSubscriptionRegistration" {
regErr := register(client, r, re)
if regErr != nil {
return resp, fmt.Errorf("failed auto registering Resource Provider: %s. Original error: %s", regErr, err)
}
}
}
return resp, err
})
}
} | [
"func",
"DoRetryWithRegistration",
"(",
"client",
"autorest",
".",
"Client",
")",
"autorest",
".",
"SendDecorator",
"{",
"return",
"func",
"(",
"s",
"autorest",
".",
"Sender",
")",
"autorest",
".",
"Sender",
"{",
"return",
"autorest",
".",
"SenderFunc",
"(",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"{",
"rr",
":=",
"autorest",
".",
"NewRetriableRequest",
"(",
"r",
")",
"\n",
"for",
"currentAttempt",
":=",
"0",
";",
"currentAttempt",
"<",
"client",
".",
"RetryAttempts",
";",
"currentAttempt",
"++",
"{",
"err",
"=",
"rr",
".",
"Prepare",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"resp",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
"=",
"autorest",
".",
"SendWithSender",
"(",
"s",
",",
"rr",
".",
"Request",
"(",
")",
",",
"autorest",
".",
"DoRetryForStatusCodes",
"(",
"client",
".",
"RetryAttempts",
",",
"client",
".",
"RetryDuration",
",",
"autorest",
".",
"StatusCodesForRetry",
"...",
")",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"resp",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusConflict",
"||",
"client",
".",
"SkipResourceProviderRegistration",
"{",
"return",
"resp",
",",
"err",
"\n",
"}",
"\n",
"var",
"re",
"RequestError",
"\n",
"err",
"=",
"autorest",
".",
"Respond",
"(",
"resp",
",",
"autorest",
".",
"ByUnmarshallingJSON",
"(",
"&",
"re",
")",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"resp",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"re",
"\n\n",
"if",
"re",
".",
"ServiceError",
"!=",
"nil",
"&&",
"re",
".",
"ServiceError",
".",
"Code",
"==",
"\"",
"\"",
"{",
"regErr",
":=",
"register",
"(",
"client",
",",
"r",
",",
"re",
")",
"\n",
"if",
"regErr",
"!=",
"nil",
"{",
"return",
"resp",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"regErr",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"resp",
",",
"err",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // DoRetryWithRegistration tries to register the resource provider in case it is unregistered.
// It also handles request retries | [
"DoRetryWithRegistration",
"tries",
"to",
"register",
"the",
"resource",
"provider",
"in",
"case",
"it",
"is",
"unregistered",
".",
"It",
"also",
"handles",
"request",
"retries"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/azure/rp.go#L30-L70 |
152,571 | Azure/go-autorest | autorest/mocks/helpers.go | NewRequestWithContent | func NewRequestWithContent(c string) *http.Request {
r, _ := http.NewRequest("GET", "https://microsoft.com/a/b/c/", NewBody(c))
return r
} | go | func NewRequestWithContent(c string) *http.Request {
r, _ := http.NewRequest("GET", "https://microsoft.com/a/b/c/", NewBody(c))
return r
} | [
"func",
"NewRequestWithContent",
"(",
"c",
"string",
")",
"*",
"http",
".",
"Request",
"{",
"r",
",",
"_",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"NewBody",
"(",
"c",
")",
")",
"\n",
"return",
"r",
"\n",
"}"
] | // NewRequestWithContent instantiates a new request using the passed string for the body content. | [
"NewRequestWithContent",
"instantiates",
"a",
"new",
"request",
"using",
"the",
"passed",
"string",
"for",
"the",
"body",
"content",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L58-L61 |
152,572 | Azure/go-autorest | autorest/mocks/helpers.go | NewRequestWithCloseBodyContent | func NewRequestWithCloseBodyContent(c string) *http.Request {
r, _ := http.NewRequest("GET", "https://microsoft.com/a/b/c/", NewBodyClose(c))
return r
} | go | func NewRequestWithCloseBodyContent(c string) *http.Request {
r, _ := http.NewRequest("GET", "https://microsoft.com/a/b/c/", NewBodyClose(c))
return r
} | [
"func",
"NewRequestWithCloseBodyContent",
"(",
"c",
"string",
")",
"*",
"http",
".",
"Request",
"{",
"r",
",",
"_",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"NewBodyClose",
"(",
"c",
")",
")",
"\n",
"return",
"r",
"\n",
"}"
] | // NewRequestWithCloseBodyContent instantiates a new request using the passed string for the body content. | [
"NewRequestWithCloseBodyContent",
"instantiates",
"a",
"new",
"request",
"using",
"the",
"passed",
"string",
"for",
"the",
"body",
"content",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L69-L72 |
152,573 | Azure/go-autorest | autorest/mocks/helpers.go | NewRequestWithParams | func NewRequestWithParams(method, u string, body io.Reader) *http.Request {
r, err := http.NewRequest(method, u, body)
if err != nil {
panic(fmt.Sprintf("mocks: ERROR (%v) parsing testing URL %s", err, u))
}
return r
} | go | func NewRequestWithParams(method, u string, body io.Reader) *http.Request {
r, err := http.NewRequest(method, u, body)
if err != nil {
panic(fmt.Sprintf("mocks: ERROR (%v) parsing testing URL %s", err, u))
}
return r
} | [
"func",
"NewRequestWithParams",
"(",
"method",
",",
"u",
"string",
",",
"body",
"io",
".",
"Reader",
")",
"*",
"http",
".",
"Request",
"{",
"r",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"method",
",",
"u",
",",
"body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
",",
"u",
")",
")",
"\n",
"}",
"\n",
"return",
"r",
"\n",
"}"
] | // NewRequestWithParams instantiates a new request using the provided parameters. | [
"NewRequestWithParams",
"instantiates",
"a",
"new",
"request",
"using",
"the",
"provided",
"parameters",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L80-L86 |
152,574 | Azure/go-autorest | autorest/mocks/helpers.go | NewResponseWithContent | func NewResponseWithContent(c string) *http.Response {
return &http.Response{
Status: "200 OK",
StatusCode: 200,
Proto: "HTTP/1.0",
ProtoMajor: 1,
ProtoMinor: 0,
Body: NewBody(c),
Request: NewRequest(),
}
} | go | func NewResponseWithContent(c string) *http.Response {
return &http.Response{
Status: "200 OK",
StatusCode: 200,
Proto: "HTTP/1.0",
ProtoMajor: 1,
ProtoMinor: 0,
Body: NewBody(c),
Request: NewRequest(),
}
} | [
"func",
"NewResponseWithContent",
"(",
"c",
"string",
")",
"*",
"http",
".",
"Response",
"{",
"return",
"&",
"http",
".",
"Response",
"{",
"Status",
":",
"\"",
"\"",
",",
"StatusCode",
":",
"200",
",",
"Proto",
":",
"\"",
"\"",
",",
"ProtoMajor",
":",
"1",
",",
"ProtoMinor",
":",
"0",
",",
"Body",
":",
"NewBody",
"(",
"c",
")",
",",
"Request",
":",
"NewRequest",
"(",
")",
",",
"}",
"\n",
"}"
] | // NewResponseWithContent instantiates a new response with the passed string as the body content. | [
"NewResponseWithContent",
"instantiates",
"a",
"new",
"response",
"with",
"the",
"passed",
"string",
"as",
"the",
"body",
"content",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L94-L104 |
152,575 | Azure/go-autorest | autorest/mocks/helpers.go | NewResponseWithStatus | func NewResponseWithStatus(s string, c int) *http.Response {
resp := NewResponse()
resp.Status = s
resp.StatusCode = c
return resp
} | go | func NewResponseWithStatus(s string, c int) *http.Response {
resp := NewResponse()
resp.Status = s
resp.StatusCode = c
return resp
} | [
"func",
"NewResponseWithStatus",
"(",
"s",
"string",
",",
"c",
"int",
")",
"*",
"http",
".",
"Response",
"{",
"resp",
":=",
"NewResponse",
"(",
")",
"\n",
"resp",
".",
"Status",
"=",
"s",
"\n",
"resp",
".",
"StatusCode",
"=",
"c",
"\n",
"return",
"resp",
"\n",
"}"
] | // NewResponseWithStatus instantiates a new response using the passed string and integer as the
// status and status code. | [
"NewResponseWithStatus",
"instantiates",
"a",
"new",
"response",
"using",
"the",
"passed",
"string",
"and",
"integer",
"as",
"the",
"status",
"and",
"status",
"code",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L108-L113 |
152,576 | Azure/go-autorest | autorest/mocks/helpers.go | NewResponseWithBodyAndStatus | func NewResponseWithBodyAndStatus(body *Body, c int, s string) *http.Response {
resp := NewResponse()
resp.Body = body
resp.ContentLength = body.Length()
resp.Status = s
resp.StatusCode = c
return resp
} | go | func NewResponseWithBodyAndStatus(body *Body, c int, s string) *http.Response {
resp := NewResponse()
resp.Body = body
resp.ContentLength = body.Length()
resp.Status = s
resp.StatusCode = c
return resp
} | [
"func",
"NewResponseWithBodyAndStatus",
"(",
"body",
"*",
"Body",
",",
"c",
"int",
",",
"s",
"string",
")",
"*",
"http",
".",
"Response",
"{",
"resp",
":=",
"NewResponse",
"(",
")",
"\n",
"resp",
".",
"Body",
"=",
"body",
"\n",
"resp",
".",
"ContentLength",
"=",
"body",
".",
"Length",
"(",
")",
"\n",
"resp",
".",
"Status",
"=",
"s",
"\n",
"resp",
".",
"StatusCode",
"=",
"c",
"\n",
"return",
"resp",
"\n",
"}"
] | // NewResponseWithBodyAndStatus instantiates a new response using the specified mock body,
// status and status code | [
"NewResponseWithBodyAndStatus",
"instantiates",
"a",
"new",
"response",
"using",
"the",
"specified",
"mock",
"body",
"status",
"and",
"status",
"code"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L117-L124 |
152,577 | Azure/go-autorest | autorest/mocks/helpers.go | SetResponseHeader | func SetResponseHeader(resp *http.Response, h string, v string) {
if resp.Header == nil {
resp.Header = make(http.Header)
}
resp.Header.Set(h, v)
} | go | func SetResponseHeader(resp *http.Response, h string, v string) {
if resp.Header == nil {
resp.Header = make(http.Header)
}
resp.Header.Set(h, v)
} | [
"func",
"SetResponseHeader",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"h",
"string",
",",
"v",
"string",
")",
"{",
"if",
"resp",
".",
"Header",
"==",
"nil",
"{",
"resp",
".",
"Header",
"=",
"make",
"(",
"http",
".",
"Header",
")",
"\n",
"}",
"\n",
"resp",
".",
"Header",
".",
"Set",
"(",
"h",
",",
"v",
")",
"\n",
"}"
] | // SetResponseHeader adds a header to the passed response. | [
"SetResponseHeader",
"adds",
"a",
"header",
"to",
"the",
"passed",
"response",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L127-L132 |
152,578 | Azure/go-autorest | autorest/mocks/helpers.go | SetResponseHeaderValues | func SetResponseHeaderValues(resp *http.Response, h string, values []string) {
if resp.Header == nil {
resp.Header = make(http.Header)
}
for _, v := range values {
resp.Header.Add(h, v)
}
} | go | func SetResponseHeaderValues(resp *http.Response, h string, values []string) {
if resp.Header == nil {
resp.Header = make(http.Header)
}
for _, v := range values {
resp.Header.Add(h, v)
}
} | [
"func",
"SetResponseHeaderValues",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"h",
"string",
",",
"values",
"[",
"]",
"string",
")",
"{",
"if",
"resp",
".",
"Header",
"==",
"nil",
"{",
"resp",
".",
"Header",
"=",
"make",
"(",
"http",
".",
"Header",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"resp",
".",
"Header",
".",
"Add",
"(",
"h",
",",
"v",
")",
"\n",
"}",
"\n",
"}"
] | // SetResponseHeaderValues adds a header containing all the passed string values. | [
"SetResponseHeaderValues",
"adds",
"a",
"header",
"containing",
"all",
"the",
"passed",
"string",
"values",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L135-L142 |
152,579 | Azure/go-autorest | autorest/mocks/helpers.go | SetAcceptedHeaders | func SetAcceptedHeaders(resp *http.Response) {
SetLocationHeader(resp, TestURL)
SetRetryHeader(resp, TestDelay)
} | go | func SetAcceptedHeaders(resp *http.Response) {
SetLocationHeader(resp, TestURL)
SetRetryHeader(resp, TestDelay)
} | [
"func",
"SetAcceptedHeaders",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"{",
"SetLocationHeader",
"(",
"resp",
",",
"TestURL",
")",
"\n",
"SetRetryHeader",
"(",
"resp",
",",
"TestDelay",
")",
"\n",
"}"
] | // SetAcceptedHeaders adds the headers usually associated with a 202 Accepted response. | [
"SetAcceptedHeaders",
"adds",
"the",
"headers",
"usually",
"associated",
"with",
"a",
"202",
"Accepted",
"response",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L145-L148 |
152,580 | Azure/go-autorest | autorest/mocks/helpers.go | SetLocationHeader | func SetLocationHeader(resp *http.Response, location string) {
SetResponseHeader(resp, http.CanonicalHeaderKey(headerLocation), location)
} | go | func SetLocationHeader(resp *http.Response, location string) {
SetResponseHeader(resp, http.CanonicalHeaderKey(headerLocation), location)
} | [
"func",
"SetLocationHeader",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"location",
"string",
")",
"{",
"SetResponseHeader",
"(",
"resp",
",",
"http",
".",
"CanonicalHeaderKey",
"(",
"headerLocation",
")",
",",
"location",
")",
"\n",
"}"
] | // SetLocationHeader adds the Location header. | [
"SetLocationHeader",
"adds",
"the",
"Location",
"header",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L151-L153 |
152,581 | Azure/go-autorest | autorest/mocks/helpers.go | SetRetryHeader | func SetRetryHeader(resp *http.Response, delay time.Duration) {
SetResponseHeader(resp, http.CanonicalHeaderKey(headerRetryAfter), fmt.Sprintf("%v", delay.Seconds()))
} | go | func SetRetryHeader(resp *http.Response, delay time.Duration) {
SetResponseHeader(resp, http.CanonicalHeaderKey(headerRetryAfter), fmt.Sprintf("%v", delay.Seconds()))
} | [
"func",
"SetRetryHeader",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"delay",
"time",
".",
"Duration",
")",
"{",
"SetResponseHeader",
"(",
"resp",
",",
"http",
".",
"CanonicalHeaderKey",
"(",
"headerRetryAfter",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"delay",
".",
"Seconds",
"(",
")",
")",
")",
"\n",
"}"
] | // SetRetryHeader adds the Retry-After header. | [
"SetRetryHeader",
"adds",
"the",
"Retry",
"-",
"After",
"header",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/mocks/helpers.go#L156-L158 |
152,582 | Azure/go-autorest | autorest/utility.go | NewDecoder | func NewDecoder(encodedAs EncodedAs, r io.Reader) Decoder {
if encodedAs == EncodedAsJSON {
return json.NewDecoder(r)
} else if encodedAs == EncodedAsXML {
return xml.NewDecoder(r)
}
return nil
} | go | func NewDecoder(encodedAs EncodedAs, r io.Reader) Decoder {
if encodedAs == EncodedAsJSON {
return json.NewDecoder(r)
} else if encodedAs == EncodedAsXML {
return xml.NewDecoder(r)
}
return nil
} | [
"func",
"NewDecoder",
"(",
"encodedAs",
"EncodedAs",
",",
"r",
"io",
".",
"Reader",
")",
"Decoder",
"{",
"if",
"encodedAs",
"==",
"EncodedAsJSON",
"{",
"return",
"json",
".",
"NewDecoder",
"(",
"r",
")",
"\n",
"}",
"else",
"if",
"encodedAs",
"==",
"EncodedAsXML",
"{",
"return",
"xml",
".",
"NewDecoder",
"(",
"r",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // NewDecoder creates a new decoder appropriate to the passed encoding.
// encodedAs specifies the type of encoding and r supplies the io.Reader containing the
// encoded data. | [
"NewDecoder",
"creates",
"a",
"new",
"decoder",
"appropriate",
"to",
"the",
"passed",
"encoding",
".",
"encodedAs",
"specifies",
"the",
"type",
"of",
"encoding",
"and",
"r",
"supplies",
"the",
"io",
".",
"Reader",
"containing",
"the",
"encoded",
"data",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/utility.go#L51-L58 |
152,583 | Azure/go-autorest | autorest/utility.go | CopyAndDecode | func CopyAndDecode(encodedAs EncodedAs, r io.Reader, v interface{}) (bytes.Buffer, error) {
b := bytes.Buffer{}
return b, NewDecoder(encodedAs, io.TeeReader(r, &b)).Decode(v)
} | go | func CopyAndDecode(encodedAs EncodedAs, r io.Reader, v interface{}) (bytes.Buffer, error) {
b := bytes.Buffer{}
return b, NewDecoder(encodedAs, io.TeeReader(r, &b)).Decode(v)
} | [
"func",
"CopyAndDecode",
"(",
"encodedAs",
"EncodedAs",
",",
"r",
"io",
".",
"Reader",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"bytes",
".",
"Buffer",
",",
"error",
")",
"{",
"b",
":=",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"return",
"b",
",",
"NewDecoder",
"(",
"encodedAs",
",",
"io",
".",
"TeeReader",
"(",
"r",
",",
"&",
"b",
")",
")",
".",
"Decode",
"(",
"v",
")",
"\n",
"}"
] | // CopyAndDecode decodes the data from the passed io.Reader while making a copy. Having a copy
// is especially useful if there is a chance the data will fail to decode.
// encodedAs specifies the expected encoding, r provides the io.Reader to the data, and v
// is the decoding destination. | [
"CopyAndDecode",
"decodes",
"the",
"data",
"from",
"the",
"passed",
"io",
".",
"Reader",
"while",
"making",
"a",
"copy",
".",
"Having",
"a",
"copy",
"is",
"especially",
"useful",
"if",
"there",
"is",
"a",
"chance",
"the",
"data",
"will",
"fail",
"to",
"decode",
".",
"encodedAs",
"specifies",
"the",
"expected",
"encoding",
"r",
"provides",
"the",
"io",
".",
"Reader",
"to",
"the",
"data",
"and",
"v",
"is",
"the",
"decoding",
"destination",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/utility.go#L64-L67 |
152,584 | Azure/go-autorest | autorest/utility.go | TeeReadCloser | func TeeReadCloser(rc io.ReadCloser, w io.Writer) io.ReadCloser {
return &teeReadCloser{rc, io.TeeReader(rc, w)}
} | go | func TeeReadCloser(rc io.ReadCloser, w io.Writer) io.ReadCloser {
return &teeReadCloser{rc, io.TeeReader(rc, w)}
} | [
"func",
"TeeReadCloser",
"(",
"rc",
"io",
".",
"ReadCloser",
",",
"w",
"io",
".",
"Writer",
")",
"io",
".",
"ReadCloser",
"{",
"return",
"&",
"teeReadCloser",
"{",
"rc",
",",
"io",
".",
"TeeReader",
"(",
"rc",
",",
"w",
")",
"}",
"\n",
"}"
] | // TeeReadCloser returns a ReadCloser that writes to w what it reads from rc.
// It utilizes io.TeeReader to copy the data read and has the same behavior when reading.
// Further, when it is closed, it ensures that rc is closed as well. | [
"TeeReadCloser",
"returns",
"a",
"ReadCloser",
"that",
"writes",
"to",
"w",
"what",
"it",
"reads",
"from",
"rc",
".",
"It",
"utilizes",
"io",
".",
"TeeReader",
"to",
"copy",
"the",
"data",
"read",
"and",
"has",
"the",
"same",
"behavior",
"when",
"reading",
".",
"Further",
"when",
"it",
"is",
"closed",
"it",
"ensures",
"that",
"rc",
"is",
"closed",
"as",
"well",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/utility.go#L72-L74 |
152,585 | Azure/go-autorest | autorest/utility.go | Encode | func Encode(location string, v interface{}, sep ...string) string {
s := String(v, sep...)
switch strings.ToLower(location) {
case "path":
return pathEscape(s)
case "query":
return queryEscape(s)
default:
return s
}
} | go | func Encode(location string, v interface{}, sep ...string) string {
s := String(v, sep...)
switch strings.ToLower(location) {
case "path":
return pathEscape(s)
case "query":
return queryEscape(s)
default:
return s
}
} | [
"func",
"Encode",
"(",
"location",
"string",
",",
"v",
"interface",
"{",
"}",
",",
"sep",
"...",
"string",
")",
"string",
"{",
"s",
":=",
"String",
"(",
"v",
",",
"sep",
"...",
")",
"\n",
"switch",
"strings",
".",
"ToLower",
"(",
"location",
")",
"{",
"case",
"\"",
"\"",
":",
"return",
"pathEscape",
"(",
"s",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"queryEscape",
"(",
"s",
")",
"\n",
"default",
":",
"return",
"s",
"\n",
"}",
"\n",
"}"
] | // Encode method encodes url path and query parameters. | [
"Encode",
"method",
"encodes",
"url",
"path",
"and",
"query",
"parameters",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/utility.go#L178-L188 |
152,586 | Azure/go-autorest | autorest/utility.go | IsTokenRefreshError | func IsTokenRefreshError(err error) bool {
if _, ok := err.(adal.TokenRefreshError); ok {
return true
}
if de, ok := err.(DetailedError); ok {
return IsTokenRefreshError(de.Original)
}
return false
} | go | func IsTokenRefreshError(err error) bool {
if _, ok := err.(adal.TokenRefreshError); ok {
return true
}
if de, ok := err.(DetailedError); ok {
return IsTokenRefreshError(de.Original)
}
return false
} | [
"func",
"IsTokenRefreshError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"adal",
".",
"TokenRefreshError",
")",
";",
"ok",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"de",
",",
"ok",
":=",
"err",
".",
"(",
"DetailedError",
")",
";",
"ok",
"{",
"return",
"IsTokenRefreshError",
"(",
"de",
".",
"Original",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsTokenRefreshError returns true if the specified error implements the TokenRefreshError
// interface. If err is a DetailedError it will walk the chain of Original errors. | [
"IsTokenRefreshError",
"returns",
"true",
"if",
"the",
"specified",
"error",
"implements",
"the",
"TokenRefreshError",
"interface",
".",
"If",
"err",
"is",
"a",
"DetailedError",
"it",
"will",
"walk",
"the",
"chain",
"of",
"Original",
"errors",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/utility.go#L211-L219 |
152,587 | Azure/go-autorest | autorest/adal/token.go | Expires | func (t Token) Expires() time.Time {
s, err := t.ExpiresOn.Float64()
if err != nil {
s = -3600
}
expiration := date.NewUnixTimeFromSeconds(s)
return time.Time(expiration).UTC()
} | go | func (t Token) Expires() time.Time {
s, err := t.ExpiresOn.Float64()
if err != nil {
s = -3600
}
expiration := date.NewUnixTimeFromSeconds(s)
return time.Time(expiration).UTC()
} | [
"func",
"(",
"t",
"Token",
")",
"Expires",
"(",
")",
"time",
".",
"Time",
"{",
"s",
",",
"err",
":=",
"t",
".",
"ExpiresOn",
".",
"Float64",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
"=",
"-",
"3600",
"\n",
"}",
"\n\n",
"expiration",
":=",
"date",
".",
"NewUnixTimeFromSeconds",
"(",
"s",
")",
"\n\n",
"return",
"time",
".",
"Time",
"(",
"expiration",
")",
".",
"UTC",
"(",
")",
"\n",
"}"
] | // Expires returns the time.Time when the Token expires. | [
"Expires",
"returns",
"the",
"time",
".",
"Time",
"when",
"the",
"Token",
"expires",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L126-L135 |
152,588 | Azure/go-autorest | autorest/adal/token.go | WillExpireIn | func (t Token) WillExpireIn(d time.Duration) bool {
return !t.Expires().After(time.Now().Add(d))
} | go | func (t Token) WillExpireIn(d time.Duration) bool {
return !t.Expires().After(time.Now().Add(d))
} | [
"func",
"(",
"t",
"Token",
")",
"WillExpireIn",
"(",
"d",
"time",
".",
"Duration",
")",
"bool",
"{",
"return",
"!",
"t",
".",
"Expires",
"(",
")",
".",
"After",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"d",
")",
")",
"\n",
"}"
] | // WillExpireIn returns true if the Token will expire after the passed time.Duration interval
// from now, false otherwise. | [
"WillExpireIn",
"returns",
"true",
"if",
"the",
"Token",
"will",
"expire",
"after",
"the",
"passed",
"time",
".",
"Duration",
"interval",
"from",
"now",
"false",
"otherwise",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L144-L146 |
152,589 | Azure/go-autorest | autorest/adal/token.go | SetAuthenticationValues | func (noSecret *ServicePrincipalNoSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
return fmt.Errorf("Manually created ServicePrincipalToken does not contain secret material to retrieve a new access token")
} | go | func (noSecret *ServicePrincipalNoSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
return fmt.Errorf("Manually created ServicePrincipalToken does not contain secret material to retrieve a new access token")
} | [
"func",
"(",
"noSecret",
"*",
"ServicePrincipalNoSecret",
")",
"SetAuthenticationValues",
"(",
"spt",
"*",
"ServicePrincipalToken",
",",
"v",
"*",
"url",
".",
"Values",
")",
"error",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // SetAuthenticationValues is a method of the interface ServicePrincipalSecret
// It only returns an error for the ServicePrincipalNoSecret type | [
"SetAuthenticationValues",
"is",
"a",
"method",
"of",
"the",
"interface",
"ServicePrincipalSecret",
"It",
"only",
"returns",
"an",
"error",
"for",
"the",
"ServicePrincipalNoSecret",
"type"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L166-L168 |
152,590 | Azure/go-autorest | autorest/adal/token.go | SetAuthenticationValues | func (tokenSecret *ServicePrincipalTokenSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
v.Set("client_secret", tokenSecret.ClientSecret)
return nil
} | go | func (tokenSecret *ServicePrincipalTokenSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
v.Set("client_secret", tokenSecret.ClientSecret)
return nil
} | [
"func",
"(",
"tokenSecret",
"*",
"ServicePrincipalTokenSecret",
")",
"SetAuthenticationValues",
"(",
"spt",
"*",
"ServicePrincipalToken",
",",
"v",
"*",
"url",
".",
"Values",
")",
"error",
"{",
"v",
".",
"Set",
"(",
"\"",
"\"",
",",
"tokenSecret",
".",
"ClientSecret",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetAuthenticationValues is a method of the interface ServicePrincipalSecret.
// It will populate the form submitted during oAuth Token Acquisition using the client_secret. | [
"SetAuthenticationValues",
"is",
"a",
"method",
"of",
"the",
"interface",
"ServicePrincipalSecret",
".",
"It",
"will",
"populate",
"the",
"form",
"submitted",
"during",
"oAuth",
"Token",
"Acquisition",
"using",
"the",
"client_secret",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L187-L190 |
152,591 | Azure/go-autorest | autorest/adal/token.go | SignJwt | func (secret *ServicePrincipalCertificateSecret) SignJwt(spt *ServicePrincipalToken) (string, error) {
hasher := sha1.New()
_, err := hasher.Write(secret.Certificate.Raw)
if err != nil {
return "", err
}
thumbprint := base64.URLEncoding.EncodeToString(hasher.Sum(nil))
// The jti (JWT ID) claim provides a unique identifier for the JWT.
jti := make([]byte, 20)
_, err = rand.Read(jti)
if err != nil {
return "", err
}
token := jwt.New(jwt.SigningMethodRS256)
token.Header["x5t"] = thumbprint
x5c := []string{base64.StdEncoding.EncodeToString(secret.Certificate.Raw)}
token.Header["x5c"] = x5c
token.Claims = jwt.MapClaims{
"aud": spt.inner.OauthConfig.TokenEndpoint.String(),
"iss": spt.inner.ClientID,
"sub": spt.inner.ClientID,
"jti": base64.URLEncoding.EncodeToString(jti),
"nbf": time.Now().Unix(),
"exp": time.Now().Add(time.Hour * 24).Unix(),
}
signedString, err := token.SignedString(secret.PrivateKey)
return signedString, err
} | go | func (secret *ServicePrincipalCertificateSecret) SignJwt(spt *ServicePrincipalToken) (string, error) {
hasher := sha1.New()
_, err := hasher.Write(secret.Certificate.Raw)
if err != nil {
return "", err
}
thumbprint := base64.URLEncoding.EncodeToString(hasher.Sum(nil))
// The jti (JWT ID) claim provides a unique identifier for the JWT.
jti := make([]byte, 20)
_, err = rand.Read(jti)
if err != nil {
return "", err
}
token := jwt.New(jwt.SigningMethodRS256)
token.Header["x5t"] = thumbprint
x5c := []string{base64.StdEncoding.EncodeToString(secret.Certificate.Raw)}
token.Header["x5c"] = x5c
token.Claims = jwt.MapClaims{
"aud": spt.inner.OauthConfig.TokenEndpoint.String(),
"iss": spt.inner.ClientID,
"sub": spt.inner.ClientID,
"jti": base64.URLEncoding.EncodeToString(jti),
"nbf": time.Now().Unix(),
"exp": time.Now().Add(time.Hour * 24).Unix(),
}
signedString, err := token.SignedString(secret.PrivateKey)
return signedString, err
} | [
"func",
"(",
"secret",
"*",
"ServicePrincipalCertificateSecret",
")",
"SignJwt",
"(",
"spt",
"*",
"ServicePrincipalToken",
")",
"(",
"string",
",",
"error",
")",
"{",
"hasher",
":=",
"sha1",
".",
"New",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"hasher",
".",
"Write",
"(",
"secret",
".",
"Certificate",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"thumbprint",
":=",
"base64",
".",
"URLEncoding",
".",
"EncodeToString",
"(",
"hasher",
".",
"Sum",
"(",
"nil",
")",
")",
"\n\n",
"// The jti (JWT ID) claim provides a unique identifier for the JWT.",
"jti",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"20",
")",
"\n",
"_",
",",
"err",
"=",
"rand",
".",
"Read",
"(",
"jti",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"token",
":=",
"jwt",
".",
"New",
"(",
"jwt",
".",
"SigningMethodRS256",
")",
"\n",
"token",
".",
"Header",
"[",
"\"",
"\"",
"]",
"=",
"thumbprint",
"\n",
"x5c",
":=",
"[",
"]",
"string",
"{",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"secret",
".",
"Certificate",
".",
"Raw",
")",
"}",
"\n",
"token",
".",
"Header",
"[",
"\"",
"\"",
"]",
"=",
"x5c",
"\n",
"token",
".",
"Claims",
"=",
"jwt",
".",
"MapClaims",
"{",
"\"",
"\"",
":",
"spt",
".",
"inner",
".",
"OauthConfig",
".",
"TokenEndpoint",
".",
"String",
"(",
")",
",",
"\"",
"\"",
":",
"spt",
".",
"inner",
".",
"ClientID",
",",
"\"",
"\"",
":",
"spt",
".",
"inner",
".",
"ClientID",
",",
"\"",
"\"",
":",
"base64",
".",
"URLEncoding",
".",
"EncodeToString",
"(",
"jti",
")",
",",
"\"",
"\"",
":",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
",",
"\"",
"\"",
":",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"time",
".",
"Hour",
"*",
"24",
")",
".",
"Unix",
"(",
")",
",",
"}",
"\n\n",
"signedString",
",",
"err",
":=",
"token",
".",
"SignedString",
"(",
"secret",
".",
"PrivateKey",
")",
"\n",
"return",
"signedString",
",",
"err",
"\n",
"}"
] | // SignJwt returns the JWT signed with the certificate's private key. | [
"SignJwt",
"returns",
"the",
"JWT",
"signed",
"with",
"the",
"certificate",
"s",
"private",
"key",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L211-L242 |
152,592 | Azure/go-autorest | autorest/adal/token.go | SetAuthenticationValues | func (secret *ServicePrincipalCertificateSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
jwt, err := secret.SignJwt(spt)
if err != nil {
return err
}
v.Set("client_assertion", jwt)
v.Set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer")
return nil
} | go | func (secret *ServicePrincipalCertificateSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
jwt, err := secret.SignJwt(spt)
if err != nil {
return err
}
v.Set("client_assertion", jwt)
v.Set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer")
return nil
} | [
"func",
"(",
"secret",
"*",
"ServicePrincipalCertificateSecret",
")",
"SetAuthenticationValues",
"(",
"spt",
"*",
"ServicePrincipalToken",
",",
"v",
"*",
"url",
".",
"Values",
")",
"error",
"{",
"jwt",
",",
"err",
":=",
"secret",
".",
"SignJwt",
"(",
"spt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"v",
".",
"Set",
"(",
"\"",
"\"",
",",
"jwt",
")",
"\n",
"v",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetAuthenticationValues is a method of the interface ServicePrincipalSecret.
// It will populate the form submitted during oAuth Token Acquisition using a JWT signed with a certificate. | [
"SetAuthenticationValues",
"is",
"a",
"method",
"of",
"the",
"interface",
"ServicePrincipalSecret",
".",
"It",
"will",
"populate",
"the",
"form",
"submitted",
"during",
"oAuth",
"Token",
"Acquisition",
"using",
"a",
"JWT",
"signed",
"with",
"a",
"certificate",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L246-L255 |
152,593 | Azure/go-autorest | autorest/adal/token.go | MarshalTokenJSON | func (spt ServicePrincipalToken) MarshalTokenJSON() ([]byte, error) {
return json.Marshal(spt.inner.Token)
} | go | func (spt ServicePrincipalToken) MarshalTokenJSON() ([]byte, error) {
return json.Marshal(spt.inner.Token)
} | [
"func",
"(",
"spt",
"ServicePrincipalToken",
")",
"MarshalTokenJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"json",
".",
"Marshal",
"(",
"spt",
".",
"inner",
".",
"Token",
")",
"\n",
"}"
] | // MarshalTokenJSON returns the marshalled inner token. | [
"MarshalTokenJSON",
"returns",
"the",
"marshalled",
"inner",
"token",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L345-L347 |
152,594 | Azure/go-autorest | autorest/adal/token.go | NewServicePrincipalTokenWithSecret | func NewServicePrincipalTokenWithSecret(oauthConfig OAuthConfig, id string, resource string, secret ServicePrincipalSecret, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(id, "id"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
if secret == nil {
return nil, fmt.Errorf("parameter 'secret' cannot be nil")
}
spt := &ServicePrincipalToken{
inner: servicePrincipalToken{
Token: newToken(),
OauthConfig: oauthConfig,
Secret: secret,
ClientID: id,
Resource: resource,
AutoRefresh: true,
RefreshWithin: defaultRefresh,
},
refreshLock: &sync.RWMutex{},
sender: &http.Client{Transport: tracing.Transport},
refreshCallbacks: callbacks,
}
return spt, nil
} | go | func NewServicePrincipalTokenWithSecret(oauthConfig OAuthConfig, id string, resource string, secret ServicePrincipalSecret, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(id, "id"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
if secret == nil {
return nil, fmt.Errorf("parameter 'secret' cannot be nil")
}
spt := &ServicePrincipalToken{
inner: servicePrincipalToken{
Token: newToken(),
OauthConfig: oauthConfig,
Secret: secret,
ClientID: id,
Resource: resource,
AutoRefresh: true,
RefreshWithin: defaultRefresh,
},
refreshLock: &sync.RWMutex{},
sender: &http.Client{Transport: tracing.Transport},
refreshCallbacks: callbacks,
}
return spt, nil
} | [
"func",
"NewServicePrincipalTokenWithSecret",
"(",
"oauthConfig",
"OAuthConfig",
",",
"id",
"string",
",",
"resource",
"string",
",",
"secret",
"ServicePrincipalSecret",
",",
"callbacks",
"...",
"TokenRefreshCallback",
")",
"(",
"*",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateOAuthConfig",
"(",
"oauthConfig",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"id",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"resource",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"secret",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"spt",
":=",
"&",
"ServicePrincipalToken",
"{",
"inner",
":",
"servicePrincipalToken",
"{",
"Token",
":",
"newToken",
"(",
")",
",",
"OauthConfig",
":",
"oauthConfig",
",",
"Secret",
":",
"secret",
",",
"ClientID",
":",
"id",
",",
"Resource",
":",
"resource",
",",
"AutoRefresh",
":",
"true",
",",
"RefreshWithin",
":",
"defaultRefresh",
",",
"}",
",",
"refreshLock",
":",
"&",
"sync",
".",
"RWMutex",
"{",
"}",
",",
"sender",
":",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"tracing",
".",
"Transport",
"}",
",",
"refreshCallbacks",
":",
"callbacks",
",",
"}",
"\n",
"return",
"spt",
",",
"nil",
"\n",
"}"
] | // NewServicePrincipalTokenWithSecret create a ServicePrincipalToken using the supplied ServicePrincipalSecret implementation. | [
"NewServicePrincipalTokenWithSecret",
"create",
"a",
"ServicePrincipalToken",
"using",
"the",
"supplied",
"ServicePrincipalSecret",
"implementation",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L417-L445 |
152,595 | Azure/go-autorest | autorest/adal/token.go | NewServicePrincipalTokenFromManualToken | func NewServicePrincipalTokenFromManualToken(oauthConfig OAuthConfig, clientID string, resource string, token Token, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
if token.IsZero() {
return nil, fmt.Errorf("parameter 'token' cannot be zero-initialized")
}
spt, err := NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalNoSecret{},
callbacks...)
if err != nil {
return nil, err
}
spt.inner.Token = token
return spt, nil
} | go | func NewServicePrincipalTokenFromManualToken(oauthConfig OAuthConfig, clientID string, resource string, token Token, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
if token.IsZero() {
return nil, fmt.Errorf("parameter 'token' cannot be zero-initialized")
}
spt, err := NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalNoSecret{},
callbacks...)
if err != nil {
return nil, err
}
spt.inner.Token = token
return spt, nil
} | [
"func",
"NewServicePrincipalTokenFromManualToken",
"(",
"oauthConfig",
"OAuthConfig",
",",
"clientID",
"string",
",",
"resource",
"string",
",",
"token",
"Token",
",",
"callbacks",
"...",
"TokenRefreshCallback",
")",
"(",
"*",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateOAuthConfig",
"(",
"oauthConfig",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"clientID",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"resource",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"token",
".",
"IsZero",
"(",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"spt",
",",
"err",
":=",
"NewServicePrincipalTokenWithSecret",
"(",
"oauthConfig",
",",
"clientID",
",",
"resource",
",",
"&",
"ServicePrincipalNoSecret",
"{",
"}",
",",
"callbacks",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"spt",
".",
"inner",
".",
"Token",
"=",
"token",
"\n\n",
"return",
"spt",
",",
"nil",
"\n",
"}"
] | // NewServicePrincipalTokenFromManualToken creates a ServicePrincipalToken using the supplied token | [
"NewServicePrincipalTokenFromManualToken",
"creates",
"a",
"ServicePrincipalToken",
"using",
"the",
"supplied",
"token"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L448-L474 |
152,596 | Azure/go-autorest | autorest/adal/token.go | NewServicePrincipalToken | func NewServicePrincipalToken(oauthConfig OAuthConfig, clientID string, secret string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(secret, "secret"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
return NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalTokenSecret{
ClientSecret: secret,
},
callbacks...,
)
} | go | func NewServicePrincipalToken(oauthConfig OAuthConfig, clientID string, secret string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(secret, "secret"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
return NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalTokenSecret{
ClientSecret: secret,
},
callbacks...,
)
} | [
"func",
"NewServicePrincipalToken",
"(",
"oauthConfig",
"OAuthConfig",
",",
"clientID",
"string",
",",
"secret",
"string",
",",
"resource",
"string",
",",
"callbacks",
"...",
"TokenRefreshCallback",
")",
"(",
"*",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateOAuthConfig",
"(",
"oauthConfig",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"clientID",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"secret",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"resource",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewServicePrincipalTokenWithSecret",
"(",
"oauthConfig",
",",
"clientID",
",",
"resource",
",",
"&",
"ServicePrincipalTokenSecret",
"{",
"ClientSecret",
":",
"secret",
",",
"}",
",",
"callbacks",
"...",
",",
")",
"\n",
"}"
] | // NewServicePrincipalToken creates a ServicePrincipalToken from the supplied Service Principal
// credentials scoped to the named resource. | [
"NewServicePrincipalToken",
"creates",
"a",
"ServicePrincipalToken",
"from",
"the",
"supplied",
"Service",
"Principal",
"credentials",
"scoped",
"to",
"the",
"named",
"resource",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L510-L532 |
152,597 | Azure/go-autorest | autorest/adal/token.go | NewServicePrincipalTokenFromCertificate | func NewServicePrincipalTokenFromCertificate(oauthConfig OAuthConfig, clientID string, certificate *x509.Certificate, privateKey *rsa.PrivateKey, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
if certificate == nil {
return nil, fmt.Errorf("parameter 'certificate' cannot be nil")
}
if privateKey == nil {
return nil, fmt.Errorf("parameter 'privateKey' cannot be nil")
}
return NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalCertificateSecret{
PrivateKey: privateKey,
Certificate: certificate,
},
callbacks...,
)
} | go | func NewServicePrincipalTokenFromCertificate(oauthConfig OAuthConfig, clientID string, certificate *x509.Certificate, privateKey *rsa.PrivateKey, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
if certificate == nil {
return nil, fmt.Errorf("parameter 'certificate' cannot be nil")
}
if privateKey == nil {
return nil, fmt.Errorf("parameter 'privateKey' cannot be nil")
}
return NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalCertificateSecret{
PrivateKey: privateKey,
Certificate: certificate,
},
callbacks...,
)
} | [
"func",
"NewServicePrincipalTokenFromCertificate",
"(",
"oauthConfig",
"OAuthConfig",
",",
"clientID",
"string",
",",
"certificate",
"*",
"x509",
".",
"Certificate",
",",
"privateKey",
"*",
"rsa",
".",
"PrivateKey",
",",
"resource",
"string",
",",
"callbacks",
"...",
"TokenRefreshCallback",
")",
"(",
"*",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateOAuthConfig",
"(",
"oauthConfig",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"clientID",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"resource",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"certificate",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"privateKey",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"NewServicePrincipalTokenWithSecret",
"(",
"oauthConfig",
",",
"clientID",
",",
"resource",
",",
"&",
"ServicePrincipalCertificateSecret",
"{",
"PrivateKey",
":",
"privateKey",
",",
"Certificate",
":",
"certificate",
",",
"}",
",",
"callbacks",
"...",
",",
")",
"\n",
"}"
] | // NewServicePrincipalTokenFromCertificate creates a ServicePrincipalToken from the supplied pkcs12 bytes. | [
"NewServicePrincipalTokenFromCertificate",
"creates",
"a",
"ServicePrincipalToken",
"from",
"the",
"supplied",
"pkcs12",
"bytes",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L535-L561 |
152,598 | Azure/go-autorest | autorest/adal/token.go | NewServicePrincipalTokenFromUsernamePassword | func NewServicePrincipalTokenFromUsernamePassword(oauthConfig OAuthConfig, clientID string, username string, password string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(username, "username"); err != nil {
return nil, err
}
if err := validateStringParam(password, "password"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
return NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalUsernamePasswordSecret{
Username: username,
Password: password,
},
callbacks...,
)
} | go | func NewServicePrincipalTokenFromUsernamePassword(oauthConfig OAuthConfig, clientID string, username string, password string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(username, "username"); err != nil {
return nil, err
}
if err := validateStringParam(password, "password"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
return NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalUsernamePasswordSecret{
Username: username,
Password: password,
},
callbacks...,
)
} | [
"func",
"NewServicePrincipalTokenFromUsernamePassword",
"(",
"oauthConfig",
"OAuthConfig",
",",
"clientID",
"string",
",",
"username",
"string",
",",
"password",
"string",
",",
"resource",
"string",
",",
"callbacks",
"...",
"TokenRefreshCallback",
")",
"(",
"*",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateOAuthConfig",
"(",
"oauthConfig",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"clientID",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"username",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"password",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"resource",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewServicePrincipalTokenWithSecret",
"(",
"oauthConfig",
",",
"clientID",
",",
"resource",
",",
"&",
"ServicePrincipalUsernamePasswordSecret",
"{",
"Username",
":",
"username",
",",
"Password",
":",
"password",
",",
"}",
",",
"callbacks",
"...",
",",
")",
"\n",
"}"
] | // NewServicePrincipalTokenFromUsernamePassword creates a ServicePrincipalToken from the username and password. | [
"NewServicePrincipalTokenFromUsernamePassword",
"creates",
"a",
"ServicePrincipalToken",
"from",
"the",
"username",
"and",
"password",
"."
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L564-L590 |
152,599 | Azure/go-autorest | autorest/adal/token.go | NewServicePrincipalTokenFromAuthorizationCode | func NewServicePrincipalTokenFromAuthorizationCode(oauthConfig OAuthConfig, clientID string, clientSecret string, authorizationCode string, redirectURI string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(clientSecret, "clientSecret"); err != nil {
return nil, err
}
if err := validateStringParam(authorizationCode, "authorizationCode"); err != nil {
return nil, err
}
if err := validateStringParam(redirectURI, "redirectURI"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
return NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalAuthorizationCodeSecret{
ClientSecret: clientSecret,
AuthorizationCode: authorizationCode,
RedirectURI: redirectURI,
},
callbacks...,
)
} | go | func NewServicePrincipalTokenFromAuthorizationCode(oauthConfig OAuthConfig, clientID string, clientSecret string, authorizationCode string, redirectURI string, resource string, callbacks ...TokenRefreshCallback) (*ServicePrincipalToken, error) {
if err := validateOAuthConfig(oauthConfig); err != nil {
return nil, err
}
if err := validateStringParam(clientID, "clientID"); err != nil {
return nil, err
}
if err := validateStringParam(clientSecret, "clientSecret"); err != nil {
return nil, err
}
if err := validateStringParam(authorizationCode, "authorizationCode"); err != nil {
return nil, err
}
if err := validateStringParam(redirectURI, "redirectURI"); err != nil {
return nil, err
}
if err := validateStringParam(resource, "resource"); err != nil {
return nil, err
}
return NewServicePrincipalTokenWithSecret(
oauthConfig,
clientID,
resource,
&ServicePrincipalAuthorizationCodeSecret{
ClientSecret: clientSecret,
AuthorizationCode: authorizationCode,
RedirectURI: redirectURI,
},
callbacks...,
)
} | [
"func",
"NewServicePrincipalTokenFromAuthorizationCode",
"(",
"oauthConfig",
"OAuthConfig",
",",
"clientID",
"string",
",",
"clientSecret",
"string",
",",
"authorizationCode",
"string",
",",
"redirectURI",
"string",
",",
"resource",
"string",
",",
"callbacks",
"...",
"TokenRefreshCallback",
")",
"(",
"*",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateOAuthConfig",
"(",
"oauthConfig",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"clientID",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"clientSecret",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"authorizationCode",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"redirectURI",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateStringParam",
"(",
"resource",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewServicePrincipalTokenWithSecret",
"(",
"oauthConfig",
",",
"clientID",
",",
"resource",
",",
"&",
"ServicePrincipalAuthorizationCodeSecret",
"{",
"ClientSecret",
":",
"clientSecret",
",",
"AuthorizationCode",
":",
"authorizationCode",
",",
"RedirectURI",
":",
"redirectURI",
",",
"}",
",",
"callbacks",
"...",
",",
")",
"\n",
"}"
] | // NewServicePrincipalTokenFromAuthorizationCode creates a ServicePrincipalToken from the | [
"NewServicePrincipalTokenFromAuthorizationCode",
"creates",
"a",
"ServicePrincipalToken",
"from",
"the"
] | da8db3a19ec5aba5d01f6032407abf1bb1cc15d3 | https://github.com/Azure/go-autorest/blob/da8db3a19ec5aba5d01f6032407abf1bb1cc15d3/autorest/adal/token.go#L593-L625 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.