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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
12,900 | influxdata/platform | tsdb/tsm1/ring.go | getPartition | func (r *ring) getPartition(key []byte) *partition {
return r.partitions[int(xxhash.Sum64(key)%partitions)]
} | go | func (r *ring) getPartition(key []byte) *partition {
return r.partitions[int(xxhash.Sum64(key)%partitions)]
} | [
"func",
"(",
"r",
"*",
"ring",
")",
"getPartition",
"(",
"key",
"[",
"]",
"byte",
")",
"*",
"partition",
"{",
"return",
"r",
".",
"partitions",
"[",
"int",
"(",
"xxhash",
".",
"Sum64",
"(",
"key",
")",
"%",
"partitions",
")",
"]",
"\n",
"}"
] | // getPartition retrieves the hash ring partition associated with the provided
// key. | [
"getPartition",
"retrieves",
"the",
"hash",
"ring",
"partition",
"associated",
"with",
"the",
"provided",
"key",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/ring.go#L86-L88 |
12,901 | influxdata/platform | inmem/organization_service.go | FindOrganization | func (s *Service) FindOrganization(ctx context.Context, filter platform.OrganizationFilter) (*platform.Organization, error) {
op := OpPrefix + platform.OpFindOrganization
if filter.ID == nil && filter.Name == nil {
return nil, &platform.Error{
Code: platform.EInvalid,
Op: op,
Msg: "no filter parameters provided",
}
}
if filter.ID != nil {
o, err := s.FindOrganizationByID(ctx, *filter.ID)
if err != nil {
return nil, &platform.Error{
Op: op,
Err: err,
}
}
return o, nil
}
orgs, n, err := s.FindOrganizations(ctx, filter)
if err != nil {
return nil, &platform.Error{
Op: op,
Err: err,
}
}
if n < 1 {
return nil, &platform.Error{
Code: platform.ENotFound,
Op: op,
Msg: errOrganizationNotFound,
}
}
return orgs[0], nil
} | go | func (s *Service) FindOrganization(ctx context.Context, filter platform.OrganizationFilter) (*platform.Organization, error) {
op := OpPrefix + platform.OpFindOrganization
if filter.ID == nil && filter.Name == nil {
return nil, &platform.Error{
Code: platform.EInvalid,
Op: op,
Msg: "no filter parameters provided",
}
}
if filter.ID != nil {
o, err := s.FindOrganizationByID(ctx, *filter.ID)
if err != nil {
return nil, &platform.Error{
Op: op,
Err: err,
}
}
return o, nil
}
orgs, n, err := s.FindOrganizations(ctx, filter)
if err != nil {
return nil, &platform.Error{
Op: op,
Err: err,
}
}
if n < 1 {
return nil, &platform.Error{
Code: platform.ENotFound,
Op: op,
Msg: errOrganizationNotFound,
}
}
return orgs[0], nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"FindOrganization",
"(",
"ctx",
"context",
".",
"Context",
",",
"filter",
"platform",
".",
"OrganizationFilter",
")",
"(",
"*",
"platform",
".",
"Organization",
",",
"error",
")",
"{",
"op",
":=",
"OpPrefix",
"+",
"... | // FindOrganization returns the first organization that matches a filter. | [
"FindOrganization",
"returns",
"the",
"first",
"organization",
"that",
"matches",
"a",
"filter",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/organization_service.go#L79-L116 |
12,902 | influxdata/platform | inmem/organization_service.go | FindOrganizations | func (s *Service) FindOrganizations(ctx context.Context, filter platform.OrganizationFilter, opt ...platform.FindOptions) ([]*platform.Organization, int, error) {
op := OpPrefix + platform.OpFindOrganizations
if filter.ID != nil {
o, err := s.FindOrganizationByID(ctx, *filter.ID)
if err != nil {
return nil, 0, &platform.Error{
Op: op,
Err: err,
}
}
return []*platform.Organization{o}, 1, nil
}
filterFunc := func(o *platform.Organization) bool { return true }
if filter.Name != nil {
filterFunc = func(o *platform.Organization) bool {
return o.Name == *filter.Name
}
}
orgs, pe := s.filterOrganizations(ctx, filterFunc)
if pe != nil {
return nil, 0, &platform.Error{
Err: pe,
Op: op,
}
}
if len(orgs) == 0 {
return orgs, 0, &platform.Error{
Code: platform.ENotFound,
Op: op,
Msg: errOrganizationNotFound,
}
}
return orgs, len(orgs), nil
} | go | func (s *Service) FindOrganizations(ctx context.Context, filter platform.OrganizationFilter, opt ...platform.FindOptions) ([]*platform.Organization, int, error) {
op := OpPrefix + platform.OpFindOrganizations
if filter.ID != nil {
o, err := s.FindOrganizationByID(ctx, *filter.ID)
if err != nil {
return nil, 0, &platform.Error{
Op: op,
Err: err,
}
}
return []*platform.Organization{o}, 1, nil
}
filterFunc := func(o *platform.Organization) bool { return true }
if filter.Name != nil {
filterFunc = func(o *platform.Organization) bool {
return o.Name == *filter.Name
}
}
orgs, pe := s.filterOrganizations(ctx, filterFunc)
if pe != nil {
return nil, 0, &platform.Error{
Err: pe,
Op: op,
}
}
if len(orgs) == 0 {
return orgs, 0, &platform.Error{
Code: platform.ENotFound,
Op: op,
Msg: errOrganizationNotFound,
}
}
return orgs, len(orgs), nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"FindOrganizations",
"(",
"ctx",
"context",
".",
"Context",
",",
"filter",
"platform",
".",
"OrganizationFilter",
",",
"opt",
"...",
"platform",
".",
"FindOptions",
")",
"(",
"[",
"]",
"*",
"platform",
".",
"Organizat... | // FindOrganizations returns a list of organizations that match filter and the total count of matching organizations. | [
"FindOrganizations",
"returns",
"a",
"list",
"of",
"organizations",
"that",
"match",
"filter",
"and",
"the",
"total",
"count",
"of",
"matching",
"organizations",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/organization_service.go#L119-L157 |
12,903 | influxdata/platform | zap/auth_service.go | SetAuthorizationStatus | func (s *AuthorizationService) SetAuthorizationStatus(ctx context.Context, id platform.ID, status platform.Status) (err error) {
defer func() {
if err != nil {
s.Logger.Info("error updating authorization", zap.Error(err))
}
}()
return s.AuthorizationService.SetAuthorizationStatus(ctx, id, status)
} | go | func (s *AuthorizationService) SetAuthorizationStatus(ctx context.Context, id platform.ID, status platform.Status) (err error) {
defer func() {
if err != nil {
s.Logger.Info("error updating authorization", zap.Error(err))
}
}()
return s.AuthorizationService.SetAuthorizationStatus(ctx, id, status)
} | [
"func",
"(",
"s",
"*",
"AuthorizationService",
")",
"SetAuthorizationStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
",",
"status",
"platform",
".",
"Status",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")"... | // SetAuthorizationStatus updates an authorization's status and logs any errors. | [
"SetAuthorizationStatus",
"updates",
"an",
"authorization",
"s",
"status",
"and",
"logs",
"any",
"errors",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/zap/auth_service.go#L75-L83 |
12,904 | influxdata/platform | tsdb/tsm1/bool.go | Write | func (e *BooleanEncoder) Write(b bool) {
// If we have filled the current byte, flush it
if e.i >= 8 {
e.flush()
}
// Use 1 bit for each boolean value, shift the current byte
// by 1 and set the least signficant bit acordingly
e.b = e.b << 1
if b {
e.b |= 1
}
// Increment the current boolean count
e.i++
// Increment the total boolean count
e.n++
} | go | func (e *BooleanEncoder) Write(b bool) {
// If we have filled the current byte, flush it
if e.i >= 8 {
e.flush()
}
// Use 1 bit for each boolean value, shift the current byte
// by 1 and set the least signficant bit acordingly
e.b = e.b << 1
if b {
e.b |= 1
}
// Increment the current boolean count
e.i++
// Increment the total boolean count
e.n++
} | [
"func",
"(",
"e",
"*",
"BooleanEncoder",
")",
"Write",
"(",
"b",
"bool",
")",
"{",
"// If we have filled the current byte, flush it",
"if",
"e",
".",
"i",
">=",
"8",
"{",
"e",
".",
"flush",
"(",
")",
"\n",
"}",
"\n\n",
"// Use 1 bit for each boolean value, shi... | // Write encodes b to the underlying buffer. | [
"Write",
"encodes",
"b",
"to",
"the",
"underlying",
"buffer",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/bool.go#L48-L65 |
12,905 | influxdata/platform | cmd/influxd/launcher/launcher.go | Shutdown | func (m *Launcher) Shutdown(ctx context.Context) {
m.httpServer.Shutdown(ctx)
m.logger.Info("Stopping", zap.String("service", "task"))
m.scheduler.Stop()
m.logger.Info("Stopping", zap.String("service", "nats"))
m.natsServer.Close()
m.logger.Info("Stopping", zap.String("service", "bolt"))
if err := m.boltClient.Close(); err != nil {
m.logger.Info("failed closing bolt", zap.Error(err))
}
m.logger.Info("Stopping", zap.String("service", "query"))
if err := m.queryController.Shutdown(ctx); err != nil {
m.logger.Info("Failed closing query service", zap.Error(err))
}
m.logger.Info("Stopping", zap.String("service", "storage-engine"))
if err := m.engine.Close(); err != nil {
m.logger.Error("failed to close engine", zap.Error(err))
}
m.wg.Wait()
m.logger.Sync()
} | go | func (m *Launcher) Shutdown(ctx context.Context) {
m.httpServer.Shutdown(ctx)
m.logger.Info("Stopping", zap.String("service", "task"))
m.scheduler.Stop()
m.logger.Info("Stopping", zap.String("service", "nats"))
m.natsServer.Close()
m.logger.Info("Stopping", zap.String("service", "bolt"))
if err := m.boltClient.Close(); err != nil {
m.logger.Info("failed closing bolt", zap.Error(err))
}
m.logger.Info("Stopping", zap.String("service", "query"))
if err := m.queryController.Shutdown(ctx); err != nil {
m.logger.Info("Failed closing query service", zap.Error(err))
}
m.logger.Info("Stopping", zap.String("service", "storage-engine"))
if err := m.engine.Close(); err != nil {
m.logger.Error("failed to close engine", zap.Error(err))
}
m.wg.Wait()
m.logger.Sync()
} | [
"func",
"(",
"m",
"*",
"Launcher",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"m",
".",
"httpServer",
".",
"Shutdown",
"(",
"ctx",
")",
"\n\n",
"m",
".",
"logger",
".",
"Info",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(... | // Shutdown shuts down the HTTP server and waits for all services to clean up. | [
"Shutdown",
"shuts",
"down",
"the",
"HTTP",
"server",
"and",
"waits",
"for",
"all",
"services",
"to",
"clean",
"up",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/cmd/influxd/launcher/launcher.go#L109-L136 |
12,906 | influxdata/platform | query/influxql/service.go | Query | func (s *Service) Query(ctx context.Context, req *query.Request) (flux.ResultIterator, error) {
resp, err := s.query(ctx, req)
if err != nil {
return nil, err
}
// Decode the response into the JSON structure.
var results Response
if err := json.NewDecoder(resp.Body).Decode(&results); err != nil {
return nil, err
}
// Return a result iterator using the response.
return NewResponseIterator(&results), nil
} | go | func (s *Service) Query(ctx context.Context, req *query.Request) (flux.ResultIterator, error) {
resp, err := s.query(ctx, req)
if err != nil {
return nil, err
}
// Decode the response into the JSON structure.
var results Response
if err := json.NewDecoder(resp.Body).Decode(&results); err != nil {
return nil, err
}
// Return a result iterator using the response.
return NewResponseIterator(&results), nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"Query",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"query",
".",
"Request",
")",
"(",
"flux",
".",
"ResultIterator",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"query",
"(",
"c... | // Query will execute a query for the influxql.Compiler type against an influxdb 1.x endpoint,
// and return results using the default decoder. | [
"Query",
"will",
"execute",
"a",
"query",
"for",
"the",
"influxql",
".",
"Compiler",
"type",
"against",
"an",
"influxdb",
"1",
".",
"x",
"endpoint",
"and",
"return",
"results",
"using",
"the",
"default",
"decoder",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/query/influxql/service.go#L31-L45 |
12,907 | influxdata/platform | task/backend/executor/executor.go | NewAsyncQueryServiceExecutor | func NewAsyncQueryServiceExecutor(logger *zap.Logger, svc query.AsyncQueryService, st backend.Store) backend.Executor {
return &asyncQueryServiceExecutor{logger: logger, svc: svc, st: st}
} | go | func NewAsyncQueryServiceExecutor(logger *zap.Logger, svc query.AsyncQueryService, st backend.Store) backend.Executor {
return &asyncQueryServiceExecutor{logger: logger, svc: svc, st: st}
} | [
"func",
"NewAsyncQueryServiceExecutor",
"(",
"logger",
"*",
"zap",
".",
"Logger",
",",
"svc",
"query",
".",
"AsyncQueryService",
",",
"st",
"backend",
".",
"Store",
")",
"backend",
".",
"Executor",
"{",
"return",
"&",
"asyncQueryServiceExecutor",
"{",
"logger",
... | // NewQueryServiceExecutor returns a new executor based on the given AsyncQueryService. | [
"NewQueryServiceExecutor",
"returns",
"a",
"new",
"executor",
"based",
"on",
"the",
"given",
"AsyncQueryService",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/task/backend/executor/executor.go#L189-L191 |
12,908 | influxdata/platform | mock/auth_service.go | NewAuthorizationService | func NewAuthorizationService() *AuthorizationService {
return &AuthorizationService{
FindAuthorizationByIDFn: func(context.Context, platform.ID) (*platform.Authorization, error) { return nil, nil },
FindAuthorizationByTokenFn: func(context.Context, string) (*platform.Authorization, error) { return nil, nil },
FindAuthorizationsFn: func(context.Context, platform.AuthorizationFilter, ...platform.FindOptions) ([]*platform.Authorization, int, error) {
return nil, 0, nil
},
CreateAuthorizationFn: func(context.Context, *platform.Authorization) error { return nil },
DeleteAuthorizationFn: func(context.Context, platform.ID) error { return nil },
SetAuthorizationStatusFn: func(context.Context, platform.ID, platform.Status) error { return nil },
}
} | go | func NewAuthorizationService() *AuthorizationService {
return &AuthorizationService{
FindAuthorizationByIDFn: func(context.Context, platform.ID) (*platform.Authorization, error) { return nil, nil },
FindAuthorizationByTokenFn: func(context.Context, string) (*platform.Authorization, error) { return nil, nil },
FindAuthorizationsFn: func(context.Context, platform.AuthorizationFilter, ...platform.FindOptions) ([]*platform.Authorization, int, error) {
return nil, 0, nil
},
CreateAuthorizationFn: func(context.Context, *platform.Authorization) error { return nil },
DeleteAuthorizationFn: func(context.Context, platform.ID) error { return nil },
SetAuthorizationStatusFn: func(context.Context, platform.ID, platform.Status) error { return nil },
}
} | [
"func",
"NewAuthorizationService",
"(",
")",
"*",
"AuthorizationService",
"{",
"return",
"&",
"AuthorizationService",
"{",
"FindAuthorizationByIDFn",
":",
"func",
"(",
"context",
".",
"Context",
",",
"platform",
".",
"ID",
")",
"(",
"*",
"platform",
".",
"Author... | // NewAuthorizationService returns a mock AuthorizationService where its methods will return
// zero values. | [
"NewAuthorizationService",
"returns",
"a",
"mock",
"AuthorizationService",
"where",
"its",
"methods",
"will",
"return",
"zero",
"values",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/mock/auth_service.go#L29-L40 |
12,909 | influxdata/platform | http/user_service.go | FindMe | func (s *UserService) FindMe(ctx context.Context, id platform.ID) (*platform.User, error) {
url, err := newURL(s.Addr, mePath)
if err != nil {
return nil, err
}
req, err := http.NewRequest("GET", url.String(), nil)
if err != nil {
return nil, err
}
SetToken(s.Token, req)
hc := newClient(url.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := CheckError(resp, true); err != nil {
return nil, err
}
var res userResponse
if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
return nil, err
}
return &res.User, nil
} | go | func (s *UserService) FindMe(ctx context.Context, id platform.ID) (*platform.User, error) {
url, err := newURL(s.Addr, mePath)
if err != nil {
return nil, err
}
req, err := http.NewRequest("GET", url.String(), nil)
if err != nil {
return nil, err
}
SetToken(s.Token, req)
hc := newClient(url.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := CheckError(resp, true); err != nil {
return nil, err
}
var res userResponse
if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
return nil, err
}
return &res.User, nil
} | [
"func",
"(",
"s",
"*",
"UserService",
")",
"FindMe",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
")",
"(",
"*",
"platform",
".",
"User",
",",
"error",
")",
"{",
"url",
",",
"err",
":=",
"newURL",
"(",
"s",
".",
"Addr"... | // FindMe returns user information about the owner of the token | [
"FindMe",
"returns",
"user",
"information",
"about",
"the",
"owner",
"of",
"the",
"token"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/http/user_service.go#L421-L450 |
12,910 | influxdata/platform | http/user_service.go | FindUsers | func (s *UserService) FindUsers(ctx context.Context, filter platform.UserFilter, opt ...platform.FindOptions) ([]*platform.User, int, error) {
url, err := newURL(s.Addr, usersPath)
if err != nil {
return nil, 0, err
}
query := url.Query()
req, err := http.NewRequest("GET", url.String(), nil)
if err != nil {
return nil, 0, err
}
if filter.ID != nil {
query.Add("id", filter.ID.String())
}
if filter.Name != nil {
query.Add("name", *filter.Name)
}
req.URL.RawQuery = query.Encode()
SetToken(s.Token, req)
hc := newClient(url.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return nil, 0, err
}
if err := CheckError(resp, true); err != nil {
return nil, 0, err
}
var r usersResponse
if err := json.NewDecoder(resp.Body).Decode(&r); err != nil {
return nil, 0, err
}
us := r.ToPlatform()
return us, len(us), nil
} | go | func (s *UserService) FindUsers(ctx context.Context, filter platform.UserFilter, opt ...platform.FindOptions) ([]*platform.User, int, error) {
url, err := newURL(s.Addr, usersPath)
if err != nil {
return nil, 0, err
}
query := url.Query()
req, err := http.NewRequest("GET", url.String(), nil)
if err != nil {
return nil, 0, err
}
if filter.ID != nil {
query.Add("id", filter.ID.String())
}
if filter.Name != nil {
query.Add("name", *filter.Name)
}
req.URL.RawQuery = query.Encode()
SetToken(s.Token, req)
hc := newClient(url.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return nil, 0, err
}
if err := CheckError(resp, true); err != nil {
return nil, 0, err
}
var r usersResponse
if err := json.NewDecoder(resp.Body).Decode(&r); err != nil {
return nil, 0, err
}
us := r.ToPlatform()
return us, len(us), nil
} | [
"func",
"(",
"s",
"*",
"UserService",
")",
"FindUsers",
"(",
"ctx",
"context",
".",
"Context",
",",
"filter",
"platform",
".",
"UserFilter",
",",
"opt",
"...",
"platform",
".",
"FindOptions",
")",
"(",
"[",
"]",
"*",
"platform",
".",
"User",
",",
"int"... | // FindUsers returns a list of users that match filter and the total count of matching users.
// Additional options provide pagination & sorting. | [
"FindUsers",
"returns",
"a",
"list",
"of",
"users",
"that",
"match",
"filter",
"and",
"the",
"total",
"count",
"of",
"matching",
"users",
".",
"Additional",
"options",
"provide",
"pagination",
"&",
"sorting",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/http/user_service.go#L507-L546 |
12,911 | influxdata/platform | http/user_service.go | CreateUser | func (s *UserService) CreateUser(ctx context.Context, u *platform.User) error {
url, err := newURL(s.Addr, usersPath)
if err != nil {
return err
}
octets, err := json.Marshal(u)
if err != nil {
return err
}
req, err := http.NewRequest("POST", url.String(), bytes.NewReader(octets))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
SetToken(s.Token, req)
hc := newClient(url.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return err
}
// TODO(jsternberg): Should this check for a 201 explicitly?
if err := CheckError(resp, true); err != nil {
return err
}
if err := json.NewDecoder(resp.Body).Decode(u); err != nil {
return err
}
return nil
} | go | func (s *UserService) CreateUser(ctx context.Context, u *platform.User) error {
url, err := newURL(s.Addr, usersPath)
if err != nil {
return err
}
octets, err := json.Marshal(u)
if err != nil {
return err
}
req, err := http.NewRequest("POST", url.String(), bytes.NewReader(octets))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
SetToken(s.Token, req)
hc := newClient(url.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return err
}
// TODO(jsternberg): Should this check for a 201 explicitly?
if err := CheckError(resp, true); err != nil {
return err
}
if err := json.NewDecoder(resp.Body).Decode(u); err != nil {
return err
}
return nil
} | [
"func",
"(",
"s",
"*",
"UserService",
")",
"CreateUser",
"(",
"ctx",
"context",
".",
"Context",
",",
"u",
"*",
"platform",
".",
"User",
")",
"error",
"{",
"url",
",",
"err",
":=",
"newURL",
"(",
"s",
".",
"Addr",
",",
"usersPath",
")",
"\n",
"if",
... | // CreateUser creates a new user and sets u.ID with the new identifier. | [
"CreateUser",
"creates",
"a",
"new",
"user",
"and",
"sets",
"u",
".",
"ID",
"with",
"the",
"new",
"identifier",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/http/user_service.go#L549-L585 |
12,912 | influxdata/platform | pkg/deep/equal.go | Equal | func Equal(a1, a2 interface{}) bool {
if a1 == nil || a2 == nil {
return a1 == a2
}
v1 := reflect.ValueOf(a1)
v2 := reflect.ValueOf(a2)
if v1.Type() != v2.Type() {
return false
}
return deepValueEqual(v1, v2, make(map[visit]bool), 0)
} | go | func Equal(a1, a2 interface{}) bool {
if a1 == nil || a2 == nil {
return a1 == a2
}
v1 := reflect.ValueOf(a1)
v2 := reflect.ValueOf(a2)
if v1.Type() != v2.Type() {
return false
}
return deepValueEqual(v1, v2, make(map[visit]bool), 0)
} | [
"func",
"Equal",
"(",
"a1",
",",
"a2",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"a1",
"==",
"nil",
"||",
"a2",
"==",
"nil",
"{",
"return",
"a1",
"==",
"a2",
"\n",
"}",
"\n",
"v1",
":=",
"reflect",
".",
"ValueOf",
"(",
"a1",
")",
"\n",
"... | // Equal is a copy of reflect.DeepEqual except that it treats NaN == NaN as true. | [
"Equal",
"is",
"a",
"copy",
"of",
"reflect",
".",
"DeepEqual",
"except",
"that",
"it",
"treats",
"NaN",
"==",
"NaN",
"as",
"true",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/pkg/deep/equal.go#L41-L51 |
12,913 | influxdata/platform | storage/compat/compat.go | NewConfig | func NewConfig() Config {
return Config{
WALFsyncDelay: toml.Duration(tsm1.DefaultWALFsyncDelay),
ValidateKeys: storage.DefaultValidateKeys,
CacheMaxMemorySize: toml.Size(tsm1.DefaultCacheMaxMemorySize),
CacheSnapshotMemorySize: toml.Size(tsm1.DefaultCacheSnapshotMemorySize),
CacheSnapshotWriteColdDuration: toml.Duration(tsm1.DefaultCacheSnapshotWriteColdDuration),
CompactFullWriteColdDuration: toml.Duration(tsm1.DefaultCompactFullWriteColdDuration),
CompactThroughput: toml.Size(tsm1.DefaultCompactThroughput),
CompactThroughputBurst: toml.Size(tsm1.DefaultCompactThroughputBurst),
MaxConcurrentCompactions: tsm1.DefaultCompactMaxConcurrent,
TraceLoggingEnabled: storage.DefaultTraceLoggingEnabled,
TSMWillNeed: tsm1.DefaultMADVWillNeed,
}
} | go | func NewConfig() Config {
return Config{
WALFsyncDelay: toml.Duration(tsm1.DefaultWALFsyncDelay),
ValidateKeys: storage.DefaultValidateKeys,
CacheMaxMemorySize: toml.Size(tsm1.DefaultCacheMaxMemorySize),
CacheSnapshotMemorySize: toml.Size(tsm1.DefaultCacheSnapshotMemorySize),
CacheSnapshotWriteColdDuration: toml.Duration(tsm1.DefaultCacheSnapshotWriteColdDuration),
CompactFullWriteColdDuration: toml.Duration(tsm1.DefaultCompactFullWriteColdDuration),
CompactThroughput: toml.Size(tsm1.DefaultCompactThroughput),
CompactThroughputBurst: toml.Size(tsm1.DefaultCompactThroughputBurst),
MaxConcurrentCompactions: tsm1.DefaultCompactMaxConcurrent,
TraceLoggingEnabled: storage.DefaultTraceLoggingEnabled,
TSMWillNeed: tsm1.DefaultMADVWillNeed,
}
} | [
"func",
"NewConfig",
"(",
")",
"Config",
"{",
"return",
"Config",
"{",
"WALFsyncDelay",
":",
"toml",
".",
"Duration",
"(",
"tsm1",
".",
"DefaultWALFsyncDelay",
")",
",",
"ValidateKeys",
":",
"storage",
".",
"DefaultValidateKeys",
",",
"CacheMaxMemorySize",
":",
... | // NewConfig constructs an old Config struct with appropriate defaults for a new Config. | [
"NewConfig",
"constructs",
"an",
"old",
"Config",
"struct",
"with",
"appropriate",
"defaults",
"for",
"a",
"new",
"Config",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/storage/compat/compat.go#L35-L49 |
12,914 | influxdata/platform | storage/compat/compat.go | Convert | func Convert(oldConfig Config) (string, storage.Config) {
newConfig := storage.NewConfig()
newConfig.TraceLoggingEnabled = oldConfig.TraceLoggingEnabled
newConfig.ValidateKeys = oldConfig.ValidateKeys
newConfig.Engine.MADVWillNeed = oldConfig.TSMWillNeed
newConfig.Engine.Cache.MaxMemorySize = oldConfig.CacheMaxMemorySize
newConfig.Engine.Cache.SnapshotMemorySize = oldConfig.CacheSnapshotMemorySize
newConfig.Engine.Cache.SnapshotWriteColdDuration = oldConfig.CacheSnapshotWriteColdDuration
newConfig.Engine.Compaction.FullWriteColdDuration = oldConfig.CompactFullWriteColdDuration
newConfig.Engine.Compaction.Throughput = oldConfig.CompactThroughput
newConfig.Engine.Compaction.ThroughputBurst = oldConfig.CompactThroughputBurst
newConfig.Engine.Compaction.MaxConcurrent = oldConfig.MaxConcurrentCompactions
newConfig.WALPath = oldConfig.WALDir
newConfig.WAL.FsyncDelay = oldConfig.WALFsyncDelay
return oldConfig.Dir, newConfig
} | go | func Convert(oldConfig Config) (string, storage.Config) {
newConfig := storage.NewConfig()
newConfig.TraceLoggingEnabled = oldConfig.TraceLoggingEnabled
newConfig.ValidateKeys = oldConfig.ValidateKeys
newConfig.Engine.MADVWillNeed = oldConfig.TSMWillNeed
newConfig.Engine.Cache.MaxMemorySize = oldConfig.CacheMaxMemorySize
newConfig.Engine.Cache.SnapshotMemorySize = oldConfig.CacheSnapshotMemorySize
newConfig.Engine.Cache.SnapshotWriteColdDuration = oldConfig.CacheSnapshotWriteColdDuration
newConfig.Engine.Compaction.FullWriteColdDuration = oldConfig.CompactFullWriteColdDuration
newConfig.Engine.Compaction.Throughput = oldConfig.CompactThroughput
newConfig.Engine.Compaction.ThroughputBurst = oldConfig.CompactThroughputBurst
newConfig.Engine.Compaction.MaxConcurrent = oldConfig.MaxConcurrentCompactions
newConfig.WALPath = oldConfig.WALDir
newConfig.WAL.FsyncDelay = oldConfig.WALFsyncDelay
return oldConfig.Dir, newConfig
} | [
"func",
"Convert",
"(",
"oldConfig",
"Config",
")",
"(",
"string",
",",
"storage",
".",
"Config",
")",
"{",
"newConfig",
":=",
"storage",
".",
"NewConfig",
"(",
")",
"\n",
"newConfig",
".",
"TraceLoggingEnabled",
"=",
"oldConfig",
".",
"TraceLoggingEnabled",
... | // Convert takes an old Config and converts it into a new Config. It also returns the value
// of the Dir key so that it can be passed through appropriately to the storage engine constructor. | [
"Convert",
"takes",
"an",
"old",
"Config",
"and",
"converts",
"it",
"into",
"a",
"new",
"Config",
".",
"It",
"also",
"returns",
"the",
"value",
"of",
"the",
"Dir",
"key",
"so",
"that",
"it",
"can",
"be",
"passed",
"through",
"appropriately",
"to",
"the",... | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/storage/compat/compat.go#L53-L68 |
12,915 | influxdata/platform | query/control/controller.go | Query | func (c *Controller) Query(ctx context.Context, req *query.Request) (flux.Query, error) {
// Set the request on the context so platform specific Flux operations can retrieve it later.
ctx = query.ContextWithRequest(ctx, req)
// Set the org label value for controller metrics
ctx = context.WithValue(ctx, orgLabel, req.OrganizationID.String())
q, err := c.c.Query(ctx, req.Compiler)
if err != nil {
// If the controller reports an error, it's usually because of a syntax error
// or other problem that the client must fix.
return q, &platform.Error{
Code: platform.EInvalid,
Msg: err.Error(),
}
}
return q, nil
} | go | func (c *Controller) Query(ctx context.Context, req *query.Request) (flux.Query, error) {
// Set the request on the context so platform specific Flux operations can retrieve it later.
ctx = query.ContextWithRequest(ctx, req)
// Set the org label value for controller metrics
ctx = context.WithValue(ctx, orgLabel, req.OrganizationID.String())
q, err := c.c.Query(ctx, req.Compiler)
if err != nil {
// If the controller reports an error, it's usually because of a syntax error
// or other problem that the client must fix.
return q, &platform.Error{
Code: platform.EInvalid,
Msg: err.Error(),
}
}
return q, nil
} | [
"func",
"(",
"c",
"*",
"Controller",
")",
"Query",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"query",
".",
"Request",
")",
"(",
"flux",
".",
"Query",
",",
"error",
")",
"{",
"// Set the request on the context so platform specific Flux operations ca... | // Query satisfies the AsyncQueryService while ensuring the request is propagated on the context. | [
"Query",
"satisfies",
"the",
"AsyncQueryService",
"while",
"ensuring",
"the",
"request",
"is",
"propagated",
"on",
"the",
"context",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/query/control/controller.go#L30-L46 |
12,916 | influxdata/platform | pkg/rhh/rhh.go | grow | func (m *HashMap) grow() {
// Copy old elements and hashes.
elems, hashes := m.elems, m.hashes
capacity := m.capacity
// Double capacity & reallocate.
m.capacity *= 2
m.alloc()
// Copy old elements to new hash/elem list.
for i := int64(0); i < capacity; i++ {
elem, hash := &elems[i], hashes[i]
if hash == 0 {
continue
}
m.insert(hash, elem.key, elem.value)
}
} | go | func (m *HashMap) grow() {
// Copy old elements and hashes.
elems, hashes := m.elems, m.hashes
capacity := m.capacity
// Double capacity & reallocate.
m.capacity *= 2
m.alloc()
// Copy old elements to new hash/elem list.
for i := int64(0); i < capacity; i++ {
elem, hash := &elems[i], hashes[i]
if hash == 0 {
continue
}
m.insert(hash, elem.key, elem.value)
}
} | [
"func",
"(",
"m",
"*",
"HashMap",
")",
"grow",
"(",
")",
"{",
"// Copy old elements and hashes.",
"elems",
",",
"hashes",
":=",
"m",
".",
"elems",
",",
"m",
".",
"hashes",
"\n",
"capacity",
":=",
"m",
".",
"capacity",
"\n\n",
"// Double capacity & reallocate... | // grow doubles the capacity and reinserts all existing hashes & elements. | [
"grow",
"doubles",
"the",
"capacity",
"and",
"reinserts",
"all",
"existing",
"hashes",
"&",
"elements",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/pkg/rhh/rhh.go#L185-L202 |
12,917 | influxdata/platform | bolt/dashboard.go | CreateDashboard | func (c *Client) CreateDashboard(ctx context.Context, d *platform.Dashboard) error {
err := c.db.Update(func(tx *bolt.Tx) error {
d.ID = c.IDGenerator.ID()
for _, cell := range d.Cells {
cell.ID = c.IDGenerator.ID()
if err := c.createCellView(ctx, tx, d.ID, cell.ID, nil); err != nil {
return err
}
}
if err := c.appendDashboardEventToLog(ctx, tx, d.ID, dashboardCreatedEvent); err != nil {
return err
}
// TODO(desa): don't populate this here. use the first/last methods of the oplog to get meta fields.
d.Meta.CreatedAt = c.time()
return c.putDashboardWithMeta(ctx, tx, d)
})
if err != nil {
return &platform.Error{
Err: err,
Op: getOp(platform.OpCreateDashboard),
}
}
return nil
} | go | func (c *Client) CreateDashboard(ctx context.Context, d *platform.Dashboard) error {
err := c.db.Update(func(tx *bolt.Tx) error {
d.ID = c.IDGenerator.ID()
for _, cell := range d.Cells {
cell.ID = c.IDGenerator.ID()
if err := c.createCellView(ctx, tx, d.ID, cell.ID, nil); err != nil {
return err
}
}
if err := c.appendDashboardEventToLog(ctx, tx, d.ID, dashboardCreatedEvent); err != nil {
return err
}
// TODO(desa): don't populate this here. use the first/last methods of the oplog to get meta fields.
d.Meta.CreatedAt = c.time()
return c.putDashboardWithMeta(ctx, tx, d)
})
if err != nil {
return &platform.Error{
Err: err,
Op: getOp(platform.OpCreateDashboard),
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateDashboard",
"(",
"ctx",
"context",
".",
"Context",
",",
"d",
"*",
"platform",
".",
"Dashboard",
")",
"error",
"{",
"err",
":=",
"c",
".",
"db",
".",
"Update",
"(",
"func",
"(",
"tx",
"*",
"bolt",
".",
... | // CreateDashboard creates a platform dashboard and sets d.ID. | [
"CreateDashboard",
"creates",
"a",
"platform",
"dashboard",
"and",
"sets",
"d",
".",
"ID",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/dashboard.go#L197-L225 |
12,918 | influxdata/platform | tsdb/tsm1/wal.go | EnableTraceLogging | func (l *WAL) EnableTraceLogging(enabled bool) {
l.traceLogging = enabled
if enabled {
l.traceLogger = l.logger
}
} | go | func (l *WAL) EnableTraceLogging(enabled bool) {
l.traceLogging = enabled
if enabled {
l.traceLogger = l.logger
}
} | [
"func",
"(",
"l",
"*",
"WAL",
")",
"EnableTraceLogging",
"(",
"enabled",
"bool",
")",
"{",
"l",
".",
"traceLogging",
"=",
"enabled",
"\n",
"if",
"enabled",
"{",
"l",
".",
"traceLogger",
"=",
"l",
".",
"logger",
"\n",
"}",
"\n",
"}"
] | // EnableTraceLogging must be called before the WAL is opened. | [
"EnableTraceLogging",
"must",
"be",
"called",
"before",
"the",
"WAL",
"is",
"opened",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L145-L150 |
12,919 | influxdata/platform | tsdb/tsm1/wal.go | WriteMulti | func (l *WAL) WriteMulti(values map[string][]Value) (int, error) {
entry := &WriteWALEntry{
Values: values,
}
id, err := l.writeToLog(entry)
if err != nil {
l.tracker.IncWritesErr()
return -1, err
}
l.tracker.IncWritesOK()
return id, nil
} | go | func (l *WAL) WriteMulti(values map[string][]Value) (int, error) {
entry := &WriteWALEntry{
Values: values,
}
id, err := l.writeToLog(entry)
if err != nil {
l.tracker.IncWritesErr()
return -1, err
}
l.tracker.IncWritesOK()
return id, nil
} | [
"func",
"(",
"l",
"*",
"WAL",
")",
"WriteMulti",
"(",
"values",
"map",
"[",
"string",
"]",
"[",
"]",
"Value",
")",
"(",
"int",
",",
"error",
")",
"{",
"entry",
":=",
"&",
"WriteWALEntry",
"{",
"Values",
":",
"values",
",",
"}",
"\n\n",
"id",
",",... | // WriteMulti writes the given values to the WAL. It returns the WAL segment ID to
// which the points were written. If an error is returned the segment ID should
// be ignored. | [
"WriteMulti",
"writes",
"the",
"given",
"values",
"to",
"the",
"WAL",
".",
"It",
"returns",
"the",
"WAL",
"segment",
"ID",
"to",
"which",
"the",
"points",
"were",
"written",
".",
"If",
"an",
"error",
"is",
"returned",
"the",
"segment",
"ID",
"should",
"b... | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L303-L316 |
12,920 | influxdata/platform | tsdb/tsm1/wal.go | ClosedSegments | func (l *WAL) ClosedSegments() ([]string, error) {
l.mu.RLock()
defer l.mu.RUnlock()
// Not loading files from disk so nothing to do
if l.path == "" {
return nil, nil
}
var currentFile string
if l.currentSegmentWriter != nil {
currentFile = l.currentSegmentWriter.path()
}
files, err := segmentFileNames(l.path)
if err != nil {
return nil, err
}
var closedFiles []string
for _, fn := range files {
// Skip the current path
if fn == currentFile {
continue
}
closedFiles = append(closedFiles, fn)
}
return closedFiles, nil
} | go | func (l *WAL) ClosedSegments() ([]string, error) {
l.mu.RLock()
defer l.mu.RUnlock()
// Not loading files from disk so nothing to do
if l.path == "" {
return nil, nil
}
var currentFile string
if l.currentSegmentWriter != nil {
currentFile = l.currentSegmentWriter.path()
}
files, err := segmentFileNames(l.path)
if err != nil {
return nil, err
}
var closedFiles []string
for _, fn := range files {
// Skip the current path
if fn == currentFile {
continue
}
closedFiles = append(closedFiles, fn)
}
return closedFiles, nil
} | [
"func",
"(",
"l",
"*",
"WAL",
")",
"ClosedSegments",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"l",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"l",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"// Not loading files from disk s... | // ClosedSegments returns a slice of the names of the closed segment files. | [
"ClosedSegments",
"returns",
"a",
"slice",
"of",
"the",
"names",
"of",
"the",
"closed",
"segment",
"files",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L319-L348 |
12,921 | influxdata/platform | tsdb/tsm1/wal.go | Delete | func (l *WAL) Delete(keys [][]byte) (int, error) {
if len(keys) == 0 {
return 0, nil
}
entry := &DeleteWALEntry{
Keys: keys,
}
id, err := l.writeToLog(entry)
if err != nil {
return -1, err
}
return id, nil
} | go | func (l *WAL) Delete(keys [][]byte) (int, error) {
if len(keys) == 0 {
return 0, nil
}
entry := &DeleteWALEntry{
Keys: keys,
}
id, err := l.writeToLog(entry)
if err != nil {
return -1, err
}
return id, nil
} | [
"func",
"(",
"l",
"*",
"WAL",
")",
"Delete",
"(",
"keys",
"[",
"]",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"len",
"(",
"keys",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n",
"entry",
":=",
"&",
... | // Delete deletes the given keys, returning the segment ID for the operation. | [
"Delete",
"deletes",
"the",
"given",
"keys",
"returning",
"the",
"segment",
"ID",
"for",
"the",
"operation",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L487-L500 |
12,922 | influxdata/platform | tsdb/tsm1/wal.go | DeleteRange | func (l *WAL) DeleteRange(keys [][]byte, min, max int64) (int, error) {
if len(keys) == 0 {
return 0, nil
}
entry := &DeleteRangeWALEntry{
Keys: keys,
Min: min,
Max: max,
}
id, err := l.writeToLog(entry)
if err != nil {
return -1, err
}
return id, nil
} | go | func (l *WAL) DeleteRange(keys [][]byte, min, max int64) (int, error) {
if len(keys) == 0 {
return 0, nil
}
entry := &DeleteRangeWALEntry{
Keys: keys,
Min: min,
Max: max,
}
id, err := l.writeToLog(entry)
if err != nil {
return -1, err
}
return id, nil
} | [
"func",
"(",
"l",
"*",
"WAL",
")",
"DeleteRange",
"(",
"keys",
"[",
"]",
"[",
"]",
"byte",
",",
"min",
",",
"max",
"int64",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"len",
"(",
"keys",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"... | // DeleteRange deletes the given keys within the given time range,
// returning the segment ID for the operation. | [
"DeleteRange",
"deletes",
"the",
"given",
"keys",
"within",
"the",
"given",
"time",
"range",
"returning",
"the",
"segment",
"ID",
"for",
"the",
"operation",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L504-L519 |
12,923 | influxdata/platform | tsdb/tsm1/wal.go | segmentFileNames | func segmentFileNames(dir string) ([]string, error) {
names, err := filepath.Glob(filepath.Join(dir, fmt.Sprintf("%s*.%s", WALFilePrefix, WALFileExtension)))
if err != nil {
return nil, err
}
sort.Strings(names)
return names, nil
} | go | func segmentFileNames(dir string) ([]string, error) {
names, err := filepath.Glob(filepath.Join(dir, fmt.Sprintf("%s*.%s", WALFilePrefix, WALFileExtension)))
if err != nil {
return nil, err
}
sort.Strings(names)
return names, nil
} | [
"func",
"segmentFileNames",
"(",
"dir",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"names",
",",
"err",
":=",
"filepath",
".",
"Glob",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
... | // segmentFileNames will return all files that are WAL segment files in sorted order by ascending ID. | [
"segmentFileNames",
"will",
"return",
"all",
"files",
"that",
"are",
"WAL",
"segment",
"files",
"in",
"sorted",
"order",
"by",
"ascending",
"ID",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L542-L549 |
12,924 | influxdata/platform | tsdb/tsm1/wal.go | Encode | func (w *DeleteWALEntry) Encode(dst []byte) ([]byte, error) {
sz := w.MarshalSize()
if len(dst) < sz {
dst = make([]byte, sz)
}
var n int
for _, k := range w.Keys {
n += copy(dst[n:], k)
n += copy(dst[n:], "\n")
}
// We return n-1 to strip off the last newline so that unmarshalling the value
// does not produce an empty string
return []byte(dst[:n-1]), nil
} | go | func (w *DeleteWALEntry) Encode(dst []byte) ([]byte, error) {
sz := w.MarshalSize()
if len(dst) < sz {
dst = make([]byte, sz)
}
var n int
for _, k := range w.Keys {
n += copy(dst[n:], k)
n += copy(dst[n:], "\n")
}
// We return n-1 to strip off the last newline so that unmarshalling the value
// does not produce an empty string
return []byte(dst[:n-1]), nil
} | [
"func",
"(",
"w",
"*",
"DeleteWALEntry",
")",
"Encode",
"(",
"dst",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"sz",
":=",
"w",
".",
"MarshalSize",
"(",
")",
"\n\n",
"if",
"len",
"(",
"dst",
")",
"<",
"sz",
"{",
"ds... | // Encode converts the DeleteWALEntry into a byte slice, appending to dst. | [
"Encode",
"converts",
"the",
"DeleteWALEntry",
"into",
"a",
"byte",
"slice",
"appending",
"to",
"dst",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L1005-L1021 |
12,925 | influxdata/platform | tsdb/tsm1/wal.go | Encode | func (w *DeleteRangeWALEntry) Encode(b []byte) ([]byte, error) {
sz := w.MarshalSize()
if len(b) < sz {
b = make([]byte, sz)
}
binary.BigEndian.PutUint64(b[:8], uint64(w.Min))
binary.BigEndian.PutUint64(b[8:16], uint64(w.Max))
i := 16
for _, k := range w.Keys {
binary.BigEndian.PutUint32(b[i:i+4], uint32(len(k)))
i += 4
i += copy(b[i:], k)
}
return b[:i], nil
} | go | func (w *DeleteRangeWALEntry) Encode(b []byte) ([]byte, error) {
sz := w.MarshalSize()
if len(b) < sz {
b = make([]byte, sz)
}
binary.BigEndian.PutUint64(b[:8], uint64(w.Min))
binary.BigEndian.PutUint64(b[8:16], uint64(w.Max))
i := 16
for _, k := range w.Keys {
binary.BigEndian.PutUint32(b[i:i+4], uint32(len(k)))
i += 4
i += copy(b[i:], k)
}
return b[:i], nil
} | [
"func",
"(",
"w",
"*",
"DeleteRangeWALEntry",
")",
"Encode",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"sz",
":=",
"w",
".",
"MarshalSize",
"(",
")",
"\n\n",
"if",
"len",
"(",
"b",
")",
"<",
"sz",
"{",
"b... | // Encode converts the DeleteRangeWALEntry into a byte slice, appending to b. | [
"Encode",
"converts",
"the",
"DeleteRangeWALEntry",
"into",
"a",
"byte",
"slice",
"appending",
"to",
"b",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L1087-L1105 |
12,926 | influxdata/platform | tsdb/tsm1/wal.go | Next | func (r *WALSegmentReader) Next() bool {
var nReadOK int
// read the type and the length of the entry
var lv [5]byte
n, err := io.ReadFull(r.r, lv[:])
if err == io.EOF {
return false
}
if err != nil {
r.err = err
// We return true here because we want the client code to call read which
// will return the this error to be handled.
return true
}
nReadOK += n
entryType := lv[0]
length := binary.BigEndian.Uint32(lv[1:5])
b := *(getBuf(int(length)))
defer putBuf(&b)
// read the compressed block and decompress it
n, err = io.ReadFull(r.r, b[:length])
if err != nil {
r.err = err
return true
}
nReadOK += n
decLen, err := snappy.DecodedLen(b[:length])
if err != nil {
r.err = err
return true
}
decBuf := *(getBuf(decLen))
defer putBuf(&decBuf)
data, err := snappy.Decode(decBuf, b[:length])
if err != nil {
r.err = err
return true
}
// and marshal it and send it to the cache
switch WalEntryType(entryType) {
case WriteWALEntryType:
r.entry = &WriteWALEntry{
Values: make(map[string][]Value),
}
case DeleteWALEntryType:
r.entry = &DeleteWALEntry{}
case DeleteRangeWALEntryType:
r.entry = &DeleteRangeWALEntry{}
default:
r.err = fmt.Errorf("unknown wal entry type: %v", entryType)
return true
}
r.err = r.entry.UnmarshalBinary(data)
if r.err == nil {
// Read and decode of this entry was successful.
r.n += int64(nReadOK)
}
return true
} | go | func (r *WALSegmentReader) Next() bool {
var nReadOK int
// read the type and the length of the entry
var lv [5]byte
n, err := io.ReadFull(r.r, lv[:])
if err == io.EOF {
return false
}
if err != nil {
r.err = err
// We return true here because we want the client code to call read which
// will return the this error to be handled.
return true
}
nReadOK += n
entryType := lv[0]
length := binary.BigEndian.Uint32(lv[1:5])
b := *(getBuf(int(length)))
defer putBuf(&b)
// read the compressed block and decompress it
n, err = io.ReadFull(r.r, b[:length])
if err != nil {
r.err = err
return true
}
nReadOK += n
decLen, err := snappy.DecodedLen(b[:length])
if err != nil {
r.err = err
return true
}
decBuf := *(getBuf(decLen))
defer putBuf(&decBuf)
data, err := snappy.Decode(decBuf, b[:length])
if err != nil {
r.err = err
return true
}
// and marshal it and send it to the cache
switch WalEntryType(entryType) {
case WriteWALEntryType:
r.entry = &WriteWALEntry{
Values: make(map[string][]Value),
}
case DeleteWALEntryType:
r.entry = &DeleteWALEntry{}
case DeleteRangeWALEntryType:
r.entry = &DeleteRangeWALEntry{}
default:
r.err = fmt.Errorf("unknown wal entry type: %v", entryType)
return true
}
r.err = r.entry.UnmarshalBinary(data)
if r.err == nil {
// Read and decode of this entry was successful.
r.n += int64(nReadOK)
}
return true
} | [
"func",
"(",
"r",
"*",
"WALSegmentReader",
")",
"Next",
"(",
")",
"bool",
"{",
"var",
"nReadOK",
"int",
"\n\n",
"// read the type and the length of the entry",
"var",
"lv",
"[",
"5",
"]",
"byte",
"\n",
"n",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"... | // Next indicates if there is a value to read. | [
"Next",
"indicates",
"if",
"there",
"is",
"a",
"value",
"to",
"read",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/wal.go#L1203-L1270 |
12,927 | influxdata/platform | bolt/authorization.go | SetAuthorizationStatus | func (c *Client) SetAuthorizationStatus(ctx context.Context, id platform.ID, status platform.Status) error {
return c.db.Update(func(tx *bolt.Tx) error {
if pe := c.updateAuthorization(ctx, tx, id, status); pe != nil {
return &platform.Error{
Err: pe,
Op: platform.OpSetAuthorizationStatus,
}
}
return nil
})
} | go | func (c *Client) SetAuthorizationStatus(ctx context.Context, id platform.ID, status platform.Status) error {
return c.db.Update(func(tx *bolt.Tx) error {
if pe := c.updateAuthorization(ctx, tx, id, status); pe != nil {
return &platform.Error{
Err: pe,
Op: platform.OpSetAuthorizationStatus,
}
}
return nil
})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetAuthorizationStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
",",
"status",
"platform",
".",
"Status",
")",
"error",
"{",
"return",
"c",
".",
"db",
".",
"Update",
"(",
"func",
... | // SetAuthorizationStatus updates the status of the authorization. Useful
// for setting an authorization to inactive or active. | [
"SetAuthorizationStatus",
"updates",
"the",
"status",
"of",
"the",
"authorization",
".",
"Useful",
"for",
"setting",
"an",
"authorization",
"to",
"inactive",
"or",
"active",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/authorization.go#L377-L387 |
12,928 | influxdata/platform | cmd/influx/main.go | Execute | func Execute() {
if err := influxCmd.Execute(); err != nil {
fmt.Println(err)
os.Exit(1)
}
} | go | func Execute() {
if err := influxCmd.Execute(); err != nil {
fmt.Println(err)
os.Exit(1)
}
} | [
"func",
"Execute",
"(",
")",
"{",
"if",
"err",
":=",
"influxCmd",
".",
"Execute",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"}"
] | // Execute executes the influx command | [
"Execute",
"executes",
"the",
"influx",
"command"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/cmd/influx/main.go#L90-L95 |
12,929 | influxdata/platform | tsdb/tsm1/cache.go | init | func (c *Cache) init() {
if !atomic.CompareAndSwapUint32(&c.initializedCount, 0, 1) {
return
}
c.mu.Lock()
c.store, _ = newring(ringShards)
c.mu.Unlock()
} | go | func (c *Cache) init() {
if !atomic.CompareAndSwapUint32(&c.initializedCount, 0, 1) {
return
}
c.mu.Lock()
c.store, _ = newring(ringShards)
c.mu.Unlock()
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"init",
"(",
")",
"{",
"if",
"!",
"atomic",
".",
"CompareAndSwapUint32",
"(",
"&",
"c",
".",
"initializedCount",
",",
"0",
",",
"1",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"c",
".",
"mu",
".",
"Lock",
"(",
"... | // init initializes the cache and allocates the underlying store. Once initialized,
// the store re-used until Freed. | [
"init",
"initializes",
"the",
"cache",
"and",
"allocates",
"the",
"underlying",
"store",
".",
"Once",
"initialized",
"the",
"store",
"re",
"-",
"used",
"until",
"Freed",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/cache.go#L199-L207 |
12,930 | influxdata/platform | tsdb/tsm1/cache.go | Free | func (c *Cache) Free() {
if !atomic.CompareAndSwapUint32(&c.initializedCount, 1, 0) {
return
}
c.mu.Lock()
c.store = emptyStore{}
c.mu.Unlock()
} | go | func (c *Cache) Free() {
if !atomic.CompareAndSwapUint32(&c.initializedCount, 1, 0) {
return
}
c.mu.Lock()
c.store = emptyStore{}
c.mu.Unlock()
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"Free",
"(",
")",
"{",
"if",
"!",
"atomic",
".",
"CompareAndSwapUint32",
"(",
"&",
"c",
".",
"initializedCount",
",",
"1",
",",
"0",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"c",
".",
"mu",
".",
"Lock",
"(",
"... | // Free releases the underlying store and memory held by the Cache. | [
"Free",
"releases",
"the",
"underlying",
"store",
"and",
"memory",
"held",
"by",
"the",
"Cache",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/cache.go#L210-L218 |
12,931 | influxdata/platform | tsdb/tsm1/cache.go | Write | func (c *Cache) Write(key []byte, values []Value) error {
c.init()
addedSize := uint64(Values(values).Size())
// Enough room in the cache?
limit := c.maxSize
n := c.Size() + addedSize
if limit > 0 && n > limit {
c.tracker.IncWritesErr()
c.tracker.AddWrittenBytesDrop(uint64(addedSize))
return ErrCacheMemorySizeLimitExceeded(n, limit)
}
newKey, err := c.store.write(key, values)
if err != nil {
c.tracker.IncWritesErr()
c.tracker.AddWrittenBytesErr(uint64(addedSize))
return err
}
if newKey {
addedSize += uint64(len(key))
}
// Update the cache size and the memory size stat.
c.tracker.IncCacheSize(addedSize)
c.tracker.AddMemBytes(addedSize)
c.tracker.AddWrittenBytesOK(uint64(addedSize))
c.tracker.IncWritesOK()
return nil
} | go | func (c *Cache) Write(key []byte, values []Value) error {
c.init()
addedSize := uint64(Values(values).Size())
// Enough room in the cache?
limit := c.maxSize
n := c.Size() + addedSize
if limit > 0 && n > limit {
c.tracker.IncWritesErr()
c.tracker.AddWrittenBytesDrop(uint64(addedSize))
return ErrCacheMemorySizeLimitExceeded(n, limit)
}
newKey, err := c.store.write(key, values)
if err != nil {
c.tracker.IncWritesErr()
c.tracker.AddWrittenBytesErr(uint64(addedSize))
return err
}
if newKey {
addedSize += uint64(len(key))
}
// Update the cache size and the memory size stat.
c.tracker.IncCacheSize(addedSize)
c.tracker.AddMemBytes(addedSize)
c.tracker.AddWrittenBytesOK(uint64(addedSize))
c.tracker.IncWritesOK()
return nil
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"Write",
"(",
"key",
"[",
"]",
"byte",
",",
"values",
"[",
"]",
"Value",
")",
"error",
"{",
"c",
".",
"init",
"(",
")",
"\n",
"addedSize",
":=",
"uint64",
"(",
"Values",
"(",
"values",
")",
".",
"Size",
"(",... | // Write writes the set of values for the key to the cache. This function is goroutine-safe.
// It returns an error if the cache will exceed its max size by adding the new values. | [
"Write",
"writes",
"the",
"set",
"of",
"values",
"for",
"the",
"key",
"to",
"the",
"cache",
".",
"This",
"function",
"is",
"goroutine",
"-",
"safe",
".",
"It",
"returns",
"an",
"error",
"if",
"the",
"cache",
"will",
"exceed",
"its",
"max",
"size",
"by"... | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/cache.go#L222-L253 |
12,932 | influxdata/platform | tsdb/tsm1/cache.go | WriteMulti | func (c *Cache) WriteMulti(values map[string][]Value) error {
c.init()
var addedSize uint64
for _, v := range values {
addedSize += uint64(Values(v).Size())
}
// Enough room in the cache?
limit := c.maxSize // maxSize is safe for reading without a lock.
n := c.Size() + addedSize
if limit > 0 && n > limit {
c.tracker.IncWritesErr()
c.tracker.AddWrittenBytesDrop(uint64(addedSize))
return ErrCacheMemorySizeLimitExceeded(n, limit)
}
var werr error
c.mu.RLock()
store := c.store
c.mu.RUnlock()
var bytesWrittenErr uint64
// We'll optimistically set size here, and then decrement it for write errors.
for k, v := range values {
newKey, err := store.write([]byte(k), v)
if err != nil {
// The write failed, hold onto the error and adjust the size delta.
werr = err
addedSize -= uint64(Values(v).Size())
bytesWrittenErr += uint64(Values(v).Size())
}
if newKey {
addedSize += uint64(len(k))
}
}
// Some points in the batch were dropped. An error is returned so
// error stat is incremented as well.
if werr != nil {
c.tracker.IncWritesErr()
c.tracker.IncWritesDrop()
c.tracker.AddWrittenBytesErr(bytesWrittenErr)
}
// Update the memory size stat
c.tracker.IncCacheSize(addedSize)
c.tracker.AddMemBytes(addedSize)
c.tracker.IncWritesOK()
c.tracker.AddWrittenBytesOK(addedSize)
c.mu.Lock()
c.lastWriteTime = time.Now()
c.mu.Unlock()
return werr
} | go | func (c *Cache) WriteMulti(values map[string][]Value) error {
c.init()
var addedSize uint64
for _, v := range values {
addedSize += uint64(Values(v).Size())
}
// Enough room in the cache?
limit := c.maxSize // maxSize is safe for reading without a lock.
n := c.Size() + addedSize
if limit > 0 && n > limit {
c.tracker.IncWritesErr()
c.tracker.AddWrittenBytesDrop(uint64(addedSize))
return ErrCacheMemorySizeLimitExceeded(n, limit)
}
var werr error
c.mu.RLock()
store := c.store
c.mu.RUnlock()
var bytesWrittenErr uint64
// We'll optimistically set size here, and then decrement it for write errors.
for k, v := range values {
newKey, err := store.write([]byte(k), v)
if err != nil {
// The write failed, hold onto the error and adjust the size delta.
werr = err
addedSize -= uint64(Values(v).Size())
bytesWrittenErr += uint64(Values(v).Size())
}
if newKey {
addedSize += uint64(len(k))
}
}
// Some points in the batch were dropped. An error is returned so
// error stat is incremented as well.
if werr != nil {
c.tracker.IncWritesErr()
c.tracker.IncWritesDrop()
c.tracker.AddWrittenBytesErr(bytesWrittenErr)
}
// Update the memory size stat
c.tracker.IncCacheSize(addedSize)
c.tracker.AddMemBytes(addedSize)
c.tracker.IncWritesOK()
c.tracker.AddWrittenBytesOK(addedSize)
c.mu.Lock()
c.lastWriteTime = time.Now()
c.mu.Unlock()
return werr
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"WriteMulti",
"(",
"values",
"map",
"[",
"string",
"]",
"[",
"]",
"Value",
")",
"error",
"{",
"c",
".",
"init",
"(",
")",
"\n",
"var",
"addedSize",
"uint64",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values"... | // WriteMulti writes the map of keys and associated values to the cache. This
// function is goroutine-safe. It returns an error if the cache will exceeded
// its max size by adding the new values. The write attempts to write as many
// values as possible. If one key fails, the others can still succeed and an
// error will be returned. | [
"WriteMulti",
"writes",
"the",
"map",
"of",
"keys",
"and",
"associated",
"values",
"to",
"the",
"cache",
".",
"This",
"function",
"is",
"goroutine",
"-",
"safe",
".",
"It",
"returns",
"an",
"error",
"if",
"the",
"cache",
"will",
"exceeded",
"its",
"max",
... | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/cache.go#L260-L317 |
12,933 | influxdata/platform | tsdb/tsm1/cache.go | Delete | func (c *Cache) Delete(keys [][]byte) {
c.DeleteRange(keys, math.MinInt64, math.MaxInt64)
} | go | func (c *Cache) Delete(keys [][]byte) {
c.DeleteRange(keys, math.MinInt64, math.MaxInt64)
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"Delete",
"(",
"keys",
"[",
"]",
"[",
"]",
"byte",
")",
"{",
"c",
".",
"DeleteRange",
"(",
"keys",
",",
"math",
".",
"MinInt64",
",",
"math",
".",
"MaxInt64",
")",
"\n",
"}"
] | // Delete removes all values for the given keys from the cache. | [
"Delete",
"removes",
"all",
"values",
"for",
"the",
"given",
"keys",
"from",
"the",
"cache",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/cache.go#L549-L551 |
12,934 | influxdata/platform | tsdb/tsm1/cache.go | NewCacheLoader | func NewCacheLoader(files []string) *CacheLoader {
return &CacheLoader{
files: files,
Logger: zap.NewNop(),
}
} | go | func NewCacheLoader(files []string) *CacheLoader {
return &CacheLoader{
files: files,
Logger: zap.NewNop(),
}
} | [
"func",
"NewCacheLoader",
"(",
"files",
"[",
"]",
"string",
")",
"*",
"CacheLoader",
"{",
"return",
"&",
"CacheLoader",
"{",
"files",
":",
"files",
",",
"Logger",
":",
"zap",
".",
"NewNop",
"(",
")",
",",
"}",
"\n",
"}"
] | // NewCacheLoader returns a new instance of a CacheLoader. | [
"NewCacheLoader",
"returns",
"a",
"new",
"instance",
"of",
"a",
"CacheLoader",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/cache.go#L636-L641 |
12,935 | influxdata/platform | tsdb/tsm1/cache.go | Load | func (cl *CacheLoader) Load(cache *Cache) error {
var r *WALSegmentReader
for _, fn := range cl.files {
if err := func() error {
f, err := os.OpenFile(fn, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
return err
}
defer f.Close()
// Log some information about the segments.
stat, err := os.Stat(f.Name())
if err != nil {
return err
}
cl.Logger.Info("Reading file", zap.String("path", f.Name()), zap.Int64("size", stat.Size()))
// Nothing to read, skip it
if stat.Size() == 0 {
return nil
}
if r == nil {
r = NewWALSegmentReader(f)
defer r.Close()
} else {
r.Reset(f)
}
for r.Next() {
entry, err := r.Read()
if err != nil {
n := r.Count()
cl.Logger.Info("File corrupt", zap.Error(err), zap.String("path", f.Name()), zap.Int64("pos", n))
if err := f.Truncate(n); err != nil {
return err
}
break
}
switch t := entry.(type) {
case *WriteWALEntry:
if err := cache.WriteMulti(t.Values); err != nil {
return err
}
case *DeleteRangeWALEntry:
cache.DeleteRange(t.Keys, t.Min, t.Max)
case *DeleteWALEntry:
cache.Delete(t.Keys)
}
}
return r.Close()
}(); err != nil {
return err
}
}
return nil
} | go | func (cl *CacheLoader) Load(cache *Cache) error {
var r *WALSegmentReader
for _, fn := range cl.files {
if err := func() error {
f, err := os.OpenFile(fn, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
return err
}
defer f.Close()
// Log some information about the segments.
stat, err := os.Stat(f.Name())
if err != nil {
return err
}
cl.Logger.Info("Reading file", zap.String("path", f.Name()), zap.Int64("size", stat.Size()))
// Nothing to read, skip it
if stat.Size() == 0 {
return nil
}
if r == nil {
r = NewWALSegmentReader(f)
defer r.Close()
} else {
r.Reset(f)
}
for r.Next() {
entry, err := r.Read()
if err != nil {
n := r.Count()
cl.Logger.Info("File corrupt", zap.Error(err), zap.String("path", f.Name()), zap.Int64("pos", n))
if err := f.Truncate(n); err != nil {
return err
}
break
}
switch t := entry.(type) {
case *WriteWALEntry:
if err := cache.WriteMulti(t.Values); err != nil {
return err
}
case *DeleteRangeWALEntry:
cache.DeleteRange(t.Keys, t.Min, t.Max)
case *DeleteWALEntry:
cache.Delete(t.Keys)
}
}
return r.Close()
}(); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"cl",
"*",
"CacheLoader",
")",
"Load",
"(",
"cache",
"*",
"Cache",
")",
"error",
"{",
"var",
"r",
"*",
"WALSegmentReader",
"\n",
"for",
"_",
",",
"fn",
":=",
"range",
"cl",
".",
"files",
"{",
"if",
"err",
":=",
"func",
"(",
")",
"err... | // Load returns a cache loaded with the data contained within the segment files.
// If, during reading of a segment file, corruption is encountered, that segment
// file is truncated up to and including the last valid byte, and processing
// continues with the next segment file. | [
"Load",
"returns",
"a",
"cache",
"loaded",
"with",
"the",
"data",
"contained",
"within",
"the",
"segment",
"files",
".",
"If",
"during",
"reading",
"of",
"a",
"segment",
"file",
"corruption",
"is",
"encountered",
"that",
"segment",
"file",
"is",
"truncated",
... | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/tsm1/cache.go#L647-L706 |
12,936 | influxdata/platform | view.go | UnmarshalViewPropertiesJSON | func UnmarshalViewPropertiesJSON(b []byte) (ViewProperties, error) {
var v struct {
B json.RawMessage `json:"properties"`
}
if err := json.Unmarshal(b, &v); err != nil {
return nil, err
}
if len(v.B) == 0 {
// Then there wasn't any visualization field, so there's no need unmarshal it
return EmptyViewProperties{}, nil
}
var t struct {
Shape string `json:"shape"`
Type string `json:"type"`
}
if err := json.Unmarshal(v.B, &t); err != nil {
return nil, err
}
var vis ViewProperties
switch t.Shape {
case "chronograf-v2":
switch t.Type {
case "xy":
var xyv XYViewProperties
if err := json.Unmarshal(v.B, &xyv); err != nil {
return nil, err
}
vis = xyv
case "single-stat":
var ssv SingleStatViewProperties
if err := json.Unmarshal(v.B, &ssv); err != nil {
return nil, err
}
vis = ssv
case "gauge":
var gv GaugeViewProperties
if err := json.Unmarshal(v.B, &gv); err != nil {
return nil, err
}
vis = gv
case "table":
var tv TableViewProperties
if err := json.Unmarshal(v.B, &tv); err != nil {
return nil, err
}
vis = tv
case "markdown":
var mv MarkdownViewProperties
if err := json.Unmarshal(v.B, &mv); err != nil {
return nil, err
}
vis = mv
case "log-viewer": // happens in log viewer stays in log viewer.
var lv LogViewProperties
if err := json.Unmarshal(v.B, &lv); err != nil {
return nil, err
}
vis = lv
case "line-plus-single-stat":
var lv LinePlusSingleStatProperties
if err := json.Unmarshal(v.B, &lv); err != nil {
return nil, err
}
vis = lv
}
case "empty":
var ev EmptyViewProperties
if err := json.Unmarshal(v.B, &ev); err != nil {
return nil, err
}
vis = ev
default:
return nil, fmt.Errorf("unknown type %v", t.Shape)
}
return vis, nil
} | go | func UnmarshalViewPropertiesJSON(b []byte) (ViewProperties, error) {
var v struct {
B json.RawMessage `json:"properties"`
}
if err := json.Unmarshal(b, &v); err != nil {
return nil, err
}
if len(v.B) == 0 {
// Then there wasn't any visualization field, so there's no need unmarshal it
return EmptyViewProperties{}, nil
}
var t struct {
Shape string `json:"shape"`
Type string `json:"type"`
}
if err := json.Unmarshal(v.B, &t); err != nil {
return nil, err
}
var vis ViewProperties
switch t.Shape {
case "chronograf-v2":
switch t.Type {
case "xy":
var xyv XYViewProperties
if err := json.Unmarshal(v.B, &xyv); err != nil {
return nil, err
}
vis = xyv
case "single-stat":
var ssv SingleStatViewProperties
if err := json.Unmarshal(v.B, &ssv); err != nil {
return nil, err
}
vis = ssv
case "gauge":
var gv GaugeViewProperties
if err := json.Unmarshal(v.B, &gv); err != nil {
return nil, err
}
vis = gv
case "table":
var tv TableViewProperties
if err := json.Unmarshal(v.B, &tv); err != nil {
return nil, err
}
vis = tv
case "markdown":
var mv MarkdownViewProperties
if err := json.Unmarshal(v.B, &mv); err != nil {
return nil, err
}
vis = mv
case "log-viewer": // happens in log viewer stays in log viewer.
var lv LogViewProperties
if err := json.Unmarshal(v.B, &lv); err != nil {
return nil, err
}
vis = lv
case "line-plus-single-stat":
var lv LinePlusSingleStatProperties
if err := json.Unmarshal(v.B, &lv); err != nil {
return nil, err
}
vis = lv
}
case "empty":
var ev EmptyViewProperties
if err := json.Unmarshal(v.B, &ev); err != nil {
return nil, err
}
vis = ev
default:
return nil, fmt.Errorf("unknown type %v", t.Shape)
}
return vis, nil
} | [
"func",
"UnmarshalViewPropertiesJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"ViewProperties",
",",
"error",
")",
"{",
"var",
"v",
"struct",
"{",
"B",
"json",
".",
"RawMessage",
"`json:\"properties\"`",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
... | // UnmarshalViewPropertiesJSON unmarshals JSON bytes into a ViewProperties. | [
"UnmarshalViewPropertiesJSON",
"unmarshals",
"JSON",
"bytes",
"into",
"a",
"ViewProperties",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/view.go#L117-L198 |
12,937 | influxdata/platform | view.go | MarshalViewPropertiesJSON | func MarshalViewPropertiesJSON(v ViewProperties) ([]byte, error) {
var s interface{}
switch vis := v.(type) {
case SingleStatViewProperties:
s = struct {
Shape string `json:"shape"`
SingleStatViewProperties
}{
Shape: "chronograf-v2",
SingleStatViewProperties: vis,
}
case TableViewProperties:
s = struct {
Shape string `json:"shape"`
TableViewProperties
}{
Shape: "chronograf-v2",
TableViewProperties: vis,
}
case GaugeViewProperties:
s = struct {
Shape string `json:"shape"`
GaugeViewProperties
}{
Shape: "chronograf-v2",
GaugeViewProperties: vis,
}
case XYViewProperties:
s = struct {
Shape string `json:"shape"`
XYViewProperties
}{
Shape: "chronograf-v2",
XYViewProperties: vis,
}
case LinePlusSingleStatProperties:
s = struct {
Shape string `json:"shape"`
LinePlusSingleStatProperties
}{
Shape: "chronograf-v2",
LinePlusSingleStatProperties: vis,
}
case MarkdownViewProperties:
s = struct {
Shape string `json:"shape"`
MarkdownViewProperties
}{
Shape: "chronograf-v2",
MarkdownViewProperties: vis,
}
case LogViewProperties:
s = struct {
Shape string `json:"shape"`
LogViewProperties
}{
Shape: "chronograf-v2",
LogViewProperties: vis,
}
default:
s = struct {
Shape string `json:"shape"`
EmptyViewProperties
}{
Shape: "empty",
EmptyViewProperties: EmptyViewProperties{},
}
}
return json.Marshal(s)
} | go | func MarshalViewPropertiesJSON(v ViewProperties) ([]byte, error) {
var s interface{}
switch vis := v.(type) {
case SingleStatViewProperties:
s = struct {
Shape string `json:"shape"`
SingleStatViewProperties
}{
Shape: "chronograf-v2",
SingleStatViewProperties: vis,
}
case TableViewProperties:
s = struct {
Shape string `json:"shape"`
TableViewProperties
}{
Shape: "chronograf-v2",
TableViewProperties: vis,
}
case GaugeViewProperties:
s = struct {
Shape string `json:"shape"`
GaugeViewProperties
}{
Shape: "chronograf-v2",
GaugeViewProperties: vis,
}
case XYViewProperties:
s = struct {
Shape string `json:"shape"`
XYViewProperties
}{
Shape: "chronograf-v2",
XYViewProperties: vis,
}
case LinePlusSingleStatProperties:
s = struct {
Shape string `json:"shape"`
LinePlusSingleStatProperties
}{
Shape: "chronograf-v2",
LinePlusSingleStatProperties: vis,
}
case MarkdownViewProperties:
s = struct {
Shape string `json:"shape"`
MarkdownViewProperties
}{
Shape: "chronograf-v2",
MarkdownViewProperties: vis,
}
case LogViewProperties:
s = struct {
Shape string `json:"shape"`
LogViewProperties
}{
Shape: "chronograf-v2",
LogViewProperties: vis,
}
default:
s = struct {
Shape string `json:"shape"`
EmptyViewProperties
}{
Shape: "empty",
EmptyViewProperties: EmptyViewProperties{},
}
}
return json.Marshal(s)
} | [
"func",
"MarshalViewPropertiesJSON",
"(",
"v",
"ViewProperties",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"s",
"interface",
"{",
"}",
"\n",
"switch",
"vis",
":=",
"v",
".",
"(",
"type",
")",
"{",
"case",
"SingleStatViewProperties",
":",... | // MarshalViewPropertiesJSON encodes a view into JSON bytes. | [
"MarshalViewPropertiesJSON",
"encodes",
"a",
"view",
"into",
"JSON",
"bytes",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/view.go#L201-L270 |
12,938 | influxdata/platform | http/proto.go | NewProtoBackend | func NewProtoBackend(b *APIBackend) *ProtoBackend {
return &ProtoBackend{
Logger: b.Logger.With(zap.String("handler", "proto")),
ProtoService: b.ProtoService,
LabelService: b.LabelService,
}
} | go | func NewProtoBackend(b *APIBackend) *ProtoBackend {
return &ProtoBackend{
Logger: b.Logger.With(zap.String("handler", "proto")),
ProtoService: b.ProtoService,
LabelService: b.LabelService,
}
} | [
"func",
"NewProtoBackend",
"(",
"b",
"*",
"APIBackend",
")",
"*",
"ProtoBackend",
"{",
"return",
"&",
"ProtoBackend",
"{",
"Logger",
":",
"b",
".",
"Logger",
".",
"With",
"(",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
",",
"... | // NewProtoBackend creates an instance of the Protobackend from the APIBackend. | [
"NewProtoBackend",
"creates",
"an",
"instance",
"of",
"the",
"Protobackend",
"from",
"the",
"APIBackend",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/http/proto.go#L55-L61 |
12,939 | influxdata/platform | http/proto.go | NewProtoHandler | func NewProtoHandler(b *ProtoBackend) *ProtoHandler {
h := &ProtoHandler{
Router: NewRouter(),
Logger: b.Logger,
ProtoService: b.ProtoService,
LabelService: b.LabelService,
}
h.HandlerFunc("GET", protosPath, h.handleGetProtos)
h.HandlerFunc("POST", protosDashboardsPath, h.handlePostProtosDashboards)
return h
} | go | func NewProtoHandler(b *ProtoBackend) *ProtoHandler {
h := &ProtoHandler{
Router: NewRouter(),
Logger: b.Logger,
ProtoService: b.ProtoService,
LabelService: b.LabelService,
}
h.HandlerFunc("GET", protosPath, h.handleGetProtos)
h.HandlerFunc("POST", protosDashboardsPath, h.handlePostProtosDashboards)
return h
} | [
"func",
"NewProtoHandler",
"(",
"b",
"*",
"ProtoBackend",
")",
"*",
"ProtoHandler",
"{",
"h",
":=",
"&",
"ProtoHandler",
"{",
"Router",
":",
"NewRouter",
"(",
")",
",",
"Logger",
":",
"b",
".",
"Logger",
",",
"ProtoService",
":",
"b",
".",
"ProtoService"... | // NewProtoHandler creates an instance of a proto handler. | [
"NewProtoHandler",
"creates",
"an",
"instance",
"of",
"a",
"proto",
"handler",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/http/proto.go#L64-L76 |
12,940 | influxdata/platform | http/proto.go | Decode | func (r *createProtoResourcesRequest) Decode(req *http.Request) error {
ctx := req.Context()
id, err := extractProtoID(ctx)
if err != nil {
return err
}
r.ProtoID = id
if err := json.NewDecoder(req.Body).Decode(r); err != nil {
return err
}
return nil
} | go | func (r *createProtoResourcesRequest) Decode(req *http.Request) error {
ctx := req.Context()
id, err := extractProtoID(ctx)
if err != nil {
return err
}
r.ProtoID = id
if err := json.NewDecoder(req.Body).Decode(r); err != nil {
return err
}
return nil
} | [
"func",
"(",
"r",
"*",
"createProtoResourcesRequest",
")",
"Decode",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"ctx",
":=",
"req",
".",
"Context",
"(",
")",
"\n",
"id",
",",
"err",
":=",
"extractProtoID",
"(",
"ctx",
")",
"\n",
"if"... | // Decode turns an http request into a createProtoResourceRequest. | [
"Decode",
"turns",
"an",
"http",
"request",
"into",
"a",
"createProtoResourceRequest",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/http/proto.go#L128-L142 |
12,941 | influxdata/platform | tsdb/errors.go | NewShardError | func NewShardError(id uint64, err error) error {
if err == nil {
return nil
}
return ShardError{id: id, Err: err}
} | go | func NewShardError(id uint64, err error) error {
if err == nil {
return nil
}
return ShardError{id: id, Err: err}
} | [
"func",
"NewShardError",
"(",
"id",
"uint64",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"ShardError",
"{",
"id",
":",
"id",
",",
"Err",
":",
"err",
"}",
"\n",
"}"
] | // NewShardError returns a new ShardError. | [
"NewShardError",
"returns",
"a",
"new",
"ShardError",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/errors.go#L28-L33 |
12,942 | influxdata/platform | http/org_service.go | UpdateOrganization | func (s *OrganizationService) UpdateOrganization(ctx context.Context, id platform.ID, upd platform.OrganizationUpdate) (*platform.Organization, error) {
u, err := newURL(s.Addr, organizationIDPath(id))
if err != nil {
return nil, err
}
octets, err := json.Marshal(upd)
if err != nil {
return nil, err
}
req, err := http.NewRequest("PATCH", u.String(), bytes.NewReader(octets))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
SetToken(s.Token, req)
hc := newClient(u.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return nil, err
}
if err := CheckError(resp, true); err != nil {
return nil, err
}
var o platform.Organization
if err := json.NewDecoder(resp.Body).Decode(&o); err != nil {
return nil, err
}
defer resp.Body.Close()
return &o, nil
} | go | func (s *OrganizationService) UpdateOrganization(ctx context.Context, id platform.ID, upd platform.OrganizationUpdate) (*platform.Organization, error) {
u, err := newURL(s.Addr, organizationIDPath(id))
if err != nil {
return nil, err
}
octets, err := json.Marshal(upd)
if err != nil {
return nil, err
}
req, err := http.NewRequest("PATCH", u.String(), bytes.NewReader(octets))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
SetToken(s.Token, req)
hc := newClient(u.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return nil, err
}
if err := CheckError(resp, true); err != nil {
return nil, err
}
var o platform.Organization
if err := json.NewDecoder(resp.Body).Decode(&o); err != nil {
return nil, err
}
defer resp.Body.Close()
return &o, nil
} | [
"func",
"(",
"s",
"*",
"OrganizationService",
")",
"UpdateOrganization",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
",",
"upd",
"platform",
".",
"OrganizationUpdate",
")",
"(",
"*",
"platform",
".",
"Organization",
",",
"error",... | // UpdateOrganization updates the organization over HTTP. | [
"UpdateOrganization",
"updates",
"the",
"organization",
"over",
"HTTP",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/http/org_service.go#L632-L669 |
12,943 | influxdata/platform | bolt/macro.go | FindMacroByID | func (c *Client) FindMacroByID(ctx context.Context, id platform.ID) (*platform.Macro, error) {
op := getOp(platform.OpFindMacroByID)
var macro *platform.Macro
err := c.db.View(func(tx *bolt.Tx) error {
m, pe := c.findMacroByID(ctx, tx, id)
if pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
macro = m
return nil
})
if err != nil {
return nil, err
}
return macro, nil
} | go | func (c *Client) FindMacroByID(ctx context.Context, id platform.ID) (*platform.Macro, error) {
op := getOp(platform.OpFindMacroByID)
var macro *platform.Macro
err := c.db.View(func(tx *bolt.Tx) error {
m, pe := c.findMacroByID(ctx, tx, id)
if pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
macro = m
return nil
})
if err != nil {
return nil, err
}
return macro, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"FindMacroByID",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
")",
"(",
"*",
"platform",
".",
"Macro",
",",
"error",
")",
"{",
"op",
":=",
"getOp",
"(",
"platform",
".",
"OpFindMacroBy... | // FindMacroByID finds a single macro in the store by its ID | [
"FindMacroByID",
"finds",
"a",
"single",
"macro",
"in",
"the",
"store",
"by",
"its",
"ID"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/macro.go#L54-L73 |
12,944 | influxdata/platform | bolt/macro.go | CreateMacro | func (c *Client) CreateMacro(ctx context.Context, macro *platform.Macro) error {
op := getOp(platform.OpCreateMacro)
return c.db.Update(func(tx *bolt.Tx) error {
macro.ID = c.IDGenerator.ID()
if pe := c.putMacro(ctx, tx, macro); pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
return nil
})
} | go | func (c *Client) CreateMacro(ctx context.Context, macro *platform.Macro) error {
op := getOp(platform.OpCreateMacro)
return c.db.Update(func(tx *bolt.Tx) error {
macro.ID = c.IDGenerator.ID()
if pe := c.putMacro(ctx, tx, macro); pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
return nil
})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateMacro",
"(",
"ctx",
"context",
".",
"Context",
",",
"macro",
"*",
"platform",
".",
"Macro",
")",
"error",
"{",
"op",
":=",
"getOp",
"(",
"platform",
".",
"OpCreateMacro",
")",
"\n",
"return",
"c",
".",
"db... | // CreateMacro creates a new macro and assigns it an ID | [
"CreateMacro",
"creates",
"a",
"new",
"macro",
"and",
"assigns",
"it",
"an",
"ID"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/macro.go#L104-L117 |
12,945 | influxdata/platform | bolt/macro.go | ReplaceMacro | func (c *Client) ReplaceMacro(ctx context.Context, macro *platform.Macro) error {
op := getOp(platform.OpReplaceMacro)
return c.db.Update(func(tx *bolt.Tx) error {
if pe := c.putMacro(ctx, tx, macro); pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
return nil
})
} | go | func (c *Client) ReplaceMacro(ctx context.Context, macro *platform.Macro) error {
op := getOp(platform.OpReplaceMacro)
return c.db.Update(func(tx *bolt.Tx) error {
if pe := c.putMacro(ctx, tx, macro); pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
return nil
})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ReplaceMacro",
"(",
"ctx",
"context",
".",
"Context",
",",
"macro",
"*",
"platform",
".",
"Macro",
")",
"error",
"{",
"op",
":=",
"getOp",
"(",
"platform",
".",
"OpReplaceMacro",
")",
"\n",
"return",
"c",
".",
"... | // ReplaceMacro puts a macro in the store | [
"ReplaceMacro",
"puts",
"a",
"macro",
"in",
"the",
"store"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/macro.go#L120-L131 |
12,946 | influxdata/platform | bolt/macro.go | UpdateMacro | func (c *Client) UpdateMacro(ctx context.Context, id platform.ID, update *platform.MacroUpdate) (*platform.Macro, error) {
op := getOp(platform.OpUpdateMacro)
var macro *platform.Macro
err := c.db.Update(func(tx *bolt.Tx) error {
m, pe := c.findMacroByID(ctx, tx, id)
if pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
if err := update.Apply(m); err != nil {
return &platform.Error{
Op: op,
Err: err,
}
}
macro = m
if pe = c.putMacro(ctx, tx, macro); pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
return nil
})
return macro, err
} | go | func (c *Client) UpdateMacro(ctx context.Context, id platform.ID, update *platform.MacroUpdate) (*platform.Macro, error) {
op := getOp(platform.OpUpdateMacro)
var macro *platform.Macro
err := c.db.Update(func(tx *bolt.Tx) error {
m, pe := c.findMacroByID(ctx, tx, id)
if pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
if err := update.Apply(m); err != nil {
return &platform.Error{
Op: op,
Err: err,
}
}
macro = m
if pe = c.putMacro(ctx, tx, macro); pe != nil {
return &platform.Error{
Op: op,
Err: pe,
}
}
return nil
})
return macro, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpdateMacro",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
",",
"update",
"*",
"platform",
".",
"MacroUpdate",
")",
"(",
"*",
"platform",
".",
"Macro",
",",
"error",
")",
"{",
"op",
... | // UpdateMacro updates a single macro in the store with a changeset | [
"UpdateMacro",
"updates",
"a",
"single",
"macro",
"in",
"the",
"store",
"with",
"a",
"changeset"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/macro.go#L159-L189 |
12,947 | influxdata/platform | bolt/macro.go | DeleteMacro | func (c *Client) DeleteMacro(ctx context.Context, id platform.ID) error {
op := getOp(platform.OpDeleteMacro)
return c.db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket(macroBucket)
encID, err := id.Encode()
if err != nil {
return &platform.Error{
Code: platform.EInvalid,
Op: op,
Err: err,
}
}
d := b.Get(encID)
if d == nil {
return &platform.Error{
Code: platform.ENotFound,
Op: op,
Msg: "macro not found",
}
}
if err := b.Delete(encID); err != nil {
return &platform.Error{
Op: op,
Err: err,
}
}
return nil
})
} | go | func (c *Client) DeleteMacro(ctx context.Context, id platform.ID) error {
op := getOp(platform.OpDeleteMacro)
return c.db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket(macroBucket)
encID, err := id.Encode()
if err != nil {
return &platform.Error{
Code: platform.EInvalid,
Op: op,
Err: err,
}
}
d := b.Get(encID)
if d == nil {
return &platform.Error{
Code: platform.ENotFound,
Op: op,
Msg: "macro not found",
}
}
if err := b.Delete(encID); err != nil {
return &platform.Error{
Op: op,
Err: err,
}
}
return nil
})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteMacro",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
")",
"error",
"{",
"op",
":=",
"getOp",
"(",
"platform",
".",
"OpDeleteMacro",
")",
"\n",
"return",
"c",
".",
"db",
".",
"... | // DeleteMacro removes a single macro from the store by its ID | [
"DeleteMacro",
"removes",
"a",
"single",
"macro",
"from",
"the",
"store",
"by",
"its",
"ID"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/macro.go#L192-L224 |
12,948 | influxdata/platform | models/points.go | ParsePoints | func ParsePoints(buf []byte) ([]Point, error) {
return ParsePointsWithPrecision(buf, time.Now().UTC(), "n")
} | go | func ParsePoints(buf []byte) ([]Point, error) {
return ParsePointsWithPrecision(buf, time.Now().UTC(), "n")
} | [
"func",
"ParsePoints",
"(",
"buf",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"Point",
",",
"error",
")",
"{",
"return",
"ParsePointsWithPrecision",
"(",
"buf",
",",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // ParsePoints returns a slice of Points from a text representation of a point
// with each point separated by newlines. If any points fail to parse, a non-nil error
// will be returned in addition to the points that parsed successfully. | [
"ParsePoints",
"returns",
"a",
"slice",
"of",
"Points",
"from",
"a",
"text",
"representation",
"of",
"a",
"point",
"with",
"each",
"point",
"separated",
"by",
"newlines",
".",
"If",
"any",
"points",
"fail",
"to",
"parse",
"a",
"non",
"-",
"nil",
"error",
... | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/models/points.go#L279-L281 |
12,949 | influxdata/platform | models/points.go | ValidKeyToken | func ValidKeyToken(s string) bool {
if !utf8.ValidString(s) {
return false
}
for _, r := range s {
if !unicode.IsPrint(r) || r == unicode.ReplacementChar {
return false
}
}
return true
} | go | func ValidKeyToken(s string) bool {
if !utf8.ValidString(s) {
return false
}
for _, r := range s {
if !unicode.IsPrint(r) || r == unicode.ReplacementChar {
return false
}
}
return true
} | [
"func",
"ValidKeyToken",
"(",
"s",
"string",
")",
"bool",
"{",
"if",
"!",
"utf8",
".",
"ValidString",
"(",
"s",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"s",
"{",
"if",
"!",
"unicode",
".",
"IsPrint",
"("... | // ValidKeyToken returns true if the token used for measurement, tag key, or tag
// value is a valid unicode string and only contains printable, non-replacement characters. | [
"ValidKeyToken",
"returns",
"true",
"if",
"the",
"token",
"used",
"for",
"measurement",
"tag",
"key",
"or",
"tag",
"value",
"is",
"a",
"valid",
"unicode",
"string",
"and",
"only",
"contains",
"printable",
"non",
"-",
"replacement",
"characters",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/models/points.go#L2458-L2468 |
12,950 | influxdata/platform | models/points.go | ValidKeyTokens | func ValidKeyTokens(name string, tags Tags) bool {
if !ValidKeyToken(name) {
return false
}
for _, tag := range tags {
if !ValidKeyToken(string(tag.Key)) || !ValidKeyToken(string(tag.Value)) {
return false
}
}
return true
} | go | func ValidKeyTokens(name string, tags Tags) bool {
if !ValidKeyToken(name) {
return false
}
for _, tag := range tags {
if !ValidKeyToken(string(tag.Key)) || !ValidKeyToken(string(tag.Value)) {
return false
}
}
return true
} | [
"func",
"ValidKeyTokens",
"(",
"name",
"string",
",",
"tags",
"Tags",
")",
"bool",
"{",
"if",
"!",
"ValidKeyToken",
"(",
"name",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"_",
",",
"tag",
":=",
"range",
"tags",
"{",
"if",
"!",
"ValidKeyTok... | // ValidKeyTokens returns true if the measurement name and all tags are valid. | [
"ValidKeyTokens",
"returns",
"true",
"if",
"the",
"measurement",
"name",
"and",
"all",
"tags",
"are",
"valid",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/models/points.go#L2471-L2481 |
12,951 | influxdata/platform | label.go | Validate | func (l *Label) Validate() error {
if !l.ResourceID.Valid() {
return &Error{
Code: EInvalid,
Msg: "resourceID is required",
}
}
if l.Name == "" {
return &Error{
Code: EInvalid,
Msg: "label name is required",
}
}
return nil
} | go | func (l *Label) Validate() error {
if !l.ResourceID.Valid() {
return &Error{
Code: EInvalid,
Msg: "resourceID is required",
}
}
if l.Name == "" {
return &Error{
Code: EInvalid,
Msg: "label name is required",
}
}
return nil
} | [
"func",
"(",
"l",
"*",
"Label",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"!",
"l",
".",
"ResourceID",
".",
"Valid",
"(",
")",
"{",
"return",
"&",
"Error",
"{",
"Code",
":",
"EInvalid",
",",
"Msg",
":",
"\"",
"\"",
",",
"}",
"\n",
"}",
"... | // Validate returns an error if the label is invalid. | [
"Validate",
"returns",
"an",
"error",
"if",
"the",
"label",
"is",
"invalid",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/label.go#L38-L54 |
12,952 | influxdata/platform | http/auth_service.go | SetAuthorizationStatus | func (s *AuthorizationService) SetAuthorizationStatus(ctx context.Context, id platform.ID, status platform.Status) error {
u, err := newURL(s.Addr, authorizationIDPath(id))
if err != nil {
return err
}
b, err := json.Marshal(setAuthorizationStatusRequest{
Status: status,
})
if err != nil {
return err
}
req, err := http.NewRequest("PATCH", u.String(), bytes.NewReader(b))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
SetToken(s.Token, req)
hc := newClient(u.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return err
}
if err := CheckError(resp, true); err != nil {
return err
}
return nil
} | go | func (s *AuthorizationService) SetAuthorizationStatus(ctx context.Context, id platform.ID, status platform.Status) error {
u, err := newURL(s.Addr, authorizationIDPath(id))
if err != nil {
return err
}
b, err := json.Marshal(setAuthorizationStatusRequest{
Status: status,
})
if err != nil {
return err
}
req, err := http.NewRequest("PATCH", u.String(), bytes.NewReader(b))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
SetToken(s.Token, req)
hc := newClient(u.Scheme, s.InsecureSkipVerify)
resp, err := hc.Do(req)
if err != nil {
return err
}
if err := CheckError(resp, true); err != nil {
return err
}
return nil
} | [
"func",
"(",
"s",
"*",
"AuthorizationService",
")",
"SetAuthorizationStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
",",
"status",
"platform",
".",
"Status",
")",
"error",
"{",
"u",
",",
"err",
":=",
"newURL",
"(",
"s",... | // SetAuthorizationStatus updates an authorization's status. | [
"SetAuthorizationStatus",
"updates",
"an",
"authorization",
"s",
"status",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/http/auth_service.go#L695-L728 |
12,953 | influxdata/platform | inmem/macro.go | FindMacroByID | func (s *Service) FindMacroByID(ctx context.Context, id platform.ID) (*platform.Macro, error) {
op := OpPrefix + platform.OpFindMacroByID
i, ok := s.macroKV.Load(id.String())
if !ok {
return nil, &platform.Error{
Op: op,
Code: platform.ENotFound,
Msg: "macro not found",
}
}
macro, ok := i.(*platform.Macro)
if !ok {
return nil, &platform.Error{
Op: op,
Msg: fmt.Sprintf("type %T is not a macro", i),
}
}
return macro, nil
} | go | func (s *Service) FindMacroByID(ctx context.Context, id platform.ID) (*platform.Macro, error) {
op := OpPrefix + platform.OpFindMacroByID
i, ok := s.macroKV.Load(id.String())
if !ok {
return nil, &platform.Error{
Op: op,
Code: platform.ENotFound,
Msg: "macro not found",
}
}
macro, ok := i.(*platform.Macro)
if !ok {
return nil, &platform.Error{
Op: op,
Msg: fmt.Sprintf("type %T is not a macro", i),
}
}
return macro, nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"FindMacroByID",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
")",
"(",
"*",
"platform",
".",
"Macro",
",",
"error",
")",
"{",
"op",
":=",
"OpPrefix",
"+",
"platform",
".",
"OpFindMac... | // FindMacroByID implements the platform.MacroService interface | [
"FindMacroByID",
"implements",
"the",
"platform",
".",
"MacroService",
"interface"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/macro.go#L11-L31 |
12,954 | influxdata/platform | inmem/macro.go | FindMacros | func (s *Service) FindMacros(ctx context.Context) ([]*platform.Macro, error) {
op := OpPrefix + platform.OpFindMacros
var err error
var macros []*platform.Macro
s.macroKV.Range(func(k, v interface{}) bool {
macro, ok := v.(*platform.Macro)
if !ok {
err = &platform.Error{
Op: op,
Msg: fmt.Sprintf("type %T is not a macro", v),
}
return false
}
macros = append(macros, macro)
return true
})
if err != nil {
return nil, err
}
return macros, nil
} | go | func (s *Service) FindMacros(ctx context.Context) ([]*platform.Macro, error) {
op := OpPrefix + platform.OpFindMacros
var err error
var macros []*platform.Macro
s.macroKV.Range(func(k, v interface{}) bool {
macro, ok := v.(*platform.Macro)
if !ok {
err = &platform.Error{
Op: op,
Msg: fmt.Sprintf("type %T is not a macro", v),
}
return false
}
macros = append(macros, macro)
return true
})
if err != nil {
return nil, err
}
return macros, nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"FindMacros",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"*",
"platform",
".",
"Macro",
",",
"error",
")",
"{",
"op",
":=",
"OpPrefix",
"+",
"platform",
".",
"OpFindMacros",
"\n",
"var",
"err",
... | // FindMacros implements the platform.MacroService interface | [
"FindMacros",
"implements",
"the",
"platform",
".",
"MacroService",
"interface"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/macro.go#L34-L57 |
12,955 | influxdata/platform | inmem/macro.go | CreateMacro | func (s *Service) CreateMacro(ctx context.Context, m *platform.Macro) error {
op := OpPrefix + platform.OpCreateMacro
m.ID = s.IDGenerator.ID()
err := s.ReplaceMacro(ctx, m)
if err != nil {
return &platform.Error{
Op: op,
Err: err,
}
}
return nil
} | go | func (s *Service) CreateMacro(ctx context.Context, m *platform.Macro) error {
op := OpPrefix + platform.OpCreateMacro
m.ID = s.IDGenerator.ID()
err := s.ReplaceMacro(ctx, m)
if err != nil {
return &platform.Error{
Op: op,
Err: err,
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"CreateMacro",
"(",
"ctx",
"context",
".",
"Context",
",",
"m",
"*",
"platform",
".",
"Macro",
")",
"error",
"{",
"op",
":=",
"OpPrefix",
"+",
"platform",
".",
"OpCreateMacro",
"\n",
"m",
".",
"ID",
"=",
"s",
... | // CreateMacro implements the platform.MacroService interface | [
"CreateMacro",
"implements",
"the",
"platform",
".",
"MacroService",
"interface"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/macro.go#L60-L71 |
12,956 | influxdata/platform | inmem/macro.go | UpdateMacro | func (s *Service) UpdateMacro(ctx context.Context, id platform.ID, update *platform.MacroUpdate) (*platform.Macro, error) {
op := OpPrefix + platform.OpUpdateMacro
macro, err := s.FindMacroByID(ctx, id)
if err != nil {
return nil, &platform.Error{
Op: op,
Code: platform.ENotFound,
Msg: "macro not found",
Err: err,
}
}
if err := update.Apply(macro); err != nil {
return nil, &platform.Error{
Op: op,
Err: err,
}
}
if err := s.ReplaceMacro(ctx, macro); err != nil {
return nil, &platform.Error{
Op: op,
Err: err,
}
}
return macro, nil
} | go | func (s *Service) UpdateMacro(ctx context.Context, id platform.ID, update *platform.MacroUpdate) (*platform.Macro, error) {
op := OpPrefix + platform.OpUpdateMacro
macro, err := s.FindMacroByID(ctx, id)
if err != nil {
return nil, &platform.Error{
Op: op,
Code: platform.ENotFound,
Msg: "macro not found",
Err: err,
}
}
if err := update.Apply(macro); err != nil {
return nil, &platform.Error{
Op: op,
Err: err,
}
}
if err := s.ReplaceMacro(ctx, macro); err != nil {
return nil, &platform.Error{
Op: op,
Err: err,
}
}
return macro, nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"UpdateMacro",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
",",
"update",
"*",
"platform",
".",
"MacroUpdate",
")",
"(",
"*",
"platform",
".",
"Macro",
",",
"error",
")",
"{",
"op",
... | // UpdateMacro implements the platform.MacroService interface | [
"UpdateMacro",
"implements",
"the",
"platform",
".",
"MacroService",
"interface"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/macro.go#L74-L101 |
12,957 | influxdata/platform | inmem/macro.go | DeleteMacro | func (s *Service) DeleteMacro(ctx context.Context, id platform.ID) error {
op := OpPrefix + platform.OpDeleteMacro
_, err := s.FindMacroByID(ctx, id)
if err != nil {
return &platform.Error{
Op: op,
Code: platform.ENotFound,
Msg: "macro not found",
Err: err,
}
}
s.macroKV.Delete(id.String())
return nil
} | go | func (s *Service) DeleteMacro(ctx context.Context, id platform.ID) error {
op := OpPrefix + platform.OpDeleteMacro
_, err := s.FindMacroByID(ctx, id)
if err != nil {
return &platform.Error{
Op: op,
Code: platform.ENotFound,
Msg: "macro not found",
Err: err,
}
}
s.macroKV.Delete(id.String())
return nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"DeleteMacro",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
")",
"error",
"{",
"op",
":=",
"OpPrefix",
"+",
"platform",
".",
"OpDeleteMacro",
"\n",
"_",
",",
"err",
":=",
"s",
".",
... | // DeleteMacro implements the platform.MacroService interface | [
"DeleteMacro",
"implements",
"the",
"platform",
".",
"MacroService",
"interface"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/macro.go#L104-L119 |
12,958 | influxdata/platform | inmem/macro.go | ReplaceMacro | func (s *Service) ReplaceMacro(ctx context.Context, m *platform.Macro) error {
s.macroKV.Store(m.ID.String(), m)
return nil
} | go | func (s *Service) ReplaceMacro(ctx context.Context, m *platform.Macro) error {
s.macroKV.Store(m.ID.String(), m)
return nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"ReplaceMacro",
"(",
"ctx",
"context",
".",
"Context",
",",
"m",
"*",
"platform",
".",
"Macro",
")",
"error",
"{",
"s",
".",
"macroKV",
".",
"Store",
"(",
"m",
".",
"ID",
".",
"String",
"(",
")",
",",
"m",
... | // ReplaceMacro stores a Macro in the key value store | [
"ReplaceMacro",
"stores",
"a",
"Macro",
"in",
"the",
"key",
"value",
"store"
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/macro.go#L122-L125 |
12,959 | influxdata/platform | task/backend/meta.go | NewStoreTaskMeta | func NewStoreTaskMeta(req CreateTaskRequest, o options.Options) StoreTaskMeta {
stm := StoreTaskMeta{
MaxConcurrency: int32(o.Concurrency),
Status: string(req.Status),
LatestCompleted: req.ScheduleAfter,
EffectiveCron: o.EffectiveCronString(),
Offset: int32(o.Offset / time.Second),
}
if stm.Status == "" {
stm.Status = string(DefaultTaskStatus)
}
if o.Every != 0 {
t := time.Unix(stm.LatestCompleted, 0).Truncate(o.Every).Unix()
if t == stm.LatestCompleted {
// For example, every 1m truncates to exactly on the minute.
// But the input request is schedule after, not "on or after".
// Add one interval.
t += int64(o.Every / time.Second)
}
stm.LatestCompleted = t
}
return stm
} | go | func NewStoreTaskMeta(req CreateTaskRequest, o options.Options) StoreTaskMeta {
stm := StoreTaskMeta{
MaxConcurrency: int32(o.Concurrency),
Status: string(req.Status),
LatestCompleted: req.ScheduleAfter,
EffectiveCron: o.EffectiveCronString(),
Offset: int32(o.Offset / time.Second),
}
if stm.Status == "" {
stm.Status = string(DefaultTaskStatus)
}
if o.Every != 0 {
t := time.Unix(stm.LatestCompleted, 0).Truncate(o.Every).Unix()
if t == stm.LatestCompleted {
// For example, every 1m truncates to exactly on the minute.
// But the input request is schedule after, not "on or after".
// Add one interval.
t += int64(o.Every / time.Second)
}
stm.LatestCompleted = t
}
return stm
} | [
"func",
"NewStoreTaskMeta",
"(",
"req",
"CreateTaskRequest",
",",
"o",
"options",
".",
"Options",
")",
"StoreTaskMeta",
"{",
"stm",
":=",
"StoreTaskMeta",
"{",
"MaxConcurrency",
":",
"int32",
"(",
"o",
".",
"Concurrency",
")",
",",
"Status",
":",
"string",
"... | // This file contains helper methods for the StoreTaskMeta type defined in protobuf.
// NewStoreTaskMeta returns a new StoreTaskMeta based on the given request and parsed options. | [
"This",
"file",
"contains",
"helper",
"methods",
"for",
"the",
"StoreTaskMeta",
"type",
"defined",
"in",
"protobuf",
".",
"NewStoreTaskMeta",
"returns",
"a",
"new",
"StoreTaskMeta",
"based",
"on",
"the",
"given",
"request",
"and",
"parsed",
"options",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/task/backend/meta.go#L16-L41 |
12,960 | influxdata/platform | inmem/view.go | FindViews | func (s *Service) FindViews(ctx context.Context, filter platform.ViewFilter) ([]*platform.View, int, error) {
var ds []*platform.View
if filter.ID != nil {
d, err := s.FindViewByID(ctx, *filter.ID)
if err != nil && platform.ErrorCode(err) != platform.ENotFound {
return nil, 0, &platform.Error{
Err: err,
Op: OpPrefix + platform.OpFindViews,
}
}
if d != nil {
ds = append(ds, d)
}
return ds, len(ds), nil
}
var err error
filterF := filterViewFn(filter)
s.viewKV.Range(func(k, v interface{}) bool {
d, ok := v.(*platform.View)
if !ok {
return false
}
if filterF(d) {
ds = append(ds, d)
}
return true
})
return ds, len(ds), err
} | go | func (s *Service) FindViews(ctx context.Context, filter platform.ViewFilter) ([]*platform.View, int, error) {
var ds []*platform.View
if filter.ID != nil {
d, err := s.FindViewByID(ctx, *filter.ID)
if err != nil && platform.ErrorCode(err) != platform.ENotFound {
return nil, 0, &platform.Error{
Err: err,
Op: OpPrefix + platform.OpFindViews,
}
}
if d != nil {
ds = append(ds, d)
}
return ds, len(ds), nil
}
var err error
filterF := filterViewFn(filter)
s.viewKV.Range(func(k, v interface{}) bool {
d, ok := v.(*platform.View)
if !ok {
return false
}
if filterF(d) {
ds = append(ds, d)
}
return true
})
return ds, len(ds), err
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"FindViews",
"(",
"ctx",
"context",
".",
"Context",
",",
"filter",
"platform",
".",
"ViewFilter",
")",
"(",
"[",
"]",
"*",
"platform",
".",
"View",
",",
"int",
",",
"error",
")",
"{",
"var",
"ds",
"[",
"]",
... | // FindViews implements platform.ViewService interface. | [
"FindViews",
"implements",
"platform",
".",
"ViewService",
"interface",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/view.go#L52-L83 |
12,961 | influxdata/platform | inmem/view.go | CreateView | func (s *Service) CreateView(ctx context.Context, c *platform.View) error {
c.ID = s.IDGenerator.ID()
if err := s.PutView(ctx, c); err != nil {
return &platform.Error{
Err: err,
Op: OpPrefix + platform.OpCreateView,
}
}
return nil
} | go | func (s *Service) CreateView(ctx context.Context, c *platform.View) error {
c.ID = s.IDGenerator.ID()
if err := s.PutView(ctx, c); err != nil {
return &platform.Error{
Err: err,
Op: OpPrefix + platform.OpCreateView,
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"CreateView",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"*",
"platform",
".",
"View",
")",
"error",
"{",
"c",
".",
"ID",
"=",
"s",
".",
"IDGenerator",
".",
"ID",
"(",
")",
"\n",
"if",
"err",
":=",
"... | // CreateView implements platform.ViewService interface. | [
"CreateView",
"implements",
"platform",
".",
"ViewService",
"interface",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/view.go#L86-L95 |
12,962 | influxdata/platform | inmem/view.go | UpdateView | func (s *Service) UpdateView(ctx context.Context, id platform.ID, upd platform.ViewUpdate) (*platform.View, error) {
c, err := s.FindViewByID(ctx, id)
if err != nil {
return nil, &platform.Error{
Err: err,
Op: OpPrefix + platform.OpUpdateView,
}
}
if upd.Name != nil {
c.Name = *upd.Name
}
if upd.Properties != nil {
c.Properties = upd.Properties
}
s.viewKV.Store(c.ID.String(), c)
return c, nil
} | go | func (s *Service) UpdateView(ctx context.Context, id platform.ID, upd platform.ViewUpdate) (*platform.View, error) {
c, err := s.FindViewByID(ctx, id)
if err != nil {
return nil, &platform.Error{
Err: err,
Op: OpPrefix + platform.OpUpdateView,
}
}
if upd.Name != nil {
c.Name = *upd.Name
}
if upd.Properties != nil {
c.Properties = upd.Properties
}
s.viewKV.Store(c.ID.String(), c)
return c, nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"UpdateView",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
",",
"upd",
"platform",
".",
"ViewUpdate",
")",
"(",
"*",
"platform",
".",
"View",
",",
"error",
")",
"{",
"c",
",",
"err"... | // UpdateView implements platform.ViewService interface. | [
"UpdateView",
"implements",
"platform",
".",
"ViewService",
"interface",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/view.go#L107-L127 |
12,963 | influxdata/platform | inmem/view.go | DeleteView | func (s *Service) DeleteView(ctx context.Context, id platform.ID) error {
if _, err := s.FindViewByID(ctx, id); err != nil {
return &platform.Error{
Err: err,
Op: OpPrefix + platform.OpDeleteView,
}
}
s.viewKV.Delete(id.String())
return nil
} | go | func (s *Service) DeleteView(ctx context.Context, id platform.ID) error {
if _, err := s.FindViewByID(ctx, id); err != nil {
return &platform.Error{
Err: err,
Op: OpPrefix + platform.OpDeleteView,
}
}
s.viewKV.Delete(id.String())
return nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"DeleteView",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"platform",
".",
"ID",
")",
"error",
"{",
"if",
"_",
",",
"err",
":=",
"s",
".",
"FindViewByID",
"(",
"ctx",
",",
"id",
")",
";",
"err",
"!=",
... | // DeleteView implements platform.ViewService interface. | [
"DeleteView",
"implements",
"platform",
".",
"ViewService",
"interface",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/inmem/view.go#L130-L139 |
12,964 | influxdata/platform | bolt/kv.go | Open | func (s *KVStore) Open(ctx context.Context) error {
// Ensure the required directory structure exists.
if err := os.MkdirAll(filepath.Dir(s.path), 0700); err != nil {
return fmt.Errorf("unable to create directory %s: %v", s.path, err)
}
if _, err := os.Stat(s.path); err != nil && !os.IsNotExist(err) {
return err
}
// Open database file.
db, err := bolt.Open(s.path, 0600, &bolt.Options{Timeout: 1 * time.Second})
if err != nil {
return fmt.Errorf("unable to open boltdb file %v", err)
}
s.db = db
s.logger.Info("Resources opened", zap.String("path", s.path))
return nil
} | go | func (s *KVStore) Open(ctx context.Context) error {
// Ensure the required directory structure exists.
if err := os.MkdirAll(filepath.Dir(s.path), 0700); err != nil {
return fmt.Errorf("unable to create directory %s: %v", s.path, err)
}
if _, err := os.Stat(s.path); err != nil && !os.IsNotExist(err) {
return err
}
// Open database file.
db, err := bolt.Open(s.path, 0600, &bolt.Options{Timeout: 1 * time.Second})
if err != nil {
return fmt.Errorf("unable to open boltdb file %v", err)
}
s.db = db
s.logger.Info("Resources opened", zap.String("path", s.path))
return nil
} | [
"func",
"(",
"s",
"*",
"KVStore",
")",
"Open",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"// Ensure the required directory structure exists.",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Dir",
"(",
"s",
".",
"path",
")"... | // Open creates boltDB file it doesn't exists and opens it otherwise. | [
"Open",
"creates",
"boltDB",
"file",
"it",
"doesn",
"t",
"exists",
"and",
"opens",
"it",
"otherwise",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/kv.go#L32-L51 |
12,965 | influxdata/platform | bolt/kv.go | Seek | func (c *Cursor) Seek(prefix []byte) ([]byte, []byte) {
k, v := c.cursor.Seek(prefix)
if len(v) == 0 {
return nil, nil
}
return k, v
} | go | func (c *Cursor) Seek(prefix []byte) ([]byte, []byte) {
k, v := c.cursor.Seek(prefix)
if len(v) == 0 {
return nil, nil
}
return k, v
} | [
"func",
"(",
"c",
"*",
"Cursor",
")",
"Seek",
"(",
"prefix",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"[",
"]",
"byte",
")",
"{",
"k",
",",
"v",
":=",
"c",
".",
"cursor",
".",
"Seek",
"(",
"prefix",
")",
"\n",
"if",
"len",
"(",
... | // Seek seeks for the first key that matches the prefix provided. | [
"Seek",
"seeks",
"for",
"the",
"first",
"key",
"that",
"matches",
"the",
"prefix",
"provided",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/bolt/kv.go#L177-L183 |
12,966 | influxdata/platform | mock/proxy_query_service.go | NewProxyQueryService | func NewProxyQueryService() *ProxyQueryService {
return &ProxyQueryService{
QueryFn: func(context.Context, io.Writer, *query.ProxyRequest) (int64, error) { return 0, nil },
}
} | go | func NewProxyQueryService() *ProxyQueryService {
return &ProxyQueryService{
QueryFn: func(context.Context, io.Writer, *query.ProxyRequest) (int64, error) { return 0, nil },
}
} | [
"func",
"NewProxyQueryService",
"(",
")",
"*",
"ProxyQueryService",
"{",
"return",
"&",
"ProxyQueryService",
"{",
"QueryFn",
":",
"func",
"(",
"context",
".",
"Context",
",",
"io",
".",
"Writer",
",",
"*",
"query",
".",
"ProxyRequest",
")",
"(",
"int64",
"... | // NewProxyQueryService returns a mock of ProxyQueryService where its methods will return zero values. | [
"NewProxyQueryService",
"returns",
"a",
"mock",
"of",
"ProxyQueryService",
"where",
"its",
"methods",
"will",
"return",
"zero",
"values",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/mock/proxy_query_service.go#L18-L22 |
12,967 | influxdata/platform | mock/proxy_query_service.go | Query | func (s *ProxyQueryService) Query(ctx context.Context, w io.Writer, req *query.ProxyRequest) (int64, error) {
return s.QueryFn(ctx, w, req)
} | go | func (s *ProxyQueryService) Query(ctx context.Context, w io.Writer, req *query.ProxyRequest) (int64, error) {
return s.QueryFn(ctx, w, req)
} | [
"func",
"(",
"s",
"*",
"ProxyQueryService",
")",
"Query",
"(",
"ctx",
"context",
".",
"Context",
",",
"w",
"io",
".",
"Writer",
",",
"req",
"*",
"query",
".",
"ProxyRequest",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"s",
".",
"QueryFn",
... | // Query performs the requested query and encodes the results into w. | [
"Query",
"performs",
"the",
"requested",
"query",
"and",
"encodes",
"the",
"results",
"into",
"w",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/mock/proxy_query_service.go#L25-L27 |
12,968 | influxdata/platform | tsdb/index.go | NewSeriesIteratorAdapter | func NewSeriesIteratorAdapter(sfile *SeriesFile, itr SeriesIDIterator) SeriesIterator {
return &seriesIteratorAdapter{
sfile: sfile,
itr: itr,
}
} | go | func NewSeriesIteratorAdapter(sfile *SeriesFile, itr SeriesIDIterator) SeriesIterator {
return &seriesIteratorAdapter{
sfile: sfile,
itr: itr,
}
} | [
"func",
"NewSeriesIteratorAdapter",
"(",
"sfile",
"*",
"SeriesFile",
",",
"itr",
"SeriesIDIterator",
")",
"SeriesIterator",
"{",
"return",
"&",
"seriesIteratorAdapter",
"{",
"sfile",
":",
"sfile",
",",
"itr",
":",
"itr",
",",
"}",
"\n",
"}"
] | // NewSeriesIteratorAdapter returns an adapter for converting series ids to series. | [
"NewSeriesIteratorAdapter",
"returns",
"an",
"adapter",
"for",
"converting",
"series",
"ids",
"to",
"series",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/index.go#L30-L35 |
12,969 | influxdata/platform | tsdb/index.go | NewSeriesQueryAdapterIterator | func NewSeriesQueryAdapterIterator(sfile *SeriesFile, itr SeriesIDIterator, opt query.IteratorOptions) query.Iterator {
return &seriesQueryAdapterIterator{
sfile: sfile,
itr: itr,
point: query.FloatPoint{
Aux: make([]interface{}, len(opt.Aux)),
},
opt: opt,
}
} | go | func NewSeriesQueryAdapterIterator(sfile *SeriesFile, itr SeriesIDIterator, opt query.IteratorOptions) query.Iterator {
return &seriesQueryAdapterIterator{
sfile: sfile,
itr: itr,
point: query.FloatPoint{
Aux: make([]interface{}, len(opt.Aux)),
},
opt: opt,
}
} | [
"func",
"NewSeriesQueryAdapterIterator",
"(",
"sfile",
"*",
"SeriesFile",
",",
"itr",
"SeriesIDIterator",
",",
"opt",
"query",
".",
"IteratorOptions",
")",
"query",
".",
"Iterator",
"{",
"return",
"&",
"seriesQueryAdapterIterator",
"{",
"sfile",
":",
"sfile",
",",... | // NewSeriesQueryAdapterIterator returns a new instance of SeriesQueryAdapterIterator. | [
"NewSeriesQueryAdapterIterator",
"returns",
"a",
"new",
"instance",
"of",
"SeriesQueryAdapterIterator",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/tsdb/index.go#L221-L230 |
12,970 | influxdata/platform | task/backend/store.go | CreateArgs | func (StoreValidation) CreateArgs(req CreateTaskRequest) (options.Options, error) {
var missing []string
var o options.Options
if req.Script == "" {
missing = append(missing, "script")
} else {
var err error
o, err = options.FromScript(req.Script)
if err != nil {
return o, err
}
}
if !req.Org.Valid() {
missing = append(missing, "organization ID")
}
if !req.User.Valid() {
missing = append(missing, "user ID")
}
if len(missing) > 0 {
return o, fmt.Errorf("missing required fields to create task: %s", strings.Join(missing, ", "))
}
if err := req.Status.validate(true); err != nil {
return o, err
}
return o, nil
} | go | func (StoreValidation) CreateArgs(req CreateTaskRequest) (options.Options, error) {
var missing []string
var o options.Options
if req.Script == "" {
missing = append(missing, "script")
} else {
var err error
o, err = options.FromScript(req.Script)
if err != nil {
return o, err
}
}
if !req.Org.Valid() {
missing = append(missing, "organization ID")
}
if !req.User.Valid() {
missing = append(missing, "user ID")
}
if len(missing) > 0 {
return o, fmt.Errorf("missing required fields to create task: %s", strings.Join(missing, ", "))
}
if err := req.Status.validate(true); err != nil {
return o, err
}
return o, nil
} | [
"func",
"(",
"StoreValidation",
")",
"CreateArgs",
"(",
"req",
"CreateTaskRequest",
")",
"(",
"options",
".",
"Options",
",",
"error",
")",
"{",
"var",
"missing",
"[",
"]",
"string",
"\n",
"var",
"o",
"options",
".",
"Options",
"\n\n",
"if",
"req",
".",
... | // CreateArgs returns the script's parsed options,
// and an error if any of the provided fields are invalid for creating a task. | [
"CreateArgs",
"returns",
"the",
"script",
"s",
"parsed",
"options",
"and",
"an",
"error",
"if",
"any",
"of",
"the",
"provided",
"fields",
"are",
"invalid",
"for",
"creating",
"a",
"task",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/task/backend/store.go#L352-L382 |
12,971 | influxdata/platform | gather/handler.go | Process | func (h *handler) Process(s nats.Subscription, m nats.Message) {
defer m.Ack()
req := new(platform.ScraperTarget)
err := json.Unmarshal(m.Data(), req)
if err != nil {
h.Logger.Error("unable to unmarshal json", zap.Error(err))
return
}
ms, err := h.Scraper.Gather(context.TODO(), *req)
if err != nil {
h.Logger.Error("unable to gather", zap.Error(err))
return
}
// send metrics to storage queue
buf := new(bytes.Buffer)
if err := json.NewEncoder(buf).Encode(ms); err != nil {
h.Logger.Error("unable to marshal json", zap.Error(err))
return
}
if err := h.Publisher.Publish(MetricsSubject, buf); err != nil {
h.Logger.Error("unable to publish scraper metrics", zap.Error(err))
return
}
} | go | func (h *handler) Process(s nats.Subscription, m nats.Message) {
defer m.Ack()
req := new(platform.ScraperTarget)
err := json.Unmarshal(m.Data(), req)
if err != nil {
h.Logger.Error("unable to unmarshal json", zap.Error(err))
return
}
ms, err := h.Scraper.Gather(context.TODO(), *req)
if err != nil {
h.Logger.Error("unable to gather", zap.Error(err))
return
}
// send metrics to storage queue
buf := new(bytes.Buffer)
if err := json.NewEncoder(buf).Encode(ms); err != nil {
h.Logger.Error("unable to marshal json", zap.Error(err))
return
}
if err := h.Publisher.Publish(MetricsSubject, buf); err != nil {
h.Logger.Error("unable to publish scraper metrics", zap.Error(err))
return
}
} | [
"func",
"(",
"h",
"*",
"handler",
")",
"Process",
"(",
"s",
"nats",
".",
"Subscription",
",",
"m",
"nats",
".",
"Message",
")",
"{",
"defer",
"m",
".",
"Ack",
"(",
")",
"\n\n",
"req",
":=",
"new",
"(",
"platform",
".",
"ScraperTarget",
")",
"\n",
... | // Process consumes scraper target from scraper target queue,
// call the scraper to gather, and publish to metrics queue. | [
"Process",
"consumes",
"scraper",
"target",
"from",
"scraper",
"target",
"queue",
"call",
"the",
"scraper",
"to",
"gather",
"and",
"publish",
"to",
"metrics",
"queue",
"."
] | d500d3cf55899337bc03259b46c58bae9c06f1eb | https://github.com/influxdata/platform/blob/d500d3cf55899337bc03259b46c58bae9c06f1eb/gather/handler.go#L22-L50 |
12,972 | 0xrawsec/golang-utils | net/sftp/sftp.go | PrivateKeyAuthMethod | func PrivateKeyAuthMethod(privateKeyPath string) ssh.AuthMethod {
sss, err := loadPrivateKey(privateKeyPath)
if err != nil {
panic(err)
}
return ssh.PublicKeys(sss)
} | go | func PrivateKeyAuthMethod(privateKeyPath string) ssh.AuthMethod {
sss, err := loadPrivateKey(privateKeyPath)
if err != nil {
panic(err)
}
return ssh.PublicKeys(sss)
} | [
"func",
"PrivateKeyAuthMethod",
"(",
"privateKeyPath",
"string",
")",
"ssh",
".",
"AuthMethod",
"{",
"sss",
",",
"err",
":=",
"loadPrivateKey",
"(",
"privateKeyPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"r... | // PrivateKeyAuthMethod returns a ssh.AuthMethod initialized with a private key
// @privateKeyPath: path to the private key to use | [
"PrivateKeyAuthMethod",
"returns",
"a",
"ssh",
".",
"AuthMethod",
"initialized",
"with",
"a",
"private",
"key"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/net/sftp/sftp.go#L45-L52 |
12,973 | 0xrawsec/golang-utils | net/sftp/sftp.go | New | func New(host, port, username string, sams ...ssh.AuthMethod) (*Client, error) {
config := &ssh.ClientConfig{
User: username,
Auth: sams,
}
client, err := ssh.Dial("tcp", BuildSSHURL(host, port), config)
if err != nil {
return nil, err
}
tmpSftpClient, err := sftp.NewClient(client)
if err != nil {
return nil, err
}
return (*Client)(unsafe.Pointer(tmpSftpClient)), err
} | go | func New(host, port, username string, sams ...ssh.AuthMethod) (*Client, error) {
config := &ssh.ClientConfig{
User: username,
Auth: sams,
}
client, err := ssh.Dial("tcp", BuildSSHURL(host, port), config)
if err != nil {
return nil, err
}
tmpSftpClient, err := sftp.NewClient(client)
if err != nil {
return nil, err
}
return (*Client)(unsafe.Pointer(tmpSftpClient)), err
} | [
"func",
"New",
"(",
"host",
",",
"port",
",",
"username",
"string",
",",
"sams",
"...",
"ssh",
".",
"AuthMethod",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"config",
":=",
"&",
"ssh",
".",
"ClientConfig",
"{",
"User",
":",
"username",
",",
"... | // New returns a new SFTP Client
// @host: hostname to connect to
// @port: port on the hostname
// @username: username to login
// @sams: list of ssh.AuthMethod to use | [
"New",
"returns",
"a",
"new",
"SFTP",
"Client"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/net/sftp/sftp.go#L59-L73 |
12,974 | 0xrawsec/golang-utils | net/sftp/sftp.go | ResolveSymlink | func (sc *Client) ResolveSymlink(path string) string {
pointer, err := sc.ReadLink(path)
if err != nil {
return path
}
return pointer
} | go | func (sc *Client) ResolveSymlink(path string) string {
pointer, err := sc.ReadLink(path)
if err != nil {
return path
}
return pointer
} | [
"func",
"(",
"sc",
"*",
"Client",
")",
"ResolveSymlink",
"(",
"path",
"string",
")",
"string",
"{",
"pointer",
",",
"err",
":=",
"sc",
".",
"ReadLink",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"path",
"\n",
"}",
"\n",
"retur... | // ResolveSymlink resolve a path and returns the path of the file pointed if
// it is a symlink
// @path: path to resolve | [
"ResolveSymlink",
"resolve",
"a",
"path",
"and",
"returns",
"the",
"path",
"of",
"the",
"file",
"pointed",
"if",
"it",
"is",
"a",
"symlink"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/net/sftp/sftp.go#L78-L84 |
12,975 | 0xrawsec/golang-utils | net/sftp/sftp.go | Walk | func (sc *Client) Walk(root string) <-chan fswalker.WalkItem {
iterChannel := make(chan fswalker.WalkItem)
dirsToProcess := []string{root}
go func() {
for len(dirsToProcess) > 0 {
dirs, files := []os.FileInfo{}, []os.FileInfo{}
dirpath := dirsToProcess[len(dirsToProcess)-1]
dirsToProcess = dirsToProcess[:len(dirsToProcess)-1]
filesInfo, err := sc.ReadDir(sc.ResolveSymlink(dirpath))
if err != nil {
fmt.Printf("Error reading directory (%s): %s\n", err.Error(), dirpath)
} else {
for _, fileInfo := range filesInfo {
switch {
case fileInfo.Mode().IsDir():
dirs = append(dirs, fileInfo)
dirsToProcess = append(dirsToProcess, filepath.Join(dirpath, fileInfo.Name()))
case fileInfo.Mode().IsRegular():
files = append(files, fileInfo)
case fileInfo.Mode()&os.ModeSymlink == os.ModeSymlink:
sympath := filepath.Join(dirpath, fileInfo.Name())
pointerFI, err := sc.Stat(sympath)
if err != nil {
fmt.Fprintf(os.Stderr, "Error reading symlink (%s): %s\n", err.Error(), sympath)
} else {
switch {
case pointerFI.Mode().IsDir():
dirs = append(dirs, fileInfo)
dirsToProcess = append(dirsToProcess, sc.Join(dirpath, fileInfo.Name()))
case pointerFI.Mode().IsRegular():
files = append(files, fileInfo)
}
}
}
}
}
iterChannel <- fswalker.WalkItem{Dirpath: dirpath,
Dirs: dirs,
Files: files,
Err: err}
}
close(iterChannel)
}()
return iterChannel
} | go | func (sc *Client) Walk(root string) <-chan fswalker.WalkItem {
iterChannel := make(chan fswalker.WalkItem)
dirsToProcess := []string{root}
go func() {
for len(dirsToProcess) > 0 {
dirs, files := []os.FileInfo{}, []os.FileInfo{}
dirpath := dirsToProcess[len(dirsToProcess)-1]
dirsToProcess = dirsToProcess[:len(dirsToProcess)-1]
filesInfo, err := sc.ReadDir(sc.ResolveSymlink(dirpath))
if err != nil {
fmt.Printf("Error reading directory (%s): %s\n", err.Error(), dirpath)
} else {
for _, fileInfo := range filesInfo {
switch {
case fileInfo.Mode().IsDir():
dirs = append(dirs, fileInfo)
dirsToProcess = append(dirsToProcess, filepath.Join(dirpath, fileInfo.Name()))
case fileInfo.Mode().IsRegular():
files = append(files, fileInfo)
case fileInfo.Mode()&os.ModeSymlink == os.ModeSymlink:
sympath := filepath.Join(dirpath, fileInfo.Name())
pointerFI, err := sc.Stat(sympath)
if err != nil {
fmt.Fprintf(os.Stderr, "Error reading symlink (%s): %s\n", err.Error(), sympath)
} else {
switch {
case pointerFI.Mode().IsDir():
dirs = append(dirs, fileInfo)
dirsToProcess = append(dirsToProcess, sc.Join(dirpath, fileInfo.Name()))
case pointerFI.Mode().IsRegular():
files = append(files, fileInfo)
}
}
}
}
}
iterChannel <- fswalker.WalkItem{Dirpath: dirpath,
Dirs: dirs,
Files: files,
Err: err}
}
close(iterChannel)
}()
return iterChannel
} | [
"func",
"(",
"sc",
"*",
"Client",
")",
"Walk",
"(",
"root",
"string",
")",
"<-",
"chan",
"fswalker",
".",
"WalkItem",
"{",
"iterChannel",
":=",
"make",
"(",
"chan",
"fswalker",
".",
"WalkItem",
")",
"\n",
"dirsToProcess",
":=",
"[",
"]",
"string",
"{",... | // Walk walks recursively through the SFTP
// @root: root path to start walking through | [
"Walk",
"walks",
"recursively",
"through",
"the",
"SFTP"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/net/sftp/sftp.go#L88-L132 |
12,976 | 0xrawsec/golang-utils | crypto/data/data.go | Md5 | func Md5(data []byte) string {
md5 := md5.New()
md5.Write(data)
return hex.EncodeToString(md5.Sum(nil))
} | go | func Md5(data []byte) string {
md5 := md5.New()
md5.Write(data)
return hex.EncodeToString(md5.Sum(nil))
} | [
"func",
"Md5",
"(",
"data",
"[",
"]",
"byte",
")",
"string",
"{",
"md5",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"md5",
".",
"Write",
"(",
"data",
")",
"\n",
"return",
"hex",
".",
"EncodeToString",
"(",
"md5",
".",
"Sum",
"(",
"nil",
")",
")",... | // Md5 returns the md5 sum of data | [
"Md5",
"returns",
"the",
"md5",
"sum",
"of",
"data"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/crypto/data/data.go#L12-L16 |
12,977 | 0xrawsec/golang-utils | crypto/data/data.go | Sha1 | func Sha1(data []byte) string {
sha1 := sha1.New()
sha1.Write(data)
return hex.EncodeToString(sha1.Sum(nil))
} | go | func Sha1(data []byte) string {
sha1 := sha1.New()
sha1.Write(data)
return hex.EncodeToString(sha1.Sum(nil))
} | [
"func",
"Sha1",
"(",
"data",
"[",
"]",
"byte",
")",
"string",
"{",
"sha1",
":=",
"sha1",
".",
"New",
"(",
")",
"\n",
"sha1",
".",
"Write",
"(",
"data",
")",
"\n",
"return",
"hex",
".",
"EncodeToString",
"(",
"sha1",
".",
"Sum",
"(",
"nil",
")",
... | // Sha1 returns the sha1 sum of data | [
"Sha1",
"returns",
"the",
"sha1",
"sum",
"of",
"data"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/crypto/data/data.go#L19-L23 |
12,978 | 0xrawsec/golang-utils | crypto/data/data.go | Sha256 | func Sha256(data []byte) string {
sha256 := sha256.New()
sha256.Write(data)
return hex.EncodeToString(sha256.Sum(nil))
} | go | func Sha256(data []byte) string {
sha256 := sha256.New()
sha256.Write(data)
return hex.EncodeToString(sha256.Sum(nil))
} | [
"func",
"Sha256",
"(",
"data",
"[",
"]",
"byte",
")",
"string",
"{",
"sha256",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"sha256",
".",
"Write",
"(",
"data",
")",
"\n",
"return",
"hex",
".",
"EncodeToString",
"(",
"sha256",
".",
"Sum",
"(",
"nil"... | // Sha256 returns the sha256 sum of data | [
"Sha256",
"returns",
"the",
"sha256",
"sum",
"of",
"data"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/crypto/data/data.go#L26-L30 |
12,979 | 0xrawsec/golang-utils | crypto/data/data.go | Sha512 | func Sha512(data []byte) string {
sha512 := sha512.New()
sha512.Write(data)
return hex.EncodeToString(sha512.Sum(nil))
} | go | func Sha512(data []byte) string {
sha512 := sha512.New()
sha512.Write(data)
return hex.EncodeToString(sha512.Sum(nil))
} | [
"func",
"Sha512",
"(",
"data",
"[",
"]",
"byte",
")",
"string",
"{",
"sha512",
":=",
"sha512",
".",
"New",
"(",
")",
"\n",
"sha512",
".",
"Write",
"(",
"data",
")",
"\n",
"return",
"hex",
".",
"EncodeToString",
"(",
"sha512",
".",
"Sum",
"(",
"nil"... | // Sha512 returns the sha512 sum of data | [
"Sha512",
"returns",
"the",
"sha512",
"sum",
"of",
"data"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/crypto/data/data.go#L33-L37 |
12,980 | 0xrawsec/golang-utils | stats/stats.go | Truncate | func Truncate(f float64, p int) float64 {
return float64(int(f*math.Pow10(p))) / math.Pow10(p)
} | go | func Truncate(f float64, p int) float64 {
return float64(int(f*math.Pow10(p))) / math.Pow10(p)
} | [
"func",
"Truncate",
"(",
"f",
"float64",
",",
"p",
"int",
")",
"float64",
"{",
"return",
"float64",
"(",
"int",
"(",
"f",
"*",
"math",
".",
"Pow10",
"(",
"p",
")",
")",
")",
"/",
"math",
".",
"Pow10",
"(",
"p",
")",
"\n",
"}"
] | // Trucate truncates a float with p figures of precision | [
"Trucate",
"truncates",
"a",
"float",
"with",
"p",
"figures",
"of",
"precision"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/stats/stats.go#L6-L8 |
12,981 | 0xrawsec/golang-utils | stats/stats.go | Average | func Average(floats []float64) float64 {
var sum float64
var cnt float64
for _, f := range floats {
sum += f
cnt++
}
return sum / cnt
} | go | func Average(floats []float64) float64 {
var sum float64
var cnt float64
for _, f := range floats {
sum += f
cnt++
}
return sum / cnt
} | [
"func",
"Average",
"(",
"floats",
"[",
"]",
"float64",
")",
"float64",
"{",
"var",
"sum",
"float64",
"\n",
"var",
"cnt",
"float64",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"floats",
"{",
"sum",
"+=",
"f",
"\n",
"cnt",
"++",
"\n",
"}",
"\n",
"r... | // Average computes the average of a table of floats | [
"Average",
"computes",
"the",
"average",
"of",
"a",
"table",
"of",
"floats"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/stats/stats.go#L11-L19 |
12,982 | 0xrawsec/golang-utils | stats/stats.go | StdDev | func StdDev(floats []float64) float64 {
var sum float64
a := Average(floats)
for _, f := range floats {
sum += math.Pow(f-a, 2)
}
return math.Sqrt(sum / float64(len(floats)))
} | go | func StdDev(floats []float64) float64 {
var sum float64
a := Average(floats)
for _, f := range floats {
sum += math.Pow(f-a, 2)
}
return math.Sqrt(sum / float64(len(floats)))
} | [
"func",
"StdDev",
"(",
"floats",
"[",
"]",
"float64",
")",
"float64",
"{",
"var",
"sum",
"float64",
"\n",
"a",
":=",
"Average",
"(",
"floats",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"floats",
"{",
"sum",
"+=",
"math",
".",
"Pow",
"(",
"f... | // StdDev returns the standard deviation of a random variable | [
"StdDev",
"returns",
"the",
"standard",
"deviation",
"of",
"a",
"random",
"variable"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/stats/stats.go#L22-L29 |
12,983 | 0xrawsec/golang-utils | fileutils/hash/hash.go | Update | func (h *Hashes) Update(path string) (err error) {
var buffer [4096]byte
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
md5 := md5.New()
sha1 := sha1.New()
sha256 := sha256.New()
sha512 := sha512.New()
for read, err := file.Read(buffer[:]); err != io.EOF && read != 0; read, err = file.Read(buffer[:]) {
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
return err
}
md5.Write(buffer[:read])
sha1.Write(buffer[:read])
sha256.Write(buffer[:read])
sha512.Write(buffer[:read])
}
h.Path = path
h.Md5 = hex.EncodeToString(md5.Sum(nil))
h.Sha1 = hex.EncodeToString(sha1.Sum(nil))
h.Sha256 = hex.EncodeToString(sha256.Sum(nil))
h.Sha512 = hex.EncodeToString(sha512.Sum(nil))
return nil
} | go | func (h *Hashes) Update(path string) (err error) {
var buffer [4096]byte
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
md5 := md5.New()
sha1 := sha1.New()
sha256 := sha256.New()
sha512 := sha512.New()
for read, err := file.Read(buffer[:]); err != io.EOF && read != 0; read, err = file.Read(buffer[:]) {
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
return err
}
md5.Write(buffer[:read])
sha1.Write(buffer[:read])
sha256.Write(buffer[:read])
sha512.Write(buffer[:read])
}
h.Path = path
h.Md5 = hex.EncodeToString(md5.Sum(nil))
h.Sha1 = hex.EncodeToString(sha1.Sum(nil))
h.Sha256 = hex.EncodeToString(sha256.Sum(nil))
h.Sha512 = hex.EncodeToString(sha512.Sum(nil))
return nil
} | [
"func",
"(",
"h",
"*",
"Hashes",
")",
"Update",
"(",
"path",
"string",
")",
"(",
"err",
"error",
")",
"{",
"var",
"buffer",
"[",
"4096",
"]",
"byte",
"\n",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
... | // Update the current Hashes structure | [
"Update",
"the",
"current",
"Hashes",
"structure"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/fileutils/hash/hash.go#L43-L71 |
12,984 | 0xrawsec/golang-utils | config/config.go | HasKey | func (c *Config) HasKey(key string) bool {
_, ok := (*c)[key]
return ok
} | go | func (c *Config) HasKey(key string) bool {
_, ok := (*c)[key]
return ok
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"HasKey",
"(",
"key",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"(",
"*",
"c",
")",
"[",
"key",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] | // HasKey returns true if the configuration has the given key | [
"HasKey",
"returns",
"true",
"if",
"the",
"configuration",
"has",
"the",
"given",
"key"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/config/config.go#L289-L292 |
12,985 | 0xrawsec/golang-utils | encoding/encoding.go | Unpack | func Unpack(reader io.ReadSeeker, endianness Endianness, data interface{}, offsets ...int64) error {
switch {
// No offset to deal with
case len(offsets) == 0:
if err := binary.Read(reader, endianness, data); err != nil {
return err
}
// An offset to deal with
case len(offsets) == 1:
if soughtOffset, err := reader.Seek(offsets[0], os.SEEK_SET); soughtOffset != offsets[0] || err != nil {
switch {
case err != nil:
return err
case soughtOffset != offsets[0]:
return ErrSeeking
default:
if err := binary.Read(reader, endianness, data); err != nil {
return err
}
}
}
// Error if more than one offset
default:
return ErrMultipleOffsets
}
return nil
} | go | func Unpack(reader io.ReadSeeker, endianness Endianness, data interface{}, offsets ...int64) error {
switch {
// No offset to deal with
case len(offsets) == 0:
if err := binary.Read(reader, endianness, data); err != nil {
return err
}
// An offset to deal with
case len(offsets) == 1:
if soughtOffset, err := reader.Seek(offsets[0], os.SEEK_SET); soughtOffset != offsets[0] || err != nil {
switch {
case err != nil:
return err
case soughtOffset != offsets[0]:
return ErrSeeking
default:
if err := binary.Read(reader, endianness, data); err != nil {
return err
}
}
}
// Error if more than one offset
default:
return ErrMultipleOffsets
}
return nil
} | [
"func",
"Unpack",
"(",
"reader",
"io",
".",
"ReadSeeker",
",",
"endianness",
"Endianness",
",",
"data",
"interface",
"{",
"}",
",",
"offsets",
"...",
"int64",
")",
"error",
"{",
"switch",
"{",
"// No offset to deal with",
"case",
"len",
"(",
"offsets",
")",
... | // Unpack data type from reader object. An optional offset can be specified. | [
"Unpack",
"data",
"type",
"from",
"reader",
"object",
".",
"An",
"optional",
"offset",
"can",
"be",
"specified",
"."
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/encoding/encoding.go#L28-L55 |
12,986 | 0xrawsec/golang-utils | crypto/file/file.go | Md5 | func Md5(path string) (string, error) {
var buffer [4096]byte
file, err := os.Open(path)
if err != nil {
return "", err
}
defer file.Close()
md5 := md5.New()
for read, err := file.Read(buffer[:]); err != io.EOF && read != 0; read, err = file.Read(buffer[:]) {
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
return "", err
}
md5.Write(buffer[:read])
}
return hex.EncodeToString(md5.Sum(nil)), nil
} | go | func Md5(path string) (string, error) {
var buffer [4096]byte
file, err := os.Open(path)
if err != nil {
return "", err
}
defer file.Close()
md5 := md5.New()
for read, err := file.Read(buffer[:]); err != io.EOF && read != 0; read, err = file.Read(buffer[:]) {
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
return "", err
}
md5.Write(buffer[:read])
}
return hex.EncodeToString(md5.Sum(nil)), nil
} | [
"func",
"Md5",
"(",
"path",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"buffer",
"[",
"4096",
"]",
"byte",
"\n",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"... | // Md5 return the md5 sum of a file | [
"Md5",
"return",
"the",
"md5",
"sum",
"of",
"a",
"file"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/crypto/file/file.go#L14-L31 |
12,987 | 0xrawsec/golang-utils | readers/readers.go | NewReverseReader | func NewReverseReader(rs io.ReadSeeker) *ReverseReader {
rr := ReverseReader{}
rr.rs = rs
s, err := rs.Seek(0, os.SEEK_END)
if err != nil {
panic(err)
}
rr.size = s
rr.offset = s
return &rr
} | go | func NewReverseReader(rs io.ReadSeeker) *ReverseReader {
rr := ReverseReader{}
rr.rs = rs
s, err := rs.Seek(0, os.SEEK_END)
if err != nil {
panic(err)
}
rr.size = s
rr.offset = s
return &rr
} | [
"func",
"NewReverseReader",
"(",
"rs",
"io",
".",
"ReadSeeker",
")",
"*",
"ReverseReader",
"{",
"rr",
":=",
"ReverseReader",
"{",
"}",
"\n",
"rr",
".",
"rs",
"=",
"rs",
"\n",
"s",
",",
"err",
":=",
"rs",
".",
"Seek",
"(",
"0",
",",
"os",
".",
"SE... | // NewReverseReader creates a new ReverseReader | [
"NewReverseReader",
"creates",
"a",
"new",
"ReverseReader"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/readers/readers.go#L22-L32 |
12,988 | 0xrawsec/golang-utils | readers/readers.go | Read | func (r *ReverseReader) Read(p []byte) (n int, err error) {
//fmt.Printf("Offset %d\n", r.offset)
//fmt.Printf("Reading %d bytes\n", len(p))
switch {
case r.offset <= 0:
return 0, io.EOF
case r.offset-int64(len(p)) <= 0:
r.rs.Seek(0, os.SEEK_SET)
n, err = r.rs.Read(p[:r.offset])
r.rs.Seek(0, os.SEEK_SET)
r.offset = 0
return n, nil
default:
r.offset -= int64(len(p))
r.rs.Seek(r.offset, os.SEEK_SET)
n, err = r.rs.Read(p)
r.rs.Seek(r.offset, os.SEEK_SET)
return
}
} | go | func (r *ReverseReader) Read(p []byte) (n int, err error) {
//fmt.Printf("Offset %d\n", r.offset)
//fmt.Printf("Reading %d bytes\n", len(p))
switch {
case r.offset <= 0:
return 0, io.EOF
case r.offset-int64(len(p)) <= 0:
r.rs.Seek(0, os.SEEK_SET)
n, err = r.rs.Read(p[:r.offset])
r.rs.Seek(0, os.SEEK_SET)
r.offset = 0
return n, nil
default:
r.offset -= int64(len(p))
r.rs.Seek(r.offset, os.SEEK_SET)
n, err = r.rs.Read(p)
r.rs.Seek(r.offset, os.SEEK_SET)
return
}
} | [
"func",
"(",
"r",
"*",
"ReverseReader",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"//fmt.Printf(\"Offset %d\\n\", r.offset)",
"//fmt.Printf(\"Reading %d bytes\\n\", len(p))",
"switch",
"{",
"case",
"r",
".",
... | // Read implements io.Reader interface
// very likely bad performances due to the seeks | [
"Read",
"implements",
"io",
".",
"Reader",
"interface",
"very",
"likely",
"bad",
"performances",
"due",
"to",
"the",
"seeks"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/readers/readers.go#L36-L55 |
12,989 | 0xrawsec/golang-utils | readers/readers.go | ReadRune | func (r *ReverseReader) ReadRune() (ru rune, size int, err error) {
var rb [4]byte
n, err := r.Read(rb[:])
ru, size = utf8.DecodeLastRune(rb[:n])
if err != nil {
return
}
r.offset += int64(n - size)
r.rs.Seek(r.offset, os.SEEK_SET)
if ru == utf8.RuneError {
return ru, size, fmt.Errorf("RuneError")
}
return
} | go | func (r *ReverseReader) ReadRune() (ru rune, size int, err error) {
var rb [4]byte
n, err := r.Read(rb[:])
ru, size = utf8.DecodeLastRune(rb[:n])
if err != nil {
return
}
r.offset += int64(n - size)
r.rs.Seek(r.offset, os.SEEK_SET)
if ru == utf8.RuneError {
return ru, size, fmt.Errorf("RuneError")
}
return
} | [
"func",
"(",
"r",
"*",
"ReverseReader",
")",
"ReadRune",
"(",
")",
"(",
"ru",
"rune",
",",
"size",
"int",
",",
"err",
"error",
")",
"{",
"var",
"rb",
"[",
"4",
"]",
"byte",
"\n",
"n",
",",
"err",
":=",
"r",
".",
"Read",
"(",
"rb",
"[",
":",
... | // ReadRune reads a rune backward | [
"ReadRune",
"reads",
"a",
"rune",
"backward"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/readers/readers.go#L58-L71 |
12,990 | 0xrawsec/golang-utils | readers/readers.go | ReversedReadlines | func ReversedReadlines(r io.ReadSeeker) (lines chan []byte) {
lines = make(chan []byte)
go func() {
defer close(lines)
var c [1]byte
rr := NewReverseReader(r)
line := make([]byte, 0, 4096)
for n, err := rr.Read(c[:]); err != io.EOF && n != 0; n, err = rr.Read(c[:]) {
if c[0] == '\n' {
cpLine := make([]byte, len(line))
reversedCopy(cpLine, line)
lines <- cpLine
line = make([]byte, 0, 4096)
} else {
// don't append newline
line = append(line, c[0])
}
}
// process the last line
cpLine := make([]byte, len(line))
reversedCopy(cpLine, line)
lines <- cpLine
}()
return
} | go | func ReversedReadlines(r io.ReadSeeker) (lines chan []byte) {
lines = make(chan []byte)
go func() {
defer close(lines)
var c [1]byte
rr := NewReverseReader(r)
line := make([]byte, 0, 4096)
for n, err := rr.Read(c[:]); err != io.EOF && n != 0; n, err = rr.Read(c[:]) {
if c[0] == '\n' {
cpLine := make([]byte, len(line))
reversedCopy(cpLine, line)
lines <- cpLine
line = make([]byte, 0, 4096)
} else {
// don't append newline
line = append(line, c[0])
}
}
// process the last line
cpLine := make([]byte, len(line))
reversedCopy(cpLine, line)
lines <- cpLine
}()
return
} | [
"func",
"ReversedReadlines",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"lines",
"chan",
"[",
"]",
"byte",
")",
"{",
"lines",
"=",
"make",
"(",
"chan",
"[",
"]",
"byte",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"lines",
")... | // ReversedReadlines returns the lines found in a reader in reversed order | [
"ReversedReadlines",
"returns",
"the",
"lines",
"found",
"in",
"a",
"reader",
"in",
"reversed",
"order"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/readers/readers.go#L97-L122 |
12,991 | 0xrawsec/golang-utils | datastructs/syncedset.go | NewSyncedSet | func NewSyncedSet(sets ...*SyncedSet) (ss SyncedSet) {
ss.set = make(map[interface{}]bool)
if len(sets) > 0 {
for _, s := range sets {
pDatas := s.List()
ss.Add(*pDatas...)
}
}
return
} | go | func NewSyncedSet(sets ...*SyncedSet) (ss SyncedSet) {
ss.set = make(map[interface{}]bool)
if len(sets) > 0 {
for _, s := range sets {
pDatas := s.List()
ss.Add(*pDatas...)
}
}
return
} | [
"func",
"NewSyncedSet",
"(",
"sets",
"...",
"*",
"SyncedSet",
")",
"(",
"ss",
"SyncedSet",
")",
"{",
"ss",
".",
"set",
"=",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"bool",
")",
"\n",
"if",
"len",
"(",
"sets",
")",
">",
"0",
"{",
"f... | // NewSyncedSet constructs a new SyncedSet | [
"NewSyncedSet",
"constructs",
"a",
"new",
"SyncedSet"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L15-L24 |
12,992 | 0xrawsec/golang-utils | datastructs/syncedset.go | Equal | func (s *SyncedSet) Equal(other *SyncedSet) bool {
s.RLock()
defer s.RUnlock()
test := reflect.DeepEqual(s.set, other.set)
return test
} | go | func (s *SyncedSet) Equal(other *SyncedSet) bool {
s.RLock()
defer s.RUnlock()
test := reflect.DeepEqual(s.set, other.set)
return test
} | [
"func",
"(",
"s",
"*",
"SyncedSet",
")",
"Equal",
"(",
"other",
"*",
"SyncedSet",
")",
"bool",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n",
"test",
":=",
"reflect",
".",
"DeepEqual",
"(",
"s",
".",
"set",
... | // Equal returns true if both sets are equal | [
"Equal",
"returns",
"true",
"if",
"both",
"sets",
"are",
"equal"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L33-L38 |
12,993 | 0xrawsec/golang-utils | datastructs/syncedset.go | Add | func (s *SyncedSet) Add(datas ...interface{}) {
s.Lock()
defer s.Unlock()
for _, data := range datas {
s.set[data] = true
}
} | go | func (s *SyncedSet) Add(datas ...interface{}) {
s.Lock()
defer s.Unlock()
for _, data := range datas {
s.set[data] = true
}
} | [
"func",
"(",
"s",
"*",
"SyncedSet",
")",
"Add",
"(",
"datas",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"data",
":=",
"range",
"datas",
"{",
"s",
".... | // Add adds data to the set | [
"Add",
"adds",
"data",
"to",
"the",
"set"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L41-L47 |
12,994 | 0xrawsec/golang-utils | datastructs/syncedset.go | Del | func (s *SyncedSet) Del(datas ...interface{}) {
s.Lock()
defer s.Unlock()
for _, data := range datas {
delete(s.set, data)
}
} | go | func (s *SyncedSet) Del(datas ...interface{}) {
s.Lock()
defer s.Unlock()
for _, data := range datas {
delete(s.set, data)
}
} | [
"func",
"(",
"s",
"*",
"SyncedSet",
")",
"Del",
"(",
"datas",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"data",
":=",
"range",
"datas",
"{",
"delete",... | // Del deletes data from the set | [
"Del",
"deletes",
"data",
"from",
"the",
"set"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L50-L56 |
12,995 | 0xrawsec/golang-utils | datastructs/syncedset.go | Intersect | func (s *SyncedSet) Intersect(other *SyncedSet) *SyncedSet {
newSet := NewSyncedSet()
for k := range s.set {
if other.Contains(k) {
newSet.Add(k)
}
}
return &newSet
} | go | func (s *SyncedSet) Intersect(other *SyncedSet) *SyncedSet {
newSet := NewSyncedSet()
for k := range s.set {
if other.Contains(k) {
newSet.Add(k)
}
}
return &newSet
} | [
"func",
"(",
"s",
"*",
"SyncedSet",
")",
"Intersect",
"(",
"other",
"*",
"SyncedSet",
")",
"*",
"SyncedSet",
"{",
"newSet",
":=",
"NewSyncedSet",
"(",
")",
"\n",
"for",
"k",
":=",
"range",
"s",
".",
"set",
"{",
"if",
"other",
".",
"Contains",
"(",
... | // Intersect returns a pointer to a new set containing the intersection of current
// set and other | [
"Intersect",
"returns",
"a",
"pointer",
"to",
"a",
"new",
"set",
"containing",
"the",
"intersection",
"of",
"current",
"set",
"and",
"other"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L60-L68 |
12,996 | 0xrawsec/golang-utils | datastructs/syncedset.go | Union | func (s *SyncedSet) Union(other *SyncedSet) *SyncedSet {
newSet := NewSyncedSet()
for elt := range s.set {
newSet.Add(elt)
}
for elt := range other.set {
newSet.Add(elt)
}
return &newSet
} | go | func (s *SyncedSet) Union(other *SyncedSet) *SyncedSet {
newSet := NewSyncedSet()
for elt := range s.set {
newSet.Add(elt)
}
for elt := range other.set {
newSet.Add(elt)
}
return &newSet
} | [
"func",
"(",
"s",
"*",
"SyncedSet",
")",
"Union",
"(",
"other",
"*",
"SyncedSet",
")",
"*",
"SyncedSet",
"{",
"newSet",
":=",
"NewSyncedSet",
"(",
")",
"\n",
"for",
"elt",
":=",
"range",
"s",
".",
"set",
"{",
"newSet",
".",
"Add",
"(",
"elt",
")",
... | // Union returns a pointer to a new set containing the union of current set and other | [
"Union",
"returns",
"a",
"pointer",
"to",
"a",
"new",
"set",
"containing",
"the",
"union",
"of",
"current",
"set",
"and",
"other"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L71-L80 |
12,997 | 0xrawsec/golang-utils | datastructs/syncedset.go | Contains | func (s *SyncedSet) Contains(datas ...interface{}) bool {
s.RLock()
defer s.RUnlock()
for _, data := range datas {
if _, ok := s.set[data]; !ok {
return false
}
}
return true
} | go | func (s *SyncedSet) Contains(datas ...interface{}) bool {
s.RLock()
defer s.RUnlock()
for _, data := range datas {
if _, ok := s.set[data]; !ok {
return false
}
}
return true
} | [
"func",
"(",
"s",
"*",
"SyncedSet",
")",
"Contains",
"(",
"datas",
"...",
"interface",
"{",
"}",
")",
"bool",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"_",
",",
"data",
":=",
"range",
"datas",
... | // Contains returns true if the syncedset contains all the data | [
"Contains",
"returns",
"true",
"if",
"the",
"syncedset",
"contains",
"all",
"the",
"data"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L83-L92 |
12,998 | 0xrawsec/golang-utils | datastructs/syncedset.go | List | func (s *SyncedSet) List() *[]interface{} {
s.RLock()
defer s.RUnlock()
i := 0
l := make([]interface{}, s.Len())
for k := range s.set {
l[i] = k
i++
}
return &l
} | go | func (s *SyncedSet) List() *[]interface{} {
s.RLock()
defer s.RUnlock()
i := 0
l := make([]interface{}, s.Len())
for k := range s.set {
l[i] = k
i++
}
return &l
} | [
"func",
"(",
"s",
"*",
"SyncedSet",
")",
"List",
"(",
")",
"*",
"[",
"]",
"interface",
"{",
"}",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n",
"i",
":=",
"0",
"\n",
"l",
":=",
"make",
"(",
"[",
"]",
... | // List returns a pointer to a new list containing the data in the set | [
"List",
"returns",
"a",
"pointer",
"to",
"a",
"new",
"list",
"containing",
"the",
"data",
"in",
"the",
"set"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L95-L105 |
12,999 | 0xrawsec/golang-utils | datastructs/syncedset.go | Items | func (s *SyncedSet) Items() (c chan interface{}) {
c = make(chan interface{})
go func() {
s.RLock()
defer s.RUnlock()
defer close(c)
for k := range s.set {
c <- k
}
}()
return c
} | go | func (s *SyncedSet) Items() (c chan interface{}) {
c = make(chan interface{})
go func() {
s.RLock()
defer s.RUnlock()
defer close(c)
for k := range s.set {
c <- k
}
}()
return c
} | [
"func",
"(",
"s",
"*",
"SyncedSet",
")",
"Items",
"(",
")",
"(",
"c",
"chan",
"interface",
"{",
"}",
")",
"{",
"c",
"=",
"make",
"(",
"chan",
"interface",
"{",
"}",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
... | // Items returns a channel with all the elements contained in the set | [
"Items",
"returns",
"a",
"channel",
"with",
"all",
"the",
"elements",
"contained",
"in",
"the",
"set"
] | 817f34752728629396193de0249e187c6ab1c5cb | https://github.com/0xrawsec/golang-utils/blob/817f34752728629396193de0249e187c6ab1c5cb/datastructs/syncedset.go#L108-L120 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.