id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
6,100 | google/safebrowsing | database.go | Lookup | func (db *database) Lookup(hash hashPrefix) (h hashPrefix, tds []ThreatDescriptor) {
if !hash.IsFull() {
panic("hash is not full")
}
db.ml.RLock()
for td, hs := range db.tfl {
if n := hs.Lookup(hash); n > 0 {
h = hash[:n]
tds = append(tds, td)
}
}
db.ml.RUnlock()
return h, tds
} | go | func (db *database) Lookup(hash hashPrefix) (h hashPrefix, tds []ThreatDescriptor) {
if !hash.IsFull() {
panic("hash is not full")
}
db.ml.RLock()
for td, hs := range db.tfl {
if n := hs.Lookup(hash); n > 0 {
h = hash[:n]
tds = append(tds, td)
}
}
db.ml.RUnlock()
return h, tds
} | [
"func",
"(",
"db",
"*",
"database",
")",
"Lookup",
"(",
"hash",
"hashPrefix",
")",
"(",
"h",
"hashPrefix",
",",
"tds",
"[",
"]",
"ThreatDescriptor",
")",
"{",
"if",
"!",
"hash",
".",
"IsFull",
"(",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"... | // Lookup looks up the full hash in the threat list and returns a partial
// hash and a set of ThreatDescriptors that may match the full hash. | [
"Lookup",
"looks",
"up",
"the",
"full",
"hash",
"in",
"the",
"threat",
"list",
"and",
"returns",
"a",
"partial",
"hash",
"and",
"a",
"set",
"of",
"ThreatDescriptors",
"that",
"may",
"match",
"the",
"full",
"hash",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L281-L295 |
6,101 | google/safebrowsing | database.go | setError | func (db *database) setError(err error) {
db.tfu = nil
db.ml.Lock()
if db.err == nil {
db.readyCh = make(chan struct{})
}
db.tfl, db.err, db.last = nil, err, time.Time{}
db.ml.Unlock()
} | go | func (db *database) setError(err error) {
db.tfu = nil
db.ml.Lock()
if db.err == nil {
db.readyCh = make(chan struct{})
}
db.tfl, db.err, db.last = nil, err, time.Time{}
db.ml.Unlock()
} | [
"func",
"(",
"db",
"*",
"database",
")",
"setError",
"(",
"err",
"error",
")",
"{",
"db",
".",
"tfu",
"=",
"nil",
"\n\n",
"db",
".",
"ml",
".",
"Lock",
"(",
")",
"\n",
"if",
"db",
".",
"err",
"==",
"nil",
"{",
"db",
".",
"readyCh",
"=",
"make... | // setError clears the database state and sets the last error to be err.
//
// This assumes that the db.mu lock is already held. | [
"setError",
"clears",
"the",
"database",
"state",
"and",
"sets",
"the",
"last",
"error",
"to",
"be",
"err",
".",
"This",
"assumes",
"that",
"the",
"db",
".",
"mu",
"lock",
"is",
"already",
"held",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L300-L309 |
6,102 | google/safebrowsing | database.go | isStale | func (db *database) isStale(lastUpdate time.Time) bool {
if db.config.now().Sub(lastUpdate) > 2*(db.config.UpdatePeriod+jitter) {
return true
}
return false
} | go | func (db *database) isStale(lastUpdate time.Time) bool {
if db.config.now().Sub(lastUpdate) > 2*(db.config.UpdatePeriod+jitter) {
return true
}
return false
} | [
"func",
"(",
"db",
"*",
"database",
")",
"isStale",
"(",
"lastUpdate",
"time",
".",
"Time",
")",
"bool",
"{",
"if",
"db",
".",
"config",
".",
"now",
"(",
")",
".",
"Sub",
"(",
"lastUpdate",
")",
">",
"2",
"*",
"(",
"db",
".",
"config",
".",
"Up... | // isStale checks whether the last successful update should be considered stale.
// Staleness is defined as being older than two of the configured update periods
// plus jitter. | [
"isStale",
"checks",
"whether",
"the",
"last",
"successful",
"update",
"should",
"be",
"considered",
"stale",
".",
"Staleness",
"is",
"defined",
"as",
"being",
"older",
"than",
"two",
"of",
"the",
"configured",
"update",
"periods",
"plus",
"jitter",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L314-L319 |
6,103 | google/safebrowsing | database.go | setStale | func (db *database) setStale() {
if db.err == nil {
db.readyCh = make(chan struct{})
}
db.err = errStale
} | go | func (db *database) setStale() {
if db.err == nil {
db.readyCh = make(chan struct{})
}
db.err = errStale
} | [
"func",
"(",
"db",
"*",
"database",
")",
"setStale",
"(",
")",
"{",
"if",
"db",
".",
"err",
"==",
"nil",
"{",
"db",
".",
"readyCh",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"}",
"\n",
"db",
".",
"err",
"=",
"errStale",
"\n",
"... | // setStale sets the error state to a stale message, without clearing
// the database state.
//
// This assumes that the db.ml lock is already held. | [
"setStale",
"sets",
"the",
"error",
"state",
"to",
"a",
"stale",
"message",
"without",
"clearing",
"the",
"database",
"state",
".",
"This",
"assumes",
"that",
"the",
"db",
".",
"ml",
"lock",
"is",
"already",
"held",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L325-L330 |
6,104 | google/safebrowsing | database.go | clearError | func (db *database) clearError() {
db.ml.Lock()
defer db.ml.Unlock()
if db.err != nil {
close(db.readyCh)
}
db.err = nil
} | go | func (db *database) clearError() {
db.ml.Lock()
defer db.ml.Unlock()
if db.err != nil {
close(db.readyCh)
}
db.err = nil
} | [
"func",
"(",
"db",
"*",
"database",
")",
"clearError",
"(",
")",
"{",
"db",
".",
"ml",
".",
"Lock",
"(",
")",
"\n",
"defer",
"db",
".",
"ml",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"db",
".",
"err",
"!=",
"nil",
"{",
"close",
"(",
"db",
".",
... | // clearError clears the db error state, and unblocks any callers of
// WaitUntilReady.
//
// This assumes that the db.mu lock is already held. | [
"clearError",
"clears",
"the",
"db",
"error",
"state",
"and",
"unblocks",
"any",
"callers",
"of",
"WaitUntilReady",
".",
"This",
"assumes",
"that",
"the",
"db",
".",
"mu",
"lock",
"is",
"already",
"held",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L336-L344 |
6,105 | google/safebrowsing | database.go | generateThreatsForUpdate | func (db *database) generateThreatsForUpdate() {
if db.tfu == nil {
db.tfu = make(threatsForUpdate)
}
db.ml.RLock()
for td, hs := range db.tfl {
phs := db.tfu[td]
phs.Hashes = hs.Export()
db.tfu[td] = phs
}
db.ml.RUnlock()
} | go | func (db *database) generateThreatsForUpdate() {
if db.tfu == nil {
db.tfu = make(threatsForUpdate)
}
db.ml.RLock()
for td, hs := range db.tfl {
phs := db.tfu[td]
phs.Hashes = hs.Export()
db.tfu[td] = phs
}
db.ml.RUnlock()
} | [
"func",
"(",
"db",
"*",
"database",
")",
"generateThreatsForUpdate",
"(",
")",
"{",
"if",
"db",
".",
"tfu",
"==",
"nil",
"{",
"db",
".",
"tfu",
"=",
"make",
"(",
"threatsForUpdate",
")",
"\n",
"}",
"\n\n",
"db",
".",
"ml",
".",
"RLock",
"(",
")",
... | // generateThreatsForUpdate regenerates the threatsForUpdate hashes from
// the threatsForLookup. We do this to avoid holding onto the hash lists for
// a long time, needlessly occupying lots of memory.
//
// This assumes that the db.mu lock is already held. | [
"generateThreatsForUpdate",
"regenerates",
"the",
"threatsForUpdate",
"hashes",
"from",
"the",
"threatsForLookup",
".",
"We",
"do",
"this",
"to",
"avoid",
"holding",
"onto",
"the",
"hash",
"lists",
"for",
"a",
"long",
"time",
"needlessly",
"occupying",
"lots",
"of... | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L351-L363 |
6,106 | google/safebrowsing | database.go | generateThreatsForLookups | func (db *database) generateThreatsForLookups(last time.Time) {
tfl := make(threatsForLookup)
for td, phs := range db.tfu {
var hs hashSet
hs.Import(phs.Hashes)
tfl[td] = hs
phs.Hashes = nil // Clear hashes to keep memory usage low
db.tfu[td] = phs
}
db.ml.Lock()
wasBad := db.err != nil
db.tfl, db.las... | go | func (db *database) generateThreatsForLookups(last time.Time) {
tfl := make(threatsForLookup)
for td, phs := range db.tfu {
var hs hashSet
hs.Import(phs.Hashes)
tfl[td] = hs
phs.Hashes = nil // Clear hashes to keep memory usage low
db.tfu[td] = phs
}
db.ml.Lock()
wasBad := db.err != nil
db.tfl, db.las... | [
"func",
"(",
"db",
"*",
"database",
")",
"generateThreatsForLookups",
"(",
"last",
"time",
".",
"Time",
")",
"{",
"tfl",
":=",
"make",
"(",
"threatsForLookup",
")",
"\n",
"for",
"td",
",",
"phs",
":=",
"range",
"db",
".",
"tfu",
"{",
"var",
"hs",
"ha... | // generateThreatsForLookups regenerates the threatsForLookup data structure
// from the threatsForUpdate data structure and stores the last timestamp.
// Since the hashes are effectively stored as a set inside the threatsForLookup,
// we clear out the hashes slice in threatsForUpdate so that it can be GCed.
//
// This... | [
"generateThreatsForLookups",
"regenerates",
"the",
"threatsForLookup",
"data",
"structure",
"from",
"the",
"threatsForUpdate",
"data",
"structure",
"and",
"stores",
"the",
"last",
"timestamp",
".",
"Since",
"the",
"hashes",
"are",
"effectively",
"stored",
"as",
"a",
... | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L371-L391 |
6,107 | google/safebrowsing | database.go | saveDatabase | func saveDatabase(path string, db databaseFormat) (err error) {
var file *os.File
file, err = os.Create(path)
if err != nil {
return err
}
defer func() {
if cerr := file.Close(); err == nil {
err = cerr
}
}()
gz, err := gzip.NewWriterLevel(file, gzip.BestCompression)
if err != nil {
return err
}
d... | go | func saveDatabase(path string, db databaseFormat) (err error) {
var file *os.File
file, err = os.Create(path)
if err != nil {
return err
}
defer func() {
if cerr := file.Close(); err == nil {
err = cerr
}
}()
gz, err := gzip.NewWriterLevel(file, gzip.BestCompression)
if err != nil {
return err
}
d... | [
"func",
"saveDatabase",
"(",
"path",
"string",
",",
"db",
"databaseFormat",
")",
"(",
"err",
"error",
")",
"{",
"var",
"file",
"*",
"os",
".",
"File",
"\n",
"file",
",",
"err",
"=",
"os",
".",
"Create",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
... | // saveDatabase saves the database threat list to a file. | [
"saveDatabase",
"saves",
"the",
"database",
"threat",
"list",
"to",
"a",
"file",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L394-L421 |
6,108 | google/safebrowsing | database.go | loadDatabase | func loadDatabase(path string) (db databaseFormat, err error) {
var file *os.File
file, err = os.Open(path)
if err != nil {
return db, err
}
defer func() {
if cerr := file.Close(); err == nil {
err = cerr
}
}()
gz, err := gzip.NewReader(file)
if err != nil {
return db, err
}
defer func() {
if ze... | go | func loadDatabase(path string) (db databaseFormat, err error) {
var file *os.File
file, err = os.Open(path)
if err != nil {
return db, err
}
defer func() {
if cerr := file.Close(); err == nil {
err = cerr
}
}()
gz, err := gzip.NewReader(file)
if err != nil {
return db, err
}
defer func() {
if ze... | [
"func",
"loadDatabase",
"(",
"path",
"string",
")",
"(",
"db",
"databaseFormat",
",",
"err",
"error",
")",
"{",
"var",
"file",
"*",
"os",
".",
"File",
"\n",
"file",
",",
"err",
"=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"n... | // loadDatabase loads the database state from a file. | [
"loadDatabase",
"loads",
"the",
"database",
"state",
"from",
"a",
"file",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L424-L456 |
6,109 | google/safebrowsing | database.go | update | func (tfu threatsForUpdate) update(resp *pb.FetchThreatListUpdatesResponse) error {
// For each update response do the removes and adds
for _, m := range resp.GetListUpdateResponses() {
td := ThreatDescriptor{
PlatformType: PlatformType(m.PlatformType),
ThreatType: ThreatType(m.ThreatType),
ThreatE... | go | func (tfu threatsForUpdate) update(resp *pb.FetchThreatListUpdatesResponse) error {
// For each update response do the removes and adds
for _, m := range resp.GetListUpdateResponses() {
td := ThreatDescriptor{
PlatformType: PlatformType(m.PlatformType),
ThreatType: ThreatType(m.ThreatType),
ThreatE... | [
"func",
"(",
"tfu",
"threatsForUpdate",
")",
"update",
"(",
"resp",
"*",
"pb",
".",
"FetchThreatListUpdatesResponse",
")",
"error",
"{",
"// For each update response do the removes and adds",
"for",
"_",
",",
"m",
":=",
"range",
"resp",
".",
"GetListUpdateResponses",
... | // update updates the threat list according to the API response. | [
"update",
"updates",
"the",
"threat",
"list",
"according",
"to",
"the",
"API",
"response",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L459-L536 |
6,110 | google/safebrowsing | cmd/sbserver/main.go | unmarshal | func unmarshal(req *http.Request, pbReq proto.Message) (string, error) {
var mime string
alt := req.URL.Query().Get("alt")
if alt == "" {
alt = req.Header.Get("Content-Type")
}
switch alt {
case "json", mimeJSON:
mime = mimeJSON
case "proto", mimeProto:
mime = mimeProto
default:
return mime, errors.New(... | go | func unmarshal(req *http.Request, pbReq proto.Message) (string, error) {
var mime string
alt := req.URL.Query().Get("alt")
if alt == "" {
alt = req.Header.Get("Content-Type")
}
switch alt {
case "json", mimeJSON:
mime = mimeJSON
case "proto", mimeProto:
mime = mimeProto
default:
return mime, errors.New(... | [
"func",
"unmarshal",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"pbReq",
"proto",
".",
"Message",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"mime",
"string",
"\n",
"alt",
":=",
"req",
".",
"URL",
".",
"Query",
"(",
")",
".",
"Get",
"(... | // unmarshal reads pbResp from req. The mime will either be JSON or ProtoBuf. | [
"unmarshal",
"reads",
"pbResp",
"from",
"req",
".",
"The",
"mime",
"will",
"either",
"be",
"JSON",
"or",
"ProtoBuf",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/cmd/sbserver/main.go#L251-L281 |
6,111 | google/safebrowsing | cmd/sbserver/main.go | marshal | func marshal(resp http.ResponseWriter, pbResp proto.Message, mime string) error {
resp.Header().Set("Content-Type", mime)
switch mime {
case mimeProto:
body, err := proto.Marshal(pbResp)
if err != nil {
return err
}
if _, err := resp.Write(body); err != nil {
return err
}
case mimeJSON:
var m json... | go | func marshal(resp http.ResponseWriter, pbResp proto.Message, mime string) error {
resp.Header().Set("Content-Type", mime)
switch mime {
case mimeProto:
body, err := proto.Marshal(pbResp)
if err != nil {
return err
}
if _, err := resp.Write(body); err != nil {
return err
}
case mimeJSON:
var m json... | [
"func",
"marshal",
"(",
"resp",
"http",
".",
"ResponseWriter",
",",
"pbResp",
"proto",
".",
"Message",
",",
"mime",
"string",
")",
"error",
"{",
"resp",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"mime",
")",
"\n",
"switch",
"mime",
... | // marshal writes pbResp into resp. The mime can either be JSON or ProtoBuf. | [
"marshal",
"writes",
"pbResp",
"into",
"resp",
".",
"The",
"mime",
"can",
"either",
"be",
"JSON",
"or",
"ProtoBuf",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/cmd/sbserver/main.go#L284-L308 |
6,112 | google/safebrowsing | cmd/sbserver/main.go | serveStatus | func serveStatus(resp http.ResponseWriter, req *http.Request, sb *safebrowsing.SafeBrowser) {
stats, sbErr := sb.Status()
errStr := ""
if sbErr != nil {
errStr = sbErr.Error()
}
buf, err := json.Marshal(struct {
Stats safebrowsing.Stats
Error string
}{stats, errStr})
if err != nil {
http.Error(resp, err.... | go | func serveStatus(resp http.ResponseWriter, req *http.Request, sb *safebrowsing.SafeBrowser) {
stats, sbErr := sb.Status()
errStr := ""
if sbErr != nil {
errStr = sbErr.Error()
}
buf, err := json.Marshal(struct {
Stats safebrowsing.Stats
Error string
}{stats, errStr})
if err != nil {
http.Error(resp, err.... | [
"func",
"serveStatus",
"(",
"resp",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
",",
"sb",
"*",
"safebrowsing",
".",
"SafeBrowser",
")",
"{",
"stats",
",",
"sbErr",
":=",
"sb",
".",
"Status",
"(",
")",
"\n",
"errStr",
":=",
... | // serveStatus writes a simple JSON with server status information to resp. | [
"serveStatus",
"writes",
"a",
"simple",
"JSON",
"with",
"server",
"status",
"information",
"to",
"resp",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/cmd/sbserver/main.go#L311-L327 |
6,113 | google/safebrowsing | cmd/sbserver/main.go | serveRedirector | func serveRedirector(resp http.ResponseWriter, req *http.Request, sb *safebrowsing.SafeBrowser, fs http.FileSystem) {
rawURL := req.URL.Query().Get("url")
if rawURL == "" || req.URL.Path != "/r" {
http.NotFound(resp, req)
return
}
parsedURL, err := url.Parse(rawURL)
if err != nil {
http.Error(resp, err.Error... | go | func serveRedirector(resp http.ResponseWriter, req *http.Request, sb *safebrowsing.SafeBrowser, fs http.FileSystem) {
rawURL := req.URL.Query().Get("url")
if rawURL == "" || req.URL.Path != "/r" {
http.NotFound(resp, req)
return
}
parsedURL, err := url.Parse(rawURL)
if err != nil {
http.Error(resp, err.Error... | [
"func",
"serveRedirector",
"(",
"resp",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
",",
"sb",
"*",
"safebrowsing",
".",
"SafeBrowser",
",",
"fs",
"http",
".",
"FileSystem",
")",
"{",
"rawURL",
":=",
"req",
".",
"URL",
".",
... | // serveRedirector implements a basic HTTP redirector that will filter out
// redirect URLs that are unsafe according to the Safe Browsing API. | [
"serveRedirector",
"implements",
"a",
"basic",
"HTTP",
"redirector",
"that",
"will",
"filter",
"out",
"redirect",
"URLs",
"that",
"are",
"unsafe",
"according",
"to",
"the",
"Safe",
"Browsing",
"API",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/cmd/sbserver/main.go#L456-L495 |
6,114 | google/safebrowsing | urls.go | generateHashes | func generateHashes(url string) (map[hashPrefix]string, error) {
patterns, err := generatePatterns(url)
if err != nil {
return nil, err
}
hashes := make(map[hashPrefix]string)
for _, p := range patterns {
hashes[hashFromPattern(p)] = p
}
return hashes, nil
} | go | func generateHashes(url string) (map[hashPrefix]string, error) {
patterns, err := generatePatterns(url)
if err != nil {
return nil, err
}
hashes := make(map[hashPrefix]string)
for _, p := range patterns {
hashes[hashFromPattern(p)] = p
}
return hashes, nil
} | [
"func",
"generateHashes",
"(",
"url",
"string",
")",
"(",
"map",
"[",
"hashPrefix",
"]",
"string",
",",
"error",
")",
"{",
"patterns",
",",
"err",
":=",
"generatePatterns",
"(",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"... | // generateHashes returns a set of full hashes for all patterns in the URL. | [
"generateHashes",
"returns",
"a",
"set",
"of",
"full",
"hashes",
"for",
"all",
"patterns",
"in",
"the",
"URL",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L75-L86 |
6,115 | google/safebrowsing | urls.go | generatePatterns | func generatePatterns(url string) ([]string, error) {
hosts, err := generateLookupHosts(url)
if err != nil {
return nil, err
}
paths, err := generateLookupPaths(url)
if err != nil {
return nil, err
}
var patterns []string
for _, h := range hosts {
for _, p := range paths {
patterns = append(patterns, h... | go | func generatePatterns(url string) ([]string, error) {
hosts, err := generateLookupHosts(url)
if err != nil {
return nil, err
}
paths, err := generateLookupPaths(url)
if err != nil {
return nil, err
}
var patterns []string
for _, h := range hosts {
for _, p := range paths {
patterns = append(patterns, h... | [
"func",
"generatePatterns",
"(",
"url",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"hosts",
",",
"err",
":=",
"generateLookupHosts",
"(",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
... | // generatePatterns returns all possible host-suffix and path-prefix patterns
// for the input URL. | [
"generatePatterns",
"returns",
"all",
"possible",
"host",
"-",
"suffix",
"and",
"path",
"-",
"prefix",
"patterns",
"for",
"the",
"input",
"URL",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L90-L106 |
6,116 | google/safebrowsing | urls.go | isHex | func isHex(c byte) bool {
switch {
case '0' <= c && c <= '9':
return true
case 'a' <= c && c <= 'f':
return true
case 'A' <= c && c <= 'F':
return true
}
return false
} | go | func isHex(c byte) bool {
switch {
case '0' <= c && c <= '9':
return true
case 'a' <= c && c <= 'f':
return true
case 'A' <= c && c <= 'F':
return true
}
return false
} | [
"func",
"isHex",
"(",
"c",
"byte",
")",
"bool",
"{",
"switch",
"{",
"case",
"'0'",
"<=",
"c",
"&&",
"c",
"<=",
"'9'",
":",
"return",
"true",
"\n",
"case",
"'a'",
"<=",
"c",
"&&",
"c",
"<=",
"'f'",
":",
"return",
"true",
"\n",
"case",
"'A'",
"<=... | // isHex reports whether c is a hexadecimal character. | [
"isHex",
"reports",
"whether",
"c",
"is",
"a",
"hexadecimal",
"character",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L109-L119 |
6,117 | google/safebrowsing | urls.go | isUnicode | func isUnicode(s string) bool {
for _, c := range []byte(s) {
// For legacy reasons, 0x80 is not considered a Unicode character.
if c > 0x80 {
return true
}
}
return false
} | go | func isUnicode(s string) bool {
for _, c := range []byte(s) {
// For legacy reasons, 0x80 is not considered a Unicode character.
if c > 0x80 {
return true
}
}
return false
} | [
"func",
"isUnicode",
"(",
"s",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"c",
":=",
"range",
"[",
"]",
"byte",
"(",
"s",
")",
"{",
"// For legacy reasons, 0x80 is not considered a Unicode character.",
"if",
"c",
">",
"0x80",
"{",
"return",
"true",
"\n",
... | // isUnicode reports whether s is a Unicode string. | [
"isUnicode",
"reports",
"whether",
"s",
"is",
"a",
"Unicode",
"string",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L135-L143 |
6,118 | google/safebrowsing | urls.go | escape | func escape(s string) string {
var b bytes.Buffer
for _, c := range []byte(s) {
if c < 0x20 || c >= 0x7f || c == ' ' || c == '#' || c == '%' {
b.WriteString(fmt.Sprintf("%%%02x", c))
} else {
b.WriteByte(c)
}
}
return b.String()
} | go | func escape(s string) string {
var b bytes.Buffer
for _, c := range []byte(s) {
if c < 0x20 || c >= 0x7f || c == ' ' || c == '#' || c == '%' {
b.WriteString(fmt.Sprintf("%%%02x", c))
} else {
b.WriteByte(c)
}
}
return b.String()
} | [
"func",
"escape",
"(",
"s",
"string",
")",
"string",
"{",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"[",
"]",
"byte",
"(",
"s",
")",
"{",
"if",
"c",
"<",
"0x20",
"||",
"c",
">=",
"0x7f",
"||",
"c",
"==",
... | // escape returns the percent-encoded form of the string s. | [
"escape",
"returns",
"the",
"percent",
"-",
"encoded",
"form",
"of",
"the",
"string",
"s",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L164-L174 |
6,119 | google/safebrowsing | urls.go | unescape | func unescape(s string) string {
var b bytes.Buffer
for len(s) > 0 {
if len(s) >= 3 && s[0] == '%' && isHex(s[1]) && isHex(s[2]) {
b.WriteByte(unhex(s[1])<<4 | unhex(s[2]))
s = s[3:]
} else {
b.WriteByte(s[0])
s = s[1:]
}
}
return b.String()
} | go | func unescape(s string) string {
var b bytes.Buffer
for len(s) > 0 {
if len(s) >= 3 && s[0] == '%' && isHex(s[1]) && isHex(s[2]) {
b.WriteByte(unhex(s[1])<<4 | unhex(s[2]))
s = s[3:]
} else {
b.WriteByte(s[0])
s = s[1:]
}
}
return b.String()
} | [
"func",
"unescape",
"(",
"s",
"string",
")",
"string",
"{",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"for",
"len",
"(",
"s",
")",
">",
"0",
"{",
"if",
"len",
"(",
"s",
")",
">=",
"3",
"&&",
"s",
"[",
"0",
"]",
"==",
"'%'",
"&&",
"isHex",
"... | // unescape returns the decoded form of a percent-encoded string s. | [
"unescape",
"returns",
"the",
"decoded",
"form",
"of",
"a",
"percent",
"-",
"encoded",
"string",
"s",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L177-L189 |
6,120 | google/safebrowsing | urls.go | recursiveUnescape | func recursiveUnescape(s string) (string, error) {
const maxDepth = 1024
for i := 0; i < maxDepth; i++ {
t := unescape(s)
if t == s {
return s, nil
}
s = t
}
return "", errors.New("safebrowsing: unescaping is too recursive")
} | go | func recursiveUnescape(s string) (string, error) {
const maxDepth = 1024
for i := 0; i < maxDepth; i++ {
t := unescape(s)
if t == s {
return s, nil
}
s = t
}
return "", errors.New("safebrowsing: unescaping is too recursive")
} | [
"func",
"recursiveUnescape",
"(",
"s",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"const",
"maxDepth",
"=",
"1024",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"maxDepth",
";",
"i",
"++",
"{",
"t",
":=",
"unescape",
"(",
"s",
")",
"\n"... | // recursiveUnescape unescapes the string s recursively until it cannot be
// unescaped anymore. It reports an error if the unescaping process seemed to
// have no end. | [
"recursiveUnescape",
"unescapes",
"the",
"string",
"s",
"recursively",
"until",
"it",
"cannot",
"be",
"unescaped",
"anymore",
".",
"It",
"reports",
"an",
"error",
"if",
"the",
"unescaping",
"process",
"seemed",
"to",
"have",
"no",
"end",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L194-L204 |
6,121 | google/safebrowsing | urls.go | normalizeEscape | func normalizeEscape(s string) (string, error) {
u, err := recursiveUnescape(s)
if err != nil {
return "", err
}
return escape(u), nil
} | go | func normalizeEscape(s string) (string, error) {
u, err := recursiveUnescape(s)
if err != nil {
return "", err
}
return escape(u), nil
} | [
"func",
"normalizeEscape",
"(",
"s",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"recursiveUnescape",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
... | // normalizeEscape performs a recursive unescape and then escapes the string
// exactly once. It reports an error if it was unable to unescape the string. | [
"normalizeEscape",
"performs",
"a",
"recursive",
"unescape",
"and",
"then",
"escapes",
"the",
"string",
"exactly",
"once",
".",
"It",
"reports",
"an",
"error",
"if",
"it",
"was",
"unable",
"to",
"unescape",
"the",
"string",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L208-L214 |
6,122 | google/safebrowsing | urls.go | parseHost | func parseHost(hostish string) (host string, err error) {
i := strings.LastIndex(hostish, "@")
if i < 0 {
host = hostish
} else {
host = hostish[i+1:]
}
if strings.HasPrefix(host, "[") {
// Parse an IP-Literal per RFC 3986 and RFC 6874.
// For example: "[fe80::1] or "[fe80::1%25en0]"
i := strings.LastInd... | go | func parseHost(hostish string) (host string, err error) {
i := strings.LastIndex(hostish, "@")
if i < 0 {
host = hostish
} else {
host = hostish[i+1:]
}
if strings.HasPrefix(host, "[") {
// Parse an IP-Literal per RFC 3986 and RFC 6874.
// For example: "[fe80::1] or "[fe80::1%25en0]"
i := strings.LastInd... | [
"func",
"parseHost",
"(",
"hostish",
"string",
")",
"(",
"host",
"string",
",",
"err",
"error",
")",
"{",
"i",
":=",
"strings",
".",
"LastIndex",
"(",
"hostish",
",",
"\"",
"\"",
")",
"\n",
"if",
"i",
"<",
"0",
"{",
"host",
"=",
"hostish",
"\n",
... | // parseHost parses a string to get host by the stripping the
// username, password, and port. | [
"parseHost",
"parses",
"a",
"string",
"to",
"get",
"host",
"by",
"the",
"stripping",
"the",
"username",
"password",
"and",
"port",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L239-L276 |
6,123 | google/safebrowsing | urls.go | parseURL | func parseURL(urlStr string) (parsedURL *url.URL, err error) {
// For legacy reasons, this is a simplified version of the net/url logic.
//
// Few cases where net/url was not helpful:
// 1. URLs are are expected to have no escaped encoding in the host but to
// be escaped in the path. Safe Browsing allows escaped ... | go | func parseURL(urlStr string) (parsedURL *url.URL, err error) {
// For legacy reasons, this is a simplified version of the net/url logic.
//
// Few cases where net/url was not helpful:
// 1. URLs are are expected to have no escaped encoding in the host but to
// be escaped in the path. Safe Browsing allows escaped ... | [
"func",
"parseURL",
"(",
"urlStr",
"string",
")",
"(",
"parsedURL",
"*",
"url",
".",
"URL",
",",
"err",
"error",
")",
"{",
"// For legacy reasons, this is a simplified version of the net/url logic.",
"//",
"// Few cases where net/url was not helpful:",
"// 1. URLs are are exp... | // parseURL parses urlStr as a url.URL and reports an error if not possible. | [
"parseURL",
"parses",
"urlStr",
"as",
"a",
"url",
".",
"URL",
"and",
"reports",
"an",
"error",
"if",
"not",
"possible",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L279-L337 |
6,124 | google/safebrowsing | urls.go | generateLookupHosts | func generateLookupHosts(urlStr string) ([]string, error) {
// Safe Browsing policy asks to generate lookup hosts for the URL.
// Those are formed by the domain and also up to 4 hostnames suffixes.
// The last component or sometimes the pair isn't examined alone,
// since it's the TLD or country code. The database ... | go | func generateLookupHosts(urlStr string) ([]string, error) {
// Safe Browsing policy asks to generate lookup hosts for the URL.
// Those are formed by the domain and also up to 4 hostnames suffixes.
// The last component or sometimes the pair isn't examined alone,
// since it's the TLD or country code. The database ... | [
"func",
"generateLookupHosts",
"(",
"urlStr",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"// Safe Browsing policy asks to generate lookup hosts for the URL.",
"// Those are formed by the domain and also up to 4 hostnames suffixes.",
"// The last component or some... | // generateLookupHosts returns a list of host-suffixes for the input URL. | [
"generateLookupHosts",
"returns",
"a",
"list",
"of",
"host",
"-",
"suffixes",
"for",
"the",
"input",
"URL",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L423-L457 |
6,125 | google/safebrowsing | urls.go | generateLookupPaths | func generateLookupPaths(urlStr string) ([]string, error) {
const maxPathComponents = 4
parsedURL, err := parseURL(urlStr)
if err != nil {
return nil, err
}
path := parsedURL.Path
paths := []string{"/"}
var pathComponents []string
for _, p := range strings.Split(path, "/") {
if p != "" {
pathComponents... | go | func generateLookupPaths(urlStr string) ([]string, error) {
const maxPathComponents = 4
parsedURL, err := parseURL(urlStr)
if err != nil {
return nil, err
}
path := parsedURL.Path
paths := []string{"/"}
var pathComponents []string
for _, p := range strings.Split(path, "/") {
if p != "" {
pathComponents... | [
"func",
"generateLookupPaths",
"(",
"urlStr",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"const",
"maxPathComponents",
"=",
"4",
"\n\n",
"parsedURL",
",",
"err",
":=",
"parseURL",
"(",
"urlStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // generateLookupPaths returns a list path-prefixes for the input URL. | [
"generateLookupPaths",
"returns",
"a",
"list",
"path",
"-",
"prefixes",
"for",
"the",
"input",
"URL",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/urls.go#L470-L502 |
6,126 | google/safebrowsing | hash.go | hashFromPattern | func hashFromPattern(pattern string) hashPrefix {
hash := sha256.New()
hash.Write([]byte(pattern))
return hashPrefix(hash.Sum(nil))
} | go | func hashFromPattern(pattern string) hashPrefix {
hash := sha256.New()
hash.Write([]byte(pattern))
return hashPrefix(hash.Sum(nil))
} | [
"func",
"hashFromPattern",
"(",
"pattern",
"string",
")",
"hashPrefix",
"{",
"hash",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"pattern",
")",
")",
"\n",
"return",
"hashPrefix",
"(",
"hash",
".",
"S... | // hashFromPattern returns a full hash for the given URL pattern. | [
"hashFromPattern",
"returns",
"a",
"full",
"hash",
"for",
"the",
"given",
"URL",
"pattern",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/hash.go#L39-L43 |
6,127 | google/safebrowsing | hash.go | HasPrefix | func (h hashPrefix) HasPrefix(other hashPrefix) bool {
return strings.HasPrefix(string(h), string(other))
} | go | func (h hashPrefix) HasPrefix(other hashPrefix) bool {
return strings.HasPrefix(string(h), string(other))
} | [
"func",
"(",
"h",
"hashPrefix",
")",
"HasPrefix",
"(",
"other",
"hashPrefix",
")",
"bool",
"{",
"return",
"strings",
".",
"HasPrefix",
"(",
"string",
"(",
"h",
")",
",",
"string",
"(",
"other",
")",
")",
"\n",
"}"
] | // HasPrefix reports whether other is a prefix of h. | [
"HasPrefix",
"reports",
"whether",
"other",
"is",
"a",
"prefix",
"of",
"h",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/hash.go#L46-L48 |
6,128 | google/safebrowsing | hash.go | IsValid | func (h hashPrefix) IsValid() bool {
return len(h) >= minHashPrefixLength && len(h) <= maxHashPrefixLength
} | go | func (h hashPrefix) IsValid() bool {
return len(h) >= minHashPrefixLength && len(h) <= maxHashPrefixLength
} | [
"func",
"(",
"h",
"hashPrefix",
")",
"IsValid",
"(",
")",
"bool",
"{",
"return",
"len",
"(",
"h",
")",
">=",
"minHashPrefixLength",
"&&",
"len",
"(",
"h",
")",
"<=",
"maxHashPrefixLength",
"\n",
"}"
] | // IsValid reports whether the hash is a valid partial or full hash. | [
"IsValid",
"reports",
"whether",
"the",
"hash",
"is",
"a",
"valid",
"partial",
"or",
"full",
"hash",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/hash.go#L56-L58 |
6,129 | google/safebrowsing | hash.go | decodeHashes | func decodeHashes(input *pb.ThreatEntrySet) ([]hashPrefix, error) {
switch input.CompressionType {
case pb.CompressionType_RAW:
raw := input.GetRawHashes()
if raw == nil {
return nil, errors.New("safebrowsing: nil raw hashes")
}
if raw.PrefixSize < minHashPrefixLength || raw.PrefixSize > maxHashPrefixLengt... | go | func decodeHashes(input *pb.ThreatEntrySet) ([]hashPrefix, error) {
switch input.CompressionType {
case pb.CompressionType_RAW:
raw := input.GetRawHashes()
if raw == nil {
return nil, errors.New("safebrowsing: nil raw hashes")
}
if raw.PrefixSize < minHashPrefixLength || raw.PrefixSize > maxHashPrefixLengt... | [
"func",
"decodeHashes",
"(",
"input",
"*",
"pb",
".",
"ThreatEntrySet",
")",
"(",
"[",
"]",
"hashPrefix",
",",
"error",
")",
"{",
"switch",
"input",
".",
"CompressionType",
"{",
"case",
"pb",
".",
"CompressionType_RAW",
":",
"raw",
":=",
"input",
".",
"G... | // decodeHashes takes a ThreatEntrySet and returns a list of hashes that should
// be added to the local database. | [
"decodeHashes",
"takes",
"a",
"ThreatEntrySet",
"and",
"returns",
"a",
"list",
"of",
"hashes",
"that",
"should",
"be",
"added",
"to",
"the",
"local",
"database",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/hash.go#L158-L192 |
6,130 | google/safebrowsing | hash.go | decodeIndices | func decodeIndices(input *pb.ThreatEntrySet) ([]int32, error) {
switch input.CompressionType {
case pb.CompressionType_RAW:
raw := input.GetRawIndices()
if raw == nil {
return nil, errors.New("safebrowsing: invalid raw indices")
}
return raw.Indices, nil
case pb.CompressionType_RICE:
values, err := deco... | go | func decodeIndices(input *pb.ThreatEntrySet) ([]int32, error) {
switch input.CompressionType {
case pb.CompressionType_RAW:
raw := input.GetRawIndices()
if raw == nil {
return nil, errors.New("safebrowsing: invalid raw indices")
}
return raw.Indices, nil
case pb.CompressionType_RICE:
values, err := deco... | [
"func",
"decodeIndices",
"(",
"input",
"*",
"pb",
".",
"ThreatEntrySet",
")",
"(",
"[",
"]",
"int32",
",",
"error",
")",
"{",
"switch",
"input",
".",
"CompressionType",
"{",
"case",
"pb",
".",
"CompressionType_RAW",
":",
"raw",
":=",
"input",
".",
"GetRa... | // decodeIndices takes a ThreatEntrySet for removals returned by the server and
// returns a list of indices that the client should remove from its database. | [
"decodeIndices",
"takes",
"a",
"ThreatEntrySet",
"for",
"removals",
"returned",
"by",
"the",
"server",
"and",
"returns",
"a",
"list",
"of",
"indices",
"that",
"the",
"client",
"should",
"remove",
"from",
"its",
"database",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/hash.go#L196-L217 |
6,131 | google/safebrowsing | hash.go | decodeRiceIntegers | func decodeRiceIntegers(rice *pb.RiceDeltaEncoding) ([]uint32, error) {
if rice == nil {
return nil, errors.New("safebrowsing: missing rice encoded data")
}
if rice.RiceParameter < 0 || rice.RiceParameter > 32 {
return nil, errors.New("safebrowsing: invalid k parameter")
}
values := []uint32{uint32(rice.First... | go | func decodeRiceIntegers(rice *pb.RiceDeltaEncoding) ([]uint32, error) {
if rice == nil {
return nil, errors.New("safebrowsing: missing rice encoded data")
}
if rice.RiceParameter < 0 || rice.RiceParameter > 32 {
return nil, errors.New("safebrowsing: invalid k parameter")
}
values := []uint32{uint32(rice.First... | [
"func",
"decodeRiceIntegers",
"(",
"rice",
"*",
"pb",
".",
"RiceDeltaEncoding",
")",
"(",
"[",
"]",
"uint32",
",",
"error",
")",
"{",
"if",
"rice",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",... | // decodeRiceIntegers decodes a list of Golomb-Rice encoded integers. | [
"decodeRiceIntegers",
"decodes",
"a",
"list",
"of",
"Golomb",
"-",
"Rice",
"encoded",
"integers",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/hash.go#L220-L243 |
6,132 | google/safebrowsing | hash.go | BitsRemaining | func (br *bitReader) BitsRemaining() int {
n := 8 * len(br.buf)
for m := br.mask | 1; m != 1; m >>= 1 {
n--
}
return n
} | go | func (br *bitReader) BitsRemaining() int {
n := 8 * len(br.buf)
for m := br.mask | 1; m != 1; m >>= 1 {
n--
}
return n
} | [
"func",
"(",
"br",
"*",
"bitReader",
")",
"BitsRemaining",
"(",
")",
"int",
"{",
"n",
":=",
"8",
"*",
"len",
"(",
"br",
".",
"buf",
")",
"\n",
"for",
"m",
":=",
"br",
".",
"mask",
"|",
"1",
";",
"m",
"!=",
"1",
";",
"m",
">>=",
"1",
"{",
... | // BitsRemaining reports the number of bits left to read. | [
"BitsRemaining",
"reports",
"the",
"number",
"of",
"bits",
"left",
"to",
"read",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/hash.go#L328-L334 |
6,133 | google/safebrowsing | safebrowser.go | setDefaults | func (c *Config) setDefaults() bool {
if c.ServerURL == "" {
c.ServerURL = DefaultServerURL
}
if len(c.ThreatLists) == 0 {
c.ThreatLists = DefaultThreatLists
}
if c.UpdatePeriod <= 0 {
c.UpdatePeriod = DefaultUpdatePeriod
}
if c.RequestTimeout <= 0 {
c.RequestTimeout = DefaultRequestTimeout
}
if c.comp... | go | func (c *Config) setDefaults() bool {
if c.ServerURL == "" {
c.ServerURL = DefaultServerURL
}
if len(c.ThreatLists) == 0 {
c.ThreatLists = DefaultThreatLists
}
if c.UpdatePeriod <= 0 {
c.UpdatePeriod = DefaultUpdatePeriod
}
if c.RequestTimeout <= 0 {
c.RequestTimeout = DefaultRequestTimeout
}
if c.comp... | [
"func",
"(",
"c",
"*",
"Config",
")",
"setDefaults",
"(",
")",
"bool",
"{",
"if",
"c",
".",
"ServerURL",
"==",
"\"",
"\"",
"{",
"c",
".",
"ServerURL",
"=",
"DefaultServerURL",
"\n",
"}",
"\n",
"if",
"len",
"(",
"c",
".",
"ThreatLists",
")",
"==",
... | // setDefaults configures Config to have default parameters.
// It reports whether the current configuration is valid. | [
"setDefaults",
"configures",
"Config",
"to",
"have",
"default",
"parameters",
".",
"It",
"reports",
"whether",
"the",
"current",
"configuration",
"is",
"valid",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/safebrowser.go#L236-L253 |
6,134 | google/safebrowsing | safebrowser.go | NewSafeBrowser | func NewSafeBrowser(conf Config) (*SafeBrowser, error) {
conf = conf.copy()
if !conf.setDefaults() {
return nil, errors.New("safebrowsing: invalid configuration")
}
// Create the SafeBrowsing object.
if conf.api == nil {
var err error
conf.api, err = newNetAPI(conf.ServerURL, conf.APIKey, conf.ProxyURL)
i... | go | func NewSafeBrowser(conf Config) (*SafeBrowser, error) {
conf = conf.copy()
if !conf.setDefaults() {
return nil, errors.New("safebrowsing: invalid configuration")
}
// Create the SafeBrowsing object.
if conf.api == nil {
var err error
conf.api, err = newNetAPI(conf.ServerURL, conf.APIKey, conf.ProxyURL)
i... | [
"func",
"NewSafeBrowser",
"(",
"conf",
"Config",
")",
"(",
"*",
"SafeBrowser",
",",
"error",
")",
"{",
"conf",
"=",
"conf",
".",
"copy",
"(",
")",
"\n",
"if",
"!",
"conf",
".",
"setDefaults",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New... | // NewSafeBrowser creates a new SafeBrowser.
//
// The conf struct allows the user to configure many aspects of the
// SafeBrowser's operation. | [
"NewSafeBrowser",
"creates",
"a",
"new",
"SafeBrowser",
".",
"The",
"conf",
"struct",
"allows",
"the",
"user",
"to",
"configure",
"many",
"aspects",
"of",
"the",
"SafeBrowser",
"s",
"operation",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/safebrowser.go#L296-L351 |
6,135 | google/safebrowsing | safebrowser.go | Status | func (sb *SafeBrowser) Status() (Stats, error) {
stats := Stats{
QueriesByDatabase: atomic.LoadInt64(&sb.stats.QueriesByDatabase),
QueriesByCache: atomic.LoadInt64(&sb.stats.QueriesByCache),
QueriesByAPI: atomic.LoadInt64(&sb.stats.QueriesByAPI),
QueriesFail: atomic.LoadInt64(&sb.stats.QueriesFai... | go | func (sb *SafeBrowser) Status() (Stats, error) {
stats := Stats{
QueriesByDatabase: atomic.LoadInt64(&sb.stats.QueriesByDatabase),
QueriesByCache: atomic.LoadInt64(&sb.stats.QueriesByCache),
QueriesByAPI: atomic.LoadInt64(&sb.stats.QueriesByAPI),
QueriesFail: atomic.LoadInt64(&sb.stats.QueriesFai... | [
"func",
"(",
"sb",
"*",
"SafeBrowser",
")",
"Status",
"(",
")",
"(",
"Stats",
",",
"error",
")",
"{",
"stats",
":=",
"Stats",
"{",
"QueriesByDatabase",
":",
"atomic",
".",
"LoadInt64",
"(",
"&",
"sb",
".",
"stats",
".",
"QueriesByDatabase",
")",
",",
... | // Status reports the status of SafeBrowser. It returns some statistics
// regarding the operation, and an error representing the status of its
// internal state. Most errors are transient and will recover themselves
// after some period. | [
"Status",
"reports",
"the",
"status",
"of",
"SafeBrowser",
".",
"It",
"returns",
"some",
"statistics",
"regarding",
"the",
"operation",
"and",
"an",
"error",
"representing",
"the",
"status",
"of",
"its",
"internal",
"state",
".",
"Most",
"errors",
"are",
"tran... | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/safebrowser.go#L357-L366 |
6,136 | google/safebrowsing | safebrowser.go | WaitUntilReady | func (sb *SafeBrowser) WaitUntilReady(ctx context.Context) error {
if atomic.LoadUint32(&sb.closed) == 1 {
return errClosed
}
select {
case <-sb.db.Ready():
return nil
case <-ctx.Done():
return ctx.Err()
case <-sb.done:
return errClosed
}
} | go | func (sb *SafeBrowser) WaitUntilReady(ctx context.Context) error {
if atomic.LoadUint32(&sb.closed) == 1 {
return errClosed
}
select {
case <-sb.db.Ready():
return nil
case <-ctx.Done():
return ctx.Err()
case <-sb.done:
return errClosed
}
} | [
"func",
"(",
"sb",
"*",
"SafeBrowser",
")",
"WaitUntilReady",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"sb",
".",
"closed",
")",
"==",
"1",
"{",
"return",
"errClosed",
"\n",
"}",
"\n",
"se... | // WaitUntilReady blocks until the database is not in an error state.
// Returns nil when the database is ready. Returns an error if the provided
// context is canceled or if the SafeBrowser instance is Closed. | [
"WaitUntilReady",
"blocks",
"until",
"the",
"database",
"is",
"not",
"in",
"an",
"error",
"state",
".",
"Returns",
"nil",
"when",
"the",
"database",
"is",
"ready",
".",
"Returns",
"an",
"error",
"if",
"the",
"provided",
"context",
"is",
"canceled",
"or",
"... | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/safebrowser.go#L371-L383 |
6,137 | google/safebrowsing | safebrowser.go | Close | func (sb *SafeBrowser) Close() error {
if atomic.LoadUint32(&sb.closed) == 0 {
atomic.StoreUint32(&sb.closed, 1)
close(sb.done)
}
return nil
} | go | func (sb *SafeBrowser) Close() error {
if atomic.LoadUint32(&sb.closed) == 0 {
atomic.StoreUint32(&sb.closed, 1)
close(sb.done)
}
return nil
} | [
"func",
"(",
"sb",
"*",
"SafeBrowser",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"sb",
".",
"closed",
")",
"==",
"0",
"{",
"atomic",
".",
"StoreUint32",
"(",
"&",
"sb",
".",
"closed",
",",
"1",
")",
"\n",
... | // Close cleans up all resources.
// This method must not be called concurrently with other lookup methods. | [
"Close",
"cleans",
"up",
"all",
"resources",
".",
"This",
"method",
"must",
"not",
"be",
"called",
"concurrently",
"with",
"other",
"lookup",
"methods",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/safebrowser.go#L576-L582 |
6,138 | google/safebrowsing | api.go | doRequest | func (a *netAPI) doRequest(ctx context.Context, requestPath string, req proto.Message, resp proto.Message) error {
p, err := proto.Marshal(req)
if err != nil {
return err
}
u := *a.url // Make a copy of URL
u.Path = requestPath
httpReq, err := http.NewRequest("POST", u.String(), bytes.NewReader(p))
httpReq.He... | go | func (a *netAPI) doRequest(ctx context.Context, requestPath string, req proto.Message, resp proto.Message) error {
p, err := proto.Marshal(req)
if err != nil {
return err
}
u := *a.url // Make a copy of URL
u.Path = requestPath
httpReq, err := http.NewRequest("POST", u.String(), bytes.NewReader(p))
httpReq.He... | [
"func",
"(",
"a",
"*",
"netAPI",
")",
"doRequest",
"(",
"ctx",
"context",
".",
"Context",
",",
"requestPath",
"string",
",",
"req",
"proto",
".",
"Message",
",",
"resp",
"proto",
".",
"Message",
")",
"error",
"{",
"p",
",",
"err",
":=",
"proto",
".",... | // doRequests performs a POST to requestPath. It uses the marshaled form of req
// as the request body payload, and automatically unmarshals the response body
// payload as resp. | [
"doRequests",
"performs",
"a",
"POST",
"to",
"requestPath",
".",
"It",
"uses",
"the",
"marshaled",
"form",
"of",
"req",
"as",
"the",
"request",
"body",
"payload",
"and",
"automatically",
"unmarshals",
"the",
"response",
"body",
"payload",
"as",
"resp",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/api.go#L81-L105 |
6,139 | google/safebrowsing | api.go | ListUpdate | func (a *netAPI) ListUpdate(ctx context.Context, req *pb.FetchThreatListUpdatesRequest) (*pb.FetchThreatListUpdatesResponse, error) {
resp := new(pb.FetchThreatListUpdatesResponse)
return resp, a.doRequest(ctx, fetchUpdatePath, req, resp)
} | go | func (a *netAPI) ListUpdate(ctx context.Context, req *pb.FetchThreatListUpdatesRequest) (*pb.FetchThreatListUpdatesResponse, error) {
resp := new(pb.FetchThreatListUpdatesResponse)
return resp, a.doRequest(ctx, fetchUpdatePath, req, resp)
} | [
"func",
"(",
"a",
"*",
"netAPI",
")",
"ListUpdate",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"pb",
".",
"FetchThreatListUpdatesRequest",
")",
"(",
"*",
"pb",
".",
"FetchThreatListUpdatesResponse",
",",
"error",
")",
"{",
"resp",
":=",
"new",... | // ListUpdate issues a FetchThreatListUpdates API call and returns the response. | [
"ListUpdate",
"issues",
"a",
"FetchThreatListUpdates",
"API",
"call",
"and",
"returns",
"the",
"response",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/api.go#L108-L111 |
6,140 | google/safebrowsing | api.go | HashLookup | func (a *netAPI) HashLookup(ctx context.Context, req *pb.FindFullHashesRequest) (*pb.FindFullHashesResponse, error) {
resp := new(pb.FindFullHashesResponse)
return resp, a.doRequest(ctx, findHashPath, req, resp)
} | go | func (a *netAPI) HashLookup(ctx context.Context, req *pb.FindFullHashesRequest) (*pb.FindFullHashesResponse, error) {
resp := new(pb.FindFullHashesResponse)
return resp, a.doRequest(ctx, findHashPath, req, resp)
} | [
"func",
"(",
"a",
"*",
"netAPI",
")",
"HashLookup",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"pb",
".",
"FindFullHashesRequest",
")",
"(",
"*",
"pb",
".",
"FindFullHashesResponse",
",",
"error",
")",
"{",
"resp",
":=",
"new",
"(",
"pb",
... | // HashLookup issues a FindFullHashes API call and returns the response. | [
"HashLookup",
"issues",
"a",
"FindFullHashes",
"API",
"call",
"and",
"returns",
"the",
"response",
"."
] | 92a16cf6d02871018d6a426fb7886e34022c5c59 | https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/api.go#L114-L117 |
6,141 | gorilla/feeds | json.go | MarshalJSON | func (a *JSONAttachment) MarshalJSON() ([]byte, error) {
type EmbeddedJSONAttachment JSONAttachment
return json.Marshal(&struct {
Duration float64 `json:"duration_in_seconds,omitempty"`
*EmbeddedJSONAttachment
}{
EmbeddedJSONAttachment: (*EmbeddedJSONAttachment)(a),
Duration: a.Duration.Seconds... | go | func (a *JSONAttachment) MarshalJSON() ([]byte, error) {
type EmbeddedJSONAttachment JSONAttachment
return json.Marshal(&struct {
Duration float64 `json:"duration_in_seconds,omitempty"`
*EmbeddedJSONAttachment
}{
EmbeddedJSONAttachment: (*EmbeddedJSONAttachment)(a),
Duration: a.Duration.Seconds... | [
"func",
"(",
"a",
"*",
"JSONAttachment",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"type",
"EmbeddedJSONAttachment",
"JSONAttachment",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"&",
"struct",
"{",
"Duration",
"float64"... | // MarshalJSON implements the json.Marshaler interface.
// The Duration field is marshaled in seconds, all other fields are marshaled
// based upon the definitions in struct tags. | [
"MarshalJSON",
"implements",
"the",
"json",
".",
"Marshaler",
"interface",
".",
"The",
"Duration",
"field",
"is",
"marshaled",
"in",
"seconds",
"all",
"other",
"fields",
"are",
"marshaled",
"based",
"upon",
"the",
"definitions",
"in",
"struct",
"tags",
"."
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/json.go#L32-L41 |
6,142 | gorilla/feeds | json.go | UnmarshalJSON | func (a *JSONAttachment) UnmarshalJSON(data []byte) error {
type EmbeddedJSONAttachment JSONAttachment
var raw struct {
Duration float64 `json:"duration_in_seconds,omitempty"`
*EmbeddedJSONAttachment
}
raw.EmbeddedJSONAttachment = (*EmbeddedJSONAttachment)(a)
err := json.Unmarshal(data, &raw)
if err != nil {... | go | func (a *JSONAttachment) UnmarshalJSON(data []byte) error {
type EmbeddedJSONAttachment JSONAttachment
var raw struct {
Duration float64 `json:"duration_in_seconds,omitempty"`
*EmbeddedJSONAttachment
}
raw.EmbeddedJSONAttachment = (*EmbeddedJSONAttachment)(a)
err := json.Unmarshal(data, &raw)
if err != nil {... | [
"func",
"(",
"a",
"*",
"JSONAttachment",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"type",
"EmbeddedJSONAttachment",
"JSONAttachment",
"\n",
"var",
"raw",
"struct",
"{",
"Duration",
"float64",
"`json:\"duration_in_seconds,omitempty\"`",... | // UnmarshalJSON implements the json.Unmarshaler interface.
// The Duration field is expected to be in seconds, all other field types
// match the struct definition. | [
"UnmarshalJSON",
"implements",
"the",
"json",
".",
"Unmarshaler",
"interface",
".",
"The",
"Duration",
"field",
"is",
"expected",
"to",
"be",
"in",
"seconds",
"all",
"other",
"field",
"types",
"match",
"the",
"struct",
"definition",
"."
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/json.go#L46-L65 |
6,143 | gorilla/feeds | json.go | ToJSON | func (f *JSONFeed) ToJSON() (string, error) {
data, err := json.MarshalIndent(f, "", " ")
if err != nil {
return "", err
}
return string(data), nil
} | go | func (f *JSONFeed) ToJSON() (string, error) {
data, err := json.MarshalIndent(f, "", " ")
if err != nil {
return "", err
}
return string(data), nil
} | [
"func",
"(",
"f",
"*",
"JSONFeed",
")",
"ToJSON",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"f",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"... | // ToJSON encodes f into a JSON string. Returns an error if marshalling fails. | [
"ToJSON",
"encodes",
"f",
"into",
"a",
"JSON",
"string",
".",
"Returns",
"an",
"error",
"if",
"marshalling",
"fails",
"."
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/json.go#L121-L128 |
6,144 | gorilla/feeds | json.go | JSONFeed | func (f *JSON) JSONFeed() *JSONFeed {
feed := &JSONFeed{
Version: jsonFeedVersion,
Title: f.Title,
Description: f.Description,
}
if f.Link != nil {
feed.HomePageUrl = f.Link.Href
}
if f.Author != nil {
feed.Author = &JSONAuthor{
Name: f.Author.Name,
}
}
for _, e := range f.Items {
fee... | go | func (f *JSON) JSONFeed() *JSONFeed {
feed := &JSONFeed{
Version: jsonFeedVersion,
Title: f.Title,
Description: f.Description,
}
if f.Link != nil {
feed.HomePageUrl = f.Link.Href
}
if f.Author != nil {
feed.Author = &JSONAuthor{
Name: f.Author.Name,
}
}
for _, e := range f.Items {
fee... | [
"func",
"(",
"f",
"*",
"JSON",
")",
"JSONFeed",
"(",
")",
"*",
"JSONFeed",
"{",
"feed",
":=",
"&",
"JSONFeed",
"{",
"Version",
":",
"jsonFeedVersion",
",",
"Title",
":",
"f",
".",
"Title",
",",
"Description",
":",
"f",
".",
"Description",
",",
"}",
... | // JSONFeed creates a new JSONFeed with a generic Feed struct's data. | [
"JSONFeed",
"creates",
"a",
"new",
"JSONFeed",
"with",
"a",
"generic",
"Feed",
"struct",
"s",
"data",
"."
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/json.go#L131-L150 |
6,145 | gorilla/feeds | rss.go | newRssItem | func newRssItem(i *Item) *RssItem {
item := &RssItem{
Title: i.Title,
Link: i.Link.Href,
Description: i.Description,
Guid: i.Id,
PubDate: anyTimeFormat(time.RFC1123Z, i.Created, i.Updated),
}
if len(i.Content) > 0 {
item.Content = &RssContent{Content: i.Content}
}
if i.Source !=... | go | func newRssItem(i *Item) *RssItem {
item := &RssItem{
Title: i.Title,
Link: i.Link.Href,
Description: i.Description,
Guid: i.Id,
PubDate: anyTimeFormat(time.RFC1123Z, i.Created, i.Updated),
}
if len(i.Content) > 0 {
item.Content = &RssContent{Content: i.Content}
}
if i.Source !=... | [
"func",
"newRssItem",
"(",
"i",
"*",
"Item",
")",
"*",
"RssItem",
"{",
"item",
":=",
"&",
"RssItem",
"{",
"Title",
":",
"i",
".",
"Title",
",",
"Link",
":",
"i",
".",
"Link",
".",
"Href",
",",
"Description",
":",
"i",
".",
"Description",
",",
"Gu... | // create a new RssItem with a generic Item struct's data | [
"create",
"a",
"new",
"RssItem",
"with",
"a",
"generic",
"Item",
"struct",
"s",
"data"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/rss.go#L95-L119 |
6,146 | gorilla/feeds | rss.go | RssFeed | func (r *Rss) RssFeed() *RssFeed {
pub := anyTimeFormat(time.RFC1123Z, r.Created, r.Updated)
build := anyTimeFormat(time.RFC1123Z, r.Updated)
author := ""
if r.Author != nil {
author = r.Author.Email
if len(r.Author.Name) > 0 {
author = fmt.Sprintf("%s (%s)", r.Author.Email, r.Author.Name)
}
}
var image... | go | func (r *Rss) RssFeed() *RssFeed {
pub := anyTimeFormat(time.RFC1123Z, r.Created, r.Updated)
build := anyTimeFormat(time.RFC1123Z, r.Updated)
author := ""
if r.Author != nil {
author = r.Author.Email
if len(r.Author.Name) > 0 {
author = fmt.Sprintf("%s (%s)", r.Author.Email, r.Author.Name)
}
}
var image... | [
"func",
"(",
"r",
"*",
"Rss",
")",
"RssFeed",
"(",
")",
"*",
"RssFeed",
"{",
"pub",
":=",
"anyTimeFormat",
"(",
"time",
".",
"RFC1123Z",
",",
"r",
".",
"Created",
",",
"r",
".",
"Updated",
")",
"\n",
"build",
":=",
"anyTimeFormat",
"(",
"time",
"."... | // create a new RssFeed with a generic Feed struct's data | [
"create",
"a",
"new",
"RssFeed",
"with",
"a",
"generic",
"Feed",
"struct",
"s",
"data"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/rss.go#L122-L152 |
6,147 | gorilla/feeds | feed.go | Add | func (f *Feed) Add(item *Item) {
f.Items = append(f.Items, item)
} | go | func (f *Feed) Add(item *Item) {
f.Items = append(f.Items, item)
} | [
"func",
"(",
"f",
"*",
"Feed",
")",
"Add",
"(",
"item",
"*",
"Item",
")",
"{",
"f",
".",
"Items",
"=",
"append",
"(",
"f",
".",
"Items",
",",
"item",
")",
"\n",
"}"
] | // add a new Item to a Feed | [
"add",
"a",
"new",
"Item",
"to",
"a",
"Feed"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L56-L58 |
6,148 | gorilla/feeds | feed.go | anyTimeFormat | func anyTimeFormat(format string, times ...time.Time) string {
for _, t := range times {
if !t.IsZero() {
return t.Format(format)
}
}
return ""
} | go | func anyTimeFormat(format string, times ...time.Time) string {
for _, t := range times {
if !t.IsZero() {
return t.Format(format)
}
}
return ""
} | [
"func",
"anyTimeFormat",
"(",
"format",
"string",
",",
"times",
"...",
"time",
".",
"Time",
")",
"string",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"times",
"{",
"if",
"!",
"t",
".",
"IsZero",
"(",
")",
"{",
"return",
"t",
".",
"Format",
"(",
"f... | // returns the first non-zero time formatted as a string or "" | [
"returns",
"the",
"first",
"non",
"-",
"zero",
"time",
"formatted",
"as",
"a",
"string",
"or"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L61-L68 |
6,149 | gorilla/feeds | feed.go | ToAtom | func (f *Feed) ToAtom() (string, error) {
a := &Atom{f}
return ToXML(a)
} | go | func (f *Feed) ToAtom() (string, error) {
a := &Atom{f}
return ToXML(a)
} | [
"func",
"(",
"f",
"*",
"Feed",
")",
"ToAtom",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"a",
":=",
"&",
"Atom",
"{",
"f",
"}",
"\n",
"return",
"ToXML",
"(",
"a",
")",
"\n",
"}"
] | // creates an Atom representation of this feed | [
"creates",
"an",
"Atom",
"representation",
"of",
"this",
"feed"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L102-L105 |
6,150 | gorilla/feeds | feed.go | WriteAtom | func (f *Feed) WriteAtom(w io.Writer) error {
return WriteXML(&Atom{f}, w)
} | go | func (f *Feed) WriteAtom(w io.Writer) error {
return WriteXML(&Atom{f}, w)
} | [
"func",
"(",
"f",
"*",
"Feed",
")",
"WriteAtom",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"return",
"WriteXML",
"(",
"&",
"Atom",
"{",
"f",
"}",
",",
"w",
")",
"\n",
"}"
] | // WriteAtom writes an Atom representation of this feed to the writer. | [
"WriteAtom",
"writes",
"an",
"Atom",
"representation",
"of",
"this",
"feed",
"to",
"the",
"writer",
"."
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L108-L110 |
6,151 | gorilla/feeds | feed.go | ToRss | func (f *Feed) ToRss() (string, error) {
r := &Rss{f}
return ToXML(r)
} | go | func (f *Feed) ToRss() (string, error) {
r := &Rss{f}
return ToXML(r)
} | [
"func",
"(",
"f",
"*",
"Feed",
")",
"ToRss",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"r",
":=",
"&",
"Rss",
"{",
"f",
"}",
"\n",
"return",
"ToXML",
"(",
"r",
")",
"\n",
"}"
] | // creates an Rss representation of this feed | [
"creates",
"an",
"Rss",
"representation",
"of",
"this",
"feed"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L113-L116 |
6,152 | gorilla/feeds | feed.go | WriteRss | func (f *Feed) WriteRss(w io.Writer) error {
return WriteXML(&Rss{f}, w)
} | go | func (f *Feed) WriteRss(w io.Writer) error {
return WriteXML(&Rss{f}, w)
} | [
"func",
"(",
"f",
"*",
"Feed",
")",
"WriteRss",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"return",
"WriteXML",
"(",
"&",
"Rss",
"{",
"f",
"}",
",",
"w",
")",
"\n",
"}"
] | // WriteRss writes an RSS representation of this feed to the writer. | [
"WriteRss",
"writes",
"an",
"RSS",
"representation",
"of",
"this",
"feed",
"to",
"the",
"writer",
"."
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L119-L121 |
6,153 | gorilla/feeds | feed.go | ToJSON | func (f *Feed) ToJSON() (string, error) {
j := &JSON{f}
return j.ToJSON()
} | go | func (f *Feed) ToJSON() (string, error) {
j := &JSON{f}
return j.ToJSON()
} | [
"func",
"(",
"f",
"*",
"Feed",
")",
"ToJSON",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"j",
":=",
"&",
"JSON",
"{",
"f",
"}",
"\n",
"return",
"j",
".",
"ToJSON",
"(",
")",
"\n",
"}"
] | // ToJSON creates a JSON Feed representation of this feed | [
"ToJSON",
"creates",
"a",
"JSON",
"Feed",
"representation",
"of",
"this",
"feed"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L124-L127 |
6,154 | gorilla/feeds | feed.go | WriteJSON | func (f *Feed) WriteJSON(w io.Writer) error {
j := &JSON{f}
feed := j.JSONFeed()
e := json.NewEncoder(w)
e.SetIndent("", " ")
return e.Encode(feed)
} | go | func (f *Feed) WriteJSON(w io.Writer) error {
j := &JSON{f}
feed := j.JSONFeed()
e := json.NewEncoder(w)
e.SetIndent("", " ")
return e.Encode(feed)
} | [
"func",
"(",
"f",
"*",
"Feed",
")",
"WriteJSON",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"j",
":=",
"&",
"JSON",
"{",
"f",
"}",
"\n",
"feed",
":=",
"j",
".",
"JSONFeed",
"(",
")",
"\n\n",
"e",
":=",
"json",
".",
"NewEncoder",
"(",
"... | // WriteJSON writes an JSON representation of this feed to the writer. | [
"WriteJSON",
"writes",
"an",
"JSON",
"representation",
"of",
"this",
"feed",
"to",
"the",
"writer",
"."
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L130-L137 |
6,155 | gorilla/feeds | feed.go | Sort | func (f *Feed) Sort(less func(a, b *Item) bool) {
lessFunc := func(i, j int) bool {
return less(f.Items[i], f.Items[j])
}
sort.SliceStable(f.Items, lessFunc)
} | go | func (f *Feed) Sort(less func(a, b *Item) bool) {
lessFunc := func(i, j int) bool {
return less(f.Items[i], f.Items[j])
}
sort.SliceStable(f.Items, lessFunc)
} | [
"func",
"(",
"f",
"*",
"Feed",
")",
"Sort",
"(",
"less",
"func",
"(",
"a",
",",
"b",
"*",
"Item",
")",
"bool",
")",
"{",
"lessFunc",
":=",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"less",
"(",
"f",
".",
"Items",
"[",
"... | // Sort sorts the Items in the feed with the given less function. | [
"Sort",
"sorts",
"the",
"Items",
"in",
"the",
"feed",
"with",
"the",
"given",
"less",
"function",
"."
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/feed.go#L140-L145 |
6,156 | gorilla/feeds | uuid.go | NewUUID | func NewUUID() *UUID {
u := &UUID{}
_, err := rand.Read(u[:16])
if err != nil {
panic(err)
}
u[8] = (u[8] | 0x80) & 0xBf
u[6] = (u[6] | 0x40) & 0x4f
return u
} | go | func NewUUID() *UUID {
u := &UUID{}
_, err := rand.Read(u[:16])
if err != nil {
panic(err)
}
u[8] = (u[8] | 0x80) & 0xBf
u[6] = (u[6] | 0x40) & 0x4f
return u
} | [
"func",
"NewUUID",
"(",
")",
"*",
"UUID",
"{",
"u",
":=",
"&",
"UUID",
"{",
"}",
"\n",
"_",
",",
"err",
":=",
"rand",
".",
"Read",
"(",
"u",
"[",
":",
"16",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}... | // create a new uuid v4 | [
"create",
"a",
"new",
"uuid",
"v4"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/uuid.go#L13-L23 |
6,157 | gorilla/feeds | atom.go | AtomFeed | func (a *Atom) AtomFeed() *AtomFeed {
updated := anyTimeFormat(time.RFC3339, a.Updated, a.Created)
feed := &AtomFeed{
Xmlns: ns,
Title: a.Title,
Link: &AtomLink{Href: a.Link.Href, Rel: a.Link.Rel},
Subtitle: a.Description,
Id: a.Link.Href,
Updated: updated,
Rights: a.Copyright,
}
if... | go | func (a *Atom) AtomFeed() *AtomFeed {
updated := anyTimeFormat(time.RFC3339, a.Updated, a.Created)
feed := &AtomFeed{
Xmlns: ns,
Title: a.Title,
Link: &AtomLink{Href: a.Link.Href, Rel: a.Link.Rel},
Subtitle: a.Description,
Id: a.Link.Href,
Updated: updated,
Rights: a.Copyright,
}
if... | [
"func",
"(",
"a",
"*",
"Atom",
")",
"AtomFeed",
"(",
")",
"*",
"AtomFeed",
"{",
"updated",
":=",
"anyTimeFormat",
"(",
"time",
".",
"RFC3339",
",",
"a",
".",
"Updated",
",",
"a",
".",
"Created",
")",
"\n",
"feed",
":=",
"&",
"AtomFeed",
"{",
"Xmlns... | // create a new AtomFeed with a generic Feed struct's data | [
"create",
"a",
"new",
"AtomFeed",
"with",
"a",
"generic",
"Feed",
"struct",
"s",
"data"
] | 2079b9bbce59c062ad62eecb771e3ed3a772b8e4 | https://github.com/gorilla/feeds/blob/2079b9bbce59c062ad62eecb771e3ed3a772b8e4/atom.go#L141-L159 |
6,158 | modern-go/reflect2 | unsafe_link.go | add | func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
return unsafe.Pointer(uintptr(p) + x)
} | go | func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
return unsafe.Pointer(uintptr(p) + x)
} | [
"func",
"add",
"(",
"p",
"unsafe",
".",
"Pointer",
",",
"x",
"uintptr",
",",
"whySafe",
"string",
")",
"unsafe",
".",
"Pointer",
"{",
"return",
"unsafe",
".",
"Pointer",
"(",
"uintptr",
"(",
"p",
")",
"+",
"x",
")",
"\n",
"}"
] | // add returns p+x.
//
// The whySafe string is ignored, so that the function still inlines
// as efficiently as p+x, but all call sites should use the string to
// record why the addition is safe, which is to say why the addition
// does not cause x to advance to the very end of p's allocation
// and therefore point i... | [
"add",
"returns",
"p",
"+",
"x",
".",
"The",
"whySafe",
"string",
"is",
"ignored",
"so",
"that",
"the",
"function",
"still",
"inlines",
"as",
"efficiently",
"as",
"p",
"+",
"x",
"but",
"all",
"call",
"sites",
"should",
"use",
"the",
"string",
"to",
"re... | 94122c33edd36123c84d5368cfb2b69df93a0ec8 | https://github.com/modern-go/reflect2/blob/94122c33edd36123c84d5368cfb2b69df93a0ec8/unsafe_link.go#L57-L59 |
6,159 | modern-go/reflect2 | type_map.go | discoverTypes | func discoverTypes() {
types = make(map[string]reflect.Type)
packages = make(map[string]map[string]reflect.Type)
ver := runtime.Version()
if ver == "go1.5" || strings.HasPrefix(ver, "go1.5.") {
loadGo15Types()
} else if ver == "go1.6" || strings.HasPrefix(ver, "go1.6.") {
loadGo15Types()
} else {
loadGo17T... | go | func discoverTypes() {
types = make(map[string]reflect.Type)
packages = make(map[string]map[string]reflect.Type)
ver := runtime.Version()
if ver == "go1.5" || strings.HasPrefix(ver, "go1.5.") {
loadGo15Types()
} else if ver == "go1.6" || strings.HasPrefix(ver, "go1.6.") {
loadGo15Types()
} else {
loadGo17T... | [
"func",
"discoverTypes",
"(",
")",
"{",
"types",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"reflect",
".",
"Type",
")",
"\n",
"packages",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"reflect",
".",
"Type",
")",
"\n\n"... | // discoverTypes initializes types and packages | [
"discoverTypes",
"initializes",
"types",
"and",
"packages"
] | 94122c33edd36123c84d5368cfb2b69df93a0ec8 | https://github.com/modern-go/reflect2/blob/94122c33edd36123c84d5368cfb2b69df93a0ec8/type_map.go#L26-L38 |
6,160 | modern-go/reflect2 | type_map.go | TypeByName | func TypeByName(typeName string) Type {
initOnce.Do(discoverTypes)
return Type2(types[typeName])
} | go | func TypeByName(typeName string) Type {
initOnce.Do(discoverTypes)
return Type2(types[typeName])
} | [
"func",
"TypeByName",
"(",
"typeName",
"string",
")",
"Type",
"{",
"initOnce",
".",
"Do",
"(",
"discoverTypes",
")",
"\n",
"return",
"Type2",
"(",
"types",
"[",
"typeName",
"]",
")",
"\n",
"}"
] | // TypeByName return the type by its name, just like Class.forName in java | [
"TypeByName",
"return",
"the",
"type",
"by",
"its",
"name",
"just",
"like",
"Class",
".",
"forName",
"in",
"java"
] | 94122c33edd36123c84d5368cfb2b69df93a0ec8 | https://github.com/modern-go/reflect2/blob/94122c33edd36123c84d5368cfb2b69df93a0ec8/type_map.go#L100-L103 |
6,161 | modern-go/reflect2 | type_map.go | TypeByPackageName | func TypeByPackageName(pkgPath string, name string) Type {
initOnce.Do(discoverTypes)
pkgTypes := packages[pkgPath]
if pkgTypes == nil {
return nil
}
return Type2(pkgTypes[name])
} | go | func TypeByPackageName(pkgPath string, name string) Type {
initOnce.Do(discoverTypes)
pkgTypes := packages[pkgPath]
if pkgTypes == nil {
return nil
}
return Type2(pkgTypes[name])
} | [
"func",
"TypeByPackageName",
"(",
"pkgPath",
"string",
",",
"name",
"string",
")",
"Type",
"{",
"initOnce",
".",
"Do",
"(",
"discoverTypes",
")",
"\n",
"pkgTypes",
":=",
"packages",
"[",
"pkgPath",
"]",
"\n",
"if",
"pkgTypes",
"==",
"nil",
"{",
"return",
... | // TypeByPackageName return the type by its package and name | [
"TypeByPackageName",
"return",
"the",
"type",
"by",
"its",
"package",
"and",
"name"
] | 94122c33edd36123c84d5368cfb2b69df93a0ec8 | https://github.com/modern-go/reflect2/blob/94122c33edd36123c84d5368cfb2b69df93a0ec8/type_map.go#L106-L113 |
6,162 | ncw/swift | dlo.go | DynamicLargeObjectCreateFile | func (c *Connection) DynamicLargeObjectCreateFile(opts *LargeObjectOpts) (LargeObjectFile, error) {
lo, err := c.largeObjectCreate(opts)
if err != nil {
return nil, err
}
return withBuffer(opts, &DynamicLargeObjectCreateFile{
largeObjectCreateFile: *lo,
}), nil
} | go | func (c *Connection) DynamicLargeObjectCreateFile(opts *LargeObjectOpts) (LargeObjectFile, error) {
lo, err := c.largeObjectCreate(opts)
if err != nil {
return nil, err
}
return withBuffer(opts, &DynamicLargeObjectCreateFile{
largeObjectCreateFile: *lo,
}), nil
} | [
"func",
"(",
"c",
"*",
"Connection",
")",
"DynamicLargeObjectCreateFile",
"(",
"opts",
"*",
"LargeObjectOpts",
")",
"(",
"LargeObjectFile",
",",
"error",
")",
"{",
"lo",
",",
"err",
":=",
"c",
".",
"largeObjectCreate",
"(",
"opts",
")",
"\n",
"if",
"err",
... | // DynamicLargeObjectCreateFile creates a dynamic large object
// returning an object which satisfies io.Writer, io.Seeker, io.Closer
// and io.ReaderFrom. The flags are as passes to the
// largeObjectCreate method. | [
"DynamicLargeObjectCreateFile",
"creates",
"a",
"dynamic",
"large",
"object",
"returning",
"an",
"object",
"which",
"satisfies",
"io",
".",
"Writer",
"io",
".",
"Seeker",
"io",
".",
"Closer",
"and",
"io",
".",
"ReaderFrom",
".",
"The",
"flags",
"are",
"as",
... | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/dlo.go#L16-L25 |
6,163 | ncw/swift | dlo.go | DynamicLargeObjectCreate | func (c *Connection) DynamicLargeObjectCreate(opts *LargeObjectOpts) (LargeObjectFile, error) {
opts.Flags = os.O_TRUNC | os.O_CREATE
return c.DynamicLargeObjectCreateFile(opts)
} | go | func (c *Connection) DynamicLargeObjectCreate(opts *LargeObjectOpts) (LargeObjectFile, error) {
opts.Flags = os.O_TRUNC | os.O_CREATE
return c.DynamicLargeObjectCreateFile(opts)
} | [
"func",
"(",
"c",
"*",
"Connection",
")",
"DynamicLargeObjectCreate",
"(",
"opts",
"*",
"LargeObjectOpts",
")",
"(",
"LargeObjectFile",
",",
"error",
")",
"{",
"opts",
".",
"Flags",
"=",
"os",
".",
"O_TRUNC",
"|",
"os",
".",
"O_CREATE",
"\n",
"return",
"... | // DynamicLargeObjectCreate creates or truncates an existing dynamic
// large object returning a writeable object. This sets opts.Flags to
// an appropriate value before calling DynamicLargeObjectCreateFile | [
"DynamicLargeObjectCreate",
"creates",
"or",
"truncates",
"an",
"existing",
"dynamic",
"large",
"object",
"returning",
"a",
"writeable",
"object",
".",
"This",
"sets",
"opts",
".",
"Flags",
"to",
"an",
"appropriate",
"value",
"before",
"calling",
"DynamicLargeObject... | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/dlo.go#L30-L33 |
6,164 | ncw/swift | dlo.go | DynamicLargeObjectDelete | func (c *Connection) DynamicLargeObjectDelete(container string, path string) error {
return c.LargeObjectDelete(container, path)
} | go | func (c *Connection) DynamicLargeObjectDelete(container string, path string) error {
return c.LargeObjectDelete(container, path)
} | [
"func",
"(",
"c",
"*",
"Connection",
")",
"DynamicLargeObjectDelete",
"(",
"container",
"string",
",",
"path",
"string",
")",
"error",
"{",
"return",
"c",
".",
"LargeObjectDelete",
"(",
"container",
",",
"path",
")",
"\n",
"}"
] | // DynamicLargeObjectDelete deletes a dynamic large object and all of its segments. | [
"DynamicLargeObjectDelete",
"deletes",
"a",
"dynamic",
"large",
"object",
"and",
"all",
"of",
"its",
"segments",
"."
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/dlo.go#L36-L38 |
6,165 | ncw/swift | dlo.go | DynamicLargeObjectMove | func (c *Connection) DynamicLargeObjectMove(srcContainer string, srcObjectName string, dstContainer string, dstObjectName string) error {
info, headers, err := c.Object(dstContainer, srcObjectName)
if err != nil {
return err
}
segmentContainer, segmentPath := parseFullPath(headers["X-Object-Manifest"])
if err :... | go | func (c *Connection) DynamicLargeObjectMove(srcContainer string, srcObjectName string, dstContainer string, dstObjectName string) error {
info, headers, err := c.Object(dstContainer, srcObjectName)
if err != nil {
return err
}
segmentContainer, segmentPath := parseFullPath(headers["X-Object-Manifest"])
if err :... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"DynamicLargeObjectMove",
"(",
"srcContainer",
"string",
",",
"srcObjectName",
"string",
",",
"dstContainer",
"string",
",",
"dstObjectName",
"string",
")",
"error",
"{",
"info",
",",
"headers",
",",
"err",
":=",
"c",
... | // DynamicLargeObjectMove moves a dynamic large object from srcContainer, srcObjectName to dstContainer, dstObjectName | [
"DynamicLargeObjectMove",
"moves",
"a",
"dynamic",
"large",
"object",
"from",
"srcContainer",
"srcObjectName",
"to",
"dstContainer",
"dstObjectName"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/dlo.go#L41-L57 |
6,166 | ncw/swift | dlo.go | createDLOManifest | func (c *Connection) createDLOManifest(container string, objectName string, prefix string, contentType string) error {
headers := make(Headers)
headers["X-Object-Manifest"] = prefix
manifest, err := c.ObjectCreate(container, objectName, false, "", contentType, headers)
if err != nil {
return err
}
if err := ma... | go | func (c *Connection) createDLOManifest(container string, objectName string, prefix string, contentType string) error {
headers := make(Headers)
headers["X-Object-Manifest"] = prefix
manifest, err := c.ObjectCreate(container, objectName, false, "", contentType, headers)
if err != nil {
return err
}
if err := ma... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"createDLOManifest",
"(",
"container",
"string",
",",
"objectName",
"string",
",",
"prefix",
"string",
",",
"contentType",
"string",
")",
"error",
"{",
"headers",
":=",
"make",
"(",
"Headers",
")",
"\n",
"headers",
... | // createDLOManifest creates a dynamic large object manifest | [
"createDLOManifest",
"creates",
"a",
"dynamic",
"large",
"object",
"manifest"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/dlo.go#L60-L73 |
6,167 | ncw/swift | auth.go | newAuth | func newAuth(c *Connection) (Authenticator, error) {
AuthVersion := c.AuthVersion
if AuthVersion == 0 {
if strings.Contains(c.AuthUrl, "v3") {
AuthVersion = 3
} else if strings.Contains(c.AuthUrl, "v2") {
AuthVersion = 2
} else if strings.Contains(c.AuthUrl, "v1") {
AuthVersion = 1
} else {
return... | go | func newAuth(c *Connection) (Authenticator, error) {
AuthVersion := c.AuthVersion
if AuthVersion == 0 {
if strings.Contains(c.AuthUrl, "v3") {
AuthVersion = 3
} else if strings.Contains(c.AuthUrl, "v2") {
AuthVersion = 2
} else if strings.Contains(c.AuthUrl, "v1") {
AuthVersion = 1
} else {
return... | [
"func",
"newAuth",
"(",
"c",
"*",
"Connection",
")",
"(",
"Authenticator",
",",
"error",
")",
"{",
"AuthVersion",
":=",
"c",
".",
"AuthVersion",
"\n",
"if",
"AuthVersion",
"==",
"0",
"{",
"if",
"strings",
".",
"Contains",
"(",
"c",
".",
"AuthUrl",
",",... | // newAuth - create a new Authenticator from the AuthUrl
//
// A hint for AuthVersion can be provided | [
"newAuth",
"-",
"create",
"a",
"new",
"Authenticator",
"from",
"the",
"AuthUrl",
"A",
"hint",
"for",
"AuthVersion",
"can",
"be",
"provided"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/auth.go#L54-L81 |
6,168 | ncw/swift | auth.go | Request | func (auth *v1Auth) Request(c *Connection) (*http.Request, error) {
req, err := http.NewRequest("GET", c.AuthUrl, nil)
if err != nil {
return nil, err
}
req.Header.Set("User-Agent", c.UserAgent)
req.Header.Set("X-Auth-Key", c.ApiKey)
req.Header.Set("X-Auth-User", c.UserName)
return req, nil
} | go | func (auth *v1Auth) Request(c *Connection) (*http.Request, error) {
req, err := http.NewRequest("GET", c.AuthUrl, nil)
if err != nil {
return nil, err
}
req.Header.Set("User-Agent", c.UserAgent)
req.Header.Set("X-Auth-Key", c.ApiKey)
req.Header.Set("X-Auth-User", c.UserName)
return req, nil
} | [
"func",
"(",
"auth",
"*",
"v1Auth",
")",
"Request",
"(",
"c",
"*",
"Connection",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"c",
".",
"AuthUrl",
",",
... | // v1 Authentication - make request | [
"v1",
"Authentication",
"-",
"make",
"request"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/auth.go#L91-L100 |
6,169 | ncw/swift | auth.go | Response | func (auth *v1Auth) Response(resp *http.Response) error {
auth.Headers = resp.Header
return nil
} | go | func (auth *v1Auth) Response(resp *http.Response) error {
auth.Headers = resp.Header
return nil
} | [
"func",
"(",
"auth",
"*",
"v1Auth",
")",
"Response",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"auth",
".",
"Headers",
"=",
"resp",
".",
"Header",
"\n",
"return",
"nil",
"\n",
"}"
] | // v1 Authentication - read response | [
"v1",
"Authentication",
"-",
"read",
"response"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/auth.go#L103-L106 |
6,170 | ncw/swift | auth.go | StorageUrl | func (auth *v1Auth) StorageUrl(Internal bool) string {
storageUrl := auth.Headers.Get("X-Storage-Url")
if Internal {
newUrl, err := url.Parse(storageUrl)
if err != nil {
return storageUrl
}
newUrl.Host = "snet-" + newUrl.Host
storageUrl = newUrl.String()
}
return storageUrl
} | go | func (auth *v1Auth) StorageUrl(Internal bool) string {
storageUrl := auth.Headers.Get("X-Storage-Url")
if Internal {
newUrl, err := url.Parse(storageUrl)
if err != nil {
return storageUrl
}
newUrl.Host = "snet-" + newUrl.Host
storageUrl = newUrl.String()
}
return storageUrl
} | [
"func",
"(",
"auth",
"*",
"v1Auth",
")",
"StorageUrl",
"(",
"Internal",
"bool",
")",
"string",
"{",
"storageUrl",
":=",
"auth",
".",
"Headers",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"Internal",
"{",
"newUrl",
",",
"err",
":=",
"url",
".",
"... | // v1 Authentication - read storage url | [
"v1",
"Authentication",
"-",
"read",
"storage",
"url"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/auth.go#L109-L120 |
6,171 | ncw/swift | auth.go | Request | func (auth *v2Auth) Request(c *Connection) (*http.Request, error) {
auth.Region = c.Region
// Toggle useApiKey if not first run and not OK yet
if auth.notFirst && !auth.useApiKeyOk {
auth.useApiKey = !auth.useApiKey
}
auth.notFirst = true
// Create a V2 auth request for the body of the connection
var v2i inter... | go | func (auth *v2Auth) Request(c *Connection) (*http.Request, error) {
auth.Region = c.Region
// Toggle useApiKey if not first run and not OK yet
if auth.notFirst && !auth.useApiKeyOk {
auth.useApiKey = !auth.useApiKey
}
auth.notFirst = true
// Create a V2 auth request for the body of the connection
var v2i inter... | [
"func",
"(",
"auth",
"*",
"v2Auth",
")",
"Request",
"(",
"c",
"*",
"Connection",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"auth",
".",
"Region",
"=",
"c",
".",
"Region",
"\n",
"// Toggle useApiKey if not first run and not OK yet",
"if... | // v2 Authentication - make request | [
"v2",
"Authentication",
"-",
"make",
"request"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/auth.go#L144-L186 |
6,172 | ncw/swift | auth.go | Response | func (auth *v2Auth) Response(resp *http.Response) error {
auth.Auth = new(v2AuthResponse)
err := readJson(resp, auth.Auth)
// If successfully read Auth then no need to toggle useApiKey any more
if err == nil {
auth.useApiKeyOk = true
}
return err
} | go | func (auth *v2Auth) Response(resp *http.Response) error {
auth.Auth = new(v2AuthResponse)
err := readJson(resp, auth.Auth)
// If successfully read Auth then no need to toggle useApiKey any more
if err == nil {
auth.useApiKeyOk = true
}
return err
} | [
"func",
"(",
"auth",
"*",
"v2Auth",
")",
"Response",
"(",
"resp",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"auth",
".",
"Auth",
"=",
"new",
"(",
"v2AuthResponse",
")",
"\n",
"err",
":=",
"readJson",
"(",
"resp",
",",
"auth",
".",
"Auth",
")... | // v2 Authentication - read response | [
"v2",
"Authentication",
"-",
"read",
"response"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/auth.go#L189-L197 |
6,173 | ncw/swift | auth.go | endpointUrl | func (auth *v2Auth) endpointUrl(Type string, endpointType EndpointType) string {
for _, catalog := range auth.Auth.Access.ServiceCatalog {
if catalog.Type == Type {
for _, endpoint := range catalog.Endpoints {
if auth.Region == "" || (auth.Region == endpoint.Region) {
switch endpointType {
case Endp... | go | func (auth *v2Auth) endpointUrl(Type string, endpointType EndpointType) string {
for _, catalog := range auth.Auth.Access.ServiceCatalog {
if catalog.Type == Type {
for _, endpoint := range catalog.Endpoints {
if auth.Region == "" || (auth.Region == endpoint.Region) {
switch endpointType {
case Endp... | [
"func",
"(",
"auth",
"*",
"v2Auth",
")",
"endpointUrl",
"(",
"Type",
"string",
",",
"endpointType",
"EndpointType",
")",
"string",
"{",
"for",
"_",
",",
"catalog",
":=",
"range",
"auth",
".",
"Auth",
".",
"Access",
".",
"ServiceCatalog",
"{",
"if",
"cata... | // Finds the Endpoint Url of "type" from the v2AuthResponse using the
// Region if set or defaulting to the first one if not
//
// Returns "" if not found | [
"Finds",
"the",
"Endpoint",
"Url",
"of",
"type",
"from",
"the",
"v2AuthResponse",
"using",
"the",
"Region",
"if",
"set",
"or",
"defaulting",
"to",
"the",
"first",
"one",
"if",
"not",
"Returns",
"if",
"not",
"found"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/auth.go#L203-L223 |
6,174 | ncw/swift | auth.go | Expires | func (auth *v2Auth) Expires() time.Time {
t, err := time.Parse(time.RFC3339, auth.Auth.Access.Token.Expires)
if err != nil {
return time.Time{} // return Zero if not parsed
}
return t
} | go | func (auth *v2Auth) Expires() time.Time {
t, err := time.Parse(time.RFC3339, auth.Auth.Access.Token.Expires)
if err != nil {
return time.Time{} // return Zero if not parsed
}
return t
} | [
"func",
"(",
"auth",
"*",
"v2Auth",
")",
"Expires",
"(",
")",
"time",
".",
"Time",
"{",
"t",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"auth",
".",
"Auth",
".",
"Access",
".",
"Token",
".",
"Expires",
")",
"\n",
... | // v2 Authentication - read expires | [
"v2",
"Authentication",
"-",
"read",
"expires"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/auth.go#L250-L256 |
6,175 | ncw/swift | timeout_reader.go | newTimeoutReader | func newTimeoutReader(reader io.ReadCloser, timeout time.Duration, cancel func()) *timeoutReader {
return &timeoutReader{
reader: reader,
timeout: timeout,
cancel: cancel,
}
} | go | func newTimeoutReader(reader io.ReadCloser, timeout time.Duration, cancel func()) *timeoutReader {
return &timeoutReader{
reader: reader,
timeout: timeout,
cancel: cancel,
}
} | [
"func",
"newTimeoutReader",
"(",
"reader",
"io",
".",
"ReadCloser",
",",
"timeout",
"time",
".",
"Duration",
",",
"cancel",
"func",
"(",
")",
")",
"*",
"timeoutReader",
"{",
"return",
"&",
"timeoutReader",
"{",
"reader",
":",
"reader",
",",
"timeout",
":",... | // Returns a wrapper around the reader which obeys an idle
// timeout. The cancel function is called if the timeout happens | [
"Returns",
"a",
"wrapper",
"around",
"the",
"reader",
"which",
"obeys",
"an",
"idle",
"timeout",
".",
"The",
"cancel",
"function",
"is",
"called",
"if",
"the",
"timeout",
"happens"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/timeout_reader.go#L17-L23 |
6,176 | ncw/swift | watchdog_reader.go | newWatchdogReader | func newWatchdogReader(reader io.Reader, timeout time.Duration, timer *time.Timer) *watchdogReader {
return &watchdogReader{
timeout: timeout,
reader: reader,
timer: timer,
chunkSize: watchdogChunkSize,
}
} | go | func newWatchdogReader(reader io.Reader, timeout time.Duration, timer *time.Timer) *watchdogReader {
return &watchdogReader{
timeout: timeout,
reader: reader,
timer: timer,
chunkSize: watchdogChunkSize,
}
} | [
"func",
"newWatchdogReader",
"(",
"reader",
"io",
".",
"Reader",
",",
"timeout",
"time",
".",
"Duration",
",",
"timer",
"*",
"time",
".",
"Timer",
")",
"*",
"watchdogReader",
"{",
"return",
"&",
"watchdogReader",
"{",
"timeout",
":",
"timeout",
",",
"reade... | // Returns a new reader which will kick the watchdog timer whenever data is read | [
"Returns",
"a",
"new",
"reader",
"which",
"will",
"kick",
"the",
"watchdog",
"timer",
"whenever",
"data",
"is",
"read"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/watchdog_reader.go#L19-L26 |
6,177 | ncw/swift | slo.go | StaticLargeObjectCreateFile | func (c *Connection) StaticLargeObjectCreateFile(opts *LargeObjectOpts) (LargeObjectFile, error) {
info, err := c.cachedQueryInfo()
if err != nil || !info.SupportsSLO() {
return nil, SLONotSupported
}
realMinChunkSize := info.SLOMinSegmentSize()
if realMinChunkSize > opts.MinChunkSize {
opts.MinChunkSize = rea... | go | func (c *Connection) StaticLargeObjectCreateFile(opts *LargeObjectOpts) (LargeObjectFile, error) {
info, err := c.cachedQueryInfo()
if err != nil || !info.SupportsSLO() {
return nil, SLONotSupported
}
realMinChunkSize := info.SLOMinSegmentSize()
if realMinChunkSize > opts.MinChunkSize {
opts.MinChunkSize = rea... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"StaticLargeObjectCreateFile",
"(",
"opts",
"*",
"LargeObjectOpts",
")",
"(",
"LargeObjectFile",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"c",
".",
"cachedQueryInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"... | // StaticLargeObjectCreateFile creates a static large object returning
// an object which satisfies io.Writer, io.Seeker, io.Closer and
// io.ReaderFrom. The flags are as passed to the largeObjectCreate
// method. | [
"StaticLargeObjectCreateFile",
"creates",
"a",
"static",
"large",
"object",
"returning",
"an",
"object",
"which",
"satisfies",
"io",
".",
"Writer",
"io",
".",
"Seeker",
"io",
".",
"Closer",
"and",
"io",
".",
"ReaderFrom",
".",
"The",
"flags",
"are",
"as",
"p... | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/slo.go#L40-L56 |
6,178 | ncw/swift | slo.go | StaticLargeObjectCreate | func (c *Connection) StaticLargeObjectCreate(opts *LargeObjectOpts) (LargeObjectFile, error) {
opts.Flags = os.O_TRUNC | os.O_CREATE
return c.StaticLargeObjectCreateFile(opts)
} | go | func (c *Connection) StaticLargeObjectCreate(opts *LargeObjectOpts) (LargeObjectFile, error) {
opts.Flags = os.O_TRUNC | os.O_CREATE
return c.StaticLargeObjectCreateFile(opts)
} | [
"func",
"(",
"c",
"*",
"Connection",
")",
"StaticLargeObjectCreate",
"(",
"opts",
"*",
"LargeObjectOpts",
")",
"(",
"LargeObjectFile",
",",
"error",
")",
"{",
"opts",
".",
"Flags",
"=",
"os",
".",
"O_TRUNC",
"|",
"os",
".",
"O_CREATE",
"\n",
"return",
"c... | // StaticLargeObjectCreate creates or truncates an existing static
// large object returning a writeable object. This sets opts.Flags to
// an appropriate value before calling StaticLargeObjectCreateFile | [
"StaticLargeObjectCreate",
"creates",
"or",
"truncates",
"an",
"existing",
"static",
"large",
"object",
"returning",
"a",
"writeable",
"object",
".",
"This",
"sets",
"opts",
".",
"Flags",
"to",
"an",
"appropriate",
"value",
"before",
"calling",
"StaticLargeObjectCre... | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/slo.go#L61-L64 |
6,179 | ncw/swift | slo.go | StaticLargeObjectDelete | func (c *Connection) StaticLargeObjectDelete(container string, path string) error {
info, err := c.cachedQueryInfo()
if err != nil || !info.SupportsSLO() {
return SLONotSupported
}
return c.LargeObjectDelete(container, path)
} | go | func (c *Connection) StaticLargeObjectDelete(container string, path string) error {
info, err := c.cachedQueryInfo()
if err != nil || !info.SupportsSLO() {
return SLONotSupported
}
return c.LargeObjectDelete(container, path)
} | [
"func",
"(",
"c",
"*",
"Connection",
")",
"StaticLargeObjectDelete",
"(",
"container",
"string",
",",
"path",
"string",
")",
"error",
"{",
"info",
",",
"err",
":=",
"c",
".",
"cachedQueryInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"!",
"info... | // StaticLargeObjectDelete deletes a static large object and all of its segments. | [
"StaticLargeObjectDelete",
"deletes",
"a",
"static",
"large",
"object",
"and",
"all",
"of",
"its",
"segments",
"."
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/slo.go#L67-L73 |
6,180 | ncw/swift | slo.go | StaticLargeObjectMove | func (c *Connection) StaticLargeObjectMove(srcContainer string, srcObjectName string, dstContainer string, dstObjectName string) error {
swiftInfo, err := c.cachedQueryInfo()
if err != nil || !swiftInfo.SupportsSLO() {
return SLONotSupported
}
info, headers, err := c.Object(srcContainer, srcObjectName)
if err !=... | go | func (c *Connection) StaticLargeObjectMove(srcContainer string, srcObjectName string, dstContainer string, dstObjectName string) error {
swiftInfo, err := c.cachedQueryInfo()
if err != nil || !swiftInfo.SupportsSLO() {
return SLONotSupported
}
info, headers, err := c.Object(srcContainer, srcObjectName)
if err !=... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"StaticLargeObjectMove",
"(",
"srcContainer",
"string",
",",
"srcObjectName",
"string",
",",
"dstContainer",
"string",
",",
"dstObjectName",
"string",
")",
"error",
"{",
"swiftInfo",
",",
"err",
":=",
"c",
".",
"cached... | // StaticLargeObjectMove moves a static large object from srcContainer, srcObjectName to dstContainer, dstObjectName | [
"StaticLargeObjectMove",
"moves",
"a",
"static",
"large",
"object",
"from",
"srcContainer",
"srcObjectName",
"to",
"dstContainer",
"dstObjectName"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/slo.go#L76-L103 |
6,181 | ncw/swift | slo.go | createSLOManifest | func (c *Connection) createSLOManifest(container string, path string, contentType string, segmentContainer string, segments []Object, h Headers) error {
sloSegments := make([]swiftSegment, len(segments))
for i, segment := range segments {
sloSegments[i].Path = fmt.Sprintf("%s/%s", segmentContainer, segment.Name)
... | go | func (c *Connection) createSLOManifest(container string, path string, contentType string, segmentContainer string, segments []Object, h Headers) error {
sloSegments := make([]swiftSegment, len(segments))
for i, segment := range segments {
sloSegments[i].Path = fmt.Sprintf("%s/%s", segmentContainer, segment.Name)
... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"createSLOManifest",
"(",
"container",
"string",
",",
"path",
"string",
",",
"contentType",
"string",
",",
"segmentContainer",
"string",
",",
"segments",
"[",
"]",
"Object",
",",
"h",
"Headers",
")",
"error",
"{",
... | // createSLOManifest creates a static large object manifest | [
"createSLOManifest",
"creates",
"a",
"static",
"large",
"object",
"manifest"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/slo.go#L106-L126 |
6,182 | ncw/swift | rs/rs.go | manage | func (c *RsConnection) manage(p swift.RequestOpts) (resp *http.Response, headers swift.Headers, err error) {
p.OnReAuth = func() (string, error) {
if c.cdnUrl == "" {
c.cdnUrl = c.Auth.CdnUrl()
}
if c.cdnUrl == "" {
return "", errors.New("The X-CDN-Management-Url does not exist on the authenticated platfor... | go | func (c *RsConnection) manage(p swift.RequestOpts) (resp *http.Response, headers swift.Headers, err error) {
p.OnReAuth = func() (string, error) {
if c.cdnUrl == "" {
c.cdnUrl = c.Auth.CdnUrl()
}
if c.cdnUrl == "" {
return "", errors.New("The X-CDN-Management-Url does not exist on the authenticated platfor... | [
"func",
"(",
"c",
"*",
"RsConnection",
")",
"manage",
"(",
"p",
"swift",
".",
"RequestOpts",
")",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"headers",
"swift",
".",
"Headers",
",",
"err",
"error",
")",
"{",
"p",
".",
"OnReAuth",
"=",
"func",
... | // manage is similar to the swift storage method, but uses the CDN Management URL for CDN specific calls. | [
"manage",
"is",
"similar",
"to",
"the",
"swift",
"storage",
"method",
"but",
"uses",
"the",
"CDN",
"Management",
"URL",
"for",
"CDN",
"specific",
"calls",
"."
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/rs/rs.go#L19-L36 |
6,183 | ncw/swift | rs/rs.go | ContainerCDNDisable | func (c *RsConnection) ContainerCDNDisable(container string) error {
h := swift.Headers{"X-CDN-Enabled": "false"}
_, _, err := c.manage(swift.RequestOpts{
Container: container,
Operation: "PUT",
ErrorMap: swift.ContainerErrorMap,
NoResponse: true,
Headers: h,
})
return err
} | go | func (c *RsConnection) ContainerCDNDisable(container string) error {
h := swift.Headers{"X-CDN-Enabled": "false"}
_, _, err := c.manage(swift.RequestOpts{
Container: container,
Operation: "PUT",
ErrorMap: swift.ContainerErrorMap,
NoResponse: true,
Headers: h,
})
return err
} | [
"func",
"(",
"c",
"*",
"RsConnection",
")",
"ContainerCDNDisable",
"(",
"container",
"string",
")",
"error",
"{",
"h",
":=",
"swift",
".",
"Headers",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"}",
"\n\n",
"_",
",",
"_",
",",
"err",
":=",
"c",
".",
"manage"... | // ContainerCDNDisable disables CDN access to a container. | [
"ContainerCDNDisable",
"disables",
"CDN",
"access",
"to",
"a",
"container",
"."
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/rs/rs.go#L60-L71 |
6,184 | ncw/swift | compatibility_1_1.go | cancelRequest | func cancelRequest(transport http.RoundTripper, req *http.Request) {
if tr, ok := transport.(interface {
CancelRequest(*http.Request)
}); ok {
tr.CancelRequest(req)
}
} | go | func cancelRequest(transport http.RoundTripper, req *http.Request) {
if tr, ok := transport.(interface {
CancelRequest(*http.Request)
}); ok {
tr.CancelRequest(req)
}
} | [
"func",
"cancelRequest",
"(",
"transport",
"http",
".",
"RoundTripper",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"tr",
",",
"ok",
":=",
"transport",
".",
"(",
"interface",
"{",
"CancelRequest",
"(",
"*",
"http",
".",
"Request",
")",
"\n... | // Cancel the request | [
"Cancel",
"the",
"request"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/compatibility_1_1.go#L13-L19 |
6,185 | ncw/swift | compatibility_1_1.go | resetTimer | func resetTimer(t *time.Timer, d time.Duration) {
t.Reset(d)
} | go | func resetTimer(t *time.Timer, d time.Duration) {
t.Reset(d)
} | [
"func",
"resetTimer",
"(",
"t",
"*",
"time",
".",
"Timer",
",",
"d",
"time",
".",
"Duration",
")",
"{",
"t",
".",
"Reset",
"(",
"d",
")",
"\n",
"}"
] | // Reset a timer | [
"Reset",
"a",
"timer"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/compatibility_1_1.go#L22-L24 |
6,186 | ncw/swift | largeobjects.go | largeObjectCreate | func (c *Connection) largeObjectCreate(opts *LargeObjectOpts) (*largeObjectCreateFile, error) {
var (
segmentPath string
segmentContainer string
segments []Object
currentLength int64
err error
)
if opts.SegmentPrefix != "" {
segmentPath = opts.SegmentPrefix
} else if segmen... | go | func (c *Connection) largeObjectCreate(opts *LargeObjectOpts) (*largeObjectCreateFile, error) {
var (
segmentPath string
segmentContainer string
segments []Object
currentLength int64
err error
)
if opts.SegmentPrefix != "" {
segmentPath = opts.SegmentPrefix
} else if segmen... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"largeObjectCreate",
"(",
"opts",
"*",
"LargeObjectOpts",
")",
"(",
"*",
"largeObjectCreateFile",
",",
"error",
")",
"{",
"var",
"(",
"segmentPath",
"string",
"\n",
"segmentContainer",
"string",
"\n",
"segments",
"[",
... | // largeObjectCreate creates a large object at opts.Container, opts.ObjectName.
//
// opts.Flags can have the following bits set
// os.TRUNC - remove the contents of the large object if it exists
// os.APPEND - write at the end of the large object | [
"largeObjectCreate",
"creates",
"a",
"large",
"object",
"at",
"opts",
".",
"Container",
"opts",
".",
"ObjectName",
".",
"opts",
".",
"Flags",
"can",
"have",
"the",
"following",
"bits",
"set",
"os",
".",
"TRUNC",
"-",
"remove",
"the",
"contents",
"of",
"the... | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/largeobjects.go#L123-L198 |
6,187 | ncw/swift | largeobjects.go | LargeObjectDelete | func (c *Connection) LargeObjectDelete(container string, objectName string) error {
_, headers, err := c.Object(container, objectName)
if err != nil {
return err
}
var objects [][]string
if headers.IsLargeObject() {
segmentContainer, segments, err := c.getAllSegments(container, objectName, headers)
if err !... | go | func (c *Connection) LargeObjectDelete(container string, objectName string) error {
_, headers, err := c.Object(container, objectName)
if err != nil {
return err
}
var objects [][]string
if headers.IsLargeObject() {
segmentContainer, segments, err := c.getAllSegments(container, objectName, headers)
if err !... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"LargeObjectDelete",
"(",
"container",
"string",
",",
"objectName",
"string",
")",
"error",
"{",
"_",
",",
"headers",
",",
"err",
":=",
"c",
".",
"Object",
"(",
"container",
",",
"objectName",
")",
"\n",
"if",
... | // LargeObjectDelete deletes the large object named by container, path | [
"LargeObjectDelete",
"deletes",
"the",
"large",
"object",
"named",
"by",
"container",
"path"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/largeobjects.go#L201-L240 |
6,188 | ncw/swift | largeobjects.go | Seek | func (file *largeObjectCreateFile) Seek(offset int64, whence int) (int64, error) {
switch whence {
case 0:
file.filePos = offset
case 1:
file.filePos += offset
case 2:
file.filePos = file.currentLength + offset
default:
return -1, fmt.Errorf("invalid value for whence")
}
if file.filePos < 0 {
return -1... | go | func (file *largeObjectCreateFile) Seek(offset int64, whence int) (int64, error) {
switch whence {
case 0:
file.filePos = offset
case 1:
file.filePos += offset
case 2:
file.filePos = file.currentLength + offset
default:
return -1, fmt.Errorf("invalid value for whence")
}
if file.filePos < 0 {
return -1... | [
"func",
"(",
"file",
"*",
"largeObjectCreateFile",
")",
"Seek",
"(",
"offset",
"int64",
",",
"whence",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"switch",
"whence",
"{",
"case",
"0",
":",
"file",
".",
"filePos",
"=",
"offset",
"\n",
"case",
"... | // Seek sets the offset for the next write operation | [
"Seek",
"sets",
"the",
"offset",
"for",
"the",
"next",
"write",
"operation"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/largeobjects.go#L257-L272 |
6,189 | ncw/swift | largeobjects.go | Write | func (file *largeObjectCreateFile) Write(buf []byte) (int, error) {
var sz int64
var relativeFilePos int
writeSegmentIdx := 0
for i, obj := range file.segments {
if file.filePos < sz+obj.Bytes || (i == len(file.segments)-1 && file.filePos < sz+file.minChunkSize) {
relativeFilePos = int(file.filePos - sz)
br... | go | func (file *largeObjectCreateFile) Write(buf []byte) (int, error) {
var sz int64
var relativeFilePos int
writeSegmentIdx := 0
for i, obj := range file.segments {
if file.filePos < sz+obj.Bytes || (i == len(file.segments)-1 && file.filePos < sz+file.minChunkSize) {
relativeFilePos = int(file.filePos - sz)
br... | [
"func",
"(",
"file",
"*",
"largeObjectCreateFile",
")",
"Write",
"(",
"buf",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"sz",
"int64",
"\n",
"var",
"relativeFilePos",
"int",
"\n",
"writeSegmentIdx",
":=",
"0",
"\n",
"for",
"i",
... | // Write satisfies the io.Writer interface | [
"Write",
"satisfies",
"the",
"io",
".",
"Writer",
"interface"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/largeobjects.go#L318-L351 |
6,190 | ncw/swift | meta.go | Metadata | func (h Headers) Metadata(metaPrefix string) Metadata {
m := Metadata{}
metaPrefix = http.CanonicalHeaderKey(metaPrefix)
for key, value := range h {
if strings.HasPrefix(key, metaPrefix) {
metaKey := strings.ToLower(key[len(metaPrefix):])
m[metaKey] = value
}
}
return m
} | go | func (h Headers) Metadata(metaPrefix string) Metadata {
m := Metadata{}
metaPrefix = http.CanonicalHeaderKey(metaPrefix)
for key, value := range h {
if strings.HasPrefix(key, metaPrefix) {
metaKey := strings.ToLower(key[len(metaPrefix):])
m[metaKey] = value
}
}
return m
} | [
"func",
"(",
"h",
"Headers",
")",
"Metadata",
"(",
"metaPrefix",
"string",
")",
"Metadata",
"{",
"m",
":=",
"Metadata",
"{",
"}",
"\n",
"metaPrefix",
"=",
"http",
".",
"CanonicalHeaderKey",
"(",
"metaPrefix",
")",
"\n",
"for",
"key",
",",
"value",
":=",
... | // Metadata gets the Metadata starting with the metaPrefix out of the Headers.
//
// The keys in the Metadata will be converted to lower case | [
"Metadata",
"gets",
"the",
"Metadata",
"starting",
"with",
"the",
"metaPrefix",
"out",
"of",
"the",
"Headers",
".",
"The",
"keys",
"in",
"the",
"Metadata",
"will",
"be",
"converted",
"to",
"lower",
"case"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/meta.go#L19-L29 |
6,191 | ncw/swift | meta.go | nsToFloatString | func nsToFloatString(ns int64) string {
if ns < 0 {
return "-" + nsToFloatString(-ns)
}
result := fmt.Sprintf("%010d", ns)
split := len(result) - 9
result, decimals := result[:split], result[split:]
decimals = strings.TrimRight(decimals, "0")
if decimals != "" {
result += "."
result += decimals
}
return ... | go | func nsToFloatString(ns int64) string {
if ns < 0 {
return "-" + nsToFloatString(-ns)
}
result := fmt.Sprintf("%010d", ns)
split := len(result) - 9
result, decimals := result[:split], result[split:]
decimals = strings.TrimRight(decimals, "0")
if decimals != "" {
result += "."
result += decimals
}
return ... | [
"func",
"nsToFloatString",
"(",
"ns",
"int64",
")",
"string",
"{",
"if",
"ns",
"<",
"0",
"{",
"return",
"\"",
"\"",
"+",
"nsToFloatString",
"(",
"-",
"ns",
")",
"\n",
"}",
"\n",
"result",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ns",
"... | // Turns a number of ns into a floating point string in seconds
//
// Trims trailing zeros and guaranteed to be perfectly accurate | [
"Turns",
"a",
"number",
"of",
"ns",
"into",
"a",
"floating",
"point",
"string",
"in",
"seconds",
"Trims",
"trailing",
"zeros",
"and",
"guaranteed",
"to",
"be",
"perfectly",
"accurate"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/meta.go#L84-L97 |
6,192 | ncw/swift | meta.go | floatStringToNs | func floatStringToNs(s string) (int64, error) {
const zeros = "000000000"
if point := strings.IndexRune(s, '.'); point >= 0 {
tail := s[point+1:]
if fill := 9 - len(tail); fill < 0 {
tail = tail[:9]
} else {
tail += zeros[:fill]
}
s = s[:point] + tail
} else if len(s) > 0 { // Make sure empty string ... | go | func floatStringToNs(s string) (int64, error) {
const zeros = "000000000"
if point := strings.IndexRune(s, '.'); point >= 0 {
tail := s[point+1:]
if fill := 9 - len(tail); fill < 0 {
tail = tail[:9]
} else {
tail += zeros[:fill]
}
s = s[:point] + tail
} else if len(s) > 0 { // Make sure empty string ... | [
"func",
"floatStringToNs",
"(",
"s",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"const",
"zeros",
"=",
"\"",
"\"",
"\n",
"if",
"point",
":=",
"strings",
".",
"IndexRune",
"(",
"s",
",",
"'.'",
")",
";",
"point",
">=",
"0",
"{",
"tail",
... | // Turns a floating point string in seconds into a ns integer
//
// Guaranteed to be perfectly accurate | [
"Turns",
"a",
"floating",
"point",
"string",
"in",
"seconds",
"into",
"a",
"ns",
"integer",
"Guaranteed",
"to",
"be",
"perfectly",
"accurate"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/meta.go#L102-L116 |
6,193 | ncw/swift | swift.go | newError | func newError(StatusCode int, Text string) *Error {
return &Error{
StatusCode: StatusCode,
Text: Text,
}
} | go | func newError(StatusCode int, Text string) *Error {
return &Error{
StatusCode: StatusCode,
Text: Text,
}
} | [
"func",
"newError",
"(",
"StatusCode",
"int",
",",
"Text",
"string",
")",
"*",
"Error",
"{",
"return",
"&",
"Error",
"{",
"StatusCode",
":",
"StatusCode",
",",
"Text",
":",
"Text",
",",
"}",
"\n",
"}"
] | // newError make a new error from a string. | [
"newError",
"make",
"a",
"new",
"error",
"from",
"a",
"string",
"."
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/swift.go#L283-L288 |
6,194 | ncw/swift | swift.go | newErrorf | func newErrorf(StatusCode int, Text string, Parameters ...interface{}) *Error {
return newError(StatusCode, fmt.Sprintf(Text, Parameters...))
} | go | func newErrorf(StatusCode int, Text string, Parameters ...interface{}) *Error {
return newError(StatusCode, fmt.Sprintf(Text, Parameters...))
} | [
"func",
"newErrorf",
"(",
"StatusCode",
"int",
",",
"Text",
"string",
",",
"Parameters",
"...",
"interface",
"{",
"}",
")",
"*",
"Error",
"{",
"return",
"newError",
"(",
"StatusCode",
",",
"fmt",
".",
"Sprintf",
"(",
"Text",
",",
"Parameters",
"...",
")"... | // newErrorf makes a new error from sprintf parameters. | [
"newErrorf",
"makes",
"a",
"new",
"error",
"from",
"sprintf",
"parameters",
"."
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/swift.go#L291-L293 |
6,195 | ncw/swift | swift.go | drainAndClose | func drainAndClose(rd io.ReadCloser, err *error) {
if rd == nil {
return
}
_, _ = io.Copy(ioutil.Discard, rd)
cerr := rd.Close()
if err != nil && *err == nil {
*err = cerr
}
} | go | func drainAndClose(rd io.ReadCloser, err *error) {
if rd == nil {
return
}
_, _ = io.Copy(ioutil.Discard, rd)
cerr := rd.Close()
if err != nil && *err == nil {
*err = cerr
}
} | [
"func",
"drainAndClose",
"(",
"rd",
"io",
".",
"ReadCloser",
",",
"err",
"*",
"error",
")",
"{",
"if",
"rd",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"_",
",",
"_",
"=",
"io",
".",
"Copy",
"(",
"ioutil",
".",
"Discard",
",",
"rd",
")",
"\... | // drainAndClose discards all data from rd and closes it.
// If an error occurs during Read, it is discarded. | [
"drainAndClose",
"discards",
"all",
"data",
"from",
"rd",
"and",
"closes",
"it",
".",
"If",
"an",
"error",
"occurs",
"during",
"Read",
"it",
"is",
"discarded",
"."
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/swift.go#L353-L363 |
6,196 | ncw/swift | swift.go | parseHeaders | func (c *Connection) parseHeaders(resp *http.Response, errorMap errorMap) error {
if errorMap != nil {
if err, ok := errorMap[resp.StatusCode]; ok {
drainAndClose(resp.Body, nil)
return err
}
}
if resp.StatusCode < 200 || resp.StatusCode > 299 {
drainAndClose(resp.Body, nil)
return newErrorf(resp.Statu... | go | func (c *Connection) parseHeaders(resp *http.Response, errorMap errorMap) error {
if errorMap != nil {
if err, ok := errorMap[resp.StatusCode]; ok {
drainAndClose(resp.Body, nil)
return err
}
}
if resp.StatusCode < 200 || resp.StatusCode > 299 {
drainAndClose(resp.Body, nil)
return newErrorf(resp.Statu... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"parseHeaders",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"errorMap",
"errorMap",
")",
"error",
"{",
"if",
"errorMap",
"!=",
"nil",
"{",
"if",
"err",
",",
"ok",
":=",
"errorMap",
"[",
"resp",
".",
"Stat... | // parseHeaders checks a response for errors and translates into
// standard errors if necessary. If an error is returned, resp.Body
// has been drained and closed. | [
"parseHeaders",
"checks",
"a",
"response",
"for",
"errors",
"and",
"translates",
"into",
"standard",
"errors",
"if",
"necessary",
".",
"If",
"an",
"error",
"is",
"returned",
"resp",
".",
"Body",
"has",
"been",
"drained",
"and",
"closed",
"."
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/swift.go#L368-L380 |
6,197 | ncw/swift | swift.go | doTimeoutRequest | func (c *Connection) doTimeoutRequest(timer *time.Timer, req *http.Request) (*http.Response, error) {
// Do the request in the background so we can check the timeout
type result struct {
resp *http.Response
err error
}
done := make(chan result, 1)
go func() {
resp, err := c.client.Do(req)
done <- result{r... | go | func (c *Connection) doTimeoutRequest(timer *time.Timer, req *http.Request) (*http.Response, error) {
// Do the request in the background so we can check the timeout
type result struct {
resp *http.Response
err error
}
done := make(chan result, 1)
go func() {
resp, err := c.client.Do(req)
done <- result{r... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"doTimeoutRequest",
"(",
"timer",
"*",
"time",
".",
"Timer",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"// Do the request in the background so we can che... | // Does an http request using the running timer passed in | [
"Does",
"an",
"http",
"request",
"using",
"the",
"running",
"timer",
"passed",
"in"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/swift.go#L398-L419 |
6,198 | ncw/swift | swift.go | setDefaults | func (c *Connection) setDefaults() {
if c.UserAgent == "" {
c.UserAgent = DefaultUserAgent
}
if c.Retries == 0 {
c.Retries = DefaultRetries
}
if c.ConnectTimeout == 0 {
c.ConnectTimeout = 10 * time.Second
}
if c.Timeout == 0 {
c.Timeout = 60 * time.Second
}
if c.Transport == nil {
t := &http.Transpor... | go | func (c *Connection) setDefaults() {
if c.UserAgent == "" {
c.UserAgent = DefaultUserAgent
}
if c.Retries == 0 {
c.Retries = DefaultRetries
}
if c.ConnectTimeout == 0 {
c.ConnectTimeout = 10 * time.Second
}
if c.Timeout == 0 {
c.Timeout = 60 * time.Second
}
if c.Transport == nil {
t := &http.Transpor... | [
"func",
"(",
"c",
"*",
"Connection",
")",
"setDefaults",
"(",
")",
"{",
"if",
"c",
".",
"UserAgent",
"==",
"\"",
"\"",
"{",
"c",
".",
"UserAgent",
"=",
"DefaultUserAgent",
"\n",
"}",
"\n",
"if",
"c",
".",
"Retries",
"==",
"0",
"{",
"c",
".",
"Ret... | // Set defaults for any unset values
//
// Call with authLock held | [
"Set",
"defaults",
"for",
"any",
"unset",
"values",
"Call",
"with",
"authLock",
"held"
] | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/swift.go#L424-L454 |
6,199 | ncw/swift | swift.go | Authenticate | func (c *Connection) Authenticate() (err error) {
c.authLock.Lock()
defer c.authLock.Unlock()
return c.authenticate()
} | go | func (c *Connection) Authenticate() (err error) {
c.authLock.Lock()
defer c.authLock.Unlock()
return c.authenticate()
} | [
"func",
"(",
"c",
"*",
"Connection",
")",
"Authenticate",
"(",
")",
"(",
"err",
"error",
")",
"{",
"c",
".",
"authLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"authLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"c",
".",
"authenticate",
... | // Authenticate connects to the Swift server.
//
// If you don't call it before calling one of the connection methods
// then it will be called for you on the first access. | [
"Authenticate",
"connects",
"to",
"the",
"Swift",
"server",
".",
"If",
"you",
"don",
"t",
"call",
"it",
"before",
"calling",
"one",
"of",
"the",
"connection",
"methods",
"then",
"it",
"will",
"be",
"called",
"for",
"you",
"on",
"the",
"first",
"access",
... | 753d2090bb62619675997bd87a8e3af423a00f2d | https://github.com/ncw/swift/blob/753d2090bb62619675997bd87a8e3af423a00f2d/swift.go#L460-L464 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.