repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
markbates/goth | providers/faux/faux.go | BeginAuth | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
c := &oauth2.Config{
Endpoint: oauth2.Endpoint{
AuthURL: "http://example.com/auth",
},
}
url := c.AuthCodeURL(state)
return &Session{
ID: "id",
AuthURL: url,
}, nil
} | go | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
c := &oauth2.Config{
Endpoint: oauth2.Endpoint{
AuthURL: "http://example.com/auth",
},
}
url := c.AuthCodeURL(state)
return &Session{
ID: "id",
AuthURL: url,
}, nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"BeginAuth",
"(",
"state",
"string",
")",
"(",
"goth",
".",
"Session",
",",
"error",
")",
"{",
"c",
":=",
"&",
"oauth2",
".",
"Config",
"{",
"Endpoint",
":",
"oauth2",
".",
"Endpoint",
"{",
"AuthURL",
":",
"\... | // BeginAuth is used only for testing. | [
"BeginAuth",
"is",
"used",
"only",
"for",
"testing",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/faux/faux.go#L41-L52 | train |
markbates/goth | providers/faux/faux.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
UserID: sess.ID,
Name: sess.Name,
Email: sess.Email,
Provider: p.Name(),
AccessToken: sess.AccessToken,
}
if user.AccessToken == "" {
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
return user, nil
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
UserID: sess.ID,
Name: sess.Name,
Email: sess.Email,
Provider: p.Name(),
AccessToken: sess.AccessToken,
}
if user.AccessToken == "" {
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
return user, nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser is used only for testing. | [
"FetchUser",
"is",
"used",
"only",
"for",
"testing",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/faux/faux.go#L55-L69 | train |
markbates/goth | providers/faux/faux.go | Authorize | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
s.AccessToken = "access"
return s.AccessToken, nil
} | go | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
s.AccessToken = "access"
return s.AccessToken, nil
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Authorize",
"(",
"provider",
"goth",
".",
"Provider",
",",
"params",
"goth",
".",
"Params",
")",
"(",
"string",
",",
"error",
")",
"{",
"s",
".",
"AccessToken",
"=",
"\"access\"",
"\n",
"return",
"s",
".",
"Acc... | // Authorize is used only for testing. | [
"Authorize",
"is",
"used",
"only",
"for",
"testing",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/faux/faux.go#L96-L99 | train |
markbates/goth | providers/xero/xero.go | New | func New(clientKey, secret, callbackURL string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
//Method determines how you will connect to Xero.
//Options are public, private, and partner
//Use public if this is your first time.
//More details here: https://developer.xero.com/documentation/getting-started/api-application-types
Method: os.Getenv("XERO_METHOD"),
providerName: "xero",
}
switch p.Method {
case "private":
p.consumer = newPrivateOrPartnerConsumer(p, authorizeURL)
case "public":
p.consumer = newPublicConsumer(p, authorizeURL)
case "partner":
p.consumer = newPrivateOrPartnerConsumer(p, authorizeURL)
default:
p.consumer = newPublicConsumer(p, authorizeURL)
}
return p
} | go | func New(clientKey, secret, callbackURL string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
//Method determines how you will connect to Xero.
//Options are public, private, and partner
//Use public if this is your first time.
//More details here: https://developer.xero.com/documentation/getting-started/api-application-types
Method: os.Getenv("XERO_METHOD"),
providerName: "xero",
}
switch p.Method {
case "private":
p.consumer = newPrivateOrPartnerConsumer(p, authorizeURL)
case "public":
p.consumer = newPublicConsumer(p, authorizeURL)
case "partner":
p.consumer = newPrivateOrPartnerConsumer(p, authorizeURL)
default:
p.consumer = newPublicConsumer(p, authorizeURL)
}
return p
} | [
"func",
"New",
"(",
"clientKey",
",",
"secret",
",",
"callbackURL",
"string",
")",
"*",
"Provider",
"{",
"p",
":=",
"&",
"Provider",
"{",
"ClientKey",
":",
"clientKey",
",",
"Secret",
":",
"secret",
",",
"CallbackURL",
":",
"callbackURL",
",",
"Method",
... | // New creates a new Xero provider, and sets up important connection details.
// You should always call `xero.New` to get a new Provider. Never try to create
// one manually. | [
"New",
"creates",
"a",
"new",
"Xero",
"provider",
"and",
"sets",
"up",
"important",
"connection",
"details",
".",
"You",
"should",
"always",
"call",
"xero",
".",
"New",
"to",
"get",
"a",
"new",
"Provider",
".",
"Never",
"try",
"to",
"create",
"one",
"man... | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/xero/xero.go#L58-L82 | train |
markbates/goth | providers/xero/xero.go | BeginAuth | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
requestToken, url, err := p.consumer.GetRequestTokenAndUrl(p.CallbackURL)
if err != nil {
return nil, err
}
session := &Session{
AuthURL: url,
RequestToken: requestToken,
}
return session, err
} | go | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
requestToken, url, err := p.consumer.GetRequestTokenAndUrl(p.CallbackURL)
if err != nil {
return nil, err
}
session := &Session{
AuthURL: url,
RequestToken: requestToken,
}
return session, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"BeginAuth",
"(",
"state",
"string",
")",
"(",
"goth",
".",
"Session",
",",
"error",
")",
"{",
"requestToken",
",",
"url",
",",
"err",
":=",
"p",
".",
"consumer",
".",
"GetRequestTokenAndUrl",
"(",
"p",
".",
"C... | // BeginAuth asks Xero for an authentication end-point and a request token for a session.
// Xero does not support the "state" variable. | [
"BeginAuth",
"asks",
"Xero",
"for",
"an",
"authentication",
"end",
"-",
"point",
"and",
"a",
"request",
"token",
"for",
"a",
"session",
".",
"Xero",
"does",
"not",
"support",
"the",
"state",
"variable",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/xero/xero.go#L118-L128 | train |
markbates/goth | providers/xero/xero.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
Provider: p.Name(),
}
if sess.AccessToken == nil {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
response, err := p.consumer.Get(
endpointProfile+"Organisation",
nil,
sess.AccessToken)
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
var apiResponse APIResponse
responseBytes, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, fmt.Errorf("Could not read response: %s", err.Error())
}
if responseBytes == nil {
return user, fmt.Errorf("Received no response: %s", err.Error())
}
err = json.Unmarshal(responseBytes, &apiResponse)
if err != nil {
return user, fmt.Errorf("Could not unmarshal response: %s", err.Error())
}
user.Name = apiResponse.Organisations[0].Name
user.NickName = apiResponse.Organisations[0].LegalName
user.Location = apiResponse.Organisations[0].CountryCode
user.Description = apiResponse.Organisations[0].OrganisationType
user.UserID = apiResponse.Organisations[0].ShortCode
user.AccessToken = sess.AccessToken.Token
user.AccessTokenSecret = sess.AccessToken.Secret
user.ExpiresAt = sess.AccessTokenExpires
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
Provider: p.Name(),
}
if sess.AccessToken == nil {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
response, err := p.consumer.Get(
endpointProfile+"Organisation",
nil,
sess.AccessToken)
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
var apiResponse APIResponse
responseBytes, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, fmt.Errorf("Could not read response: %s", err.Error())
}
if responseBytes == nil {
return user, fmt.Errorf("Received no response: %s", err.Error())
}
err = json.Unmarshal(responseBytes, &apiResponse)
if err != nil {
return user, fmt.Errorf("Could not unmarshal response: %s", err.Error())
}
user.Name = apiResponse.Organisations[0].Name
user.NickName = apiResponse.Organisations[0].LegalName
user.Location = apiResponse.Organisations[0].CountryCode
user.Description = apiResponse.Organisations[0].OrganisationType
user.UserID = apiResponse.Organisations[0].ShortCode
user.AccessToken = sess.AccessToken.Token
user.AccessTokenSecret = sess.AccessToken.Secret
user.ExpiresAt = sess.AccessTokenExpires
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to Xero and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"Xero",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/xero/xero.go#L131-L180 | train |
markbates/goth | providers/xero/xero.go | RefreshOAuth1Token | func (p *Provider) RefreshOAuth1Token(session *Session) error {
newAccessToken, err := p.consumer.RefreshToken(session.AccessToken)
if err != nil {
return err
}
session.AccessToken = newAccessToken
session.AccessTokenExpires = time.Now().UTC().Add(30 * time.Minute)
return nil
} | go | func (p *Provider) RefreshOAuth1Token(session *Session) error {
newAccessToken, err := p.consumer.RefreshToken(session.AccessToken)
if err != nil {
return err
}
session.AccessToken = newAccessToken
session.AccessTokenExpires = time.Now().UTC().Add(30 * time.Minute)
return nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"RefreshOAuth1Token",
"(",
"session",
"*",
"Session",
")",
"error",
"{",
"newAccessToken",
",",
"err",
":=",
"p",
".",
"consumer",
".",
"RefreshToken",
"(",
"session",
".",
"AccessToken",
")",
"\n",
"if",
"err",
"!... | //RefreshOAuth1Token should be used instead of RefeshToken which is not compliant with the Oauth1.0a standard | [
"RefreshOAuth1Token",
"should",
"be",
"used",
"instead",
"of",
"RefeshToken",
"which",
"is",
"not",
"compliant",
"with",
"the",
"Oauth1",
".",
"0a",
"standard"
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/xero/xero.go#L240-L248 | train |
markbates/goth | providers/azureadv2/azureadv2.go | BeginAuth | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
authURL := p.config.AuthCodeURL(state)
return &Session{
AuthURL: authURL,
}, nil
} | go | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
authURL := p.config.AuthCodeURL(state)
return &Session{
AuthURL: authURL,
}, nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"BeginAuth",
"(",
"state",
"string",
")",
"(",
"goth",
".",
"Session",
",",
"error",
")",
"{",
"authURL",
":=",
"p",
".",
"config",
".",
"AuthCodeURL",
"(",
"state",
")",
"\n",
"return",
"&",
"Session",
"{",
... | // BeginAuth asks for an authentication end-point for AzureAD. | [
"BeginAuth",
"asks",
"for",
"an",
"authentication",
"end",
"-",
"point",
"for",
"AzureAD",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/azureadv2/azureadv2.go#L122-L128 | train |
markbates/goth | gothic/gothic.go | GetFromSession | func GetFromSession(key string, req *http.Request) (string, error) {
session, _ := Store.Get(req, SessionName)
value, err := getSessionValue(session, key)
if err != nil {
return "", errors.New("could not find a matching session for this request")
}
return value, nil
} | go | func GetFromSession(key string, req *http.Request) (string, error) {
session, _ := Store.Get(req, SessionName)
value, err := getSessionValue(session, key)
if err != nil {
return "", errors.New("could not find a matching session for this request")
}
return value, nil
} | [
"func",
"GetFromSession",
"(",
"key",
"string",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"string",
",",
"error",
")",
"{",
"session",
",",
"_",
":=",
"Store",
".",
"Get",
"(",
"req",
",",
"SessionName",
")",
"\n",
"value",
",",
"err",
":=... | // GetFromSession retrieves a previously-stored value from the session.
// If no value has previously been stored at the specified key, it will return an error. | [
"GetFromSession",
"retrieves",
"a",
"previously",
"-",
"stored",
"value",
"from",
"the",
"session",
".",
"If",
"no",
"value",
"has",
"previously",
"been",
"stored",
"at",
"the",
"specified",
"key",
"it",
"will",
"return",
"an",
"error",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/gothic/gothic.go#L298-L306 | train |
markbates/goth | providers/steam/steam.go | New | func New(apiKey string, callbackURL string) *Provider {
p := &Provider{
APIKey: apiKey,
CallbackURL: callbackURL,
providerName: "steam",
}
return p
} | go | func New(apiKey string, callbackURL string) *Provider {
p := &Provider{
APIKey: apiKey,
CallbackURL: callbackURL,
providerName: "steam",
}
return p
} | [
"func",
"New",
"(",
"apiKey",
"string",
",",
"callbackURL",
"string",
")",
"*",
"Provider",
"{",
"p",
":=",
"&",
"Provider",
"{",
"APIKey",
":",
"apiKey",
",",
"CallbackURL",
":",
"callbackURL",
",",
"providerName",
":",
"\"steam\"",
",",
"}",
"\n",
"ret... | // New creates a new Steam provider, and sets up important connection details.
// You should always call `steam.New` to get a new Provider. Never try to create
// one manually. | [
"New",
"creates",
"a",
"new",
"Steam",
"provider",
"and",
"sets",
"up",
"important",
"connection",
"details",
".",
"You",
"should",
"always",
"call",
"steam",
".",
"New",
"to",
"get",
"a",
"new",
"Provider",
".",
"Never",
"try",
"to",
"create",
"one",
"m... | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/steam/steam.go#L29-L36 | train |
markbates/goth | providers/steam/steam.go | BeginAuth | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
u, err := p.getAuthURL()
s := &Session{
AuthURL: u.String(),
CallbackURL: p.CallbackURL,
}
return s, err
} | go | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
u, err := p.getAuthURL()
s := &Session{
AuthURL: u.String(),
CallbackURL: p.CallbackURL,
}
return s, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"BeginAuth",
"(",
"state",
"string",
")",
"(",
"goth",
".",
"Session",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"p",
".",
"getAuthURL",
"(",
")",
"\n",
"s",
":=",
"&",
"Session",
"{",
"AuthURL",
":",
... | // BeginAuth will return the authentication end-point for Steam. | [
"BeginAuth",
"will",
"return",
"the",
"authentication",
"end",
"-",
"point",
"for",
"Steam",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/steam/steam.go#L64-L71 | train |
markbates/goth | providers/steam/steam.go | getAuthURL | func (p *Provider) getAuthURL() (*url.URL, error) {
callbackURL, err := url.Parse(p.CallbackURL)
if err != nil {
return nil, err
}
urlValues := map[string]string{
"openid.claimed_id": openIDIdentifier,
"openid.identity": openIDIdentifier,
"openid.mode": openIDMode,
"openid.ns": openIDNs,
"openid.realm": fmt.Sprintf("%s://%s", callbackURL.Scheme, callbackURL.Host),
"openid.return_to": callbackURL.String(),
}
u, err := url.Parse(apiLoginEndpoint)
if err != nil {
return nil, err
}
v := u.Query()
for key, value := range urlValues {
v.Set(key, value)
}
u.RawQuery = v.Encode()
return u, nil
} | go | func (p *Provider) getAuthURL() (*url.URL, error) {
callbackURL, err := url.Parse(p.CallbackURL)
if err != nil {
return nil, err
}
urlValues := map[string]string{
"openid.claimed_id": openIDIdentifier,
"openid.identity": openIDIdentifier,
"openid.mode": openIDMode,
"openid.ns": openIDNs,
"openid.realm": fmt.Sprintf("%s://%s", callbackURL.Scheme, callbackURL.Host),
"openid.return_to": callbackURL.String(),
}
u, err := url.Parse(apiLoginEndpoint)
if err != nil {
return nil, err
}
v := u.Query()
for key, value := range urlValues {
v.Set(key, value)
}
u.RawQuery = v.Encode()
return u, nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"getAuthURL",
"(",
")",
"(",
"*",
"url",
".",
"URL",
",",
"error",
")",
"{",
"callbackURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"p",
".",
"CallbackURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"... | // getAuthURL is an internal function to build the correct
// authentication url to redirect the user to Steam. | [
"getAuthURL",
"is",
"an",
"internal",
"function",
"to",
"build",
"the",
"correct",
"authentication",
"url",
"to",
"redirect",
"the",
"user",
"to",
"Steam",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/steam/steam.go#L75-L102 | train |
markbates/goth | providers/steam/steam.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
s := session.(*Session)
u := goth.User{
Provider: p.Name(),
AccessToken: s.ResponseNonce,
}
if s.SteamID == "" {
// data is not yet retrieved since SteamID is still empty
return u, fmt.Errorf("%s cannot get user information without SteamID", p.providerName)
}
apiURL := fmt.Sprintf(apiUserSummaryEndpoint, p.APIKey, s.SteamID)
req, err := http.NewRequest("GET", apiURL, nil)
if err != nil {
return u, err
}
req.Header.Add("Accept", "application/json")
resp, err := p.Client().Do(req)
if err != nil {
if resp != nil {
resp.Body.Close()
}
return u, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return u, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, resp.StatusCode)
}
u, err = buildUserObject(resp.Body, u)
return u, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
s := session.(*Session)
u := goth.User{
Provider: p.Name(),
AccessToken: s.ResponseNonce,
}
if s.SteamID == "" {
// data is not yet retrieved since SteamID is still empty
return u, fmt.Errorf("%s cannot get user information without SteamID", p.providerName)
}
apiURL := fmt.Sprintf(apiUserSummaryEndpoint, p.APIKey, s.SteamID)
req, err := http.NewRequest("GET", apiURL, nil)
if err != nil {
return u, err
}
req.Header.Add("Accept", "application/json")
resp, err := p.Client().Do(req)
if err != nil {
if resp != nil {
resp.Body.Close()
}
return u, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return u, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, resp.StatusCode)
}
u, err = buildUserObject(resp.Body, u)
return u, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"s",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"u",
":=",
"goth",
".",
"User",
"{",
... | // FetchUser will go to Steam and access basic info about the user. | [
"FetchUser",
"will",
"go",
"to",
"Steam",
"and",
"access",
"basic",
"info",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/steam/steam.go#L105-L139 | train |
markbates/goth | providers/steam/steam.go | buildUserObject | func buildUserObject(r io.Reader, u goth.User) (goth.User, error) {
// Response object from Steam
apiResponse := struct {
Response struct {
Players []struct {
UserID string `json:"steamid"`
NickName string `json:"personaname"`
Name string `json:"realname"`
AvatarURL string `json:"avatarfull"`
LocationCountryCode string `json:"loccountrycode"`
LocationStateCode string `json:"locstatecode"`
} `json:"players"`
} `json:"response"`
}{}
err := json.NewDecoder(r).Decode(&apiResponse)
if err != nil {
return u, err
}
if l := len(apiResponse.Response.Players); l != 1 {
return u, fmt.Errorf("Expected one player in API response. Got %d.", l)
}
player := apiResponse.Response.Players[0]
u.UserID = player.UserID
u.Name = player.Name
if len(player.Name) == 0 {
u.Name = "No name is provided by the Steam API"
}
u.NickName = player.NickName
u.AvatarURL = player.AvatarURL
u.Email = "No email is provided by the Steam API"
u.Description = "No description is provided by the Steam API"
if len(player.LocationStateCode) > 0 && len(player.LocationCountryCode) > 0 {
u.Location = fmt.Sprintf("%s, %s", player.LocationStateCode, player.LocationCountryCode)
} else if len(player.LocationCountryCode) > 0 {
u.Location = player.LocationCountryCode
} else if len(player.LocationStateCode) > 0 {
u.Location = player.LocationStateCode
} else {
u.Location = "No location is provided by the Steam API"
}
return u, nil
} | go | func buildUserObject(r io.Reader, u goth.User) (goth.User, error) {
// Response object from Steam
apiResponse := struct {
Response struct {
Players []struct {
UserID string `json:"steamid"`
NickName string `json:"personaname"`
Name string `json:"realname"`
AvatarURL string `json:"avatarfull"`
LocationCountryCode string `json:"loccountrycode"`
LocationStateCode string `json:"locstatecode"`
} `json:"players"`
} `json:"response"`
}{}
err := json.NewDecoder(r).Decode(&apiResponse)
if err != nil {
return u, err
}
if l := len(apiResponse.Response.Players); l != 1 {
return u, fmt.Errorf("Expected one player in API response. Got %d.", l)
}
player := apiResponse.Response.Players[0]
u.UserID = player.UserID
u.Name = player.Name
if len(player.Name) == 0 {
u.Name = "No name is provided by the Steam API"
}
u.NickName = player.NickName
u.AvatarURL = player.AvatarURL
u.Email = "No email is provided by the Steam API"
u.Description = "No description is provided by the Steam API"
if len(player.LocationStateCode) > 0 && len(player.LocationCountryCode) > 0 {
u.Location = fmt.Sprintf("%s, %s", player.LocationStateCode, player.LocationCountryCode)
} else if len(player.LocationCountryCode) > 0 {
u.Location = player.LocationCountryCode
} else if len(player.LocationStateCode) > 0 {
u.Location = player.LocationStateCode
} else {
u.Location = "No location is provided by the Steam API"
}
return u, nil
} | [
"func",
"buildUserObject",
"(",
"r",
"io",
".",
"Reader",
",",
"u",
"goth",
".",
"User",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"apiResponse",
":=",
"struct",
"{",
"Response",
"struct",
"{",
"Players",
"[",
"]",
"struct",
"{",
"UserID... | // buildUserObject is an internal function to build a goth.User object
// based in the data stored in r | [
"buildUserObject",
"is",
"an",
"internal",
"function",
"to",
"build",
"a",
"goth",
".",
"User",
"object",
"based",
"in",
"the",
"data",
"stored",
"in",
"r"
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/steam/steam.go#L143-L189 | train |
markbates/goth | providers/yammer/session.go | Authorize | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
v := url.Values{
"grant_type": {"authorization_code"},
"code": CondVal(params.Get("code")),
"redirect_uri": CondVal(p.config.RedirectURL),
"scope": CondVal(strings.Join(p.config.Scopes, " ")),
}
//Cant use standard auth2 implementation as yammer returns access_token as json rather than string
//stand methods are throwing exception
//token, err := p.config.Exchange(goth.ContextForClient(p.Client), params.Get("code"))
autData, err := retrieveAuthData(p, tokenURL, v)
if err != nil {
return "", err
}
token := autData["access_token"]["token"].(string)
s.AccessToken = token
return token, err
} | go | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
v := url.Values{
"grant_type": {"authorization_code"},
"code": CondVal(params.Get("code")),
"redirect_uri": CondVal(p.config.RedirectURL),
"scope": CondVal(strings.Join(p.config.Scopes, " ")),
}
//Cant use standard auth2 implementation as yammer returns access_token as json rather than string
//stand methods are throwing exception
//token, err := p.config.Exchange(goth.ContextForClient(p.Client), params.Get("code"))
autData, err := retrieveAuthData(p, tokenURL, v)
if err != nil {
return "", err
}
token := autData["access_token"]["token"].(string)
s.AccessToken = token
return token, err
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Authorize",
"(",
"provider",
"goth",
".",
"Provider",
",",
"params",
"goth",
".",
"Params",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
":=",
"provider",
".",
"(",
"*",
"Provider",
")",
"\n",
"v",
":=",
... | // Authorize the session with Yammer and return the access token to be stored for future use. | [
"Authorize",
"the",
"session",
"with",
"Yammer",
"and",
"return",
"the",
"access",
"token",
"to",
"be",
"stored",
"for",
"future",
"use",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/yammer/session.go#L33-L51 | train |
markbates/goth | providers/yammer/session.go | retrieveAuthData | func retrieveAuthData(p *Provider, TokenURL string, v url.Values) (map[string]map[string]interface{}, error) {
v.Set("client_id", p.ClientKey)
v.Set("client_secret", p.Secret)
req, err := http.NewRequest("POST", TokenURL, strings.NewReader(v.Encode()))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
r, err := p.Client().Do(req)
if err != nil {
return nil, err
}
defer r.Body.Close()
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1<<20))
if err != nil {
return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
}
if code := r.StatusCode; code < 200 || code > 299 {
return nil, fmt.Errorf("oauth2: cannot fetch token: %v\nResponse: %s", r.Status, body)
}
var objmap map[string]map[string]interface{}
err = json.Unmarshal(body, &objmap)
if err != nil {
return nil, err
}
return objmap, nil
} | go | func retrieveAuthData(p *Provider, TokenURL string, v url.Values) (map[string]map[string]interface{}, error) {
v.Set("client_id", p.ClientKey)
v.Set("client_secret", p.Secret)
req, err := http.NewRequest("POST", TokenURL, strings.NewReader(v.Encode()))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
r, err := p.Client().Do(req)
if err != nil {
return nil, err
}
defer r.Body.Close()
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1<<20))
if err != nil {
return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
}
if code := r.StatusCode; code < 200 || code > 299 {
return nil, fmt.Errorf("oauth2: cannot fetch token: %v\nResponse: %s", r.Status, body)
}
var objmap map[string]map[string]interface{}
err = json.Unmarshal(body, &objmap)
if err != nil {
return nil, err
}
return objmap, nil
} | [
"func",
"retrieveAuthData",
"(",
"p",
"*",
"Provider",
",",
"TokenURL",
"string",
",",
"v",
"url",
".",
"Values",
")",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"v",
".",
"Set",
"(",
... | //Custom implementation for yammer to get access token and user data
//Yammer provides user data along with access token, no separate api available | [
"Custom",
"implementation",
"for",
"yammer",
"to",
"get",
"access",
"token",
"and",
"user",
"data",
"Yammer",
"provides",
"user",
"data",
"along",
"with",
"access",
"token",
"no",
"separate",
"api",
"available"
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/yammer/session.go#L65-L95 | train |
markbates/goth | providers/google/google.go | BeginAuth | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
var opts []oauth2.AuthCodeOption
if p.prompt != nil {
opts = append(opts, p.prompt)
}
url := p.config.AuthCodeURL(state, opts...)
session := &Session{
AuthURL: url,
}
return session, nil
} | go | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
var opts []oauth2.AuthCodeOption
if p.prompt != nil {
opts = append(opts, p.prompt)
}
url := p.config.AuthCodeURL(state, opts...)
session := &Session{
AuthURL: url,
}
return session, nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"BeginAuth",
"(",
"state",
"string",
")",
"(",
"goth",
".",
"Session",
",",
"error",
")",
"{",
"var",
"opts",
"[",
"]",
"oauth2",
".",
"AuthCodeOption",
"\n",
"if",
"p",
".",
"prompt",
"!=",
"nil",
"{",
"opts... | // BeginAuth asks Google for an authentication endpoint. | [
"BeginAuth",
"asks",
"Google",
"for",
"an",
"authentication",
"endpoint",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/google/google.go#L63-L73 | train |
markbates/goth | providers/google/google.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// Data is not yet retrieved, since accessToken is still empty.
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
response, err := p.Client().Get(endpointProfile + "?access_token=" + url.QueryEscape(sess.AccessToken))
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
responseBytes, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
var u googleUser
if err := json.Unmarshal(responseBytes, &u); err != nil {
return user, err
}
// Extract the user data we got from Google into our goth.User.
user.Name = u.Name
user.FirstName = u.FirstName
user.LastName = u.LastName
user.NickName = u.Name
user.Email = u.Email
user.AvatarURL = u.Picture
user.UserID = u.ID
// Google provides other useful fields such as 'hd'; get them from RawData
if err := json.Unmarshal(responseBytes, &user.RawData); err != nil {
return user, err
}
return user, nil
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// Data is not yet retrieved, since accessToken is still empty.
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
response, err := p.Client().Get(endpointProfile + "?access_token=" + url.QueryEscape(sess.AccessToken))
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
responseBytes, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
var u googleUser
if err := json.Unmarshal(responseBytes, &u); err != nil {
return user, err
}
// Extract the user data we got from Google into our goth.User.
user.Name = u.Name
user.FirstName = u.FirstName
user.LastName = u.LastName
user.NickName = u.Name
user.Email = u.Email
user.AvatarURL = u.Picture
user.UserID = u.ID
// Google provides other useful fields such as 'hd'; get them from RawData
if err := json.Unmarshal(responseBytes, &user.RawData); err != nil {
return user, err
}
return user, nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to Google and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"Google",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/google/google.go#L86-L134 | train |
markbates/goth | providers/mailru/mailru.go | New | func New(clientID, clientSecret, redirectURL string, scopes ...string) *Provider {
var c = &oauth2.Config{
ClientID: clientID,
ClientSecret: clientSecret,
RedirectURL: redirectURL,
Endpoint: oauth2.Endpoint{
AuthURL: authURL,
TokenURL: tokenURL,
},
Scopes: []string{},
}
for _, scope := range scopes {
c.Scopes = append(c.Scopes, scope)
}
return &Provider{
name: "mailru",
oauthConfig: c,
}
} | go | func New(clientID, clientSecret, redirectURL string, scopes ...string) *Provider {
var c = &oauth2.Config{
ClientID: clientID,
ClientSecret: clientSecret,
RedirectURL: redirectURL,
Endpoint: oauth2.Endpoint{
AuthURL: authURL,
TokenURL: tokenURL,
},
Scopes: []string{},
}
for _, scope := range scopes {
c.Scopes = append(c.Scopes, scope)
}
return &Provider{
name: "mailru",
oauthConfig: c,
}
} | [
"func",
"New",
"(",
"clientID",
",",
"clientSecret",
",",
"redirectURL",
"string",
",",
"scopes",
"...",
"string",
")",
"*",
"Provider",
"{",
"var",
"c",
"=",
"&",
"oauth2",
".",
"Config",
"{",
"ClientID",
":",
"clientID",
",",
"ClientSecret",
":",
"clie... | // New creates a new MAILRU provider and sets up important connection details.
// You should always call `mailru.New` to get a new provider. Never try to
// create one manually. | [
"New",
"creates",
"a",
"new",
"MAILRU",
"provider",
"and",
"sets",
"up",
"important",
"connection",
"details",
".",
"You",
"should",
"always",
"call",
"mailru",
".",
"New",
"to",
"get",
"a",
"new",
"provider",
".",
"Never",
"try",
"to",
"create",
"one",
... | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/mailru/mailru.go#L26-L46 | train |
markbates/goth | providers/mailru/mailru.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (_ goth.User, err error) {
var (
sess = session.(*Session)
user = goth.User{
AccessToken: sess.AccessToken,
RefreshToken: sess.RefreshToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
}
)
if user.AccessToken == "" {
return user, fmt.Errorf("%s cannot get user information without access token", p.name)
}
var (
sig = fmt.Sprintf(
"app_id=%smethod=users.getInfosecure=1session_key=%s%s",
p.oauthConfig.ClientID, sess.AccessToken, p.oauthConfig.ClientSecret,
)
hasher = md5.New()
)
if _, err = io.WriteString(hasher, sig); err != nil {
return user, err
}
var reqURL = fmt.Sprintf(
"%s?app_id=%s&method=users.getInfo&secure=1&session_key=%s&sig=%x",
endpointUser, p.oauthConfig.ClientID, sess.AccessToken, hasher.Sum(nil),
)
res, err := p.Client().Get(reqURL)
if err != nil {
return user, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.name, res.StatusCode)
}
buf, err := ioutil.ReadAll(res.Body)
if err != nil {
return user, err
}
var raw []json.RawMessage
if err = json.Unmarshal(buf, &raw); err != nil {
return user, err
}
if len(raw) == 0 {
return user, fmt.Errorf("%s cannot get user information", p.name)
}
if err = json.Unmarshal(raw[0], &user.RawData); err != nil {
return user, err
}
// extract and ignore all errors
user.UserID, _ = user.RawData["uid"].(string)
user.FirstName, _ = user.RawData["first_name"].(string)
user.LastName, _ = user.RawData["last_name"].(string)
user.NickName, _ = user.RawData["nick"].(string)
user.Email, _ = user.RawData["email"].(string)
user.AvatarURL, _ = user.RawData["pic_big"].(string)
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (_ goth.User, err error) {
var (
sess = session.(*Session)
user = goth.User{
AccessToken: sess.AccessToken,
RefreshToken: sess.RefreshToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
}
)
if user.AccessToken == "" {
return user, fmt.Errorf("%s cannot get user information without access token", p.name)
}
var (
sig = fmt.Sprintf(
"app_id=%smethod=users.getInfosecure=1session_key=%s%s",
p.oauthConfig.ClientID, sess.AccessToken, p.oauthConfig.ClientSecret,
)
hasher = md5.New()
)
if _, err = io.WriteString(hasher, sig); err != nil {
return user, err
}
var reqURL = fmt.Sprintf(
"%s?app_id=%s&method=users.getInfo&secure=1&session_key=%s&sig=%x",
endpointUser, p.oauthConfig.ClientID, sess.AccessToken, hasher.Sum(nil),
)
res, err := p.Client().Get(reqURL)
if err != nil {
return user, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.name, res.StatusCode)
}
buf, err := ioutil.ReadAll(res.Body)
if err != nil {
return user, err
}
var raw []json.RawMessage
if err = json.Unmarshal(buf, &raw); err != nil {
return user, err
}
if len(raw) == 0 {
return user, fmt.Errorf("%s cannot get user information", p.name)
}
if err = json.Unmarshal(raw[0], &user.RawData); err != nil {
return user, err
}
// extract and ignore all errors
user.UserID, _ = user.RawData["uid"].(string)
user.FirstName, _ = user.RawData["first_name"].(string)
user.LastName, _ = user.RawData["last_name"].(string)
user.NickName, _ = user.RawData["nick"].(string)
user.Email, _ = user.RawData["email"].(string)
user.AvatarURL, _ = user.RawData["pic_big"].(string)
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"_",
"goth",
".",
"User",
",",
"err",
"error",
")",
"{",
"var",
"(",
"sess",
"=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
"=",
... | // FetchUser will go to MAILRU and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"MAILRU",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/mailru/mailru.go#L79-L149 | train |
markbates/goth | providers/mailru/mailru.go | RefreshToken | func (p *Provider) RefreshToken(refreshToken string) (*oauth2.Token, error) {
t := &oauth2.Token{RefreshToken: refreshToken}
ts := p.oauthConfig.TokenSource(goth.ContextForClient(p.Client()), t)
return ts.Token()
} | go | func (p *Provider) RefreshToken(refreshToken string) (*oauth2.Token, error) {
t := &oauth2.Token{RefreshToken: refreshToken}
ts := p.oauthConfig.TokenSource(goth.ContextForClient(p.Client()), t)
return ts.Token()
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"RefreshToken",
"(",
"refreshToken",
"string",
")",
"(",
"*",
"oauth2",
".",
"Token",
",",
"error",
")",
"{",
"t",
":=",
"&",
"oauth2",
".",
"Token",
"{",
"RefreshToken",
":",
"refreshToken",
"}",
"\n",
"ts",
"... | // RefreshToken refresh token is not provided by mailru. | [
"RefreshToken",
"refresh",
"token",
"is",
"not",
"provided",
"by",
"mailru",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/mailru/mailru.go#L155-L160 | train |
markbates/goth | providers/openidConnect/openidConnect.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
expiresAt := sess.ExpiresAt
if sess.IDToken == "" {
return goth.User{}, fmt.Errorf("%s cannot get user information without id_token", p.providerName)
}
// decode returned id token to get expiry
claims, err := decodeJWT(sess.IDToken)
if err != nil {
return goth.User{}, fmt.Errorf("oauth2: error decoding JWT token: %v", err)
}
expiry, err := p.validateClaims(claims)
if err != nil {
return goth.User{}, fmt.Errorf("oauth2: error validating JWT token: %v", err)
}
if expiry.Before(expiresAt) {
expiresAt = expiry
}
if err := p.getUserInfo(sess.AccessToken, claims); err != nil {
return goth.User{}, err
}
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: expiresAt,
RawData: claims,
}
p.userFromClaims(claims, &user)
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
expiresAt := sess.ExpiresAt
if sess.IDToken == "" {
return goth.User{}, fmt.Errorf("%s cannot get user information without id_token", p.providerName)
}
// decode returned id token to get expiry
claims, err := decodeJWT(sess.IDToken)
if err != nil {
return goth.User{}, fmt.Errorf("oauth2: error decoding JWT token: %v", err)
}
expiry, err := p.validateClaims(claims)
if err != nil {
return goth.User{}, fmt.Errorf("oauth2: error validating JWT token: %v", err)
}
if expiry.Before(expiresAt) {
expiresAt = expiry
}
if err := p.getUserInfo(sess.AccessToken, claims); err != nil {
return goth.User{}, err
}
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: expiresAt,
RawData: claims,
}
p.userFromClaims(claims, &user)
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"expiresAt",
":=",
"sess",
".",
"Expir... | // FetchUser will use the the id_token and access requested information about the user. | [
"FetchUser",
"will",
"use",
"the",
"the",
"id_token",
"and",
"access",
"requested",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/openidConnect/openidConnect.go#L141-L180 | train |
markbates/goth | providers/battlenet/battlenet.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
// Get the userID, battlenet needs userID in order to get user profile info
c := p.Client()
req, err := http.NewRequest("GET", endpointUser, nil)
if err != nil {
return user, err
}
req.Header.Add("Authorization", "Bearer "+sess.AccessToken)
response, err := c.Do(req)
if err != nil {
if response != nil {
response.Body.Close()
}
return user, err
}
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
u := struct {
ID int64 `json:"id"`
Battletag string `json:"battletag"`
}{}
if err = json.NewDecoder(bytes.NewReader(bits)).Decode(&u); err != nil {
return user, err
}
user.NickName = u.Battletag
user.UserID = fmt.Sprintf("%d", u.ID)
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
// Get the userID, battlenet needs userID in order to get user profile info
c := p.Client()
req, err := http.NewRequest("GET", endpointUser, nil)
if err != nil {
return user, err
}
req.Header.Add("Authorization", "Bearer "+sess.AccessToken)
response, err := c.Do(req)
if err != nil {
if response != nil {
response.Body.Close()
}
return user, err
}
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
u := struct {
ID int64 `json:"id"`
Battletag string `json:"battletag"`
}{}
if err = json.NewDecoder(bytes.NewReader(bits)).Decode(&u); err != nil {
return user, err
}
user.NickName = u.Battletag
user.UserID = fmt.Sprintf("%d", u.ID)
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to Battle.net and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"Battle",
".",
"net",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/battlenet/battlenet.go#L72-L124 | train |
markbates/goth | providers/twitter/twitter.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
Provider: p.Name(),
}
if sess.AccessToken == nil {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
response, err := p.consumer.Get(
endpointProfile,
map[string]string{"include_entities": "false", "skip_status": "true", "include_email": "true"},
sess.AccessToken)
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
user.Name = user.RawData["name"].(string)
user.NickName = user.RawData["screen_name"].(string)
if user.RawData["email"] != nil {
user.Email = user.RawData["email"].(string)
}
user.Description = user.RawData["description"].(string)
user.AvatarURL = user.RawData["profile_image_url"].(string)
user.UserID = user.RawData["id_str"].(string)
user.Location = user.RawData["location"].(string)
user.AccessToken = sess.AccessToken.Token
user.AccessTokenSecret = sess.AccessToken.Secret
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
Provider: p.Name(),
}
if sess.AccessToken == nil {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
response, err := p.consumer.Get(
endpointProfile,
map[string]string{"include_entities": "false", "skip_status": "true", "include_email": "true"},
sess.AccessToken)
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
user.Name = user.RawData["name"].(string)
user.NickName = user.RawData["screen_name"].(string)
if user.RawData["email"] != nil {
user.Email = user.RawData["email"].(string)
}
user.Description = user.RawData["description"].(string)
user.AvatarURL = user.RawData["profile_image_url"].(string)
user.UserID = user.RawData["id_str"].(string)
user.Location = user.RawData["location"].(string)
user.AccessToken = sess.AccessToken.Token
user.AccessTokenSecret = sess.AccessToken.Secret
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to Twitter and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"Twitter",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/twitter/twitter.go#L98-L140 | train |
markbates/goth | providers/spotify/session.go | Marshal | func (s Session) Marshal() string {
j, _ := json.Marshal(s)
return string(j)
} | go | func (s Session) Marshal() string {
j, _ := json.Marshal(s)
return string(j)
} | [
"func",
"(",
"s",
"Session",
")",
"Marshal",
"(",
")",
"string",
"{",
"j",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"s",
")",
"\n",
"return",
"string",
"(",
"j",
")",
"\n",
"}"
] | // Marshal marshals a session into a JSON string. | [
"Marshal",
"marshals",
"a",
"session",
"into",
"a",
"JSON",
"string",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/spotify/session.go#L48-L51 | train |
markbates/goth | providers/lastfm/session.go | Authorize | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
sess, err := p.GetSession(params.Get("token"))
if err != nil {
return "", err
}
s.AccessToken = sess["token"]
s.Login = sess["login"]
return sess["token"], err
} | go | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
sess, err := p.GetSession(params.Get("token"))
if err != nil {
return "", err
}
s.AccessToken = sess["token"]
s.Login = sess["login"]
return sess["token"], err
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Authorize",
"(",
"provider",
"goth",
".",
"Provider",
",",
"params",
"goth",
".",
"Params",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
":=",
"provider",
".",
"(",
"*",
"Provider",
")",
"\n",
"sess",
","... | // Authorize the session with LastFM and return the access token to be stored for future use. | [
"Authorize",
"the",
"session",
"with",
"LastFM",
"and",
"return",
"the",
"access",
"token",
"to",
"be",
"stored",
"for",
"future",
"use",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/lastfm/session.go#L27-L37 | train |
markbates/goth | providers/eveonline/eveonline.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
// Get the userID, eveonline needs userID in order to get user profile info
req, err := http.NewRequest("GET", verifyPath, nil)
if err != nil {
return user, err
}
req.Header.Set("Authorization", "Bearer "+user.AccessToken)
response, err := p.Client().Do(req)
if err != nil {
if response != nil {
response.Body.Close()
}
return user, err
}
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
u := struct {
CharacterID int64
CharacterName string
ExpiresOn string
Scopes string
TokenType string
CharacterOwnerHash string
}{}
if err = json.NewDecoder(bytes.NewReader(bits)).Decode(&u); err != nil {
return user, err
}
user.NickName = u.CharacterName
user.UserID = fmt.Sprintf("%d", u.CharacterID)
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
// Get the userID, eveonline needs userID in order to get user profile info
req, err := http.NewRequest("GET", verifyPath, nil)
if err != nil {
return user, err
}
req.Header.Set("Authorization", "Bearer "+user.AccessToken)
response, err := p.Client().Do(req)
if err != nil {
if response != nil {
response.Body.Close()
}
return user, err
}
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
u := struct {
CharacterID int64
CharacterName string
ExpiresOn string
Scopes string
TokenType string
CharacterOwnerHash string
}{}
if err = json.NewDecoder(bytes.NewReader(bits)).Decode(&u); err != nil {
return user, err
}
user.NickName = u.CharacterName
user.UserID = fmt.Sprintf("%d", u.CharacterID)
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to Eve Online and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"Eve",
"Online",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/eveonline/eveonline.go#L73-L127 | train |
markbates/goth | providers/azuread/azuread.go | New | func New(clientKey, secret, callbackURL string, resources []string, scopes ...string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
providerName: "azuread",
}
p.resources = make([]string, 0, 1+len(resources))
p.resources = append(p.resources, graphAPIResource)
p.resources = append(p.resources, resources...)
p.config = newConfig(p, scopes)
return p
} | go | func New(clientKey, secret, callbackURL string, resources []string, scopes ...string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
providerName: "azuread",
}
p.resources = make([]string, 0, 1+len(resources))
p.resources = append(p.resources, graphAPIResource)
p.resources = append(p.resources, resources...)
p.config = newConfig(p, scopes)
return p
} | [
"func",
"New",
"(",
"clientKey",
",",
"secret",
",",
"callbackURL",
"string",
",",
"resources",
"[",
"]",
"string",
",",
"scopes",
"...",
"string",
")",
"*",
"Provider",
"{",
"p",
":=",
"&",
"Provider",
"{",
"ClientKey",
":",
"clientKey",
",",
"Secret",
... | // New creates a new AzureAD provider, and sets up important connection details.
// You should always call `AzureAD.New` to get a new Provider. Never try to create
// one manually. | [
"New",
"creates",
"a",
"new",
"AzureAD",
"provider",
"and",
"sets",
"up",
"important",
"connection",
"details",
".",
"You",
"should",
"always",
"call",
"AzureAD",
".",
"New",
"to",
"get",
"a",
"new",
"Provider",
".",
"Never",
"try",
"to",
"create",
"one",
... | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/azuread/azuread.go#L28-L42 | train |
markbates/goth | providers/azuread/azuread.go | BeginAuth | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
authURL := p.config.AuthCodeURL(state)
// Azure ad requires at least one resource
authURL += "&resource=" + url.QueryEscape(strings.Join(p.resources, " "))
return &Session{
AuthURL: authURL,
}, nil
} | go | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
authURL := p.config.AuthCodeURL(state)
// Azure ad requires at least one resource
authURL += "&resource=" + url.QueryEscape(strings.Join(p.resources, " "))
return &Session{
AuthURL: authURL,
}, nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"BeginAuth",
"(",
"state",
"string",
")",
"(",
"goth",
".",
"Session",
",",
"error",
")",
"{",
"authURL",
":=",
"p",
".",
"config",
".",
"AuthCodeURL",
"(",
"state",
")",
"\n",
"authURL",
"+=",
"\"&resource=\"",
... | // BeginAuth asks AzureAD for an authentication end-point. | [
"BeginAuth",
"asks",
"AzureAD",
"for",
"an",
"authentication",
"end",
"-",
"point",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/azuread/azuread.go#L74-L83 | train |
markbates/goth | providers/lastfm/lastfm.go | BeginAuth | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
urlParams := url.Values{}
urlParams.Add("api_key", p.ClientKey)
urlParams.Add("callback", p.CallbackURL)
session := &Session{
AuthURL: authURL + "?" + urlParams.Encode(),
}
return session, nil
} | go | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
urlParams := url.Values{}
urlParams.Add("api_key", p.ClientKey)
urlParams.Add("callback", p.CallbackURL)
session := &Session{
AuthURL: authURL + "?" + urlParams.Encode(),
}
return session, nil
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"BeginAuth",
"(",
"state",
"string",
")",
"(",
"goth",
".",
"Session",
",",
"error",
")",
"{",
"urlParams",
":=",
"url",
".",
"Values",
"{",
"}",
"\n",
"urlParams",
".",
"Add",
"(",
"\"api_key\"",
",",
"p",
"... | // BeginAuth asks LastFm for an authentication end-point | [
"BeginAuth",
"asks",
"LastFm",
"for",
"an",
"authentication",
"end",
"-",
"point"
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/lastfm/lastfm.go#L66-L76 | train |
markbates/goth | providers/lastfm/lastfm.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s has no user information available (yet)", p.providerName)
}
u := struct {
XMLName xml.Name `xml:"user"`
ID string `xml:"id"`
Name string `xml:"name"`
RealName string `xml:"realname"`
URL string `xml:"url"`
Country string `xml:"country"`
Age string `xml:"age"`
Gender string `xml:"gender"`
Subscriber string `xml:"subscriber"`
PlayCount string `xml:"playcount"`
Playlists string `xml:"playlists"`
Bootstrap string `xml:"bootstrap"`
Registered struct {
Unixtime string `xml:"unixtime,attr"`
Time string `xml:",chardata"`
} `xml:"registered"`
Images []struct {
Size string `xml:"size,attr"`
URL string `xml:",chardata"`
} `xml:"image"`
}{}
login := session.(*Session).Login
err := p.request(false, map[string]string{"method": "user.getinfo", "user": login}, &u)
if err == nil {
user.Name = u.RealName
user.NickName = u.Name
user.AvatarURL = u.Images[3].URL
user.UserID = u.ID
user.Location = u.Country
}
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s has no user information available (yet)", p.providerName)
}
u := struct {
XMLName xml.Name `xml:"user"`
ID string `xml:"id"`
Name string `xml:"name"`
RealName string `xml:"realname"`
URL string `xml:"url"`
Country string `xml:"country"`
Age string `xml:"age"`
Gender string `xml:"gender"`
Subscriber string `xml:"subscriber"`
PlayCount string `xml:"playcount"`
Playlists string `xml:"playlists"`
Bootstrap string `xml:"bootstrap"`
Registered struct {
Unixtime string `xml:"unixtime,attr"`
Time string `xml:",chardata"`
} `xml:"registered"`
Images []struct {
Size string `xml:"size,attr"`
URL string `xml:",chardata"`
} `xml:"image"`
}{}
login := session.(*Session).Login
err := p.request(false, map[string]string{"method": "user.getinfo", "user": login}, &u)
if err == nil {
user.Name = u.RealName
user.NickName = u.Name
user.AvatarURL = u.Images[3].URL
user.UserID = u.ID
user.Location = u.Country
}
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to LastFM and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"LastFM",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/lastfm/lastfm.go#L79-L126 | train |
markbates/goth | providers/lastfm/lastfm.go | GetSession | func (p *Provider) GetSession(token string) (map[string]string, error) {
sess := struct {
Name string `xml:"name"`
Key string `xml:"key"`
Subscriber bool `xml:"subscriber"`
}{}
err := p.request(true, map[string]string{"method": "auth.getSession", "token": token}, &sess)
return map[string]string{"login": sess.Name, "token": sess.Key}, err
} | go | func (p *Provider) GetSession(token string) (map[string]string, error) {
sess := struct {
Name string `xml:"name"`
Key string `xml:"key"`
Subscriber bool `xml:"subscriber"`
}{}
err := p.request(true, map[string]string{"method": "auth.getSession", "token": token}, &sess)
return map[string]string{"login": sess.Name, "token": sess.Key}, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"GetSession",
"(",
"token",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"sess",
":=",
"struct",
"{",
"Name",
"string",
"`xml:\"name\"`",
"\n",
"Key",
"string",
"`xml:\"key\"`",
... | // GetSession token from LastFM | [
"GetSession",
"token",
"from",
"LastFM"
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/lastfm/lastfm.go#L129-L138 | train |
markbates/goth | providers/vk/vk.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
Email: sess.email,
}
if user.AccessToken == "" {
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
fields := "photo_200,nickname"
requestURL := fmt.Sprintf("%s?fields=%s&access_token=%s&v=%s", endpointUser, fields, sess.AccessToken, apiVersion)
response, err := p.Client().Get(requestURL)
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
err = userFromReader(bytes.NewReader(bits), &user)
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
Email: sess.email,
}
if user.AccessToken == "" {
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
fields := "photo_200,nickname"
requestURL := fmt.Sprintf("%s?fields=%s&access_token=%s&v=%s", endpointUser, fields, sess.AccessToken, apiVersion)
response, err := p.Client().Get(requestURL)
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
err = userFromReader(bytes.NewReader(bits), &user)
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to VK and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"VK",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/vk/vk.go#L76-L110 | train |
markbates/goth | providers/github/github.go | New | func New(clientKey, secret, callbackURL string, scopes ...string) *Provider {
return NewCustomisedURL(clientKey, secret, callbackURL, AuthURL, TokenURL, ProfileURL, EmailURL, scopes...)
} | go | func New(clientKey, secret, callbackURL string, scopes ...string) *Provider {
return NewCustomisedURL(clientKey, secret, callbackURL, AuthURL, TokenURL, ProfileURL, EmailURL, scopes...)
} | [
"func",
"New",
"(",
"clientKey",
",",
"secret",
",",
"callbackURL",
"string",
",",
"scopes",
"...",
"string",
")",
"*",
"Provider",
"{",
"return",
"NewCustomisedURL",
"(",
"clientKey",
",",
"secret",
",",
"callbackURL",
",",
"AuthURL",
",",
"TokenURL",
",",
... | // New creates a new Github provider, and sets up important connection details.
// You should always call `github.New` to get a new Provider. Never try to create
// one manually. | [
"New",
"creates",
"a",
"new",
"Github",
"provider",
"and",
"sets",
"up",
"important",
"connection",
"details",
".",
"You",
"should",
"always",
"call",
"github",
".",
"New",
"to",
"get",
"a",
"new",
"Provider",
".",
"Never",
"try",
"to",
"create",
"one",
... | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/github/github.go#L39-L41 | train |
markbates/goth | providers/github/github.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
response, err := p.Client().Get(p.profileURL + "?access_token=" + url.QueryEscape(sess.AccessToken))
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("GitHub API responded with a %d trying to fetch user information", response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
err = userFromReader(bytes.NewReader(bits), &user)
if err != nil {
return user, err
}
if user.Email == "" {
for _, scope := range p.config.Scopes {
if strings.TrimSpace(scope) == "user" || strings.TrimSpace(scope) == "user:email" {
user.Email, err = getPrivateMail(p, sess)
if err != nil {
return user, err
}
break
}
}
}
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
response, err := p.Client().Get(p.profileURL + "?access_token=" + url.QueryEscape(sess.AccessToken))
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("GitHub API responded with a %d trying to fetch user information", response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
err = userFromReader(bytes.NewReader(bits), &user)
if err != nil {
return user, err
}
if user.Email == "" {
for _, scope := range p.config.Scopes {
if strings.TrimSpace(scope) == "user" || strings.TrimSpace(scope) == "user:email" {
user.Email, err = getPrivateMail(p, sess)
if err != nil {
return user, err
}
break
}
}
}
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to Github and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"Github",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/github/github.go#L96-L145 | train |
markbates/goth | providers/vk/session.go | GetAuthURL | func (s *Session) GetAuthURL() (string, error) {
if s.AuthURL == "" {
return "", errors.New(goth.NoAuthUrlErrorMessage)
}
return s.AuthURL, nil
} | go | func (s *Session) GetAuthURL() (string, error) {
if s.AuthURL == "" {
return "", errors.New(goth.NoAuthUrlErrorMessage)
}
return s.AuthURL, nil
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"GetAuthURL",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"s",
".",
"AuthURL",
"==",
"\"\"",
"{",
"return",
"\"\"",
",",
"errors",
".",
"New",
"(",
"goth",
".",
"NoAuthUrlErrorMessage",
")",
"\n",
"... | // GetAuthURL returns the URL for the authentication end-point for the provider. | [
"GetAuthURL",
"returns",
"the",
"URL",
"for",
"the",
"authentication",
"end",
"-",
"point",
"for",
"the",
"provider",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/vk/session.go#L21-L26 | train |
markbates/goth | providers/vk/session.go | Authorize | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
token, err := p.config.Exchange(goth.ContextForClient(p.Client()), params.Get("code"))
if err != nil {
return "", err
}
if !token.Valid() {
return "", errors.New("Invalid token received from provider")
}
email, ok := token.Extra("email").(string)
if !ok {
return "", errors.New("Cannot fetch user email")
}
s.AccessToken = token.AccessToken
s.ExpiresAt = token.Expiry
s.email = email
return s.AccessToken, err
} | go | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
token, err := p.config.Exchange(goth.ContextForClient(p.Client()), params.Get("code"))
if err != nil {
return "", err
}
if !token.Valid() {
return "", errors.New("Invalid token received from provider")
}
email, ok := token.Extra("email").(string)
if !ok {
return "", errors.New("Cannot fetch user email")
}
s.AccessToken = token.AccessToken
s.ExpiresAt = token.Expiry
s.email = email
return s.AccessToken, err
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Authorize",
"(",
"provider",
"goth",
".",
"Provider",
",",
"params",
"goth",
".",
"Params",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
":=",
"provider",
".",
"(",
"*",
"Provider",
")",
"\n",
"token",
",... | // Authorize the session with VK and return the access token to be stored for future use. | [
"Authorize",
"the",
"session",
"with",
"VK",
"and",
"return",
"the",
"access",
"token",
"to",
"be",
"stored",
"for",
"future",
"use",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/vk/session.go#L35-L55 | train |
markbates/goth | providers/tumblr/session.go | Authorize | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
accessToken, err := p.consumer.AuthorizeToken(s.RequestToken, params.Get("oauth_verifier"))
if err != nil {
return "", err
}
s.AccessToken = accessToken
return accessToken.Token, err
} | go | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
accessToken, err := p.consumer.AuthorizeToken(s.RequestToken, params.Get("oauth_verifier"))
if err != nil {
return "", err
}
s.AccessToken = accessToken
return accessToken.Token, err
} | [
"func",
"(",
"s",
"*",
"Session",
")",
"Authorize",
"(",
"provider",
"goth",
".",
"Provider",
",",
"params",
"goth",
".",
"Params",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
":=",
"provider",
".",
"(",
"*",
"Provider",
")",
"\n",
"accessToken"... | // Authorize the session with Tumblr and return the access token to be stored for future use. | [
"Authorize",
"the",
"session",
"with",
"Tumblr",
"and",
"return",
"the",
"access",
"token",
"to",
"be",
"stored",
"for",
"future",
"use",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/tumblr/session.go#L28-L37 | train |
markbates/goth | providers/facebook/facebook.go | FetchUser | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
// always add appsecretProof to make calls more protected
// https://github.com/markbates/goth/issues/96
// https://developers.facebook.com/docs/graph-api/securing-requests
hash := hmac.New(sha256.New, []byte(p.Secret))
hash.Write([]byte(sess.AccessToken))
appsecretProof := hex.EncodeToString(hash.Sum(nil))
reqUrl := fmt.Sprint(
endpointProfile,
p.Fields,
"&access_token=",
url.QueryEscape(sess.AccessToken),
"&appsecret_proof=",
appsecretProof,
)
response, err := p.Client().Get(reqUrl)
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
err = userFromReader(bytes.NewReader(bits), &user)
return user, err
} | go | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", p.providerName)
}
// always add appsecretProof to make calls more protected
// https://github.com/markbates/goth/issues/96
// https://developers.facebook.com/docs/graph-api/securing-requests
hash := hmac.New(sha256.New, []byte(p.Secret))
hash.Write([]byte(sess.AccessToken))
appsecretProof := hex.EncodeToString(hash.Sum(nil))
reqUrl := fmt.Sprint(
endpointProfile,
p.Fields,
"&access_token=",
url.QueryEscape(sess.AccessToken),
"&appsecret_proof=",
appsecretProof,
)
response, err := p.Client().Get(reqUrl)
if err != nil {
return user, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return user, fmt.Errorf("%s responded with a %d trying to fetch user information", p.providerName, response.StatusCode)
}
bits, err := ioutil.ReadAll(response.Body)
if err != nil {
return user, err
}
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
err = userFromReader(bytes.NewReader(bits), &user)
return user, err
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"FetchUser",
"(",
"session",
"goth",
".",
"Session",
")",
"(",
"goth",
".",
"User",
",",
"error",
")",
"{",
"sess",
":=",
"session",
".",
"(",
"*",
"Session",
")",
"\n",
"user",
":=",
"goth",
".",
"User",
"... | // FetchUser will go to Facebook and access basic information about the user. | [
"FetchUser",
"will",
"go",
"to",
"Facebook",
"and",
"access",
"basic",
"information",
"about",
"the",
"user",
"."
] | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/facebook/facebook.go#L92-L142 | train |
markbates/goth | providers/cloudfoundry/cf.go | New | func New(uaaURL, clientKey, secret, callbackURL string, scopes ...string) *Provider {
uaaURL = strings.TrimSuffix(uaaURL, "/")
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
AuthURL: uaaURL + "/oauth/authorize",
TokenURL: uaaURL + "/oauth/token",
UserInfoURL: uaaURL + "/userinfo",
providerName: "cloudfoundry",
}
p.config = newConfig(p, scopes)
return p
} | go | func New(uaaURL, clientKey, secret, callbackURL string, scopes ...string) *Provider {
uaaURL = strings.TrimSuffix(uaaURL, "/")
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
AuthURL: uaaURL + "/oauth/authorize",
TokenURL: uaaURL + "/oauth/token",
UserInfoURL: uaaURL + "/userinfo",
providerName: "cloudfoundry",
}
p.config = newConfig(p, scopes)
return p
} | [
"func",
"New",
"(",
"uaaURL",
",",
"clientKey",
",",
"secret",
",",
"callbackURL",
"string",
",",
"scopes",
"...",
"string",
")",
"*",
"Provider",
"{",
"uaaURL",
"=",
"strings",
".",
"TrimSuffix",
"(",
"uaaURL",
",",
"\"/\"",
")",
"\n",
"p",
":=",
"&",... | // New creates a new Cloud Foundry provider and sets up important connection details.
// You should always call `cloudfoundry.New` to get a new provider. Never try to
// create one manually. | [
"New",
"creates",
"a",
"new",
"Cloud",
"Foundry",
"provider",
"and",
"sets",
"up",
"important",
"connection",
"details",
".",
"You",
"should",
"always",
"call",
"cloudfoundry",
".",
"New",
"to",
"get",
"a",
"new",
"provider",
".",
"Never",
"try",
"to",
"cr... | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/cloudfoundry/cf.go#L35-L48 | train |
markbates/goth | providers/naver/naver.go | New | func New(clientKey, secret, callbackURL string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
providerName: "naver",
}
p.config = newConfig(p)
return p
} | go | func New(clientKey, secret, callbackURL string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
providerName: "naver",
}
p.config = newConfig(p)
return p
} | [
"func",
"New",
"(",
"clientKey",
",",
"secret",
",",
"callbackURL",
"string",
")",
"*",
"Provider",
"{",
"p",
":=",
"&",
"Provider",
"{",
"ClientKey",
":",
"clientKey",
",",
"Secret",
":",
"secret",
",",
"CallbackURL",
":",
"callbackURL",
",",
"providerNam... | // New creates a New provider and sets up important connection details.
// You should always call `naver.New` to get a new Provider. Never try to craete
// one manually.
// Currently Naver only supports pre-defined scopes.
// You should visit Naver Developer page in order to define your application's oauth scope. | [
"New",
"creates",
"a",
"New",
"provider",
"and",
"sets",
"up",
"important",
"connection",
"details",
".",
"You",
"should",
"always",
"call",
"naver",
".",
"New",
"to",
"get",
"a",
"new",
"Provider",
".",
"Never",
"try",
"to",
"craete",
"one",
"manually",
... | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/naver/naver.go#L122-L131 | train |
markbates/goth | providers/paypal/paypal.go | New | func New(clientKey, secret, callbackURL string, scopes ...string) *Provider {
paypalEnv := os.Getenv(envKey)
authURL := authURLProduction
tokenURL := tokenURLProduction
profileEndPoint := endpointProfileProduction
if paypalEnv == sandbox {
authURL = authURLSandbox
tokenURL = tokenURLSandbox
profileEndPoint = endpointProfileSandbox
}
return NewCustomisedURL(clientKey, secret, callbackURL, authURL, tokenURL, profileEndPoint, scopes...)
} | go | func New(clientKey, secret, callbackURL string, scopes ...string) *Provider {
paypalEnv := os.Getenv(envKey)
authURL := authURLProduction
tokenURL := tokenURLProduction
profileEndPoint := endpointProfileProduction
if paypalEnv == sandbox {
authURL = authURLSandbox
tokenURL = tokenURLSandbox
profileEndPoint = endpointProfileSandbox
}
return NewCustomisedURL(clientKey, secret, callbackURL, authURL, tokenURL, profileEndPoint, scopes...)
} | [
"func",
"New",
"(",
"clientKey",
",",
"secret",
",",
"callbackURL",
"string",
",",
"scopes",
"...",
"string",
")",
"*",
"Provider",
"{",
"paypalEnv",
":=",
"os",
".",
"Getenv",
"(",
"envKey",
")",
"\n",
"authURL",
":=",
"authURLProduction",
"\n",
"tokenURL... | // New creates a new Paypal provider and sets up important connection details.
// You should always call `paypal.New` to get a new provider. Never try to
// create one manually. | [
"New",
"creates",
"a",
"new",
"Paypal",
"provider",
"and",
"sets",
"up",
"important",
"connection",
"details",
".",
"You",
"should",
"always",
"call",
"paypal",
".",
"New",
"to",
"get",
"a",
"new",
"provider",
".",
"Never",
"try",
"to",
"create",
"one",
... | 9db62076e0965a39b5a282e506e0aec27d2b1625 | https://github.com/markbates/goth/blob/9db62076e0965a39b5a282e506e0aec27d2b1625/providers/paypal/paypal.go#L48-L62 | train |
songgao/water | syscalls_windows.go | setStatus | func setStatus(fd syscall.Handle, status bool) error {
var bytesReturned uint32
rdbbuf := make([]byte, syscall.MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
code := []byte{0x00, 0x00, 0x00, 0x00}
if status {
code[0] = 0x01
}
return syscall.DeviceIoControl(fd, tap_ioctl_set_media_status, &code[0], uint32(4), &rdbbuf[0], uint32(len(rdbbuf)), &bytesReturned, nil)
} | go | func setStatus(fd syscall.Handle, status bool) error {
var bytesReturned uint32
rdbbuf := make([]byte, syscall.MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
code := []byte{0x00, 0x00, 0x00, 0x00}
if status {
code[0] = 0x01
}
return syscall.DeviceIoControl(fd, tap_ioctl_set_media_status, &code[0], uint32(4), &rdbbuf[0], uint32(len(rdbbuf)), &bytesReturned, nil)
} | [
"func",
"setStatus",
"(",
"fd",
"syscall",
".",
"Handle",
",",
"status",
"bool",
")",
"error",
"{",
"var",
"bytesReturned",
"uint32",
"\n",
"rdbbuf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"syscall",
".",
"MAXIMUM_REPARSE_DATA_BUFFER_SIZE",
")",
"\n",
"... | // setStatus is used to bring up or bring down the interface | [
"setStatus",
"is",
"used",
"to",
"bring",
"up",
"or",
"bring",
"down",
"the",
"interface"
] | 6ad6edefb15c9ffe418e722c13459ab16a545d2b | https://github.com/songgao/water/blob/6ad6edefb15c9ffe418e722c13459ab16a545d2b/syscalls_windows.go#L200-L208 | train |
songgao/water | syscalls_windows.go | setTUN | func setTUN(fd syscall.Handle, network string) error {
var bytesReturned uint32
rdbbuf := make([]byte, syscall.MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
localIP, remoteNet, err := net.ParseCIDR(network)
if err != nil {
return fmt.Errorf("Failed to parse network CIDR in config, %v", err)
}
if localIP.To4() == nil {
return fmt.Errorf("Provided network(%s) is not a valid IPv4 address", network)
}
code2 := make([]byte, 0, 12)
code2 = append(code2, localIP.To4()[:4]...)
code2 = append(code2, remoteNet.IP.To4()[:4]...)
code2 = append(code2, remoteNet.Mask[:4]...)
if len(code2) != 12 {
return fmt.Errorf("Provided network(%s) is not valid", network)
}
if err := syscall.DeviceIoControl(fd, tap_ioctl_config_tun, &code2[0], uint32(12), &rdbbuf[0], uint32(len(rdbbuf)), &bytesReturned, nil); err != nil {
return err
}
return nil
} | go | func setTUN(fd syscall.Handle, network string) error {
var bytesReturned uint32
rdbbuf := make([]byte, syscall.MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
localIP, remoteNet, err := net.ParseCIDR(network)
if err != nil {
return fmt.Errorf("Failed to parse network CIDR in config, %v", err)
}
if localIP.To4() == nil {
return fmt.Errorf("Provided network(%s) is not a valid IPv4 address", network)
}
code2 := make([]byte, 0, 12)
code2 = append(code2, localIP.To4()[:4]...)
code2 = append(code2, remoteNet.IP.To4()[:4]...)
code2 = append(code2, remoteNet.Mask[:4]...)
if len(code2) != 12 {
return fmt.Errorf("Provided network(%s) is not valid", network)
}
if err := syscall.DeviceIoControl(fd, tap_ioctl_config_tun, &code2[0], uint32(12), &rdbbuf[0], uint32(len(rdbbuf)), &bytesReturned, nil); err != nil {
return err
}
return nil
} | [
"func",
"setTUN",
"(",
"fd",
"syscall",
".",
"Handle",
",",
"network",
"string",
")",
"error",
"{",
"var",
"bytesReturned",
"uint32",
"\n",
"rdbbuf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"syscall",
".",
"MAXIMUM_REPARSE_DATA_BUFFER_SIZE",
")",
"\n",
"... | // setTUN is used to configure the IP address in the underlying driver when using TUN | [
"setTUN",
"is",
"used",
"to",
"configure",
"the",
"IP",
"address",
"in",
"the",
"underlying",
"driver",
"when",
"using",
"TUN"
] | 6ad6edefb15c9ffe418e722c13459ab16a545d2b | https://github.com/songgao/water/blob/6ad6edefb15c9ffe418e722c13459ab16a545d2b/syscalls_windows.go#L211-L233 | train |
songgao/water | syscalls_windows.go | openDev | func openDev(config Config) (ifce *Interface, err error) {
// find the device in registry.
deviceid, err := getdeviceid(config.PlatformSpecificParams.ComponentID, config.PlatformSpecificParams.InterfaceName)
if err != nil {
return nil, err
}
path := "\\\\.\\Global\\" + deviceid + ".tap"
pathp, err := syscall.UTF16PtrFromString(path)
if err != nil {
return nil, err
}
// type Handle uintptr
file, err := syscall.CreateFile(pathp, syscall.GENERIC_READ|syscall.GENERIC_WRITE, uint32(syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE), nil, syscall.OPEN_EXISTING, syscall.FILE_ATTRIBUTE_SYSTEM|syscall.FILE_FLAG_OVERLAPPED, 0)
// if err hanppens, close the interface.
defer func() {
if err != nil {
syscall.Close(file)
}
if err := recover(); err != nil {
syscall.Close(file)
}
}()
if err != nil {
return nil, err
}
var bytesReturned uint32
// find the mac address of tap device, use this to find the name of interface
mac := make([]byte, 6)
err = syscall.DeviceIoControl(file, tap_win_ioctl_get_mac, &mac[0], uint32(len(mac)), &mac[0], uint32(len(mac)), &bytesReturned, nil)
if err != nil {
return nil, err
}
// fd := os.NewFile(uintptr(file), path)
ro, err := newOverlapped()
if err != nil {
return
}
wo, err := newOverlapped()
if err != nil {
return
}
fd := &wfile{fd: file, ro: ro, wo: wo}
ifce = &Interface{isTAP: (config.DeviceType == TAP), ReadWriteCloser: fd}
// bring up device.
if err := setStatus(file, true); err != nil {
return nil, err
}
//TUN
if config.DeviceType == TUN {
if err := setTUN(file, config.PlatformSpecificParams.Network); err != nil {
return nil, err
}
}
// find the name of tap interface(u need it to set the ip or other command)
ifces, err := net.Interfaces()
if err != nil {
return
}
for _, v := range ifces {
if bytes.Equal(v.HardwareAddr[:6], mac[:6]) {
ifce.name = v.Name
return
}
}
return nil, errIfceNameNotFound
} | go | func openDev(config Config) (ifce *Interface, err error) {
// find the device in registry.
deviceid, err := getdeviceid(config.PlatformSpecificParams.ComponentID, config.PlatformSpecificParams.InterfaceName)
if err != nil {
return nil, err
}
path := "\\\\.\\Global\\" + deviceid + ".tap"
pathp, err := syscall.UTF16PtrFromString(path)
if err != nil {
return nil, err
}
// type Handle uintptr
file, err := syscall.CreateFile(pathp, syscall.GENERIC_READ|syscall.GENERIC_WRITE, uint32(syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE), nil, syscall.OPEN_EXISTING, syscall.FILE_ATTRIBUTE_SYSTEM|syscall.FILE_FLAG_OVERLAPPED, 0)
// if err hanppens, close the interface.
defer func() {
if err != nil {
syscall.Close(file)
}
if err := recover(); err != nil {
syscall.Close(file)
}
}()
if err != nil {
return nil, err
}
var bytesReturned uint32
// find the mac address of tap device, use this to find the name of interface
mac := make([]byte, 6)
err = syscall.DeviceIoControl(file, tap_win_ioctl_get_mac, &mac[0], uint32(len(mac)), &mac[0], uint32(len(mac)), &bytesReturned, nil)
if err != nil {
return nil, err
}
// fd := os.NewFile(uintptr(file), path)
ro, err := newOverlapped()
if err != nil {
return
}
wo, err := newOverlapped()
if err != nil {
return
}
fd := &wfile{fd: file, ro: ro, wo: wo}
ifce = &Interface{isTAP: (config.DeviceType == TAP), ReadWriteCloser: fd}
// bring up device.
if err := setStatus(file, true); err != nil {
return nil, err
}
//TUN
if config.DeviceType == TUN {
if err := setTUN(file, config.PlatformSpecificParams.Network); err != nil {
return nil, err
}
}
// find the name of tap interface(u need it to set the ip or other command)
ifces, err := net.Interfaces()
if err != nil {
return
}
for _, v := range ifces {
if bytes.Equal(v.HardwareAddr[:6], mac[:6]) {
ifce.name = v.Name
return
}
}
return nil, errIfceNameNotFound
} | [
"func",
"openDev",
"(",
"config",
"Config",
")",
"(",
"ifce",
"*",
"Interface",
",",
"err",
"error",
")",
"{",
"deviceid",
",",
"err",
":=",
"getdeviceid",
"(",
"config",
".",
"PlatformSpecificParams",
".",
"ComponentID",
",",
"config",
".",
"PlatformSpecifi... | // openDev find and open an interface. | [
"openDev",
"find",
"and",
"open",
"an",
"interface",
"."
] | 6ad6edefb15c9ffe418e722c13459ab16a545d2b | https://github.com/songgao/water/blob/6ad6edefb15c9ffe418e722c13459ab16a545d2b/syscalls_windows.go#L236-L308 | train |
hprose/hprose-golang | rpc/hd_socket_trans.go | SetMaxPoolSize | func (hd *halfDuplexSocketTransport) SetMaxPoolSize(size int) {
if size > 0 {
pool := make(chan *halfDuplexConnEntry, size)
for i := 0; i < len(hd.connPool); i++ {
select {
case pool <- <-hd.connPool:
default:
}
}
hd.connPool = pool
}
} | go | func (hd *halfDuplexSocketTransport) SetMaxPoolSize(size int) {
if size > 0 {
pool := make(chan *halfDuplexConnEntry, size)
for i := 0; i < len(hd.connPool); i++ {
select {
case pool <- <-hd.connPool:
default:
}
}
hd.connPool = pool
}
} | [
"func",
"(",
"hd",
"*",
"halfDuplexSocketTransport",
")",
"SetMaxPoolSize",
"(",
"size",
"int",
")",
"{",
"if",
"size",
">",
"0",
"{",
"pool",
":=",
"make",
"(",
"chan",
"*",
"halfDuplexConnEntry",
",",
"size",
")",
"\n",
"for",
"i",
":=",
"0",
";",
... | // SetMaxPoolSize sets the max conn pool size of hprose socket client | [
"SetMaxPoolSize",
"sets",
"the",
"max",
"conn",
"pool",
"size",
"of",
"hprose",
"socket",
"client"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/hd_socket_trans.go#L74-L85 | train |
hprose/hprose-golang | rpc/websocket/websocket_client.go | NewWebSocketClient | func NewWebSocketClient(uri ...string) (client *WebSocketClient) {
client = new(WebSocketClient)
client.InitBaseClient()
client.limiter.InitLimiter()
client.closed = false
client.SetURIList(uri)
client.SendAndReceive = client.sendAndReceive
return
} | go | func NewWebSocketClient(uri ...string) (client *WebSocketClient) {
client = new(WebSocketClient)
client.InitBaseClient()
client.limiter.InitLimiter()
client.closed = false
client.SetURIList(uri)
client.SendAndReceive = client.sendAndReceive
return
} | [
"func",
"NewWebSocketClient",
"(",
"uri",
"...",
"string",
")",
"(",
"client",
"*",
"WebSocketClient",
")",
"{",
"client",
"=",
"new",
"(",
"WebSocketClient",
")",
"\n",
"client",
".",
"InitBaseClient",
"(",
")",
"\n",
"client",
".",
"limiter",
".",
"InitL... | // NewWebSocketClient is the constructor of WebSocketClient | [
"NewWebSocketClient",
"is",
"the",
"constructor",
"of",
"WebSocketClient"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/websocket/websocket_client.go#L59-L67 | train |
hprose/hprose-golang | rpc/websocket/websocket_client.go | Close | func (client *WebSocketClient) Close() {
client.closed = true
client.close(rpc.ErrClientIsAlreadyClosed)
} | go | func (client *WebSocketClient) Close() {
client.closed = true
client.close(rpc.ErrClientIsAlreadyClosed)
} | [
"func",
"(",
"client",
"*",
"WebSocketClient",
")",
"Close",
"(",
")",
"{",
"client",
".",
"closed",
"=",
"true",
"\n",
"client",
".",
"close",
"(",
"rpc",
".",
"ErrClientIsAlreadyClosed",
")",
"\n",
"}"
] | // Close the client | [
"Close",
"the",
"client"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/websocket/websocket_client.go#L98-L101 | train |
hprose/hprose-golang | rpc/handler.go | AddInvokeHandler | func (hm *handlerManager) AddInvokeHandler(handler ...InvokeHandler) {
if len(handler) == 0 {
return
}
hm.invokeHandlers = append(hm.invokeHandlers, handler...)
next := hm.defaultInvokeHandler
for i := len(hm.invokeHandlers) - 1; i >= 0; i-- {
next = getNextInvokeHandler(next, hm.invokeHandlers[i])
}
hm.invokeHandler = next
} | go | func (hm *handlerManager) AddInvokeHandler(handler ...InvokeHandler) {
if len(handler) == 0 {
return
}
hm.invokeHandlers = append(hm.invokeHandlers, handler...)
next := hm.defaultInvokeHandler
for i := len(hm.invokeHandlers) - 1; i >= 0; i-- {
next = getNextInvokeHandler(next, hm.invokeHandlers[i])
}
hm.invokeHandler = next
} | [
"func",
"(",
"hm",
"*",
"handlerManager",
")",
"AddInvokeHandler",
"(",
"handler",
"...",
"InvokeHandler",
")",
"{",
"if",
"len",
"(",
"handler",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"hm",
".",
"invokeHandlers",
"=",
"append",
"(",
"hm",
"."... | // AddInvokeHandler add the invoke handler | [
"AddInvokeHandler",
"add",
"the",
"invoke",
"handler"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/handler.go#L142-L152 | train |
hprose/hprose-golang | io/writer.go | NewWriter | func NewWriter(simple bool, buf ...byte) (w *Writer) {
w = new(Writer)
w.buf = buf
w.Simple = simple
return
} | go | func NewWriter(simple bool, buf ...byte) (w *Writer) {
w = new(Writer)
w.buf = buf
w.Simple = simple
return
} | [
"func",
"NewWriter",
"(",
"simple",
"bool",
",",
"buf",
"...",
"byte",
")",
"(",
"w",
"*",
"Writer",
")",
"{",
"w",
"=",
"new",
"(",
"Writer",
")",
"\n",
"w",
".",
"buf",
"=",
"buf",
"\n",
"w",
".",
"Simple",
"=",
"simple",
"\n",
"return",
"\n"... | // NewWriter is the constructor for Hprose Writer | [
"NewWriter",
"is",
"the",
"constructor",
"for",
"Hprose",
"Writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L45-L50 | train |
hprose/hprose-golang | io/writer.go | Serialize | func (w *Writer) Serialize(v interface{}) *Writer {
if v == nil {
w.WriteNil()
} else if rv, ok := v.(reflect.Value); ok {
w.WriteValue(rv)
} else {
w.WriteValue(reflect.ValueOf(v))
}
return w
} | go | func (w *Writer) Serialize(v interface{}) *Writer {
if v == nil {
w.WriteNil()
} else if rv, ok := v.(reflect.Value); ok {
w.WriteValue(rv)
} else {
w.WriteValue(reflect.ValueOf(v))
}
return w
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Serialize",
"(",
"v",
"interface",
"{",
"}",
")",
"*",
"Writer",
"{",
"if",
"v",
"==",
"nil",
"{",
"w",
".",
"WriteNil",
"(",
")",
"\n",
"}",
"else",
"if",
"rv",
",",
"ok",
":=",
"v",
".",
"(",
"reflect"... | // Serialize a data v to the writer | [
"Serialize",
"a",
"data",
"v",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L53-L62 | train |
hprose/hprose-golang | io/writer.go | WriteValue | func (w *Writer) WriteValue(v reflect.Value) {
valueEncoders[v.Kind()](w, v)
} | go | func (w *Writer) WriteValue(v reflect.Value) {
valueEncoders[v.Kind()](w, v)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteValue",
"(",
"v",
"reflect",
".",
"Value",
")",
"{",
"valueEncoders",
"[",
"v",
".",
"Kind",
"(",
")",
"]",
"(",
"w",
",",
"v",
")",
"\n",
"}"
] | // WriteValue to the writer | [
"WriteValue",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L65-L67 | train |
hprose/hprose-golang | io/writer.go | WriteBool | func (w *Writer) WriteBool(b bool) {
if b {
w.writeByte(TagTrue)
} else {
w.writeByte(TagFalse)
}
} | go | func (w *Writer) WriteBool(b bool) {
if b {
w.writeByte(TagTrue)
} else {
w.writeByte(TagFalse)
}
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteBool",
"(",
"b",
"bool",
")",
"{",
"if",
"b",
"{",
"w",
".",
"writeByte",
"(",
"TagTrue",
")",
"\n",
"}",
"else",
"{",
"w",
".",
"writeByte",
"(",
"TagFalse",
")",
"\n",
"}",
"\n",
"}"
] | // WriteBool to the writer | [
"WriteBool",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L75-L81 | train |
hprose/hprose-golang | io/writer.go | WriteInt | func (w *Writer) WriteInt(i int64) {
if i >= 0 && i <= 9 {
w.writeByte(byte('0' + i))
return
}
if i >= math.MinInt32 && i <= math.MaxInt32 {
w.writeByte(TagInteger)
} else {
w.writeByte(TagLong)
}
var buf [20]byte
w.write(util.GetIntBytes(buf[:], i))
w.writeByte(TagSemicolon)
} | go | func (w *Writer) WriteInt(i int64) {
if i >= 0 && i <= 9 {
w.writeByte(byte('0' + i))
return
}
if i >= math.MinInt32 && i <= math.MaxInt32 {
w.writeByte(TagInteger)
} else {
w.writeByte(TagLong)
}
var buf [20]byte
w.write(util.GetIntBytes(buf[:], i))
w.writeByte(TagSemicolon)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteInt",
"(",
"i",
"int64",
")",
"{",
"if",
"i",
">=",
"0",
"&&",
"i",
"<=",
"9",
"{",
"w",
".",
"writeByte",
"(",
"byte",
"(",
"'0'",
"+",
"i",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"i",
... | // WriteInt to the writer | [
"WriteInt",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L84-L97 | train |
hprose/hprose-golang | io/writer.go | WriteUint | func (w *Writer) WriteUint(i uint64) {
if i <= 9 {
w.writeByte(byte('0' + i))
return
}
if i <= math.MaxInt32 {
w.writeByte(TagInteger)
} else {
w.writeByte(TagLong)
}
var buf [20]byte
w.write(util.GetUintBytes(buf[:], i))
w.writeByte(TagSemicolon)
} | go | func (w *Writer) WriteUint(i uint64) {
if i <= 9 {
w.writeByte(byte('0' + i))
return
}
if i <= math.MaxInt32 {
w.writeByte(TagInteger)
} else {
w.writeByte(TagLong)
}
var buf [20]byte
w.write(util.GetUintBytes(buf[:], i))
w.writeByte(TagSemicolon)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteUint",
"(",
"i",
"uint64",
")",
"{",
"if",
"i",
"<=",
"9",
"{",
"w",
".",
"writeByte",
"(",
"byte",
"(",
"'0'",
"+",
"i",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"i",
"<=",
"math",
".",
"... | // WriteUint to the writer | [
"WriteUint",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L100-L113 | train |
hprose/hprose-golang | io/writer.go | WriteFloat | func (w *Writer) WriteFloat(f float64, bitSize int) {
if f != f {
w.writeByte(TagNaN)
return
}
if f > math.MaxFloat64 {
w.write([]byte{TagInfinity, TagPos})
return
}
if f < -math.MaxFloat64 {
w.write([]byte{TagInfinity, TagNeg})
return
}
w.writeByte(TagDouble)
var buf [64]byte
w.write(strconv.AppendFloat(buf[:0], f, 'g', -1, bitSize))
w.writeByte(TagSemicolon)
} | go | func (w *Writer) WriteFloat(f float64, bitSize int) {
if f != f {
w.writeByte(TagNaN)
return
}
if f > math.MaxFloat64 {
w.write([]byte{TagInfinity, TagPos})
return
}
if f < -math.MaxFloat64 {
w.write([]byte{TagInfinity, TagNeg})
return
}
w.writeByte(TagDouble)
var buf [64]byte
w.write(strconv.AppendFloat(buf[:0], f, 'g', -1, bitSize))
w.writeByte(TagSemicolon)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteFloat",
"(",
"f",
"float64",
",",
"bitSize",
"int",
")",
"{",
"if",
"f",
"!=",
"f",
"{",
"w",
".",
"writeByte",
"(",
"TagNaN",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"f",
">",
"math",
".",
"MaxFl... | // WriteFloat to the writer | [
"WriteFloat",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L116-L133 | train |
hprose/hprose-golang | io/writer.go | WriteComplex64 | func (w *Writer) WriteComplex64(c complex64) {
if imag(c) == 0 {
w.WriteFloat(float64(real(c)), 32)
return
}
setWriterRef(w, nil, nil)
writeListHeader(w, 2)
w.WriteFloat(float64(real(c)), 32)
w.WriteFloat(float64(imag(c)), 32)
writeListFooter(w)
} | go | func (w *Writer) WriteComplex64(c complex64) {
if imag(c) == 0 {
w.WriteFloat(float64(real(c)), 32)
return
}
setWriterRef(w, nil, nil)
writeListHeader(w, 2)
w.WriteFloat(float64(real(c)), 32)
w.WriteFloat(float64(imag(c)), 32)
writeListFooter(w)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteComplex64",
"(",
"c",
"complex64",
")",
"{",
"if",
"imag",
"(",
"c",
")",
"==",
"0",
"{",
"w",
".",
"WriteFloat",
"(",
"float64",
"(",
"real",
"(",
"c",
")",
")",
",",
"32",
")",
"\n",
"return",
"\n",... | // WriteComplex64 to the writer | [
"WriteComplex64",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L136-L146 | train |
hprose/hprose-golang | io/writer.go | WriteComplex128 | func (w *Writer) WriteComplex128(c complex128) {
if imag(c) == 0 {
w.WriteFloat(real(c), 64)
return
}
setWriterRef(w, nil, nil)
writeListHeader(w, 2)
w.WriteFloat(real(c), 64)
w.WriteFloat(imag(c), 64)
writeListFooter(w)
} | go | func (w *Writer) WriteComplex128(c complex128) {
if imag(c) == 0 {
w.WriteFloat(real(c), 64)
return
}
setWriterRef(w, nil, nil)
writeListHeader(w, 2)
w.WriteFloat(real(c), 64)
w.WriteFloat(imag(c), 64)
writeListFooter(w)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteComplex128",
"(",
"c",
"complex128",
")",
"{",
"if",
"imag",
"(",
"c",
")",
"==",
"0",
"{",
"w",
".",
"WriteFloat",
"(",
"real",
"(",
"c",
")",
",",
"64",
")",
"\n",
"return",
"\n",
"}",
"\n",
"setWri... | // WriteComplex128 to the writer | [
"WriteComplex128",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L149-L159 | train |
hprose/hprose-golang | io/writer.go | WriteString | func (w *Writer) WriteString(str string) {
length := util.UTF16Length(str)
switch {
case length == 0:
w.writeByte(TagEmpty)
case length < 0:
w.WriteBytes(*(*[]byte)(unsafe.Pointer(&str)))
case length == 1:
w.writeByte(TagUTF8Char)
w.writeString(str)
default:
setWriterRef(w, nil, nil)
writeString(w, str, length)
}
} | go | func (w *Writer) WriteString(str string) {
length := util.UTF16Length(str)
switch {
case length == 0:
w.writeByte(TagEmpty)
case length < 0:
w.WriteBytes(*(*[]byte)(unsafe.Pointer(&str)))
case length == 1:
w.writeByte(TagUTF8Char)
w.writeString(str)
default:
setWriterRef(w, nil, nil)
writeString(w, str, length)
}
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteString",
"(",
"str",
"string",
")",
"{",
"length",
":=",
"util",
".",
"UTF16Length",
"(",
"str",
")",
"\n",
"switch",
"{",
"case",
"length",
"==",
"0",
":",
"w",
".",
"writeByte",
"(",
"TagEmpty",
")",
"\... | // WriteString to the writer | [
"WriteString",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L162-L176 | train |
hprose/hprose-golang | io/writer.go | WriteBytes | func (w *Writer) WriteBytes(bytes []byte) {
setWriterRef(w, nil, nil)
writeBytes(w, bytes)
} | go | func (w *Writer) WriteBytes(bytes []byte) {
setWriterRef(w, nil, nil)
writeBytes(w, bytes)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteBytes",
"(",
"bytes",
"[",
"]",
"byte",
")",
"{",
"setWriterRef",
"(",
"w",
",",
"nil",
",",
"nil",
")",
"\n",
"writeBytes",
"(",
"w",
",",
"bytes",
")",
"\n",
"}"
] | // WriteBytes to the writer | [
"WriteBytes",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L179-L182 | train |
hprose/hprose-golang | io/writer.go | WriteBigInt | func (w *Writer) WriteBigInt(bi *big.Int) {
w.writeByte(TagLong)
w.writeString(bi.String())
w.writeByte(TagSemicolon)
} | go | func (w *Writer) WriteBigInt(bi *big.Int) {
w.writeByte(TagLong)
w.writeString(bi.String())
w.writeByte(TagSemicolon)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteBigInt",
"(",
"bi",
"*",
"big",
".",
"Int",
")",
"{",
"w",
".",
"writeByte",
"(",
"TagLong",
")",
"\n",
"w",
".",
"writeString",
"(",
"bi",
".",
"String",
"(",
")",
")",
"\n",
"w",
".",
"writeByte",
"... | // WriteBigInt to the writer | [
"WriteBigInt",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L185-L189 | train |
hprose/hprose-golang | io/writer.go | WriteBigRat | func (w *Writer) WriteBigRat(br *big.Rat) {
if br.IsInt() {
w.WriteBigInt(br.Num())
} else {
str := br.String()
setWriterRef(w, nil, nil)
writeString(w, str, len(str))
}
} | go | func (w *Writer) WriteBigRat(br *big.Rat) {
if br.IsInt() {
w.WriteBigInt(br.Num())
} else {
str := br.String()
setWriterRef(w, nil, nil)
writeString(w, str, len(str))
}
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteBigRat",
"(",
"br",
"*",
"big",
".",
"Rat",
")",
"{",
"if",
"br",
".",
"IsInt",
"(",
")",
"{",
"w",
".",
"WriteBigInt",
"(",
"br",
".",
"Num",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"str",
":=",
"... | // WriteBigRat to the writer | [
"WriteBigRat",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L192-L200 | train |
hprose/hprose-golang | io/writer.go | WriteBigFloat | func (w *Writer) WriteBigFloat(bf *big.Float) {
w.writeByte(TagDouble)
var buf [64]byte
w.write(bf.Append(buf[:0], 'g', -1))
w.writeByte(TagSemicolon)
} | go | func (w *Writer) WriteBigFloat(bf *big.Float) {
w.writeByte(TagDouble)
var buf [64]byte
w.write(bf.Append(buf[:0], 'g', -1))
w.writeByte(TagSemicolon)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteBigFloat",
"(",
"bf",
"*",
"big",
".",
"Float",
")",
"{",
"w",
".",
"writeByte",
"(",
"TagDouble",
")",
"\n",
"var",
"buf",
"[",
"64",
"]",
"byte",
"\n",
"w",
".",
"write",
"(",
"bf",
".",
"Append",
"... | // WriteBigFloat to the writer | [
"WriteBigFloat",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L203-L208 | train |
hprose/hprose-golang | io/writer.go | WriteTime | func (w *Writer) WriteTime(t *time.Time) {
ptr := unsafe.Pointer(t)
typ := reflect.TypeOf(t)
if writeRef(w, ptr, typ) {
return
}
setWriterRef(w, ptr, typ)
year, month, day := t.Date()
hour, min, sec := t.Clock()
nsec := t.Nanosecond()
buf := make([]byte, 9)
if hour == 0 && min == 0 && sec == 0 && nsec == 0 {
writeDate(w, buf, year, int(month), day)
} else if year == 1970 && month == 1 && day == 1 {
writeTime(w, buf, hour, min, sec, nsec)
} else {
writeDate(w, buf, year, int(month), day)
writeTime(w, buf, hour, min, sec, nsec)
}
loc := TagSemicolon
if t.Location() == time.UTC {
loc = TagUTC
}
w.writeByte(loc)
} | go | func (w *Writer) WriteTime(t *time.Time) {
ptr := unsafe.Pointer(t)
typ := reflect.TypeOf(t)
if writeRef(w, ptr, typ) {
return
}
setWriterRef(w, ptr, typ)
year, month, day := t.Date()
hour, min, sec := t.Clock()
nsec := t.Nanosecond()
buf := make([]byte, 9)
if hour == 0 && min == 0 && sec == 0 && nsec == 0 {
writeDate(w, buf, year, int(month), day)
} else if year == 1970 && month == 1 && day == 1 {
writeTime(w, buf, hour, min, sec, nsec)
} else {
writeDate(w, buf, year, int(month), day)
writeTime(w, buf, hour, min, sec, nsec)
}
loc := TagSemicolon
if t.Location() == time.UTC {
loc = TagUTC
}
w.writeByte(loc)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteTime",
"(",
"t",
"*",
"time",
".",
"Time",
")",
"{",
"ptr",
":=",
"unsafe",
".",
"Pointer",
"(",
"t",
")",
"\n",
"typ",
":=",
"reflect",
".",
"TypeOf",
"(",
"t",
")",
"\n",
"if",
"writeRef",
"(",
"w",... | // WriteTime to the writer | [
"WriteTime",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L225-L249 | train |
hprose/hprose-golang | io/writer.go | WriteList | func (w *Writer) WriteList(lst *list.List) {
ptr := unsafe.Pointer(lst)
typ := reflect.TypeOf(lst)
if writeRef(w, ptr, typ) {
return
}
setWriterRef(w, ptr, typ)
count := lst.Len()
if count == 0 {
writeEmptyList(w)
return
}
writeListHeader(w, count)
for e := lst.Front(); e != nil; e = e.Next() {
w.Serialize(e.Value)
}
writeListFooter(w)
} | go | func (w *Writer) WriteList(lst *list.List) {
ptr := unsafe.Pointer(lst)
typ := reflect.TypeOf(lst)
if writeRef(w, ptr, typ) {
return
}
setWriterRef(w, ptr, typ)
count := lst.Len()
if count == 0 {
writeEmptyList(w)
return
}
writeListHeader(w, count)
for e := lst.Front(); e != nil; e = e.Next() {
w.Serialize(e.Value)
}
writeListFooter(w)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteList",
"(",
"lst",
"*",
"list",
".",
"List",
")",
"{",
"ptr",
":=",
"unsafe",
".",
"Pointer",
"(",
"lst",
")",
"\n",
"typ",
":=",
"reflect",
".",
"TypeOf",
"(",
"lst",
")",
"\n",
"if",
"writeRef",
"(",
... | // WriteList to the writer | [
"WriteList",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L252-L269 | train |
hprose/hprose-golang | io/writer.go | WriteTuple | func (w *Writer) WriteTuple(tuple ...interface{}) {
setWriterRef(w, nil, nil)
count := len(tuple)
if count == 0 {
writeEmptyList(w)
return
}
writeListHeader(w, count)
for _, v := range tuple {
w.Serialize(v)
}
writeListFooter(w)
} | go | func (w *Writer) WriteTuple(tuple ...interface{}) {
setWriterRef(w, nil, nil)
count := len(tuple)
if count == 0 {
writeEmptyList(w)
return
}
writeListHeader(w, count)
for _, v := range tuple {
w.Serialize(v)
}
writeListFooter(w)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteTuple",
"(",
"tuple",
"...",
"interface",
"{",
"}",
")",
"{",
"setWriterRef",
"(",
"w",
",",
"nil",
",",
"nil",
")",
"\n",
"count",
":=",
"len",
"(",
"tuple",
")",
"\n",
"if",
"count",
"==",
"0",
"{",
... | // WriteTuple to the writer | [
"WriteTuple",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L272-L284 | train |
hprose/hprose-golang | io/writer.go | WriteSlice | func (w *Writer) WriteSlice(slice []reflect.Value) {
setWriterRef(w, nil, nil)
count := len(slice)
if count == 0 {
writeEmptyList(w)
return
}
writeListHeader(w, count)
for i := range slice {
w.WriteValue(slice[i])
}
writeListFooter(w)
} | go | func (w *Writer) WriteSlice(slice []reflect.Value) {
setWriterRef(w, nil, nil)
count := len(slice)
if count == 0 {
writeEmptyList(w)
return
}
writeListHeader(w, count)
for i := range slice {
w.WriteValue(slice[i])
}
writeListFooter(w)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteSlice",
"(",
"slice",
"[",
"]",
"reflect",
".",
"Value",
")",
"{",
"setWriterRef",
"(",
"w",
",",
"nil",
",",
"nil",
")",
"\n",
"count",
":=",
"len",
"(",
"slice",
")",
"\n",
"if",
"count",
"==",
"0",
... | // WriteSlice to the writer | [
"WriteSlice",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L287-L299 | train |
hprose/hprose-golang | io/writer.go | WriteStringSlice | func (w *Writer) WriteStringSlice(slice []string) {
setWriterRef(w, nil, nil)
count := len(slice)
if count == 0 {
writeEmptyList(w)
return
}
writeListHeader(w, count)
stringSliceEncoder(w, slice)
writeListFooter(w)
} | go | func (w *Writer) WriteStringSlice(slice []string) {
setWriterRef(w, nil, nil)
count := len(slice)
if count == 0 {
writeEmptyList(w)
return
}
writeListHeader(w, count)
stringSliceEncoder(w, slice)
writeListFooter(w)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteStringSlice",
"(",
"slice",
"[",
"]",
"string",
")",
"{",
"setWriterRef",
"(",
"w",
",",
"nil",
",",
"nil",
")",
"\n",
"count",
":=",
"len",
"(",
"slice",
")",
"\n",
"if",
"count",
"==",
"0",
"{",
"writ... | // WriteStringSlice to the writer | [
"WriteStringSlice",
"to",
"the",
"writer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/writer.go#L302-L312 | train |
hprose/hprose-golang | rpc/tcp_server.go | NewTCPServer | func NewTCPServer(uri string) (server *TCPServer) {
if uri == "" {
uri = "tcp://127.0.0.1:0"
}
server = new(TCPServer)
server.initTCPService()
server.starter.server = server
server.uri = uri
return
} | go | func NewTCPServer(uri string) (server *TCPServer) {
if uri == "" {
uri = "tcp://127.0.0.1:0"
}
server = new(TCPServer)
server.initTCPService()
server.starter.server = server
server.uri = uri
return
} | [
"func",
"NewTCPServer",
"(",
"uri",
"string",
")",
"(",
"server",
"*",
"TCPServer",
")",
"{",
"if",
"uri",
"==",
"\"\"",
"{",
"uri",
"=",
"\"tcp://127.0.0.1:0\"",
"\n",
"}",
"\n",
"server",
"=",
"new",
"(",
"TCPServer",
")",
"\n",
"server",
".",
"initT... | // NewTCPServer is the constructor for TCPServer | [
"NewTCPServer",
"is",
"the",
"constructor",
"for",
"TCPServer"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/tcp_server.go#L36-L45 | train |
hprose/hprose-golang | rpc/tcp_server.go | Handle | func (server *TCPServer) Handle() (err error) {
if server.listener != nil {
return ErrServerIsAlreadyStarted
}
u, err := url.Parse(server.uri)
if err != nil {
return err
}
addr, err := net.ResolveTCPAddr(u.Scheme, u.Host)
if err != nil {
return err
}
if server.listener, err = net.ListenTCP(u.Scheme, addr); err != nil {
return err
}
go server.ServeTCP(server.listener)
return nil
} | go | func (server *TCPServer) Handle() (err error) {
if server.listener != nil {
return ErrServerIsAlreadyStarted
}
u, err := url.Parse(server.uri)
if err != nil {
return err
}
addr, err := net.ResolveTCPAddr(u.Scheme, u.Host)
if err != nil {
return err
}
if server.listener, err = net.ListenTCP(u.Scheme, addr); err != nil {
return err
}
go server.ServeTCP(server.listener)
return nil
} | [
"func",
"(",
"server",
"*",
"TCPServer",
")",
"Handle",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"server",
".",
"listener",
"!=",
"nil",
"{",
"return",
"ErrServerIsAlreadyStarted",
"\n",
"}",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(... | // Handle the hprose tcp server | [
"Handle",
"the",
"hprose",
"tcp",
"server"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/tcp_server.go#L60-L77 | train |
hprose/hprose-golang | rpc/tcp_server.go | Close | func (server *TCPServer) Close() {
if server.listener != nil {
listener := server.listener
server.listener = nil
listener.Close()
}
} | go | func (server *TCPServer) Close() {
if server.listener != nil {
listener := server.listener
server.listener = nil
listener.Close()
}
} | [
"func",
"(",
"server",
"*",
"TCPServer",
")",
"Close",
"(",
")",
"{",
"if",
"server",
".",
"listener",
"!=",
"nil",
"{",
"listener",
":=",
"server",
".",
"listener",
"\n",
"server",
".",
"listener",
"=",
"nil",
"\n",
"listener",
".",
"Close",
"(",
")... | // Close the hprose tcp server | [
"Close",
"the",
"hprose",
"tcp",
"server"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/tcp_server.go#L80-L86 | train |
hprose/hprose-golang | rpc/base_service.go | DefaultFixArguments | func DefaultFixArguments(args []reflect.Value, context ServiceContext) {
i := len(args) - 1
typ := args[i].Type()
if typ == interfaceType || typ == contextType || typ == serviceContextType {
args[i] = reflect.ValueOf(context)
}
} | go | func DefaultFixArguments(args []reflect.Value, context ServiceContext) {
i := len(args) - 1
typ := args[i].Type()
if typ == interfaceType || typ == contextType || typ == serviceContextType {
args[i] = reflect.ValueOf(context)
}
} | [
"func",
"DefaultFixArguments",
"(",
"args",
"[",
"]",
"reflect",
".",
"Value",
",",
"context",
"ServiceContext",
")",
"{",
"i",
":=",
"len",
"(",
"args",
")",
"-",
"1",
"\n",
"typ",
":=",
"args",
"[",
"i",
"]",
".",
"Type",
"(",
")",
"\n",
"if",
... | // DefaultFixArguments is the default FixArguments function | [
"DefaultFixArguments",
"is",
"the",
"default",
"FixArguments",
"function"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L51-L57 | train |
hprose/hprose-golang | rpc/base_service.go | InitBaseService | func (service *BaseService) InitBaseService() {
service.initMethodManager()
service.initHandlerManager()
service.Timeout = 120 * time.Second
service.Heartbeat = 3 * time.Second
service.ErrorDelay = 10 * time.Second
service.topics = make(map[string]*topic)
service.AddFunction("#", util.UUIDv4, Options{Simple: true})
service.override.invokeHandler = func(
name string, args []reflect.Value,
context Context) (results []reflect.Value, err error) {
return invoke(name, args, context.(ServiceContext))
}
service.override.beforeFilterHandler = func(
request []byte, context Context) (response []byte, err error) {
return service.beforeFilter(request, context.(ServiceContext))
}
service.override.afterFilterHandler = func(
request []byte, context Context) (response []byte, err error) {
return service.afterFilter(request, context.(ServiceContext))
}
} | go | func (service *BaseService) InitBaseService() {
service.initMethodManager()
service.initHandlerManager()
service.Timeout = 120 * time.Second
service.Heartbeat = 3 * time.Second
service.ErrorDelay = 10 * time.Second
service.topics = make(map[string]*topic)
service.AddFunction("#", util.UUIDv4, Options{Simple: true})
service.override.invokeHandler = func(
name string, args []reflect.Value,
context Context) (results []reflect.Value, err error) {
return invoke(name, args, context.(ServiceContext))
}
service.override.beforeFilterHandler = func(
request []byte, context Context) (response []byte, err error) {
return service.beforeFilter(request, context.(ServiceContext))
}
service.override.afterFilterHandler = func(
request []byte, context Context) (response []byte, err error) {
return service.afterFilter(request, context.(ServiceContext))
}
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"InitBaseService",
"(",
")",
"{",
"service",
".",
"initMethodManager",
"(",
")",
"\n",
"service",
".",
"initHandlerManager",
"(",
")",
"\n",
"service",
".",
"Timeout",
"=",
"120",
"*",
"time",
".",
"Second",... | // InitBaseService initializes BaseService | [
"InitBaseService",
"initializes",
"BaseService"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L60-L81 | train |
hprose/hprose-golang | rpc/base_service.go | AddFunction | func (service *BaseService) AddFunction(name string, function interface{}, option ...Options) Service {
service.methodManager.AddFunction(name, function, option...)
return service
} | go | func (service *BaseService) AddFunction(name string, function interface{}, option ...Options) Service {
service.methodManager.AddFunction(name, function, option...)
return service
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"AddFunction",
"(",
"name",
"string",
",",
"function",
"interface",
"{",
"}",
",",
"option",
"...",
"Options",
")",
"Service",
"{",
"service",
".",
"methodManager",
".",
"AddFunction",
"(",
"name",
",",
"fun... | // AddFunction publish a func or bound method
// name is the method name
// function is a func or bound method
// options includes Mode, Simple, Oneway and NameSpace | [
"AddFunction",
"publish",
"a",
"func",
"or",
"bound",
"method",
"name",
"is",
"the",
"method",
"name",
"function",
"is",
"a",
"func",
"or",
"bound",
"method",
"options",
"includes",
"Mode",
"Simple",
"Oneway",
"and",
"NameSpace"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L87-L90 | train |
hprose/hprose-golang | rpc/base_service.go | SetUserData | func (service *BaseService) SetUserData(
userdata map[string]interface{}) Service {
service.UserData = userdata
return service
} | go | func (service *BaseService) SetUserData(
userdata map[string]interface{}) Service {
service.UserData = userdata
return service
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"SetUserData",
"(",
"userdata",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"Service",
"{",
"service",
".",
"UserData",
"=",
"userdata",
"\n",
"return",
"service",
"\n",
"}"
] | // SetUserData for service | [
"SetUserData",
"for",
"service"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L187-L191 | train |
hprose/hprose-golang | rpc/base_service.go | FireErrorEvent | func FireErrorEvent(event ServiceEvent, e error, context Context) (err error) {
defer func() {
if e := recover(); e != nil {
err = NewPanicError(e)
}
}()
err = e
switch event := event.(type) {
case sendErrorEvent:
event.OnSendError(err, context)
case sendErrorEvent2:
err = event.OnSendError(err, context)
}
return err
} | go | func FireErrorEvent(event ServiceEvent, e error, context Context) (err error) {
defer func() {
if e := recover(); e != nil {
err = NewPanicError(e)
}
}()
err = e
switch event := event.(type) {
case sendErrorEvent:
event.OnSendError(err, context)
case sendErrorEvent2:
err = event.OnSendError(err, context)
}
return err
} | [
"func",
"FireErrorEvent",
"(",
"event",
"ServiceEvent",
",",
"e",
"error",
",",
"context",
"Context",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"e",
":=",
"recover",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"err",
"=",
... | // FireErrorEvent fires the OnSendError | [
"FireErrorEvent",
"fires",
"the",
"OnSendError"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L267-L281 | train |
hprose/hprose-golang | rpc/base_service.go | EndError | func (service *BaseService) EndError(err error, context Context) []byte {
w := io.NewByteWriter(service.sendError(err, context))
w.WriteByte(io.TagEnd)
return w.Bytes()
} | go | func (service *BaseService) EndError(err error, context Context) []byte {
w := io.NewByteWriter(service.sendError(err, context))
w.WriteByte(io.TagEnd)
return w.Bytes()
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"EndError",
"(",
"err",
"error",
",",
"context",
"Context",
")",
"[",
"]",
"byte",
"{",
"w",
":=",
"io",
".",
"NewByteWriter",
"(",
"service",
".",
"sendError",
"(",
"err",
",",
"context",
")",
")",
"\... | // EndError return the error response with TagEnd | [
"EndError",
"return",
"the",
"error",
"response",
"with",
"TagEnd"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L331-L335 | train |
hprose/hprose-golang | rpc/base_service.go | DoFunctionList | func (service *BaseService) DoFunctionList(context ServiceContext) []byte {
writer := io.NewWriter(true)
writer.WriteByte(io.TagFunctions)
writer.WriteStringSlice(service.MethodNames)
writer.WriteByte(io.TagEnd)
return writer.Bytes()
} | go | func (service *BaseService) DoFunctionList(context ServiceContext) []byte {
writer := io.NewWriter(true)
writer.WriteByte(io.TagFunctions)
writer.WriteStringSlice(service.MethodNames)
writer.WriteByte(io.TagEnd)
return writer.Bytes()
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"DoFunctionList",
"(",
"context",
"ServiceContext",
")",
"[",
"]",
"byte",
"{",
"writer",
":=",
"io",
".",
"NewWriter",
"(",
"true",
")",
"\n",
"writer",
".",
"WriteByte",
"(",
"io",
".",
"TagFunctions",
"... | // DoFunctionList returns the function list | [
"DoFunctionList",
"returns",
"the",
"function",
"list"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L481-L487 | train |
hprose/hprose-golang | rpc/base_service.go | Handle | func (service *BaseService) Handle(request []byte, context Context) []byte {
if service.UserData != nil {
for k, v := range service.UserData {
context.SetInterface(k, v)
}
}
response, err := service.beforeFilterHandler(request, context)
if err != nil {
return service.EndError(err, context)
}
return response
} | go | func (service *BaseService) Handle(request []byte, context Context) []byte {
if service.UserData != nil {
for k, v := range service.UserData {
context.SetInterface(k, v)
}
}
response, err := service.beforeFilterHandler(request, context)
if err != nil {
return service.EndError(err, context)
}
return response
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"Handle",
"(",
"request",
"[",
"]",
"byte",
",",
"context",
"Context",
")",
"[",
"]",
"byte",
"{",
"if",
"service",
".",
"UserData",
"!=",
"nil",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"service",
... | // Handle the hprose request and return the hprose response | [
"Handle",
"the",
"hprose",
"request",
"and",
"return",
"the",
"hprose",
"response"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L529-L540 | train |
hprose/hprose-golang | rpc/base_service.go | Publish | func (service *BaseService) Publish(
topic string,
timeout time.Duration,
heartbeat time.Duration) Service {
if timeout <= 0 {
timeout = service.Timeout
}
if heartbeat <= 0 {
heartbeat = service.Heartbeat
}
t := newTopic(heartbeat)
service.topicLock.Lock()
service.topics[topic] = t
service.topicLock.Unlock()
return service.AddFunction(topic, func(id string) interface{} {
message := t.get(id)
if message == nil {
message = make(chan interface{})
t.put(id, message)
fireSubscribeEvent(topic, id, service)
}
receiveMessage:
select {
case result := <-message:
if result == heartbeatSignals {
goto receiveMessage
}
return result
case <-time.After(timeout):
go func() {
select {
case message <- heartbeatSignals:
break
case <-time.After(t.heartbeat):
service.offline(t, topic, id)
}
}()
return nil
}
}, Options{})
} | go | func (service *BaseService) Publish(
topic string,
timeout time.Duration,
heartbeat time.Duration) Service {
if timeout <= 0 {
timeout = service.Timeout
}
if heartbeat <= 0 {
heartbeat = service.Heartbeat
}
t := newTopic(heartbeat)
service.topicLock.Lock()
service.topics[topic] = t
service.topicLock.Unlock()
return service.AddFunction(topic, func(id string) interface{} {
message := t.get(id)
if message == nil {
message = make(chan interface{})
t.put(id, message)
fireSubscribeEvent(topic, id, service)
}
receiveMessage:
select {
case result := <-message:
if result == heartbeatSignals {
goto receiveMessage
}
return result
case <-time.After(timeout):
go func() {
select {
case message <- heartbeatSignals:
break
case <-time.After(t.heartbeat):
service.offline(t, topic, id)
}
}()
return nil
}
}, Options{})
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"Publish",
"(",
"topic",
"string",
",",
"timeout",
"time",
".",
"Duration",
",",
"heartbeat",
"time",
".",
"Duration",
")",
"Service",
"{",
"if",
"timeout",
"<=",
"0",
"{",
"timeout",
"=",
"service",
".",
... | // Publish the hprose push topic | [
"Publish",
"the",
"hprose",
"push",
"topic"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L576-L616 | train |
hprose/hprose-golang | rpc/base_service.go | IDList | func (service *BaseService) IDList(topic string) []string {
return service.getTopic(topic).idlist()
} | go | func (service *BaseService) IDList(topic string) []string {
return service.getTopic(topic).idlist()
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"IDList",
"(",
"topic",
"string",
")",
"[",
"]",
"string",
"{",
"return",
"service",
".",
"getTopic",
"(",
"topic",
")",
".",
"idlist",
"(",
")",
"\n",
"}"
] | // IDList returns the push client id list | [
"IDList",
"returns",
"the",
"push",
"client",
"id",
"list"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L654-L656 | train |
hprose/hprose-golang | rpc/base_service.go | Exist | func (service *BaseService) Exist(topic string, id string) bool {
return service.getTopic(topic).exist(id)
} | go | func (service *BaseService) Exist(topic string, id string) bool {
return service.getTopic(topic).exist(id)
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"Exist",
"(",
"topic",
"string",
",",
"id",
"string",
")",
"bool",
"{",
"return",
"service",
".",
"getTopic",
"(",
"topic",
")",
".",
"exist",
"(",
"id",
")",
"\n",
"}"
] | // Exist returns true if the client id exist. | [
"Exist",
"returns",
"true",
"if",
"the",
"client",
"id",
"exist",
"."
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L659-L661 | train |
hprose/hprose-golang | rpc/base_service.go | Push | func (service *BaseService) Push(topic string, result interface{}, id ...string) {
t := service.getTopic(topic)
n := len(id)
if n == 0 {
id = t.idlist()
n = len(id)
if n == 0 {
return
}
}
for i := 0; i < n; i++ {
service.unicast(t, topic, id[i], result, nil)
}
} | go | func (service *BaseService) Push(topic string, result interface{}, id ...string) {
t := service.getTopic(topic)
n := len(id)
if n == 0 {
id = t.idlist()
n = len(id)
if n == 0 {
return
}
}
for i := 0; i < n; i++ {
service.unicast(t, topic, id[i], result, nil)
}
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"Push",
"(",
"topic",
"string",
",",
"result",
"interface",
"{",
"}",
",",
"id",
"...",
"string",
")",
"{",
"t",
":=",
"service",
".",
"getTopic",
"(",
"topic",
")",
"\n",
"n",
":=",
"len",
"(",
"id"... | // Push result to clients | [
"Push",
"result",
"to",
"clients"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L664-L677 | train |
hprose/hprose-golang | rpc/base_service.go | Broadcast | func (service *BaseService) Broadcast(
topic string, result interface{}, callback func([]string)) {
service.Multicast(topic, service.IDList(topic), result, callback)
} | go | func (service *BaseService) Broadcast(
topic string, result interface{}, callback func([]string)) {
service.Multicast(topic, service.IDList(topic), result, callback)
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"Broadcast",
"(",
"topic",
"string",
",",
"result",
"interface",
"{",
"}",
",",
"callback",
"func",
"(",
"[",
"]",
"string",
")",
")",
"{",
"service",
".",
"Multicast",
"(",
"topic",
",",
"service",
".",... | // Broadcast push result to all clients | [
"Broadcast",
"push",
"result",
"to",
"all",
"clients"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L680-L683 | train |
hprose/hprose-golang | rpc/base_service.go | Multicast | func (service *BaseService) Multicast(
topic string, ids []string, result interface{}, callback func([]string)) {
t := service.getTopic(topic)
m := 0
n := len(ids)
if n == 0 {
callback(nil)
return
}
sid := make(chan string)
go func() {
sended := make([]string, 0, n)
for id := range sid {
sended = append(sended, id)
}
callback(sended)
}()
for i := 0; i < n; i++ {
id := ids[i]
service.unicast(t, topic, id, result, func(ok bool) {
if ok {
sid <- id
}
m++
if m == n {
close(sid)
}
})
}
} | go | func (service *BaseService) Multicast(
topic string, ids []string, result interface{}, callback func([]string)) {
t := service.getTopic(topic)
m := 0
n := len(ids)
if n == 0 {
callback(nil)
return
}
sid := make(chan string)
go func() {
sended := make([]string, 0, n)
for id := range sid {
sended = append(sended, id)
}
callback(sended)
}()
for i := 0; i < n; i++ {
id := ids[i]
service.unicast(t, topic, id, result, func(ok bool) {
if ok {
sid <- id
}
m++
if m == n {
close(sid)
}
})
}
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"Multicast",
"(",
"topic",
"string",
",",
"ids",
"[",
"]",
"string",
",",
"result",
"interface",
"{",
"}",
",",
"callback",
"func",
"(",
"[",
"]",
"string",
")",
")",
"{",
"t",
":=",
"service",
".",
... | // Multicast result to the specified clients | [
"Multicast",
"result",
"to",
"the",
"specified",
"clients"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L686-L715 | train |
hprose/hprose-golang | rpc/base_service.go | Unicast | func (service *BaseService) Unicast(
topic string, id string, result interface{}, callback func(bool)) {
service.unicast(service.getTopic(topic), topic, id, result, callback)
} | go | func (service *BaseService) Unicast(
topic string, id string, result interface{}, callback func(bool)) {
service.unicast(service.getTopic(topic), topic, id, result, callback)
} | [
"func",
"(",
"service",
"*",
"BaseService",
")",
"Unicast",
"(",
"topic",
"string",
",",
"id",
"string",
",",
"result",
"interface",
"{",
"}",
",",
"callback",
"func",
"(",
"bool",
")",
")",
"{",
"service",
".",
"unicast",
"(",
"service",
".",
"getTopi... | // Unicast result to then specified client | [
"Unicast",
"result",
"to",
"then",
"specified",
"client"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_service.go#L718-L721 | train |
hprose/hprose-golang | rpc/base_client.go | IsSubscribed | func (tm *topicManager) IsSubscribed(topic string) bool {
tm.locker.RLock()
defer tm.locker.RUnlock()
return tm.allTopics[topic] != nil
} | go | func (tm *topicManager) IsSubscribed(topic string) bool {
tm.locker.RLock()
defer tm.locker.RUnlock()
return tm.allTopics[topic] != nil
} | [
"func",
"(",
"tm",
"*",
"topicManager",
")",
"IsSubscribed",
"(",
"topic",
"string",
")",
"bool",
"{",
"tm",
".",
"locker",
".",
"RLock",
"(",
")",
"\n",
"defer",
"tm",
".",
"locker",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"tm",
".",
"allTopics",
... | // IsSubscribed the topic | [
"IsSubscribed",
"the",
"topic"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L77-L81 | train |
hprose/hprose-golang | rpc/base_client.go | SubscribedList | func (tm *topicManager) SubscribedList() []string {
tm.locker.RLock()
list := make([]string, 0, len(tm.allTopics))
for name := range tm.allTopics {
list = append(list, name)
}
tm.locker.RUnlock()
return list
} | go | func (tm *topicManager) SubscribedList() []string {
tm.locker.RLock()
list := make([]string, 0, len(tm.allTopics))
for name := range tm.allTopics {
list = append(list, name)
}
tm.locker.RUnlock()
return list
} | [
"func",
"(",
"tm",
"*",
"topicManager",
")",
"SubscribedList",
"(",
")",
"[",
"]",
"string",
"{",
"tm",
".",
"locker",
".",
"RLock",
"(",
")",
"\n",
"list",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"tm",
".",
"allTopics",... | // SubscribedList returns the subscribed topic list | [
"SubscribedList",
"returns",
"the",
"subscribed",
"topic",
"list"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L84-L92 | train |
hprose/hprose-golang | rpc/base_client.go | InitBaseClient | func (client *BaseClient) InitBaseClient() {
client.initHandlerManager()
client.timeout = 30 * time.Second
client.retry = 10
client.contextPool = sync.Pool{
New: func() interface{} { return new(ClientContext) },
}
client.override.invokeHandler = func(
name string, args []reflect.Value,
context Context) (results []reflect.Value, err error) {
return client.invoke(name, args, context.(*ClientContext))
}
client.override.beforeFilterHandler = func(
request []byte, context Context) (response []byte, err error) {
return client.beforeFilter(request, context.(*ClientContext))
}
client.override.afterFilterHandler = func(
request []byte, context Context) (response []byte, err error) {
return client.afterFilter(request, context.(*ClientContext))
}
client.allTopics = make(map[string]map[string]*clientTopic)
} | go | func (client *BaseClient) InitBaseClient() {
client.initHandlerManager()
client.timeout = 30 * time.Second
client.retry = 10
client.contextPool = sync.Pool{
New: func() interface{} { return new(ClientContext) },
}
client.override.invokeHandler = func(
name string, args []reflect.Value,
context Context) (results []reflect.Value, err error) {
return client.invoke(name, args, context.(*ClientContext))
}
client.override.beforeFilterHandler = func(
request []byte, context Context) (response []byte, err error) {
return client.beforeFilter(request, context.(*ClientContext))
}
client.override.afterFilterHandler = func(
request []byte, context Context) (response []byte, err error) {
return client.afterFilter(request, context.(*ClientContext))
}
client.allTopics = make(map[string]map[string]*clientTopic)
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"InitBaseClient",
"(",
")",
"{",
"client",
".",
"initHandlerManager",
"(",
")",
"\n",
"client",
".",
"timeout",
"=",
"30",
"*",
"time",
".",
"Second",
"\n",
"client",
".",
"retry",
"=",
"10",
"\n",
"client... | // InitBaseClient initializes BaseClient | [
"InitBaseClient",
"initializes",
"BaseClient"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L114-L135 | train |
hprose/hprose-golang | rpc/base_client.go | SetUserData | func (client *BaseClient) SetUserData(
userdata map[string]interface{}) Client {
client.UserData = userdata
return client
} | go | func (client *BaseClient) SetUserData(
userdata map[string]interface{}) Client {
client.UserData = userdata
return client
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"SetUserData",
"(",
"userdata",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"Client",
"{",
"client",
".",
"UserData",
"=",
"userdata",
"\n",
"return",
"client",
"\n",
"}"
] | // SetUserData for client | [
"SetUserData",
"for",
"client"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L262-L266 | train |
hprose/hprose-golang | rpc/base_client.go | UseService | func (client *BaseClient) UseService(
remoteService interface{}, namespace ...string) {
ns := ""
if len(namespace) == 1 {
ns = namespace[0]
}
v := reflect.ValueOf(remoteService)
if v.Kind() != reflect.Ptr {
panic("UseService: remoteService argument must be a pointer")
}
client.buildRemoteService(v, ns)
} | go | func (client *BaseClient) UseService(
remoteService interface{}, namespace ...string) {
ns := ""
if len(namespace) == 1 {
ns = namespace[0]
}
v := reflect.ValueOf(remoteService)
if v.Kind() != reflect.Ptr {
panic("UseService: remoteService argument must be a pointer")
}
client.buildRemoteService(v, ns)
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"UseService",
"(",
"remoteService",
"interface",
"{",
"}",
",",
"namespace",
"...",
"string",
")",
"{",
"ns",
":=",
"\"\"",
"\n",
"if",
"len",
"(",
"namespace",
")",
"==",
"1",
"{",
"ns",
"=",
"namespace",... | // UseService build a remote service proxy object with namespace | [
"UseService",
"build",
"a",
"remote",
"service",
"proxy",
"object",
"with",
"namespace"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L269-L280 | train |
hprose/hprose-golang | rpc/base_client.go | GetClientContext | func (client *BaseClient) GetClientContext(
settings *InvokeSettings) (context *ClientContext) {
context = client.contextPool.Get().(*ClientContext)
context.InitBaseContext()
context.Client = client
context.Retried = 0
if client.UserData != nil {
for k, v := range client.UserData {
context.SetInterface(k, v)
}
}
if settings == nil {
context.InvokeSettings = InvokeSettings{
Timeout: client.timeout,
Retry: client.retry,
}
} else {
if settings.userData != nil {
for k, v := range settings.userData {
context.SetInterface(k, v)
}
}
context.InvokeSettings = *settings
if settings.Timeout <= 0 {
context.Timeout = client.timeout
}
if settings.Retry <= 0 {
context.Retry = client.retry
}
}
return context
} | go | func (client *BaseClient) GetClientContext(
settings *InvokeSettings) (context *ClientContext) {
context = client.contextPool.Get().(*ClientContext)
context.InitBaseContext()
context.Client = client
context.Retried = 0
if client.UserData != nil {
for k, v := range client.UserData {
context.SetInterface(k, v)
}
}
if settings == nil {
context.InvokeSettings = InvokeSettings{
Timeout: client.timeout,
Retry: client.retry,
}
} else {
if settings.userData != nil {
for k, v := range settings.userData {
context.SetInterface(k, v)
}
}
context.InvokeSettings = *settings
if settings.Timeout <= 0 {
context.Timeout = client.timeout
}
if settings.Retry <= 0 {
context.Retry = client.retry
}
}
return context
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"GetClientContext",
"(",
"settings",
"*",
"InvokeSettings",
")",
"(",
"context",
"*",
"ClientContext",
")",
"{",
"context",
"=",
"client",
".",
"contextPool",
".",
"Get",
"(",
")",
".",
"(",
"*",
"ClientContex... | // GetClientContext return a ClientContext | [
"GetClientContext",
"return",
"a",
"ClientContext"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L283-L314 | train |
hprose/hprose-golang | rpc/base_client.go | Invoke | func (client *BaseClient) Invoke(
name string,
args []reflect.Value,
settings *InvokeSettings) (results []reflect.Value, err error) {
context := client.GetClientContext(settings)
results, err = client.handlerManager.invokeHandler(name, args, context)
if results == nil && len(context.ResultTypes) > 0 {
n := len(context.ResultTypes)
results = make([]reflect.Value, n)
for i := 0; i < n; i++ {
results[i] = reflect.New(context.ResultTypes[i]).Elem()
}
}
client.contextPool.Put(context)
return
} | go | func (client *BaseClient) Invoke(
name string,
args []reflect.Value,
settings *InvokeSettings) (results []reflect.Value, err error) {
context := client.GetClientContext(settings)
results, err = client.handlerManager.invokeHandler(name, args, context)
if results == nil && len(context.ResultTypes) > 0 {
n := len(context.ResultTypes)
results = make([]reflect.Value, n)
for i := 0; i < n; i++ {
results[i] = reflect.New(context.ResultTypes[i]).Elem()
}
}
client.contextPool.Put(context)
return
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"Invoke",
"(",
"name",
"string",
",",
"args",
"[",
"]",
"reflect",
".",
"Value",
",",
"settings",
"*",
"InvokeSettings",
")",
"(",
"results",
"[",
"]",
"reflect",
".",
"Value",
",",
"err",
"error",
")",
... | // Invoke the remote method synchronous | [
"Invoke",
"the",
"remote",
"method",
"synchronous"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L317-L332 | train |
hprose/hprose-golang | rpc/base_client.go | Go | func (client *BaseClient) Go(
name string,
args []reflect.Value,
settings *InvokeSettings,
callback Callback) {
go func() {
defer client.fireErrorEvent(name, nil)
callback(client.Invoke(name, args, settings))
}()
} | go | func (client *BaseClient) Go(
name string,
args []reflect.Value,
settings *InvokeSettings,
callback Callback) {
go func() {
defer client.fireErrorEvent(name, nil)
callback(client.Invoke(name, args, settings))
}()
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"Go",
"(",
"name",
"string",
",",
"args",
"[",
"]",
"reflect",
".",
"Value",
",",
"settings",
"*",
"InvokeSettings",
",",
"callback",
"Callback",
")",
"{",
"go",
"func",
"(",
")",
"{",
"defer",
"client",
... | // Go invoke the remote method asynchronous | [
"Go",
"invoke",
"the",
"remote",
"method",
"asynchronous"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L335-L344 | train |
hprose/hprose-golang | rpc/base_client.go | AutoID | func (client *BaseClient) AutoID() (string, error) {
client.topicManager.locker.RLock()
if client.id != "" {
client.topicManager.locker.RUnlock()
return client.id, nil
}
client.topicManager.locker.RUnlock()
client.topicManager.locker.Lock()
defer client.topicManager.locker.Unlock()
if client.id != "" {
return client.id, nil
}
results, err := client.Invoke("#", nil, &autoIDSettings)
if err != nil {
return "", err
}
client.id = results[0].String()
return client.id, nil
} | go | func (client *BaseClient) AutoID() (string, error) {
client.topicManager.locker.RLock()
if client.id != "" {
client.topicManager.locker.RUnlock()
return client.id, nil
}
client.topicManager.locker.RUnlock()
client.topicManager.locker.Lock()
defer client.topicManager.locker.Unlock()
if client.id != "" {
return client.id, nil
}
results, err := client.Invoke("#", nil, &autoIDSettings)
if err != nil {
return "", err
}
client.id = results[0].String()
return client.id, nil
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"AutoID",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"client",
".",
"topicManager",
".",
"locker",
".",
"RLock",
"(",
")",
"\n",
"if",
"client",
".",
"id",
"!=",
"\"\"",
"{",
"client",
".",
"topi... | // AutoID returns the auto id of this hprose client.
// If the id is not initialized, it be initialized and returned. | [
"AutoID",
"returns",
"the",
"auto",
"id",
"of",
"this",
"hprose",
"client",
".",
"If",
"the",
"id",
"is",
"not",
"initialized",
"it",
"be",
"initialized",
"and",
"returned",
"."
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L813-L831 | train |
hprose/hprose-golang | rpc/base_client.go | Subscribe | func (client *BaseClient) Subscribe(
name string, id string,
settings *InvokeSettings, callback interface{}) (err error) {
if id == "" {
id, err = client.AutoID()
if err != nil {
return err
}
}
f := reflect.ValueOf(callback)
if f.Kind() != reflect.Func {
return errors.New("Subscribe: callback must be a function")
}
resultTypes, hasError := getCallbackResultTypes(f.Type())
cb := func(results []reflect.Value, err error) {
if hasError {
results = append(results, reflect.ValueOf(&err).Elem())
}
f.Call(results)
}
if settings == nil {
settings = new(InvokeSettings)
}
if settings.Timeout <= 0 {
settings.Timeout = 5 * time.Minute
}
settings.ByRef = false
settings.Idempotent = true
settings.Mode = Normal
settings.Oneway = false
settings.Simple = true
settings.ResultTypes = resultTypes
client.createTopic(name)
topic := client.getTopic(name, id)
if topic == nil {
topic = new(clientTopic)
topic.addCallback(cb)
client.topicManager.locker.Lock()
client.allTopics[name][id] = topic
client.topicManager.locker.Unlock()
go client.subscribe(name, id, settings)
} else {
topic.addCallback(cb)
}
return nil
} | go | func (client *BaseClient) Subscribe(
name string, id string,
settings *InvokeSettings, callback interface{}) (err error) {
if id == "" {
id, err = client.AutoID()
if err != nil {
return err
}
}
f := reflect.ValueOf(callback)
if f.Kind() != reflect.Func {
return errors.New("Subscribe: callback must be a function")
}
resultTypes, hasError := getCallbackResultTypes(f.Type())
cb := func(results []reflect.Value, err error) {
if hasError {
results = append(results, reflect.ValueOf(&err).Elem())
}
f.Call(results)
}
if settings == nil {
settings = new(InvokeSettings)
}
if settings.Timeout <= 0 {
settings.Timeout = 5 * time.Minute
}
settings.ByRef = false
settings.Idempotent = true
settings.Mode = Normal
settings.Oneway = false
settings.Simple = true
settings.ResultTypes = resultTypes
client.createTopic(name)
topic := client.getTopic(name, id)
if topic == nil {
topic = new(clientTopic)
topic.addCallback(cb)
client.topicManager.locker.Lock()
client.allTopics[name][id] = topic
client.topicManager.locker.Unlock()
go client.subscribe(name, id, settings)
} else {
topic.addCallback(cb)
}
return nil
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"Subscribe",
"(",
"name",
"string",
",",
"id",
"string",
",",
"settings",
"*",
"InvokeSettings",
",",
"callback",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"if",
"id",
"==",
"\"\"",
"{",
... | // Subscribe a push topic | [
"Subscribe",
"a",
"push",
"topic"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L885-L930 | train |
hprose/hprose-golang | rpc/base_client.go | Unsubscribe | func (client *BaseClient) Unsubscribe(name string, id ...string) {
client.topicManager.locker.Lock()
if client.allTopics[name] != nil {
if len(id) == 0 {
if client.id == "" {
delete(client.allTopics, name)
} else {
delete(client.allTopics[name], client.id)
}
} else {
for i := range id {
delete(client.allTopics[name], id[i])
}
}
if len(client.allTopics[name]) == 0 {
delete(client.allTopics, name)
}
}
client.topicManager.locker.Unlock()
} | go | func (client *BaseClient) Unsubscribe(name string, id ...string) {
client.topicManager.locker.Lock()
if client.allTopics[name] != nil {
if len(id) == 0 {
if client.id == "" {
delete(client.allTopics, name)
} else {
delete(client.allTopics[name], client.id)
}
} else {
for i := range id {
delete(client.allTopics[name], id[i])
}
}
if len(client.allTopics[name]) == 0 {
delete(client.allTopics, name)
}
}
client.topicManager.locker.Unlock()
} | [
"func",
"(",
"client",
"*",
"BaseClient",
")",
"Unsubscribe",
"(",
"name",
"string",
",",
"id",
"...",
"string",
")",
"{",
"client",
".",
"topicManager",
".",
"locker",
".",
"Lock",
"(",
")",
"\n",
"if",
"client",
".",
"allTopics",
"[",
"name",
"]",
... | // Unsubscribe a push topic | [
"Unsubscribe",
"a",
"push",
"topic"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/base_client.go#L933-L952 | train |
hprose/hprose-golang | rpc/tcp_client.go | NewTCPClient | func NewTCPClient(uri ...string) (client *TCPClient) {
client = new(TCPClient)
client.initSocketClient()
client.Linger = -1
client.NoDelay = true
client.KeepAlive = true
client.setCreateConn(client.createTCPConn)
client.SetURIList(uri)
return
} | go | func NewTCPClient(uri ...string) (client *TCPClient) {
client = new(TCPClient)
client.initSocketClient()
client.Linger = -1
client.NoDelay = true
client.KeepAlive = true
client.setCreateConn(client.createTCPConn)
client.SetURIList(uri)
return
} | [
"func",
"NewTCPClient",
"(",
"uri",
"...",
"string",
")",
"(",
"client",
"*",
"TCPClient",
")",
"{",
"client",
"=",
"new",
"(",
"TCPClient",
")",
"\n",
"client",
".",
"initSocketClient",
"(",
")",
"\n",
"client",
".",
"Linger",
"=",
"-",
"1",
"\n",
"... | // NewTCPClient is the constructor of TCPClient | [
"NewTCPClient",
"is",
"the",
"constructor",
"of",
"TCPClient"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/tcp_client.go#L39-L48 | train |
hprose/hprose-golang | rpc/server.go | Start | func (starter *starter) Start() (err error) {
for {
if err = starter.server.Handle(); err != nil {
return err
}
starter.c = make(chan os.Signal, 1)
signal.Notify(starter.c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
s := <-starter.c
starter.server.Close()
switch s {
case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL:
signal.Stop(starter.c)
return
}
}
} | go | func (starter *starter) Start() (err error) {
for {
if err = starter.server.Handle(); err != nil {
return err
}
starter.c = make(chan os.Signal, 1)
signal.Notify(starter.c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
s := <-starter.c
starter.server.Close()
switch s {
case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL:
signal.Stop(starter.c)
return
}
}
} | [
"func",
"(",
"starter",
"*",
"starter",
")",
"Start",
"(",
")",
"(",
"err",
"error",
")",
"{",
"for",
"{",
"if",
"err",
"=",
"starter",
".",
"server",
".",
"Handle",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"sta... | // Start the hprose server | [
"Start",
"the",
"hprose",
"server"
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/rpc/server.go#L45-L60 | train |
hprose/hprose-golang | io/reader_pool.go | ReleaseReader | func (pool *ReaderPool) ReleaseReader(reader *Reader) {
reader.Init(nil)
reader.Reset()
pool.Put(reader)
} | go | func (pool *ReaderPool) ReleaseReader(reader *Reader) {
reader.Init(nil)
reader.Reset()
pool.Put(reader)
} | [
"func",
"(",
"pool",
"*",
"ReaderPool",
")",
"ReleaseReader",
"(",
"reader",
"*",
"Reader",
")",
"{",
"reader",
".",
"Init",
"(",
"nil",
")",
"\n",
"reader",
".",
"Reset",
"(",
")",
"\n",
"pool",
".",
"Put",
"(",
"reader",
")",
"\n",
"}"
] | // ReleaseReader to pool. | [
"ReleaseReader",
"to",
"pool",
"."
] | 6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74 | https://github.com/hprose/hprose-golang/blob/6c2a3b7138ea2c7dc4a8907d644f9f134e0fae74/io/reader_pool.go#L40-L44 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.