id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
158,100 | vitessio/vitess | go/vt/worker/row_aggregator.go | NewInsertsQueryBuilder | func NewInsertsQueryBuilder(dbName string, td *tabletmanagerdatapb.TableDefinition) *InsertsQueryBuilder {
// Example: INSERT INTO test (id, sub_id, msg) VALUES (0, 10, 'a'), (1, 11, 'b')
return &InsertsQueryBuilder{
BaseQueryBuilder{
head: "INSERT INTO " + sqlescape.EscapeID(dbName) + "." + sqlescape.EscapeID(td.Name) + " (" + strings.Join(escapeAll(td.Columns), ", ") + ") VALUES ",
separator: ",",
},
}
} | go | func NewInsertsQueryBuilder(dbName string, td *tabletmanagerdatapb.TableDefinition) *InsertsQueryBuilder {
// Example: INSERT INTO test (id, sub_id, msg) VALUES (0, 10, 'a'), (1, 11, 'b')
return &InsertsQueryBuilder{
BaseQueryBuilder{
head: "INSERT INTO " + sqlescape.EscapeID(dbName) + "." + sqlescape.EscapeID(td.Name) + " (" + strings.Join(escapeAll(td.Columns), ", ") + ") VALUES ",
separator: ",",
},
}
} | [
"func",
"NewInsertsQueryBuilder",
"(",
"dbName",
"string",
",",
"td",
"*",
"tabletmanagerdatapb",
".",
"TableDefinition",
")",
"*",
"InsertsQueryBuilder",
"{",
"// Example: INSERT INTO test (id, sub_id, msg) VALUES (0, 10, 'a'), (1, 11, 'b')",
"return",
"&",
"InsertsQueryBuilder"... | // NewInsertsQueryBuilder creates a new InsertsQueryBuilder. | [
"NewInsertsQueryBuilder",
"creates",
"a",
"new",
"InsertsQueryBuilder",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/worker/row_aggregator.go#L185-L193 |
158,101 | vitessio/vitess | go/vt/worker/row_aggregator.go | NewUpdatesQueryBuilder | func NewUpdatesQueryBuilder(dbName string, td *tabletmanagerdatapb.TableDefinition) *UpdatesQueryBuilder {
// Example: UPDATE test SET msg='a' WHERE id=0 AND sub_id=10
//
// Note: We cannot use INSERT INTO ... ON DUPLICATE KEY UPDATE here because
// it's not recommended for tables with more than one unique (i.e. the
// primary key) index. That's because the update function would also be
// triggered if a unique, non-primary key index matches the row. In that
// case, we would update the wrong row (it gets selected by the unique key
// and not the primary key).
return &UpdatesQueryBuilder{
BaseQueryBuilder: BaseQueryBuilder{
head: "UPDATE " + sqlescape.EscapeID(dbName) + "." + sqlescape.EscapeID(td.Name) + " SET ",
},
td: td,
// Build list of non-primary key columns (required for update statements).
nonPrimaryKeyColumns: orderedColumnsWithoutPrimaryKeyColumns(td),
}
} | go | func NewUpdatesQueryBuilder(dbName string, td *tabletmanagerdatapb.TableDefinition) *UpdatesQueryBuilder {
// Example: UPDATE test SET msg='a' WHERE id=0 AND sub_id=10
//
// Note: We cannot use INSERT INTO ... ON DUPLICATE KEY UPDATE here because
// it's not recommended for tables with more than one unique (i.e. the
// primary key) index. That's because the update function would also be
// triggered if a unique, non-primary key index matches the row. In that
// case, we would update the wrong row (it gets selected by the unique key
// and not the primary key).
return &UpdatesQueryBuilder{
BaseQueryBuilder: BaseQueryBuilder{
head: "UPDATE " + sqlescape.EscapeID(dbName) + "." + sqlescape.EscapeID(td.Name) + " SET ",
},
td: td,
// Build list of non-primary key columns (required for update statements).
nonPrimaryKeyColumns: orderedColumnsWithoutPrimaryKeyColumns(td),
}
} | [
"func",
"NewUpdatesQueryBuilder",
"(",
"dbName",
"string",
",",
"td",
"*",
"tabletmanagerdatapb",
".",
"TableDefinition",
")",
"*",
"UpdatesQueryBuilder",
"{",
"// Example: UPDATE test SET msg='a' WHERE id=0 AND sub_id=10",
"//",
"// Note: We cannot use INSERT INTO ... ON DUPLICATE... | // NewUpdatesQueryBuilder creates a new UpdatesQueryBuilder. | [
"NewUpdatesQueryBuilder",
"creates",
"a",
"new",
"UpdatesQueryBuilder",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/worker/row_aggregator.go#L218-L235 |
158,102 | vitessio/vitess | go/vt/worker/row_aggregator.go | NewDeletesQueryBuilder | func NewDeletesQueryBuilder(dbName string, td *tabletmanagerdatapb.TableDefinition) *DeletesQueryBuilder {
// Example: DELETE FROM test WHERE (id=0 AND sub_id=10) OR (id=1 AND sub_id=11)
//
// Note that we don't do multi row DELETEs with an IN expression because
// there are reports in the wild that MySQL 5.6 would do a full table scan
// for such a query. (We haven't confirmed this ourselves.)
return &DeletesQueryBuilder{
BaseQueryBuilder: BaseQueryBuilder{
head: "DELETE FROM " + sqlescape.EscapeID(dbName) + "." + sqlescape.EscapeID(td.Name) + " WHERE ",
separator: " OR ",
},
td: td,
}
} | go | func NewDeletesQueryBuilder(dbName string, td *tabletmanagerdatapb.TableDefinition) *DeletesQueryBuilder {
// Example: DELETE FROM test WHERE (id=0 AND sub_id=10) OR (id=1 AND sub_id=11)
//
// Note that we don't do multi row DELETEs with an IN expression because
// there are reports in the wild that MySQL 5.6 would do a full table scan
// for such a query. (We haven't confirmed this ourselves.)
return &DeletesQueryBuilder{
BaseQueryBuilder: BaseQueryBuilder{
head: "DELETE FROM " + sqlescape.EscapeID(dbName) + "." + sqlescape.EscapeID(td.Name) + " WHERE ",
separator: " OR ",
},
td: td,
}
} | [
"func",
"NewDeletesQueryBuilder",
"(",
"dbName",
"string",
",",
"td",
"*",
"tabletmanagerdatapb",
".",
"TableDefinition",
")",
"*",
"DeletesQueryBuilder",
"{",
"// Example: DELETE FROM test WHERE (id=0 AND sub_id=10) OR (id=1 AND sub_id=11)",
"//",
"// Note that we don't do multi r... | // NewDeletesQueryBuilder creates a new DeletesQueryBuilder. | [
"NewDeletesQueryBuilder",
"creates",
"a",
"new",
"DeletesQueryBuilder",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/worker/row_aggregator.go#L273-L286 |
158,103 | vitessio/vitess | go/vt/worker/topo_utils.go | FindHealthyTablet | func FindHealthyTablet(ctx context.Context, wr *wrangler.Wrangler, tsc *discovery.TabletStatsCache, cell, keyspace, shard string, minHealthyRdonlyTablets int, tabletType topodatapb.TabletType) (*topodatapb.TabletAlias, error) {
if tsc == nil {
// No healthcheck instance provided. Create one.
healthCheck := discovery.NewHealthCheck(*healthcheckRetryDelay, *healthCheckTimeout)
tsc = discovery.NewTabletStatsCache(healthCheck, wr.TopoServer(), cell)
watcher := discovery.NewShardReplicationWatcher(ctx, wr.TopoServer(), healthCheck, cell, keyspace, shard, *healthCheckTopologyRefresh, discovery.DefaultTopoReadConcurrency)
defer watcher.Stop()
defer healthCheck.Close()
}
healthyTablets, err := waitForHealthyTablets(ctx, wr, tsc, cell, keyspace, shard, minHealthyRdonlyTablets, *waitForHealthyTabletsTimeout, tabletType)
if err != nil {
return nil, err
}
// random server in the list is what we want
index := rand.Intn(len(healthyTablets))
return healthyTablets[index].Tablet.Alias, nil
} | go | func FindHealthyTablet(ctx context.Context, wr *wrangler.Wrangler, tsc *discovery.TabletStatsCache, cell, keyspace, shard string, minHealthyRdonlyTablets int, tabletType topodatapb.TabletType) (*topodatapb.TabletAlias, error) {
if tsc == nil {
// No healthcheck instance provided. Create one.
healthCheck := discovery.NewHealthCheck(*healthcheckRetryDelay, *healthCheckTimeout)
tsc = discovery.NewTabletStatsCache(healthCheck, wr.TopoServer(), cell)
watcher := discovery.NewShardReplicationWatcher(ctx, wr.TopoServer(), healthCheck, cell, keyspace, shard, *healthCheckTopologyRefresh, discovery.DefaultTopoReadConcurrency)
defer watcher.Stop()
defer healthCheck.Close()
}
healthyTablets, err := waitForHealthyTablets(ctx, wr, tsc, cell, keyspace, shard, minHealthyRdonlyTablets, *waitForHealthyTabletsTimeout, tabletType)
if err != nil {
return nil, err
}
// random server in the list is what we want
index := rand.Intn(len(healthyTablets))
return healthyTablets[index].Tablet.Alias, nil
} | [
"func",
"FindHealthyTablet",
"(",
"ctx",
"context",
".",
"Context",
",",
"wr",
"*",
"wrangler",
".",
"Wrangler",
",",
"tsc",
"*",
"discovery",
".",
"TabletStatsCache",
",",
"cell",
",",
"keyspace",
",",
"shard",
"string",
",",
"minHealthyRdonlyTablets",
"int",... | // FindHealthyTablet returns a random healthy tabletType tablet.
// Since we don't want to use them all, we require at least
// minHealthyRdonlyTablets servers to be healthy.
// May block up to -wait_for_healthy_rdonly_tablets_timeout. | [
"FindHealthyTablet",
"returns",
"a",
"random",
"healthy",
"tabletType",
"tablet",
".",
"Since",
"we",
"don",
"t",
"want",
"to",
"use",
"them",
"all",
"we",
"require",
"at",
"least",
"minHealthyRdonlyTablets",
"servers",
"to",
"be",
"healthy",
".",
"May",
"bloc... | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/worker/topo_utils.go#L50-L68 |
158,104 | vitessio/vitess | go/vt/vttablet/tabletmanager/rpc_backup.go | Backup | func (agent *ActionAgent) Backup(ctx context.Context, concurrency int, logger logutil.Logger, allowMaster bool) error {
if err := agent.lock(ctx); err != nil {
return err
}
defer agent.unlock()
if agent.Cnf == nil {
return fmt.Errorf("cannot perform backup without my.cnf, please restart vttablet with a my.cnf file specified")
}
// Check tablet type current process has.
// During a network partition it is possible that from the topology perspective this is no longer the master,
// but the process didn't find out about this.
// It is not safe to take backups from tablet in this state
currentTablet := agent.Tablet()
if !allowMaster && currentTablet.Type == topodatapb.TabletType_MASTER {
return fmt.Errorf("type MASTER cannot take backup. if you really need to do this, rerun the backup command with -allow_master")
}
tablet, err := agent.TopoServer.GetTablet(ctx, agent.TabletAlias)
if err != nil {
return err
}
if !allowMaster && tablet.Type == topodatapb.TabletType_MASTER {
return fmt.Errorf("type MASTER cannot take backup. if you really need to do this, rerun the backup command with -allow_master")
}
originalType := tablet.Type
engine, err := mysqlctl.GetBackupEngine()
if err != nil {
return vterrors.Wrap(err, "failed to find backup engine")
}
builtin, _ := engine.(*mysqlctl.BuiltinBackupEngine)
if builtin != nil {
// update our type to BACKUP
if _, err := topotools.ChangeType(ctx, agent.TopoServer, tablet.Alias, topodatapb.TabletType_BACKUP); err != nil {
return err
}
// let's update our internal state (stop query service and other things)
if err := agent.refreshTablet(ctx, "before backup"); err != nil {
return err
}
}
// create the loggers: tee to console and source
l := logutil.NewTeeLogger(logutil.NewConsoleLogger(), logger)
// now we can run the backup
dir := fmt.Sprintf("%v/%v", tablet.Keyspace, tablet.Shard)
name := fmt.Sprintf("%v.%v", time.Now().UTC().Format("2006-01-02.150405"), topoproto.TabletAliasString(tablet.Alias))
returnErr := mysqlctl.Backup(ctx, agent.Cnf, agent.MysqlDaemon, l, dir, name, concurrency, agent.hookExtraEnv())
if builtin != nil {
bgCtx := context.Background()
// Starting from here we won't be able to recover if we get stopped by a cancelled
// context. It is also possible that the context already timed out during the
// above call to Backup. Thus we use the background context to get through to the finish.
// change our type back to the original value
_, err = topotools.ChangeType(bgCtx, agent.TopoServer, tablet.Alias, originalType)
if err != nil {
// failure in changing the topology type is probably worse,
// so returning that (we logged the snapshot error anyway)
if returnErr != nil {
l.Errorf("mysql backup command returned error: %v", returnErr)
}
returnErr = err
}
// let's update our internal state (start query service and other things)
if err := agent.refreshTablet(bgCtx, "after backup"); err != nil {
return err
}
}
// and re-run health check to be sure to capture any replication delay
agent.runHealthCheckLocked()
return returnErr
} | go | func (agent *ActionAgent) Backup(ctx context.Context, concurrency int, logger logutil.Logger, allowMaster bool) error {
if err := agent.lock(ctx); err != nil {
return err
}
defer agent.unlock()
if agent.Cnf == nil {
return fmt.Errorf("cannot perform backup without my.cnf, please restart vttablet with a my.cnf file specified")
}
// Check tablet type current process has.
// During a network partition it is possible that from the topology perspective this is no longer the master,
// but the process didn't find out about this.
// It is not safe to take backups from tablet in this state
currentTablet := agent.Tablet()
if !allowMaster && currentTablet.Type == topodatapb.TabletType_MASTER {
return fmt.Errorf("type MASTER cannot take backup. if you really need to do this, rerun the backup command with -allow_master")
}
tablet, err := agent.TopoServer.GetTablet(ctx, agent.TabletAlias)
if err != nil {
return err
}
if !allowMaster && tablet.Type == topodatapb.TabletType_MASTER {
return fmt.Errorf("type MASTER cannot take backup. if you really need to do this, rerun the backup command with -allow_master")
}
originalType := tablet.Type
engine, err := mysqlctl.GetBackupEngine()
if err != nil {
return vterrors.Wrap(err, "failed to find backup engine")
}
builtin, _ := engine.(*mysqlctl.BuiltinBackupEngine)
if builtin != nil {
// update our type to BACKUP
if _, err := topotools.ChangeType(ctx, agent.TopoServer, tablet.Alias, topodatapb.TabletType_BACKUP); err != nil {
return err
}
// let's update our internal state (stop query service and other things)
if err := agent.refreshTablet(ctx, "before backup"); err != nil {
return err
}
}
// create the loggers: tee to console and source
l := logutil.NewTeeLogger(logutil.NewConsoleLogger(), logger)
// now we can run the backup
dir := fmt.Sprintf("%v/%v", tablet.Keyspace, tablet.Shard)
name := fmt.Sprintf("%v.%v", time.Now().UTC().Format("2006-01-02.150405"), topoproto.TabletAliasString(tablet.Alias))
returnErr := mysqlctl.Backup(ctx, agent.Cnf, agent.MysqlDaemon, l, dir, name, concurrency, agent.hookExtraEnv())
if builtin != nil {
bgCtx := context.Background()
// Starting from here we won't be able to recover if we get stopped by a cancelled
// context. It is also possible that the context already timed out during the
// above call to Backup. Thus we use the background context to get through to the finish.
// change our type back to the original value
_, err = topotools.ChangeType(bgCtx, agent.TopoServer, tablet.Alias, originalType)
if err != nil {
// failure in changing the topology type is probably worse,
// so returning that (we logged the snapshot error anyway)
if returnErr != nil {
l.Errorf("mysql backup command returned error: %v", returnErr)
}
returnErr = err
}
// let's update our internal state (start query service and other things)
if err := agent.refreshTablet(bgCtx, "after backup"); err != nil {
return err
}
}
// and re-run health check to be sure to capture any replication delay
agent.runHealthCheckLocked()
return returnErr
} | [
"func",
"(",
"agent",
"*",
"ActionAgent",
")",
"Backup",
"(",
"ctx",
"context",
".",
"Context",
",",
"concurrency",
"int",
",",
"logger",
"logutil",
".",
"Logger",
",",
"allowMaster",
"bool",
")",
"error",
"{",
"if",
"err",
":=",
"agent",
".",
"lock",
... | // Backup takes a db backup and sends it to the BackupStorage | [
"Backup",
"takes",
"a",
"db",
"backup",
"and",
"sends",
"it",
"to",
"the",
"BackupStorage"
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/vttablet/tabletmanager/rpc_backup.go#L34-L113 |
158,105 | vitessio/vitess | go/vt/vttablet/tabletmanager/rpc_backup.go | RestoreFromBackup | func (agent *ActionAgent) RestoreFromBackup(ctx context.Context, logger logutil.Logger) error {
if err := agent.lock(ctx); err != nil {
return err
}
defer agent.unlock()
tablet, err := agent.TopoServer.GetTablet(ctx, agent.TabletAlias)
if err != nil {
return err
}
if tablet.Type == topodatapb.TabletType_MASTER {
return fmt.Errorf("type MASTER cannot restore from backup, if you really need to do this, restart vttablet in replica mode")
}
// create the loggers: tee to console and source
l := logutil.NewTeeLogger(logutil.NewConsoleLogger(), logger)
// now we can run restore
err = agent.restoreDataLocked(ctx, l, true /* deleteBeforeRestore */)
// re-run health check to be sure to capture any replication delay
agent.runHealthCheckLocked()
return err
} | go | func (agent *ActionAgent) RestoreFromBackup(ctx context.Context, logger logutil.Logger) error {
if err := agent.lock(ctx); err != nil {
return err
}
defer agent.unlock()
tablet, err := agent.TopoServer.GetTablet(ctx, agent.TabletAlias)
if err != nil {
return err
}
if tablet.Type == topodatapb.TabletType_MASTER {
return fmt.Errorf("type MASTER cannot restore from backup, if you really need to do this, restart vttablet in replica mode")
}
// create the loggers: tee to console and source
l := logutil.NewTeeLogger(logutil.NewConsoleLogger(), logger)
// now we can run restore
err = agent.restoreDataLocked(ctx, l, true /* deleteBeforeRestore */)
// re-run health check to be sure to capture any replication delay
agent.runHealthCheckLocked()
return err
} | [
"func",
"(",
"agent",
"*",
"ActionAgent",
")",
"RestoreFromBackup",
"(",
"ctx",
"context",
".",
"Context",
",",
"logger",
"logutil",
".",
"Logger",
")",
"error",
"{",
"if",
"err",
":=",
"agent",
".",
"lock",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
... | // RestoreFromBackup deletes all local data and restores anew from the latest backup. | [
"RestoreFromBackup",
"deletes",
"all",
"local",
"data",
"and",
"restores",
"anew",
"from",
"the",
"latest",
"backup",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/vttablet/tabletmanager/rpc_backup.go#L116-L140 |
158,106 | vitessio/vitess | go/vt/schemamanager/tablet_executor.go | NewTabletExecutor | func NewTabletExecutor(wr *wrangler.Wrangler, waitSlaveTimeout time.Duration) *TabletExecutor {
return &TabletExecutor{
wr: wr,
isClosed: true,
allowBigSchemaChange: false,
waitSlaveTimeout: waitSlaveTimeout,
}
} | go | func NewTabletExecutor(wr *wrangler.Wrangler, waitSlaveTimeout time.Duration) *TabletExecutor {
return &TabletExecutor{
wr: wr,
isClosed: true,
allowBigSchemaChange: false,
waitSlaveTimeout: waitSlaveTimeout,
}
} | [
"func",
"NewTabletExecutor",
"(",
"wr",
"*",
"wrangler",
".",
"Wrangler",
",",
"waitSlaveTimeout",
"time",
".",
"Duration",
")",
"*",
"TabletExecutor",
"{",
"return",
"&",
"TabletExecutor",
"{",
"wr",
":",
"wr",
",",
"isClosed",
":",
"true",
",",
"allowBigSc... | // NewTabletExecutor creates a new TabletExecutor instance | [
"NewTabletExecutor",
"creates",
"a",
"new",
"TabletExecutor",
"instance"
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/schemamanager/tablet_executor.go#L44-L51 |
158,107 | vitessio/vitess | go/vt/schemamanager/tablet_executor.go | Open | func (exec *TabletExecutor) Open(ctx context.Context, keyspace string) error {
if !exec.isClosed {
return nil
}
exec.keyspace = keyspace
shardNames, err := exec.wr.TopoServer().GetShardNames(ctx, keyspace)
if err != nil {
return fmt.Errorf("unable to get shard names for keyspace: %s, error: %v", keyspace, err)
}
exec.tablets = make([]*topodatapb.Tablet, len(shardNames))
for i, shardName := range shardNames {
shardInfo, err := exec.wr.TopoServer().GetShard(ctx, keyspace, shardName)
if err != nil {
return fmt.Errorf("unable to get shard info, keyspace: %s, shard: %s, error: %v", keyspace, shardName, err)
}
if !shardInfo.HasMaster() {
return fmt.Errorf("shard: %s does not have a master", shardName)
}
tabletInfo, err := exec.wr.TopoServer().GetTablet(ctx, shardInfo.MasterAlias)
if err != nil {
return fmt.Errorf("unable to get master tablet info, keyspace: %s, shard: %s, error: %v", keyspace, shardName, err)
}
exec.tablets[i] = tabletInfo.Tablet
}
if len(exec.tablets) == 0 {
return fmt.Errorf("keyspace: %s does not contain any master tablets", keyspace)
}
exec.isClosed = false
return nil
} | go | func (exec *TabletExecutor) Open(ctx context.Context, keyspace string) error {
if !exec.isClosed {
return nil
}
exec.keyspace = keyspace
shardNames, err := exec.wr.TopoServer().GetShardNames(ctx, keyspace)
if err != nil {
return fmt.Errorf("unable to get shard names for keyspace: %s, error: %v", keyspace, err)
}
exec.tablets = make([]*topodatapb.Tablet, len(shardNames))
for i, shardName := range shardNames {
shardInfo, err := exec.wr.TopoServer().GetShard(ctx, keyspace, shardName)
if err != nil {
return fmt.Errorf("unable to get shard info, keyspace: %s, shard: %s, error: %v", keyspace, shardName, err)
}
if !shardInfo.HasMaster() {
return fmt.Errorf("shard: %s does not have a master", shardName)
}
tabletInfo, err := exec.wr.TopoServer().GetTablet(ctx, shardInfo.MasterAlias)
if err != nil {
return fmt.Errorf("unable to get master tablet info, keyspace: %s, shard: %s, error: %v", keyspace, shardName, err)
}
exec.tablets[i] = tabletInfo.Tablet
}
if len(exec.tablets) == 0 {
return fmt.Errorf("keyspace: %s does not contain any master tablets", keyspace)
}
exec.isClosed = false
return nil
} | [
"func",
"(",
"exec",
"*",
"TabletExecutor",
")",
"Open",
"(",
"ctx",
"context",
".",
"Context",
",",
"keyspace",
"string",
")",
"error",
"{",
"if",
"!",
"exec",
".",
"isClosed",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"exec",
".",
"keyspace",
"=",
"ke... | // Open opens a connection to the master for every shard. | [
"Open",
"opens",
"a",
"connection",
"to",
"the",
"master",
"for",
"every",
"shard",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/schemamanager/tablet_executor.go#L66-L96 |
158,108 | vitessio/vitess | go/vt/schemamanager/tablet_executor.go | Validate | func (exec *TabletExecutor) Validate(ctx context.Context, sqls []string) error {
if exec.isClosed {
return fmt.Errorf("executor is closed")
}
parsedDDLs, err := exec.parseDDLs(sqls)
if err != nil {
return err
}
bigSchemaChange, err := exec.detectBigSchemaChanges(ctx, parsedDDLs)
if bigSchemaChange && exec.allowBigSchemaChange {
exec.wr.Logger().Warningf("Processing big schema change. This may cause visible MySQL downtime.")
return nil
}
return err
} | go | func (exec *TabletExecutor) Validate(ctx context.Context, sqls []string) error {
if exec.isClosed {
return fmt.Errorf("executor is closed")
}
parsedDDLs, err := exec.parseDDLs(sqls)
if err != nil {
return err
}
bigSchemaChange, err := exec.detectBigSchemaChanges(ctx, parsedDDLs)
if bigSchemaChange && exec.allowBigSchemaChange {
exec.wr.Logger().Warningf("Processing big schema change. This may cause visible MySQL downtime.")
return nil
}
return err
} | [
"func",
"(",
"exec",
"*",
"TabletExecutor",
")",
"Validate",
"(",
"ctx",
"context",
".",
"Context",
",",
"sqls",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"exec",
".",
"isClosed",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
... | // Validate validates a list of sql statements. | [
"Validate",
"validates",
"a",
"list",
"of",
"sql",
"statements",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/schemamanager/tablet_executor.go#L99-L115 |
158,109 | vitessio/vitess | go/vt/schemamanager/tablet_executor.go | Execute | func (exec *TabletExecutor) Execute(ctx context.Context, sqls []string) *ExecuteResult {
execResult := ExecuteResult{}
execResult.Sqls = sqls
if exec.isClosed {
execResult.ExecutorErr = "executor is closed"
return &execResult
}
startTime := time.Now()
defer func() { execResult.TotalTimeSpent = time.Since(startTime) }()
// Lock the keyspace so our schema change doesn't overlap with other
// keyspace-wide operations like resharding migrations.
ctx, unlock, lockErr := exec.wr.TopoServer().LockKeyspace(ctx, exec.keyspace, "ApplySchemaKeyspace")
if lockErr != nil {
execResult.ExecutorErr = lockErr.Error()
return &execResult
}
defer func() {
// This is complicated because execResult.ExecutorErr
// is not of type error.
var unlockErr error
unlock(&unlockErr)
if execResult.ExecutorErr == "" && unlockErr != nil {
execResult.ExecutorErr = unlockErr.Error()
}
}()
// Make sure the schema changes introduce a table definition change.
if err := exec.preflightSchemaChanges(ctx, sqls); err != nil {
execResult.ExecutorErr = err.Error()
return &execResult
}
for index, sql := range sqls {
execResult.CurSQLIndex = index
exec.executeOnAllTablets(ctx, &execResult, sql)
if len(execResult.FailedShards) > 0 {
break
}
}
return &execResult
} | go | func (exec *TabletExecutor) Execute(ctx context.Context, sqls []string) *ExecuteResult {
execResult := ExecuteResult{}
execResult.Sqls = sqls
if exec.isClosed {
execResult.ExecutorErr = "executor is closed"
return &execResult
}
startTime := time.Now()
defer func() { execResult.TotalTimeSpent = time.Since(startTime) }()
// Lock the keyspace so our schema change doesn't overlap with other
// keyspace-wide operations like resharding migrations.
ctx, unlock, lockErr := exec.wr.TopoServer().LockKeyspace(ctx, exec.keyspace, "ApplySchemaKeyspace")
if lockErr != nil {
execResult.ExecutorErr = lockErr.Error()
return &execResult
}
defer func() {
// This is complicated because execResult.ExecutorErr
// is not of type error.
var unlockErr error
unlock(&unlockErr)
if execResult.ExecutorErr == "" && unlockErr != nil {
execResult.ExecutorErr = unlockErr.Error()
}
}()
// Make sure the schema changes introduce a table definition change.
if err := exec.preflightSchemaChanges(ctx, sqls); err != nil {
execResult.ExecutorErr = err.Error()
return &execResult
}
for index, sql := range sqls {
execResult.CurSQLIndex = index
exec.executeOnAllTablets(ctx, &execResult, sql)
if len(execResult.FailedShards) > 0 {
break
}
}
return &execResult
} | [
"func",
"(",
"exec",
"*",
"TabletExecutor",
")",
"Execute",
"(",
"ctx",
"context",
".",
"Context",
",",
"sqls",
"[",
"]",
"string",
")",
"*",
"ExecuteResult",
"{",
"execResult",
":=",
"ExecuteResult",
"{",
"}",
"\n",
"execResult",
".",
"Sqls",
"=",
"sqls... | // Execute applies schema changes | [
"Execute",
"applies",
"schema",
"changes"
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/schemamanager/tablet_executor.go#L180-L221 |
158,110 | vitessio/vitess | go/vt/schemamanager/tablet_executor.go | Close | func (exec *TabletExecutor) Close() {
if !exec.isClosed {
exec.tablets = nil
exec.isClosed = true
}
} | go | func (exec *TabletExecutor) Close() {
if !exec.isClosed {
exec.tablets = nil
exec.isClosed = true
}
} | [
"func",
"(",
"exec",
"*",
"TabletExecutor",
")",
"Close",
"(",
")",
"{",
"if",
"!",
"exec",
".",
"isClosed",
"{",
"exec",
".",
"tablets",
"=",
"nil",
"\n",
"exec",
".",
"isClosed",
"=",
"true",
"\n",
"}",
"\n",
"}"
] | // Close clears tablet executor states | [
"Close",
"clears",
"tablet",
"executor",
"states"
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/schemamanager/tablet_executor.go#L296-L301 |
158,111 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | NewMysqld | func NewMysqld(dbcfgs *dbconfigs.DBConfigs) *Mysqld {
result := &Mysqld{
dbcfgs: dbcfgs,
}
// Create and open the connection pool for dba access.
result.dbaPool = dbconnpool.NewConnectionPool("DbaConnPool", *dbaPoolSize, *dbaIdleTimeout, *poolDynamicHostnameResolution)
result.dbaPool.Open(dbcfgs.Dba(), dbaMysqlStats)
// Create and open the connection pool for app access.
result.appPool = dbconnpool.NewConnectionPool("AppConnPool", *appPoolSize, *appIdleTimeout, *poolDynamicHostnameResolution)
result.appPool.Open(dbcfgs.AppWithDB(), appMysqlStats)
return result
} | go | func NewMysqld(dbcfgs *dbconfigs.DBConfigs) *Mysqld {
result := &Mysqld{
dbcfgs: dbcfgs,
}
// Create and open the connection pool for dba access.
result.dbaPool = dbconnpool.NewConnectionPool("DbaConnPool", *dbaPoolSize, *dbaIdleTimeout, *poolDynamicHostnameResolution)
result.dbaPool.Open(dbcfgs.Dba(), dbaMysqlStats)
// Create and open the connection pool for app access.
result.appPool = dbconnpool.NewConnectionPool("AppConnPool", *appPoolSize, *appIdleTimeout, *poolDynamicHostnameResolution)
result.appPool.Open(dbcfgs.AppWithDB(), appMysqlStats)
return result
} | [
"func",
"NewMysqld",
"(",
"dbcfgs",
"*",
"dbconfigs",
".",
"DBConfigs",
")",
"*",
"Mysqld",
"{",
"result",
":=",
"&",
"Mysqld",
"{",
"dbcfgs",
":",
"dbcfgs",
",",
"}",
"\n\n",
"// Create and open the connection pool for dba access.",
"result",
".",
"dbaPool",
"=... | // NewMysqld creates a Mysqld object based on the provided configuration
// and connection parameters. | [
"NewMysqld",
"creates",
"a",
"Mysqld",
"object",
"based",
"on",
"the",
"provided",
"configuration",
"and",
"connection",
"parameters",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L97-L111 |
158,112 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | RunMysqlUpgrade | func (mysqld *Mysqld) RunMysqlUpgrade() error {
// Execute as remote action on mysqlctld if requested.
if *socketFile != "" {
log.Infof("executing Mysqld.RunMysqlUpgrade() remotely via mysqlctld server: %v", *socketFile)
client, err := mysqlctlclient.New("unix", *socketFile)
if err != nil {
return fmt.Errorf("can't dial mysqlctld: %v", err)
}
defer client.Close()
return client.RunMysqlUpgrade(context.TODO())
}
// Find mysql_upgrade. If not there, we do nothing.
dir, err := vtenv.VtMysqlRoot()
if err != nil {
log.Warningf("VT_MYSQL_ROOT not set, skipping mysql_upgrade step: %v", err)
return nil
}
name, err := binaryPath(dir, "mysql_upgrade")
if err != nil {
log.Warningf("mysql_upgrade binary not present, skipping it: %v", err)
return nil
}
// Since we started mysql with --skip-grant-tables, we should
// be able to run mysql_upgrade without any valid user or
// password. However, mysql_upgrade executes a 'flush
// privileges' right in the middle, and then subsequent
// commands fail if we don't use valid credentials. So let's
// use dba credentials.
params, err := dbconfigs.WithCredentials(mysqld.dbcfgs.Dba())
if err != nil {
return err
}
defaultsFile, err := mysqld.defaultsExtraFile(params)
if err != nil {
return err
}
defer os.Remove(defaultsFile)
// Run the program, if it fails, we fail. Note in this
// moment, mysqld is running with no grant tables on the local
// socket only, so this doesn't need any user or password.
args := []string{
// --defaults-file=* must be the first arg.
"--defaults-file=" + defaultsFile,
"--force", // Don't complain if it's already been upgraded.
}
cmd := exec.Command(name, args...)
cmd.Env = []string{os.ExpandEnv("LD_LIBRARY_PATH=$VT_MYSQL_ROOT/lib/mysql")}
out, err := cmd.CombinedOutput()
log.Infof("mysql_upgrade output: %s", out)
return err
} | go | func (mysqld *Mysqld) RunMysqlUpgrade() error {
// Execute as remote action on mysqlctld if requested.
if *socketFile != "" {
log.Infof("executing Mysqld.RunMysqlUpgrade() remotely via mysqlctld server: %v", *socketFile)
client, err := mysqlctlclient.New("unix", *socketFile)
if err != nil {
return fmt.Errorf("can't dial mysqlctld: %v", err)
}
defer client.Close()
return client.RunMysqlUpgrade(context.TODO())
}
// Find mysql_upgrade. If not there, we do nothing.
dir, err := vtenv.VtMysqlRoot()
if err != nil {
log.Warningf("VT_MYSQL_ROOT not set, skipping mysql_upgrade step: %v", err)
return nil
}
name, err := binaryPath(dir, "mysql_upgrade")
if err != nil {
log.Warningf("mysql_upgrade binary not present, skipping it: %v", err)
return nil
}
// Since we started mysql with --skip-grant-tables, we should
// be able to run mysql_upgrade without any valid user or
// password. However, mysql_upgrade executes a 'flush
// privileges' right in the middle, and then subsequent
// commands fail if we don't use valid credentials. So let's
// use dba credentials.
params, err := dbconfigs.WithCredentials(mysqld.dbcfgs.Dba())
if err != nil {
return err
}
defaultsFile, err := mysqld.defaultsExtraFile(params)
if err != nil {
return err
}
defer os.Remove(defaultsFile)
// Run the program, if it fails, we fail. Note in this
// moment, mysqld is running with no grant tables on the local
// socket only, so this doesn't need any user or password.
args := []string{
// --defaults-file=* must be the first arg.
"--defaults-file=" + defaultsFile,
"--force", // Don't complain if it's already been upgraded.
}
cmd := exec.Command(name, args...)
cmd.Env = []string{os.ExpandEnv("LD_LIBRARY_PATH=$VT_MYSQL_ROOT/lib/mysql")}
out, err := cmd.CombinedOutput()
log.Infof("mysql_upgrade output: %s", out)
return err
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"RunMysqlUpgrade",
"(",
")",
"error",
"{",
"// Execute as remote action on mysqlctld if requested.",
"if",
"*",
"socketFile",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"*",
"socketFile",
")",
... | // RunMysqlUpgrade will run the mysql_upgrade program on the current
// install. Will be called only when mysqld is running with no
// network and no grant tables. | [
"RunMysqlUpgrade",
"will",
"run",
"the",
"mysql_upgrade",
"program",
"on",
"the",
"current",
"install",
".",
"Will",
"be",
"called",
"only",
"when",
"mysqld",
"is",
"running",
"with",
"no",
"network",
"and",
"no",
"grant",
"tables",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L116-L169 |
158,113 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | Start | func (mysqld *Mysqld) Start(ctx context.Context, cnf *Mycnf, mysqldArgs ...string) error {
// Execute as remote action on mysqlctld if requested.
if *socketFile != "" {
log.Infof("executing Mysqld.Start() remotely via mysqlctld server: %v", *socketFile)
client, err := mysqlctlclient.New("unix", *socketFile)
if err != nil {
return fmt.Errorf("can't dial mysqlctld: %v", err)
}
defer client.Close()
return client.Start(ctx, mysqldArgs...)
}
if err := mysqld.startNoWait(ctx, cnf, mysqldArgs...); err != nil {
return err
}
return mysqld.Wait(ctx, cnf)
} | go | func (mysqld *Mysqld) Start(ctx context.Context, cnf *Mycnf, mysqldArgs ...string) error {
// Execute as remote action on mysqlctld if requested.
if *socketFile != "" {
log.Infof("executing Mysqld.Start() remotely via mysqlctld server: %v", *socketFile)
client, err := mysqlctlclient.New("unix", *socketFile)
if err != nil {
return fmt.Errorf("can't dial mysqlctld: %v", err)
}
defer client.Close()
return client.Start(ctx, mysqldArgs...)
}
if err := mysqld.startNoWait(ctx, cnf, mysqldArgs...); err != nil {
return err
}
return mysqld.Wait(ctx, cnf)
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"Start",
"(",
"ctx",
"context",
".",
"Context",
",",
"cnf",
"*",
"Mycnf",
",",
"mysqldArgs",
"...",
"string",
")",
"error",
"{",
"// Execute as remote action on mysqlctld if requested.",
"if",
"*",
"socketFile",
"!=",
... | // Start will start the mysql daemon, either by running the
// 'mysqld_start' hook, or by running mysqld_safe in the background.
// If a mysqlctld address is provided in a flag, Start will run
// remotely. When waiting for mysqld to start, we will use
// the dba user. | [
"Start",
"will",
"start",
"the",
"mysql",
"daemon",
"either",
"by",
"running",
"the",
"mysqld_start",
"hook",
"or",
"by",
"running",
"mysqld_safe",
"in",
"the",
"background",
".",
"If",
"a",
"mysqlctld",
"address",
"is",
"provided",
"in",
"a",
"flag",
"Start... | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L176-L193 |
158,114 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | startNoWait | func (mysqld *Mysqld) startNoWait(ctx context.Context, cnf *Mycnf, mysqldArgs ...string) error {
var name string
ts := fmt.Sprintf("Mysqld.Start(%v)", time.Now().Unix())
// try the mysqld start hook, if any
switch hr := hook.NewHook("mysqld_start", mysqldArgs).Execute(); hr.ExitStatus {
case hook.HOOK_SUCCESS:
// hook exists and worked, we can keep going
name = "mysqld_start hook"
case hook.HOOK_DOES_NOT_EXIST:
// hook doesn't exist, run mysqld_safe ourselves
log.Infof("%v: No mysqld_start hook, running mysqld_safe directly", ts)
dir, err := vtenv.VtMysqlRoot()
if err != nil {
return err
}
name, err = binaryPath(dir, "mysqld_safe")
if err != nil {
// The movement to use systemd means that mysqld_safe is not always provided.
// This should not be considered an issue do not generate a warning.
log.Infof("%v: trying to launch mysqld instead", err)
name, err = binaryPath(dir, "mysqld")
// If this also fails, return an error.
if err != nil {
return err
}
}
arg := []string{
"--defaults-file=" + cnf.path}
arg = append(arg, mysqldArgs...)
env := []string{os.ExpandEnv("LD_LIBRARY_PATH=$VT_MYSQL_ROOT/lib/mysql")}
cmd := exec.Command(name, arg...)
cmd.Dir = dir
cmd.Env = env
log.Infof("%v %#v", ts, cmd)
stderr, err := cmd.StderrPipe()
if err != nil {
return err
}
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
go func() {
scanner := bufio.NewScanner(stderr)
for scanner.Scan() {
log.Infof("%v stderr: %v", ts, scanner.Text())
}
}()
go func() {
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {
log.Infof("%v stdout: %v", ts, scanner.Text())
}
}()
err = cmd.Start()
if err != nil {
return err
}
mysqld.mutex.Lock()
mysqld.cancelWaitCmd = make(chan struct{})
go func(cancel <-chan struct{}) {
// Wait regardless of cancel, so we don't generate defunct processes.
err := cmd.Wait()
log.Infof("%v exit: %v", ts, err)
// The process exited. Trigger OnTerm callbacks, unless we were cancelled.
select {
case <-cancel:
default:
mysqld.mutex.Lock()
for _, callback := range mysqld.onTermFuncs {
go callback()
}
mysqld.mutex.Unlock()
}
}(mysqld.cancelWaitCmd)
mysqld.mutex.Unlock()
default:
// hook failed, we report error
return fmt.Errorf("mysqld_start hook failed: %v", hr.String())
}
return nil
} | go | func (mysqld *Mysqld) startNoWait(ctx context.Context, cnf *Mycnf, mysqldArgs ...string) error {
var name string
ts := fmt.Sprintf("Mysqld.Start(%v)", time.Now().Unix())
// try the mysqld start hook, if any
switch hr := hook.NewHook("mysqld_start", mysqldArgs).Execute(); hr.ExitStatus {
case hook.HOOK_SUCCESS:
// hook exists and worked, we can keep going
name = "mysqld_start hook"
case hook.HOOK_DOES_NOT_EXIST:
// hook doesn't exist, run mysqld_safe ourselves
log.Infof("%v: No mysqld_start hook, running mysqld_safe directly", ts)
dir, err := vtenv.VtMysqlRoot()
if err != nil {
return err
}
name, err = binaryPath(dir, "mysqld_safe")
if err != nil {
// The movement to use systemd means that mysqld_safe is not always provided.
// This should not be considered an issue do not generate a warning.
log.Infof("%v: trying to launch mysqld instead", err)
name, err = binaryPath(dir, "mysqld")
// If this also fails, return an error.
if err != nil {
return err
}
}
arg := []string{
"--defaults-file=" + cnf.path}
arg = append(arg, mysqldArgs...)
env := []string{os.ExpandEnv("LD_LIBRARY_PATH=$VT_MYSQL_ROOT/lib/mysql")}
cmd := exec.Command(name, arg...)
cmd.Dir = dir
cmd.Env = env
log.Infof("%v %#v", ts, cmd)
stderr, err := cmd.StderrPipe()
if err != nil {
return err
}
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
go func() {
scanner := bufio.NewScanner(stderr)
for scanner.Scan() {
log.Infof("%v stderr: %v", ts, scanner.Text())
}
}()
go func() {
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {
log.Infof("%v stdout: %v", ts, scanner.Text())
}
}()
err = cmd.Start()
if err != nil {
return err
}
mysqld.mutex.Lock()
mysqld.cancelWaitCmd = make(chan struct{})
go func(cancel <-chan struct{}) {
// Wait regardless of cancel, so we don't generate defunct processes.
err := cmd.Wait()
log.Infof("%v exit: %v", ts, err)
// The process exited. Trigger OnTerm callbacks, unless we were cancelled.
select {
case <-cancel:
default:
mysqld.mutex.Lock()
for _, callback := range mysqld.onTermFuncs {
go callback()
}
mysqld.mutex.Unlock()
}
}(mysqld.cancelWaitCmd)
mysqld.mutex.Unlock()
default:
// hook failed, we report error
return fmt.Errorf("mysqld_start hook failed: %v", hr.String())
}
return nil
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"startNoWait",
"(",
"ctx",
"context",
".",
"Context",
",",
"cnf",
"*",
"Mycnf",
",",
"mysqldArgs",
"...",
"string",
")",
"error",
"{",
"var",
"name",
"string",
"\n",
"ts",
":=",
"fmt",
".",
"Sprintf",
"(",
"... | // startNoWait is the internal version of Start, and it doesn't wait. | [
"startNoWait",
"is",
"the",
"internal",
"version",
"of",
"Start",
"and",
"it",
"doesn",
"t",
"wait",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L196-L282 |
158,115 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | wait | func (mysqld *Mysqld) wait(ctx context.Context, cnf *Mycnf, params *mysql.ConnParams) error {
log.Infof("Waiting for mysqld socket file (%v) to be ready...", cnf.SocketFile)
for {
select {
case <-ctx.Done():
return errors.New("deadline exceeded waiting for mysqld socket file to appear: " + cnf.SocketFile)
default:
}
_, statErr := os.Stat(cnf.SocketFile)
if statErr == nil {
// Make sure the socket file isn't stale.
conn, connErr := mysql.Connect(ctx, params)
if connErr == nil {
conn.Close()
return nil
}
log.Infof("mysqld socket file exists, but can't connect: %v", connErr)
} else if !os.IsNotExist(statErr) {
return fmt.Errorf("can't stat mysqld socket file: %v", statErr)
}
time.Sleep(1000 * time.Millisecond)
}
} | go | func (mysqld *Mysqld) wait(ctx context.Context, cnf *Mycnf, params *mysql.ConnParams) error {
log.Infof("Waiting for mysqld socket file (%v) to be ready...", cnf.SocketFile)
for {
select {
case <-ctx.Done():
return errors.New("deadline exceeded waiting for mysqld socket file to appear: " + cnf.SocketFile)
default:
}
_, statErr := os.Stat(cnf.SocketFile)
if statErr == nil {
// Make sure the socket file isn't stale.
conn, connErr := mysql.Connect(ctx, params)
if connErr == nil {
conn.Close()
return nil
}
log.Infof("mysqld socket file exists, but can't connect: %v", connErr)
} else if !os.IsNotExist(statErr) {
return fmt.Errorf("can't stat mysqld socket file: %v", statErr)
}
time.Sleep(1000 * time.Millisecond)
}
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"wait",
"(",
"ctx",
"context",
".",
"Context",
",",
"cnf",
"*",
"Mycnf",
",",
"params",
"*",
"mysql",
".",
"ConnParams",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"cnf",
".",
"SocketFil... | // wait is the internal version of Wait, that takes credentials. | [
"wait",
"is",
"the",
"internal",
"version",
"of",
"Wait",
"that",
"takes",
"credentials",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L297-L321 |
158,116 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | execCmd | func execCmd(name string, args, env []string, dir string, input io.Reader) (cmd *exec.Cmd, output string, err error) {
cmdPath, _ := exec.LookPath(name)
log.Infof("execCmd: %v %v %v", name, cmdPath, args)
cmd = exec.Command(cmdPath, args...)
cmd.Env = env
cmd.Dir = dir
if input != nil {
cmd.Stdin = input
}
out, err := cmd.CombinedOutput()
output = string(out)
if err != nil {
log.Infof("execCmd: %v failed: %v", name, err)
err = fmt.Errorf("%v: %v, output: %v", name, err, output)
}
log.Infof("execCmd: %v output: %v", name, output)
return cmd, output, err
} | go | func execCmd(name string, args, env []string, dir string, input io.Reader) (cmd *exec.Cmd, output string, err error) {
cmdPath, _ := exec.LookPath(name)
log.Infof("execCmd: %v %v %v", name, cmdPath, args)
cmd = exec.Command(cmdPath, args...)
cmd.Env = env
cmd.Dir = dir
if input != nil {
cmd.Stdin = input
}
out, err := cmd.CombinedOutput()
output = string(out)
if err != nil {
log.Infof("execCmd: %v failed: %v", name, err)
err = fmt.Errorf("%v: %v, output: %v", name, err, output)
}
log.Infof("execCmd: %v output: %v", name, output)
return cmd, output, err
} | [
"func",
"execCmd",
"(",
"name",
"string",
",",
"args",
",",
"env",
"[",
"]",
"string",
",",
"dir",
"string",
",",
"input",
"io",
".",
"Reader",
")",
"(",
"cmd",
"*",
"exec",
".",
"Cmd",
",",
"output",
"string",
",",
"err",
"error",
")",
"{",
"cmd... | // execCmd searches the PATH for a command and runs it, logging the output.
// If input is not nil, pipe it to the command's stdin. | [
"execCmd",
"searches",
"the",
"PATH",
"for",
"a",
"command",
"and",
"runs",
"it",
"logging",
"the",
"output",
".",
"If",
"input",
"is",
"not",
"nil",
"pipe",
"it",
"to",
"the",
"command",
"s",
"stdin",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L433-L451 |
158,117 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | binaryPath | func binaryPath(root, binary string) (string, error) {
subdirs := []string{"sbin", "bin", "libexec"}
for _, subdir := range subdirs {
binPath := path.Join(root, subdir, binary)
if _, err := os.Stat(binPath); err == nil {
return binPath, nil
}
}
return "", fmt.Errorf("%s not found in any of %s/{%s}",
binary, root, strings.Join(subdirs, ","))
} | go | func binaryPath(root, binary string) (string, error) {
subdirs := []string{"sbin", "bin", "libexec"}
for _, subdir := range subdirs {
binPath := path.Join(root, subdir, binary)
if _, err := os.Stat(binPath); err == nil {
return binPath, nil
}
}
return "", fmt.Errorf("%s not found in any of %s/{%s}",
binary, root, strings.Join(subdirs, ","))
} | [
"func",
"binaryPath",
"(",
"root",
",",
"binary",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"subdirs",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"\n",
"for",
"_",
",",
"subdir",
":=",
"range",
... | // binaryPath does a limited path lookup for a command,
// searching only within sbin and bin in the given root. | [
"binaryPath",
"does",
"a",
"limited",
"path",
"lookup",
"for",
"a",
"command",
"searching",
"only",
"within",
"sbin",
"and",
"bin",
"in",
"the",
"given",
"root",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L455-L465 |
158,118 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | useMysqldInitialize | func useMysqldInitialize(version string) bool {
return strings.Contains(version, "Ver 5.7.") ||
strings.Contains(version, "Ver 8.0.")
} | go | func useMysqldInitialize(version string) bool {
return strings.Contains(version, "Ver 5.7.") ||
strings.Contains(version, "Ver 8.0.")
} | [
"func",
"useMysqldInitialize",
"(",
"version",
"string",
")",
"bool",
"{",
"return",
"strings",
".",
"Contains",
"(",
"version",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"version",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // MySQL 5.7 GA and up have deprecated mysql_install_db.
// Instead, initialization is built into mysqld. | [
"MySQL",
"5",
".",
"7",
"GA",
"and",
"up",
"have",
"deprecated",
"mysql_install_db",
".",
"Instead",
"initialization",
"is",
"built",
"into",
"mysqld",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L539-L542 |
158,119 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | RefreshConfig | func (mysqld *Mysqld) RefreshConfig(ctx context.Context, cnf *Mycnf) error {
// Execute as remote action on mysqlctld if requested.
if *socketFile != "" {
log.Infof("executing Mysqld.RefreshConfig() remotely via mysqlctld server: %v", *socketFile)
client, err := mysqlctlclient.New("unix", *socketFile)
if err != nil {
return fmt.Errorf("can't dial mysqlctld: %v", err)
}
defer client.Close()
return client.RefreshConfig(ctx)
}
log.Info("Checking for updates to my.cnf")
root, err := vtenv.VtRoot()
if err != nil {
return err
}
f, err := ioutil.TempFile(path.Dir(cnf.path), "my.cnf")
if err != nil {
return fmt.Errorf("could not create temp file: %v", err)
}
defer os.Remove(f.Name())
err = mysqld.initConfig(root, cnf, f.Name())
if err != nil {
return fmt.Errorf("could not initConfig in %v: %v", f.Name(), err)
}
existing, err := ioutil.ReadFile(cnf.path)
if err != nil {
return fmt.Errorf("could not read existing file %v: %v", cnf.path, err)
}
updated, err := ioutil.ReadFile(f.Name())
if err != nil {
return fmt.Errorf("could not read updated file %v: %v", f.Name(), err)
}
if bytes.Equal(existing, updated) {
log.Infof("No changes to my.cnf. Continuing.")
return nil
}
backupPath := cnf.path + ".previous"
err = os.Rename(cnf.path, backupPath)
if err != nil {
return fmt.Errorf("could not back up existing %v: %v", cnf.path, err)
}
err = os.Rename(f.Name(), cnf.path)
if err != nil {
return fmt.Errorf("could not move %v to %v: %v", f.Name(), cnf.path, err)
}
log.Infof("Updated my.cnf. Backup of previous version available in %v", backupPath)
return nil
} | go | func (mysqld *Mysqld) RefreshConfig(ctx context.Context, cnf *Mycnf) error {
// Execute as remote action on mysqlctld if requested.
if *socketFile != "" {
log.Infof("executing Mysqld.RefreshConfig() remotely via mysqlctld server: %v", *socketFile)
client, err := mysqlctlclient.New("unix", *socketFile)
if err != nil {
return fmt.Errorf("can't dial mysqlctld: %v", err)
}
defer client.Close()
return client.RefreshConfig(ctx)
}
log.Info("Checking for updates to my.cnf")
root, err := vtenv.VtRoot()
if err != nil {
return err
}
f, err := ioutil.TempFile(path.Dir(cnf.path), "my.cnf")
if err != nil {
return fmt.Errorf("could not create temp file: %v", err)
}
defer os.Remove(f.Name())
err = mysqld.initConfig(root, cnf, f.Name())
if err != nil {
return fmt.Errorf("could not initConfig in %v: %v", f.Name(), err)
}
existing, err := ioutil.ReadFile(cnf.path)
if err != nil {
return fmt.Errorf("could not read existing file %v: %v", cnf.path, err)
}
updated, err := ioutil.ReadFile(f.Name())
if err != nil {
return fmt.Errorf("could not read updated file %v: %v", f.Name(), err)
}
if bytes.Equal(existing, updated) {
log.Infof("No changes to my.cnf. Continuing.")
return nil
}
backupPath := cnf.path + ".previous"
err = os.Rename(cnf.path, backupPath)
if err != nil {
return fmt.Errorf("could not back up existing %v: %v", cnf.path, err)
}
err = os.Rename(f.Name(), cnf.path)
if err != nil {
return fmt.Errorf("could not move %v to %v: %v", f.Name(), cnf.path, err)
}
log.Infof("Updated my.cnf. Backup of previous version available in %v", backupPath)
return nil
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"RefreshConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"cnf",
"*",
"Mycnf",
")",
"error",
"{",
"// Execute as remote action on mysqlctld if requested.",
"if",
"*",
"socketFile",
"!=",
"\"",
"\"",
"{",
"log",
"."... | // RefreshConfig attempts to recreate the my.cnf from templates, and log and
// swap in to place if it's updated. It keeps a copy of the last version in case fallback is required.
// Should be called from a stable replica, server_id is not regenerated. | [
"RefreshConfig",
"attempts",
"to",
"recreate",
"the",
"my",
".",
"cnf",
"from",
"templates",
"and",
"log",
"and",
"swap",
"in",
"to",
"place",
"if",
"it",
"s",
"updated",
".",
"It",
"keeps",
"a",
"copy",
"of",
"the",
"last",
"version",
"in",
"case",
"f... | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L677-L731 |
158,120 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | ReinitConfig | func (mysqld *Mysqld) ReinitConfig(ctx context.Context, cnf *Mycnf) error {
log.Infof("Mysqld.ReinitConfig")
// Execute as remote action on mysqlctld if requested.
if *socketFile != "" {
log.Infof("executing Mysqld.ReinitConfig() remotely via mysqlctld server: %v", *socketFile)
client, err := mysqlctlclient.New("unix", *socketFile)
if err != nil {
return fmt.Errorf("can't dial mysqlctld: %v", err)
}
defer client.Close()
return client.ReinitConfig(ctx)
}
if err := cnf.RandomizeMysqlServerID(); err != nil {
return err
}
root, err := vtenv.VtRoot()
if err != nil {
return err
}
return mysqld.initConfig(root, cnf, cnf.path)
} | go | func (mysqld *Mysqld) ReinitConfig(ctx context.Context, cnf *Mycnf) error {
log.Infof("Mysqld.ReinitConfig")
// Execute as remote action on mysqlctld if requested.
if *socketFile != "" {
log.Infof("executing Mysqld.ReinitConfig() remotely via mysqlctld server: %v", *socketFile)
client, err := mysqlctlclient.New("unix", *socketFile)
if err != nil {
return fmt.Errorf("can't dial mysqlctld: %v", err)
}
defer client.Close()
return client.ReinitConfig(ctx)
}
if err := cnf.RandomizeMysqlServerID(); err != nil {
return err
}
root, err := vtenv.VtRoot()
if err != nil {
return err
}
return mysqld.initConfig(root, cnf, cnf.path)
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"ReinitConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"cnf",
"*",
"Mycnf",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"// Execute as remote action on mysqlctld if requested.",
"if",
... | // ReinitConfig updates the config file as if Mysqld is initializing. At the
// moment it only randomizes ServerID because it's not safe to restore a replica
// from a backup and then give it the same ServerID as before, MySQL can then
// skip transactions in the replication stream with the same server_id. | [
"ReinitConfig",
"updates",
"the",
"config",
"file",
"as",
"if",
"Mysqld",
"is",
"initializing",
".",
"At",
"the",
"moment",
"it",
"only",
"randomizes",
"ServerID",
"because",
"it",
"s",
"not",
"safe",
"to",
"restore",
"a",
"replica",
"from",
"a",
"backup",
... | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L737-L759 |
158,121 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | Teardown | func (mysqld *Mysqld) Teardown(ctx context.Context, cnf *Mycnf, force bool) error {
log.Infof("mysqlctl.Teardown")
if err := mysqld.Shutdown(ctx, cnf, true); err != nil {
log.Warningf("failed mysqld shutdown: %v", err.Error())
if !force {
return err
}
}
var removalErr error
for _, dir := range TopLevelDirs() {
qdir := path.Join(cnf.TabletDir(), dir)
if err := deleteTopDir(qdir); err != nil {
removalErr = err
}
}
return removalErr
} | go | func (mysqld *Mysqld) Teardown(ctx context.Context, cnf *Mycnf, force bool) error {
log.Infof("mysqlctl.Teardown")
if err := mysqld.Shutdown(ctx, cnf, true); err != nil {
log.Warningf("failed mysqld shutdown: %v", err.Error())
if !force {
return err
}
}
var removalErr error
for _, dir := range TopLevelDirs() {
qdir := path.Join(cnf.TabletDir(), dir)
if err := deleteTopDir(qdir); err != nil {
removalErr = err
}
}
return removalErr
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"Teardown",
"(",
"ctx",
"context",
".",
"Context",
",",
"cnf",
"*",
"Mycnf",
",",
"force",
"bool",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"mysqld",
".",
"S... | // Teardown will shutdown the running daemon, and delete the root directory. | [
"Teardown",
"will",
"shutdown",
"the",
"running",
"daemon",
"and",
"delete",
"the",
"root",
"directory",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L814-L830 |
158,122 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | executeMysqlScript | func (mysqld *Mysqld) executeMysqlScript(connParams *mysql.ConnParams, sql io.Reader) error {
dir, err := vtenv.VtMysqlRoot()
if err != nil {
return err
}
name, err := binaryPath(dir, "mysql")
if err != nil {
return err
}
cnf, err := mysqld.defaultsExtraFile(connParams)
if err != nil {
return err
}
defer os.Remove(cnf)
args := []string{
"--defaults-extra-file=" + cnf,
"--batch",
}
env := []string{
"LD_LIBRARY_PATH=" + path.Join(dir, "lib/mysql"),
}
_, _, err = execCmd(name, args, env, dir, sql)
if err != nil {
return err
}
return nil
} | go | func (mysqld *Mysqld) executeMysqlScript(connParams *mysql.ConnParams, sql io.Reader) error {
dir, err := vtenv.VtMysqlRoot()
if err != nil {
return err
}
name, err := binaryPath(dir, "mysql")
if err != nil {
return err
}
cnf, err := mysqld.defaultsExtraFile(connParams)
if err != nil {
return err
}
defer os.Remove(cnf)
args := []string{
"--defaults-extra-file=" + cnf,
"--batch",
}
env := []string{
"LD_LIBRARY_PATH=" + path.Join(dir, "lib/mysql"),
}
_, _, err = execCmd(name, args, env, dir, sql)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"executeMysqlScript",
"(",
"connParams",
"*",
"mysql",
".",
"ConnParams",
",",
"sql",
"io",
".",
"Reader",
")",
"error",
"{",
"dir",
",",
"err",
":=",
"vtenv",
".",
"VtMysqlRoot",
"(",
")",
"\n",
"if",
"err",
... | // executeMysqlScript executes a .sql script from an io.Reader with the mysql
// command line tool. It uses the connParams as is, not adding credentials. | [
"executeMysqlScript",
"executes",
"a",
".",
"sql",
"script",
"from",
"an",
"io",
".",
"Reader",
"with",
"the",
"mysql",
"command",
"line",
"tool",
".",
"It",
"uses",
"the",
"connParams",
"as",
"is",
"not",
"adding",
"credentials",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L859-L885 |
158,123 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | GetAppConnection | func (mysqld *Mysqld) GetAppConnection(ctx context.Context) (*dbconnpool.PooledDBConnection, error) {
return mysqld.appPool.Get(ctx)
} | go | func (mysqld *Mysqld) GetAppConnection(ctx context.Context) (*dbconnpool.PooledDBConnection, error) {
return mysqld.appPool.Get(ctx)
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"GetAppConnection",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"dbconnpool",
".",
"PooledDBConnection",
",",
"error",
")",
"{",
"return",
"mysqld",
".",
"appPool",
".",
"Get",
"(",
"ctx",
")",
"\n",
... | // GetAppConnection returns a connection from the app pool.
// Recycle needs to be called on the result. | [
"GetAppConnection",
"returns",
"a",
"connection",
"from",
"the",
"app",
"pool",
".",
"Recycle",
"needs",
"to",
"be",
"called",
"on",
"the",
"result",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L932-L934 |
158,124 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | GetDbaConnection | func (mysqld *Mysqld) GetDbaConnection() (*dbconnpool.DBConnection, error) {
return dbconnpool.NewDBConnection(mysqld.dbcfgs.Dba(), dbaMysqlStats)
} | go | func (mysqld *Mysqld) GetDbaConnection() (*dbconnpool.DBConnection, error) {
return dbconnpool.NewDBConnection(mysqld.dbcfgs.Dba(), dbaMysqlStats)
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"GetDbaConnection",
"(",
")",
"(",
"*",
"dbconnpool",
".",
"DBConnection",
",",
"error",
")",
"{",
"return",
"dbconnpool",
".",
"NewDBConnection",
"(",
"mysqld",
".",
"dbcfgs",
".",
"Dba",
"(",
")",
",",
"dbaMys... | // GetDbaConnection creates a new DBConnection. | [
"GetDbaConnection",
"creates",
"a",
"new",
"DBConnection",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L937-L939 |
158,125 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | GetAllPrivsConnection | func (mysqld *Mysqld) GetAllPrivsConnection() (*dbconnpool.DBConnection, error) {
return dbconnpool.NewDBConnection(mysqld.dbcfgs.AllPrivsWithDB(), allprivsMysqlStats)
} | go | func (mysqld *Mysqld) GetAllPrivsConnection() (*dbconnpool.DBConnection, error) {
return dbconnpool.NewDBConnection(mysqld.dbcfgs.AllPrivsWithDB(), allprivsMysqlStats)
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"GetAllPrivsConnection",
"(",
")",
"(",
"*",
"dbconnpool",
".",
"DBConnection",
",",
"error",
")",
"{",
"return",
"dbconnpool",
".",
"NewDBConnection",
"(",
"mysqld",
".",
"dbcfgs",
".",
"AllPrivsWithDB",
"(",
")",
... | // GetAllPrivsConnection creates a new DBConnection. | [
"GetAllPrivsConnection",
"creates",
"a",
"new",
"DBConnection",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L942-L944 |
158,126 | vitessio/vitess | go/vt/mysqlctl/mysqld.go | Close | func (mysqld *Mysqld) Close() {
if mysqld.dbaPool != nil {
mysqld.dbaPool.Close()
}
if mysqld.appPool != nil {
mysqld.appPool.Close()
}
} | go | func (mysqld *Mysqld) Close() {
if mysqld.dbaPool != nil {
mysqld.dbaPool.Close()
}
if mysqld.appPool != nil {
mysqld.appPool.Close()
}
} | [
"func",
"(",
"mysqld",
"*",
"Mysqld",
")",
"Close",
"(",
")",
"{",
"if",
"mysqld",
".",
"dbaPool",
"!=",
"nil",
"{",
"mysqld",
".",
"dbaPool",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"if",
"mysqld",
".",
"appPool",
"!=",
"nil",
"{",
"mysqld",
".... | // Close will close this instance of Mysqld. It will wait for all dba
// queries to be finished. | [
"Close",
"will",
"close",
"this",
"instance",
"of",
"Mysqld",
".",
"It",
"will",
"wait",
"for",
"all",
"dba",
"queries",
"to",
"be",
"finished",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/mysqlctl/mysqld.go#L948-L955 |
158,127 | vitessio/vitess | go/vt/vttablet/tabletmanager/vreplication.go | VReplicationExec | func (agent *ActionAgent) VReplicationExec(ctx context.Context, query string) (*querypb.QueryResult, error) {
qr, err := agent.VREngine.Exec(query)
if err != nil {
return nil, err
}
return sqltypes.ResultToProto3(qr), nil
} | go | func (agent *ActionAgent) VReplicationExec(ctx context.Context, query string) (*querypb.QueryResult, error) {
qr, err := agent.VREngine.Exec(query)
if err != nil {
return nil, err
}
return sqltypes.ResultToProto3(qr), nil
} | [
"func",
"(",
"agent",
"*",
"ActionAgent",
")",
"VReplicationExec",
"(",
"ctx",
"context",
".",
"Context",
",",
"query",
"string",
")",
"(",
"*",
"querypb",
".",
"QueryResult",
",",
"error",
")",
"{",
"qr",
",",
"err",
":=",
"agent",
".",
"VREngine",
".... | // VReplicationExec executes a vreplication command. | [
"VReplicationExec",
"executes",
"a",
"vreplication",
"command",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/vttablet/tabletmanager/vreplication.go#L28-L34 |
158,128 | vitessio/vitess | go/vt/vttablet/tabletmanager/vreplication.go | VReplicationWaitForPos | func (agent *ActionAgent) VReplicationWaitForPos(ctx context.Context, id int, pos string) error {
return agent.VREngine.WaitForPos(ctx, id, pos)
} | go | func (agent *ActionAgent) VReplicationWaitForPos(ctx context.Context, id int, pos string) error {
return agent.VREngine.WaitForPos(ctx, id, pos)
} | [
"func",
"(",
"agent",
"*",
"ActionAgent",
")",
"VReplicationWaitForPos",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"int",
",",
"pos",
"string",
")",
"error",
"{",
"return",
"agent",
".",
"VREngine",
".",
"WaitForPos",
"(",
"ctx",
",",
"id",
",",
... | // VReplicationWaitForPos waits for the specified position. | [
"VReplicationWaitForPos",
"waits",
"for",
"the",
"specified",
"position",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/vttablet/tabletmanager/vreplication.go#L37-L39 |
158,129 | vitessio/vitess | go/vt/vtexplain/vtexplain_topo.go | GetSrvKeyspaceNames | func (et *ExplainTopo) GetSrvKeyspaceNames(ctx context.Context, cell string) ([]string, error) {
et.Lock.Lock()
defer et.Lock.Unlock()
keyspaces := make([]string, 0, 1)
for k := range et.Keyspaces {
keyspaces = append(keyspaces, k)
}
return keyspaces, nil
} | go | func (et *ExplainTopo) GetSrvKeyspaceNames(ctx context.Context, cell string) ([]string, error) {
et.Lock.Lock()
defer et.Lock.Unlock()
keyspaces := make([]string, 0, 1)
for k := range et.Keyspaces {
keyspaces = append(keyspaces, k)
}
return keyspaces, nil
} | [
"func",
"(",
"et",
"*",
"ExplainTopo",
")",
"GetSrvKeyspaceNames",
"(",
"ctx",
"context",
".",
"Context",
",",
"cell",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"et",
".",
"Lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"et",
".... | // GetSrvKeyspaceNames is part of the srvtopo.Server interface. | [
"GetSrvKeyspaceNames",
"is",
"part",
"of",
"the",
"srvtopo",
".",
"Server",
"interface",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/vtexplain/vtexplain_topo.go#L63-L72 |
158,130 | vitessio/vitess | go/vt/vtexplain/vtexplain_topo.go | GetSrvKeyspace | func (et *ExplainTopo) GetSrvKeyspace(ctx context.Context, cell, keyspace string) (*topodatapb.SrvKeyspace, error) {
et.Lock.Lock()
defer et.Lock.Unlock()
vschema := et.Keyspaces[keyspace]
if vschema == nil {
return nil, fmt.Errorf("no vschema for keyspace %s", keyspace)
}
var srvKeyspace *topodatapb.SrvKeyspace
if vschema.Sharded {
shards := make([]*topodatapb.ShardReference, 0, et.NumShards)
for i := 0; i < et.NumShards; i++ {
kr, err := key.EvenShardsKeyRange(i, et.NumShards)
if err != nil {
return nil, err
}
shard := &topodatapb.ShardReference{
Name: key.KeyRangeString(kr),
KeyRange: kr,
}
shards = append(shards, shard)
}
srvKeyspace = &topodatapb.SrvKeyspace{
ShardingColumnName: "", // exact value is ignored
ShardingColumnType: 0,
Partitions: []*topodatapb.SrvKeyspace_KeyspacePartition{
{
ServedType: topodatapb.TabletType_MASTER,
ShardReferences: shards,
},
{
ServedType: topodatapb.TabletType_REPLICA,
ShardReferences: shards,
},
{
ServedType: topodatapb.TabletType_RDONLY,
ShardReferences: shards,
},
},
}
} else {
// unsharded
kr, err := key.EvenShardsKeyRange(0, 1)
if err != nil {
return nil, err
}
shard := &topodatapb.ShardReference{
Name: key.KeyRangeString(kr),
}
srvKeyspace = &topodatapb.SrvKeyspace{
Partitions: []*topodatapb.SrvKeyspace_KeyspacePartition{
{
ServedType: topodatapb.TabletType_MASTER,
ShardReferences: []*topodatapb.ShardReference{shard},
},
{
ServedType: topodatapb.TabletType_REPLICA,
ShardReferences: []*topodatapb.ShardReference{shard},
},
{
ServedType: topodatapb.TabletType_RDONLY,
ShardReferences: []*topodatapb.ShardReference{shard},
},
},
}
}
return srvKeyspace, nil
} | go | func (et *ExplainTopo) GetSrvKeyspace(ctx context.Context, cell, keyspace string) (*topodatapb.SrvKeyspace, error) {
et.Lock.Lock()
defer et.Lock.Unlock()
vschema := et.Keyspaces[keyspace]
if vschema == nil {
return nil, fmt.Errorf("no vschema for keyspace %s", keyspace)
}
var srvKeyspace *topodatapb.SrvKeyspace
if vschema.Sharded {
shards := make([]*topodatapb.ShardReference, 0, et.NumShards)
for i := 0; i < et.NumShards; i++ {
kr, err := key.EvenShardsKeyRange(i, et.NumShards)
if err != nil {
return nil, err
}
shard := &topodatapb.ShardReference{
Name: key.KeyRangeString(kr),
KeyRange: kr,
}
shards = append(shards, shard)
}
srvKeyspace = &topodatapb.SrvKeyspace{
ShardingColumnName: "", // exact value is ignored
ShardingColumnType: 0,
Partitions: []*topodatapb.SrvKeyspace_KeyspacePartition{
{
ServedType: topodatapb.TabletType_MASTER,
ShardReferences: shards,
},
{
ServedType: topodatapb.TabletType_REPLICA,
ShardReferences: shards,
},
{
ServedType: topodatapb.TabletType_RDONLY,
ShardReferences: shards,
},
},
}
} else {
// unsharded
kr, err := key.EvenShardsKeyRange(0, 1)
if err != nil {
return nil, err
}
shard := &topodatapb.ShardReference{
Name: key.KeyRangeString(kr),
}
srvKeyspace = &topodatapb.SrvKeyspace{
Partitions: []*topodatapb.SrvKeyspace_KeyspacePartition{
{
ServedType: topodatapb.TabletType_MASTER,
ShardReferences: []*topodatapb.ShardReference{shard},
},
{
ServedType: topodatapb.TabletType_REPLICA,
ShardReferences: []*topodatapb.ShardReference{shard},
},
{
ServedType: topodatapb.TabletType_RDONLY,
ShardReferences: []*topodatapb.ShardReference{shard},
},
},
}
}
return srvKeyspace, nil
} | [
"func",
"(",
"et",
"*",
"ExplainTopo",
")",
"GetSrvKeyspace",
"(",
"ctx",
"context",
".",
"Context",
",",
"cell",
",",
"keyspace",
"string",
")",
"(",
"*",
"topodatapb",
".",
"SrvKeyspace",
",",
"error",
")",
"{",
"et",
".",
"Lock",
".",
"Lock",
"(",
... | // GetSrvKeyspace is part of the srvtopo.Server interface. | [
"GetSrvKeyspace",
"is",
"part",
"of",
"the",
"srvtopo",
".",
"Server",
"interface",
"."
] | d568817542a413611801aa17a1c213aa95592182 | https://github.com/vitessio/vitess/blob/d568817542a413611801aa17a1c213aa95592182/go/vt/vtexplain/vtexplain_topo.go#L75-L149 |
158,131 | Shopify/sarama | sync_producer.go | NewSyncProducer | func NewSyncProducer(addrs []string, config *Config) (SyncProducer, error) {
if config == nil {
config = NewConfig()
config.Producer.Return.Successes = true
}
if err := verifyProducerConfig(config); err != nil {
return nil, err
}
p, err := NewAsyncProducer(addrs, config)
if err != nil {
return nil, err
}
return newSyncProducerFromAsyncProducer(p.(*asyncProducer)), nil
} | go | func NewSyncProducer(addrs []string, config *Config) (SyncProducer, error) {
if config == nil {
config = NewConfig()
config.Producer.Return.Successes = true
}
if err := verifyProducerConfig(config); err != nil {
return nil, err
}
p, err := NewAsyncProducer(addrs, config)
if err != nil {
return nil, err
}
return newSyncProducerFromAsyncProducer(p.(*asyncProducer)), nil
} | [
"func",
"NewSyncProducer",
"(",
"addrs",
"[",
"]",
"string",
",",
"config",
"*",
"Config",
")",
"(",
"SyncProducer",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"NewConfig",
"(",
")",
"\n",
"config",
".",
"Producer",
".",
... | // NewSyncProducer creates a new SyncProducer using the given broker addresses and configuration. | [
"NewSyncProducer",
"creates",
"a",
"new",
"SyncProducer",
"using",
"the",
"given",
"broker",
"addresses",
"and",
"configuration",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/sync_producer.go#L41-L56 |
158,132 | Shopify/sarama | client.go | NewClient | func NewClient(addrs []string, conf *Config) (Client, error) {
Logger.Println("Initializing new client")
if conf == nil {
conf = NewConfig()
}
if err := conf.Validate(); err != nil {
return nil, err
}
if len(addrs) < 1 {
return nil, ConfigurationError("You must provide at least one broker address")
}
client := &client{
conf: conf,
closer: make(chan none),
closed: make(chan none),
brokers: make(map[int32]*Broker),
metadata: make(map[string]map[int32]*PartitionMetadata),
metadataTopics: make(map[string]none),
cachedPartitionsResults: make(map[string][maxPartitionIndex][]int32),
coordinators: make(map[string]int32),
}
random := rand.New(rand.NewSource(time.Now().UnixNano()))
for _, index := range random.Perm(len(addrs)) {
client.seedBrokers = append(client.seedBrokers, NewBroker(addrs[index]))
}
if conf.Metadata.Full {
// do an initial fetch of all cluster metadata by specifying an empty list of topics
err := client.RefreshMetadata()
switch err {
case nil:
break
case ErrLeaderNotAvailable, ErrReplicaNotAvailable, ErrTopicAuthorizationFailed, ErrClusterAuthorizationFailed:
// indicates that maybe part of the cluster is down, but is not fatal to creating the client
Logger.Println(err)
default:
close(client.closed) // we haven't started the background updater yet, so we have to do this manually
_ = client.Close()
return nil, err
}
}
go withRecover(client.backgroundMetadataUpdater)
Logger.Println("Successfully initialized new client")
return client, nil
} | go | func NewClient(addrs []string, conf *Config) (Client, error) {
Logger.Println("Initializing new client")
if conf == nil {
conf = NewConfig()
}
if err := conf.Validate(); err != nil {
return nil, err
}
if len(addrs) < 1 {
return nil, ConfigurationError("You must provide at least one broker address")
}
client := &client{
conf: conf,
closer: make(chan none),
closed: make(chan none),
brokers: make(map[int32]*Broker),
metadata: make(map[string]map[int32]*PartitionMetadata),
metadataTopics: make(map[string]none),
cachedPartitionsResults: make(map[string][maxPartitionIndex][]int32),
coordinators: make(map[string]int32),
}
random := rand.New(rand.NewSource(time.Now().UnixNano()))
for _, index := range random.Perm(len(addrs)) {
client.seedBrokers = append(client.seedBrokers, NewBroker(addrs[index]))
}
if conf.Metadata.Full {
// do an initial fetch of all cluster metadata by specifying an empty list of topics
err := client.RefreshMetadata()
switch err {
case nil:
break
case ErrLeaderNotAvailable, ErrReplicaNotAvailable, ErrTopicAuthorizationFailed, ErrClusterAuthorizationFailed:
// indicates that maybe part of the cluster is down, but is not fatal to creating the client
Logger.Println(err)
default:
close(client.closed) // we haven't started the background updater yet, so we have to do this manually
_ = client.Close()
return nil, err
}
}
go withRecover(client.backgroundMetadataUpdater)
Logger.Println("Successfully initialized new client")
return client, nil
} | [
"func",
"NewClient",
"(",
"addrs",
"[",
"]",
"string",
",",
"conf",
"*",
"Config",
")",
"(",
"Client",
",",
"error",
")",
"{",
"Logger",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"conf",
"==",
"nil",
"{",
"conf",
"=",
"NewConfig",
"(",
... | // NewClient creates a new Client. It connects to one of the given broker addresses
// and uses that broker to automatically fetch metadata on the rest of the kafka cluster. If metadata cannot
// be retrieved from any of the given broker addresses, the client is not created. | [
"NewClient",
"creates",
"a",
"new",
"Client",
".",
"It",
"connects",
"to",
"one",
"of",
"the",
"given",
"broker",
"addresses",
"and",
"uses",
"that",
"broker",
"to",
"automatically",
"fetch",
"metadata",
"on",
"the",
"rest",
"of",
"the",
"kafka",
"cluster",
... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/client.go#L126-L177 |
158,133 | Shopify/sarama | client.go | registerBroker | func (client *client) registerBroker(broker *Broker) {
if client.brokers[broker.ID()] == nil {
client.brokers[broker.ID()] = broker
Logger.Printf("client/brokers registered new broker #%d at %s", broker.ID(), broker.Addr())
} else if broker.Addr() != client.brokers[broker.ID()].Addr() {
safeAsyncClose(client.brokers[broker.ID()])
client.brokers[broker.ID()] = broker
Logger.Printf("client/brokers replaced registered broker #%d with %s", broker.ID(), broker.Addr())
}
} | go | func (client *client) registerBroker(broker *Broker) {
if client.brokers[broker.ID()] == nil {
client.brokers[broker.ID()] = broker
Logger.Printf("client/brokers registered new broker #%d at %s", broker.ID(), broker.Addr())
} else if broker.Addr() != client.brokers[broker.ID()].Addr() {
safeAsyncClose(client.brokers[broker.ID()])
client.brokers[broker.ID()] = broker
Logger.Printf("client/brokers replaced registered broker #%d with %s", broker.ID(), broker.Addr())
}
} | [
"func",
"(",
"client",
"*",
"client",
")",
"registerBroker",
"(",
"broker",
"*",
"Broker",
")",
"{",
"if",
"client",
".",
"brokers",
"[",
"broker",
".",
"ID",
"(",
")",
"]",
"==",
"nil",
"{",
"client",
".",
"brokers",
"[",
"broker",
".",
"ID",
"(",... | // private broker management helpers
// registerBroker makes sure a broker received by a Metadata or Coordinator request is registered
// in the brokers map. It returns the broker that is registered, which may be the provided broker,
// or a previously registered Broker instance. You must hold the write lock before calling this function. | [
"private",
"broker",
"management",
"helpers",
"registerBroker",
"makes",
"sure",
"a",
"broker",
"received",
"by",
"a",
"Metadata",
"or",
"Coordinator",
"request",
"is",
"registered",
"in",
"the",
"brokers",
"map",
".",
"It",
"returns",
"the",
"broker",
"that",
... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/client.go#L527-L536 |
158,134 | Shopify/sarama | client.go | deregisterBroker | func (client *client) deregisterBroker(broker *Broker) {
client.lock.Lock()
defer client.lock.Unlock()
if len(client.seedBrokers) > 0 && broker == client.seedBrokers[0] {
client.deadSeeds = append(client.deadSeeds, broker)
client.seedBrokers = client.seedBrokers[1:]
} else {
// we do this so that our loop in `tryRefreshMetadata` doesn't go on forever,
// but we really shouldn't have to; once that loop is made better this case can be
// removed, and the function generally can be renamed from `deregisterBroker` to
// `nextSeedBroker` or something
Logger.Printf("client/brokers deregistered broker #%d at %s", broker.ID(), broker.Addr())
delete(client.brokers, broker.ID())
}
} | go | func (client *client) deregisterBroker(broker *Broker) {
client.lock.Lock()
defer client.lock.Unlock()
if len(client.seedBrokers) > 0 && broker == client.seedBrokers[0] {
client.deadSeeds = append(client.deadSeeds, broker)
client.seedBrokers = client.seedBrokers[1:]
} else {
// we do this so that our loop in `tryRefreshMetadata` doesn't go on forever,
// but we really shouldn't have to; once that loop is made better this case can be
// removed, and the function generally can be renamed from `deregisterBroker` to
// `nextSeedBroker` or something
Logger.Printf("client/brokers deregistered broker #%d at %s", broker.ID(), broker.Addr())
delete(client.brokers, broker.ID())
}
} | [
"func",
"(",
"client",
"*",
"client",
")",
"deregisterBroker",
"(",
"broker",
"*",
"Broker",
")",
"{",
"client",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"client",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"len",
"(",
"client",
... | // deregisterBroker removes a broker from the seedsBroker list, and if it's
// not the seedbroker, removes it from brokers map completely. | [
"deregisterBroker",
"removes",
"a",
"broker",
"from",
"the",
"seedsBroker",
"list",
"and",
"if",
"it",
"s",
"not",
"the",
"seedbroker",
"removes",
"it",
"from",
"brokers",
"map",
"completely",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/client.go#L540-L555 |
158,135 | Shopify/sarama | client.go | backgroundMetadataUpdater | func (client *client) backgroundMetadataUpdater() {
defer close(client.closed)
if client.conf.Metadata.RefreshFrequency == time.Duration(0) {
return
}
ticker := time.NewTicker(client.conf.Metadata.RefreshFrequency)
defer ticker.Stop()
for {
select {
case <-ticker.C:
if err := client.refreshMetadata(); err != nil {
Logger.Println("Client background metadata update:", err)
}
case <-client.closer:
return
}
}
} | go | func (client *client) backgroundMetadataUpdater() {
defer close(client.closed)
if client.conf.Metadata.RefreshFrequency == time.Duration(0) {
return
}
ticker := time.NewTicker(client.conf.Metadata.RefreshFrequency)
defer ticker.Stop()
for {
select {
case <-ticker.C:
if err := client.refreshMetadata(); err != nil {
Logger.Println("Client background metadata update:", err)
}
case <-client.closer:
return
}
}
} | [
"func",
"(",
"client",
"*",
"client",
")",
"backgroundMetadataUpdater",
"(",
")",
"{",
"defer",
"close",
"(",
"client",
".",
"closed",
")",
"\n\n",
"if",
"client",
".",
"conf",
".",
"Metadata",
".",
"RefreshFrequency",
"==",
"time",
".",
"Duration",
"(",
... | // core metadata update logic | [
"core",
"metadata",
"update",
"logic"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/client.go#L698-L718 |
158,136 | Shopify/sarama | client.go | updateMetadata | func (client *client) updateMetadata(data *MetadataResponse, allKnownMetaData bool) (retry bool, err error) {
client.lock.Lock()
defer client.lock.Unlock()
// For all the brokers we received:
// - if it is a new ID, save it
// - if it is an existing ID, but the address we have is stale, discard the old one and save it
// - otherwise ignore it, replacing our existing one would just bounce the connection
for _, broker := range data.Brokers {
client.registerBroker(broker)
}
client.controllerID = data.ControllerID
if allKnownMetaData {
client.metadata = make(map[string]map[int32]*PartitionMetadata)
client.metadataTopics = make(map[string]none)
client.cachedPartitionsResults = make(map[string][maxPartitionIndex][]int32)
}
for _, topic := range data.Topics {
// topics must be added firstly to `metadataTopics` to guarantee that all
// requested topics must be recorded to keep them trackable for periodically
// metadata refresh.
if _, exists := client.metadataTopics[topic.Name]; !exists {
client.metadataTopics[topic.Name] = none{}
}
delete(client.metadata, topic.Name)
delete(client.cachedPartitionsResults, topic.Name)
switch topic.Err {
case ErrNoError:
// no-op
case ErrInvalidTopic, ErrTopicAuthorizationFailed: // don't retry, don't store partial results
err = topic.Err
continue
case ErrUnknownTopicOrPartition: // retry, do not store partial partition results
err = topic.Err
retry = true
continue
case ErrLeaderNotAvailable: // retry, but store partial partition results
retry = true
default: // don't retry, don't store partial results
Logger.Printf("Unexpected topic-level metadata error: %s", topic.Err)
err = topic.Err
continue
}
client.metadata[topic.Name] = make(map[int32]*PartitionMetadata, len(topic.Partitions))
for _, partition := range topic.Partitions {
client.metadata[topic.Name][partition.ID] = partition
if partition.Err == ErrLeaderNotAvailable {
retry = true
}
}
var partitionCache [maxPartitionIndex][]int32
partitionCache[allPartitions] = client.setPartitionCache(topic.Name, allPartitions)
partitionCache[writablePartitions] = client.setPartitionCache(topic.Name, writablePartitions)
client.cachedPartitionsResults[topic.Name] = partitionCache
}
return
} | go | func (client *client) updateMetadata(data *MetadataResponse, allKnownMetaData bool) (retry bool, err error) {
client.lock.Lock()
defer client.lock.Unlock()
// For all the brokers we received:
// - if it is a new ID, save it
// - if it is an existing ID, but the address we have is stale, discard the old one and save it
// - otherwise ignore it, replacing our existing one would just bounce the connection
for _, broker := range data.Brokers {
client.registerBroker(broker)
}
client.controllerID = data.ControllerID
if allKnownMetaData {
client.metadata = make(map[string]map[int32]*PartitionMetadata)
client.metadataTopics = make(map[string]none)
client.cachedPartitionsResults = make(map[string][maxPartitionIndex][]int32)
}
for _, topic := range data.Topics {
// topics must be added firstly to `metadataTopics` to guarantee that all
// requested topics must be recorded to keep them trackable for periodically
// metadata refresh.
if _, exists := client.metadataTopics[topic.Name]; !exists {
client.metadataTopics[topic.Name] = none{}
}
delete(client.metadata, topic.Name)
delete(client.cachedPartitionsResults, topic.Name)
switch topic.Err {
case ErrNoError:
// no-op
case ErrInvalidTopic, ErrTopicAuthorizationFailed: // don't retry, don't store partial results
err = topic.Err
continue
case ErrUnknownTopicOrPartition: // retry, do not store partial partition results
err = topic.Err
retry = true
continue
case ErrLeaderNotAvailable: // retry, but store partial partition results
retry = true
default: // don't retry, don't store partial results
Logger.Printf("Unexpected topic-level metadata error: %s", topic.Err)
err = topic.Err
continue
}
client.metadata[topic.Name] = make(map[int32]*PartitionMetadata, len(topic.Partitions))
for _, partition := range topic.Partitions {
client.metadata[topic.Name][partition.ID] = partition
if partition.Err == ErrLeaderNotAvailable {
retry = true
}
}
var partitionCache [maxPartitionIndex][]int32
partitionCache[allPartitions] = client.setPartitionCache(topic.Name, allPartitions)
partitionCache[writablePartitions] = client.setPartitionCache(topic.Name, writablePartitions)
client.cachedPartitionsResults[topic.Name] = partitionCache
}
return
} | [
"func",
"(",
"client",
"*",
"client",
")",
"updateMetadata",
"(",
"data",
"*",
"MetadataResponse",
",",
"allKnownMetaData",
"bool",
")",
"(",
"retry",
"bool",
",",
"err",
"error",
")",
"{",
"client",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"... | // if no fatal error, returns a list of topics that need retrying due to ErrLeaderNotAvailable | [
"if",
"no",
"fatal",
"error",
"returns",
"a",
"list",
"of",
"topics",
"that",
"need",
"retrying",
"due",
"to",
"ErrLeaderNotAvailable"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/client.go#L809-L871 |
158,137 | Shopify/sarama | config.go | NewConfig | func NewConfig() *Config {
c := &Config{}
c.Admin.Timeout = 3 * time.Second
c.Net.MaxOpenRequests = 5
c.Net.DialTimeout = 30 * time.Second
c.Net.ReadTimeout = 30 * time.Second
c.Net.WriteTimeout = 30 * time.Second
c.Net.SASL.Handshake = true
c.Metadata.Retry.Max = 3
c.Metadata.Retry.Backoff = 250 * time.Millisecond
c.Metadata.RefreshFrequency = 10 * time.Minute
c.Metadata.Full = true
c.Producer.MaxMessageBytes = 1000000
c.Producer.RequiredAcks = WaitForLocal
c.Producer.Timeout = 10 * time.Second
c.Producer.Partitioner = NewHashPartitioner
c.Producer.Retry.Max = 3
c.Producer.Retry.Backoff = 100 * time.Millisecond
c.Producer.Return.Errors = true
c.Producer.CompressionLevel = CompressionLevelDefault
c.Consumer.Fetch.Min = 1
c.Consumer.Fetch.Default = 1024 * 1024
c.Consumer.Retry.Backoff = 2 * time.Second
c.Consumer.MaxWaitTime = 250 * time.Millisecond
c.Consumer.MaxProcessingTime = 100 * time.Millisecond
c.Consumer.Return.Errors = false
c.Consumer.Offsets.CommitInterval = 1 * time.Second
c.Consumer.Offsets.Initial = OffsetNewest
c.Consumer.Offsets.Retry.Max = 3
c.Consumer.Group.Session.Timeout = 10 * time.Second
c.Consumer.Group.Heartbeat.Interval = 3 * time.Second
c.Consumer.Group.Rebalance.Strategy = BalanceStrategyRange
c.Consumer.Group.Rebalance.Timeout = 60 * time.Second
c.Consumer.Group.Rebalance.Retry.Max = 4
c.Consumer.Group.Rebalance.Retry.Backoff = 2 * time.Second
c.ClientID = defaultClientID
c.ChannelBufferSize = 256
c.Version = MinVersion
c.MetricRegistry = metrics.NewRegistry()
return c
} | go | func NewConfig() *Config {
c := &Config{}
c.Admin.Timeout = 3 * time.Second
c.Net.MaxOpenRequests = 5
c.Net.DialTimeout = 30 * time.Second
c.Net.ReadTimeout = 30 * time.Second
c.Net.WriteTimeout = 30 * time.Second
c.Net.SASL.Handshake = true
c.Metadata.Retry.Max = 3
c.Metadata.Retry.Backoff = 250 * time.Millisecond
c.Metadata.RefreshFrequency = 10 * time.Minute
c.Metadata.Full = true
c.Producer.MaxMessageBytes = 1000000
c.Producer.RequiredAcks = WaitForLocal
c.Producer.Timeout = 10 * time.Second
c.Producer.Partitioner = NewHashPartitioner
c.Producer.Retry.Max = 3
c.Producer.Retry.Backoff = 100 * time.Millisecond
c.Producer.Return.Errors = true
c.Producer.CompressionLevel = CompressionLevelDefault
c.Consumer.Fetch.Min = 1
c.Consumer.Fetch.Default = 1024 * 1024
c.Consumer.Retry.Backoff = 2 * time.Second
c.Consumer.MaxWaitTime = 250 * time.Millisecond
c.Consumer.MaxProcessingTime = 100 * time.Millisecond
c.Consumer.Return.Errors = false
c.Consumer.Offsets.CommitInterval = 1 * time.Second
c.Consumer.Offsets.Initial = OffsetNewest
c.Consumer.Offsets.Retry.Max = 3
c.Consumer.Group.Session.Timeout = 10 * time.Second
c.Consumer.Group.Heartbeat.Interval = 3 * time.Second
c.Consumer.Group.Rebalance.Strategy = BalanceStrategyRange
c.Consumer.Group.Rebalance.Timeout = 60 * time.Second
c.Consumer.Group.Rebalance.Retry.Max = 4
c.Consumer.Group.Rebalance.Retry.Backoff = 2 * time.Second
c.ClientID = defaultClientID
c.ChannelBufferSize = 256
c.Version = MinVersion
c.MetricRegistry = metrics.NewRegistry()
return c
} | [
"func",
"NewConfig",
"(",
")",
"*",
"Config",
"{",
"c",
":=",
"&",
"Config",
"{",
"}",
"\n\n",
"c",
".",
"Admin",
".",
"Timeout",
"=",
"3",
"*",
"time",
".",
"Second",
"\n\n",
"c",
".",
"Net",
".",
"MaxOpenRequests",
"=",
"5",
"\n",
"c",
".",
"... | // NewConfig returns a new configuration instance with sane defaults. | [
"NewConfig",
"returns",
"a",
"new",
"configuration",
"instance",
"with",
"sane",
"defaults",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/config.go#L382-L430 |
158,138 | Shopify/sarama | async_producer.go | NewAsyncProducer | func NewAsyncProducer(addrs []string, conf *Config) (AsyncProducer, error) {
client, err := NewClient(addrs, conf)
if err != nil {
return nil, err
}
return newAsyncProducer(client)
} | go | func NewAsyncProducer(addrs []string, conf *Config) (AsyncProducer, error) {
client, err := NewClient(addrs, conf)
if err != nil {
return nil, err
}
return newAsyncProducer(client)
} | [
"func",
"NewAsyncProducer",
"(",
"addrs",
"[",
"]",
"string",
",",
"conf",
"*",
"Config",
")",
"(",
"AsyncProducer",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"NewClient",
"(",
"addrs",
",",
"conf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",... | // NewAsyncProducer creates a new AsyncProducer using the given broker addresses and configuration. | [
"NewAsyncProducer",
"creates",
"a",
"new",
"AsyncProducer",
"using",
"the",
"given",
"broker",
"addresses",
"and",
"configuration",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/async_producer.go#L110-L116 |
158,139 | Shopify/sarama | async_producer.go | dispatcher | func (p *asyncProducer) dispatcher() {
handlers := make(map[string]chan<- *ProducerMessage)
shuttingDown := false
for msg := range p.input {
if msg == nil {
Logger.Println("Something tried to send a nil message, it was ignored.")
continue
}
if msg.flags&shutdown != 0 {
shuttingDown = true
p.inFlight.Done()
continue
} else if msg.retries == 0 {
if shuttingDown {
// we can't just call returnError here because that decrements the wait group,
// which hasn't been incremented yet for this message, and shouldn't be
pErr := &ProducerError{Msg: msg, Err: ErrShuttingDown}
if p.conf.Producer.Return.Errors {
p.errors <- pErr
} else {
Logger.Println(pErr)
}
continue
}
p.inFlight.Add(1)
}
version := 1
if p.conf.Version.IsAtLeast(V0_11_0_0) {
version = 2
} else if msg.Headers != nil {
p.returnError(msg, ConfigurationError("Producing headers requires Kafka at least v0.11"))
continue
}
if msg.byteSize(version) > p.conf.Producer.MaxMessageBytes {
p.returnError(msg, ErrMessageSizeTooLarge)
continue
}
handler := handlers[msg.Topic]
if handler == nil {
handler = p.newTopicProducer(msg.Topic)
handlers[msg.Topic] = handler
}
handler <- msg
}
for _, handler := range handlers {
close(handler)
}
} | go | func (p *asyncProducer) dispatcher() {
handlers := make(map[string]chan<- *ProducerMessage)
shuttingDown := false
for msg := range p.input {
if msg == nil {
Logger.Println("Something tried to send a nil message, it was ignored.")
continue
}
if msg.flags&shutdown != 0 {
shuttingDown = true
p.inFlight.Done()
continue
} else if msg.retries == 0 {
if shuttingDown {
// we can't just call returnError here because that decrements the wait group,
// which hasn't been incremented yet for this message, and shouldn't be
pErr := &ProducerError{Msg: msg, Err: ErrShuttingDown}
if p.conf.Producer.Return.Errors {
p.errors <- pErr
} else {
Logger.Println(pErr)
}
continue
}
p.inFlight.Add(1)
}
version := 1
if p.conf.Version.IsAtLeast(V0_11_0_0) {
version = 2
} else if msg.Headers != nil {
p.returnError(msg, ConfigurationError("Producing headers requires Kafka at least v0.11"))
continue
}
if msg.byteSize(version) > p.conf.Producer.MaxMessageBytes {
p.returnError(msg, ErrMessageSizeTooLarge)
continue
}
handler := handlers[msg.Topic]
if handler == nil {
handler = p.newTopicProducer(msg.Topic)
handlers[msg.Topic] = handler
}
handler <- msg
}
for _, handler := range handlers {
close(handler)
}
} | [
"func",
"(",
"p",
"*",
"asyncProducer",
")",
"dispatcher",
"(",
")",
"{",
"handlers",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"chan",
"<-",
"*",
"ProducerMessage",
")",
"\n",
"shuttingDown",
":=",
"false",
"\n\n",
"for",
"msg",
":=",
"range",
"p"... | // singleton
// dispatches messages by topic | [
"singleton",
"dispatches",
"messages",
"by",
"topic"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/async_producer.go#L295-L348 |
158,140 | Shopify/sarama | async_producer.go | newBrokerProducer | func (p *asyncProducer) newBrokerProducer(broker *Broker) *brokerProducer {
var (
input = make(chan *ProducerMessage)
bridge = make(chan *produceSet)
responses = make(chan *brokerProducerResponse)
)
bp := &brokerProducer{
parent: p,
broker: broker,
input: input,
output: bridge,
responses: responses,
buffer: newProduceSet(p),
currentRetries: make(map[string]map[int32]error),
}
go withRecover(bp.run)
// minimal bridge to make the network response `select`able
go withRecover(func() {
for set := range bridge {
request := set.buildRequest()
response, err := broker.Produce(request)
responses <- &brokerProducerResponse{
set: set,
err: err,
res: response,
}
}
close(responses)
})
if p.conf.Producer.Retry.Max <= 0 {
bp.abandoned = make(chan struct{})
}
return bp
} | go | func (p *asyncProducer) newBrokerProducer(broker *Broker) *brokerProducer {
var (
input = make(chan *ProducerMessage)
bridge = make(chan *produceSet)
responses = make(chan *brokerProducerResponse)
)
bp := &brokerProducer{
parent: p,
broker: broker,
input: input,
output: bridge,
responses: responses,
buffer: newProduceSet(p),
currentRetries: make(map[string]map[int32]error),
}
go withRecover(bp.run)
// minimal bridge to make the network response `select`able
go withRecover(func() {
for set := range bridge {
request := set.buildRequest()
response, err := broker.Produce(request)
responses <- &brokerProducerResponse{
set: set,
err: err,
res: response,
}
}
close(responses)
})
if p.conf.Producer.Retry.Max <= 0 {
bp.abandoned = make(chan struct{})
}
return bp
} | [
"func",
"(",
"p",
"*",
"asyncProducer",
")",
"newBrokerProducer",
"(",
"broker",
"*",
"Broker",
")",
"*",
"brokerProducer",
"{",
"var",
"(",
"input",
"=",
"make",
"(",
"chan",
"*",
"ProducerMessage",
")",
"\n",
"bridge",
"=",
"make",
"(",
"chan",
"*",
... | // one per broker; also constructs an associated flusher | [
"one",
"per",
"broker",
";",
"also",
"constructs",
"an",
"associated",
"flusher"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/async_producer.go#L635-L674 |
158,141 | Shopify/sarama | mockbroker.go | SetHandlerByMap | func (b *MockBroker) SetHandlerByMap(handlerMap map[string]MockResponse) {
b.setHandler(func(req *request) (res encoder) {
reqTypeName := reflect.TypeOf(req.body).Elem().Name()
mockResponse := handlerMap[reqTypeName]
if mockResponse == nil {
return nil
}
return mockResponse.For(req.body)
})
} | go | func (b *MockBroker) SetHandlerByMap(handlerMap map[string]MockResponse) {
b.setHandler(func(req *request) (res encoder) {
reqTypeName := reflect.TypeOf(req.body).Elem().Name()
mockResponse := handlerMap[reqTypeName]
if mockResponse == nil {
return nil
}
return mockResponse.For(req.body)
})
} | [
"func",
"(",
"b",
"*",
"MockBroker",
")",
"SetHandlerByMap",
"(",
"handlerMap",
"map",
"[",
"string",
"]",
"MockResponse",
")",
"{",
"b",
".",
"setHandler",
"(",
"func",
"(",
"req",
"*",
"request",
")",
"(",
"res",
"encoder",
")",
"{",
"reqTypeName",
"... | // SetHandlerByMap defines mapping of Request types to MockResponses. When a
// request is received by the broker, it looks up the request type in the map
// and uses the found MockResponse instance to generate an appropriate reply.
// If the request type is not found in the map then nothing is sent. | [
"SetHandlerByMap",
"defines",
"mapping",
"of",
"Request",
"types",
"to",
"MockResponses",
".",
"When",
"a",
"request",
"is",
"received",
"by",
"the",
"broker",
"it",
"looks",
"up",
"the",
"request",
"type",
"in",
"the",
"map",
"and",
"uses",
"the",
"found",
... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/mockbroker.go#L82-L91 |
158,142 | Shopify/sarama | mockbroker.go | SetNotifier | func (b *MockBroker) SetNotifier(notifier RequestNotifierFunc) {
b.lock.Lock()
b.notifier = notifier
b.lock.Unlock()
} | go | func (b *MockBroker) SetNotifier(notifier RequestNotifierFunc) {
b.lock.Lock()
b.notifier = notifier
b.lock.Unlock()
} | [
"func",
"(",
"b",
"*",
"MockBroker",
")",
"SetNotifier",
"(",
"notifier",
"RequestNotifierFunc",
")",
"{",
"b",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"b",
".",
"notifier",
"=",
"notifier",
"\n",
"b",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
... | // SetNotifier set a function that will get invoked whenever a request has been
// processed successfully and will provide the number of bytes read and written | [
"SetNotifier",
"set",
"a",
"function",
"that",
"will",
"get",
"invoked",
"whenever",
"a",
"request",
"has",
"been",
"processed",
"successfully",
"and",
"will",
"provide",
"the",
"number",
"of",
"bytes",
"read",
"and",
"written"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/mockbroker.go#L95-L99 |
158,143 | Shopify/sarama | mockbroker.go | History | func (b *MockBroker) History() []RequestResponse {
b.lock.Lock()
history := make([]RequestResponse, len(b.history))
copy(history, b.history)
b.lock.Unlock()
return history
} | go | func (b *MockBroker) History() []RequestResponse {
b.lock.Lock()
history := make([]RequestResponse, len(b.history))
copy(history, b.history)
b.lock.Unlock()
return history
} | [
"func",
"(",
"b",
"*",
"MockBroker",
")",
"History",
"(",
")",
"[",
"]",
"RequestResponse",
"{",
"b",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"history",
":=",
"make",
"(",
"[",
"]",
"RequestResponse",
",",
"len",
"(",
"b",
".",
"history",
")",
... | // History returns a slice of RequestResponse pairs in the order they were
// processed by the broker. Note that in case of multiple connections to the
// broker the order expected by a test can be different from the order recorded
// in the history, unless some synchronization is implemented in the test. | [
"History",
"returns",
"a",
"slice",
"of",
"RequestResponse",
"pairs",
"in",
"the",
"order",
"they",
"were",
"processed",
"by",
"the",
"broker",
".",
"Note",
"that",
"in",
"case",
"of",
"multiple",
"connections",
"to",
"the",
"broker",
"the",
"order",
"expect... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/mockbroker.go#L110-L116 |
158,144 | Shopify/sarama | mockbroker.go | Close | func (b *MockBroker) Close() {
close(b.expectations)
if len(b.expectations) > 0 {
buf := bytes.NewBufferString(fmt.Sprintf("mockbroker/%d: not all expectations were satisfied! Still waiting on:\n", b.BrokerID()))
for e := range b.expectations {
_, _ = buf.WriteString(spew.Sdump(e))
}
b.t.Error(buf.String())
}
close(b.closing)
<-b.stopper
} | go | func (b *MockBroker) Close() {
close(b.expectations)
if len(b.expectations) > 0 {
buf := bytes.NewBufferString(fmt.Sprintf("mockbroker/%d: not all expectations were satisfied! Still waiting on:\n", b.BrokerID()))
for e := range b.expectations {
_, _ = buf.WriteString(spew.Sdump(e))
}
b.t.Error(buf.String())
}
close(b.closing)
<-b.stopper
} | [
"func",
"(",
"b",
"*",
"MockBroker",
")",
"Close",
"(",
")",
"{",
"close",
"(",
"b",
".",
"expectations",
")",
"\n",
"if",
"len",
"(",
"b",
".",
"expectations",
")",
">",
"0",
"{",
"buf",
":=",
"bytes",
".",
"NewBufferString",
"(",
"fmt",
".",
"S... | // Close terminates the broker blocking until it stops internal goroutines and
// releases all resources. | [
"Close",
"terminates",
"the",
"broker",
"blocking",
"until",
"it",
"stops",
"internal",
"goroutines",
"and",
"releases",
"all",
"resources",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/mockbroker.go#L130-L141 |
158,145 | Shopify/sarama | mockbroker.go | setHandler | func (b *MockBroker) setHandler(handler requestHandlerFunc) {
b.lock.Lock()
b.handler = handler
b.lock.Unlock()
} | go | func (b *MockBroker) setHandler(handler requestHandlerFunc) {
b.lock.Lock()
b.handler = handler
b.lock.Unlock()
} | [
"func",
"(",
"b",
"*",
"MockBroker",
")",
"setHandler",
"(",
"handler",
"requestHandlerFunc",
")",
"{",
"b",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"b",
".",
"handler",
"=",
"handler",
"\n",
"b",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // setHandler sets the specified function as the request handler. Whenever
// a mock broker reads a request from the wire it passes the request to the
// function and sends back whatever the handler function returns. | [
"setHandler",
"sets",
"the",
"specified",
"function",
"as",
"the",
"request",
"handler",
".",
"Whenever",
"a",
"mock",
"broker",
"reads",
"a",
"request",
"from",
"the",
"wire",
"it",
"passes",
"the",
"request",
"to",
"the",
"function",
"and",
"sends",
"back"... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/mockbroker.go#L146-L150 |
158,146 | Shopify/sarama | mockbroker.go | NewMockBrokerAddr | func NewMockBrokerAddr(t TestReporter, brokerID int32, addr string) *MockBroker {
listener, err := net.Listen("tcp", addr)
if err != nil {
t.Fatal(err)
}
return NewMockBrokerListener(t, brokerID, listener)
} | go | func NewMockBrokerAddr(t TestReporter, brokerID int32, addr string) *MockBroker {
listener, err := net.Listen("tcp", addr)
if err != nil {
t.Fatal(err)
}
return NewMockBrokerListener(t, brokerID, listener)
} | [
"func",
"NewMockBrokerAddr",
"(",
"t",
"TestReporter",
",",
"brokerID",
"int32",
",",
"addr",
"string",
")",
"*",
"MockBroker",
"{",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // NewMockBrokerAddr behaves like newMockBroker but listens on the address you give
// it rather than just some ephemeral port. | [
"NewMockBrokerAddr",
"behaves",
"like",
"newMockBroker",
"but",
"listens",
"on",
"the",
"address",
"you",
"give",
"it",
"rather",
"than",
"just",
"some",
"ephemeral",
"port",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/mockbroker.go#L290-L296 |
158,147 | Shopify/sarama | mockbroker.go | NewMockBrokerListener | func NewMockBrokerListener(t TestReporter, brokerID int32, listener net.Listener) *MockBroker {
var err error
broker := &MockBroker{
closing: make(chan none),
stopper: make(chan none),
t: t,
brokerID: brokerID,
expectations: make(chan encoder, 512),
listener: listener,
}
broker.handler = broker.defaultRequestHandler
Logger.Printf("*** mockbroker/%d listening on %s\n", brokerID, broker.listener.Addr().String())
_, portStr, err := net.SplitHostPort(broker.listener.Addr().String())
if err != nil {
t.Fatal(err)
}
tmp, err := strconv.ParseInt(portStr, 10, 32)
if err != nil {
t.Fatal(err)
}
broker.port = int32(tmp)
go broker.serverLoop()
return broker
} | go | func NewMockBrokerListener(t TestReporter, brokerID int32, listener net.Listener) *MockBroker {
var err error
broker := &MockBroker{
closing: make(chan none),
stopper: make(chan none),
t: t,
brokerID: brokerID,
expectations: make(chan encoder, 512),
listener: listener,
}
broker.handler = broker.defaultRequestHandler
Logger.Printf("*** mockbroker/%d listening on %s\n", brokerID, broker.listener.Addr().String())
_, portStr, err := net.SplitHostPort(broker.listener.Addr().String())
if err != nil {
t.Fatal(err)
}
tmp, err := strconv.ParseInt(portStr, 10, 32)
if err != nil {
t.Fatal(err)
}
broker.port = int32(tmp)
go broker.serverLoop()
return broker
} | [
"func",
"NewMockBrokerListener",
"(",
"t",
"TestReporter",
",",
"brokerID",
"int32",
",",
"listener",
"net",
".",
"Listener",
")",
"*",
"MockBroker",
"{",
"var",
"err",
"error",
"\n\n",
"broker",
":=",
"&",
"MockBroker",
"{",
"closing",
":",
"make",
"(",
"... | // NewMockBrokerListener behaves like newMockBrokerAddr but accepts connections on the listener specified. | [
"NewMockBrokerListener",
"behaves",
"like",
"newMockBrokerAddr",
"but",
"accepts",
"connections",
"on",
"the",
"listener",
"specified",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/mockbroker.go#L299-L326 |
158,148 | Shopify/sarama | examples/consumergroup/main.go | Setup | func (consumer *Consumer) Setup(sarama.ConsumerGroupSession) error {
// Mark the consumer as ready
close(consumer.ready)
return nil
} | go | func (consumer *Consumer) Setup(sarama.ConsumerGroupSession) error {
// Mark the consumer as ready
close(consumer.ready)
return nil
} | [
"func",
"(",
"consumer",
"*",
"Consumer",
")",
"Setup",
"(",
"sarama",
".",
"ConsumerGroupSession",
")",
"error",
"{",
"// Mark the consumer as ready",
"close",
"(",
"consumer",
".",
"ready",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Setup is run at the beginning of a new session, before ConsumeClaim | [
"Setup",
"is",
"run",
"at",
"the",
"beginning",
"of",
"a",
"new",
"session",
"before",
"ConsumeClaim"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/examples/consumergroup/main.go#L111-L115 |
158,149 | Shopify/sarama | broker.go | Connected | func (b *Broker) Connected() (bool, error) {
b.lock.Lock()
defer b.lock.Unlock()
return b.conn != nil, b.connErr
} | go | func (b *Broker) Connected() (bool, error) {
b.lock.Lock()
defer b.lock.Unlock()
return b.conn != nil, b.connErr
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"Connected",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"b",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"b",
".",
"conn",
"!=",
"ni... | // Connected returns true if the broker is connected and false otherwise. If the broker is not
// connected but it had tried to connect, the error from that connection attempt is also returned. | [
"Connected",
"returns",
"true",
"if",
"the",
"broker",
"is",
"connected",
"and",
"false",
"otherwise",
".",
"If",
"the",
"broker",
"is",
"not",
"connected",
"but",
"it",
"had",
"tried",
"to",
"connect",
"the",
"error",
"from",
"that",
"connection",
"attempt"... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L221-L226 |
158,150 | Shopify/sarama | broker.go | Close | func (b *Broker) Close() error {
b.lock.Lock()
defer b.lock.Unlock()
if b.conn == nil {
return ErrNotConnected
}
close(b.responses)
<-b.done
err := b.conn.Close()
b.conn = nil
b.connErr = nil
b.done = nil
b.responses = nil
b.unregisterMetrics()
if err == nil {
Logger.Printf("Closed connection to broker %s\n", b.addr)
} else {
Logger.Printf("Error while closing connection to broker %s: %s\n", b.addr, err)
}
atomic.StoreInt32(&b.opened, 0)
return err
} | go | func (b *Broker) Close() error {
b.lock.Lock()
defer b.lock.Unlock()
if b.conn == nil {
return ErrNotConnected
}
close(b.responses)
<-b.done
err := b.conn.Close()
b.conn = nil
b.connErr = nil
b.done = nil
b.responses = nil
b.unregisterMetrics()
if err == nil {
Logger.Printf("Closed connection to broker %s\n", b.addr)
} else {
Logger.Printf("Error while closing connection to broker %s: %s\n", b.addr, err)
}
atomic.StoreInt32(&b.opened, 0)
return err
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"Close",
"(",
")",
"error",
"{",
"b",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"b",
".",
"conn",
"==",
"nil",
"{",
"return",
"ErrNotConnect... | //Close closes the broker resources | [
"Close",
"closes",
"the",
"broker",
"resources"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L229-L258 |
158,151 | Shopify/sarama | broker.go | GetMetadata | func (b *Broker) GetMetadata(request *MetadataRequest) (*MetadataResponse, error) {
response := new(MetadataResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) GetMetadata(request *MetadataRequest) (*MetadataResponse, error) {
response := new(MetadataResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"GetMetadata",
"(",
"request",
"*",
"MetadataRequest",
")",
"(",
"*",
"MetadataResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"MetadataResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndReceive",
... | //GetMetadata send a metadata request and returns a metadata response or error | [
"GetMetadata",
"send",
"a",
"metadata",
"request",
"and",
"returns",
"a",
"metadata",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L282-L292 |
158,152 | Shopify/sarama | broker.go | GetConsumerMetadata | func (b *Broker) GetConsumerMetadata(request *ConsumerMetadataRequest) (*ConsumerMetadataResponse, error) {
response := new(ConsumerMetadataResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) GetConsumerMetadata(request *ConsumerMetadataRequest) (*ConsumerMetadataResponse, error) {
response := new(ConsumerMetadataResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"GetConsumerMetadata",
"(",
"request",
"*",
"ConsumerMetadataRequest",
")",
"(",
"*",
"ConsumerMetadataResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"ConsumerMetadataResponse",
")",
"\n\n",
"err",
":=",
... | //GetConsumerMetadata send a consumer metadata request and returns a consumer metadata response or error | [
"GetConsumerMetadata",
"send",
"a",
"consumer",
"metadata",
"request",
"and",
"returns",
"a",
"consumer",
"metadata",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L295-L305 |
158,153 | Shopify/sarama | broker.go | FindCoordinator | func (b *Broker) FindCoordinator(request *FindCoordinatorRequest) (*FindCoordinatorResponse, error) {
response := new(FindCoordinatorResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) FindCoordinator(request *FindCoordinatorRequest) (*FindCoordinatorResponse, error) {
response := new(FindCoordinatorResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"FindCoordinator",
"(",
"request",
"*",
"FindCoordinatorRequest",
")",
"(",
"*",
"FindCoordinatorResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"FindCoordinatorResponse",
")",
"\n\n",
"err",
":=",
"b",
... | //FindCoordinator sends a find coordinate request and returns a response or error | [
"FindCoordinator",
"sends",
"a",
"find",
"coordinate",
"request",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L308-L318 |
158,154 | Shopify/sarama | broker.go | GetAvailableOffsets | func (b *Broker) GetAvailableOffsets(request *OffsetRequest) (*OffsetResponse, error) {
response := new(OffsetResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) GetAvailableOffsets(request *OffsetRequest) (*OffsetResponse, error) {
response := new(OffsetResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"GetAvailableOffsets",
"(",
"request",
"*",
"OffsetRequest",
")",
"(",
"*",
"OffsetResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"OffsetResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndReceive"... | //GetAvailableOffsets return an offset response or error | [
"GetAvailableOffsets",
"return",
"an",
"offset",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L321-L331 |
158,155 | Shopify/sarama | broker.go | Produce | func (b *Broker) Produce(request *ProduceRequest) (*ProduceResponse, error) {
var (
response *ProduceResponse
err error
)
if request.RequiredAcks == NoResponse {
err = b.sendAndReceive(request, nil)
} else {
response = new(ProduceResponse)
err = b.sendAndReceive(request, response)
}
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) Produce(request *ProduceRequest) (*ProduceResponse, error) {
var (
response *ProduceResponse
err error
)
if request.RequiredAcks == NoResponse {
err = b.sendAndReceive(request, nil)
} else {
response = new(ProduceResponse)
err = b.sendAndReceive(request, response)
}
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"Produce",
"(",
"request",
"*",
"ProduceRequest",
")",
"(",
"*",
"ProduceResponse",
",",
"error",
")",
"{",
"var",
"(",
"response",
"*",
"ProduceResponse",
"\n",
"err",
"error",
"\n",
")",
"\n\n",
"if",
"request",
... | //Produce returns a produce response or error | [
"Produce",
"returns",
"a",
"produce",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L334-L352 |
158,156 | Shopify/sarama | broker.go | Fetch | func (b *Broker) Fetch(request *FetchRequest) (*FetchResponse, error) {
response := new(FetchResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) Fetch(request *FetchRequest) (*FetchResponse, error) {
response := new(FetchResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"Fetch",
"(",
"request",
"*",
"FetchRequest",
")",
"(",
"*",
"FetchResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"FetchResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndReceive",
"(",
"reque... | //Fetch returns a FetchResponse or error | [
"Fetch",
"returns",
"a",
"FetchResponse",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L355-L364 |
158,157 | Shopify/sarama | broker.go | CommitOffset | func (b *Broker) CommitOffset(request *OffsetCommitRequest) (*OffsetCommitResponse, error) {
response := new(OffsetCommitResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) CommitOffset(request *OffsetCommitRequest) (*OffsetCommitResponse, error) {
response := new(OffsetCommitResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"CommitOffset",
"(",
"request",
"*",
"OffsetCommitRequest",
")",
"(",
"*",
"OffsetCommitResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"OffsetCommitResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"send... | //CommitOffset return an Offset commit reponse or error | [
"CommitOffset",
"return",
"an",
"Offset",
"commit",
"reponse",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L367-L376 |
158,158 | Shopify/sarama | broker.go | FetchOffset | func (b *Broker) FetchOffset(request *OffsetFetchRequest) (*OffsetFetchResponse, error) {
response := new(OffsetFetchResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) FetchOffset(request *OffsetFetchRequest) (*OffsetFetchResponse, error) {
response := new(OffsetFetchResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"FetchOffset",
"(",
"request",
"*",
"OffsetFetchRequest",
")",
"(",
"*",
"OffsetFetchResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"OffsetFetchResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndR... | //FetchOffset returns an offset fetch response or error | [
"FetchOffset",
"returns",
"an",
"offset",
"fetch",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L379-L388 |
158,159 | Shopify/sarama | broker.go | JoinGroup | func (b *Broker) JoinGroup(request *JoinGroupRequest) (*JoinGroupResponse, error) {
response := new(JoinGroupResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) JoinGroup(request *JoinGroupRequest) (*JoinGroupResponse, error) {
response := new(JoinGroupResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"JoinGroup",
"(",
"request",
"*",
"JoinGroupRequest",
")",
"(",
"*",
"JoinGroupResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"JoinGroupResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndReceive",... | //JoinGroup returns a join group response or error | [
"JoinGroup",
"returns",
"a",
"join",
"group",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L391-L400 |
158,160 | Shopify/sarama | broker.go | SyncGroup | func (b *Broker) SyncGroup(request *SyncGroupRequest) (*SyncGroupResponse, error) {
response := new(SyncGroupResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) SyncGroup(request *SyncGroupRequest) (*SyncGroupResponse, error) {
response := new(SyncGroupResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"SyncGroup",
"(",
"request",
"*",
"SyncGroupRequest",
")",
"(",
"*",
"SyncGroupResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"SyncGroupResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndReceive",... | //SyncGroup returns a sync group response or error | [
"SyncGroup",
"returns",
"a",
"sync",
"group",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L403-L412 |
158,161 | Shopify/sarama | broker.go | LeaveGroup | func (b *Broker) LeaveGroup(request *LeaveGroupRequest) (*LeaveGroupResponse, error) {
response := new(LeaveGroupResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) LeaveGroup(request *LeaveGroupRequest) (*LeaveGroupResponse, error) {
response := new(LeaveGroupResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"LeaveGroup",
"(",
"request",
"*",
"LeaveGroupRequest",
")",
"(",
"*",
"LeaveGroupResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"LeaveGroupResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndRecei... | //LeaveGroup return a leave group response or error | [
"LeaveGroup",
"return",
"a",
"leave",
"group",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L415-L424 |
158,162 | Shopify/sarama | broker.go | Heartbeat | func (b *Broker) Heartbeat(request *HeartbeatRequest) (*HeartbeatResponse, error) {
response := new(HeartbeatResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) Heartbeat(request *HeartbeatRequest) (*HeartbeatResponse, error) {
response := new(HeartbeatResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"Heartbeat",
"(",
"request",
"*",
"HeartbeatRequest",
")",
"(",
"*",
"HeartbeatResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"HeartbeatResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndReceive",... | //Heartbeat returns a heartbeat response or error | [
"Heartbeat",
"returns",
"a",
"heartbeat",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L427-L436 |
158,163 | Shopify/sarama | broker.go | ListGroups | func (b *Broker) ListGroups(request *ListGroupsRequest) (*ListGroupsResponse, error) {
response := new(ListGroupsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) ListGroups(request *ListGroupsRequest) (*ListGroupsResponse, error) {
response := new(ListGroupsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"ListGroups",
"(",
"request",
"*",
"ListGroupsRequest",
")",
"(",
"*",
"ListGroupsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"ListGroupsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndRecei... | //ListGroups return a list group response or error | [
"ListGroups",
"return",
"a",
"list",
"group",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L439-L448 |
158,164 | Shopify/sarama | broker.go | DescribeGroups | func (b *Broker) DescribeGroups(request *DescribeGroupsRequest) (*DescribeGroupsResponse, error) {
response := new(DescribeGroupsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) DescribeGroups(request *DescribeGroupsRequest) (*DescribeGroupsResponse, error) {
response := new(DescribeGroupsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"DescribeGroups",
"(",
"request",
"*",
"DescribeGroupsRequest",
")",
"(",
"*",
"DescribeGroupsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"DescribeGroupsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",... | //DescribeGroups return describe group response or error | [
"DescribeGroups",
"return",
"describe",
"group",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L451-L460 |
158,165 | Shopify/sarama | broker.go | ApiVersions | func (b *Broker) ApiVersions(request *ApiVersionsRequest) (*ApiVersionsResponse, error) {
response := new(ApiVersionsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) ApiVersions(request *ApiVersionsRequest) (*ApiVersionsResponse, error) {
response := new(ApiVersionsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"ApiVersions",
"(",
"request",
"*",
"ApiVersionsRequest",
")",
"(",
"*",
"ApiVersionsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"ApiVersionsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndR... | //ApiVersions return api version response or error | [
"ApiVersions",
"return",
"api",
"version",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L463-L472 |
158,166 | Shopify/sarama | broker.go | CreateTopics | func (b *Broker) CreateTopics(request *CreateTopicsRequest) (*CreateTopicsResponse, error) {
response := new(CreateTopicsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) CreateTopics(request *CreateTopicsRequest) (*CreateTopicsResponse, error) {
response := new(CreateTopicsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"CreateTopics",
"(",
"request",
"*",
"CreateTopicsRequest",
")",
"(",
"*",
"CreateTopicsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"CreateTopicsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"send... | //CreateTopics send a create topic request and returns create topic response | [
"CreateTopics",
"send",
"a",
"create",
"topic",
"request",
"and",
"returns",
"create",
"topic",
"response"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L475-L484 |
158,167 | Shopify/sarama | broker.go | DeleteTopics | func (b *Broker) DeleteTopics(request *DeleteTopicsRequest) (*DeleteTopicsResponse, error) {
response := new(DeleteTopicsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) DeleteTopics(request *DeleteTopicsRequest) (*DeleteTopicsResponse, error) {
response := new(DeleteTopicsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"DeleteTopics",
"(",
"request",
"*",
"DeleteTopicsRequest",
")",
"(",
"*",
"DeleteTopicsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"DeleteTopicsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"send... | //DeleteTopics sends a delete topic request and returns delete topic response | [
"DeleteTopics",
"sends",
"a",
"delete",
"topic",
"request",
"and",
"returns",
"delete",
"topic",
"response"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L487-L496 |
158,168 | Shopify/sarama | broker.go | CreatePartitions | func (b *Broker) CreatePartitions(request *CreatePartitionsRequest) (*CreatePartitionsResponse, error) {
response := new(CreatePartitionsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) CreatePartitions(request *CreatePartitionsRequest) (*CreatePartitionsResponse, error) {
response := new(CreatePartitionsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"CreatePartitions",
"(",
"request",
"*",
"CreatePartitionsRequest",
")",
"(",
"*",
"CreatePartitionsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"CreatePartitionsResponse",
")",
"\n\n",
"err",
":=",
"b"... | //CreatePartitions sends a create partition request and returns create
//partitions response or error | [
"CreatePartitions",
"sends",
"a",
"create",
"partition",
"request",
"and",
"returns",
"create",
"partitions",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L500-L509 |
158,169 | Shopify/sarama | broker.go | DeleteRecords | func (b *Broker) DeleteRecords(request *DeleteRecordsRequest) (*DeleteRecordsResponse, error) {
response := new(DeleteRecordsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) DeleteRecords(request *DeleteRecordsRequest) (*DeleteRecordsResponse, error) {
response := new(DeleteRecordsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"DeleteRecords",
"(",
"request",
"*",
"DeleteRecordsRequest",
")",
"(",
"*",
"DeleteRecordsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"DeleteRecordsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"... | //DeleteRecords send a request to delete records and return delete record
//response or error | [
"DeleteRecords",
"send",
"a",
"request",
"to",
"delete",
"records",
"and",
"return",
"delete",
"record",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L513-L522 |
158,170 | Shopify/sarama | broker.go | DescribeAcls | func (b *Broker) DescribeAcls(request *DescribeAclsRequest) (*DescribeAclsResponse, error) {
response := new(DescribeAclsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) DescribeAcls(request *DescribeAclsRequest) (*DescribeAclsResponse, error) {
response := new(DescribeAclsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"DescribeAcls",
"(",
"request",
"*",
"DescribeAclsRequest",
")",
"(",
"*",
"DescribeAclsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"DescribeAclsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"send... | //DescribeAcls sends a describe acl request and returns a response or error | [
"DescribeAcls",
"sends",
"a",
"describe",
"acl",
"request",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L525-L534 |
158,171 | Shopify/sarama | broker.go | CreateAcls | func (b *Broker) CreateAcls(request *CreateAclsRequest) (*CreateAclsResponse, error) {
response := new(CreateAclsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) CreateAcls(request *CreateAclsRequest) (*CreateAclsResponse, error) {
response := new(CreateAclsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"CreateAcls",
"(",
"request",
"*",
"CreateAclsRequest",
")",
"(",
"*",
"CreateAclsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"CreateAclsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndRecei... | //CreateAcls sends a create acl request and returns a response or error | [
"CreateAcls",
"sends",
"a",
"create",
"acl",
"request",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L537-L546 |
158,172 | Shopify/sarama | broker.go | DeleteAcls | func (b *Broker) DeleteAcls(request *DeleteAclsRequest) (*DeleteAclsResponse, error) {
response := new(DeleteAclsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) DeleteAcls(request *DeleteAclsRequest) (*DeleteAclsResponse, error) {
response := new(DeleteAclsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"DeleteAcls",
"(",
"request",
"*",
"DeleteAclsRequest",
")",
"(",
"*",
"DeleteAclsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"DeleteAclsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndRecei... | //DeleteAcls sends a delete acl request and returns a response or error | [
"DeleteAcls",
"sends",
"a",
"delete",
"acl",
"request",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L549-L558 |
158,173 | Shopify/sarama | broker.go | InitProducerID | func (b *Broker) InitProducerID(request *InitProducerIDRequest) (*InitProducerIDResponse, error) {
response := new(InitProducerIDResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) InitProducerID(request *InitProducerIDRequest) (*InitProducerIDResponse, error) {
response := new(InitProducerIDResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"InitProducerID",
"(",
"request",
"*",
"InitProducerIDRequest",
")",
"(",
"*",
"InitProducerIDResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"InitProducerIDResponse",
")",
"\n\n",
"err",
":=",
"b",
".",... | //InitProducerID sends an init producer request and returns a response or error | [
"InitProducerID",
"sends",
"an",
"init",
"producer",
"request",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L561-L570 |
158,174 | Shopify/sarama | broker.go | AddPartitionsToTxn | func (b *Broker) AddPartitionsToTxn(request *AddPartitionsToTxnRequest) (*AddPartitionsToTxnResponse, error) {
response := new(AddPartitionsToTxnResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) AddPartitionsToTxn(request *AddPartitionsToTxnRequest) (*AddPartitionsToTxnResponse, error) {
response := new(AddPartitionsToTxnResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"AddPartitionsToTxn",
"(",
"request",
"*",
"AddPartitionsToTxnRequest",
")",
"(",
"*",
"AddPartitionsToTxnResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"AddPartitionsToTxnResponse",
")",
"\n\n",
"err",
":=... | //AddPartitionsToTxn send a request to add partition to txn and returns
//a response or error | [
"AddPartitionsToTxn",
"send",
"a",
"request",
"to",
"add",
"partition",
"to",
"txn",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L574-L583 |
158,175 | Shopify/sarama | broker.go | AddOffsetsToTxn | func (b *Broker) AddOffsetsToTxn(request *AddOffsetsToTxnRequest) (*AddOffsetsToTxnResponse, error) {
response := new(AddOffsetsToTxnResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) AddOffsetsToTxn(request *AddOffsetsToTxnRequest) (*AddOffsetsToTxnResponse, error) {
response := new(AddOffsetsToTxnResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"AddOffsetsToTxn",
"(",
"request",
"*",
"AddOffsetsToTxnRequest",
")",
"(",
"*",
"AddOffsetsToTxnResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"AddOffsetsToTxnResponse",
")",
"\n\n",
"err",
":=",
"b",
... | //AddOffsetsToTxn sends a request to add offsets to txn and returns a response
//or error | [
"AddOffsetsToTxn",
"sends",
"a",
"request",
"to",
"add",
"offsets",
"to",
"txn",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L587-L596 |
158,176 | Shopify/sarama | broker.go | EndTxn | func (b *Broker) EndTxn(request *EndTxnRequest) (*EndTxnResponse, error) {
response := new(EndTxnResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) EndTxn(request *EndTxnRequest) (*EndTxnResponse, error) {
response := new(EndTxnResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"EndTxn",
"(",
"request",
"*",
"EndTxnRequest",
")",
"(",
"*",
"EndTxnResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"EndTxnResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"sendAndReceive",
"(",
"r... | //EndTxn sends a request to end txn and returns a response or error | [
"EndTxn",
"sends",
"a",
"request",
"to",
"end",
"txn",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L599-L608 |
158,177 | Shopify/sarama | broker.go | TxnOffsetCommit | func (b *Broker) TxnOffsetCommit(request *TxnOffsetCommitRequest) (*TxnOffsetCommitResponse, error) {
response := new(TxnOffsetCommitResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) TxnOffsetCommit(request *TxnOffsetCommitRequest) (*TxnOffsetCommitResponse, error) {
response := new(TxnOffsetCommitResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"TxnOffsetCommit",
"(",
"request",
"*",
"TxnOffsetCommitRequest",
")",
"(",
"*",
"TxnOffsetCommitResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"TxnOffsetCommitResponse",
")",
"\n\n",
"err",
":=",
"b",
... | //TxnOffsetCommit sends a request to commit transaction offsets and returns
//a response or error | [
"TxnOffsetCommit",
"sends",
"a",
"request",
"to",
"commit",
"transaction",
"offsets",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L612-L621 |
158,178 | Shopify/sarama | broker.go | DescribeConfigs | func (b *Broker) DescribeConfigs(request *DescribeConfigsRequest) (*DescribeConfigsResponse, error) {
response := new(DescribeConfigsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) DescribeConfigs(request *DescribeConfigsRequest) (*DescribeConfigsResponse, error) {
response := new(DescribeConfigsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"DescribeConfigs",
"(",
"request",
"*",
"DescribeConfigsRequest",
")",
"(",
"*",
"DescribeConfigsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"DescribeConfigsResponse",
")",
"\n\n",
"err",
":=",
"b",
... | //DescribeConfigs sends a request to describe config and returns a response or
//error | [
"DescribeConfigs",
"sends",
"a",
"request",
"to",
"describe",
"config",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L625-L634 |
158,179 | Shopify/sarama | broker.go | AlterConfigs | func (b *Broker) AlterConfigs(request *AlterConfigsRequest) (*AlterConfigsResponse, error) {
response := new(AlterConfigsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) AlterConfigs(request *AlterConfigsRequest) (*AlterConfigsResponse, error) {
response := new(AlterConfigsResponse)
err := b.sendAndReceive(request, response)
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"AlterConfigs",
"(",
"request",
"*",
"AlterConfigsRequest",
")",
"(",
"*",
"AlterConfigsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"AlterConfigsResponse",
")",
"\n\n",
"err",
":=",
"b",
".",
"send... | //AlterConfigs sends a request to alter config and return a response or error | [
"AlterConfigs",
"sends",
"a",
"request",
"to",
"alter",
"config",
"and",
"return",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L637-L646 |
158,180 | Shopify/sarama | broker.go | DeleteGroups | func (b *Broker) DeleteGroups(request *DeleteGroupsRequest) (*DeleteGroupsResponse, error) {
response := new(DeleteGroupsResponse)
if err := b.sendAndReceive(request, response); err != nil {
return nil, err
}
return response, nil
} | go | func (b *Broker) DeleteGroups(request *DeleteGroupsRequest) (*DeleteGroupsResponse, error) {
response := new(DeleteGroupsResponse)
if err := b.sendAndReceive(request, response); err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"DeleteGroups",
"(",
"request",
"*",
"DeleteGroupsRequest",
")",
"(",
"*",
"DeleteGroupsResponse",
",",
"error",
")",
"{",
"response",
":=",
"new",
"(",
"DeleteGroupsResponse",
")",
"\n\n",
"if",
"err",
":=",
"b",
".",... | //DeleteGroups sends a request to delete groups and returns a response or error | [
"DeleteGroups",
"sends",
"a",
"request",
"to",
"delete",
"groups",
"and",
"returns",
"a",
"response",
"or",
"error"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L649-L657 |
158,181 | Shopify/sarama | broker.go | sendAndReceiveV0SASLPlainAuth | func (b *Broker) sendAndReceiveV0SASLPlainAuth() error {
length := 1 + len(b.conf.Net.SASL.User) + 1 + len(b.conf.Net.SASL.Password)
authBytes := make([]byte, length+4) //4 byte length header + auth data
binary.BigEndian.PutUint32(authBytes, uint32(length))
copy(authBytes[4:], []byte("\x00"+b.conf.Net.SASL.User+"\x00"+b.conf.Net.SASL.Password))
err := b.conn.SetWriteDeadline(time.Now().Add(b.conf.Net.WriteTimeout))
if err != nil {
Logger.Printf("Failed to set write deadline when doing SASL auth with broker %s: %s\n", b.addr, err.Error())
return err
}
requestTime := time.Now()
bytesWritten, err := b.conn.Write(authBytes)
b.updateOutgoingCommunicationMetrics(bytesWritten)
if err != nil {
Logger.Printf("Failed to write SASL auth header to broker %s: %s\n", b.addr, err.Error())
return err
}
header := make([]byte, 4)
n, err := io.ReadFull(b.conn, header)
b.updateIncomingCommunicationMetrics(n, time.Since(requestTime))
// If the credentials are valid, we would get a 4 byte response filled with null characters.
// Otherwise, the broker closes the connection and we get an EOF
if err != nil {
Logger.Printf("Failed to read response while authenticating with SASL to broker %s: %s\n", b.addr, err.Error())
return err
}
Logger.Printf("SASL authentication successful with broker %s:%v - %v\n", b.addr, n, header)
return nil
} | go | func (b *Broker) sendAndReceiveV0SASLPlainAuth() error {
length := 1 + len(b.conf.Net.SASL.User) + 1 + len(b.conf.Net.SASL.Password)
authBytes := make([]byte, length+4) //4 byte length header + auth data
binary.BigEndian.PutUint32(authBytes, uint32(length))
copy(authBytes[4:], []byte("\x00"+b.conf.Net.SASL.User+"\x00"+b.conf.Net.SASL.Password))
err := b.conn.SetWriteDeadline(time.Now().Add(b.conf.Net.WriteTimeout))
if err != nil {
Logger.Printf("Failed to set write deadline when doing SASL auth with broker %s: %s\n", b.addr, err.Error())
return err
}
requestTime := time.Now()
bytesWritten, err := b.conn.Write(authBytes)
b.updateOutgoingCommunicationMetrics(bytesWritten)
if err != nil {
Logger.Printf("Failed to write SASL auth header to broker %s: %s\n", b.addr, err.Error())
return err
}
header := make([]byte, 4)
n, err := io.ReadFull(b.conn, header)
b.updateIncomingCommunicationMetrics(n, time.Since(requestTime))
// If the credentials are valid, we would get a 4 byte response filled with null characters.
// Otherwise, the broker closes the connection and we get an EOF
if err != nil {
Logger.Printf("Failed to read response while authenticating with SASL to broker %s: %s\n", b.addr, err.Error())
return err
}
Logger.Printf("SASL authentication successful with broker %s:%v - %v\n", b.addr, n, header)
return nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"sendAndReceiveV0SASLPlainAuth",
"(",
")",
"error",
"{",
"length",
":=",
"1",
"+",
"len",
"(",
"b",
".",
"conf",
".",
"Net",
".",
"SASL",
".",
"User",
")",
"+",
"1",
"+",
"len",
"(",
"b",
".",
"conf",
".",
... | // sendAndReceiveV0SASLPlainAuth flows the v0 sasl auth NOT wrapped in the kafka protocol | [
"sendAndReceiveV0SASLPlainAuth",
"flows",
"the",
"v0",
"sasl",
"auth",
"NOT",
"wrapped",
"in",
"the",
"kafka",
"protocol"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L954-L987 |
158,182 | Shopify/sarama | broker.go | sendAndReceiveV1SASLPlainAuth | func (b *Broker) sendAndReceiveV1SASLPlainAuth() error {
correlationID := b.correlationID
requestTime := time.Now()
bytesWritten, err := b.sendSASLPlainAuthClientResponse(correlationID)
b.updateOutgoingCommunicationMetrics(bytesWritten)
if err != nil {
Logger.Printf("Failed to write SASL auth header to broker %s: %s\n", b.addr, err.Error())
return err
}
b.correlationID++
bytesRead, err := b.receiveSASLServerResponse(correlationID)
b.updateIncomingCommunicationMetrics(bytesRead, time.Since(requestTime))
// With v1 sasl we get an error message set in the response we can return
if err != nil {
Logger.Printf("Error returned from broker during SASL flow %s: %s\n", b.addr, err.Error())
return err
}
return nil
} | go | func (b *Broker) sendAndReceiveV1SASLPlainAuth() error {
correlationID := b.correlationID
requestTime := time.Now()
bytesWritten, err := b.sendSASLPlainAuthClientResponse(correlationID)
b.updateOutgoingCommunicationMetrics(bytesWritten)
if err != nil {
Logger.Printf("Failed to write SASL auth header to broker %s: %s\n", b.addr, err.Error())
return err
}
b.correlationID++
bytesRead, err := b.receiveSASLServerResponse(correlationID)
b.updateIncomingCommunicationMetrics(bytesRead, time.Since(requestTime))
// With v1 sasl we get an error message set in the response we can return
if err != nil {
Logger.Printf("Error returned from broker during SASL flow %s: %s\n", b.addr, err.Error())
return err
}
return nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"sendAndReceiveV1SASLPlainAuth",
"(",
")",
"error",
"{",
"correlationID",
":=",
"b",
".",
"correlationID",
"\n\n",
"requestTime",
":=",
"time",
".",
"Now",
"(",
")",
"\n\n",
"bytesWritten",
",",
"err",
":=",
"b",
".",
... | // sendAndReceiveV1SASLPlainAuth flows the v1 sasl authentication using the kafka protocol | [
"sendAndReceiveV1SASLPlainAuth",
"flows",
"the",
"v1",
"sasl",
"authentication",
"using",
"the",
"kafka",
"protocol"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L990-L1016 |
158,183 | Shopify/sarama | broker.go | mapToString | func mapToString(extensions map[string]string, keyValSep string, elemSep string) string {
buf := make([]string, 0, len(extensions))
for k, v := range extensions {
buf = append(buf, k+keyValSep+v)
}
sort.Strings(buf)
return strings.Join(buf, elemSep)
} | go | func mapToString(extensions map[string]string, keyValSep string, elemSep string) string {
buf := make([]string, 0, len(extensions))
for k, v := range extensions {
buf = append(buf, k+keyValSep+v)
}
sort.Strings(buf)
return strings.Join(buf, elemSep)
} | [
"func",
"mapToString",
"(",
"extensions",
"map",
"[",
"string",
"]",
"string",
",",
"keyValSep",
"string",
",",
"elemSep",
"string",
")",
"string",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"extensions",
")",
")",
... | // mapToString returns a list of key-value pairs ordered by key.
// keyValSep separates the key from the value. elemSep separates each pair. | [
"mapToString",
"returns",
"a",
"list",
"of",
"key",
"-",
"value",
"pairs",
"ordered",
"by",
"key",
".",
"keyValSep",
"separates",
"the",
"key",
"from",
"the",
"value",
".",
"elemSep",
"separates",
"each",
"pair",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/broker.go#L1164-L1174 |
158,184 | Shopify/sarama | message_set.go | Messages | func (msb *MessageBlock) Messages() []*MessageBlock {
if msb.Msg.Set != nil {
return msb.Msg.Set.Messages
}
return []*MessageBlock{msb}
} | go | func (msb *MessageBlock) Messages() []*MessageBlock {
if msb.Msg.Set != nil {
return msb.Msg.Set.Messages
}
return []*MessageBlock{msb}
} | [
"func",
"(",
"msb",
"*",
"MessageBlock",
")",
"Messages",
"(",
")",
"[",
"]",
"*",
"MessageBlock",
"{",
"if",
"msb",
".",
"Msg",
".",
"Set",
"!=",
"nil",
"{",
"return",
"msb",
".",
"Msg",
".",
"Set",
".",
"Messages",
"\n",
"}",
"\n",
"return",
"[... | // Messages convenience helper which returns either all the
// messages that are wrapped in this block | [
"Messages",
"convenience",
"helper",
"which",
"returns",
"either",
"all",
"the",
"messages",
"that",
"are",
"wrapped",
"in",
"this",
"block"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/message_set.go#L10-L15 |
158,185 | Shopify/sarama | consumer_group.go | NewConsumerGroup | func NewConsumerGroup(addrs []string, groupID string, config *Config) (ConsumerGroup, error) {
client, err := NewClient(addrs, config)
if err != nil {
return nil, err
}
c, err := newConsumerGroup(groupID, client)
if err != nil {
_ = client.Close()
}
return c, err
} | go | func NewConsumerGroup(addrs []string, groupID string, config *Config) (ConsumerGroup, error) {
client, err := NewClient(addrs, config)
if err != nil {
return nil, err
}
c, err := newConsumerGroup(groupID, client)
if err != nil {
_ = client.Close()
}
return c, err
} | [
"func",
"NewConsumerGroup",
"(",
"addrs",
"[",
"]",
"string",
",",
"groupID",
"string",
",",
"config",
"*",
"Config",
")",
"(",
"ConsumerGroup",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"NewClient",
"(",
"addrs",
",",
"config",
")",
"\n",
"i... | // NewConsumerGroup creates a new consumer group the given broker addresses and configuration. | [
"NewConsumerGroup",
"creates",
"a",
"new",
"consumer",
"group",
"the",
"given",
"broker",
"addresses",
"and",
"configuration",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/consumer_group.go#L69-L80 |
158,186 | Shopify/sarama | consumer_group.go | Close | func (c *consumerGroup) Close() (err error) {
c.closeOnce.Do(func() {
close(c.closed)
c.lock.Lock()
defer c.lock.Unlock()
// leave group
if e := c.leave(); e != nil {
err = e
}
// drain errors
go func() {
close(c.errors)
}()
for e := range c.errors {
err = e
}
if e := c.client.Close(); e != nil {
err = e
}
})
return
} | go | func (c *consumerGroup) Close() (err error) {
c.closeOnce.Do(func() {
close(c.closed)
c.lock.Lock()
defer c.lock.Unlock()
// leave group
if e := c.leave(); e != nil {
err = e
}
// drain errors
go func() {
close(c.errors)
}()
for e := range c.errors {
err = e
}
if e := c.client.Close(); e != nil {
err = e
}
})
return
} | [
"func",
"(",
"c",
"*",
"consumerGroup",
")",
"Close",
"(",
")",
"(",
"err",
"error",
")",
"{",
"c",
".",
"closeOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"close",
"(",
"c",
".",
"closed",
")",
"\n\n",
"c",
".",
"lock",
".",
"Lock",
"(",
")... | // Close implements ConsumerGroup. | [
"Close",
"implements",
"ConsumerGroup",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/consumer_group.go#L117-L142 |
158,187 | Shopify/sarama | consumer_group.go | Consume | func (c *consumerGroup) Consume(ctx context.Context, topics []string, handler ConsumerGroupHandler) error {
// Ensure group is not closed
select {
case <-c.closed:
return ErrClosedConsumerGroup
default:
}
c.lock.Lock()
defer c.lock.Unlock()
// Quick exit when no topics are provided
if len(topics) == 0 {
return fmt.Errorf("no topics provided")
}
// Refresh metadata for requested topics
if err := c.client.RefreshMetadata(topics...); err != nil {
return err
}
// Init session
sess, err := c.newSession(ctx, topics, handler, c.config.Consumer.Group.Rebalance.Retry.Max)
if err == ErrClosedClient {
return ErrClosedConsumerGroup
} else if err != nil {
return err
}
// Wait for session exit signal
<-sess.ctx.Done()
// Gracefully release session claims
return sess.release(true)
} | go | func (c *consumerGroup) Consume(ctx context.Context, topics []string, handler ConsumerGroupHandler) error {
// Ensure group is not closed
select {
case <-c.closed:
return ErrClosedConsumerGroup
default:
}
c.lock.Lock()
defer c.lock.Unlock()
// Quick exit when no topics are provided
if len(topics) == 0 {
return fmt.Errorf("no topics provided")
}
// Refresh metadata for requested topics
if err := c.client.RefreshMetadata(topics...); err != nil {
return err
}
// Init session
sess, err := c.newSession(ctx, topics, handler, c.config.Consumer.Group.Rebalance.Retry.Max)
if err == ErrClosedClient {
return ErrClosedConsumerGroup
} else if err != nil {
return err
}
// Wait for session exit signal
<-sess.ctx.Done()
// Gracefully release session claims
return sess.release(true)
} | [
"func",
"(",
"c",
"*",
"consumerGroup",
")",
"Consume",
"(",
"ctx",
"context",
".",
"Context",
",",
"topics",
"[",
"]",
"string",
",",
"handler",
"ConsumerGroupHandler",
")",
"error",
"{",
"// Ensure group is not closed",
"select",
"{",
"case",
"<-",
"c",
".... | // Consume implements ConsumerGroup. | [
"Consume",
"implements",
"ConsumerGroup",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/consumer_group.go#L145-L179 |
158,188 | Shopify/sarama | consumer_group.go | leave | func (c *consumerGroup) leave() error {
if c.memberID == "" {
return nil
}
coordinator, err := c.client.Coordinator(c.groupID)
if err != nil {
return err
}
resp, err := coordinator.LeaveGroup(&LeaveGroupRequest{
GroupId: c.groupID,
MemberId: c.memberID,
})
if err != nil {
_ = coordinator.Close()
return err
}
// Unset memberID
c.memberID = ""
// Check response
switch resp.Err {
case ErrRebalanceInProgress, ErrUnknownMemberId, ErrNoError:
return nil
default:
return resp.Err
}
} | go | func (c *consumerGroup) leave() error {
if c.memberID == "" {
return nil
}
coordinator, err := c.client.Coordinator(c.groupID)
if err != nil {
return err
}
resp, err := coordinator.LeaveGroup(&LeaveGroupRequest{
GroupId: c.groupID,
MemberId: c.memberID,
})
if err != nil {
_ = coordinator.Close()
return err
}
// Unset memberID
c.memberID = ""
// Check response
switch resp.Err {
case ErrRebalanceInProgress, ErrUnknownMemberId, ErrNoError:
return nil
default:
return resp.Err
}
} | [
"func",
"(",
"c",
"*",
"consumerGroup",
")",
"leave",
"(",
")",
"error",
"{",
"if",
"c",
".",
"memberID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"coordinator",
",",
"err",
":=",
"c",
".",
"client",
".",
"Coordinator",
"(",
"c",
... | // Leaves the cluster, called by Close, protected by lock. | [
"Leaves",
"the",
"cluster",
"called",
"by",
"Close",
"protected",
"by",
"lock",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/consumer_group.go#L366-L395 |
158,189 | Shopify/sarama | consumer_group.go | waitClosed | func (c *consumerGroupClaim) waitClosed() (errs ConsumerErrors) {
go func() {
for range c.Messages() {
}
}()
for err := range c.Errors() {
errs = append(errs, err)
}
return
} | go | func (c *consumerGroupClaim) waitClosed() (errs ConsumerErrors) {
go func() {
for range c.Messages() {
}
}()
for err := range c.Errors() {
errs = append(errs, err)
}
return
} | [
"func",
"(",
"c",
"*",
"consumerGroupClaim",
")",
"waitClosed",
"(",
")",
"(",
"errs",
"ConsumerErrors",
")",
"{",
"go",
"func",
"(",
")",
"{",
"for",
"range",
"c",
".",
"Messages",
"(",
")",
"{",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"err",
"... | // Drains messages and errors, ensures the claim is fully closed. | [
"Drains",
"messages",
"and",
"errors",
"ensures",
"the",
"claim",
"is",
"fully",
"closed",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/consumer_group.go#L791-L801 |
158,190 | Shopify/sarama | message.go | decodeSet | func (m *Message) decodeSet() (err error) {
pd := realDecoder{raw: m.Value}
m.Set = &MessageSet{}
return m.Set.decode(&pd)
} | go | func (m *Message) decodeSet() (err error) {
pd := realDecoder{raw: m.Value}
m.Set = &MessageSet{}
return m.Set.decode(&pd)
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"decodeSet",
"(",
")",
"(",
"err",
"error",
")",
"{",
"pd",
":=",
"realDecoder",
"{",
"raw",
":",
"m",
".",
"Value",
"}",
"\n",
"m",
".",
"Set",
"=",
"&",
"MessageSet",
"{",
"}",
"\n",
"return",
"m",
".",
... | // decodes a message set from a previously encoded bulk-message | [
"decodes",
"a",
"message",
"set",
"from",
"a",
"previously",
"encoded",
"bulk",
"-",
"message"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/message.go#L168-L172 |
158,191 | Shopify/sarama | consumer.go | NewConsumer | func NewConsumer(addrs []string, config *Config) (Consumer, error) {
client, err := NewClient(addrs, config)
if err != nil {
return nil, err
}
return newConsumer(client)
} | go | func NewConsumer(addrs []string, config *Config) (Consumer, error) {
client, err := NewClient(addrs, config)
if err != nil {
return nil, err
}
return newConsumer(client)
} | [
"func",
"NewConsumer",
"(",
"addrs",
"[",
"]",
"string",
",",
"config",
"*",
"Config",
")",
"(",
"Consumer",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"NewClient",
"(",
"addrs",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"re... | // NewConsumer creates a new consumer using the given broker addresses and configuration. | [
"NewConsumer",
"creates",
"a",
"new",
"consumer",
"using",
"the",
"given",
"broker",
"addresses",
"and",
"configuration",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/consumer.go#L83-L89 |
158,192 | Shopify/sarama | consumer.go | subscriptionConsumer | func (bc *brokerConsumer) subscriptionConsumer() {
<-bc.wait // wait for our first piece of work
for newSubscriptions := range bc.newSubscriptions {
bc.updateSubscriptions(newSubscriptions)
if len(bc.subscriptions) == 0 {
// We're about to be shut down or we're about to receive more subscriptions.
// Either way, the signal just hasn't propagated to our goroutine yet.
<-bc.wait
continue
}
response, err := bc.fetchNewMessages()
if err != nil {
Logger.Printf("consumer/broker/%d disconnecting due to error processing FetchRequest: %s\n", bc.broker.ID(), err)
bc.abort(err)
return
}
bc.acks.Add(len(bc.subscriptions))
for child := range bc.subscriptions {
child.feeder <- response
}
bc.acks.Wait()
bc.handleResponses()
}
} | go | func (bc *brokerConsumer) subscriptionConsumer() {
<-bc.wait // wait for our first piece of work
for newSubscriptions := range bc.newSubscriptions {
bc.updateSubscriptions(newSubscriptions)
if len(bc.subscriptions) == 0 {
// We're about to be shut down or we're about to receive more subscriptions.
// Either way, the signal just hasn't propagated to our goroutine yet.
<-bc.wait
continue
}
response, err := bc.fetchNewMessages()
if err != nil {
Logger.Printf("consumer/broker/%d disconnecting due to error processing FetchRequest: %s\n", bc.broker.ID(), err)
bc.abort(err)
return
}
bc.acks.Add(len(bc.subscriptions))
for child := range bc.subscriptions {
child.feeder <- response
}
bc.acks.Wait()
bc.handleResponses()
}
} | [
"func",
"(",
"bc",
"*",
"brokerConsumer",
")",
"subscriptionConsumer",
"(",
")",
"{",
"<-",
"bc",
".",
"wait",
"// wait for our first piece of work",
"\n\n",
"for",
"newSubscriptions",
":=",
"range",
"bc",
".",
"newSubscriptions",
"{",
"bc",
".",
"updateSubscripti... | //subscriptionConsumer ensures we will get nil right away if no new subscriptions is available | [
"subscriptionConsumer",
"ensures",
"we",
"will",
"get",
"nil",
"right",
"away",
"if",
"no",
"new",
"subscriptions",
"is",
"available"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/consumer.go#L752-L780 |
158,193 | Shopify/sarama | consumer.go | handleResponses | func (bc *brokerConsumer) handleResponses() {
for child := range bc.subscriptions {
result := child.responseResult
child.responseResult = nil
switch result {
case nil:
// no-op
case errTimedOut:
Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because consuming was taking too long\n",
bc.broker.ID(), child.topic, child.partition)
delete(bc.subscriptions, child)
case ErrOffsetOutOfRange:
// there's no point in retrying this it will just fail the same way again
// shut it down and force the user to choose what to do
child.sendError(result)
Logger.Printf("consumer/%s/%d shutting down because %s\n", child.topic, child.partition, result)
close(child.trigger)
delete(bc.subscriptions, child)
case ErrUnknownTopicOrPartition, ErrNotLeaderForPartition, ErrLeaderNotAvailable, ErrReplicaNotAvailable:
// not an error, but does need redispatching
Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because %s\n",
bc.broker.ID(), child.topic, child.partition, result)
child.trigger <- none{}
delete(bc.subscriptions, child)
default:
// dunno, tell the user and try redispatching
child.sendError(result)
Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because %s\n",
bc.broker.ID(), child.topic, child.partition, result)
child.trigger <- none{}
delete(bc.subscriptions, child)
}
}
} | go | func (bc *brokerConsumer) handleResponses() {
for child := range bc.subscriptions {
result := child.responseResult
child.responseResult = nil
switch result {
case nil:
// no-op
case errTimedOut:
Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because consuming was taking too long\n",
bc.broker.ID(), child.topic, child.partition)
delete(bc.subscriptions, child)
case ErrOffsetOutOfRange:
// there's no point in retrying this it will just fail the same way again
// shut it down and force the user to choose what to do
child.sendError(result)
Logger.Printf("consumer/%s/%d shutting down because %s\n", child.topic, child.partition, result)
close(child.trigger)
delete(bc.subscriptions, child)
case ErrUnknownTopicOrPartition, ErrNotLeaderForPartition, ErrLeaderNotAvailable, ErrReplicaNotAvailable:
// not an error, but does need redispatching
Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because %s\n",
bc.broker.ID(), child.topic, child.partition, result)
child.trigger <- none{}
delete(bc.subscriptions, child)
default:
// dunno, tell the user and try redispatching
child.sendError(result)
Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because %s\n",
bc.broker.ID(), child.topic, child.partition, result)
child.trigger <- none{}
delete(bc.subscriptions, child)
}
}
} | [
"func",
"(",
"bc",
"*",
"brokerConsumer",
")",
"handleResponses",
"(",
")",
"{",
"for",
"child",
":=",
"range",
"bc",
".",
"subscriptions",
"{",
"result",
":=",
"child",
".",
"responseResult",
"\n",
"child",
".",
"responseResult",
"=",
"nil",
"\n\n",
"swit... | //handleResponses handles the response codes left for us by our subscriptions, and abandons ones that have been closed | [
"handleResponses",
"handles",
"the",
"response",
"codes",
"left",
"for",
"us",
"by",
"our",
"subscriptions",
"and",
"abandons",
"ones",
"that",
"have",
"been",
"closed"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/consumer.go#L801-L835 |
158,194 | Shopify/sarama | partitioner.go | WithCustomHashFunction | func WithCustomHashFunction(hasher func() hash.Hash32) HashPartitionerOption {
return func(hp *hashPartitioner) {
hp.hasher = hasher()
}
} | go | func WithCustomHashFunction(hasher func() hash.Hash32) HashPartitionerOption {
return func(hp *hashPartitioner) {
hp.hasher = hasher()
}
} | [
"func",
"WithCustomHashFunction",
"(",
"hasher",
"func",
"(",
")",
"hash",
".",
"Hash32",
")",
"HashPartitionerOption",
"{",
"return",
"func",
"(",
"hp",
"*",
"hashPartitioner",
")",
"{",
"hp",
".",
"hasher",
"=",
"hasher",
"(",
")",
"\n",
"}",
"\n",
"}"... | // WithCustomHashFunction lets you specify what hash function to use for the partitioning | [
"WithCustomHashFunction",
"lets",
"you",
"specify",
"what",
"hash",
"function",
"to",
"use",
"for",
"the",
"partitioning"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/partitioner.go#L57-L61 |
158,195 | Shopify/sarama | partitioner.go | NewRandomPartitioner | func NewRandomPartitioner(topic string) Partitioner {
p := new(randomPartitioner)
p.generator = rand.New(rand.NewSource(time.Now().UTC().UnixNano()))
return p
} | go | func NewRandomPartitioner(topic string) Partitioner {
p := new(randomPartitioner)
p.generator = rand.New(rand.NewSource(time.Now().UTC().UnixNano()))
return p
} | [
"func",
"NewRandomPartitioner",
"(",
"topic",
"string",
")",
"Partitioner",
"{",
"p",
":=",
"new",
"(",
"randomPartitioner",
")",
"\n",
"p",
".",
"generator",
"=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".... | // NewRandomPartitioner returns a Partitioner which chooses a random partition each time. | [
"NewRandomPartitioner",
"returns",
"a",
"Partitioner",
"which",
"chooses",
"a",
"random",
"partition",
"each",
"time",
"."
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/partitioner.go#L89-L93 |
158,196 | Shopify/sarama | partitioner.go | NewCustomHashPartitioner | func NewCustomHashPartitioner(hasher func() hash.Hash32) PartitionerConstructor {
return func(topic string) Partitioner {
p := new(hashPartitioner)
p.random = NewRandomPartitioner(topic)
p.hasher = hasher()
p.referenceAbs = false
return p
}
} | go | func NewCustomHashPartitioner(hasher func() hash.Hash32) PartitionerConstructor {
return func(topic string) Partitioner {
p := new(hashPartitioner)
p.random = NewRandomPartitioner(topic)
p.hasher = hasher()
p.referenceAbs = false
return p
}
} | [
"func",
"NewCustomHashPartitioner",
"(",
"hasher",
"func",
"(",
")",
"hash",
".",
"Hash32",
")",
"PartitionerConstructor",
"{",
"return",
"func",
"(",
"topic",
"string",
")",
"Partitioner",
"{",
"p",
":=",
"new",
"(",
"hashPartitioner",
")",
"\n",
"p",
".",
... | // NewCustomHashPartitioner is a wrapper around NewHashPartitioner, allowing the use of custom hasher.
// The argument is a function providing the instance, implementing the hash.Hash32 interface. This is to ensure that
// each partition dispatcher gets its own hasher, to avoid concurrency issues by sharing an instance. | [
"NewCustomHashPartitioner",
"is",
"a",
"wrapper",
"around",
"NewHashPartitioner",
"allowing",
"the",
"use",
"of",
"custom",
"hasher",
".",
"The",
"argument",
"is",
"a",
"function",
"providing",
"the",
"instance",
"implementing",
"the",
"hash",
".",
"Hash32",
"inte... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/partitioner.go#L134-L142 |
158,197 | Shopify/sarama | partitioner.go | NewCustomPartitioner | func NewCustomPartitioner(options ...HashPartitionerOption) PartitionerConstructor {
return func(topic string) Partitioner {
p := new(hashPartitioner)
p.random = NewRandomPartitioner(topic)
p.hasher = fnv.New32a()
p.referenceAbs = false
for _, option := range options {
option(p)
}
return p
}
} | go | func NewCustomPartitioner(options ...HashPartitionerOption) PartitionerConstructor {
return func(topic string) Partitioner {
p := new(hashPartitioner)
p.random = NewRandomPartitioner(topic)
p.hasher = fnv.New32a()
p.referenceAbs = false
for _, option := range options {
option(p)
}
return p
}
} | [
"func",
"NewCustomPartitioner",
"(",
"options",
"...",
"HashPartitionerOption",
")",
"PartitionerConstructor",
"{",
"return",
"func",
"(",
"topic",
"string",
")",
"Partitioner",
"{",
"p",
":=",
"new",
"(",
"hashPartitioner",
")",
"\n",
"p",
".",
"random",
"=",
... | // NewCustomPartitioner creates a default Partitioner but lets you specify the behavior of each component via options | [
"NewCustomPartitioner",
"creates",
"a",
"default",
"Partitioner",
"but",
"lets",
"you",
"specify",
"the",
"behavior",
"of",
"each",
"component",
"via",
"options"
] | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/partitioner.go#L145-L156 |
158,198 | Shopify/sarama | partitioner.go | NewHashPartitioner | func NewHashPartitioner(topic string) Partitioner {
p := new(hashPartitioner)
p.random = NewRandomPartitioner(topic)
p.hasher = fnv.New32a()
p.referenceAbs = false
return p
} | go | func NewHashPartitioner(topic string) Partitioner {
p := new(hashPartitioner)
p.random = NewRandomPartitioner(topic)
p.hasher = fnv.New32a()
p.referenceAbs = false
return p
} | [
"func",
"NewHashPartitioner",
"(",
"topic",
"string",
")",
"Partitioner",
"{",
"p",
":=",
"new",
"(",
"hashPartitioner",
")",
"\n",
"p",
".",
"random",
"=",
"NewRandomPartitioner",
"(",
"topic",
")",
"\n",
"p",
".",
"hasher",
"=",
"fnv",
".",
"New32a",
"... | // NewHashPartitioner returns a Partitioner which behaves as follows. If the message's key is nil then a
// random partition is chosen. Otherwise the FNV-1a hash of the encoded bytes of the message key is used,
// modulus the number of partitions. This ensures that messages with the same key always end up on the
// same partition. | [
"NewHashPartitioner",
"returns",
"a",
"Partitioner",
"which",
"behaves",
"as",
"follows",
".",
"If",
"the",
"message",
"s",
"key",
"is",
"nil",
"then",
"a",
"random",
"partition",
"is",
"chosen",
".",
"Otherwise",
"the",
"FNV",
"-",
"1a",
"hash",
"of",
"th... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/partitioner.go#L162-L168 |
158,199 | Shopify/sarama | partitioner.go | NewReferenceHashPartitioner | func NewReferenceHashPartitioner(topic string) Partitioner {
p := new(hashPartitioner)
p.random = NewRandomPartitioner(topic)
p.hasher = fnv.New32a()
p.referenceAbs = true
return p
} | go | func NewReferenceHashPartitioner(topic string) Partitioner {
p := new(hashPartitioner)
p.random = NewRandomPartitioner(topic)
p.hasher = fnv.New32a()
p.referenceAbs = true
return p
} | [
"func",
"NewReferenceHashPartitioner",
"(",
"topic",
"string",
")",
"Partitioner",
"{",
"p",
":=",
"new",
"(",
"hashPartitioner",
")",
"\n",
"p",
".",
"random",
"=",
"NewRandomPartitioner",
"(",
"topic",
")",
"\n",
"p",
".",
"hasher",
"=",
"fnv",
".",
"New... | // NewReferenceHashPartitioner is like NewHashPartitioner except that it handles absolute values
// in the same way as the reference Java implementation. NewHashPartitioner was supposed to do
// that but it had a mistake and now there are people depending on both behaviours. This will
// all go away on the next major version bump. | [
"NewReferenceHashPartitioner",
"is",
"like",
"NewHashPartitioner",
"except",
"that",
"it",
"handles",
"absolute",
"values",
"in",
"the",
"same",
"way",
"as",
"the",
"reference",
"Java",
"implementation",
".",
"NewHashPartitioner",
"was",
"supposed",
"to",
"do",
"tha... | ea9ab1c316850bee881a07bb2555ee8a685cd4b6 | https://github.com/Shopify/sarama/blob/ea9ab1c316850bee881a07bb2555ee8a685cd4b6/partitioner.go#L174-L180 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.