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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
4,700 | ligato/cn-infra | db/keyval/proto_serializer.go | Marshal | func (sp *SerializerProto) Marshal(message proto.Message) ([]byte, error) {
return proto.Marshal(message)
} | go | func (sp *SerializerProto) Marshal(message proto.Message) ([]byte, error) {
return proto.Marshal(message)
} | [
"func",
"(",
"sp",
"*",
"SerializerProto",
")",
"Marshal",
"(",
"message",
"proto",
".",
"Message",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"proto",
".",
"Marshal",
"(",
"message",
")",
"\n",
"}"
] | // Marshal serializes data from proto message to the slice of bytes using proto
// marshaller. | [
"Marshal",
"serializes",
"data",
"from",
"proto",
"message",
"to",
"the",
"slice",
"of",
"bytes",
"using",
"proto",
"marshaller",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/proto_serializer.go#L48-L50 |
4,701 | ligato/cn-infra | db/keyval/proto_serializer.go | Unmarshal | func (sj *SerializerJSON) Unmarshal(data []byte, protoData proto.Message) error {
return jsonpb.Unmarshal(bytes.NewBuffer(data), protoData)
} | go | func (sj *SerializerJSON) Unmarshal(data []byte, protoData proto.Message) error {
return jsonpb.Unmarshal(bytes.NewBuffer(data), protoData)
} | [
"func",
"(",
"sj",
"*",
"SerializerJSON",
")",
"Unmarshal",
"(",
"data",
"[",
"]",
"byte",
",",
"protoData",
"proto",
".",
"Message",
")",
"error",
"{",
"return",
"jsonpb",
".",
"Unmarshal",
"(",
"bytes",
".",
"NewBuffer",
"(",
"data",
")",
",",
"proto... | // Unmarshal deserializes data from slice of bytes into the provided protobuf
// message using jsonpb marshaller to correctly unmarshal protobuf data. | [
"Unmarshal",
"deserializes",
"data",
"from",
"slice",
"of",
"bytes",
"into",
"the",
"provided",
"protobuf",
"message",
"using",
"jsonpb",
"marshaller",
"to",
"correctly",
"unmarshal",
"protobuf",
"data",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/proto_serializer.go#L57-L59 |
4,702 | ligato/cn-infra | db/keyval/proto_serializer.go | Marshal | func (sj *SerializerJSON) Marshal(message proto.Message) ([]byte, error) {
if message == nil {
return []byte("null"), nil
}
var buf bytes.Buffer
if err := DefaultMarshaler.Marshal(&buf, message); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | func (sj *SerializerJSON) Marshal(message proto.Message) ([]byte, error) {
if message == nil {
return []byte("null"), nil
}
var buf bytes.Buffer
if err := DefaultMarshaler.Marshal(&buf, message); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | [
"func",
"(",
"sj",
"*",
"SerializerJSON",
")",
"Marshal",
"(",
"message",
"proto",
".",
"Message",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"message",
"==",
"nil",
"{",
"return",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"nil"... | // Marshal serializes proto message to the slice of bytes using
// jsonpb marshaller to correctly marshal protobuf data. | [
"Marshal",
"serializes",
"proto",
"message",
"to",
"the",
"slice",
"of",
"bytes",
"using",
"jsonpb",
"marshaller",
"to",
"correctly",
"marshal",
"protobuf",
"data",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/proto_serializer.go#L63-L72 |
4,703 | ligato/cn-infra | datasync/kvdbsync/watch_impl.go | watchResync | func (keys *watchBrokerKeys) watchResync(resyncReg resync.Registration) {
for resyncStatus := range resyncReg.StatusChan() {
if resyncStatus.ResyncStatus() == resync.Started {
err := keys.resync()
if err != nil {
// We are not able to propagate it somewhere else.
logrus.DefaultLogger().Errorf("getting resync data failed: %v", err)
// TODO NICE-to-HAVE publish the err using the transport asynchronously
}
}
resyncStatus.Ack()
}
} | go | func (keys *watchBrokerKeys) watchResync(resyncReg resync.Registration) {
for resyncStatus := range resyncReg.StatusChan() {
if resyncStatus.ResyncStatus() == resync.Started {
err := keys.resync()
if err != nil {
// We are not able to propagate it somewhere else.
logrus.DefaultLogger().Errorf("getting resync data failed: %v", err)
// TODO NICE-to-HAVE publish the err using the transport asynchronously
}
}
resyncStatus.Ack()
}
} | [
"func",
"(",
"keys",
"*",
"watchBrokerKeys",
")",
"watchResync",
"(",
"resyncReg",
"resync",
".",
"Registration",
")",
"{",
"for",
"resyncStatus",
":=",
"range",
"resyncReg",
".",
"StatusChan",
"(",
")",
"{",
"if",
"resyncStatus",
".",
"ResyncStatus",
"(",
"... | // resyncReg.StatusChan == Started => resync | [
"resyncReg",
".",
"StatusChan",
"==",
"Started",
"=",
">",
"resync"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/kvdbsync/watch_impl.go#L95-L107 |
4,704 | ligato/cn-infra | datasync/kvdbsync/watch_impl.go | resyncRev | func (keys *watchBrokerKeys) resyncRev() error {
for _, keyPrefix := range keys.prefixes {
revIt, err := keys.adapter.db.ListValues(keyPrefix)
if err != nil {
return err
}
// if there are data for given prefix, register it
for {
data, stop := revIt.GetNext()
if stop {
break
}
logrus.DefaultLogger().Debugf("registering key found in KV: %q", data.GetKey())
keys.adapter.base.LastRev().PutWithRevision(data.GetKey(),
syncbase.NewKeyVal(data.GetKey(), data, data.GetRevision()))
}
}
return nil
} | go | func (keys *watchBrokerKeys) resyncRev() error {
for _, keyPrefix := range keys.prefixes {
revIt, err := keys.adapter.db.ListValues(keyPrefix)
if err != nil {
return err
}
// if there are data for given prefix, register it
for {
data, stop := revIt.GetNext()
if stop {
break
}
logrus.DefaultLogger().Debugf("registering key found in KV: %q", data.GetKey())
keys.adapter.base.LastRev().PutWithRevision(data.GetKey(),
syncbase.NewKeyVal(data.GetKey(), data, data.GetRevision()))
}
}
return nil
} | [
"func",
"(",
"keys",
"*",
"watchBrokerKeys",
")",
"resyncRev",
"(",
")",
"error",
"{",
"for",
"_",
",",
"keyPrefix",
":=",
"range",
"keys",
".",
"prefixes",
"{",
"revIt",
",",
"err",
":=",
"keys",
".",
"adapter",
".",
"db",
".",
"ListValues",
"(",
"k... | // ResyncRev fill the PrevRevision map. This step needs to be done even if resync is ommited | [
"ResyncRev",
"fill",
"the",
"PrevRevision",
"map",
".",
"This",
"step",
"needs",
"to",
"be",
"done",
"even",
"if",
"resync",
"is",
"ommited"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/kvdbsync/watch_impl.go#L110-L130 |
4,705 | ligato/cn-infra | logging/logmanager/config.go | NewConf | func NewConf() *Config {
return &Config{
DefaultLevel: "",
Loggers: []LoggerConfig{},
Hooks: make(map[string]HookConfig),
}
} | go | func NewConf() *Config {
return &Config{
DefaultLevel: "",
Loggers: []LoggerConfig{},
Hooks: make(map[string]HookConfig),
}
} | [
"func",
"NewConf",
"(",
")",
"*",
"Config",
"{",
"return",
"&",
"Config",
"{",
"DefaultLevel",
":",
"\"",
"\"",
",",
"Loggers",
":",
"[",
"]",
"LoggerConfig",
"{",
"}",
",",
"Hooks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"HookConfig",
")",
"... | // NewConf creates default configuration with InfoLevel & empty loggers.
// Suitable also for usage in flavor to programmatically specify default behavior. | [
"NewConf",
"creates",
"default",
"configuration",
"with",
"InfoLevel",
"&",
"empty",
"loggers",
".",
"Suitable",
"also",
"for",
"usage",
"in",
"flavor",
"to",
"programmatically",
"specify",
"default",
"behavior",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logmanager/config.go#L5-L11 |
4,706 | ligato/cn-infra | db/keyval/filedb/database/database.go | Add | func (c *DbClient) Add(path string, entry *decoder.FileDataEntry) {
c.Lock()
defer c.Unlock()
if entry == nil {
return
}
fileData, ok := c.db[path]
if ok {
value, ok := fileData[entry.Key]
if ok {
if !bytes.Equal(value.data, entry.Value) {
rev := value.rev + 1
fileData[entry.Key] = &dbEntry{entry.Value, rev}
}
} else {
fileData[entry.Key] = &dbEntry{entry.Value, initialRev}
}
} else {
fileData = map[string]*dbEntry{entry.Key: {entry.Value, initialRev}}
}
c.db[path] = fileData
} | go | func (c *DbClient) Add(path string, entry *decoder.FileDataEntry) {
c.Lock()
defer c.Unlock()
if entry == nil {
return
}
fileData, ok := c.db[path]
if ok {
value, ok := fileData[entry.Key]
if ok {
if !bytes.Equal(value.data, entry.Value) {
rev := value.rev + 1
fileData[entry.Key] = &dbEntry{entry.Value, rev}
}
} else {
fileData[entry.Key] = &dbEntry{entry.Value, initialRev}
}
} else {
fileData = map[string]*dbEntry{entry.Key: {entry.Value, initialRev}}
}
c.db[path] = fileData
} | [
"func",
"(",
"c",
"*",
"DbClient",
")",
"Add",
"(",
"path",
"string",
",",
"entry",
"*",
"decoder",
".",
"FileDataEntry",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"entry",
"==",
"nil",
"{",
... | // Add puts new entry to the database, or updates the old one if given key already exists | [
"Add",
"puts",
"new",
"entry",
"to",
"the",
"database",
"or",
"updates",
"the",
"old",
"one",
"if",
"given",
"key",
"already",
"exists"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/database/database.go#L64-L88 |
4,707 | ligato/cn-infra | db/keyval/filedb/database/database.go | Delete | func (c *DbClient) Delete(path, key string) {
c.Lock()
defer c.Unlock()
fileData, ok := c.db[path]
if !ok {
return
}
delete(fileData, key)
} | go | func (c *DbClient) Delete(path, key string) {
c.Lock()
defer c.Unlock()
fileData, ok := c.db[path]
if !ok {
return
}
delete(fileData, key)
} | [
"func",
"(",
"c",
"*",
"DbClient",
")",
"Delete",
"(",
"path",
",",
"key",
"string",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"fileData",
",",
"ok",
":=",
"c",
".",
"db",
"[",
"path",
"]",
"\n... | // Delete removes key in given path. | [
"Delete",
"removes",
"key",
"in",
"given",
"path",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/database/database.go#L91-L100 |
4,708 | ligato/cn-infra | db/keyval/filedb/database/database.go | DeleteFile | func (c *DbClient) DeleteFile(path string) {
c.Lock()
defer c.Unlock()
delete(c.db, path)
} | go | func (c *DbClient) DeleteFile(path string) {
c.Lock()
defer c.Unlock()
delete(c.db, path)
} | [
"func",
"(",
"c",
"*",
"DbClient",
")",
"DeleteFile",
"(",
"path",
"string",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"c",
".",
"db",
",",
"path",
")",
"\n",
"}"
] | // DeleteFile removes file entry including all keys within | [
"DeleteFile",
"removes",
"file",
"entry",
"including",
"all",
"keys",
"within"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/database/database.go#L103-L108 |
4,709 | ligato/cn-infra | db/keyval/filedb/database/database.go | GetDataForPrefix | func (c *DbClient) GetDataForPrefix(prefix string) []*decoder.FileDataEntry {
c.Lock()
defer c.Unlock()
var keyValues []*decoder.FileDataEntry
for _, file := range c.db {
for key, value := range file {
if strings.HasPrefix(key, prefix) {
keyValues = append(keyValues, &decoder.FileDataEntry{
Key: key,
Value: value.data,
})
}
}
}
return keyValues
} | go | func (c *DbClient) GetDataForPrefix(prefix string) []*decoder.FileDataEntry {
c.Lock()
defer c.Unlock()
var keyValues []*decoder.FileDataEntry
for _, file := range c.db {
for key, value := range file {
if strings.HasPrefix(key, prefix) {
keyValues = append(keyValues, &decoder.FileDataEntry{
Key: key,
Value: value.data,
})
}
}
}
return keyValues
} | [
"func",
"(",
"c",
"*",
"DbClient",
")",
"GetDataForPrefix",
"(",
"prefix",
"string",
")",
"[",
"]",
"*",
"decoder",
".",
"FileDataEntry",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"keyValues",
"[",
... | // GetDataForPrefix returns all values which match provided prefix | [
"GetDataForPrefix",
"returns",
"all",
"values",
"which",
"match",
"provided",
"prefix"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/database/database.go#L111-L127 |
4,710 | ligato/cn-infra | db/keyval/filedb/database/database.go | GetDataForFile | func (c *DbClient) GetDataForFile(path string) []*decoder.FileDataEntry {
c.Lock()
defer c.Unlock()
var keyValues []*decoder.FileDataEntry
if dbKeyValues, ok := c.db[path]; ok {
for key, value := range dbKeyValues {
keyValues = append(keyValues, &decoder.FileDataEntry{
Key: key,
Value: value.data,
})
}
}
return keyValues
} | go | func (c *DbClient) GetDataForFile(path string) []*decoder.FileDataEntry {
c.Lock()
defer c.Unlock()
var keyValues []*decoder.FileDataEntry
if dbKeyValues, ok := c.db[path]; ok {
for key, value := range dbKeyValues {
keyValues = append(keyValues, &decoder.FileDataEntry{
Key: key,
Value: value.data,
})
}
}
return keyValues
} | [
"func",
"(",
"c",
"*",
"DbClient",
")",
"GetDataForFile",
"(",
"path",
"string",
")",
"[",
"]",
"*",
"decoder",
".",
"FileDataEntry",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"keyValues",
"[",
"]"... | // GetDataForFile returns a map of key-value entries from given file | [
"GetDataForFile",
"returns",
"a",
"map",
"of",
"key",
"-",
"value",
"entries",
"from",
"given",
"file"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/database/database.go#L130-L144 |
4,711 | ligato/cn-infra | db/keyval/filedb/database/database.go | GetDataForKey | func (c *DbClient) GetDataForKey(key string) (*decoder.FileDataEntry, bool) {
c.Lock()
defer c.Unlock()
for _, file := range c.db {
value, ok := file[key]
if ok {
return &decoder.FileDataEntry{
Key: key,
Value: value.data,
}, true
}
}
return nil, false
} | go | func (c *DbClient) GetDataForKey(key string) (*decoder.FileDataEntry, bool) {
c.Lock()
defer c.Unlock()
for _, file := range c.db {
value, ok := file[key]
if ok {
return &decoder.FileDataEntry{
Key: key,
Value: value.data,
}, true
}
}
return nil, false
} | [
"func",
"(",
"c",
"*",
"DbClient",
")",
"GetDataForKey",
"(",
"key",
"string",
")",
"(",
"*",
"decoder",
".",
"FileDataEntry",
",",
"bool",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
","... | // GetDataForKey returns data for given key. | [
"GetDataForKey",
"returns",
"data",
"for",
"given",
"key",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/database/database.go#L147-L161 |
4,712 | ligato/cn-infra | db/sql/cassandra/config.go | ConfigToClientConfig | func ConfigToClientConfig(ymlConfig *Config) (*ClientConfig, error) {
timeout := defaultOpTimeout
if ymlConfig.OpTimeout > 0 {
timeout = ymlConfig.OpTimeout
}
connectTimeout := defaultDialTimeout
if ymlConfig.DialTimeout > 0 {
connectTimeout = ymlConfig.DialTimeout
}
reconnectInterval := defaultRedialInterval
if ymlConfig.RedialInterval > 0 {
reconnectInterval = ymlConfig.RedialInterval
}
protoVersion := defaultProtocolVersion
if ymlConfig.ProtocolVersion > 0 {
protoVersion = ymlConfig.ProtocolVersion
}
endpoints, port, err := getEndpointsAndPort(ymlConfig.Endpoints)
if err != nil {
return nil, err
}
var sslOpts *gocql.SslOptions
if ymlConfig.TLS.Enabled {
sslOpts = &gocql.SslOptions{
CaPath: ymlConfig.TLS.CAfile,
CertPath: ymlConfig.TLS.Certfile,
KeyPath: ymlConfig.TLS.Keyfile,
EnableHostVerification: ymlConfig.TLS.EnableHostVerification,
}
}
clientConfig := &gocql.ClusterConfig{
Hosts: endpoints,
Port: port,
Timeout: timeout * time.Millisecond,
ConnectTimeout: connectTimeout * time.Millisecond,
ReconnectInterval: reconnectInterval * time.Second,
ProtoVersion: protoVersion,
SslOpts: sslOpts,
}
cfg := &ClientConfig{ClusterConfig: clientConfig}
return cfg, nil
} | go | func ConfigToClientConfig(ymlConfig *Config) (*ClientConfig, error) {
timeout := defaultOpTimeout
if ymlConfig.OpTimeout > 0 {
timeout = ymlConfig.OpTimeout
}
connectTimeout := defaultDialTimeout
if ymlConfig.DialTimeout > 0 {
connectTimeout = ymlConfig.DialTimeout
}
reconnectInterval := defaultRedialInterval
if ymlConfig.RedialInterval > 0 {
reconnectInterval = ymlConfig.RedialInterval
}
protoVersion := defaultProtocolVersion
if ymlConfig.ProtocolVersion > 0 {
protoVersion = ymlConfig.ProtocolVersion
}
endpoints, port, err := getEndpointsAndPort(ymlConfig.Endpoints)
if err != nil {
return nil, err
}
var sslOpts *gocql.SslOptions
if ymlConfig.TLS.Enabled {
sslOpts = &gocql.SslOptions{
CaPath: ymlConfig.TLS.CAfile,
CertPath: ymlConfig.TLS.Certfile,
KeyPath: ymlConfig.TLS.Keyfile,
EnableHostVerification: ymlConfig.TLS.EnableHostVerification,
}
}
clientConfig := &gocql.ClusterConfig{
Hosts: endpoints,
Port: port,
Timeout: timeout * time.Millisecond,
ConnectTimeout: connectTimeout * time.Millisecond,
ReconnectInterval: reconnectInterval * time.Second,
ProtoVersion: protoVersion,
SslOpts: sslOpts,
}
cfg := &ClientConfig{ClusterConfig: clientConfig}
return cfg, nil
} | [
"func",
"ConfigToClientConfig",
"(",
"ymlConfig",
"*",
"Config",
")",
"(",
"*",
"ClientConfig",
",",
"error",
")",
"{",
"timeout",
":=",
"defaultOpTimeout",
"\n",
"if",
"ymlConfig",
".",
"OpTimeout",
">",
"0",
"{",
"timeout",
"=",
"ymlConfig",
".",
"OpTimeou... | // ConfigToClientConfig transforms the yaml configuration into ClientConfig.
// If the configuration of endpoints is invalid, error ErrInvalidEndpointConfig
// is returned. | [
"ConfigToClientConfig",
"transforms",
"the",
"yaml",
"configuration",
"into",
"ClientConfig",
".",
"If",
"the",
"configuration",
"of",
"endpoints",
"is",
"invalid",
"error",
"ErrInvalidEndpointConfig",
"is",
"returned",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/sql/cassandra/config.go#L78-L128 |
4,713 | ligato/cn-infra | rpc/grpc/listen_and_serve.go | ListenAndServe | func ListenAndServe(cfg *Config, srv *grpc.Server) (netListener net.Listener, err error) {
switch socketType := cfg.getSocketType(); socketType {
case "unix", "unixpacket":
permissions, err := getUnixSocketFilePermissions(cfg.Permission)
if err != nil {
return nil, err
}
if err := checkUnixSocketFileAndDirectory(cfg.Endpoint, cfg.ForceSocketRemoval); err != nil {
return nil, err
}
netListener, err = net.Listen(socketType, cfg.Endpoint)
if err != nil {
return nil, err
}
// Set permissions to the socket file
if err := os.Chmod(cfg.Endpoint, permissions); err != nil {
return nil, err
}
default:
netListener, err = net.Listen(socketType, cfg.Endpoint)
if err != nil {
return nil, err
}
}
go func() {
err := srv.Serve(netListener)
// Serve always returns non-nil error
logging.DefaultLogger.Debugf("GRPC server Serve: %v", err)
}()
return netListener, nil
} | go | func ListenAndServe(cfg *Config, srv *grpc.Server) (netListener net.Listener, err error) {
switch socketType := cfg.getSocketType(); socketType {
case "unix", "unixpacket":
permissions, err := getUnixSocketFilePermissions(cfg.Permission)
if err != nil {
return nil, err
}
if err := checkUnixSocketFileAndDirectory(cfg.Endpoint, cfg.ForceSocketRemoval); err != nil {
return nil, err
}
netListener, err = net.Listen(socketType, cfg.Endpoint)
if err != nil {
return nil, err
}
// Set permissions to the socket file
if err := os.Chmod(cfg.Endpoint, permissions); err != nil {
return nil, err
}
default:
netListener, err = net.Listen(socketType, cfg.Endpoint)
if err != nil {
return nil, err
}
}
go func() {
err := srv.Serve(netListener)
// Serve always returns non-nil error
logging.DefaultLogger.Debugf("GRPC server Serve: %v", err)
}()
return netListener, nil
} | [
"func",
"ListenAndServe",
"(",
"cfg",
"*",
"Config",
",",
"srv",
"*",
"grpc",
".",
"Server",
")",
"(",
"netListener",
"net",
".",
"Listener",
",",
"err",
"error",
")",
"{",
"switch",
"socketType",
":=",
"cfg",
".",
"getSocketType",
"(",
")",
";",
"sock... | // ListenAndServe starts configured listener and serving for clients | [
"ListenAndServe",
"starts",
"configured",
"listener",
"and",
"serving",
"for",
"clients"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/rpc/grpc/listen_and_serve.go#L29-L63 |
4,714 | ligato/cn-infra | rpc/grpc/listen_and_serve.go | getUnixSocketFilePermissions | func getUnixSocketFilePermissions(permissions int) (os.FileMode, error) {
if permissions > 0 {
if permissions > 7777 {
return 0, fmt.Errorf("incorrect unix socket file/path permission value '%d'", permissions)
}
// Convert to correct mode format
mode, err := strconv.ParseInt(strconv.Itoa(permissions), 8, 32)
if err != nil {
return 0, fmt.Errorf("failed to parse socket file permissions %d", permissions)
}
return os.FileMode(mode), nil
}
return os.ModePerm, nil
} | go | func getUnixSocketFilePermissions(permissions int) (os.FileMode, error) {
if permissions > 0 {
if permissions > 7777 {
return 0, fmt.Errorf("incorrect unix socket file/path permission value '%d'", permissions)
}
// Convert to correct mode format
mode, err := strconv.ParseInt(strconv.Itoa(permissions), 8, 32)
if err != nil {
return 0, fmt.Errorf("failed to parse socket file permissions %d", permissions)
}
return os.FileMode(mode), nil
}
return os.ModePerm, nil
} | [
"func",
"getUnixSocketFilePermissions",
"(",
"permissions",
"int",
")",
"(",
"os",
".",
"FileMode",
",",
"error",
")",
"{",
"if",
"permissions",
">",
"0",
"{",
"if",
"permissions",
">",
"7777",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
... | // Resolve permissions and return FileMode | [
"Resolve",
"permissions",
"and",
"return",
"FileMode"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/rpc/grpc/listen_and_serve.go#L66-L79 |
4,715 | ligato/cn-infra | datasync/resync/registration.go | newRegistration | func newRegistration(resyncName string, statusChan chan StatusEvent) *registration {
return ®istration{resyncName: resyncName, statusChan: statusChan}
} | go | func newRegistration(resyncName string, statusChan chan StatusEvent) *registration {
return ®istration{resyncName: resyncName, statusChan: statusChan}
} | [
"func",
"newRegistration",
"(",
"resyncName",
"string",
",",
"statusChan",
"chan",
"StatusEvent",
")",
"*",
"registration",
"{",
"return",
"&",
"registration",
"{",
"resyncName",
":",
"resyncName",
",",
"statusChan",
":",
"statusChan",
"}",
"\n",
"}"
] | // newRegistration is a constructor. | [
"newRegistration",
"is",
"a",
"constructor",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/resync/registration.go#L26-L28 |
4,716 | ligato/cn-infra | datasync/resync/registration.go | newStatusEvent | func newStatusEvent(status Status) *statusEvent {
return &statusEvent{status: status, ackChan: make(chan time.Time)}
} | go | func newStatusEvent(status Status) *statusEvent {
return &statusEvent{status: status, ackChan: make(chan time.Time)}
} | [
"func",
"newStatusEvent",
"(",
"status",
"Status",
")",
"*",
"statusEvent",
"{",
"return",
"&",
"statusEvent",
"{",
"status",
":",
"status",
",",
"ackChan",
":",
"make",
"(",
"chan",
"time",
".",
"Time",
")",
"}",
"\n",
"}"
] | // newStatusEvent is a constructor. | [
"newStatusEvent",
"is",
"a",
"constructor",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/resync/registration.go#L41-L43 |
4,717 | ligato/cn-infra | logging/logrus/registry.go | NewLogRegistry | func NewLogRegistry() logging.Registry {
registry := &logRegistry{
loggers: new(sync.Map),
logLevels: make(map[string]logrus.Level),
defaultLevel: initialLogLvl,
}
// put default logger
registry.putLoggerToMapping(defaultLogger)
return registry
} | go | func NewLogRegistry() logging.Registry {
registry := &logRegistry{
loggers: new(sync.Map),
logLevels: make(map[string]logrus.Level),
defaultLevel: initialLogLvl,
}
// put default logger
registry.putLoggerToMapping(defaultLogger)
return registry
} | [
"func",
"NewLogRegistry",
"(",
")",
"logging",
".",
"Registry",
"{",
"registry",
":=",
"&",
"logRegistry",
"{",
"loggers",
":",
"new",
"(",
"sync",
".",
"Map",
")",
",",
"logLevels",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"logrus",
".",
"Level",
... | // NewLogRegistry is a constructor | [
"NewLogRegistry",
"is",
"a",
"constructor"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L46-L55 |
4,718 | ligato/cn-infra | logging/logrus/registry.go | NewLogger | func (lr *logRegistry) NewLogger(name string) logging.Logger {
if existingLogger := lr.getLoggerFromMapping(name); existingLogger != nil {
panic(fmt.Errorf("logger with name '%s' already exists", name))
}
if err := checkLoggerName(name); err != nil {
panic(err)
}
logger := NewLogger(name)
// set initial logger level
if lvl, ok := lr.logLevels[name]; ok {
setLevel(logger, lvl)
} else {
setLevel(logger, lr.defaultLevel)
}
lr.putLoggerToMapping(logger)
// add all defined hooks
for _, hook := range lr.hooks {
logger.std.AddHook(hook)
}
return logger
} | go | func (lr *logRegistry) NewLogger(name string) logging.Logger {
if existingLogger := lr.getLoggerFromMapping(name); existingLogger != nil {
panic(fmt.Errorf("logger with name '%s' already exists", name))
}
if err := checkLoggerName(name); err != nil {
panic(err)
}
logger := NewLogger(name)
// set initial logger level
if lvl, ok := lr.logLevels[name]; ok {
setLevel(logger, lvl)
} else {
setLevel(logger, lr.defaultLevel)
}
lr.putLoggerToMapping(logger)
// add all defined hooks
for _, hook := range lr.hooks {
logger.std.AddHook(hook)
}
return logger
} | [
"func",
"(",
"lr",
"*",
"logRegistry",
")",
"NewLogger",
"(",
"name",
"string",
")",
"logging",
".",
"Logger",
"{",
"if",
"existingLogger",
":=",
"lr",
".",
"getLoggerFromMapping",
"(",
"name",
")",
";",
"existingLogger",
"!=",
"nil",
"{",
"panic",
"(",
... | // NewLogger creates new named Logger instance. Name can be subsequently used to
// refer the logger in registry. | [
"NewLogger",
"creates",
"new",
"named",
"Logger",
"instance",
".",
"Name",
"can",
"be",
"subsequently",
"used",
"to",
"refer",
"the",
"logger",
"in",
"registry",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L80-L105 |
4,719 | ligato/cn-infra | logging/logrus/registry.go | SetLevel | func (lr *logRegistry) SetLevel(logger, level string) error {
lvl, err := logrus.ParseLevel(level)
if err != nil {
return err
}
if logger == "default" {
lr.defaultLevel = lvl
return nil
}
lr.logLevels[logger] = lvl
logVal := lr.getLoggerFromMapping(logger)
if logVal != nil {
defaultLogger.Debugf("setting logger level: %v -> %v", logVal.GetName(), lvl.String())
return setLevel(logVal, lvl)
}
return nil
} | go | func (lr *logRegistry) SetLevel(logger, level string) error {
lvl, err := logrus.ParseLevel(level)
if err != nil {
return err
}
if logger == "default" {
lr.defaultLevel = lvl
return nil
}
lr.logLevels[logger] = lvl
logVal := lr.getLoggerFromMapping(logger)
if logVal != nil {
defaultLogger.Debugf("setting logger level: %v -> %v", logVal.GetName(), lvl.String())
return setLevel(logVal, lvl)
}
return nil
} | [
"func",
"(",
"lr",
"*",
"logRegistry",
")",
"SetLevel",
"(",
"logger",
",",
"level",
"string",
")",
"error",
"{",
"lvl",
",",
"err",
":=",
"logrus",
".",
"ParseLevel",
"(",
"level",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"... | // SetLevel modifies log level of selected logger in the registry | [
"SetLevel",
"modifies",
"log",
"level",
"of",
"selected",
"logger",
"in",
"the",
"registry"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L159-L175 |
4,720 | ligato/cn-infra | logging/logrus/registry.go | GetLevel | func (lr *logRegistry) GetLevel(logger string) (string, error) {
logVal := lr.getLoggerFromMapping(logger)
if logVal == nil {
return "", fmt.Errorf("logger %s not found", logger)
}
return logVal.GetLevel().String(), nil
} | go | func (lr *logRegistry) GetLevel(logger string) (string, error) {
logVal := lr.getLoggerFromMapping(logger)
if logVal == nil {
return "", fmt.Errorf("logger %s not found", logger)
}
return logVal.GetLevel().String(), nil
} | [
"func",
"(",
"lr",
"*",
"logRegistry",
")",
"GetLevel",
"(",
"logger",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"logVal",
":=",
"lr",
".",
"getLoggerFromMapping",
"(",
"logger",
")",
"\n",
"if",
"logVal",
"==",
"nil",
"{",
"return",
"\"",
... | // GetLevel returns the currently set log level of the logger | [
"GetLevel",
"returns",
"the",
"currently",
"set",
"log",
"level",
"of",
"the",
"logger"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L178-L184 |
4,721 | ligato/cn-infra | logging/logrus/registry.go | Lookup | func (lr *logRegistry) Lookup(loggerName string) (logger logging.Logger, found bool) {
loggerInt, found := lr.loggers.Load(loggerName)
if !found {
return nil, false
}
logger, ok := loggerInt.(*Logger)
if ok {
return logger, found
}
panic(fmt.Errorf("cannot cast log value to Logger obj"))
} | go | func (lr *logRegistry) Lookup(loggerName string) (logger logging.Logger, found bool) {
loggerInt, found := lr.loggers.Load(loggerName)
if !found {
return nil, false
}
logger, ok := loggerInt.(*Logger)
if ok {
return logger, found
}
panic(fmt.Errorf("cannot cast log value to Logger obj"))
} | [
"func",
"(",
"lr",
"*",
"logRegistry",
")",
"Lookup",
"(",
"loggerName",
"string",
")",
"(",
"logger",
"logging",
".",
"Logger",
",",
"found",
"bool",
")",
"{",
"loggerInt",
",",
"found",
":=",
"lr",
".",
"loggers",
".",
"Load",
"(",
"loggerName",
")",... | // Lookup returns a logger instance identified by name from registry | [
"Lookup",
"returns",
"a",
"logger",
"instance",
"identified",
"by",
"name",
"from",
"registry"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L187-L197 |
4,722 | ligato/cn-infra | logging/logrus/registry.go | ClearRegistry | func (lr *logRegistry) ClearRegistry() {
var wasErr error
// range over logger map and store keys
lr.loggers.Range(func(k, v interface{}) bool {
key, ok := k.(string)
if !ok {
wasErr = fmt.Errorf("cannot cast log map key to string")
// false stops the iteration
return false
}
if key != DefaultLoggerName {
lr.loggers.Delete(key)
}
return true
})
if wasErr != nil {
panic(wasErr)
}
} | go | func (lr *logRegistry) ClearRegistry() {
var wasErr error
// range over logger map and store keys
lr.loggers.Range(func(k, v interface{}) bool {
key, ok := k.(string)
if !ok {
wasErr = fmt.Errorf("cannot cast log map key to string")
// false stops the iteration
return false
}
if key != DefaultLoggerName {
lr.loggers.Delete(key)
}
return true
})
if wasErr != nil {
panic(wasErr)
}
} | [
"func",
"(",
"lr",
"*",
"logRegistry",
")",
"ClearRegistry",
"(",
")",
"{",
"var",
"wasErr",
"error",
"\n\n",
"// range over logger map and store keys",
"lr",
".",
"loggers",
".",
"Range",
"(",
"func",
"(",
"k",
",",
"v",
"interface",
"{",
"}",
")",
"bool"... | // ClearRegistry removes all loggers except the default one from registry | [
"ClearRegistry",
"removes",
"all",
"loggers",
"except",
"the",
"default",
"one",
"from",
"registry"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L200-L220 |
4,723 | ligato/cn-infra | logging/logrus/registry.go | putLoggerToMapping | func (lr *logRegistry) putLoggerToMapping(logger *Logger) {
lr.loggers.Store(logger.name, logger)
} | go | func (lr *logRegistry) putLoggerToMapping(logger *Logger) {
lr.loggers.Store(logger.name, logger)
} | [
"func",
"(",
"lr",
"*",
"logRegistry",
")",
"putLoggerToMapping",
"(",
"logger",
"*",
"Logger",
")",
"{",
"lr",
".",
"loggers",
".",
"Store",
"(",
"logger",
".",
"name",
",",
"logger",
")",
"\n",
"}"
] | // putLoggerToMapping writes logger into map of named loggers | [
"putLoggerToMapping",
"writes",
"logger",
"into",
"map",
"of",
"named",
"loggers"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L223-L225 |
4,724 | ligato/cn-infra | logging/logrus/registry.go | getLoggerFromMapping | func (lr *logRegistry) getLoggerFromMapping(logger string) *Logger {
loggerVal, found := lr.loggers.Load(logger)
if !found {
return nil
}
log, ok := loggerVal.(*Logger)
if ok {
return log
}
panic("cannot cast log value to Logger obj")
} | go | func (lr *logRegistry) getLoggerFromMapping(logger string) *Logger {
loggerVal, found := lr.loggers.Load(logger)
if !found {
return nil
}
log, ok := loggerVal.(*Logger)
if ok {
return log
}
panic("cannot cast log value to Logger obj")
} | [
"func",
"(",
"lr",
"*",
"logRegistry",
")",
"getLoggerFromMapping",
"(",
"logger",
"string",
")",
"*",
"Logger",
"{",
"loggerVal",
",",
"found",
":=",
"lr",
".",
"loggers",
".",
"Load",
"(",
"logger",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"nil"... | // getLoggerFromMapping returns a logger by its name | [
"getLoggerFromMapping",
"returns",
"a",
"logger",
"by",
"its",
"name"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L228-L239 |
4,725 | ligato/cn-infra | logging/logrus/registry.go | AddHook | func (lr *logRegistry) AddHook(hook logrus.Hook) {
defaultLogger.Infof("adding hook %q to registry", hook)
lr.hooks = append(lr.hooks, hook)
lgs := lr.ListLoggers()
for lg := range lgs {
logger, found := lr.Lookup(lg)
if found {
logger.AddHook(hook)
}
}
} | go | func (lr *logRegistry) AddHook(hook logrus.Hook) {
defaultLogger.Infof("adding hook %q to registry", hook)
lr.hooks = append(lr.hooks, hook)
lgs := lr.ListLoggers()
for lg := range lgs {
logger, found := lr.Lookup(lg)
if found {
logger.AddHook(hook)
}
}
} | [
"func",
"(",
"lr",
"*",
"logRegistry",
")",
"AddHook",
"(",
"hook",
"logrus",
".",
"Hook",
")",
"{",
"defaultLogger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"hook",
")",
"\n",
"lr",
".",
"hooks",
"=",
"append",
"(",
"lr",
".",
"hooks",
",",
"hook",
... | // HookConfigs stores hook configs provided by log manager
// and applies hook to existing loggers | [
"HookConfigs",
"stores",
"hook",
"configs",
"provided",
"by",
"log",
"manager",
"and",
"applies",
"hook",
"to",
"existing",
"loggers"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logrus/registry.go#L243-L254 |
4,726 | ligato/cn-infra | db/keyval/filedb/plugin.go | Init | func (p *Plugin) Init() error {
// Read fileDB configuration file
var err error
p.config, err = p.getFileDBConfig()
if err != nil || p.disabled {
return err
}
// Register decoders
decoders := []decoder.API{decoder.NewJSONDecoder(), decoder.NewYAMLDecoder()}
if p.client, err = NewClient(p.config.ConfigPaths, p.config.StatusPath, decoders, filesystem.NewFsHandler(), p.Log); err != nil {
return err
}
p.protoWrapper = kvproto.NewProtoWrapper(p.client, &keyval.SerializerJSON{})
return nil
} | go | func (p *Plugin) Init() error {
// Read fileDB configuration file
var err error
p.config, err = p.getFileDBConfig()
if err != nil || p.disabled {
return err
}
// Register decoders
decoders := []decoder.API{decoder.NewJSONDecoder(), decoder.NewYAMLDecoder()}
if p.client, err = NewClient(p.config.ConfigPaths, p.config.StatusPath, decoders, filesystem.NewFsHandler(), p.Log); err != nil {
return err
}
p.protoWrapper = kvproto.NewProtoWrapper(p.client, &keyval.SerializerJSON{})
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"Init",
"(",
")",
"error",
"{",
"// Read fileDB configuration file",
"var",
"err",
"error",
"\n",
"p",
".",
"config",
",",
"err",
"=",
"p",
".",
"getFileDBConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
... | // Init reads file config and creates new client to communicate with file system | [
"Init",
"reads",
"file",
"config",
"and",
"creates",
"new",
"client",
"to",
"communicate",
"with",
"file",
"system"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/plugin.go#L53-L70 |
4,727 | ligato/cn-infra | db/keyval/filedb/plugin.go | AfterInit | func (p *Plugin) AfterInit() error {
if !p.disabled {
p.client.eventWatcher()
}
return nil
} | go | func (p *Plugin) AfterInit() error {
if !p.disabled {
p.client.eventWatcher()
}
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"AfterInit",
"(",
")",
"error",
"{",
"if",
"!",
"p",
".",
"disabled",
"{",
"p",
".",
"client",
".",
"eventWatcher",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // AfterInit starts file system event watcher | [
"AfterInit",
"starts",
"file",
"system",
"event",
"watcher"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/plugin.go#L73-L79 |
4,728 | ligato/cn-infra | datasync/syncbase/change.go | NewChange | func NewChange(key string, value proto.Message, rev int64, changeType datasync.Op) *Change {
return &Change{
changeType: changeType,
KeyVal: &KeyVal{key, &lazyProto{value}, rev},
}
} | go | func NewChange(key string, value proto.Message, rev int64, changeType datasync.Op) *Change {
return &Change{
changeType: changeType,
KeyVal: &KeyVal{key, &lazyProto{value}, rev},
}
} | [
"func",
"NewChange",
"(",
"key",
"string",
",",
"value",
"proto",
".",
"Message",
",",
"rev",
"int64",
",",
"changeType",
"datasync",
".",
"Op",
")",
"*",
"Change",
"{",
"return",
"&",
"Change",
"{",
"changeType",
":",
"changeType",
",",
"KeyVal",
":",
... | // NewChange creates a new instance of Change. | [
"NewChange",
"creates",
"a",
"new",
"instance",
"of",
"Change",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/syncbase/change.go#L29-L34 |
4,729 | ligato/cn-infra | datasync/syncbase/change.go | NewChangeBytes | func NewChangeBytes(key string, value []byte, rev int64, changeType datasync.Op) *Change {
return &Change{
changeType: changeType,
KeyVal: &KeyValBytes{key, value, rev},
}
} | go | func NewChangeBytes(key string, value []byte, rev int64, changeType datasync.Op) *Change {
return &Change{
changeType: changeType,
KeyVal: &KeyValBytes{key, value, rev},
}
} | [
"func",
"NewChangeBytes",
"(",
"key",
"string",
",",
"value",
"[",
"]",
"byte",
",",
"rev",
"int64",
",",
"changeType",
"datasync",
".",
"Op",
")",
"*",
"Change",
"{",
"return",
"&",
"Change",
"{",
"changeType",
":",
"changeType",
",",
"KeyVal",
":",
"... | // NewChangeBytes creates a new instance of NewChangeBytes. | [
"NewChangeBytes",
"creates",
"a",
"new",
"instance",
"of",
"NewChangeBytes",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/syncbase/change.go#L37-L42 |
4,730 | ligato/cn-infra | examples/kafka-plugin/post-init-consumer/main.go | Init | func (plugin *ExamplePlugin) Init() (err error) {
// Create a synchronous publisher.
// In the manual mode, every publisher has selected its target partition.
plugin.kafkaSyncPublisher, err = plugin.Kafka.NewSyncPublisherToPartition(connection, topic1, syncMessagePartition)
if err != nil {
return err
}
// Prepare subscription channel. Relevant kafka messages are send to this
// channel so that the watcher can read it.
plugin.subscription = make(chan messaging.ProtoMessage)
plugin.Log.Info("Initialization of the custom plugin for the Kafka example is completed")
// Run the producer.
go plugin.producer()
// Verify results and close the example if successful.
go plugin.closeExample()
return err
} | go | func (plugin *ExamplePlugin) Init() (err error) {
// Create a synchronous publisher.
// In the manual mode, every publisher has selected its target partition.
plugin.kafkaSyncPublisher, err = plugin.Kafka.NewSyncPublisherToPartition(connection, topic1, syncMessagePartition)
if err != nil {
return err
}
// Prepare subscription channel. Relevant kafka messages are send to this
// channel so that the watcher can read it.
plugin.subscription = make(chan messaging.ProtoMessage)
plugin.Log.Info("Initialization of the custom plugin for the Kafka example is completed")
// Run the producer.
go plugin.producer()
// Verify results and close the example if successful.
go plugin.closeExample()
return err
} | [
"func",
"(",
"plugin",
"*",
"ExamplePlugin",
")",
"Init",
"(",
")",
"(",
"err",
"error",
")",
"{",
"// Create a synchronous publisher.",
"// In the manual mode, every publisher has selected its target partition.",
"plugin",
".",
"kafkaSyncPublisher",
",",
"err",
"=",
"plu... | // Init initializes and starts producers | [
"Init",
"initializes",
"and",
"starts",
"producers"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/kafka-plugin/post-init-consumer/main.go#L87-L108 |
4,731 | ligato/cn-infra | db/keyval/redis/plugin_impl_redis.go | Init | func (p *Plugin) Init() (err error) {
redisCfg, err := p.getRedisConfig()
if err != nil || p.disabled {
return err
}
// Create client according to config
client, err := ConfigToClient(redisCfg)
if err != nil {
return err
}
// Uses config file to establish connection with the database
p.connection, err = NewBytesConnection(client, p.Log)
if err != nil {
return err
}
p.protoWrapper = kvproto.NewProtoWrapper(p.connection, &keyval.SerializerJSON{})
return nil
} | go | func (p *Plugin) Init() (err error) {
redisCfg, err := p.getRedisConfig()
if err != nil || p.disabled {
return err
}
// Create client according to config
client, err := ConfigToClient(redisCfg)
if err != nil {
return err
}
// Uses config file to establish connection with the database
p.connection, err = NewBytesConnection(client, p.Log)
if err != nil {
return err
}
p.protoWrapper = kvproto.NewProtoWrapper(p.connection, &keyval.SerializerJSON{})
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"Init",
"(",
")",
"(",
"err",
"error",
")",
"{",
"redisCfg",
",",
"err",
":=",
"p",
".",
"getRedisConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"p",
".",
"disabled",
"{",
"return",
"err",
"\n",
"... | // Init retrieves redis configuration and establishes a new connection
// with the redis data store.
// If the configuration file doesn't exist or cannot be read, the returned errora
// will be of os.PathError type. An untyped error is returned in case the file
// doesn't contain a valid YAML configuration. | [
"Init",
"retrieves",
"redis",
"configuration",
"and",
"establishes",
"a",
"new",
"connection",
"with",
"the",
"redis",
"data",
"store",
".",
"If",
"the",
"configuration",
"file",
"doesn",
"t",
"exist",
"or",
"cannot",
"be",
"read",
"the",
"returned",
"errora",... | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/redis/plugin_impl_redis.go#L54-L74 |
4,732 | ligato/cn-infra | db/keyval/redis/plugin_impl_redis.go | AfterInit | func (p *Plugin) AfterInit() error {
if p.StatusCheck != nil && !p.disabled {
p.StatusCheck.Register(p.PluginName, func() (statuscheck.PluginState, error) {
_, _, err := p.NewBroker("/").GetValue(healthCheckProbeKey, nil)
if err == nil {
return statuscheck.OK, nil
}
return statuscheck.Error, err
})
p.Log.Infof("Status check for %s was started", p.PluginName)
}
return nil
} | go | func (p *Plugin) AfterInit() error {
if p.StatusCheck != nil && !p.disabled {
p.StatusCheck.Register(p.PluginName, func() (statuscheck.PluginState, error) {
_, _, err := p.NewBroker("/").GetValue(healthCheckProbeKey, nil)
if err == nil {
return statuscheck.OK, nil
}
return statuscheck.Error, err
})
p.Log.Infof("Status check for %s was started", p.PluginName)
}
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"AfterInit",
"(",
")",
"error",
"{",
"if",
"p",
".",
"StatusCheck",
"!=",
"nil",
"&&",
"!",
"p",
".",
"disabled",
"{",
"p",
".",
"StatusCheck",
".",
"Register",
"(",
"p",
".",
"PluginName",
",",
"func",
"(",
... | // AfterInit registers redis to status check if required | [
"AfterInit",
"registers",
"redis",
"to",
"status",
"check",
"if",
"required"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/redis/plugin_impl_redis.go#L77-L90 |
4,733 | ligato/cn-infra | db/keyval/consul/plugin.go | Init | func (p *Plugin) Init() (err error) {
if p.Config == nil {
p.Config, err = p.getConfig()
if err != nil || p.disabled {
return err
}
}
clientCfg, err := ConfigToClient(p.Config)
if err != nil {
return err
}
p.client, err = NewClient(clientCfg)
if err != nil {
p.Log.Errorf("Err: %v", err)
return err
}
p.reconnectResync = p.Config.ReconnectResync
p.protoWrapper = kvproto.NewProtoWrapper(p.client, &keyval.SerializerJSON{})
// Register for providing status reports (polling mode)
if p.StatusCheck != nil {
p.StatusCheck.Register(p.PluginName, p.statusCheckProbe)
} else {
p.Log.Warnf("Unable to start status check for consul")
}
return nil
} | go | func (p *Plugin) Init() (err error) {
if p.Config == nil {
p.Config, err = p.getConfig()
if err != nil || p.disabled {
return err
}
}
clientCfg, err := ConfigToClient(p.Config)
if err != nil {
return err
}
p.client, err = NewClient(clientCfg)
if err != nil {
p.Log.Errorf("Err: %v", err)
return err
}
p.reconnectResync = p.Config.ReconnectResync
p.protoWrapper = kvproto.NewProtoWrapper(p.client, &keyval.SerializerJSON{})
// Register for providing status reports (polling mode)
if p.StatusCheck != nil {
p.StatusCheck.Register(p.PluginName, p.statusCheckProbe)
} else {
p.Log.Warnf("Unable to start status check for consul")
}
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"Init",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"p",
".",
"Config",
"==",
"nil",
"{",
"p",
".",
"Config",
",",
"err",
"=",
"p",
".",
"getConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"... | // Init initializes Consul plugin. | [
"Init",
"initializes",
"Consul",
"plugin",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/consul/plugin.go#L62-L91 |
4,734 | ligato/cn-infra | db/keyval/consul/plugin.go | ConfigToClient | func ConfigToClient(cfg *Config) (*api.Config, error) {
clientCfg := api.DefaultConfig()
if cfg.Address != "" {
clientCfg.Address = cfg.Address
}
return clientCfg, nil
} | go | func ConfigToClient(cfg *Config) (*api.Config, error) {
clientCfg := api.DefaultConfig()
if cfg.Address != "" {
clientCfg.Address = cfg.Address
}
return clientCfg, nil
} | [
"func",
"ConfigToClient",
"(",
"cfg",
"*",
"Config",
")",
"(",
"*",
"api",
".",
"Config",
",",
"error",
")",
"{",
"clientCfg",
":=",
"api",
".",
"DefaultConfig",
"(",
")",
"\n",
"if",
"cfg",
".",
"Address",
"!=",
"\"",
"\"",
"{",
"clientCfg",
".",
... | // ConfigToClient transforms Config into api.Config,
// which is ready for use with underlying consul package. | [
"ConfigToClient",
"transforms",
"Config",
"into",
"api",
".",
"Config",
"which",
"is",
"ready",
"for",
"use",
"with",
"underlying",
"consul",
"package",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/consul/plugin.go#L146-L152 |
4,735 | ligato/cn-infra | idxmap/chan.go | ToChan | func ToChan(ch chan NamedMappingGenericEvent, opts ...interface{}) func(dto NamedMappingGenericEvent) {
timeout := DefaultNotifTimeout
var logger logging.Logger = logrus.DefaultLogger()
/*for _, opt := range opts {
switch opt.(type) {
case *core.WithLoggerOpt:
logger = opt.(*core.WithLoggerOpt).Logger
case *core.WithTimeoutOpt:
timeout = opt.(*core.WithTimeoutOpt).Timeout
}
}*/
return func(dto NamedMappingGenericEvent) {
select {
case ch <- dto:
case <-time.After(timeout):
logger.Warn("Unable to deliver notification")
}
}
} | go | func ToChan(ch chan NamedMappingGenericEvent, opts ...interface{}) func(dto NamedMappingGenericEvent) {
timeout := DefaultNotifTimeout
var logger logging.Logger = logrus.DefaultLogger()
/*for _, opt := range opts {
switch opt.(type) {
case *core.WithLoggerOpt:
logger = opt.(*core.WithLoggerOpt).Logger
case *core.WithTimeoutOpt:
timeout = opt.(*core.WithTimeoutOpt).Timeout
}
}*/
return func(dto NamedMappingGenericEvent) {
select {
case ch <- dto:
case <-time.After(timeout):
logger.Warn("Unable to deliver notification")
}
}
} | [
"func",
"ToChan",
"(",
"ch",
"chan",
"NamedMappingGenericEvent",
",",
"opts",
"...",
"interface",
"{",
"}",
")",
"func",
"(",
"dto",
"NamedMappingGenericEvent",
")",
"{",
"timeout",
":=",
"DefaultNotifTimeout",
"\n",
"var",
"logger",
"logging",
".",
"Logger",
... | // ToChan creates a callback that can be passed to the Watch function
// in order to receive notifications through a channel. If the notification
// can not be delivered until timeout, it is dropped. | [
"ToChan",
"creates",
"a",
"callback",
"that",
"can",
"be",
"passed",
"to",
"the",
"Watch",
"function",
"in",
"order",
"to",
"receive",
"notifications",
"through",
"a",
"channel",
".",
"If",
"the",
"notification",
"can",
"not",
"be",
"delivered",
"until",
"ti... | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/idxmap/chan.go#L30-L51 |
4,736 | ligato/cn-infra | examples/tutorials/02_plugin-deps/main.go | NewHelloWorld | func NewHelloWorld() *HelloWorld {
// Create new instance.
p := new(HelloWorld)
// Set the plugin name.
p.SetName("helloworld")
// Initialize essential plugin deps: logger and config.
p.Setup()
return p
} | go | func NewHelloWorld() *HelloWorld {
// Create new instance.
p := new(HelloWorld)
// Set the plugin name.
p.SetName("helloworld")
// Initialize essential plugin deps: logger and config.
p.Setup()
return p
} | [
"func",
"NewHelloWorld",
"(",
")",
"*",
"HelloWorld",
"{",
"// Create new instance.",
"p",
":=",
"new",
"(",
"HelloWorld",
")",
"\n",
"// Set the plugin name.",
"p",
".",
"SetName",
"(",
"\"",
"\"",
")",
"\n",
"// Initialize essential plugin deps: logger and config.",... | // NewHelloWorld is a constructor for our HelloWorld plugin. | [
"NewHelloWorld",
"is",
"a",
"constructor",
"for",
"our",
"HelloWorld",
"plugin",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/tutorials/02_plugin-deps/main.go#L44-L52 |
4,737 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | NewMultiplexer | func NewMultiplexer(consumerFactory ConsumerFactory, producers multiplexerProducers, clientCfg *client.Config,
name string, log logging.Logger) *Multiplexer {
if clientCfg.Logger == nil {
clientCfg.Logger = log
}
cl := &Multiplexer{consumerFactory: consumerFactory,
Logger: log,
name: name,
mapping: []*consumerSubscription{},
multiplexerProducers: producers,
config: clientCfg,
}
go cl.watchAsyncProducerChannels()
if producers.manAsyncProducer != nil && producers.manAsyncProducer.Config != nil {
go cl.watchManualAsyncProducerChannels()
}
return cl
} | go | func NewMultiplexer(consumerFactory ConsumerFactory, producers multiplexerProducers, clientCfg *client.Config,
name string, log logging.Logger) *Multiplexer {
if clientCfg.Logger == nil {
clientCfg.Logger = log
}
cl := &Multiplexer{consumerFactory: consumerFactory,
Logger: log,
name: name,
mapping: []*consumerSubscription{},
multiplexerProducers: producers,
config: clientCfg,
}
go cl.watchAsyncProducerChannels()
if producers.manAsyncProducer != nil && producers.manAsyncProducer.Config != nil {
go cl.watchManualAsyncProducerChannels()
}
return cl
} | [
"func",
"NewMultiplexer",
"(",
"consumerFactory",
"ConsumerFactory",
",",
"producers",
"multiplexerProducers",
",",
"clientCfg",
"*",
"client",
".",
"Config",
",",
"name",
"string",
",",
"log",
"logging",
".",
"Logger",
")",
"*",
"Multiplexer",
"{",
"if",
"clien... | // NewMultiplexer creates new instance of Kafka Multiplexer | [
"NewMultiplexer",
"creates",
"new",
"instance",
"of",
"Kafka",
"Multiplexer"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L92-L110 |
4,738 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | Start | func (mux *Multiplexer) Start() error {
mux.rwlock.Lock()
defer mux.rwlock.Unlock()
var err error
if mux.started {
return fmt.Errorf("multiplexer has been started already")
}
// block further Consumer consumers
mux.started = true
var hashTopics, manTopics []string
for _, subscription := range mux.mapping {
if subscription.manual {
manTopics = append(manTopics, subscription.topic)
continue
}
hashTopics = append(hashTopics, subscription.topic)
}
mux.config.SetRecvMessageChan(make(chan *client.ConsumerMessage))
mux.config.GroupID = mux.name
mux.config.SetInitialOffset(sarama.OffsetOldest)
mux.config.Topics = append(hashTopics, manTopics...)
// create consumer
mux.WithFields(logging.Fields{"hashTopics": hashTopics, "manualTopics": manTopics}).Debugf("Consuming started")
mux.Consumer, err = client.NewConsumer(mux.config, nil)
if err != nil {
return err
}
if len(hashTopics) == 0 {
mux.Debug("No topics for hash partitioner")
} else {
mux.WithFields(logging.Fields{"topics": hashTopics}).Debugf("Consuming (hash) started")
mux.Consumer.StartConsumerHandlers()
}
if len(manTopics) == 0 {
mux.Debug("No topics for manual partitioner")
} else {
mux.WithFields(logging.Fields{"topics": manTopics}).Debugf("Consuming (manual) started")
for _, sub := range mux.mapping {
if sub.manual {
sConsumer := mux.Consumer.SConsumer
if sConsumer == nil {
return fmt.Errorf("consumer for manual partition is not available")
}
partitionConsumer, err := sConsumer.ConsumePartition(sub.topic, sub.partition, sub.offset)
if err != nil {
return err
}
// Store partition consumer in subscription so it can be closed lately
sub.partitionConsumer = &partitionConsumer
mux.Logger.WithFields(logging.Fields{"topic": sub.topic, "partition": sub.partition, "offset": sub.offset}).Info("Partition sConsumer started")
mux.Consumer.StartConsumerManualHandlers(partitionConsumer)
}
}
}
go mux.genericConsumer()
go mux.manualConsumer(mux.Consumer)
return err
} | go | func (mux *Multiplexer) Start() error {
mux.rwlock.Lock()
defer mux.rwlock.Unlock()
var err error
if mux.started {
return fmt.Errorf("multiplexer has been started already")
}
// block further Consumer consumers
mux.started = true
var hashTopics, manTopics []string
for _, subscription := range mux.mapping {
if subscription.manual {
manTopics = append(manTopics, subscription.topic)
continue
}
hashTopics = append(hashTopics, subscription.topic)
}
mux.config.SetRecvMessageChan(make(chan *client.ConsumerMessage))
mux.config.GroupID = mux.name
mux.config.SetInitialOffset(sarama.OffsetOldest)
mux.config.Topics = append(hashTopics, manTopics...)
// create consumer
mux.WithFields(logging.Fields{"hashTopics": hashTopics, "manualTopics": manTopics}).Debugf("Consuming started")
mux.Consumer, err = client.NewConsumer(mux.config, nil)
if err != nil {
return err
}
if len(hashTopics) == 0 {
mux.Debug("No topics for hash partitioner")
} else {
mux.WithFields(logging.Fields{"topics": hashTopics}).Debugf("Consuming (hash) started")
mux.Consumer.StartConsumerHandlers()
}
if len(manTopics) == 0 {
mux.Debug("No topics for manual partitioner")
} else {
mux.WithFields(logging.Fields{"topics": manTopics}).Debugf("Consuming (manual) started")
for _, sub := range mux.mapping {
if sub.manual {
sConsumer := mux.Consumer.SConsumer
if sConsumer == nil {
return fmt.Errorf("consumer for manual partition is not available")
}
partitionConsumer, err := sConsumer.ConsumePartition(sub.topic, sub.partition, sub.offset)
if err != nil {
return err
}
// Store partition consumer in subscription so it can be closed lately
sub.partitionConsumer = &partitionConsumer
mux.Logger.WithFields(logging.Fields{"topic": sub.topic, "partition": sub.partition, "offset": sub.offset}).Info("Partition sConsumer started")
mux.Consumer.StartConsumerManualHandlers(partitionConsumer)
}
}
}
go mux.genericConsumer()
go mux.manualConsumer(mux.Consumer)
return err
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"Start",
"(",
")",
"error",
"{",
"mux",
".",
"rwlock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mux",
".",
"rwlock",
".",
"Unlock",
"(",
")",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"mux",
".",
"start... | // Start should be called once all the Connections have been subscribed
// for topic consumption. An attempt to start consuming a topic after the multiplexer is started
// returns an error. | [
"Start",
"should",
"be",
"called",
"once",
"all",
"the",
"Connections",
"have",
"been",
"subscribed",
"for",
"topic",
"consumption",
".",
"An",
"attempt",
"to",
"start",
"consuming",
"a",
"topic",
"after",
"the",
"multiplexer",
"is",
"started",
"returns",
"an"... | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L162-L230 |
4,739 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | Close | func (mux *Multiplexer) Close() {
safeclose.Close(
mux.Consumer,
mux.hashSyncProducer,
mux.hashAsyncProducer,
mux.manSyncProducer,
mux.manAsyncProducer)
} | go | func (mux *Multiplexer) Close() {
safeclose.Close(
mux.Consumer,
mux.hashSyncProducer,
mux.hashAsyncProducer,
mux.manSyncProducer,
mux.manAsyncProducer)
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"Close",
"(",
")",
"{",
"safeclose",
".",
"Close",
"(",
"mux",
".",
"Consumer",
",",
"mux",
".",
"hashSyncProducer",
",",
"mux",
".",
"hashAsyncProducer",
",",
"mux",
".",
"manSyncProducer",
",",
"mux",
".",
... | // Close cleans up the resources used by the Multiplexer | [
"Close",
"cleans",
"up",
"the",
"resources",
"used",
"by",
"the",
"Multiplexer"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L233-L240 |
4,740 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | NewBytesConnection | func (mux *Multiplexer) NewBytesConnection(name string) *BytesConnectionStr {
return &BytesConnectionStr{BytesConnectionFields{multiplexer: mux, name: name}}
} | go | func (mux *Multiplexer) NewBytesConnection(name string) *BytesConnectionStr {
return &BytesConnectionStr{BytesConnectionFields{multiplexer: mux, name: name}}
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"NewBytesConnection",
"(",
"name",
"string",
")",
"*",
"BytesConnectionStr",
"{",
"return",
"&",
"BytesConnectionStr",
"{",
"BytesConnectionFields",
"{",
"multiplexer",
":",
"mux",
",",
"name",
":",
"name",
"}",
"}"... | // NewBytesConnection creates instance of the BytesConnectionStr that provides access to shared
// Multiplexer's clients with hash partitioner. | [
"NewBytesConnection",
"creates",
"instance",
"of",
"the",
"BytesConnectionStr",
"that",
"provides",
"access",
"to",
"shared",
"Multiplexer",
"s",
"clients",
"with",
"hash",
"partitioner",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L244-L246 |
4,741 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | NewBytesManualConnection | func (mux *Multiplexer) NewBytesManualConnection(name string) *BytesManualConnectionStr {
return &BytesManualConnectionStr{BytesConnectionFields{multiplexer: mux, name: name}}
} | go | func (mux *Multiplexer) NewBytesManualConnection(name string) *BytesManualConnectionStr {
return &BytesManualConnectionStr{BytesConnectionFields{multiplexer: mux, name: name}}
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"NewBytesManualConnection",
"(",
"name",
"string",
")",
"*",
"BytesManualConnectionStr",
"{",
"return",
"&",
"BytesManualConnectionStr",
"{",
"BytesConnectionFields",
"{",
"multiplexer",
":",
"mux",
",",
"name",
":",
"n... | // NewBytesManualConnection creates instance of the BytesManualConnectionStr that provides access to shared
// Multiplexer's clients with manual partitioner. | [
"NewBytesManualConnection",
"creates",
"instance",
"of",
"the",
"BytesManualConnectionStr",
"that",
"provides",
"access",
"to",
"shared",
"Multiplexer",
"s",
"clients",
"with",
"manual",
"partitioner",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L250-L252 |
4,742 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | NewProtoConnection | func (mux *Multiplexer) NewProtoConnection(name string, serializer keyval.Serializer) *ProtoConnection {
return &ProtoConnection{ProtoConnectionFields{multiplexer: mux, serializer: serializer, name: name}}
} | go | func (mux *Multiplexer) NewProtoConnection(name string, serializer keyval.Serializer) *ProtoConnection {
return &ProtoConnection{ProtoConnectionFields{multiplexer: mux, serializer: serializer, name: name}}
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"NewProtoConnection",
"(",
"name",
"string",
",",
"serializer",
"keyval",
".",
"Serializer",
")",
"*",
"ProtoConnection",
"{",
"return",
"&",
"ProtoConnection",
"{",
"ProtoConnectionFields",
"{",
"multiplexer",
":",
"... | // NewProtoConnection creates instance of the ProtoConnection that provides access to shared
// Multiplexer's clients with hash partitioner. | [
"NewProtoConnection",
"creates",
"instance",
"of",
"the",
"ProtoConnection",
"that",
"provides",
"access",
"to",
"shared",
"Multiplexer",
"s",
"clients",
"with",
"hash",
"partitioner",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L256-L258 |
4,743 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | NewProtoManualConnection | func (mux *Multiplexer) NewProtoManualConnection(name string, serializer keyval.Serializer) *ProtoManualConnection {
return &ProtoManualConnection{ProtoConnectionFields{multiplexer: mux, serializer: serializer, name: name}}
} | go | func (mux *Multiplexer) NewProtoManualConnection(name string, serializer keyval.Serializer) *ProtoManualConnection {
return &ProtoManualConnection{ProtoConnectionFields{multiplexer: mux, serializer: serializer, name: name}}
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"NewProtoManualConnection",
"(",
"name",
"string",
",",
"serializer",
"keyval",
".",
"Serializer",
")",
"*",
"ProtoManualConnection",
"{",
"return",
"&",
"ProtoManualConnection",
"{",
"ProtoConnectionFields",
"{",
"multip... | // NewProtoManualConnection creates instance of the ProtoConnectionFields that provides access to shared
// Multiplexer's clients with manual partitioner. | [
"NewProtoManualConnection",
"creates",
"instance",
"of",
"the",
"ProtoConnectionFields",
"that",
"provides",
"access",
"to",
"shared",
"Multiplexer",
"s",
"clients",
"with",
"manual",
"partitioner",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L262-L264 |
4,744 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | propagateMessage | func (mux *Multiplexer) propagateMessage(msg *client.ConsumerMessage) {
mux.rwlock.RLock()
defer mux.rwlock.RUnlock()
if msg == nil {
return
}
// Find subscribed topics. Note: topic can be subscribed for both dynamic and manual consuming
for _, subscription := range mux.mapping {
if msg.Topic == subscription.topic {
// Clustered mode - message is consumed only on right partition and offset
if subscription.manual {
if msg.Partition == subscription.partition && msg.Offset >= subscription.offset {
mux.Debug("offset ", msg.Offset, string(msg.Value), string(msg.Key), msg.Partition)
subscription.byteConsMsg(msg)
}
} else {
// Non-manual mode
// if we are not able to write into the channel we should skip the receiver
// and report an error to avoid deadlock
mux.Debug("offset ", msg.Offset, string(msg.Value), string(msg.Key), msg.Partition)
subscription.byteConsMsg(msg)
}
}
}
} | go | func (mux *Multiplexer) propagateMessage(msg *client.ConsumerMessage) {
mux.rwlock.RLock()
defer mux.rwlock.RUnlock()
if msg == nil {
return
}
// Find subscribed topics. Note: topic can be subscribed for both dynamic and manual consuming
for _, subscription := range mux.mapping {
if msg.Topic == subscription.topic {
// Clustered mode - message is consumed only on right partition and offset
if subscription.manual {
if msg.Partition == subscription.partition && msg.Offset >= subscription.offset {
mux.Debug("offset ", msg.Offset, string(msg.Value), string(msg.Key), msg.Partition)
subscription.byteConsMsg(msg)
}
} else {
// Non-manual mode
// if we are not able to write into the channel we should skip the receiver
// and report an error to avoid deadlock
mux.Debug("offset ", msg.Offset, string(msg.Value), string(msg.Key), msg.Partition)
subscription.byteConsMsg(msg)
}
}
}
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"propagateMessage",
"(",
"msg",
"*",
"client",
".",
"ConsumerMessage",
")",
"{",
"mux",
".",
"rwlock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"mux",
".",
"rwlock",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"... | // Propagates incoming messages to respective channels. | [
"Propagates",
"incoming",
"messages",
"to",
"respective",
"channels",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L267-L293 |
4,745 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | genericConsumer | func (mux *Multiplexer) genericConsumer() {
mux.Debug("Generic Consumer started")
for {
select {
case <-mux.Consumer.GetCloseChannel():
mux.Debug("Closing Consumer")
return
case msg := <-mux.Consumer.Config.RecvMessageChan:
// 'hash' partitioner messages will be marked
mux.propagateMessage(msg)
case err := <-mux.Consumer.Config.RecvErrorChan:
mux.Error("Received partitionConsumer error ", err)
}
}
} | go | func (mux *Multiplexer) genericConsumer() {
mux.Debug("Generic Consumer started")
for {
select {
case <-mux.Consumer.GetCloseChannel():
mux.Debug("Closing Consumer")
return
case msg := <-mux.Consumer.Config.RecvMessageChan:
// 'hash' partitioner messages will be marked
mux.propagateMessage(msg)
case err := <-mux.Consumer.Config.RecvErrorChan:
mux.Error("Received partitionConsumer error ", err)
}
}
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"genericConsumer",
"(",
")",
"{",
"mux",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"mux",
".",
"Consumer",
".",
"GetCloseChannel",
"(",
")",
":",
"mux",
".",
"Deb... | // genericConsumer handles incoming messages to the multiplexer and distributes them among the subscribers. | [
"genericConsumer",
"handles",
"incoming",
"messages",
"to",
"the",
"multiplexer",
"and",
"distributes",
"them",
"among",
"the",
"subscribers",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L296-L310 |
4,746 | ligato/cn-infra | messaging/kafka/mux/multiplexer.go | stopConsuming | func (mux *Multiplexer) stopConsuming(topic string, name string) error {
mux.rwlock.Lock()
defer mux.rwlock.Unlock()
var wasError error
var topicFound bool
for index, subs := range mux.mapping {
if !subs.manual && subs.topic == topic && subs.connectionName == name {
topicFound = true
mux.mapping = append(mux.mapping[:index], mux.mapping[index+1:]...)
}
}
if !topicFound {
wasError = fmt.Errorf("topic %s was not consumed by '%s'", topic, name)
}
return wasError
} | go | func (mux *Multiplexer) stopConsuming(topic string, name string) error {
mux.rwlock.Lock()
defer mux.rwlock.Unlock()
var wasError error
var topicFound bool
for index, subs := range mux.mapping {
if !subs.manual && subs.topic == topic && subs.connectionName == name {
topicFound = true
mux.mapping = append(mux.mapping[:index], mux.mapping[index+1:]...)
}
}
if !topicFound {
wasError = fmt.Errorf("topic %s was not consumed by '%s'", topic, name)
}
return wasError
} | [
"func",
"(",
"mux",
"*",
"Multiplexer",
")",
"stopConsuming",
"(",
"topic",
"string",
",",
"name",
"string",
")",
"error",
"{",
"mux",
".",
"rwlock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mux",
".",
"rwlock",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
... | // Remove consumer subscription on given topic. If there is no such a subscription, return error. | [
"Remove",
"consumer",
"subscription",
"on",
"given",
"topic",
".",
"If",
"there",
"is",
"no",
"such",
"a",
"subscription",
"return",
"error",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/multiplexer.go#L331-L347 |
4,747 | ligato/cn-infra | examples/kafka-plugin/hash-partitioner/main.go | asyncEventHandler | func (plugin *ExamplePlugin) asyncEventHandler() {
plugin.Log.Info("Started Kafka async event handler...")
msgCounter := 0
asyncMsgSucc := 0
if messageCountNum == 0 {
// Set as done
plugin.asyncSuccess = true
plugin.asyncRecv = true
}
for {
select {
// Channel subscribed with watcher
case message := <-plugin.asyncSubscription:
plugin.Log.Infof("Received async Kafka Message, topic '%s', partition '%v', offset '%v', key: '%s', ",
message.GetTopic(), message.GetPartition(), message.GetOffset(), message.GetKey())
// mark the offset
plugin.kafkaWatcher.MarkOffset(message, "")
msgCounter++
if msgCounter == messageCountNum {
plugin.asyncRecv = true
}
case message := <-plugin.asyncSuccessChannel:
plugin.Log.Infof("Async message successfully delivered, topic '%s', partition '%v', offset '%v', key: '%s', ",
message.GetTopic(), message.GetPartition(), message.GetOffset(), message.GetKey())
asyncMsgSucc++
if asyncMsgSucc == messageCountNum {
plugin.asyncSuccess = true
}
// Error callback channel
case err := <-plugin.asyncErrorChannel:
plugin.Log.Errorf("Failed to publish async message, %v", err)
}
}
} | go | func (plugin *ExamplePlugin) asyncEventHandler() {
plugin.Log.Info("Started Kafka async event handler...")
msgCounter := 0
asyncMsgSucc := 0
if messageCountNum == 0 {
// Set as done
plugin.asyncSuccess = true
plugin.asyncRecv = true
}
for {
select {
// Channel subscribed with watcher
case message := <-plugin.asyncSubscription:
plugin.Log.Infof("Received async Kafka Message, topic '%s', partition '%v', offset '%v', key: '%s', ",
message.GetTopic(), message.GetPartition(), message.GetOffset(), message.GetKey())
// mark the offset
plugin.kafkaWatcher.MarkOffset(message, "")
msgCounter++
if msgCounter == messageCountNum {
plugin.asyncRecv = true
}
case message := <-plugin.asyncSuccessChannel:
plugin.Log.Infof("Async message successfully delivered, topic '%s', partition '%v', offset '%v', key: '%s', ",
message.GetTopic(), message.GetPartition(), message.GetOffset(), message.GetKey())
asyncMsgSucc++
if asyncMsgSucc == messageCountNum {
plugin.asyncSuccess = true
}
// Error callback channel
case err := <-plugin.asyncErrorChannel:
plugin.Log.Errorf("Failed to publish async message, %v", err)
}
}
} | [
"func",
"(",
"plugin",
"*",
"ExamplePlugin",
")",
"asyncEventHandler",
"(",
")",
"{",
"plugin",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"msgCounter",
":=",
"0",
"\n",
"asyncMsgSucc",
":=",
"0",
"\n",
"if",
"messageCountNum",
"==",
"0",
"{"... | // asyncEventHandler is a Kafka consumer asynchronously processing events from
// a channel associated with a specific topic. If a producer sends a message
// matching this destination criteria, the consumer will receive it. | [
"asyncEventHandler",
"is",
"a",
"Kafka",
"consumer",
"asynchronously",
"processing",
"events",
"from",
"a",
"channel",
"associated",
"with",
"a",
"specific",
"topic",
".",
"If",
"a",
"producer",
"sends",
"a",
"message",
"matching",
"this",
"destination",
"criteria... | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/kafka-plugin/hash-partitioner/main.go#L280-L313 |
4,748 | ligato/cn-infra | rpc/rest/options.go | UseAuthenticator | func UseAuthenticator(a BasicHTTPAuthenticator) Option {
return func(p *Plugin) {
p.Deps.Authenticator = a
}
} | go | func UseAuthenticator(a BasicHTTPAuthenticator) Option {
return func(p *Plugin) {
p.Deps.Authenticator = a
}
} | [
"func",
"UseAuthenticator",
"(",
"a",
"BasicHTTPAuthenticator",
")",
"Option",
"{",
"return",
"func",
"(",
"p",
"*",
"Plugin",
")",
"{",
"p",
".",
"Deps",
".",
"Authenticator",
"=",
"a",
"\n",
"}",
"\n",
"}"
] | // UseAuthenticator returns an Option which sets HTTP Authenticator. | [
"UseAuthenticator",
"returns",
"an",
"Option",
"which",
"sets",
"HTTP",
"Authenticator",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/rpc/rest/options.go#L69-L73 |
4,749 | ligato/cn-infra | db/keyval/etcd/plugin_impl_etcd.go | AfterInit | func (p *Plugin) AfterInit() error {
if p.StatusCheck != nil && !p.disabled {
p.StatusCheck.Register(p.PluginName, p.statusCheckProbe)
p.Log.Infof("Status check for %s was started", p.PluginName)
}
return nil
} | go | func (p *Plugin) AfterInit() error {
if p.StatusCheck != nil && !p.disabled {
p.StatusCheck.Register(p.PluginName, p.statusCheckProbe)
p.Log.Infof("Status check for %s was started", p.PluginName)
}
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"AfterInit",
"(",
")",
"error",
"{",
"if",
"p",
".",
"StatusCheck",
"!=",
"nil",
"&&",
"!",
"p",
".",
"disabled",
"{",
"p",
".",
"StatusCheck",
".",
"Register",
"(",
"p",
".",
"PluginName",
",",
"p",
".",
"st... | // AfterInit registers ETCD plugin to status check if needed | [
"AfterInit",
"registers",
"ETCD",
"plugin",
"to",
"status",
"check",
"if",
"needed"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/etcd/plugin_impl_etcd.go#L117-L124 |
4,750 | ligato/cn-infra | db/keyval/etcd/plugin_impl_etcd.go | OnConnect | func (p *Plugin) OnConnect(callback func() error) {
p.Lock()
defer p.Unlock()
if p.connected {
if err := callback(); err != nil {
p.Log.Errorf("callback for OnConnect failed: %v", err)
}
} else {
p.onConnection = append(p.onConnection, callback)
}
} | go | func (p *Plugin) OnConnect(callback func() error) {
p.Lock()
defer p.Unlock()
if p.connected {
if err := callback(); err != nil {
p.Log.Errorf("callback for OnConnect failed: %v", err)
}
} else {
p.onConnection = append(p.onConnection, callback)
}
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"OnConnect",
"(",
"callback",
"func",
"(",
")",
"error",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"p",
".",
"connected",
"{",
"if",
"err",
":=",
"call... | // OnConnect executes callback if plugin is connected, or gathers functions from all plugin with ETCD as dependency | [
"OnConnect",
"executes",
"callback",
"if",
"plugin",
"is",
"connected",
"or",
"gathers",
"functions",
"from",
"all",
"plugin",
"with",
"ETCD",
"as",
"dependency"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/etcd/plugin_impl_etcd.go#L148-L159 |
4,751 | ligato/cn-infra | db/keyval/etcd/plugin_impl_etcd.go | Compact | func (p *Plugin) Compact(rev ...int64) (toRev int64, err error) {
if p.connection != nil {
return p.connection.Compact(rev...)
}
return 0, fmt.Errorf("connection is not established")
} | go | func (p *Plugin) Compact(rev ...int64) (toRev int64, err error) {
if p.connection != nil {
return p.connection.Compact(rev...)
}
return 0, fmt.Errorf("connection is not established")
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"Compact",
"(",
"rev",
"...",
"int64",
")",
"(",
"toRev",
"int64",
",",
"err",
"error",
")",
"{",
"if",
"p",
".",
"connection",
"!=",
"nil",
"{",
"return",
"p",
".",
"connection",
".",
"Compact",
"(",
"rev",
... | // Compact compatcs the ETCD database to the specific revision | [
"Compact",
"compatcs",
"the",
"ETCD",
"database",
"to",
"the",
"specific",
"revision"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/etcd/plugin_impl_etcd.go#L176-L181 |
4,752 | ligato/cn-infra | db/keyval/etcd/plugin_impl_etcd.go | etcdReconnectionLoop | func (p *Plugin) etcdReconnectionLoop(clientCfg *ClientConfig) {
var err error
// Set reconnect interval
interval := p.config.ReconnectInterval
if interval == 0 {
interval = defaultReconnectInterval
}
p.Log.Infof("ETCD server %s not reachable in init phase. Agent will continue to try to connect every %d second(s)",
p.config.Endpoints, interval)
for {
time.Sleep(interval)
p.Log.Infof("Connecting to ETCD %v ...", p.config.Endpoints)
p.connection, err = NewEtcdConnectionWithBytes(*clientCfg, p.Log)
if err != nil {
continue
}
p.setupPostInitConnection()
return
}
} | go | func (p *Plugin) etcdReconnectionLoop(clientCfg *ClientConfig) {
var err error
// Set reconnect interval
interval := p.config.ReconnectInterval
if interval == 0 {
interval = defaultReconnectInterval
}
p.Log.Infof("ETCD server %s not reachable in init phase. Agent will continue to try to connect every %d second(s)",
p.config.Endpoints, interval)
for {
time.Sleep(interval)
p.Log.Infof("Connecting to ETCD %v ...", p.config.Endpoints)
p.connection, err = NewEtcdConnectionWithBytes(*clientCfg, p.Log)
if err != nil {
continue
}
p.setupPostInitConnection()
return
}
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"etcdReconnectionLoop",
"(",
"clientCfg",
"*",
"ClientConfig",
")",
"{",
"var",
"err",
"error",
"\n",
"// Set reconnect interval",
"interval",
":=",
"p",
".",
"config",
".",
"ReconnectInterval",
"\n",
"if",
"interval",
"==... | // Method starts loop which attempt to connect to the ETCD. If successful, send signal callback with resync,
// which will be started when datasync confirms successful registration | [
"Method",
"starts",
"loop",
"which",
"attempt",
"to",
"connect",
"to",
"the",
"ETCD",
".",
"If",
"successful",
"send",
"signal",
"callback",
"with",
"resync",
"which",
"will",
"be",
"started",
"when",
"datasync",
"confirms",
"successful",
"registration"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/etcd/plugin_impl_etcd.go#L185-L205 |
4,753 | ligato/cn-infra | db/keyval/etcd/plugin_impl_etcd.go | configureConnection | func (p *Plugin) configureConnection() {
if p.config.AutoCompact > 0 {
if p.config.AutoCompact < time.Duration(time.Minute*60) {
p.Log.Warnf("Auto compact option for ETCD is set to less than 60 minutes!")
}
p.startPeriodicAutoCompact(p.config.AutoCompact)
}
p.protoWrapper = kvproto.NewProtoWrapper(p.connection, &keyval.SerializerJSON{})
} | go | func (p *Plugin) configureConnection() {
if p.config.AutoCompact > 0 {
if p.config.AutoCompact < time.Duration(time.Minute*60) {
p.Log.Warnf("Auto compact option for ETCD is set to less than 60 minutes!")
}
p.startPeriodicAutoCompact(p.config.AutoCompact)
}
p.protoWrapper = kvproto.NewProtoWrapper(p.connection, &keyval.SerializerJSON{})
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"configureConnection",
"(",
")",
"{",
"if",
"p",
".",
"config",
".",
"AutoCompact",
">",
"0",
"{",
"if",
"p",
".",
"config",
".",
"AutoCompact",
"<",
"time",
".",
"Duration",
"(",
"time",
".",
"Minute",
"*",
"6... | // If ETCD is connected, complete all other procedures | [
"If",
"ETCD",
"is",
"connected",
"complete",
"all",
"other",
"procedures"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/etcd/plugin_impl_etcd.go#L232-L240 |
4,754 | ligato/cn-infra | db/keyval/etcd/plugin_impl_etcd.go | statusCheckProbe | func (p *Plugin) statusCheckProbe() (statuscheck.PluginState, error) {
if p.connection == nil {
p.connected = false
return statuscheck.Error, fmt.Errorf("no ETCD connection available")
}
if _, _, _, err := p.connection.GetValue(healthCheckProbeKey); err != nil {
p.lastConnErr = err
p.connected = false
return statuscheck.Error, err
}
if p.config.ReconnectResync && p.lastConnErr != nil {
if p.Resync != nil {
p.Resync.DoResync()
p.lastConnErr = nil
} else {
p.Log.Warn("Expected resync after ETCD reconnect could not start beacuse of missing Resync plugin")
}
}
p.connected = true
return statuscheck.OK, nil
} | go | func (p *Plugin) statusCheckProbe() (statuscheck.PluginState, error) {
if p.connection == nil {
p.connected = false
return statuscheck.Error, fmt.Errorf("no ETCD connection available")
}
if _, _, _, err := p.connection.GetValue(healthCheckProbeKey); err != nil {
p.lastConnErr = err
p.connected = false
return statuscheck.Error, err
}
if p.config.ReconnectResync && p.lastConnErr != nil {
if p.Resync != nil {
p.Resync.DoResync()
p.lastConnErr = nil
} else {
p.Log.Warn("Expected resync after ETCD reconnect could not start beacuse of missing Resync plugin")
}
}
p.connected = true
return statuscheck.OK, nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"statusCheckProbe",
"(",
")",
"(",
"statuscheck",
".",
"PluginState",
",",
"error",
")",
"{",
"if",
"p",
".",
"connection",
"==",
"nil",
"{",
"p",
".",
"connected",
"=",
"false",
"\n",
"return",
"statuscheck",
".",... | // ETCD status check probe function | [
"ETCD",
"status",
"check",
"probe",
"function"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/etcd/plugin_impl_etcd.go#L243-L263 |
4,755 | ligato/cn-infra | messaging/kafka/client/mocks.go | GetAsyncProducerMock | func GetAsyncProducerMock(t mocks.ErrorReporter) (*AsyncProducer, *mocks.AsyncProducer) {
saramaCfg := sarama.NewConfig()
saramaCfg.Producer.Return.Successes = true
mock := mocks.NewAsyncProducer(t, saramaCfg)
cfg := NewConfig(logrus.DefaultLogger())
cfg.SetSendSuccess(true)
cfg.SetSuccessChan(make(chan *ProducerMessage, 1))
ap := AsyncProducer{Logger: logrus.DefaultLogger(), Config: cfg, Producer: mock, closeChannel: make(chan struct{}), Client: &saramaClientMock{}}
go ap.successHandler(mock.Successes())
return &ap, mock
} | go | func GetAsyncProducerMock(t mocks.ErrorReporter) (*AsyncProducer, *mocks.AsyncProducer) {
saramaCfg := sarama.NewConfig()
saramaCfg.Producer.Return.Successes = true
mock := mocks.NewAsyncProducer(t, saramaCfg)
cfg := NewConfig(logrus.DefaultLogger())
cfg.SetSendSuccess(true)
cfg.SetSuccessChan(make(chan *ProducerMessage, 1))
ap := AsyncProducer{Logger: logrus.DefaultLogger(), Config: cfg, Producer: mock, closeChannel: make(chan struct{}), Client: &saramaClientMock{}}
go ap.successHandler(mock.Successes())
return &ap, mock
} | [
"func",
"GetAsyncProducerMock",
"(",
"t",
"mocks",
".",
"ErrorReporter",
")",
"(",
"*",
"AsyncProducer",
",",
"*",
"mocks",
".",
"AsyncProducer",
")",
"{",
"saramaCfg",
":=",
"sarama",
".",
"NewConfig",
"(",
")",
"\n",
"saramaCfg",
".",
"Producer",
".",
"R... | // GetAsyncProducerMock returns mocked implementation of async producer that doesn't
// need connection to Kafka broker and can be used for testing purposes. | [
"GetAsyncProducerMock",
"returns",
"mocked",
"implementation",
"of",
"async",
"producer",
"that",
"doesn",
"t",
"need",
"connection",
"to",
"Kafka",
"broker",
"and",
"can",
"be",
"used",
"for",
"testing",
"purposes",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/client/mocks.go#L36-L48 |
4,756 | ligato/cn-infra | messaging/kafka/client/mocks.go | GetSyncProducerMock | func GetSyncProducerMock(t mocks.ErrorReporter) (*SyncProducer, *mocks.SyncProducer) {
saramaCfg := sarama.NewConfig()
saramaCfg.Producer.Return.Successes = true
mock := mocks.NewSyncProducer(t, saramaCfg)
cfg := NewConfig(logrus.DefaultLogger())
ap := SyncProducer{Logger: logrus.DefaultLogger(), Config: cfg, Producer: mock, closeChannel: make(chan struct{}), Client: &saramaClientMock{}}
return &ap, mock
} | go | func GetSyncProducerMock(t mocks.ErrorReporter) (*SyncProducer, *mocks.SyncProducer) {
saramaCfg := sarama.NewConfig()
saramaCfg.Producer.Return.Successes = true
mock := mocks.NewSyncProducer(t, saramaCfg)
cfg := NewConfig(logrus.DefaultLogger())
ap := SyncProducer{Logger: logrus.DefaultLogger(), Config: cfg, Producer: mock, closeChannel: make(chan struct{}), Client: &saramaClientMock{}}
return &ap, mock
} | [
"func",
"GetSyncProducerMock",
"(",
"t",
"mocks",
".",
"ErrorReporter",
")",
"(",
"*",
"SyncProducer",
",",
"*",
"mocks",
".",
"SyncProducer",
")",
"{",
"saramaCfg",
":=",
"sarama",
".",
"NewConfig",
"(",
")",
"\n",
"saramaCfg",
".",
"Producer",
".",
"Retu... | // GetSyncProducerMock returns mocked implementation of sync producer that doesn't need
// connection to Kafka broker and can be used for testing purposes. | [
"GetSyncProducerMock",
"returns",
"mocked",
"implementation",
"of",
"sync",
"producer",
"that",
"doesn",
"t",
"need",
"connection",
"to",
"Kafka",
"broker",
"and",
"can",
"be",
"used",
"for",
"testing",
"purposes",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/client/mocks.go#L52-L61 |
4,757 | ligato/cn-infra | messaging/kafka/client/mocks.go | GetConsumerMock | func GetConsumerMock(t mocks.ErrorReporter) *Consumer {
cfg := NewConfig(logrus.DefaultLogger())
ap := Consumer{
Logger: logrus.DefaultLogger(),
Config: cfg,
Consumer: newClusterConsumerMock(t),
closeChannel: make(chan struct{}),
}
return &ap
} | go | func GetConsumerMock(t mocks.ErrorReporter) *Consumer {
cfg := NewConfig(logrus.DefaultLogger())
ap := Consumer{
Logger: logrus.DefaultLogger(),
Config: cfg,
Consumer: newClusterConsumerMock(t),
closeChannel: make(chan struct{}),
}
return &ap
} | [
"func",
"GetConsumerMock",
"(",
"t",
"mocks",
".",
"ErrorReporter",
")",
"*",
"Consumer",
"{",
"cfg",
":=",
"NewConfig",
"(",
"logrus",
".",
"DefaultLogger",
"(",
")",
")",
"\n",
"ap",
":=",
"Consumer",
"{",
"Logger",
":",
"logrus",
".",
"DefaultLogger",
... | // GetConsumerMock returns mocked implementation of consumer that doesn't need connection
// to kafka cluster. | [
"GetConsumerMock",
"returns",
"mocked",
"implementation",
"of",
"consumer",
"that",
"doesn",
"t",
"need",
"connection",
"to",
"kafka",
"cluster",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/client/mocks.go#L65-L75 |
4,758 | ligato/cn-infra | datasync/msgsync/plugin_impl_msgsync.go | AfterInit | func (p *Plugin) AfterInit() error {
if !p.Messaging.Disabled() {
cfg := p.Config
p.Cfg.LoadValue(&cfg)
if cfg.Topic != "" {
var err error
p.adapter, err = p.Messaging.NewSyncPublisher("msgsync-connection", cfg.Topic)
if err != nil {
return err
}
}
}
return nil
} | go | func (p *Plugin) AfterInit() error {
if !p.Messaging.Disabled() {
cfg := p.Config
p.Cfg.LoadValue(&cfg)
if cfg.Topic != "" {
var err error
p.adapter, err = p.Messaging.NewSyncPublisher("msgsync-connection", cfg.Topic)
if err != nil {
return err
}
}
}
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"AfterInit",
"(",
")",
"error",
"{",
"if",
"!",
"p",
".",
"Messaging",
".",
"Disabled",
"(",
")",
"{",
"cfg",
":=",
"p",
".",
"Config",
"\n",
"p",
".",
"Cfg",
".",
"LoadValue",
"(",
"&",
"cfg",
")",
"\n\n",... | // AfterInit uses provided MUX connection to build new publisher. | [
"AfterInit",
"uses",
"provided",
"MUX",
"connection",
"to",
"build",
"new",
"publisher",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/msgsync/plugin_impl_msgsync.go#L54-L69 |
4,759 | ligato/cn-infra | processmanager/process_impl.go | deleteProcess | func (p *Process) deleteProcess() error {
if p.command == nil || p.command.Process == nil {
return nil
}
// Close the process watcher
if p.cancelChan != nil {
close(p.cancelChan)
}
p.log.Debugf("Process %s deleted", p.name)
return nil
} | go | func (p *Process) deleteProcess() error {
if p.command == nil || p.command.Process == nil {
return nil
}
// Close the process watcher
if p.cancelChan != nil {
close(p.cancelChan)
}
p.log.Debugf("Process %s deleted", p.name)
return nil
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"deleteProcess",
"(",
")",
"error",
"{",
"if",
"p",
".",
"command",
"==",
"nil",
"||",
"p",
".",
"command",
".",
"Process",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Close the process watcher",
"if... | // Delete stops the process and internal watcher | [
"Delete",
"stops",
"the",
"process",
"and",
"internal",
"watcher"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/processmanager/process_impl.go#L162-L174 |
4,760 | ligato/cn-infra | processmanager/process_impl.go | watch | func (p *Process) watch() {
if p.isWatched {
p.log.Warnf("Process watcher already running")
return
}
p.log.Debugf("Process %s watcher started", p.name)
p.isWatched = true
ticker := time.NewTicker(1 * time.Second)
var last status.ProcessStatus
var numRestarts int32
var autoTerm bool
if p.options != nil {
numRestarts = p.options.restart
autoTerm = p.options.autoTerm
}
for {
select {
case <-ticker.C:
var current status.ProcessStatus
// skip initial status since the process is not running yet
if current == status.Initial {
continue
}
if !p.isAlive() {
current = status.Terminated
} else {
pStatus, err := p.GetStatus(p.GetPid())
if err != nil {
p.log.Warn(err)
}
if pStatus.State == "" {
current = status.Unavailable
} else {
current = pStatus.State
}
}
// identify status change
if current != last {
if p.GetNotificationChan() != nil {
p.options.notifyChan <- current
}
// handle automatic process restarts
if current == status.Terminated {
if numRestarts > 0 || numRestarts == infiniteRestarts {
go func() {
var err error
if p.command, err = p.startProcess(); err != nil {
p.log.Error("attempt to restart process %s failed: %v", p.name, err)
}
}()
numRestarts--
} else {
p.log.Debugf("no more attempts to restart process %s", p.name)
}
}
// handle automatic zombie process cleanup
if current == status.Zombie && autoTerm {
p.log.Debugf("Terminating zombie process %d", p.GetPid())
if _, err := p.Wait(); err != nil {
p.log.Warnf("failed to terminate dead process: %s", p.GetPid(), err)
}
}
}
last = current
case <-p.cancelChan:
ticker.Stop()
p.closeNotifyChan()
return
}
}
} | go | func (p *Process) watch() {
if p.isWatched {
p.log.Warnf("Process watcher already running")
return
}
p.log.Debugf("Process %s watcher started", p.name)
p.isWatched = true
ticker := time.NewTicker(1 * time.Second)
var last status.ProcessStatus
var numRestarts int32
var autoTerm bool
if p.options != nil {
numRestarts = p.options.restart
autoTerm = p.options.autoTerm
}
for {
select {
case <-ticker.C:
var current status.ProcessStatus
// skip initial status since the process is not running yet
if current == status.Initial {
continue
}
if !p.isAlive() {
current = status.Terminated
} else {
pStatus, err := p.GetStatus(p.GetPid())
if err != nil {
p.log.Warn(err)
}
if pStatus.State == "" {
current = status.Unavailable
} else {
current = pStatus.State
}
}
// identify status change
if current != last {
if p.GetNotificationChan() != nil {
p.options.notifyChan <- current
}
// handle automatic process restarts
if current == status.Terminated {
if numRestarts > 0 || numRestarts == infiniteRestarts {
go func() {
var err error
if p.command, err = p.startProcess(); err != nil {
p.log.Error("attempt to restart process %s failed: %v", p.name, err)
}
}()
numRestarts--
} else {
p.log.Debugf("no more attempts to restart process %s", p.name)
}
}
// handle automatic zombie process cleanup
if current == status.Zombie && autoTerm {
p.log.Debugf("Terminating zombie process %d", p.GetPid())
if _, err := p.Wait(); err != nil {
p.log.Warnf("failed to terminate dead process: %s", p.GetPid(), err)
}
}
}
last = current
case <-p.cancelChan:
ticker.Stop()
p.closeNotifyChan()
return
}
}
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"watch",
"(",
")",
"{",
"if",
"p",
".",
"isWatched",
"{",
"p",
".",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"p",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"... | // Periodically tries to 'ping' process. If the process is unresponsive, marks it as terminated. Otherwise the process
// status is updated. If process status was changed, notification is sent. In addition, terminated processes are
// restarted if allowed by policy, and dead processes are cleaned up. | [
"Periodically",
"tries",
"to",
"ping",
"process",
".",
"If",
"the",
"process",
"is",
"unresponsive",
"marks",
"it",
"as",
"terminated",
".",
"Otherwise",
"the",
"process",
"status",
"is",
"updated",
".",
"If",
"process",
"status",
"was",
"changed",
"notificati... | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/processmanager/process_impl.go#L188-L261 |
4,761 | ligato/cn-infra | examples/statuscheck-plugin/main.go | checkStatus | func (plugin *ExamplePlugin) checkStatus(closeCh chan struct{}) {
for {
select {
case <-closeCh:
plugin.Log.Info("Closing")
return
case <-time.After(1 * time.Second):
status := plugin.StatusMonitor.GetAllPluginStatus()
for k, v := range status {
plugin.Log.Infof("Status[%v] = %v", k, v)
}
}
}
} | go | func (plugin *ExamplePlugin) checkStatus(closeCh chan struct{}) {
for {
select {
case <-closeCh:
plugin.Log.Info("Closing")
return
case <-time.After(1 * time.Second):
status := plugin.StatusMonitor.GetAllPluginStatus()
for k, v := range status {
plugin.Log.Infof("Status[%v] = %v", k, v)
}
}
}
} | [
"func",
"(",
"plugin",
"*",
"ExamplePlugin",
")",
"checkStatus",
"(",
"closeCh",
"chan",
"struct",
"{",
"}",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"<-",
"closeCh",
":",
"plugin",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"return",
... | // checkStatus periodically prints status of plugins that publish their state
// to status check plugin | [
"checkStatus",
"periodically",
"prints",
"status",
"of",
"plugins",
"that",
"publish",
"their",
"state",
"to",
"status",
"check",
"plugin"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/statuscheck-plugin/main.go#L93-L106 |
4,762 | ligato/cn-infra | logging/logmanager/hooks.go | addHook | func (p *Plugin) addHook(hookName string, hookConfig HookConfig) error {
var lgHook logrus.Hook
var err error
switch hookName {
case HookSysLog:
address := hookConfig.Address
if hookConfig.Address != "" {
address = address + ":" + strconv.Itoa(hookConfig.Port)
}
lgHook, err = lgSyslog.NewSyslogHook(
hookConfig.Protocol,
address,
syslog.LOG_INFO,
p.ServiceLabel.GetAgentLabel(),
)
case HookLogStash:
lgHook, err = logrustash.NewHook(
hookConfig.Protocol,
hookConfig.Address+":"+strconv.Itoa(hookConfig.Port),
p.ServiceLabel.GetAgentLabel(),
)
case HookFluent:
lgHook, err = logrus_fluent.NewWithConfig(logrus_fluent.Config{
Host: hookConfig.Address,
Port: hookConfig.Port,
DefaultTag: p.ServiceLabel.GetAgentLabel(),
})
default:
return fmt.Errorf("unsupported hook: %q", hookName)
}
if err != nil {
return fmt.Errorf("creating hook for %v failed: %v", hookName, err)
}
// create hook
cHook := &commonHook{Hook: lgHook}
// fill up defined levels, or use default if not defined
if len(hookConfig.Levels) == 0 {
cHook.levels = []logrus.Level{logrus.PanicLevel, logrus.FatalLevel, logrus.ErrorLevel}
} else {
for _, level := range hookConfig.Levels {
if lgl, err := logrus.ParseLevel(level); err == nil {
cHook.levels = append(cHook.levels, lgl)
} else {
p.Log.Warnf("cannot parse hook log level %v : %v", level, err.Error())
}
}
}
// add hook to existing loggers and store it into registry for late use
p.LogRegistry.AddHook(cHook)
return nil
} | go | func (p *Plugin) addHook(hookName string, hookConfig HookConfig) error {
var lgHook logrus.Hook
var err error
switch hookName {
case HookSysLog:
address := hookConfig.Address
if hookConfig.Address != "" {
address = address + ":" + strconv.Itoa(hookConfig.Port)
}
lgHook, err = lgSyslog.NewSyslogHook(
hookConfig.Protocol,
address,
syslog.LOG_INFO,
p.ServiceLabel.GetAgentLabel(),
)
case HookLogStash:
lgHook, err = logrustash.NewHook(
hookConfig.Protocol,
hookConfig.Address+":"+strconv.Itoa(hookConfig.Port),
p.ServiceLabel.GetAgentLabel(),
)
case HookFluent:
lgHook, err = logrus_fluent.NewWithConfig(logrus_fluent.Config{
Host: hookConfig.Address,
Port: hookConfig.Port,
DefaultTag: p.ServiceLabel.GetAgentLabel(),
})
default:
return fmt.Errorf("unsupported hook: %q", hookName)
}
if err != nil {
return fmt.Errorf("creating hook for %v failed: %v", hookName, err)
}
// create hook
cHook := &commonHook{Hook: lgHook}
// fill up defined levels, or use default if not defined
if len(hookConfig.Levels) == 0 {
cHook.levels = []logrus.Level{logrus.PanicLevel, logrus.FatalLevel, logrus.ErrorLevel}
} else {
for _, level := range hookConfig.Levels {
if lgl, err := logrus.ParseLevel(level); err == nil {
cHook.levels = append(cHook.levels, lgl)
} else {
p.Log.Warnf("cannot parse hook log level %v : %v", level, err.Error())
}
}
}
// add hook to existing loggers and store it into registry for late use
p.LogRegistry.AddHook(cHook)
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"addHook",
"(",
"hookName",
"string",
",",
"hookConfig",
"HookConfig",
")",
"error",
"{",
"var",
"lgHook",
"logrus",
".",
"Hook",
"\n",
"var",
"err",
"error",
"\n\n",
"switch",
"hookName",
"{",
"case",
"HookSysLog",
... | // store hook into registy for late use and applies to existing loggers | [
"store",
"hook",
"into",
"registy",
"for",
"late",
"use",
"and",
"applies",
"to",
"existing",
"loggers"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/logmanager/hooks.go#L33-L84 |
4,763 | ligato/cn-infra | logging/log_api.go | String | func (level LogLevel) String() string {
switch level {
case PanicLevel:
return "panic"
case FatalLevel:
return "fatal"
case ErrorLevel:
return "error"
case WarnLevel:
return "warn"
case InfoLevel:
return "info"
case DebugLevel:
return "debug"
default:
return fmt.Sprintf("unknown(%d)", level)
}
} | go | func (level LogLevel) String() string {
switch level {
case PanicLevel:
return "panic"
case FatalLevel:
return "fatal"
case ErrorLevel:
return "error"
case WarnLevel:
return "warn"
case InfoLevel:
return "info"
case DebugLevel:
return "debug"
default:
return fmt.Sprintf("unknown(%d)", level)
}
} | [
"func",
"(",
"level",
"LogLevel",
")",
"String",
"(",
")",
"string",
"{",
"switch",
"level",
"{",
"case",
"PanicLevel",
":",
"return",
"\"",
"\"",
"\n",
"case",
"FatalLevel",
":",
"return",
"\"",
"\"",
"\n",
"case",
"ErrorLevel",
":",
"return",
"\"",
"... | // String converts the LogLevel to a string. E.g. PanicLevel becomes "panic". | [
"String",
"converts",
"the",
"LogLevel",
"to",
"a",
"string",
".",
"E",
".",
"g",
".",
"PanicLevel",
"becomes",
"panic",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/log_api.go#L142-L159 |
4,764 | ligato/cn-infra | logging/log_api.go | ParseLogLevel | func ParseLogLevel(level string) LogLevel {
switch strings.ToLower(level) {
case "debug":
return DebugLevel
case "info":
return InfoLevel
case "warn", "warning":
return WarnLevel
case "error":
return ErrorLevel
case "fatal":
return FatalLevel
case "panic":
return PanicLevel
default:
return InfoLevel
}
} | go | func ParseLogLevel(level string) LogLevel {
switch strings.ToLower(level) {
case "debug":
return DebugLevel
case "info":
return InfoLevel
case "warn", "warning":
return WarnLevel
case "error":
return ErrorLevel
case "fatal":
return FatalLevel
case "panic":
return PanicLevel
default:
return InfoLevel
}
} | [
"func",
"ParseLogLevel",
"(",
"level",
"string",
")",
"LogLevel",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"level",
")",
"{",
"case",
"\"",
"\"",
":",
"return",
"DebugLevel",
"\n",
"case",
"\"",
"\"",
":",
"return",
"InfoLevel",
"\n",
"case",
"\"",... | // ParseLogLevel parses string representation of LogLevel. | [
"ParseLogLevel",
"parses",
"string",
"representation",
"of",
"LogLevel",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/log_api.go#L162-L179 |
4,765 | ligato/cn-infra | logging/log_api.go | NewParentLogger | func NewParentLogger(name string, factory LoggerFactory) *ParentLogger {
return &ParentLogger{
Logger: factory.NewLogger(name),
Prefix: name,
Factory: factory,
}
} | go | func NewParentLogger(name string, factory LoggerFactory) *ParentLogger {
return &ParentLogger{
Logger: factory.NewLogger(name),
Prefix: name,
Factory: factory,
}
} | [
"func",
"NewParentLogger",
"(",
"name",
"string",
",",
"factory",
"LoggerFactory",
")",
"*",
"ParentLogger",
"{",
"return",
"&",
"ParentLogger",
"{",
"Logger",
":",
"factory",
".",
"NewLogger",
"(",
"name",
")",
",",
"Prefix",
":",
"name",
",",
"Factory",
... | // NewParentLogger creates new parent logger with given LoggerFactory and name as prefix. | [
"NewParentLogger",
"creates",
"new",
"parent",
"logger",
"with",
"given",
"LoggerFactory",
"and",
"name",
"as",
"prefix",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/log_api.go#L192-L198 |
4,766 | ligato/cn-infra | logging/log_api.go | NewLogger | func (p *ParentLogger) NewLogger(name string) Logger {
factory := p.Factory
if factory == nil {
factory = DefaultRegistry
}
return factory.NewLogger(fmt.Sprintf("%s.%s", p.Prefix, name))
} | go | func (p *ParentLogger) NewLogger(name string) Logger {
factory := p.Factory
if factory == nil {
factory = DefaultRegistry
}
return factory.NewLogger(fmt.Sprintf("%s.%s", p.Prefix, name))
} | [
"func",
"(",
"p",
"*",
"ParentLogger",
")",
"NewLogger",
"(",
"name",
"string",
")",
"Logger",
"{",
"factory",
":=",
"p",
".",
"Factory",
"\n",
"if",
"factory",
"==",
"nil",
"{",
"factory",
"=",
"DefaultRegistry",
"\n",
"}",
"\n",
"return",
"factory",
... | // NewLogger returns logger using name prefixed with prefix defined in parent logger.
// If Factory is nil, DefaultRegistry is used. | [
"NewLogger",
"returns",
"logger",
"using",
"name",
"prefixed",
"with",
"prefix",
"defined",
"in",
"parent",
"logger",
".",
"If",
"Factory",
"is",
"nil",
"DefaultRegistry",
"is",
"used",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/logging/log_api.go#L202-L208 |
4,767 | ligato/cn-infra | messaging/kafka/plugin_impl_kafka.go | AfterInit | func (p *Plugin) AfterInit() error {
if p.disabled {
p.Log.Debugf("kafka plugin disabled, skipping AfterInit")
return nil
}
if p.mux != nil {
err := p.mux.Start()
if err != nil {
return err
}
}
// Register for providing status reports (polling mode)
if p.StatusCheck != nil {
p.StatusCheck.Register(p.PluginName, func() (statuscheck.PluginState, error) {
if p.hsClient == nil || p.hsClient.Closed() {
return statuscheck.Error, fmt.Errorf("kafka client/consumer not available")
}
// Method 'RefreshMetadata()' returns error if kafka server is unavailable
err := p.hsClient.RefreshMetadata(topic)
if err == nil {
return statuscheck.OK, nil
}
p.Log.Errorf("Kafka server unavailable")
return statuscheck.Error, err
})
} else {
p.Log.Warnf("Unable to start status check for kafka")
}
return nil
} | go | func (p *Plugin) AfterInit() error {
if p.disabled {
p.Log.Debugf("kafka plugin disabled, skipping AfterInit")
return nil
}
if p.mux != nil {
err := p.mux.Start()
if err != nil {
return err
}
}
// Register for providing status reports (polling mode)
if p.StatusCheck != nil {
p.StatusCheck.Register(p.PluginName, func() (statuscheck.PluginState, error) {
if p.hsClient == nil || p.hsClient.Closed() {
return statuscheck.Error, fmt.Errorf("kafka client/consumer not available")
}
// Method 'RefreshMetadata()' returns error if kafka server is unavailable
err := p.hsClient.RefreshMetadata(topic)
if err == nil {
return statuscheck.OK, nil
}
p.Log.Errorf("Kafka server unavailable")
return statuscheck.Error, err
})
} else {
p.Log.Warnf("Unable to start status check for kafka")
}
return nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"AfterInit",
"(",
")",
"error",
"{",
"if",
"p",
".",
"disabled",
"{",
"p",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"p",
".",
"mux",
"!=",
"nil",
"{... | // AfterInit is called in the second phase of the initialization. The kafka multiplexerNewWatcher
// is started, all consumers have to be subscribed until this phase. | [
"AfterInit",
"is",
"called",
"in",
"the",
"second",
"phase",
"of",
"the",
"initialization",
".",
"The",
"kafka",
"multiplexerNewWatcher",
"is",
"started",
"all",
"consumers",
"have",
"to",
"be",
"subscribed",
"until",
"this",
"phase",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/plugin_impl_kafka.go#L113-L145 |
4,768 | ligato/cn-infra | messaging/kafka/plugin_impl_kafka.go | Close | func (p *Plugin) Close() error {
return safeclose.Close(p.hsClient, p.manClient, p.mux)
} | go | func (p *Plugin) Close() error {
return safeclose.Close(p.hsClient, p.manClient, p.mux)
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"Close",
"(",
")",
"error",
"{",
"return",
"safeclose",
".",
"Close",
"(",
"p",
".",
"hsClient",
",",
"p",
".",
"manClient",
",",
"p",
".",
"mux",
")",
"\n",
"}"
] | // Close is called at plugin cleanup phase. | [
"Close",
"is",
"called",
"at",
"plugin",
"cleanup",
"phase",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/plugin_impl_kafka.go#L148-L150 |
4,769 | ligato/cn-infra | messaging/kafka/plugin_impl_kafka.go | NewSyncPublisher | func (p *Plugin) NewSyncPublisher(connectionName string, topic string) (messaging.ProtoPublisher, error) {
return p.NewProtoConnection(connectionName).NewSyncPublisher(topic)
} | go | func (p *Plugin) NewSyncPublisher(connectionName string, topic string) (messaging.ProtoPublisher, error) {
return p.NewProtoConnection(connectionName).NewSyncPublisher(topic)
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"NewSyncPublisher",
"(",
"connectionName",
"string",
",",
"topic",
"string",
")",
"(",
"messaging",
".",
"ProtoPublisher",
",",
"error",
")",
"{",
"return",
"p",
".",
"NewProtoConnection",
"(",
"connectionName",
")",
"."... | // NewSyncPublisher creates a publisher that allows to publish messages using synchronous API. The publisher creates
// new proto connection on multiplexer with default partitioner. | [
"NewSyncPublisher",
"creates",
"a",
"publisher",
"that",
"allows",
"to",
"publish",
"messages",
"using",
"synchronous",
"API",
".",
"The",
"publisher",
"creates",
"new",
"proto",
"connection",
"on",
"multiplexer",
"with",
"default",
"partitioner",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/plugin_impl_kafka.go#L180-L182 |
4,770 | ligato/cn-infra | messaging/kafka/plugin_impl_kafka.go | NewSyncPublisherToPartition | func (p *Plugin) NewSyncPublisherToPartition(connectionName string, topic string, partition int32) (messaging.ProtoPublisher, error) {
return p.NewProtoManualConnection(connectionName).NewSyncPublisherToPartition(topic, partition)
} | go | func (p *Plugin) NewSyncPublisherToPartition(connectionName string, topic string, partition int32) (messaging.ProtoPublisher, error) {
return p.NewProtoManualConnection(connectionName).NewSyncPublisherToPartition(topic, partition)
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"NewSyncPublisherToPartition",
"(",
"connectionName",
"string",
",",
"topic",
"string",
",",
"partition",
"int32",
")",
"(",
"messaging",
".",
"ProtoPublisher",
",",
"error",
")",
"{",
"return",
"p",
".",
"NewProtoManualCo... | // NewSyncPublisherToPartition creates a publisher that allows to publish messages to custom partition using synchronous API.
// The publisher creates new proto connection on multiplexer with manual partitioner. | [
"NewSyncPublisherToPartition",
"creates",
"a",
"publisher",
"that",
"allows",
"to",
"publish",
"messages",
"to",
"custom",
"partition",
"using",
"synchronous",
"API",
".",
"The",
"publisher",
"creates",
"new",
"proto",
"connection",
"on",
"multiplexer",
"with",
"man... | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/plugin_impl_kafka.go#L186-L188 |
4,771 | ligato/cn-infra | messaging/kafka/plugin_impl_kafka.go | NewAsyncPublisher | func (p *Plugin) NewAsyncPublisher(connectionName string, topic string, successClb func(messaging.ProtoMessage), errorClb func(messaging.ProtoMessageErr)) (messaging.ProtoPublisher, error) {
return p.NewProtoConnection(connectionName).NewAsyncPublisher(topic, successClb, errorClb)
} | go | func (p *Plugin) NewAsyncPublisher(connectionName string, topic string, successClb func(messaging.ProtoMessage), errorClb func(messaging.ProtoMessageErr)) (messaging.ProtoPublisher, error) {
return p.NewProtoConnection(connectionName).NewAsyncPublisher(topic, successClb, errorClb)
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"NewAsyncPublisher",
"(",
"connectionName",
"string",
",",
"topic",
"string",
",",
"successClb",
"func",
"(",
"messaging",
".",
"ProtoMessage",
")",
",",
"errorClb",
"func",
"(",
"messaging",
".",
"ProtoMessageErr",
")",
... | // NewAsyncPublisher creates a publisher that allows to publish messages using asynchronous API. The publisher creates
// new proto connection on multiplexer with default partitioner. | [
"NewAsyncPublisher",
"creates",
"a",
"publisher",
"that",
"allows",
"to",
"publish",
"messages",
"using",
"asynchronous",
"API",
".",
"The",
"publisher",
"creates",
"new",
"proto",
"connection",
"on",
"multiplexer",
"with",
"default",
"partitioner",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/plugin_impl_kafka.go#L192-L194 |
4,772 | ligato/cn-infra | messaging/kafka/plugin_impl_kafka.go | NewAsyncPublisherToPartition | func (p *Plugin) NewAsyncPublisherToPartition(connectionName string, topic string, partition int32, successClb func(messaging.ProtoMessage), errorClb func(messaging.ProtoMessageErr)) (messaging.ProtoPublisher, error) {
return p.NewProtoManualConnection(connectionName).NewAsyncPublisherToPartition(topic, partition, successClb, errorClb)
} | go | func (p *Plugin) NewAsyncPublisherToPartition(connectionName string, topic string, partition int32, successClb func(messaging.ProtoMessage), errorClb func(messaging.ProtoMessageErr)) (messaging.ProtoPublisher, error) {
return p.NewProtoManualConnection(connectionName).NewAsyncPublisherToPartition(topic, partition, successClb, errorClb)
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"NewAsyncPublisherToPartition",
"(",
"connectionName",
"string",
",",
"topic",
"string",
",",
"partition",
"int32",
",",
"successClb",
"func",
"(",
"messaging",
".",
"ProtoMessage",
")",
",",
"errorClb",
"func",
"(",
"mess... | // NewAsyncPublisherToPartition creates a publisher that allows to publish messages to custom partition using asynchronous API.
// The publisher creates new proto connection on multiplexer with manual partitioner. | [
"NewAsyncPublisherToPartition",
"creates",
"a",
"publisher",
"that",
"allows",
"to",
"publish",
"messages",
"to",
"custom",
"partition",
"using",
"asynchronous",
"API",
".",
"The",
"publisher",
"creates",
"new",
"proto",
"connection",
"on",
"multiplexer",
"with",
"m... | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/plugin_impl_kafka.go#L198-L200 |
4,773 | ligato/cn-infra | messaging/kafka/plugin_impl_kafka.go | getClientConfig | func (p *Plugin) getClientConfig(config *mux.Config, logger logging.Logger, topic string) (*client.Config, error) {
clientCfg := client.NewConfig(logger)
// Set brokers obtained from kafka config. In case there are none available, use a default one
if len(config.Addrs) > 0 {
clientCfg.SetBrokers(config.Addrs...)
} else {
clientCfg.SetBrokers(mux.DefAddress)
}
// Set group ID obtained from kafka config. In case there is none, use a service label
if config.GroupID != "" {
clientCfg.SetGroup(config.GroupID)
} else {
clientCfg.SetGroup(p.ServiceLabel.GetAgentLabel())
}
clientCfg.SetRecvMessageChan(p.subscription)
clientCfg.SetInitialOffset(sarama.OffsetNewest)
clientCfg.SetTopics(topic)
if config.TLS.Enabled {
p.Log.Info("TLS enabled")
tlsConfig, err := clienttls.CreateTLSConfig(config.TLS)
if err != nil {
return nil, err
}
clientCfg.SetTLS(tlsConfig)
}
return clientCfg, nil
} | go | func (p *Plugin) getClientConfig(config *mux.Config, logger logging.Logger, topic string) (*client.Config, error) {
clientCfg := client.NewConfig(logger)
// Set brokers obtained from kafka config. In case there are none available, use a default one
if len(config.Addrs) > 0 {
clientCfg.SetBrokers(config.Addrs...)
} else {
clientCfg.SetBrokers(mux.DefAddress)
}
// Set group ID obtained from kafka config. In case there is none, use a service label
if config.GroupID != "" {
clientCfg.SetGroup(config.GroupID)
} else {
clientCfg.SetGroup(p.ServiceLabel.GetAgentLabel())
}
clientCfg.SetRecvMessageChan(p.subscription)
clientCfg.SetInitialOffset(sarama.OffsetNewest)
clientCfg.SetTopics(topic)
if config.TLS.Enabled {
p.Log.Info("TLS enabled")
tlsConfig, err := clienttls.CreateTLSConfig(config.TLS)
if err != nil {
return nil, err
}
clientCfg.SetTLS(tlsConfig)
}
return clientCfg, nil
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"getClientConfig",
"(",
"config",
"*",
"mux",
".",
"Config",
",",
"logger",
"logging",
".",
"Logger",
",",
"topic",
"string",
")",
"(",
"*",
"client",
".",
"Config",
",",
"error",
")",
"{",
"clientCfg",
":=",
"cl... | // Receive client config according to kafka config data | [
"Receive",
"client",
"config",
"according",
"to",
"kafka",
"config",
"data"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/plugin_impl_kafka.go#L218-L244 |
4,774 | ligato/cn-infra | datasync/syncbase/kv_iterator.go | NewKeyVal | func NewKeyVal(key string, value datasync.LazyValue, rev int64) *KeyVal {
return &KeyVal{key, value, rev}
} | go | func NewKeyVal(key string, value datasync.LazyValue, rev int64) *KeyVal {
return &KeyVal{key, value, rev}
} | [
"func",
"NewKeyVal",
"(",
"key",
"string",
",",
"value",
"datasync",
".",
"LazyValue",
",",
"rev",
"int64",
")",
"*",
"KeyVal",
"{",
"return",
"&",
"KeyVal",
"{",
"key",
",",
"value",
",",
"rev",
"}",
"\n",
"}"
] | // NewKeyVal creates a new instance of KeyVal. | [
"NewKeyVal",
"creates",
"a",
"new",
"instance",
"of",
"KeyVal",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/syncbase/kv_iterator.go#L55-L57 |
4,775 | ligato/cn-infra | datasync/syncbase/kv_iterator.go | NewKeyValBytes | func NewKeyValBytes(key string, value []byte, rev int64) *KeyValBytes {
return &KeyValBytes{key, value, rev}
} | go | func NewKeyValBytes(key string, value []byte, rev int64) *KeyValBytes {
return &KeyValBytes{key, value, rev}
} | [
"func",
"NewKeyValBytes",
"(",
"key",
"string",
",",
"value",
"[",
"]",
"byte",
",",
"rev",
"int64",
")",
"*",
"KeyValBytes",
"{",
"return",
"&",
"KeyValBytes",
"{",
"key",
",",
"value",
",",
"rev",
"}",
"\n",
"}"
] | // NewKeyValBytes creates a new instance of KeyValBytes. | [
"NewKeyValBytes",
"creates",
"a",
"new",
"instance",
"of",
"KeyValBytes",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/syncbase/kv_iterator.go#L89-L91 |
4,776 | ligato/cn-infra | db/keyval/filedb/filesystem/filesystem.go | CreateFile | func (fsh *Handler) CreateFile(file string) error {
path, _ := filepath.Split(file)
// Create path at first if necessary
if path != "" {
if err := os.MkdirAll(path, os.ModePerm); err != nil {
return errors.Errorf("failed to create path for file %s: %v", file, err)
}
}
sf, err := os.Create(file)
if err != nil {
return errors.Errorf("failed to create file %s: %v", file, err)
}
return sf.Close()
} | go | func (fsh *Handler) CreateFile(file string) error {
path, _ := filepath.Split(file)
// Create path at first if necessary
if path != "" {
if err := os.MkdirAll(path, os.ModePerm); err != nil {
return errors.Errorf("failed to create path for file %s: %v", file, err)
}
}
sf, err := os.Create(file)
if err != nil {
return errors.Errorf("failed to create file %s: %v", file, err)
}
return sf.Close()
} | [
"func",
"(",
"fsh",
"*",
"Handler",
")",
"CreateFile",
"(",
"file",
"string",
")",
"error",
"{",
"path",
",",
"_",
":=",
"filepath",
".",
"Split",
"(",
"file",
")",
"\n",
"// Create path at first if necessary",
"if",
"path",
"!=",
"\"",
"\"",
"{",
"if",
... | // CreateFile is an implementation of the file system API interface | [
"CreateFile",
"is",
"an",
"implementation",
"of",
"the",
"file",
"system",
"API",
"interface"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/filesystem/filesystem.go#L57-L70 |
4,777 | ligato/cn-infra | db/keyval/filedb/filesystem/filesystem.go | ReadFile | func (fsh *Handler) ReadFile(file string) ([]byte, error) {
return ioutil.ReadFile(file)
} | go | func (fsh *Handler) ReadFile(file string) ([]byte, error) {
return ioutil.ReadFile(file)
} | [
"func",
"(",
"fsh",
"*",
"Handler",
")",
"ReadFile",
"(",
"file",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"ioutil",
".",
"ReadFile",
"(",
"file",
")",
"\n",
"}"
] | // ReadFile is an implementation of the file system API interface | [
"ReadFile",
"is",
"an",
"implementation",
"of",
"the",
"file",
"system",
"API",
"interface"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/filesystem/filesystem.go#L73-L75 |
4,778 | ligato/cn-infra | db/keyval/filedb/filesystem/filesystem.go | WriteFile | func (fsh *Handler) WriteFile(file string, data []byte) error {
fileObj, err := os.OpenFile(file, os.O_TRUNC|os.O_WRONLY, os.ModePerm)
if err != nil {
return fmt.Errorf("failed to open status file %s for writing: %v", file, err)
}
defer fileObj.Close()
if _, err := fileObj.Write(data); err != nil {
return fmt.Errorf("failed to write status file %s for writing: %v", file, err)
}
return nil
} | go | func (fsh *Handler) WriteFile(file string, data []byte) error {
fileObj, err := os.OpenFile(file, os.O_TRUNC|os.O_WRONLY, os.ModePerm)
if err != nil {
return fmt.Errorf("failed to open status file %s for writing: %v", file, err)
}
defer fileObj.Close()
if _, err := fileObj.Write(data); err != nil {
return fmt.Errorf("failed to write status file %s for writing: %v", file, err)
}
return nil
} | [
"func",
"(",
"fsh",
"*",
"Handler",
")",
"WriteFile",
"(",
"file",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"fileObj",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"file",
",",
"os",
".",
"O_TRUNC",
"|",
"os",
".",
"O_WRONLY",
... | // WriteFile is an implementation of the file system API interface | [
"WriteFile",
"is",
"an",
"implementation",
"of",
"the",
"file",
"system",
"API",
"interface"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/filesystem/filesystem.go#L78-L88 |
4,779 | ligato/cn-infra | db/keyval/filedb/filesystem/filesystem.go | FileExists | func (fsh *Handler) FileExists(file string) bool {
if _, err := os.Stat(file); os.IsNotExist(err) {
return false
}
return true
} | go | func (fsh *Handler) FileExists(file string) bool {
if _, err := os.Stat(file); os.IsNotExist(err) {
return false
}
return true
} | [
"func",
"(",
"fsh",
"*",
"Handler",
")",
"FileExists",
"(",
"file",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"file",
")",
";",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"false",
"\n",
"}",
... | // FileExists is an implementation of the file system API interface | [
"FileExists",
"is",
"an",
"implementation",
"of",
"the",
"file",
"system",
"API",
"interface"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/filesystem/filesystem.go#L91-L96 |
4,780 | ligato/cn-infra | db/keyval/filedb/filesystem/filesystem.go | GetFileNames | func (fsh *Handler) GetFileNames(paths []string) (files []string, err error) {
for _, path := range paths {
err := filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info == nil || info.IsDir() {
return nil
}
files = append(files, path)
return nil
})
if err != nil {
err = errors.Errorf("failed to traverse through %s: %v", path, err)
}
}
return files, err
} | go | func (fsh *Handler) GetFileNames(paths []string) (files []string, err error) {
for _, path := range paths {
err := filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info == nil || info.IsDir() {
return nil
}
files = append(files, path)
return nil
})
if err != nil {
err = errors.Errorf("failed to traverse through %s: %v", path, err)
}
}
return files, err
} | [
"func",
"(",
"fsh",
"*",
"Handler",
")",
"GetFileNames",
"(",
"paths",
"[",
"]",
"string",
")",
"(",
"files",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"for",
"_",
",",
"path",
":=",
"range",
"paths",
"{",
"err",
":=",
"filepath",
".",
"... | // GetFileNames is an implementation of the file system API interface | [
"GetFileNames",
"is",
"an",
"implementation",
"of",
"the",
"file",
"system",
"API",
"interface"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/filesystem/filesystem.go#L99-L116 |
4,781 | ligato/cn-infra | db/keyval/filedb/filesystem/filesystem.go | Watch | func (fsh *Handler) Watch(paths []string, onEvent func(event fsnotify.Event), onClose func()) error {
var err error
fsh.watcher, err = fsnotify.NewWatcher()
if err != nil {
return errors.Errorf("failed to init fileDB file system watcher: %v", err)
}
for _, path := range paths {
fsh.watcher.Add(path)
}
go func() {
for {
select {
case event, ok := <-fsh.watcher.Events:
if !ok {
onClose()
return
}
onEvent(event)
case err := <-fsh.watcher.Errors:
if err != nil {
fsh.log.Errorf("filesystem notification error %v", err)
}
}
}
}()
return nil
} | go | func (fsh *Handler) Watch(paths []string, onEvent func(event fsnotify.Event), onClose func()) error {
var err error
fsh.watcher, err = fsnotify.NewWatcher()
if err != nil {
return errors.Errorf("failed to init fileDB file system watcher: %v", err)
}
for _, path := range paths {
fsh.watcher.Add(path)
}
go func() {
for {
select {
case event, ok := <-fsh.watcher.Events:
if !ok {
onClose()
return
}
onEvent(event)
case err := <-fsh.watcher.Errors:
if err != nil {
fsh.log.Errorf("filesystem notification error %v", err)
}
}
}
}()
return nil
} | [
"func",
"(",
"fsh",
"*",
"Handler",
")",
"Watch",
"(",
"paths",
"[",
"]",
"string",
",",
"onEvent",
"func",
"(",
"event",
"fsnotify",
".",
"Event",
")",
",",
"onClose",
"func",
"(",
")",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"fsh",
".",
... | // Watch starts new filesystem notification watcher. All events from files are passed to 'onEvent' function.
// Function 'onClose' is called when event channel is closed. | [
"Watch",
"starts",
"new",
"filesystem",
"notification",
"watcher",
".",
"All",
"events",
"from",
"files",
"are",
"passed",
"to",
"onEvent",
"function",
".",
"Function",
"onClose",
"is",
"called",
"when",
"event",
"channel",
"is",
"closed",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/filesystem/filesystem.go#L120-L148 |
4,782 | ligato/cn-infra | db/keyval/filedb/filesystem/filesystem.go | getFilesInPath | func (fsh *Handler) getFilesInPath(files []string, path string) error {
pathInfo, err := os.Stat(path)
if err != nil {
return errors.Errorf("failed to read path %s: %v", path, err)
}
if pathInfo.IsDir() {
pathList, err := ioutil.ReadDir(path)
if err != nil {
return errors.Errorf("failed to read directory %s: %v", path, err)
}
for _, nested := range pathList {
// Recursive call to process all the tree
if err := fsh.getFilesInPath(files, path+nested.Name()); err != nil {
return err
}
}
}
files = append(files, path)
return nil
} | go | func (fsh *Handler) getFilesInPath(files []string, path string) error {
pathInfo, err := os.Stat(path)
if err != nil {
return errors.Errorf("failed to read path %s: %v", path, err)
}
if pathInfo.IsDir() {
pathList, err := ioutil.ReadDir(path)
if err != nil {
return errors.Errorf("failed to read directory %s: %v", path, err)
}
for _, nested := range pathList {
// Recursive call to process all the tree
if err := fsh.getFilesInPath(files, path+nested.Name()); err != nil {
return err
}
}
}
files = append(files, path)
return nil
} | [
"func",
"(",
"fsh",
"*",
"Handler",
")",
"getFilesInPath",
"(",
"files",
"[",
"]",
"string",
",",
"path",
"string",
")",
"error",
"{",
"pathInfo",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",... | // Processes given path. If the target is a file, it is stored in the file list. If the target
// is a directory, function is called recursively on nested paths in order to process the whole tree. | [
"Processes",
"given",
"path",
".",
"If",
"the",
"target",
"is",
"a",
"file",
"it",
"is",
"stored",
"in",
"the",
"file",
"list",
".",
"If",
"the",
"target",
"is",
"a",
"directory",
"function",
"is",
"called",
"recursively",
"on",
"nested",
"paths",
"in",
... | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/filedb/filesystem/filesystem.go#L157-L177 |
4,783 | ligato/cn-infra | messaging/kafka/mux/mock.go | Mock | func Mock(t *testing.T) *KafkaMock {
asyncP, aMock := client.GetAsyncProducerMock(t)
syncP, sMock := client.GetSyncProducerMock(t)
producers := multiplexerProducers{
syncP, syncP, asyncP, asyncP,
}
return &KafkaMock{
NewMultiplexer(getMockConsumerFactory(t), producers, &client.Config{}, "name", logrus.DefaultLogger()),
aMock, sMock}
} | go | func Mock(t *testing.T) *KafkaMock {
asyncP, aMock := client.GetAsyncProducerMock(t)
syncP, sMock := client.GetSyncProducerMock(t)
producers := multiplexerProducers{
syncP, syncP, asyncP, asyncP,
}
return &KafkaMock{
NewMultiplexer(getMockConsumerFactory(t), producers, &client.Config{}, "name", logrus.DefaultLogger()),
aMock, sMock}
} | [
"func",
"Mock",
"(",
"t",
"*",
"testing",
".",
"T",
")",
"*",
"KafkaMock",
"{",
"asyncP",
",",
"aMock",
":=",
"client",
".",
"GetAsyncProducerMock",
"(",
"t",
")",
"\n",
"syncP",
",",
"sMock",
":=",
"client",
".",
"GetSyncProducerMock",
"(",
"t",
")",
... | // Mock returns mock of Multiplexer that can be used for testing purposes. | [
"Mock",
"returns",
"mock",
"of",
"Multiplexer",
"that",
"can",
"be",
"used",
"for",
"testing",
"purposes",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/messaging/kafka/mux/mock.go#L32-L42 |
4,784 | ligato/cn-infra | examples/tutorials/06_plugin_lookup/plugin2.go | RegisterWorld | func (p *HelloUniverse) RegisterWorld(name string, size int) {
p.worlds[name] = size
log.Printf("World %s (size %d) was registered", name, size)
} | go | func (p *HelloUniverse) RegisterWorld(name string, size int) {
p.worlds[name] = size
log.Printf("World %s (size %d) was registered", name, size)
} | [
"func",
"(",
"p",
"*",
"HelloUniverse",
")",
"RegisterWorld",
"(",
"name",
"string",
",",
"size",
"int",
")",
"{",
"p",
".",
"worlds",
"[",
"name",
"]",
"=",
"size",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"name",
",",
"size",
")",
"\n"... | // RegisterWorld is exported for other plugins to use | [
"RegisterWorld",
"is",
"exported",
"for",
"other",
"plugins",
"to",
"use"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/tutorials/06_plugin_lookup/plugin2.go#L39-L42 |
4,785 | ligato/cn-infra | utils/safeclose/safeclose.go | safeClose | func safeClose(obj interface{}) error {
defer func() {
if r := recover(); r != nil {
logrus.DefaultLogger().Error("Recovered in safeclose: ", r)
}
}()
// closerWithoutErr is similar interface to io.Closer, but Close() does not return error
type closerWithoutErr interface {
Close()
}
if val := reflect.ValueOf(obj); val.IsValid() && !val.IsNil() {
if closer, ok := obj.(*io.Closer); ok {
if closer != nil {
return (*closer).Close()
}
} else if closer, ok := obj.(io.Closer); ok {
if closer != nil {
return closer.Close()
}
} else if closer, ok := obj.(*closerWithoutErr); ok {
if closer != nil {
(*closer).Close()
}
} else if closer, ok := obj.(closerWithoutErr); ok {
if closer != nil {
closer.Close()
}
} else if reflect.TypeOf(obj).Kind() == reflect.Chan {
val.Close()
}
}
return nil
} | go | func safeClose(obj interface{}) error {
defer func() {
if r := recover(); r != nil {
logrus.DefaultLogger().Error("Recovered in safeclose: ", r)
}
}()
// closerWithoutErr is similar interface to io.Closer, but Close() does not return error
type closerWithoutErr interface {
Close()
}
if val := reflect.ValueOf(obj); val.IsValid() && !val.IsNil() {
if closer, ok := obj.(*io.Closer); ok {
if closer != nil {
return (*closer).Close()
}
} else if closer, ok := obj.(io.Closer); ok {
if closer != nil {
return closer.Close()
}
} else if closer, ok := obj.(*closerWithoutErr); ok {
if closer != nil {
(*closer).Close()
}
} else if closer, ok := obj.(closerWithoutErr); ok {
if closer != nil {
closer.Close()
}
} else if reflect.TypeOf(obj).Kind() == reflect.Chan {
val.Close()
}
}
return nil
} | [
"func",
"safeClose",
"(",
"obj",
"interface",
"{",
"}",
")",
"error",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"logrus",
".",
"DefaultLogger",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
... | // safeClose closes closable object. | [
"safeClose",
"closes",
"closable",
"object",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/utils/safeclose/safeclose.go#L26-L62 |
4,786 | ligato/cn-infra | utils/safeclose/safeclose.go | Close | func Close(objs ...interface{}) error {
errs := make([]error, len(objs))
for i, obj := range objs {
errs[i] = safeClose(obj)
}
for _, err := range errs {
if err != nil {
return CloseErrors(errs)
}
}
return nil
} | go | func Close(objs ...interface{}) error {
errs := make([]error, len(objs))
for i, obj := range objs {
errs[i] = safeClose(obj)
}
for _, err := range errs {
if err != nil {
return CloseErrors(errs)
}
}
return nil
} | [
"func",
"Close",
"(",
"objs",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"errs",
":=",
"make",
"(",
"[",
"]",
"error",
",",
"len",
"(",
"objs",
")",
")",
"\n\n",
"for",
"i",
",",
"obj",
":=",
"range",
"objs",
"{",
"errs",
"[",
"i",
"]",
... | // Close tries to close all objects and return all errors using CloseErrors if there are any. | [
"Close",
"tries",
"to",
"close",
"all",
"objects",
"and",
"return",
"all",
"errors",
"using",
"CloseErrors",
"if",
"there",
"are",
"any",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/utils/safeclose/safeclose.go#L65-L79 |
4,787 | ligato/cn-infra | examples/redis-lib/airport/airport.go | main | func main() {
var debug bool
var redisConfigPath string
// init example flags
flag.BoolVar(&debug, "debug", false, "Enable debugging")
flag.StringVar(&redisConfigPath, "redis-config", "", "Redis configuration file path")
flag.Parse()
log := logrus.DefaultLogger()
if debug {
log.SetLevel(logging.DebugLevel)
}
// load redis config file
redisConfig, err := redis.LoadConfig(redisConfigPath)
if err != nil {
log.Errorf("Failed to load Redis config file %s: %v", redisConfigPath, err)
return
}
airport := &Airport{
log: log,
airlines: []string{"AA", "DL", "SW", "UA"},
flightRadar: make(map[string]struct{}),
arrivalPrefix: "/redis/airport/arrival",
departurePrefix: "/redis/airport/departure",
hangarPrefix: "/redis/airport/hangar",
motions: []string{" ->", "<- "},
respChan: make(chan keyval.BytesWatchResp, 10),
closeChan: make(chan string),
}
doneChan := make(chan struct{})
if err := airport.init(redisConfig, doneChan); err != nil {
airport.log.Errorf("airport example error: %v", err)
} else {
airport.start()
}
} | go | func main() {
var debug bool
var redisConfigPath string
// init example flags
flag.BoolVar(&debug, "debug", false, "Enable debugging")
flag.StringVar(&redisConfigPath, "redis-config", "", "Redis configuration file path")
flag.Parse()
log := logrus.DefaultLogger()
if debug {
log.SetLevel(logging.DebugLevel)
}
// load redis config file
redisConfig, err := redis.LoadConfig(redisConfigPath)
if err != nil {
log.Errorf("Failed to load Redis config file %s: %v", redisConfigPath, err)
return
}
airport := &Airport{
log: log,
airlines: []string{"AA", "DL", "SW", "UA"},
flightRadar: make(map[string]struct{}),
arrivalPrefix: "/redis/airport/arrival",
departurePrefix: "/redis/airport/departure",
hangarPrefix: "/redis/airport/hangar",
motions: []string{" ->", "<- "},
respChan: make(chan keyval.BytesWatchResp, 10),
closeChan: make(chan string),
}
doneChan := make(chan struct{})
if err := airport.init(redisConfig, doneChan); err != nil {
airport.log.Errorf("airport example error: %v", err)
} else {
airport.start()
}
} | [
"func",
"main",
"(",
")",
"{",
"var",
"debug",
"bool",
"\n",
"var",
"redisConfigPath",
"string",
"\n\n",
"// init example flags",
"flag",
".",
"BoolVar",
"(",
"&",
"debug",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"String... | // Initialize airport and start serving | [
"Initialize",
"airport",
"and",
"start",
"serving"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/redis-lib/airport/airport.go#L161-L198 |
4,788 | ligato/cn-infra | examples/redis-lib/airport/airport.go | init | func (a *Airport) init(config interface{}, doneChan chan struct{}) (err error) {
a.log.Info("Airport redis example. If you need more info about what is happening, run example with -debug=true")
rand.Seed(time.Now().UnixNano())
printHeaders()
setupFlightStatusFormat()
// prepare client to connect to the redis DB
a.client, err = redis.ConfigToClient(config)
if err != nil {
return fmt.Errorf("failed to create redis client: %v", err)
}
a.connection, err = redis.NewBytesConnection(a.client, a.log)
if err != nil {
return fmt.Errorf("failed to create connection from redis client: %v", err)
}
// prepare all the brokers and watchers in order to simulate airport
a.arrivalBroker = kvproto.NewProtoWrapper(a.connection).NewBroker(a.arrivalPrefix)
a.arrivalWatcher = kvproto.NewProtoWrapper(a.connection).NewWatcher(a.arrivalPrefix)
a.departureBroker = kvproto.NewProtoWrapper(a.connection).NewBroker(a.departurePrefix)
a.departureWatcher = kvproto.NewProtoWrapper(a.connection).NewWatcher(a.departurePrefix)
a.hangarBroker = kvproto.NewProtoWrapper(a.connection).NewBroker(a.hangarPrefix)
a.hangarWatcher = kvproto.NewProtoWrapper(a.connection).NewWatcher(a.hangarPrefix)
a.cleanUp(false)
// start watchers
a.arrivalChan = make(chan datasync.ProtoWatchResp, flightSlots)
if err := a.arrivalWatcher.Watch(keyval.ToChanProto(a.arrivalChan), nil, ""); err != nil {
return fmt.Errorf("failed to start 'arrival' watcher: %v", err)
}
a.departureChan = make(chan datasync.ProtoWatchResp, flightSlots)
if err := a.departureWatcher.Watch(keyval.ToChanProto(a.departureChan), nil, ""); err != nil {
return fmt.Errorf("failed to start 'departure' watcher: %v", err)
}
a.hangarChan = make(chan datasync.ProtoWatchResp, hangarSlots)
if err := a.hangarWatcher.Watch(keyval.ToChanProto(a.hangarChan), nil, ""); err != nil {
return fmt.Errorf("failed to start 'hangar' watcher: %v", err)
}
a.runwayChan = make(chan flight.Info, flightSlots)
return nil
} | go | func (a *Airport) init(config interface{}, doneChan chan struct{}) (err error) {
a.log.Info("Airport redis example. If you need more info about what is happening, run example with -debug=true")
rand.Seed(time.Now().UnixNano())
printHeaders()
setupFlightStatusFormat()
// prepare client to connect to the redis DB
a.client, err = redis.ConfigToClient(config)
if err != nil {
return fmt.Errorf("failed to create redis client: %v", err)
}
a.connection, err = redis.NewBytesConnection(a.client, a.log)
if err != nil {
return fmt.Errorf("failed to create connection from redis client: %v", err)
}
// prepare all the brokers and watchers in order to simulate airport
a.arrivalBroker = kvproto.NewProtoWrapper(a.connection).NewBroker(a.arrivalPrefix)
a.arrivalWatcher = kvproto.NewProtoWrapper(a.connection).NewWatcher(a.arrivalPrefix)
a.departureBroker = kvproto.NewProtoWrapper(a.connection).NewBroker(a.departurePrefix)
a.departureWatcher = kvproto.NewProtoWrapper(a.connection).NewWatcher(a.departurePrefix)
a.hangarBroker = kvproto.NewProtoWrapper(a.connection).NewBroker(a.hangarPrefix)
a.hangarWatcher = kvproto.NewProtoWrapper(a.connection).NewWatcher(a.hangarPrefix)
a.cleanUp(false)
// start watchers
a.arrivalChan = make(chan datasync.ProtoWatchResp, flightSlots)
if err := a.arrivalWatcher.Watch(keyval.ToChanProto(a.arrivalChan), nil, ""); err != nil {
return fmt.Errorf("failed to start 'arrival' watcher: %v", err)
}
a.departureChan = make(chan datasync.ProtoWatchResp, flightSlots)
if err := a.departureWatcher.Watch(keyval.ToChanProto(a.departureChan), nil, ""); err != nil {
return fmt.Errorf("failed to start 'departure' watcher: %v", err)
}
a.hangarChan = make(chan datasync.ProtoWatchResp, hangarSlots)
if err := a.hangarWatcher.Watch(keyval.ToChanProto(a.hangarChan), nil, ""); err != nil {
return fmt.Errorf("failed to start 'hangar' watcher: %v", err)
}
a.runwayChan = make(chan flight.Info, flightSlots)
return nil
} | [
"func",
"(",
"a",
"*",
"Airport",
")",
"init",
"(",
"config",
"interface",
"{",
"}",
",",
"doneChan",
"chan",
"struct",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"a",
".",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"rand",
".",
"Seed... | // Set all required brokers, watchers, prepare redis connection | [
"Set",
"all",
"required",
"brokers",
"watchers",
"prepare",
"redis",
"connection"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/redis-lib/airport/airport.go#L201-L247 |
4,789 | ligato/cn-infra | examples/redis-lib/airport/airport.go | processArrivals | func (a *Airport) processArrivals() {
for {
arrival, ok := <-a.arrivalChan
if !ok {
a.log.Errorf("arrival channel closed")
return
}
switch arrival.GetChangeType() {
case datasync.Put:
fl := flight.Info{}
if err := arrival.GetValue(&fl); err != nil {
a.log.Errorf("failed to get value for arrival flight: %v", err)
continue
}
fl.Status = flight.Status_arrival
a.runwayChan <- fl
case datasync.Delete:
a.log.Debugf("arrival %s deleted\n", arrival.GetKey())
}
}
} | go | func (a *Airport) processArrivals() {
for {
arrival, ok := <-a.arrivalChan
if !ok {
a.log.Errorf("arrival channel closed")
return
}
switch arrival.GetChangeType() {
case datasync.Put:
fl := flight.Info{}
if err := arrival.GetValue(&fl); err != nil {
a.log.Errorf("failed to get value for arrival flight: %v", err)
continue
}
fl.Status = flight.Status_arrival
a.runwayChan <- fl
case datasync.Delete:
a.log.Debugf("arrival %s deleted\n", arrival.GetKey())
}
}
} | [
"func",
"(",
"a",
"*",
"Airport",
")",
"processArrivals",
"(",
")",
"{",
"for",
"{",
"arrival",
",",
"ok",
":=",
"<-",
"a",
".",
"arrivalChan",
"\n",
"if",
"!",
"ok",
"{",
"a",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\... | // Wait for arrivals. Incoming flights are set to 'arrival' status and sent to runway. | [
"Wait",
"for",
"arrivals",
".",
"Incoming",
"flights",
"are",
"set",
"to",
"arrival",
"status",
"and",
"sent",
"to",
"runway",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/redis-lib/airport/airport.go#L295-L315 |
4,790 | ligato/cn-infra | examples/redis-lib/airport/airport.go | processDepartures | func (a *Airport) processDepartures() {
for {
departure, ok := <-a.departureChan
if !ok {
a.log.Errorf("departure channel closed")
return
}
switch departure.GetChangeType() {
case datasync.Put:
fl := flight.Info{}
if err := departure.GetValue(&fl); err != nil {
a.log.Errorf("failed to get value for departure flight: %v", err)
continue
}
fl.Status = flight.Status_departure
a.runwayChan <- fl
case datasync.Delete:
a.log.Debugf("departure %s deleted\n", departure.GetKey())
}
}
} | go | func (a *Airport) processDepartures() {
for {
departure, ok := <-a.departureChan
if !ok {
a.log.Errorf("departure channel closed")
return
}
switch departure.GetChangeType() {
case datasync.Put:
fl := flight.Info{}
if err := departure.GetValue(&fl); err != nil {
a.log.Errorf("failed to get value for departure flight: %v", err)
continue
}
fl.Status = flight.Status_departure
a.runwayChan <- fl
case datasync.Delete:
a.log.Debugf("departure %s deleted\n", departure.GetKey())
}
}
} | [
"func",
"(",
"a",
"*",
"Airport",
")",
"processDepartures",
"(",
")",
"{",
"for",
"{",
"departure",
",",
"ok",
":=",
"<-",
"a",
".",
"departureChan",
"\n",
"if",
"!",
"ok",
"{",
"a",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return"... | // Wait for departures. Outgoing flights are set to 'departure' and sent to runway | [
"Wait",
"for",
"departures",
".",
"Outgoing",
"flights",
"are",
"set",
"to",
"departure",
"and",
"sent",
"to",
"runway"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/redis-lib/airport/airport.go#L318-L338 |
4,791 | ligato/cn-infra | examples/redis-lib/airport/airport.go | processHangar | func (a *Airport) processHangar() {
for {
hangar, ok := <-a.hangarChan
if !ok {
a.log.Errorf("hangar channel closed")
return
}
switch hangar.GetChangeType() {
case datasync.Put:
a.log.Debugf("hangar %s updated", hangar.GetKey())
case datasync.Delete:
fl := flight.Info{}
if _, err := fmt.Sscanf(hangar.GetKey(), hangarKeyTemplate, &(fl.Airline), &(fl.Number), &(fl.Priority)); err != nil {
a.log.Errorf("error creating hangar key: %v", err)
continue
}
if err := a.departureBroker.Put(fmt.Sprintf(flightIDFormat, fl.Airline, fl.Number), &fl); err != nil {
a.log.Errorf("failed to put flight to departure broker: %v", err)
continue
}
}
}
} | go | func (a *Airport) processHangar() {
for {
hangar, ok := <-a.hangarChan
if !ok {
a.log.Errorf("hangar channel closed")
return
}
switch hangar.GetChangeType() {
case datasync.Put:
a.log.Debugf("hangar %s updated", hangar.GetKey())
case datasync.Delete:
fl := flight.Info{}
if _, err := fmt.Sscanf(hangar.GetKey(), hangarKeyTemplate, &(fl.Airline), &(fl.Number), &(fl.Priority)); err != nil {
a.log.Errorf("error creating hangar key: %v", err)
continue
}
if err := a.departureBroker.Put(fmt.Sprintf(flightIDFormat, fl.Airline, fl.Number), &fl); err != nil {
a.log.Errorf("failed to put flight to departure broker: %v", err)
continue
}
}
}
} | [
"func",
"(",
"a",
"*",
"Airport",
")",
"processHangar",
"(",
")",
"{",
"for",
"{",
"hangar",
",",
"ok",
":=",
"<-",
"a",
".",
"hangarChan",
"\n",
"if",
"!",
"ok",
"{",
"a",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
... | // Wait for hangar. Incoming flights are stored, outgoing are sent to departure. | [
"Wait",
"for",
"hangar",
".",
"Incoming",
"flights",
"are",
"stored",
"outgoing",
"are",
"sent",
"to",
"departure",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/redis-lib/airport/airport.go#L341-L363 |
4,792 | ligato/cn-infra | datasync/syncbase/msg/change_event.go | Done | func (ev *ChangeEvent) Done(err error) {
//TODO publish response to the topic
if err != nil {
logrus.DefaultLogger().Error(err)
}
} | go | func (ev *ChangeEvent) Done(err error) {
//TODO publish response to the topic
if err != nil {
logrus.DefaultLogger().Error(err)
}
} | [
"func",
"(",
"ev",
"*",
"ChangeEvent",
")",
"Done",
"(",
"err",
"error",
")",
"{",
"//TODO publish response to the topic",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"DefaultLogger",
"(",
")",
".",
"Error",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // Done does nothing yet. | [
"Done",
"does",
"nothing",
"yet",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/syncbase/msg/change_event.go#L57-L62 |
4,793 | ligato/cn-infra | datasync/syncbase/msg/change_event.go | GetChangeType | func (ev *ChangeWatchResp) GetChangeType() datasync.Op {
if ev.message.OperationType == PutDel_DEL {
return datasync.Delete
}
return datasync.Put
} | go | func (ev *ChangeWatchResp) GetChangeType() datasync.Op {
if ev.message.OperationType == PutDel_DEL {
return datasync.Delete
}
return datasync.Put
} | [
"func",
"(",
"ev",
"*",
"ChangeWatchResp",
")",
"GetChangeType",
"(",
")",
"datasync",
".",
"Op",
"{",
"if",
"ev",
".",
"message",
".",
"OperationType",
"==",
"PutDel_DEL",
"{",
"return",
"datasync",
".",
"Delete",
"\n",
"}",
"\n\n",
"return",
"datasync",
... | // GetChangeType - see the comment in implemented interface datasync.ChangeEvent. | [
"GetChangeType",
"-",
"see",
"the",
"comment",
"in",
"implemented",
"interface",
"datasync",
".",
"ChangeEvent",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/syncbase/msg/change_event.go#L70-L76 |
4,794 | ligato/cn-infra | datasync/syncbase/msg/change_event.go | GetValue | func (ev *ChangeWatchResp) GetValue(val proto.Message) error {
return json.Unmarshal(ev.message.Content, val) //TODO use contentType...
} | go | func (ev *ChangeWatchResp) GetValue(val proto.Message) error {
return json.Unmarshal(ev.message.Content, val) //TODO use contentType...
} | [
"func",
"(",
"ev",
"*",
"ChangeWatchResp",
")",
"GetValue",
"(",
"val",
"proto",
".",
"Message",
")",
"error",
"{",
"return",
"json",
".",
"Unmarshal",
"(",
"ev",
".",
"message",
".",
"Content",
",",
"val",
")",
"//TODO use contentType...",
"\n",
"}"
] | // GetValue - see the comments in the interface datasync.ChangeEvent. | [
"GetValue",
"-",
"see",
"the",
"comments",
"in",
"the",
"interface",
"datasync",
".",
"ChangeEvent",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/syncbase/msg/change_event.go#L89-L91 |
4,795 | ligato/cn-infra | datasync/grpcsync/grpc_watcher.go | NewAdapter | func NewAdapter(grpcServer *grpc.Server) *Adapter {
//TODO grpcServer.RegisterCodec(json.NewCodec(), "application/json")
adapter := &Adapter{
base: syncbase.NewRegistry(),
server: grpcServer,
}
msg.RegisterDataMsgServiceServer(grpcServer, &DataMsgServiceServer{adapter})
return adapter
} | go | func NewAdapter(grpcServer *grpc.Server) *Adapter {
//TODO grpcServer.RegisterCodec(json.NewCodec(), "application/json")
adapter := &Adapter{
base: syncbase.NewRegistry(),
server: grpcServer,
}
msg.RegisterDataMsgServiceServer(grpcServer, &DataMsgServiceServer{adapter})
return adapter
} | [
"func",
"NewAdapter",
"(",
"grpcServer",
"*",
"grpc",
".",
"Server",
")",
"*",
"Adapter",
"{",
"//TODO grpcServer.RegisterCodec(json.NewCodec(), \"application/json\")",
"adapter",
":=",
"&",
"Adapter",
"{",
"base",
":",
"syncbase",
".",
"NewRegistry",
"(",
")",
",",... | // NewAdapter creates a new instance of Adapter. | [
"NewAdapter",
"creates",
"a",
"new",
"instance",
"of",
"Adapter",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/grpcsync/grpc_watcher.go#L35-L44 |
4,796 | ligato/cn-infra | examples/redis-lib/simple/simple.go | Close | func (sr *SimpleRedis) Close() error {
return safeclose.Close(sr.client, sr.respChan, sr.closeChan)
} | go | func (sr *SimpleRedis) Close() error {
return safeclose.Close(sr.client, sr.respChan, sr.closeChan)
} | [
"func",
"(",
"sr",
"*",
"SimpleRedis",
")",
"Close",
"(",
")",
"error",
"{",
"return",
"safeclose",
".",
"Close",
"(",
"sr",
".",
"client",
",",
"sr",
".",
"respChan",
",",
"sr",
".",
"closeChan",
")",
"\n",
"}"
] | // Close close the redis client and watcher channels | [
"Close",
"close",
"the",
"redis",
"client",
"and",
"watcher",
"channels"
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/examples/redis-lib/simple/simple.go#L221-L223 |
4,797 | ligato/cn-infra | datasync/kvdbsync/options.go | UseKV | func UseKV(kv keyval.KvProtoPlugin) Option {
return func(p *Plugin) {
p.KvPlugin = kv
}
} | go | func UseKV(kv keyval.KvProtoPlugin) Option {
return func(p *Plugin) {
p.KvPlugin = kv
}
} | [
"func",
"UseKV",
"(",
"kv",
"keyval",
".",
"KvProtoPlugin",
")",
"Option",
"{",
"return",
"func",
"(",
"p",
"*",
"Plugin",
")",
"{",
"p",
".",
"KvPlugin",
"=",
"kv",
"\n",
"}",
"\n",
"}"
] | // UseKV returns Option that sets KvPlugin dependency. | [
"UseKV",
"returns",
"Option",
"that",
"sets",
"KvPlugin",
"dependency",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/datasync/kvdbsync/options.go#L62-L66 |
4,798 | ligato/cn-infra | db/keyval/kvproto/proto_watcher_impl.go | GetValue | func (wr *protoWatchResp) GetValue(msg proto.Message) error {
return wr.serializer.Unmarshal(wr.BytesWatchResp.GetValue(), msg)
} | go | func (wr *protoWatchResp) GetValue(msg proto.Message) error {
return wr.serializer.Unmarshal(wr.BytesWatchResp.GetValue(), msg)
} | [
"func",
"(",
"wr",
"*",
"protoWatchResp",
")",
"GetValue",
"(",
"msg",
"proto",
".",
"Message",
")",
"error",
"{",
"return",
"wr",
".",
"serializer",
".",
"Unmarshal",
"(",
"wr",
".",
"BytesWatchResp",
".",
"GetValue",
"(",
")",
",",
"msg",
")",
"\n",
... | // GetValue returns the value after the change. | [
"GetValue",
"returns",
"the",
"value",
"after",
"the",
"change",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/kvproto/proto_watcher_impl.go#L53-L55 |
4,799 | ligato/cn-infra | db/keyval/kvproto/proto_watcher_impl.go | GetPrevValue | func (wr *protoWatchResp) GetPrevValue(msg proto.Message) (prevValueExist bool, err error) {
prevVal := wr.BytesWatchResp.GetPrevValue()
if prevVal == nil {
return false, nil
}
err = wr.serializer.Unmarshal(prevVal, msg)
if err != nil {
return true, err
}
return true, nil
} | go | func (wr *protoWatchResp) GetPrevValue(msg proto.Message) (prevValueExist bool, err error) {
prevVal := wr.BytesWatchResp.GetPrevValue()
if prevVal == nil {
return false, nil
}
err = wr.serializer.Unmarshal(prevVal, msg)
if err != nil {
return true, err
}
return true, nil
} | [
"func",
"(",
"wr",
"*",
"protoWatchResp",
")",
"GetPrevValue",
"(",
"msg",
"proto",
".",
"Message",
")",
"(",
"prevValueExist",
"bool",
",",
"err",
"error",
")",
"{",
"prevVal",
":=",
"wr",
".",
"BytesWatchResp",
".",
"GetPrevValue",
"(",
")",
"\n",
"if"... | // GetPrevValue returns the previous value after the change. | [
"GetPrevValue",
"returns",
"the",
"previous",
"value",
"after",
"the",
"change",
"."
] | 6552f4407e293b0986ec353eb0f01968cbecb928 | https://github.com/ligato/cn-infra/blob/6552f4407e293b0986ec353eb0f01968cbecb928/db/keyval/kvproto/proto_watcher_impl.go#L58-L68 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.