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
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 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",
"{",
"BaseQueryBuilder",
"{",
"head",
":",
"\"",
"\"",
"+",
"sqlescape",
".",
"EscapeID",
"(",
"dbName",
")",
"+",
"\"",
"\"",
"+",
"sqlescape",
".",
"EscapeID",
"(",
"td",
".",
"Name",
")",
"+",
"\"",
"\"",
"+",
"strings",
".",
"Join",
"(",
"escapeAll",
"(",
"td",
".",
"Columns",
")",
",",
"\"",
"\"",
")",
"+",
"\"",
"\"",
",",
"separator",
":",
"\"",
"\"",
",",
"}",
",",
"}",
"\n",
"}"
] | // 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 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",
":",
"\"",
"\"",
"+",
"sqlescape",
".",
"EscapeID",
"(",
"dbName",
")",
"+",
"\"",
"\"",
"+",
"sqlescape",
".",
"EscapeID",
"(",
"td",
".",
"Name",
")",
"+",
"\"",
"\"",
",",
"}",
",",
"td",
":",
"td",
",",
"// Build list of non-primary key columns (required for update statements).",
"nonPrimaryKeyColumns",
":",
"orderedColumnsWithoutPrimaryKeyColumns",
"(",
"td",
")",
",",
"}",
"\n",
"}"
] | // 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 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",
":",
"\"",
"\"",
"+",
"sqlescape",
".",
"EscapeID",
"(",
"dbName",
")",
"+",
"\"",
"\"",
"+",
"sqlescape",
".",
"EscapeID",
"(",
"td",
".",
"Name",
")",
"+",
"\"",
"\"",
",",
"separator",
":",
"\"",
"\"",
",",
"}",
",",
"td",
":",
"td",
",",
"}",
"\n",
"}"
] | // 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",
",",
"tabletType",
"topodatapb",
".",
"TabletType",
")",
"(",
"*",
"topodatapb",
".",
"TabletAlias",
",",
"error",
")",
"{",
"if",
"tsc",
"==",
"nil",
"{",
"// No healthcheck instance provided. Create one.",
"healthCheck",
":=",
"discovery",
".",
"NewHealthCheck",
"(",
"*",
"healthcheckRetryDelay",
",",
"*",
"healthCheckTimeout",
")",
"\n",
"tsc",
"=",
"discovery",
".",
"NewTabletStatsCache",
"(",
"healthCheck",
",",
"wr",
".",
"TopoServer",
"(",
")",
",",
"cell",
")",
"\n",
"watcher",
":=",
"discovery",
".",
"NewShardReplicationWatcher",
"(",
"ctx",
",",
"wr",
".",
"TopoServer",
"(",
")",
",",
"healthCheck",
",",
"cell",
",",
"keyspace",
",",
"shard",
",",
"*",
"healthCheckTopologyRefresh",
",",
"discovery",
".",
"DefaultTopoReadConcurrency",
")",
"\n",
"defer",
"watcher",
".",
"Stop",
"(",
")",
"\n",
"defer",
"healthCheck",
".",
"Close",
"(",
")",
"\n",
"}",
"\n\n",
"healthyTablets",
",",
"err",
":=",
"waitForHealthyTablets",
"(",
"ctx",
",",
"wr",
",",
"tsc",
",",
"cell",
",",
"keyspace",
",",
"shard",
",",
"minHealthyRdonlyTablets",
",",
"*",
"waitForHealthyTabletsTimeout",
",",
"tabletType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// random server in the list is what we want",
"index",
":=",
"rand",
".",
"Intn",
"(",
"len",
"(",
"healthyTablets",
")",
")",
"\n",
"return",
"healthyTablets",
"[",
"index",
"]",
".",
"Tablet",
".",
"Alias",
",",
"nil",
"\n",
"}"
] | // 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",
"block",
"up",
"to",
"-",
"wait_for_healthy_rdonly_tablets_timeout",
"."
] | 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",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"agent",
".",
"unlock",
"(",
")",
"\n\n",
"if",
"agent",
".",
"Cnf",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// 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",
"(",
")",
"\n",
"if",
"!",
"allowMaster",
"&&",
"currentTablet",
".",
"Type",
"==",
"topodatapb",
".",
"TabletType_MASTER",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tablet",
",",
"err",
":=",
"agent",
".",
"TopoServer",
".",
"GetTablet",
"(",
"ctx",
",",
"agent",
".",
"TabletAlias",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"allowMaster",
"&&",
"tablet",
".",
"Type",
"==",
"topodatapb",
".",
"TabletType_MASTER",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"originalType",
":=",
"tablet",
".",
"Type",
"\n\n",
"engine",
",",
"err",
":=",
"mysqlctl",
".",
"GetBackupEngine",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"vterrors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"builtin",
",",
"_",
":=",
"engine",
".",
"(",
"*",
"mysqlctl",
".",
"BuiltinBackupEngine",
")",
"\n",
"if",
"builtin",
"!=",
"nil",
"{",
"// update our type to BACKUP",
"if",
"_",
",",
"err",
":=",
"topotools",
".",
"ChangeType",
"(",
"ctx",
",",
"agent",
".",
"TopoServer",
",",
"tablet",
".",
"Alias",
",",
"topodatapb",
".",
"TabletType_BACKUP",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// let's update our internal state (stop query service and other things)",
"if",
"err",
":=",
"agent",
".",
"refreshTablet",
"(",
"ctx",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"// create the loggers: tee to console and source",
"l",
":=",
"logutil",
".",
"NewTeeLogger",
"(",
"logutil",
".",
"NewConsoleLogger",
"(",
")",
",",
"logger",
")",
"\n\n",
"// now we can run the backup",
"dir",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tablet",
".",
"Keyspace",
",",
"tablet",
".",
"Shard",
")",
"\n",
"name",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Format",
"(",
"\"",
"\"",
")",
",",
"topoproto",
".",
"TabletAliasString",
"(",
"tablet",
".",
"Alias",
")",
")",
"\n",
"returnErr",
":=",
"mysqlctl",
".",
"Backup",
"(",
"ctx",
",",
"agent",
".",
"Cnf",
",",
"agent",
".",
"MysqlDaemon",
",",
"l",
",",
"dir",
",",
"name",
",",
"concurrency",
",",
"agent",
".",
"hookExtraEnv",
"(",
")",
")",
"\n\n",
"if",
"builtin",
"!=",
"nil",
"{",
"bgCtx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"// 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",
")",
"\n",
"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",
"(",
"\"",
"\"",
",",
"returnErr",
")",
"\n",
"}",
"\n",
"returnErr",
"=",
"err",
"\n",
"}",
"\n\n",
"// let's update our internal state (start query service and other things)",
"if",
"err",
":=",
"agent",
".",
"refreshTablet",
"(",
"bgCtx",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"// and re-run health check to be sure to capture any replication delay",
"agent",
".",
"runHealthCheckLocked",
"(",
")",
"\n\n",
"return",
"returnErr",
"\n",
"}"
] | // 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",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"agent",
".",
"unlock",
"(",
")",
"\n\n",
"tablet",
",",
"err",
":=",
"agent",
".",
"TopoServer",
".",
"GetTablet",
"(",
"ctx",
",",
"agent",
".",
"TabletAlias",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"tablet",
".",
"Type",
"==",
"topodatapb",
".",
"TabletType_MASTER",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// create the loggers: tee to console and source",
"l",
":=",
"logutil",
".",
"NewTeeLogger",
"(",
"logutil",
".",
"NewConsoleLogger",
"(",
")",
",",
"logger",
")",
"\n\n",
"// now we can run restore",
"err",
"=",
"agent",
".",
"restoreDataLocked",
"(",
"ctx",
",",
"l",
",",
"true",
"/* deleteBeforeRestore */",
")",
"\n\n",
"// re-run health check to be sure to capture any replication delay",
"agent",
".",
"runHealthCheckLocked",
"(",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] | // 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",
",",
"allowBigSchemaChange",
":",
"false",
",",
"waitSlaveTimeout",
":",
"waitSlaveTimeout",
",",
"}",
"\n",
"}"
] | // 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",
"=",
"keyspace",
"\n",
"shardNames",
",",
"err",
":=",
"exec",
".",
"wr",
".",
"TopoServer",
"(",
")",
".",
"GetShardNames",
"(",
"ctx",
",",
"keyspace",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"keyspace",
",",
"err",
")",
"\n",
"}",
"\n",
"exec",
".",
"tablets",
"=",
"make",
"(",
"[",
"]",
"*",
"topodatapb",
".",
"Tablet",
",",
"len",
"(",
"shardNames",
")",
")",
"\n",
"for",
"i",
",",
"shardName",
":=",
"range",
"shardNames",
"{",
"shardInfo",
",",
"err",
":=",
"exec",
".",
"wr",
".",
"TopoServer",
"(",
")",
".",
"GetShard",
"(",
"ctx",
",",
"keyspace",
",",
"shardName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"keyspace",
",",
"shardName",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"shardInfo",
".",
"HasMaster",
"(",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"shardName",
")",
"\n",
"}",
"\n",
"tabletInfo",
",",
"err",
":=",
"exec",
".",
"wr",
".",
"TopoServer",
"(",
")",
".",
"GetTablet",
"(",
"ctx",
",",
"shardInfo",
".",
"MasterAlias",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"keyspace",
",",
"shardName",
",",
"err",
")",
"\n",
"}",
"\n",
"exec",
".",
"tablets",
"[",
"i",
"]",
"=",
"tabletInfo",
".",
"Tablet",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"exec",
".",
"tablets",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"keyspace",
")",
"\n",
"}",
"\n",
"exec",
".",
"isClosed",
"=",
"false",
"\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"}",
"\n\n",
"parsedDDLs",
",",
"err",
":=",
"exec",
".",
"parseDDLs",
"(",
"sqls",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"bigSchemaChange",
",",
"err",
":=",
"exec",
".",
"detectBigSchemaChanges",
"(",
"ctx",
",",
"parsedDDLs",
")",
"\n",
"if",
"bigSchemaChange",
"&&",
"exec",
".",
"allowBigSchemaChange",
"{",
"exec",
".",
"wr",
".",
"Logger",
"(",
")",
".",
"Warningf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\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",
"\n",
"if",
"exec",
".",
"isClosed",
"{",
"execResult",
".",
"ExecutorErr",
"=",
"\"",
"\"",
"\n",
"return",
"&",
"execResult",
"\n",
"}",
"\n",
"startTime",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"execResult",
".",
"TotalTimeSpent",
"=",
"time",
".",
"Since",
"(",
"startTime",
")",
"}",
"(",
")",
"\n\n",
"// 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",
",",
"\"",
"\"",
")",
"\n",
"if",
"lockErr",
"!=",
"nil",
"{",
"execResult",
".",
"ExecutorErr",
"=",
"lockErr",
".",
"Error",
"(",
")",
"\n",
"return",
"&",
"execResult",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"// This is complicated because execResult.ExecutorErr",
"// is not of type error.",
"var",
"unlockErr",
"error",
"\n",
"unlock",
"(",
"&",
"unlockErr",
")",
"\n",
"if",
"execResult",
".",
"ExecutorErr",
"==",
"\"",
"\"",
"&&",
"unlockErr",
"!=",
"nil",
"{",
"execResult",
".",
"ExecutorErr",
"=",
"unlockErr",
".",
"Error",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"// Make sure the schema changes introduce a table definition change.",
"if",
"err",
":=",
"exec",
".",
"preflightSchemaChanges",
"(",
"ctx",
",",
"sqls",
")",
";",
"err",
"!=",
"nil",
"{",
"execResult",
".",
"ExecutorErr",
"=",
"err",
".",
"Error",
"(",
")",
"\n",
"return",
"&",
"execResult",
"\n",
"}",
"\n\n",
"for",
"index",
",",
"sql",
":=",
"range",
"sqls",
"{",
"execResult",
".",
"CurSQLIndex",
"=",
"index",
"\n",
"exec",
".",
"executeOnAllTablets",
"(",
"ctx",
",",
"&",
"execResult",
",",
"sql",
")",
"\n",
"if",
"len",
"(",
"execResult",
".",
"FailedShards",
")",
">",
"0",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"execResult",
"\n",
"}"
] | // 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",
"=",
"dbconnpool",
".",
"NewConnectionPool",
"(",
"\"",
"\"",
",",
"*",
"dbaPoolSize",
",",
"*",
"dbaIdleTimeout",
",",
"*",
"poolDynamicHostnameResolution",
")",
"\n",
"result",
".",
"dbaPool",
".",
"Open",
"(",
"dbcfgs",
".",
"Dba",
"(",
")",
",",
"dbaMysqlStats",
")",
"\n\n",
"// Create and open the connection pool for app access.",
"result",
".",
"appPool",
"=",
"dbconnpool",
".",
"NewConnectionPool",
"(",
"\"",
"\"",
",",
"*",
"appPoolSize",
",",
"*",
"appIdleTimeout",
",",
"*",
"poolDynamicHostnameResolution",
")",
"\n",
"result",
".",
"appPool",
".",
"Open",
"(",
"dbcfgs",
".",
"AppWithDB",
"(",
")",
",",
"appMysqlStats",
")",
"\n\n",
"return",
"result",
"\n",
"}"
] | // 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",
")",
"\n",
"client",
",",
"err",
":=",
"mysqlctlclient",
".",
"New",
"(",
"\"",
"\"",
",",
"*",
"socketFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"client",
".",
"Close",
"(",
")",
"\n",
"return",
"client",
".",
"RunMysqlUpgrade",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Find mysql_upgrade. If not there, we do nothing.",
"dir",
",",
"err",
":=",
"vtenv",
".",
"VtMysqlRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"name",
",",
"err",
":=",
"binaryPath",
"(",
"dir",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// 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",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defaultsFile",
",",
"err",
":=",
"mysqld",
".",
"defaultsExtraFile",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"os",
".",
"Remove",
"(",
"defaultsFile",
")",
"\n\n",
"// 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.",
"\"",
"\"",
"+",
"defaultsFile",
",",
"\"",
"\"",
",",
"// Don't complain if it's already been upgraded.",
"}",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"name",
",",
"args",
"...",
")",
"\n",
"cmd",
".",
"Env",
"=",
"[",
"]",
"string",
"{",
"os",
".",
"ExpandEnv",
"(",
"\"",
"\"",
")",
"}",
"\n",
"out",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"out",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // 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",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"*",
"socketFile",
")",
"\n",
"client",
",",
"err",
":=",
"mysqlctlclient",
".",
"New",
"(",
"\"",
"\"",
",",
"*",
"socketFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"client",
".",
"Close",
"(",
")",
"\n",
"return",
"client",
".",
"Start",
"(",
"ctx",
",",
"mysqldArgs",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"mysqld",
".",
"startNoWait",
"(",
"ctx",
",",
"cnf",
",",
"mysqldArgs",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"mysqld",
".",
"Wait",
"(",
"ctx",
",",
"cnf",
")",
"\n",
"}"
] | // 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",
"will",
"run",
"remotely",
".",
"When",
"waiting",
"for",
"mysqld",
"to",
"start",
"we",
"will",
"use",
"the",
"dba",
"user",
"."
] | 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",
"(",
"\"",
"\"",
",",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
")",
"\n\n",
"// try the mysqld start hook, if any",
"switch",
"hr",
":=",
"hook",
".",
"NewHook",
"(",
"\"",
"\"",
",",
"mysqldArgs",
")",
".",
"Execute",
"(",
")",
";",
"hr",
".",
"ExitStatus",
"{",
"case",
"hook",
".",
"HOOK_SUCCESS",
":",
"// hook exists and worked, we can keep going",
"name",
"=",
"\"",
"\"",
"\n",
"case",
"hook",
".",
"HOOK_DOES_NOT_EXIST",
":",
"// hook doesn't exist, run mysqld_safe ourselves",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"ts",
")",
"\n",
"dir",
",",
"err",
":=",
"vtenv",
".",
"VtMysqlRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"name",
",",
"err",
"=",
"binaryPath",
"(",
"dir",
",",
"\"",
"\"",
")",
"\n",
"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",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"name",
",",
"err",
"=",
"binaryPath",
"(",
"dir",
",",
"\"",
"\"",
")",
"\n",
"// If this also fails, return an error.",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"arg",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"+",
"cnf",
".",
"path",
"}",
"\n",
"arg",
"=",
"append",
"(",
"arg",
",",
"mysqldArgs",
"...",
")",
"\n",
"env",
":=",
"[",
"]",
"string",
"{",
"os",
".",
"ExpandEnv",
"(",
"\"",
"\"",
")",
"}",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"name",
",",
"arg",
"...",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"dir",
"\n",
"cmd",
".",
"Env",
"=",
"env",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"ts",
",",
"cmd",
")",
"\n",
"stderr",
",",
"err",
":=",
"cmd",
".",
"StderrPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"stdout",
",",
"err",
":=",
"cmd",
".",
"StdoutPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"stderr",
")",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"ts",
",",
"scanner",
".",
"Text",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"stdout",
")",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"ts",
",",
"scanner",
".",
"Text",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"err",
"=",
"cmd",
".",
"Start",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"mysqld",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"mysqld",
".",
"cancelWaitCmd",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"go",
"func",
"(",
"cancel",
"<-",
"chan",
"struct",
"{",
"}",
")",
"{",
"// Wait regardless of cancel, so we don't generate defunct processes.",
"err",
":=",
"cmd",
".",
"Wait",
"(",
")",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"ts",
",",
"err",
")",
"\n\n",
"// The process exited. Trigger OnTerm callbacks, unless we were cancelled.",
"select",
"{",
"case",
"<-",
"cancel",
":",
"default",
":",
"mysqld",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"for",
"_",
",",
"callback",
":=",
"range",
"mysqld",
".",
"onTermFuncs",
"{",
"go",
"callback",
"(",
")",
"\n",
"}",
"\n",
"mysqld",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
"mysqld",
".",
"cancelWaitCmd",
")",
"\n",
"mysqld",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"default",
":",
"// hook failed, we report error",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"hr",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"SocketFile",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"cnf",
".",
"SocketFile",
")",
"\n",
"default",
":",
"}",
"\n\n",
"_",
",",
"statErr",
":=",
"os",
".",
"Stat",
"(",
"cnf",
".",
"SocketFile",
")",
"\n",
"if",
"statErr",
"==",
"nil",
"{",
"// Make sure the socket file isn't stale.",
"conn",
",",
"connErr",
":=",
"mysql",
".",
"Connect",
"(",
"ctx",
",",
"params",
")",
"\n",
"if",
"connErr",
"==",
"nil",
"{",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"connErr",
")",
"\n",
"}",
"else",
"if",
"!",
"os",
".",
"IsNotExist",
"(",
"statErr",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"statErr",
")",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"1000",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
")",
"{",
"cmdPath",
",",
"_",
":=",
"exec",
".",
"LookPath",
"(",
"name",
")",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"name",
",",
"cmdPath",
",",
"args",
")",
"\n\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"cmdPath",
",",
"args",
"...",
")",
"\n",
"cmd",
".",
"Env",
"=",
"env",
"\n",
"cmd",
".",
"Dir",
"=",
"dir",
"\n",
"if",
"input",
"!=",
"nil",
"{",
"cmd",
".",
"Stdin",
"=",
"input",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
"\n",
"output",
"=",
"string",
"(",
"out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"name",
",",
"err",
")",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"err",
",",
"output",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"name",
",",
"output",
")",
"\n",
"return",
"cmd",
",",
"output",
",",
"err",
"\n",
"}"
] | // 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",
"subdirs",
"{",
"binPath",
":=",
"path",
".",
"Join",
"(",
"root",
",",
"subdir",
",",
"binary",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"binPath",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"binPath",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"binary",
",",
"root",
",",
"strings",
".",
"Join",
"(",
"subdirs",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] | // 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",
".",
"Infof",
"(",
"\"",
"\"",
",",
"*",
"socketFile",
")",
"\n",
"client",
",",
"err",
":=",
"mysqlctlclient",
".",
"New",
"(",
"\"",
"\"",
",",
"*",
"socketFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"client",
".",
"Close",
"(",
")",
"\n",
"return",
"client",
".",
"RefreshConfig",
"(",
"ctx",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"root",
",",
"err",
":=",
"vtenv",
".",
"VtRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"f",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"path",
".",
"Dir",
"(",
"cnf",
".",
"path",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"defer",
"os",
".",
"Remove",
"(",
"f",
".",
"Name",
"(",
")",
")",
"\n",
"err",
"=",
"mysqld",
".",
"initConfig",
"(",
"root",
",",
"cnf",
",",
"f",
".",
"Name",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
".",
"Name",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"existing",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"cnf",
".",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cnf",
".",
"path",
",",
"err",
")",
"\n",
"}",
"\n",
"updated",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"f",
".",
"Name",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
".",
"Name",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"bytes",
".",
"Equal",
"(",
"existing",
",",
"updated",
")",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"backupPath",
":=",
"cnf",
".",
"path",
"+",
"\"",
"\"",
"\n",
"err",
"=",
"os",
".",
"Rename",
"(",
"cnf",
".",
"path",
",",
"backupPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cnf",
".",
"path",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"Rename",
"(",
"f",
".",
"Name",
"(",
")",
",",
"cnf",
".",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
".",
"Name",
"(",
")",
",",
"cnf",
".",
"path",
",",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"backupPath",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"fallback",
"is",
"required",
".",
"Should",
"be",
"called",
"from",
"a",
"stable",
"replica",
"server_id",
"is",
"not",
"regenerated",
"."
] | 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",
"*",
"socketFile",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"*",
"socketFile",
")",
"\n",
"client",
",",
"err",
":=",
"mysqlctlclient",
".",
"New",
"(",
"\"",
"\"",
",",
"*",
"socketFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"client",
".",
"Close",
"(",
")",
"\n",
"return",
"client",
".",
"ReinitConfig",
"(",
"ctx",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"cnf",
".",
"RandomizeMysqlServerID",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"root",
",",
"err",
":=",
"vtenv",
".",
"VtRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"mysqld",
".",
"initConfig",
"(",
"root",
",",
"cnf",
",",
"cnf",
".",
"path",
")",
"\n",
"}"
] | // 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",
"and",
"then",
"give",
"it",
"the",
"same",
"ServerID",
"as",
"before",
"MySQL",
"can",
"then",
"skip",
"transactions",
"in",
"the",
"replication",
"stream",
"with",
"the",
"same",
"server_id",
"."
] | 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",
".",
"Shutdown",
"(",
"ctx",
",",
"cnf",
",",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"if",
"!",
"force",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"removalErr",
"error",
"\n",
"for",
"_",
",",
"dir",
":=",
"range",
"TopLevelDirs",
"(",
")",
"{",
"qdir",
":=",
"path",
".",
"Join",
"(",
"cnf",
".",
"TabletDir",
"(",
")",
",",
"dir",
")",
"\n",
"if",
"err",
":=",
"deleteTopDir",
"(",
"qdir",
")",
";",
"err",
"!=",
"nil",
"{",
"removalErr",
"=",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"removalErr",
"\n",
"}"
] | // 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",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"name",
",",
"err",
":=",
"binaryPath",
"(",
"dir",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"cnf",
",",
"err",
":=",
"mysqld",
".",
"defaultsExtraFile",
"(",
"connParams",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"os",
".",
"Remove",
"(",
"cnf",
")",
"\n",
"args",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"+",
"cnf",
",",
"\"",
"\"",
",",
"}",
"\n",
"env",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"+",
"path",
".",
"Join",
"(",
"dir",
",",
"\"",
"\"",
")",
",",
"}",
"\n",
"_",
",",
"_",
",",
"err",
"=",
"execCmd",
"(",
"name",
",",
"args",
",",
"env",
",",
"dir",
",",
"sql",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // 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",
"(",
")",
",",
"dbaMysqlStats",
")",
"\n",
"}"
] | // 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",
"(",
")",
",",
"allprivsMysqlStats",
")",
"\n",
"}"
] | // 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",
".",
"appPool",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
".",
"Exec",
"(",
"query",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"sqltypes",
".",
"ResultToProto3",
"(",
"qr",
")",
",",
"nil",
"\n",
"}"
] | // 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",
",",
"pos",
")",
"\n",
"}"
] | // 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",
".",
"Lock",
".",
"Unlock",
"(",
")",
"\n\n",
"keyspaces",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"1",
")",
"\n",
"for",
"k",
":=",
"range",
"et",
".",
"Keyspaces",
"{",
"keyspaces",
"=",
"append",
"(",
"keyspaces",
",",
"k",
")",
"\n",
"}",
"\n",
"return",
"keyspaces",
",",
"nil",
"\n",
"}"
] | // 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",
"(",
")",
"\n",
"defer",
"et",
".",
"Lock",
".",
"Unlock",
"(",
")",
"\n\n",
"vschema",
":=",
"et",
".",
"Keyspaces",
"[",
"keyspace",
"]",
"\n",
"if",
"vschema",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"keyspace",
")",
"\n",
"}",
"\n\n",
"var",
"srvKeyspace",
"*",
"topodatapb",
".",
"SrvKeyspace",
"\n",
"if",
"vschema",
".",
"Sharded",
"{",
"shards",
":=",
"make",
"(",
"[",
"]",
"*",
"topodatapb",
".",
"ShardReference",
",",
"0",
",",
"et",
".",
"NumShards",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"et",
".",
"NumShards",
";",
"i",
"++",
"{",
"kr",
",",
"err",
":=",
"key",
".",
"EvenShardsKeyRange",
"(",
"i",
",",
"et",
".",
"NumShards",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"shard",
":=",
"&",
"topodatapb",
".",
"ShardReference",
"{",
"Name",
":",
"key",
".",
"KeyRangeString",
"(",
"kr",
")",
",",
"KeyRange",
":",
"kr",
",",
"}",
"\n",
"shards",
"=",
"append",
"(",
"shards",
",",
"shard",
")",
"\n",
"}",
"\n\n",
"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",
",",
"}",
",",
"}",
",",
"}",
"\n\n",
"}",
"else",
"{",
"// unsharded",
"kr",
",",
"err",
":=",
"key",
".",
"EvenShardsKeyRange",
"(",
"0",
",",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"shard",
":=",
"&",
"topodatapb",
".",
"ShardReference",
"{",
"Name",
":",
"key",
".",
"KeyRangeString",
"(",
"kr",
")",
",",
"}",
"\n\n",
"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",
"}",
",",
"}",
",",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"srvKeyspace",
",",
"nil",
"\n",
"}"
] | // 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",
".",
"Return",
".",
"Successes",
"=",
"true",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"verifyProducerConfig",
"(",
"config",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"p",
",",
"err",
":=",
"NewAsyncProducer",
"(",
"addrs",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"newSyncProducerFromAsyncProducer",
"(",
"p",
".",
"(",
"*",
"asyncProducer",
")",
")",
",",
"nil",
"\n",
"}"
] | // 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",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"conf",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"addrs",
")",
"<",
"1",
"{",
"return",
"nil",
",",
"ConfigurationError",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"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",
")",
",",
"}",
"\n\n",
"random",
":=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
"\n",
"for",
"_",
",",
"index",
":=",
"range",
"random",
".",
"Perm",
"(",
"len",
"(",
"addrs",
")",
")",
"{",
"client",
".",
"seedBrokers",
"=",
"append",
"(",
"client",
".",
"seedBrokers",
",",
"NewBroker",
"(",
"addrs",
"[",
"index",
"]",
")",
")",
"\n",
"}",
"\n\n",
"if",
"conf",
".",
"Metadata",
".",
"Full",
"{",
"// do an initial fetch of all cluster metadata by specifying an empty list of topics",
"err",
":=",
"client",
".",
"RefreshMetadata",
"(",
")",
"\n",
"switch",
"err",
"{",
"case",
"nil",
":",
"break",
"\n",
"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",
")",
"\n",
"default",
":",
"close",
"(",
"client",
".",
"closed",
")",
"// we haven't started the background updater yet, so we have to do this manually",
"\n",
"_",
"=",
"client",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"go",
"withRecover",
"(",
"client",
".",
"backgroundMetadataUpdater",
")",
"\n\n",
"Logger",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"client",
",",
"nil",
"\n",
"}"
] | // 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",
".",
"If",
"metadata",
"cannot",
"be",
"retrieved",
"from",
"any",
"of",
"the",
"given",
"broker",
"addresses",
"the",
"client",
"is",
"not",
"created",
"."
] | 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",
"(",
")",
"]",
"=",
"broker",
"\n",
"Logger",
".",
"Printf",
"(",
"\"",
"\"",
",",
"broker",
".",
"ID",
"(",
")",
",",
"broker",
".",
"Addr",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"broker",
".",
"Addr",
"(",
")",
"!=",
"client",
".",
"brokers",
"[",
"broker",
".",
"ID",
"(",
")",
"]",
".",
"Addr",
"(",
")",
"{",
"safeAsyncClose",
"(",
"client",
".",
"brokers",
"[",
"broker",
".",
"ID",
"(",
")",
"]",
")",
"\n",
"client",
".",
"brokers",
"[",
"broker",
".",
"ID",
"(",
")",
"]",
"=",
"broker",
"\n",
"Logger",
".",
"Printf",
"(",
"\"",
"\"",
",",
"broker",
".",
"ID",
"(",
")",
",",
"broker",
".",
"Addr",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
"is",
"registered",
"which",
"may",
"be",
"the",
"provided",
"broker",
"or",
"a",
"previously",
"registered",
"Broker",
"instance",
".",
"You",
"must",
"hold",
"the",
"write",
"lock",
"before",
"calling",
"this",
"function",
"."
] | 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",
".",
"seedBrokers",
")",
">",
"0",
"&&",
"broker",
"==",
"client",
".",
"seedBrokers",
"[",
"0",
"]",
"{",
"client",
".",
"deadSeeds",
"=",
"append",
"(",
"client",
".",
"deadSeeds",
",",
"broker",
")",
"\n",
"client",
".",
"seedBrokers",
"=",
"client",
".",
"seedBrokers",
"[",
"1",
":",
"]",
"\n",
"}",
"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",
"(",
"\"",
"\"",
",",
"broker",
".",
"ID",
"(",
")",
",",
"broker",
".",
"Addr",
"(",
")",
")",
"\n",
"delete",
"(",
"client",
".",
"brokers",
",",
"broker",
".",
"ID",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
"(",
"0",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"client",
".",
"conf",
".",
"Metadata",
".",
"RefreshFrequency",
")",
"\n",
"defer",
"ticker",
".",
"Stop",
"(",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ticker",
".",
"C",
":",
"if",
"err",
":=",
"client",
".",
"refreshMetadata",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"Logger",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"case",
"<-",
"client",
".",
"closer",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // 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",
"client",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"// 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",
")",
"\n",
"}",
"\n\n",
"client",
".",
"controllerID",
"=",
"data",
".",
"ControllerID",
"\n\n",
"if",
"allKnownMetaData",
"{",
"client",
".",
"metadata",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"int32",
"]",
"*",
"PartitionMetadata",
")",
"\n",
"client",
".",
"metadataTopics",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"none",
")",
"\n",
"client",
".",
"cachedPartitionsResults",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"maxPartitionIndex",
"]",
"[",
"]",
"int32",
")",
"\n",
"}",
"\n",
"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",
"{",
"}",
"\n",
"}",
"\n",
"delete",
"(",
"client",
".",
"metadata",
",",
"topic",
".",
"Name",
")",
"\n",
"delete",
"(",
"client",
".",
"cachedPartitionsResults",
",",
"topic",
".",
"Name",
")",
"\n\n",
"switch",
"topic",
".",
"Err",
"{",
"case",
"ErrNoError",
":",
"// no-op",
"case",
"ErrInvalidTopic",
",",
"ErrTopicAuthorizationFailed",
":",
"// don't retry, don't store partial results",
"err",
"=",
"topic",
".",
"Err",
"\n",
"continue",
"\n",
"case",
"ErrUnknownTopicOrPartition",
":",
"// retry, do not store partial partition results",
"err",
"=",
"topic",
".",
"Err",
"\n",
"retry",
"=",
"true",
"\n",
"continue",
"\n",
"case",
"ErrLeaderNotAvailable",
":",
"// retry, but store partial partition results",
"retry",
"=",
"true",
"\n",
"default",
":",
"// don't retry, don't store partial results",
"Logger",
".",
"Printf",
"(",
"\"",
"\"",
",",
"topic",
".",
"Err",
")",
"\n",
"err",
"=",
"topic",
".",
"Err",
"\n",
"continue",
"\n",
"}",
"\n\n",
"client",
".",
"metadata",
"[",
"topic",
".",
"Name",
"]",
"=",
"make",
"(",
"map",
"[",
"int32",
"]",
"*",
"PartitionMetadata",
",",
"len",
"(",
"topic",
".",
"Partitions",
")",
")",
"\n",
"for",
"_",
",",
"partition",
":=",
"range",
"topic",
".",
"Partitions",
"{",
"client",
".",
"metadata",
"[",
"topic",
".",
"Name",
"]",
"[",
"partition",
".",
"ID",
"]",
"=",
"partition",
"\n",
"if",
"partition",
".",
"Err",
"==",
"ErrLeaderNotAvailable",
"{",
"retry",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"var",
"partitionCache",
"[",
"maxPartitionIndex",
"]",
"[",
"]",
"int32",
"\n",
"partitionCache",
"[",
"allPartitions",
"]",
"=",
"client",
".",
"setPartitionCache",
"(",
"topic",
".",
"Name",
",",
"allPartitions",
")",
"\n",
"partitionCache",
"[",
"writablePartitions",
"]",
"=",
"client",
".",
"setPartitionCache",
"(",
"topic",
".",
"Name",
",",
"writablePartitions",
")",
"\n",
"client",
".",
"cachedPartitionsResults",
"[",
"topic",
".",
"Name",
"]",
"=",
"partitionCache",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // 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",
".",
"Net",
".",
"DialTimeout",
"=",
"30",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Net",
".",
"ReadTimeout",
"=",
"30",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Net",
".",
"WriteTimeout",
"=",
"30",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Net",
".",
"SASL",
".",
"Handshake",
"=",
"true",
"\n\n",
"c",
".",
"Metadata",
".",
"Retry",
".",
"Max",
"=",
"3",
"\n",
"c",
".",
"Metadata",
".",
"Retry",
".",
"Backoff",
"=",
"250",
"*",
"time",
".",
"Millisecond",
"\n",
"c",
".",
"Metadata",
".",
"RefreshFrequency",
"=",
"10",
"*",
"time",
".",
"Minute",
"\n",
"c",
".",
"Metadata",
".",
"Full",
"=",
"true",
"\n\n",
"c",
".",
"Producer",
".",
"MaxMessageBytes",
"=",
"1000000",
"\n",
"c",
".",
"Producer",
".",
"RequiredAcks",
"=",
"WaitForLocal",
"\n",
"c",
".",
"Producer",
".",
"Timeout",
"=",
"10",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Producer",
".",
"Partitioner",
"=",
"NewHashPartitioner",
"\n",
"c",
".",
"Producer",
".",
"Retry",
".",
"Max",
"=",
"3",
"\n",
"c",
".",
"Producer",
".",
"Retry",
".",
"Backoff",
"=",
"100",
"*",
"time",
".",
"Millisecond",
"\n",
"c",
".",
"Producer",
".",
"Return",
".",
"Errors",
"=",
"true",
"\n",
"c",
".",
"Producer",
".",
"CompressionLevel",
"=",
"CompressionLevelDefault",
"\n\n",
"c",
".",
"Consumer",
".",
"Fetch",
".",
"Min",
"=",
"1",
"\n",
"c",
".",
"Consumer",
".",
"Fetch",
".",
"Default",
"=",
"1024",
"*",
"1024",
"\n",
"c",
".",
"Consumer",
".",
"Retry",
".",
"Backoff",
"=",
"2",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Consumer",
".",
"MaxWaitTime",
"=",
"250",
"*",
"time",
".",
"Millisecond",
"\n",
"c",
".",
"Consumer",
".",
"MaxProcessingTime",
"=",
"100",
"*",
"time",
".",
"Millisecond",
"\n",
"c",
".",
"Consumer",
".",
"Return",
".",
"Errors",
"=",
"false",
"\n",
"c",
".",
"Consumer",
".",
"Offsets",
".",
"CommitInterval",
"=",
"1",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Consumer",
".",
"Offsets",
".",
"Initial",
"=",
"OffsetNewest",
"\n",
"c",
".",
"Consumer",
".",
"Offsets",
".",
"Retry",
".",
"Max",
"=",
"3",
"\n\n",
"c",
".",
"Consumer",
".",
"Group",
".",
"Session",
".",
"Timeout",
"=",
"10",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Consumer",
".",
"Group",
".",
"Heartbeat",
".",
"Interval",
"=",
"3",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Consumer",
".",
"Group",
".",
"Rebalance",
".",
"Strategy",
"=",
"BalanceStrategyRange",
"\n",
"c",
".",
"Consumer",
".",
"Group",
".",
"Rebalance",
".",
"Timeout",
"=",
"60",
"*",
"time",
".",
"Second",
"\n",
"c",
".",
"Consumer",
".",
"Group",
".",
"Rebalance",
".",
"Retry",
".",
"Max",
"=",
"4",
"\n",
"c",
".",
"Consumer",
".",
"Group",
".",
"Rebalance",
".",
"Retry",
".",
"Backoff",
"=",
"2",
"*",
"time",
".",
"Second",
"\n\n",
"c",
".",
"ClientID",
"=",
"defaultClientID",
"\n",
"c",
".",
"ChannelBufferSize",
"=",
"256",
"\n",
"c",
".",
"Version",
"=",
"MinVersion",
"\n",
"c",
".",
"MetricRegistry",
"=",
"metrics",
".",
"NewRegistry",
"(",
")",
"\n\n",
"return",
"c",
"\n",
"}"
] | // 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",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"newAsyncProducer",
"(",
"client",
")",
"\n",
"}"
] | // 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",
".",
"input",
"{",
"if",
"msg",
"==",
"nil",
"{",
"Logger",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"msg",
".",
"flags",
"&",
"shutdown",
"!=",
"0",
"{",
"shuttingDown",
"=",
"true",
"\n",
"p",
".",
"inFlight",
".",
"Done",
"(",
")",
"\n",
"continue",
"\n",
"}",
"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",
"}",
"\n",
"if",
"p",
".",
"conf",
".",
"Producer",
".",
"Return",
".",
"Errors",
"{",
"p",
".",
"errors",
"<-",
"pErr",
"\n",
"}",
"else",
"{",
"Logger",
".",
"Println",
"(",
"pErr",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"p",
".",
"inFlight",
".",
"Add",
"(",
"1",
")",
"\n",
"}",
"\n\n",
"version",
":=",
"1",
"\n",
"if",
"p",
".",
"conf",
".",
"Version",
".",
"IsAtLeast",
"(",
"V0_11_0_0",
")",
"{",
"version",
"=",
"2",
"\n",
"}",
"else",
"if",
"msg",
".",
"Headers",
"!=",
"nil",
"{",
"p",
".",
"returnError",
"(",
"msg",
",",
"ConfigurationError",
"(",
"\"",
"\"",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"msg",
".",
"byteSize",
"(",
"version",
")",
">",
"p",
".",
"conf",
".",
"Producer",
".",
"MaxMessageBytes",
"{",
"p",
".",
"returnError",
"(",
"msg",
",",
"ErrMessageSizeTooLarge",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"handler",
":=",
"handlers",
"[",
"msg",
".",
"Topic",
"]",
"\n",
"if",
"handler",
"==",
"nil",
"{",
"handler",
"=",
"p",
".",
"newTopicProducer",
"(",
"msg",
".",
"Topic",
")",
"\n",
"handlers",
"[",
"msg",
".",
"Topic",
"]",
"=",
"handler",
"\n",
"}",
"\n\n",
"handler",
"<-",
"msg",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"handler",
":=",
"range",
"handlers",
"{",
"close",
"(",
"handler",
")",
"\n",
"}",
"\n",
"}"
] | // 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",
"*",
"produceSet",
")",
"\n",
"responses",
"=",
"make",
"(",
"chan",
"*",
"brokerProducerResponse",
")",
"\n",
")",
"\n\n",
"bp",
":=",
"&",
"brokerProducer",
"{",
"parent",
":",
"p",
",",
"broker",
":",
"broker",
",",
"input",
":",
"input",
",",
"output",
":",
"bridge",
",",
"responses",
":",
"responses",
",",
"buffer",
":",
"newProduceSet",
"(",
"p",
")",
",",
"currentRetries",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"int32",
"]",
"error",
")",
",",
"}",
"\n",
"go",
"withRecover",
"(",
"bp",
".",
"run",
")",
"\n\n",
"// minimal bridge to make the network response `select`able",
"go",
"withRecover",
"(",
"func",
"(",
")",
"{",
"for",
"set",
":=",
"range",
"bridge",
"{",
"request",
":=",
"set",
".",
"buildRequest",
"(",
")",
"\n\n",
"response",
",",
"err",
":=",
"broker",
".",
"Produce",
"(",
"request",
")",
"\n\n",
"responses",
"<-",
"&",
"brokerProducerResponse",
"{",
"set",
":",
"set",
",",
"err",
":",
"err",
",",
"res",
":",
"response",
",",
"}",
"\n",
"}",
"\n",
"close",
"(",
"responses",
")",
"\n",
"}",
")",
"\n\n",
"if",
"p",
".",
"conf",
".",
"Producer",
".",
"Retry",
".",
"Max",
"<=",
"0",
"{",
"bp",
".",
"abandoned",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"bp",
"\n",
"}"
] | // 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",
":=",
"reflect",
".",
"TypeOf",
"(",
"req",
".",
"body",
")",
".",
"Elem",
"(",
")",
".",
"Name",
"(",
")",
"\n",
"mockResponse",
":=",
"handlerMap",
"[",
"reqTypeName",
"]",
"\n",
"if",
"mockResponse",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"mockResponse",
".",
"For",
"(",
"req",
".",
"body",
")",
"\n",
"}",
")",
"\n",
"}"
] | // 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",
"MockResponse",
"instance",
"to",
"generate",
"an",
"appropriate",
"reply",
".",
"If",
"the",
"request",
"type",
"is",
"not",
"found",
"in",
"the",
"map",
"then",
"nothing",
"is",
"sent",
"."
] | 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",
")",
")",
"\n",
"copy",
"(",
"history",
",",
"b",
".",
"history",
")",
"\n",
"b",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"history",
"\n",
"}"
] | // 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",
"expected",
"by",
"a",
"test",
"can",
"be",
"different",
"from",
"the",
"order",
"recorded",
"in",
"the",
"history",
"unless",
"some",
"synchronization",
"is",
"implemented",
"in",
"the",
"test",
"."
] | 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",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"BrokerID",
"(",
")",
")",
")",
"\n",
"for",
"e",
":=",
"range",
"b",
".",
"expectations",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"spew",
".",
"Sdump",
"(",
"e",
")",
")",
"\n",
"}",
"\n",
"b",
".",
"t",
".",
"Error",
"(",
"buf",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"close",
"(",
"b",
".",
"closing",
")",
"\n",
"<-",
"b",
".",
"stopper",
"\n",
"}"
] | // 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",
"whatever",
"the",
"handler",
"function",
"returns",
"."
] | 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",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"NewMockBrokerListener",
"(",
"t",
",",
"brokerID",
",",
"listener",
")",
"\n",
"}"
] | // 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",
"(",
"chan",
"none",
")",
",",
"stopper",
":",
"make",
"(",
"chan",
"none",
")",
",",
"t",
":",
"t",
",",
"brokerID",
":",
"brokerID",
",",
"expectations",
":",
"make",
"(",
"chan",
"encoder",
",",
"512",
")",
",",
"listener",
":",
"listener",
",",
"}",
"\n",
"broker",
".",
"handler",
"=",
"broker",
".",
"defaultRequestHandler",
"\n\n",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"brokerID",
",",
"broker",
".",
"listener",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"_",
",",
"portStr",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"broker",
".",
"listener",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"tmp",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"portStr",
",",
"10",
",",
"32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"broker",
".",
"port",
"=",
"int32",
"(",
"tmp",
")",
"\n\n",
"go",
"broker",
".",
"serverLoop",
"(",
")",
"\n\n",
"return",
"broker",
"\n",
"}"
] | // 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",
"!=",
"nil",
",",
"b",
".",
"connErr",
"\n",
"}"
] | // 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",
"is",
"also",
"returned",
"."
] | 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",
"ErrNotConnected",
"\n",
"}",
"\n\n",
"close",
"(",
"b",
".",
"responses",
")",
"\n",
"<-",
"b",
".",
"done",
"\n\n",
"err",
":=",
"b",
".",
"conn",
".",
"Close",
"(",
")",
"\n\n",
"b",
".",
"conn",
"=",
"nil",
"\n",
"b",
".",
"connErr",
"=",
"nil",
"\n",
"b",
".",
"done",
"=",
"nil",
"\n",
"b",
".",
"responses",
"=",
"nil",
"\n\n",
"b",
".",
"unregisterMetrics",
"(",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"addr",
")",
"\n",
"}",
"else",
"{",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"addr",
",",
"err",
")",
"\n",
"}",
"\n\n",
"atomic",
".",
"StoreInt32",
"(",
"&",
"b",
".",
"opened",
",",
"0",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] | //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",
"(",
"request",
",",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
":=",
"b",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
"(",
"request",
",",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"RequiredAcks",
"==",
"NoResponse",
"{",
"err",
"=",
"b",
".",
"sendAndReceive",
"(",
"request",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"response",
"=",
"new",
"(",
"ProduceResponse",
")",
"\n",
"err",
"=",
"b",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
":=",
"b",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"sendAndReceive",
"(",
"request",
",",
"response",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | //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",
".",
"Net",
".",
"SASL",
".",
"Password",
")",
"\n",
"authBytes",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"length",
"+",
"4",
")",
"//4 byte length header + auth data",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"authBytes",
",",
"uint32",
"(",
"length",
")",
")",
"\n",
"copy",
"(",
"authBytes",
"[",
"4",
":",
"]",
",",
"[",
"]",
"byte",
"(",
"\"",
"\\x00",
"\"",
"+",
"b",
".",
"conf",
".",
"Net",
".",
"SASL",
".",
"User",
"+",
"\"",
"\\x00",
"\"",
"+",
"b",
".",
"conf",
".",
"Net",
".",
"SASL",
".",
"Password",
")",
")",
"\n\n",
"err",
":=",
"b",
".",
"conn",
".",
"SetWriteDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"b",
".",
"conf",
".",
"Net",
".",
"WriteTimeout",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"addr",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"requestTime",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"bytesWritten",
",",
"err",
":=",
"b",
".",
"conn",
".",
"Write",
"(",
"authBytes",
")",
"\n",
"b",
".",
"updateOutgoingCommunicationMetrics",
"(",
"bytesWritten",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"addr",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"header",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"n",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"b",
".",
"conn",
",",
"header",
")",
"\n",
"b",
".",
"updateIncomingCommunicationMetrics",
"(",
"n",
",",
"time",
".",
"Since",
"(",
"requestTime",
")",
")",
"\n",
"// 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",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"addr",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"addr",
",",
"n",
",",
"header",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // 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",
".",
"sendSASLPlainAuthClientResponse",
"(",
"correlationID",
")",
"\n\n",
"b",
".",
"updateOutgoingCommunicationMetrics",
"(",
"bytesWritten",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"addr",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"b",
".",
"correlationID",
"++",
"\n\n",
"bytesRead",
",",
"err",
":=",
"b",
".",
"receiveSASLServerResponse",
"(",
"correlationID",
")",
"\n",
"b",
".",
"updateIncomingCommunicationMetrics",
"(",
"bytesRead",
",",
"time",
".",
"Since",
"(",
"requestTime",
")",
")",
"\n\n",
"// With v1 sasl we get an error message set in the response we can return",
"if",
"err",
"!=",
"nil",
"{",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
".",
"addr",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // 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",
")",
")",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"extensions",
"{",
"buf",
"=",
"append",
"(",
"buf",
",",
"k",
"+",
"keyValSep",
"+",
"v",
")",
"\n",
"}",
"\n\n",
"sort",
".",
"Strings",
"(",
"buf",
")",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"buf",
",",
"elemSep",
")",
"\n",
"}"
] | // 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",
"[",
"]",
"*",
"MessageBlock",
"{",
"msb",
"}",
"\n",
"}"
] | // 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",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"c",
",",
"err",
":=",
"newConsumerGroup",
"(",
"groupID",
",",
"client",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"_",
"=",
"client",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"c",
",",
"err",
"\n",
"}"
] | // 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",
"(",
")",
"\n",
"defer",
"c",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"// leave group",
"if",
"e",
":=",
"c",
".",
"leave",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"err",
"=",
"e",
"\n",
"}",
"\n\n",
"// drain errors",
"go",
"func",
"(",
")",
"{",
"close",
"(",
"c",
".",
"errors",
")",
"\n",
"}",
"(",
")",
"\n",
"for",
"e",
":=",
"range",
"c",
".",
"errors",
"{",
"err",
"=",
"e",
"\n",
"}",
"\n\n",
"if",
"e",
":=",
"c",
".",
"client",
".",
"Close",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"err",
"=",
"e",
"\n",
"}",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] | // 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",
".",
"closed",
":",
"return",
"ErrClosedConsumerGroup",
"\n",
"default",
":",
"}",
"\n\n",
"c",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"// Quick exit when no topics are provided",
"if",
"len",
"(",
"topics",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Refresh metadata for requested topics",
"if",
"err",
":=",
"c",
".",
"client",
".",
"RefreshMetadata",
"(",
"topics",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Init session",
"sess",
",",
"err",
":=",
"c",
".",
"newSession",
"(",
"ctx",
",",
"topics",
",",
"handler",
",",
"c",
".",
"config",
".",
"Consumer",
".",
"Group",
".",
"Rebalance",
".",
"Retry",
".",
"Max",
")",
"\n",
"if",
"err",
"==",
"ErrClosedClient",
"{",
"return",
"ErrClosedConsumerGroup",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Wait for session exit signal",
"<-",
"sess",
".",
"ctx",
".",
"Done",
"(",
")",
"\n\n",
"// Gracefully release session claims",
"return",
"sess",
".",
"release",
"(",
"true",
")",
"\n",
"}"
] | // 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",
".",
"groupID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"coordinator",
".",
"LeaveGroup",
"(",
"&",
"LeaveGroupRequest",
"{",
"GroupId",
":",
"c",
".",
"groupID",
",",
"MemberId",
":",
"c",
".",
"memberID",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"_",
"=",
"coordinator",
".",
"Close",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// Unset memberID",
"c",
".",
"memberID",
"=",
"\"",
"\"",
"\n\n",
"// Check response",
"switch",
"resp",
".",
"Err",
"{",
"case",
"ErrRebalanceInProgress",
",",
"ErrUnknownMemberId",
",",
"ErrNoError",
":",
"return",
"nil",
"\n",
"default",
":",
"return",
"resp",
".",
"Err",
"\n",
"}",
"\n",
"}"
] | // 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",
":=",
"range",
"c",
".",
"Errors",
"(",
")",
"{",
"errs",
"=",
"append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // 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",
".",
"Set",
".",
"decode",
"(",
"&",
"pd",
")",
"\n",
"}"
] | // 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",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"newConsumer",
"(",
"client",
")",
"\n",
"}"
] | // 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",
".",
"updateSubscriptions",
"(",
"newSubscriptions",
")",
"\n\n",
"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",
"\n",
"continue",
"\n",
"}",
"\n\n",
"response",
",",
"err",
":=",
"bc",
".",
"fetchNewMessages",
"(",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"bc",
".",
"broker",
".",
"ID",
"(",
")",
",",
"err",
")",
"\n",
"bc",
".",
"abort",
"(",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"bc",
".",
"acks",
".",
"Add",
"(",
"len",
"(",
"bc",
".",
"subscriptions",
")",
")",
"\n",
"for",
"child",
":=",
"range",
"bc",
".",
"subscriptions",
"{",
"child",
".",
"feeder",
"<-",
"response",
"\n",
"}",
"\n",
"bc",
".",
"acks",
".",
"Wait",
"(",
")",
"\n",
"bc",
".",
"handleResponses",
"(",
")",
"\n",
"}",
"\n",
"}"
] | //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",
"switch",
"result",
"{",
"case",
"nil",
":",
"// no-op",
"case",
"errTimedOut",
":",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"bc",
".",
"broker",
".",
"ID",
"(",
")",
",",
"child",
".",
"topic",
",",
"child",
".",
"partition",
")",
"\n",
"delete",
"(",
"bc",
".",
"subscriptions",
",",
"child",
")",
"\n",
"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",
")",
"\n",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"child",
".",
"topic",
",",
"child",
".",
"partition",
",",
"result",
")",
"\n",
"close",
"(",
"child",
".",
"trigger",
")",
"\n",
"delete",
"(",
"bc",
".",
"subscriptions",
",",
"child",
")",
"\n",
"case",
"ErrUnknownTopicOrPartition",
",",
"ErrNotLeaderForPartition",
",",
"ErrLeaderNotAvailable",
",",
"ErrReplicaNotAvailable",
":",
"// not an error, but does need redispatching",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"bc",
".",
"broker",
".",
"ID",
"(",
")",
",",
"child",
".",
"topic",
",",
"child",
".",
"partition",
",",
"result",
")",
"\n",
"child",
".",
"trigger",
"<-",
"none",
"{",
"}",
"\n",
"delete",
"(",
"bc",
".",
"subscriptions",
",",
"child",
")",
"\n",
"default",
":",
"// dunno, tell the user and try redispatching",
"child",
".",
"sendError",
"(",
"result",
")",
"\n",
"Logger",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"bc",
".",
"broker",
".",
"ID",
"(",
")",
",",
"child",
".",
"topic",
",",
"child",
".",
"partition",
",",
"result",
")",
"\n",
"child",
".",
"trigger",
"<-",
"none",
"{",
"}",
"\n",
"delete",
"(",
"bc",
".",
"subscriptions",
",",
"child",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | //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",
"(",
")",
".",
"UTC",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // 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",
".",
"random",
"=",
"NewRandomPartitioner",
"(",
"topic",
")",
"\n",
"p",
".",
"hasher",
"=",
"hasher",
"(",
")",
"\n",
"p",
".",
"referenceAbs",
"=",
"false",
"\n",
"return",
"p",
"\n",
"}",
"\n",
"}"
] | // 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",
"interface",
".",
"This",
"is",
"to",
"ensure",
"that",
"each",
"partition",
"dispatcher",
"gets",
"its",
"own",
"hasher",
"to",
"avoid",
"concurrency",
"issues",
"by",
"sharing",
"an",
"instance",
"."
] | 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",
"=",
"NewRandomPartitioner",
"(",
"topic",
")",
"\n",
"p",
".",
"hasher",
"=",
"fnv",
".",
"New32a",
"(",
")",
"\n",
"p",
".",
"referenceAbs",
"=",
"false",
"\n",
"for",
"_",
",",
"option",
":=",
"range",
"options",
"{",
"option",
"(",
"p",
")",
"\n",
"}",
"\n",
"return",
"p",
"\n",
"}",
"\n",
"}"
] | // 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",
"(",
")",
"\n",
"p",
".",
"referenceAbs",
"=",
"false",
"\n",
"return",
"p",
"\n",
"}"
] | // 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",
"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",
"."
] | 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",
".",
"New32a",
"(",
")",
"\n",
"p",
".",
"referenceAbs",
"=",
"true",
"\n",
"return",
"p",
"\n",
"}"
] | // 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",
"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",
"."
] | 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.