repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
hyperledger/burrow | permission/util.go | PermFlagToStringList | func PermFlagToStringList(permFlag PermFlag) []string {
permStrings := make([]string, 0, NumPermissions)
for i := uint(0); i < NumPermissions; i++ {
permFlag := permFlag & (1 << i)
if permFlag > 0 {
permStrings = append(permStrings, permFlag.String())
}
}
return permStrings
} | go | func PermFlagToStringList(permFlag PermFlag) []string {
permStrings := make([]string, 0, NumPermissions)
for i := uint(0); i < NumPermissions; i++ {
permFlag := permFlag & (1 << i)
if permFlag > 0 {
permStrings = append(permStrings, permFlag.String())
}
}
return permStrings
} | [
"func",
"PermFlagToStringList",
"(",
"permFlag",
"PermFlag",
")",
"[",
"]",
"string",
"{",
"permStrings",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"NumPermissions",
")",
"\n",
"for",
"i",
":=",
"uint",
"(",
"0",
")",
";",
"i",
"<",
"NumPermissions",
";",
"i",
"++",
"{",
"permFlag",
":=",
"permFlag",
"&",
"(",
"1",
"<<",
"i",
")",
"\n",
"if",
"permFlag",
">",
"0",
"{",
"permStrings",
"=",
"append",
"(",
"permStrings",
",",
"permFlag",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"permStrings",
"\n",
"}"
] | // Creates a list of individual permission flag strings from a possibly composite PermFlag
// by projecting out each bit and adding its permission string if it is set | [
"Creates",
"a",
"list",
"of",
"individual",
"permission",
"flag",
"strings",
"from",
"a",
"possibly",
"composite",
"PermFlag",
"by",
"projecting",
"out",
"each",
"bit",
"and",
"adding",
"its",
"permission",
"string",
"if",
"it",
"is",
"set"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/permission/util.go#L95-L104 | train |
hyperledger/burrow | rpc/service.go | NewService | func NewService(state acmstate.IterableStatsReader, nameReg names.IterableReader, blockchain bcm.BlockchainInfo,
validators validator.History, nodeView *tendermint.NodeView, logger *logging.Logger) *Service {
return &Service{
state: state,
nameReg: nameReg,
blockchain: blockchain,
validators: validators,
nodeView: nodeView,
logger: logger.With(structure.ComponentKey, "Service"),
}
} | go | func NewService(state acmstate.IterableStatsReader, nameReg names.IterableReader, blockchain bcm.BlockchainInfo,
validators validator.History, nodeView *tendermint.NodeView, logger *logging.Logger) *Service {
return &Service{
state: state,
nameReg: nameReg,
blockchain: blockchain,
validators: validators,
nodeView: nodeView,
logger: logger.With(structure.ComponentKey, "Service"),
}
} | [
"func",
"NewService",
"(",
"state",
"acmstate",
".",
"IterableStatsReader",
",",
"nameReg",
"names",
".",
"IterableReader",
",",
"blockchain",
"bcm",
".",
"BlockchainInfo",
",",
"validators",
"validator",
".",
"History",
",",
"nodeView",
"*",
"tendermint",
".",
"NodeView",
",",
"logger",
"*",
"logging",
".",
"Logger",
")",
"*",
"Service",
"{",
"return",
"&",
"Service",
"{",
"state",
":",
"state",
",",
"nameReg",
":",
"nameReg",
",",
"blockchain",
":",
"blockchain",
",",
"validators",
":",
"validators",
",",
"nodeView",
":",
"nodeView",
",",
"logger",
":",
"logger",
".",
"With",
"(",
"structure",
".",
"ComponentKey",
",",
"\"Service\"",
")",
",",
"}",
"\n",
"}"
] | // Service provides an internal query and information service with serialisable return types on which can accomodate
// a number of transport front ends | [
"Service",
"provides",
"an",
"internal",
"query",
"and",
"information",
"service",
"with",
"serialisable",
"return",
"types",
"on",
"which",
"can",
"accomodate",
"a",
"number",
"of",
"transport",
"front",
"ends"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/rpc/service.go#L58-L69 | train |
hyperledger/burrow | rpc/service.go | Blocks | func (s *Service) Blocks(minHeight, maxHeight int64) (*ResultBlocks, error) {
if s.nodeView == nil {
return nil, fmt.Errorf("NodeView is not mounted so cannot pull Tendermint blocks")
}
latestHeight := int64(s.blockchain.LastBlockHeight())
if minHeight < 1 {
minHeight = latestHeight
}
if maxHeight == 0 || latestHeight < maxHeight {
maxHeight = latestHeight
}
if maxHeight > minHeight && maxHeight-minHeight > MaxBlockLookback {
minHeight = maxHeight - MaxBlockLookback
}
var blockMetas []*tmTypes.BlockMeta
for height := minHeight; height <= maxHeight; height++ {
blockMeta := s.nodeView.BlockStore().LoadBlockMeta(height)
blockMetas = append(blockMetas, blockMeta)
}
return &ResultBlocks{
LastHeight: uint64(latestHeight),
BlockMetas: blockMetas,
}, nil
} | go | func (s *Service) Blocks(minHeight, maxHeight int64) (*ResultBlocks, error) {
if s.nodeView == nil {
return nil, fmt.Errorf("NodeView is not mounted so cannot pull Tendermint blocks")
}
latestHeight := int64(s.blockchain.LastBlockHeight())
if minHeight < 1 {
minHeight = latestHeight
}
if maxHeight == 0 || latestHeight < maxHeight {
maxHeight = latestHeight
}
if maxHeight > minHeight && maxHeight-minHeight > MaxBlockLookback {
minHeight = maxHeight - MaxBlockLookback
}
var blockMetas []*tmTypes.BlockMeta
for height := minHeight; height <= maxHeight; height++ {
blockMeta := s.nodeView.BlockStore().LoadBlockMeta(height)
blockMetas = append(blockMetas, blockMeta)
}
return &ResultBlocks{
LastHeight: uint64(latestHeight),
BlockMetas: blockMetas,
}, nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"Blocks",
"(",
"minHeight",
",",
"maxHeight",
"int64",
")",
"(",
"*",
"ResultBlocks",
",",
"error",
")",
"{",
"if",
"s",
".",
"nodeView",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"NodeView is not mounted so cannot pull Tendermint blocks\"",
")",
"\n",
"}",
"\n",
"latestHeight",
":=",
"int64",
"(",
"s",
".",
"blockchain",
".",
"LastBlockHeight",
"(",
")",
")",
"\n",
"if",
"minHeight",
"<",
"1",
"{",
"minHeight",
"=",
"latestHeight",
"\n",
"}",
"\n",
"if",
"maxHeight",
"==",
"0",
"||",
"latestHeight",
"<",
"maxHeight",
"{",
"maxHeight",
"=",
"latestHeight",
"\n",
"}",
"\n",
"if",
"maxHeight",
">",
"minHeight",
"&&",
"maxHeight",
"-",
"minHeight",
">",
"MaxBlockLookback",
"{",
"minHeight",
"=",
"maxHeight",
"-",
"MaxBlockLookback",
"\n",
"}",
"\n",
"var",
"blockMetas",
"[",
"]",
"*",
"tmTypes",
".",
"BlockMeta",
"\n",
"for",
"height",
":=",
"minHeight",
";",
"height",
"<=",
"maxHeight",
";",
"height",
"++",
"{",
"blockMeta",
":=",
"s",
".",
"nodeView",
".",
"BlockStore",
"(",
")",
".",
"LoadBlockMeta",
"(",
"height",
")",
"\n",
"blockMetas",
"=",
"append",
"(",
"blockMetas",
",",
"blockMeta",
")",
"\n",
"}",
"\n",
"return",
"&",
"ResultBlocks",
"{",
"LastHeight",
":",
"uint64",
"(",
"latestHeight",
")",
",",
"BlockMetas",
":",
"blockMetas",
",",
"}",
",",
"nil",
"\n",
"}"
] | // Returns the current blockchain height and metadata for a range of blocks
// between minHeight and maxHeight. Only returns maxBlockLookback block metadata
// from the top of the range of blocks.
// Passing 0 for maxHeight sets the upper height of the range to the current
// blockchain height. | [
"Returns",
"the",
"current",
"blockchain",
"height",
"and",
"metadata",
"for",
"a",
"range",
"of",
"blocks",
"between",
"minHeight",
"and",
"maxHeight",
".",
"Only",
"returns",
"maxBlockLookback",
"block",
"metadata",
"from",
"the",
"top",
"of",
"the",
"range",
"of",
"blocks",
".",
"Passing",
"0",
"for",
"maxHeight",
"sets",
"the",
"upper",
"height",
"of",
"the",
"range",
"to",
"the",
"current",
"blockchain",
"height",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/rpc/service.go#L298-L324 | train |
hyperledger/burrow | genesis/deterministic_genesis.go | NewDeterministicGenesis | func NewDeterministicGenesis(seed int64) *deterministicGenesis {
return &deterministicGenesis{
random: rand.New(rand.NewSource(seed)),
}
} | go | func NewDeterministicGenesis(seed int64) *deterministicGenesis {
return &deterministicGenesis{
random: rand.New(rand.NewSource(seed)),
}
} | [
"func",
"NewDeterministicGenesis",
"(",
"seed",
"int64",
")",
"*",
"deterministicGenesis",
"{",
"return",
"&",
"deterministicGenesis",
"{",
"random",
":",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"seed",
")",
")",
",",
"}",
"\n",
"}"
] | // Generates deterministic pseudo-random genesis state | [
"Generates",
"deterministic",
"pseudo",
"-",
"random",
"genesis",
"state"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/genesis/deterministic_genesis.go#L18-L22 | train |
hyperledger/burrow | execution/contexts/governance_context.go | Execute | func (ctx *GovernanceContext) Execute(txe *exec.TxExecution, p payload.Payload) error {
var ok bool
ctx.txe = txe
ctx.tx, ok = p.(*payload.GovTx)
if !ok {
return fmt.Errorf("payload must be NameTx, but is: %v", txe.Envelope.Tx.Payload)
}
// Nothing down with any incoming funds at this point
accounts, _, err := getInputs(ctx.StateWriter, ctx.tx.Inputs)
if err != nil {
return err
}
// ensure all inputs have root permissions
err = allHavePermission(ctx.StateWriter, permission.Root, accounts, ctx.Logger)
if err != nil {
return errors.Wrap(err, "at least one input lacks permission for GovTx")
}
for _, i := range ctx.tx.Inputs {
txe.Input(i.Address, nil)
}
for _, update := range ctx.tx.AccountUpdates {
if update.Address == nil && update.PublicKey == nil {
// We do not want to generate a key
return fmt.Errorf("could not execution GovTx since account template %v contains neither "+
"address or public key", update)
}
if update.PublicKey == nil {
update.PublicKey, err = ctx.MaybeGetPublicKey(*update.Address)
if err != nil {
return err
}
}
// Check address
if update.PublicKey != nil {
address := update.PublicKey.GetAddress()
if update.Address != nil && address != *update.Address {
return fmt.Errorf("supplied public key %v whose address %v does not match %v provided by"+
"GovTx", update.PublicKey, address, update.Address)
}
update.Address = &address
} else if update.Balances().HasPower() {
// If we are updating power we will need the key
return fmt.Errorf("GovTx must be provided with public key when updating validator power")
}
account, err := getOrMakeOutput(ctx.StateWriter, accounts, *update.Address, ctx.Logger)
if err != nil {
return err
}
governAccountEvent, err := ctx.UpdateAccount(account, update)
if err != nil {
txe.GovernAccount(governAccountEvent, errors.AsException(err))
return err
}
txe.GovernAccount(governAccountEvent, nil)
}
return nil
} | go | func (ctx *GovernanceContext) Execute(txe *exec.TxExecution, p payload.Payload) error {
var ok bool
ctx.txe = txe
ctx.tx, ok = p.(*payload.GovTx)
if !ok {
return fmt.Errorf("payload must be NameTx, but is: %v", txe.Envelope.Tx.Payload)
}
// Nothing down with any incoming funds at this point
accounts, _, err := getInputs(ctx.StateWriter, ctx.tx.Inputs)
if err != nil {
return err
}
// ensure all inputs have root permissions
err = allHavePermission(ctx.StateWriter, permission.Root, accounts, ctx.Logger)
if err != nil {
return errors.Wrap(err, "at least one input lacks permission for GovTx")
}
for _, i := range ctx.tx.Inputs {
txe.Input(i.Address, nil)
}
for _, update := range ctx.tx.AccountUpdates {
if update.Address == nil && update.PublicKey == nil {
// We do not want to generate a key
return fmt.Errorf("could not execution GovTx since account template %v contains neither "+
"address or public key", update)
}
if update.PublicKey == nil {
update.PublicKey, err = ctx.MaybeGetPublicKey(*update.Address)
if err != nil {
return err
}
}
// Check address
if update.PublicKey != nil {
address := update.PublicKey.GetAddress()
if update.Address != nil && address != *update.Address {
return fmt.Errorf("supplied public key %v whose address %v does not match %v provided by"+
"GovTx", update.PublicKey, address, update.Address)
}
update.Address = &address
} else if update.Balances().HasPower() {
// If we are updating power we will need the key
return fmt.Errorf("GovTx must be provided with public key when updating validator power")
}
account, err := getOrMakeOutput(ctx.StateWriter, accounts, *update.Address, ctx.Logger)
if err != nil {
return err
}
governAccountEvent, err := ctx.UpdateAccount(account, update)
if err != nil {
txe.GovernAccount(governAccountEvent, errors.AsException(err))
return err
}
txe.GovernAccount(governAccountEvent, nil)
}
return nil
} | [
"func",
"(",
"ctx",
"*",
"GovernanceContext",
")",
"Execute",
"(",
"txe",
"*",
"exec",
".",
"TxExecution",
",",
"p",
"payload",
".",
"Payload",
")",
"error",
"{",
"var",
"ok",
"bool",
"\n",
"ctx",
".",
"txe",
"=",
"txe",
"\n",
"ctx",
".",
"tx",
",",
"ok",
"=",
"p",
".",
"(",
"*",
"payload",
".",
"GovTx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"payload must be NameTx, but is: %v\"",
",",
"txe",
".",
"Envelope",
".",
"Tx",
".",
"Payload",
")",
"\n",
"}",
"\n",
"accounts",
",",
"_",
",",
"err",
":=",
"getInputs",
"(",
"ctx",
".",
"StateWriter",
",",
"ctx",
".",
"tx",
".",
"Inputs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"allHavePermission",
"(",
"ctx",
".",
"StateWriter",
",",
"permission",
".",
"Root",
",",
"accounts",
",",
"ctx",
".",
"Logger",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"at least one input lacks permission for GovTx\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"i",
":=",
"range",
"ctx",
".",
"tx",
".",
"Inputs",
"{",
"txe",
".",
"Input",
"(",
"i",
".",
"Address",
",",
"nil",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"update",
":=",
"range",
"ctx",
".",
"tx",
".",
"AccountUpdates",
"{",
"if",
"update",
".",
"Address",
"==",
"nil",
"&&",
"update",
".",
"PublicKey",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"could not execution GovTx since account template %v contains neither \"",
"+",
"\"address or public key\"",
",",
"update",
")",
"\n",
"}",
"\n",
"if",
"update",
".",
"PublicKey",
"==",
"nil",
"{",
"update",
".",
"PublicKey",
",",
"err",
"=",
"ctx",
".",
"MaybeGetPublicKey",
"(",
"*",
"update",
".",
"Address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"update",
".",
"PublicKey",
"!=",
"nil",
"{",
"address",
":=",
"update",
".",
"PublicKey",
".",
"GetAddress",
"(",
")",
"\n",
"if",
"update",
".",
"Address",
"!=",
"nil",
"&&",
"address",
"!=",
"*",
"update",
".",
"Address",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"supplied public key %v whose address %v does not match %v provided by\"",
"+",
"\"GovTx\"",
",",
"update",
".",
"PublicKey",
",",
"address",
",",
"update",
".",
"Address",
")",
"\n",
"}",
"\n",
"update",
".",
"Address",
"=",
"&",
"address",
"\n",
"}",
"else",
"if",
"update",
".",
"Balances",
"(",
")",
".",
"HasPower",
"(",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"GovTx must be provided with public key when updating validator power\"",
")",
"\n",
"}",
"\n",
"account",
",",
"err",
":=",
"getOrMakeOutput",
"(",
"ctx",
".",
"StateWriter",
",",
"accounts",
",",
"*",
"update",
".",
"Address",
",",
"ctx",
".",
"Logger",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"governAccountEvent",
",",
"err",
":=",
"ctx",
".",
"UpdateAccount",
"(",
"account",
",",
"update",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"txe",
".",
"GovernAccount",
"(",
"governAccountEvent",
",",
"errors",
".",
"AsException",
"(",
"err",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"txe",
".",
"GovernAccount",
"(",
"governAccountEvent",
",",
"nil",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // GovTx provides a set of TemplateAccounts and GovernanceContext tries to alter the chain state to match the
// specification given | [
"GovTx",
"provides",
"a",
"set",
"of",
"TemplateAccounts",
"and",
"GovernanceContext",
"tries",
"to",
"alter",
"the",
"chain",
"state",
"to",
"match",
"the",
"specification",
"given"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/contexts/governance_context.go#L29-L88 | train |
hyperledger/burrow | vent/sqldb/utils.go | findTable | func (db *SQLDB) findTable(tableName string) (bool, error) {
found := 0
safeTable := safe(tableName)
query := db.DBAdapter.FindTableQuery()
db.Log.Info("msg", "FIND TABLE", "query", query, "value", safeTable)
if err := db.DB.QueryRow(query, tableName).Scan(&found); err != nil {
db.Log.Info("msg", "Error finding table", "err", err)
return false, err
}
if found == 0 {
db.Log.Warn("msg", "Table not found", "value", safeTable)
return false, nil
}
return true, nil
} | go | func (db *SQLDB) findTable(tableName string) (bool, error) {
found := 0
safeTable := safe(tableName)
query := db.DBAdapter.FindTableQuery()
db.Log.Info("msg", "FIND TABLE", "query", query, "value", safeTable)
if err := db.DB.QueryRow(query, tableName).Scan(&found); err != nil {
db.Log.Info("msg", "Error finding table", "err", err)
return false, err
}
if found == 0 {
db.Log.Warn("msg", "Table not found", "value", safeTable)
return false, nil
}
return true, nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"findTable",
"(",
"tableName",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"found",
":=",
"0",
"\n",
"safeTable",
":=",
"safe",
"(",
"tableName",
")",
"\n",
"query",
":=",
"db",
".",
"DBAdapter",
".",
"FindTableQuery",
"(",
")",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"FIND TABLE\"",
",",
"\"query\"",
",",
"query",
",",
"\"value\"",
",",
"safeTable",
")",
"\n",
"if",
"err",
":=",
"db",
".",
"DB",
".",
"QueryRow",
"(",
"query",
",",
"tableName",
")",
".",
"Scan",
"(",
"&",
"found",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error finding table\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"found",
"==",
"0",
"{",
"db",
".",
"Log",
".",
"Warn",
"(",
"\"msg\"",
",",
"\"Table not found\"",
",",
"\"value\"",
",",
"safeTable",
")",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // findTable checks if a table exists in the default schema | [
"findTable",
"checks",
"if",
"a",
"table",
"exists",
"in",
"the",
"default",
"schema"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L19-L37 | train |
hyperledger/burrow | vent/sqldb/utils.go | getTableDef | func (db *SQLDB) getTableDef(tableName string) (*types.SQLTable, error) {
table := &types.SQLTable{
Name: safe(tableName),
}
found, err := db.findTable(table.Name)
if err != nil {
return nil, err
}
if !found {
db.Log.Info("msg", "Error table not found", "value", table.Name)
return nil, errors.New("Error table not found " + table.Name)
}
query := db.DBAdapter.TableDefinitionQuery()
db.Log.Info("msg", "QUERY STRUCTURE", "query", query, "value", table.Name)
rows, err := db.DB.Query(query, safe(tableName))
if err != nil {
db.Log.Info("msg", "Error querying table structure", "err", err)
return nil, err
}
defer rows.Close()
var columns []*types.SQLTableColumn
for rows.Next() {
var columnName string
var columnSQLType types.SQLColumnType
var columnIsPK int
var columnLength int
if err = rows.Scan(&columnName, &columnSQLType, &columnLength, &columnIsPK); err != nil {
db.Log.Info("msg", "Error scanning table structure", "err", err)
return nil, err
}
if _, err = db.DBAdapter.TypeMapping(columnSQLType); err != nil {
return nil, err
}
columns = append(columns, &types.SQLTableColumn{
Name: columnName,
Type: columnSQLType,
Length: columnLength,
Primary: columnIsPK == 1,
})
}
if err = rows.Err(); err != nil {
db.Log.Info("msg", "Error during rows iteration", "err", err)
return nil, err
}
table.Columns = columns
return table, nil
} | go | func (db *SQLDB) getTableDef(tableName string) (*types.SQLTable, error) {
table := &types.SQLTable{
Name: safe(tableName),
}
found, err := db.findTable(table.Name)
if err != nil {
return nil, err
}
if !found {
db.Log.Info("msg", "Error table not found", "value", table.Name)
return nil, errors.New("Error table not found " + table.Name)
}
query := db.DBAdapter.TableDefinitionQuery()
db.Log.Info("msg", "QUERY STRUCTURE", "query", query, "value", table.Name)
rows, err := db.DB.Query(query, safe(tableName))
if err != nil {
db.Log.Info("msg", "Error querying table structure", "err", err)
return nil, err
}
defer rows.Close()
var columns []*types.SQLTableColumn
for rows.Next() {
var columnName string
var columnSQLType types.SQLColumnType
var columnIsPK int
var columnLength int
if err = rows.Scan(&columnName, &columnSQLType, &columnLength, &columnIsPK); err != nil {
db.Log.Info("msg", "Error scanning table structure", "err", err)
return nil, err
}
if _, err = db.DBAdapter.TypeMapping(columnSQLType); err != nil {
return nil, err
}
columns = append(columns, &types.SQLTableColumn{
Name: columnName,
Type: columnSQLType,
Length: columnLength,
Primary: columnIsPK == 1,
})
}
if err = rows.Err(); err != nil {
db.Log.Info("msg", "Error during rows iteration", "err", err)
return nil, err
}
table.Columns = columns
return table, nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"getTableDef",
"(",
"tableName",
"string",
")",
"(",
"*",
"types",
".",
"SQLTable",
",",
"error",
")",
"{",
"table",
":=",
"&",
"types",
".",
"SQLTable",
"{",
"Name",
":",
"safe",
"(",
"tableName",
")",
",",
"}",
"\n",
"found",
",",
"err",
":=",
"db",
".",
"findTable",
"(",
"table",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error table not found\"",
",",
"\"value\"",
",",
"table",
".",
"Name",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"Error table not found \"",
"+",
"table",
".",
"Name",
")",
"\n",
"}",
"\n",
"query",
":=",
"db",
".",
"DBAdapter",
".",
"TableDefinitionQuery",
"(",
")",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"QUERY STRUCTURE\"",
",",
"\"query\"",
",",
"query",
",",
"\"value\"",
",",
"table",
".",
"Name",
")",
"\n",
"rows",
",",
"err",
":=",
"db",
".",
"DB",
".",
"Query",
"(",
"query",
",",
"safe",
"(",
"tableName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error querying table structure\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"rows",
".",
"Close",
"(",
")",
"\n",
"var",
"columns",
"[",
"]",
"*",
"types",
".",
"SQLTableColumn",
"\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"var",
"columnName",
"string",
"\n",
"var",
"columnSQLType",
"types",
".",
"SQLColumnType",
"\n",
"var",
"columnIsPK",
"int",
"\n",
"var",
"columnLength",
"int",
"\n",
"if",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"columnName",
",",
"&",
"columnSQLType",
",",
"&",
"columnLength",
",",
"&",
"columnIsPK",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error scanning table structure\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
"=",
"db",
".",
"DBAdapter",
".",
"TypeMapping",
"(",
"columnSQLType",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"columns",
"=",
"append",
"(",
"columns",
",",
"&",
"types",
".",
"SQLTableColumn",
"{",
"Name",
":",
"columnName",
",",
"Type",
":",
"columnSQLType",
",",
"Length",
":",
"columnLength",
",",
"Primary",
":",
"columnIsPK",
"==",
"1",
",",
"}",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"rows",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error during rows iteration\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"table",
".",
"Columns",
"=",
"columns",
"\n",
"return",
"table",
",",
"nil",
"\n",
"}"
] | // getTableDef returns the structure of a given SQL table | [
"getTableDef",
"returns",
"the",
"structure",
"of",
"a",
"given",
"SQL",
"table"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L176-L232 | train |
hyperledger/burrow | vent/sqldb/utils.go | alterTable | func (db *SQLDB) alterTable(table *types.SQLTable) error {
db.Log.Info("msg", "Altering table", "value", table.Name)
// prepare log query
logQuery := db.DBAdapter.InsertLogQuery()
// current table structure
safeTable := safe(table.Name)
currentTable, err := db.getTableDef(safeTable)
if err != nil {
return err
}
sqlValues, _ := db.getJSON(nil)
// for each column in the new table structure
for order, newColumn := range table.Columns {
found := false
// check if exists in the current table structure
for _, currentColumn := range currentTable.Columns {
// if column exists
if currentColumn.Name == newColumn.Name {
found = true
break
}
}
if !found {
safeCol := safe(newColumn.Name)
query, dictionary := db.DBAdapter.AlterColumnQuery(safeTable, safeCol, newColumn.Type, newColumn.Length, order)
//alter column
db.Log.Info("msg", "ALTER TABLE", "query", safe(query))
_, err = db.DB.Exec(safe(query))
if err != nil {
if db.DBAdapter.ErrorEquals(err, types.SQLErrorTypeDuplicatedColumn) {
db.Log.Warn("msg", "Duplicate column", "value", safeCol)
} else {
db.Log.Info("msg", "Error altering table", "err", err)
return err
}
} else {
//store dictionary
db.Log.Info("msg", "STORE DICTIONARY", "query", dictionary)
_, err = db.DB.Exec(dictionary)
if err != nil {
db.Log.Info("msg", "Error storing dictionary", "err", err)
return err
}
// Marshal the table into a JSON string.
var jsonData []byte
jsonData, err = db.getJSON(newColumn)
if err != nil {
db.Log.Info("msg", "error marshaling column", "err", err, "value", fmt.Sprintf("%v", newColumn))
return err
}
//insert log
_, err = db.DB.Exec(logQuery, table.Name, "", "", nil, nil, types.ActionAlterTable, jsonData, query, sqlValues)
if err != nil {
db.Log.Info("msg", "Error inserting log", "err", err)
return err
}
}
}
}
// Ensure triggers are defined
err = db.createTableTriggers(table)
if err != nil {
db.Log.Info("msg", "error creating notification triggers", "err", err, "value", fmt.Sprintf("%v", table))
return fmt.Errorf("could not create table notification triggers: %v", err)
}
return nil
} | go | func (db *SQLDB) alterTable(table *types.SQLTable) error {
db.Log.Info("msg", "Altering table", "value", table.Name)
// prepare log query
logQuery := db.DBAdapter.InsertLogQuery()
// current table structure
safeTable := safe(table.Name)
currentTable, err := db.getTableDef(safeTable)
if err != nil {
return err
}
sqlValues, _ := db.getJSON(nil)
// for each column in the new table structure
for order, newColumn := range table.Columns {
found := false
// check if exists in the current table structure
for _, currentColumn := range currentTable.Columns {
// if column exists
if currentColumn.Name == newColumn.Name {
found = true
break
}
}
if !found {
safeCol := safe(newColumn.Name)
query, dictionary := db.DBAdapter.AlterColumnQuery(safeTable, safeCol, newColumn.Type, newColumn.Length, order)
//alter column
db.Log.Info("msg", "ALTER TABLE", "query", safe(query))
_, err = db.DB.Exec(safe(query))
if err != nil {
if db.DBAdapter.ErrorEquals(err, types.SQLErrorTypeDuplicatedColumn) {
db.Log.Warn("msg", "Duplicate column", "value", safeCol)
} else {
db.Log.Info("msg", "Error altering table", "err", err)
return err
}
} else {
//store dictionary
db.Log.Info("msg", "STORE DICTIONARY", "query", dictionary)
_, err = db.DB.Exec(dictionary)
if err != nil {
db.Log.Info("msg", "Error storing dictionary", "err", err)
return err
}
// Marshal the table into a JSON string.
var jsonData []byte
jsonData, err = db.getJSON(newColumn)
if err != nil {
db.Log.Info("msg", "error marshaling column", "err", err, "value", fmt.Sprintf("%v", newColumn))
return err
}
//insert log
_, err = db.DB.Exec(logQuery, table.Name, "", "", nil, nil, types.ActionAlterTable, jsonData, query, sqlValues)
if err != nil {
db.Log.Info("msg", "Error inserting log", "err", err)
return err
}
}
}
}
// Ensure triggers are defined
err = db.createTableTriggers(table)
if err != nil {
db.Log.Info("msg", "error creating notification triggers", "err", err, "value", fmt.Sprintf("%v", table))
return fmt.Errorf("could not create table notification triggers: %v", err)
}
return nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"alterTable",
"(",
"table",
"*",
"types",
".",
"SQLTable",
")",
"error",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Altering table\"",
",",
"\"value\"",
",",
"table",
".",
"Name",
")",
"\n",
"logQuery",
":=",
"db",
".",
"DBAdapter",
".",
"InsertLogQuery",
"(",
")",
"\n",
"safeTable",
":=",
"safe",
"(",
"table",
".",
"Name",
")",
"\n",
"currentTable",
",",
"err",
":=",
"db",
".",
"getTableDef",
"(",
"safeTable",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"sqlValues",
",",
"_",
":=",
"db",
".",
"getJSON",
"(",
"nil",
")",
"\n",
"for",
"order",
",",
"newColumn",
":=",
"range",
"table",
".",
"Columns",
"{",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"currentColumn",
":=",
"range",
"currentTable",
".",
"Columns",
"{",
"if",
"currentColumn",
".",
"Name",
"==",
"newColumn",
".",
"Name",
"{",
"found",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"safeCol",
":=",
"safe",
"(",
"newColumn",
".",
"Name",
")",
"\n",
"query",
",",
"dictionary",
":=",
"db",
".",
"DBAdapter",
".",
"AlterColumnQuery",
"(",
"safeTable",
",",
"safeCol",
",",
"newColumn",
".",
"Type",
",",
"newColumn",
".",
"Length",
",",
"order",
")",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"ALTER TABLE\"",
",",
"\"query\"",
",",
"safe",
"(",
"query",
")",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"DB",
".",
"Exec",
"(",
"safe",
"(",
"query",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"db",
".",
"DBAdapter",
".",
"ErrorEquals",
"(",
"err",
",",
"types",
".",
"SQLErrorTypeDuplicatedColumn",
")",
"{",
"db",
".",
"Log",
".",
"Warn",
"(",
"\"msg\"",
",",
"\"Duplicate column\"",
",",
"\"value\"",
",",
"safeCol",
")",
"\n",
"}",
"else",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error altering table\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"STORE DICTIONARY\"",
",",
"\"query\"",
",",
"dictionary",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"DB",
".",
"Exec",
"(",
"dictionary",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error storing dictionary\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"var",
"jsonData",
"[",
"]",
"byte",
"\n",
"jsonData",
",",
"err",
"=",
"db",
".",
"getJSON",
"(",
"newColumn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"error marshaling column\"",
",",
"\"err\"",
",",
"err",
",",
"\"value\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"newColumn",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"DB",
".",
"Exec",
"(",
"logQuery",
",",
"table",
".",
"Name",
",",
"\"\"",
",",
"\"\"",
",",
"nil",
",",
"nil",
",",
"types",
".",
"ActionAlterTable",
",",
"jsonData",
",",
"query",
",",
"sqlValues",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error inserting log\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"=",
"db",
".",
"createTableTriggers",
"(",
"table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"error creating notification triggers\"",
",",
"\"err\"",
",",
"err",
",",
"\"value\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"table",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"could not create table notification triggers: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // alterTable alters the structure of a SQL table & add info to the dictionary | [
"alterTable",
"alters",
"the",
"structure",
"of",
"a",
"SQL",
"table",
"&",
"add",
"info",
"to",
"the",
"dictionary"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L235-L311 | train |
hyperledger/burrow | vent/sqldb/utils.go | createTable | func (db *SQLDB) createTable(table *types.SQLTable, isInitialise bool) error {
db.Log.Info("msg", "Creating Table", "value", table.Name)
// prepare log query
logQuery := db.DBAdapter.InsertLogQuery()
//get create table query
safeTable := safe(table.Name)
query, dictionary := db.DBAdapter.CreateTableQuery(safeTable, table.Columns)
if query == "" {
db.Log.Info("msg", "empty CREATE TABLE query")
return errors.New("empty CREATE TABLE query")
}
// create table
db.Log.Info("msg", "CREATE TABLE", "query", query)
_, err := db.DB.Exec(query)
if err != nil {
return err
}
//store dictionary
db.Log.Info("msg", "STORE DICTIONARY", "query", dictionary)
_, err = db.DB.Exec(dictionary)
if err != nil {
db.Log.Info("msg", "Error storing dictionary", "err", err)
return err
}
err = db.createTableTriggers(table)
if err != nil {
db.Log.Info("msg", "error creating notification triggers", "err", err, "value", fmt.Sprintf("%v", table))
return fmt.Errorf("could not create table notification triggers: %v", err)
}
//insert log (if action is not database initialization)
if !isInitialise {
// Marshal the table into a JSON string.
var jsonData []byte
jsonData, err = db.getJSON(table)
if err != nil {
db.Log.Info("msg", "error marshaling table", "err", err, "value", fmt.Sprintf("%v", table))
return err
}
sqlValues, _ := db.getJSON(nil)
//insert log
_, err = db.DB.Exec(logQuery, table.Name, "", "", nil, nil, types.ActionCreateTable, jsonData, query, sqlValues)
if err != nil {
db.Log.Info("msg", "Error inserting log", "err", err)
return err
}
}
return nil
} | go | func (db *SQLDB) createTable(table *types.SQLTable, isInitialise bool) error {
db.Log.Info("msg", "Creating Table", "value", table.Name)
// prepare log query
logQuery := db.DBAdapter.InsertLogQuery()
//get create table query
safeTable := safe(table.Name)
query, dictionary := db.DBAdapter.CreateTableQuery(safeTable, table.Columns)
if query == "" {
db.Log.Info("msg", "empty CREATE TABLE query")
return errors.New("empty CREATE TABLE query")
}
// create table
db.Log.Info("msg", "CREATE TABLE", "query", query)
_, err := db.DB.Exec(query)
if err != nil {
return err
}
//store dictionary
db.Log.Info("msg", "STORE DICTIONARY", "query", dictionary)
_, err = db.DB.Exec(dictionary)
if err != nil {
db.Log.Info("msg", "Error storing dictionary", "err", err)
return err
}
err = db.createTableTriggers(table)
if err != nil {
db.Log.Info("msg", "error creating notification triggers", "err", err, "value", fmt.Sprintf("%v", table))
return fmt.Errorf("could not create table notification triggers: %v", err)
}
//insert log (if action is not database initialization)
if !isInitialise {
// Marshal the table into a JSON string.
var jsonData []byte
jsonData, err = db.getJSON(table)
if err != nil {
db.Log.Info("msg", "error marshaling table", "err", err, "value", fmt.Sprintf("%v", table))
return err
}
sqlValues, _ := db.getJSON(nil)
//insert log
_, err = db.DB.Exec(logQuery, table.Name, "", "", nil, nil, types.ActionCreateTable, jsonData, query, sqlValues)
if err != nil {
db.Log.Info("msg", "Error inserting log", "err", err)
return err
}
}
return nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"createTable",
"(",
"table",
"*",
"types",
".",
"SQLTable",
",",
"isInitialise",
"bool",
")",
"error",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Creating Table\"",
",",
"\"value\"",
",",
"table",
".",
"Name",
")",
"\n",
"logQuery",
":=",
"db",
".",
"DBAdapter",
".",
"InsertLogQuery",
"(",
")",
"\n",
"safeTable",
":=",
"safe",
"(",
"table",
".",
"Name",
")",
"\n",
"query",
",",
"dictionary",
":=",
"db",
".",
"DBAdapter",
".",
"CreateTableQuery",
"(",
"safeTable",
",",
"table",
".",
"Columns",
")",
"\n",
"if",
"query",
"==",
"\"\"",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"empty CREATE TABLE query\"",
")",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"empty CREATE TABLE query\"",
")",
"\n",
"}",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"CREATE TABLE\"",
",",
"\"query\"",
",",
"query",
")",
"\n",
"_",
",",
"err",
":=",
"db",
".",
"DB",
".",
"Exec",
"(",
"query",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"STORE DICTIONARY\"",
",",
"\"query\"",
",",
"dictionary",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"DB",
".",
"Exec",
"(",
"dictionary",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error storing dictionary\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"db",
".",
"createTableTriggers",
"(",
"table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"error creating notification triggers\"",
",",
"\"err\"",
",",
"err",
",",
"\"value\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"table",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"could not create table notification triggers: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"isInitialise",
"{",
"var",
"jsonData",
"[",
"]",
"byte",
"\n",
"jsonData",
",",
"err",
"=",
"db",
".",
"getJSON",
"(",
"table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"error marshaling table\"",
",",
"\"err\"",
",",
"err",
",",
"\"value\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"table",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"sqlValues",
",",
"_",
":=",
"db",
".",
"getJSON",
"(",
"nil",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"DB",
".",
"Exec",
"(",
"logQuery",
",",
"table",
".",
"Name",
",",
"\"\"",
",",
"\"\"",
",",
"nil",
",",
"nil",
",",
"types",
".",
"ActionCreateTable",
",",
"jsonData",
",",
"query",
",",
"sqlValues",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error inserting log\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // createTable creates a new table | [
"createTable",
"creates",
"a",
"new",
"table"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L314-L368 | train |
hyperledger/burrow | vent/sqldb/utils.go | getSelectQuery | func (db *SQLDB) getSelectQuery(table *types.SQLTable, height uint64) (string, error) {
fields := ""
for _, tableColumn := range table.Columns {
if fields != "" {
fields += ", "
}
fields += db.DBAdapter.SecureName(tableColumn.Name)
}
if fields == "" {
return "", errors.New("error table does not contain any fields")
}
query := db.DBAdapter.SelectRowQuery(table.Name, fields, strconv.FormatUint(height, 10))
return query, nil
} | go | func (db *SQLDB) getSelectQuery(table *types.SQLTable, height uint64) (string, error) {
fields := ""
for _, tableColumn := range table.Columns {
if fields != "" {
fields += ", "
}
fields += db.DBAdapter.SecureName(tableColumn.Name)
}
if fields == "" {
return "", errors.New("error table does not contain any fields")
}
query := db.DBAdapter.SelectRowQuery(table.Name, fields, strconv.FormatUint(height, 10))
return query, nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"getSelectQuery",
"(",
"table",
"*",
"types",
".",
"SQLTable",
",",
"height",
"uint64",
")",
"(",
"string",
",",
"error",
")",
"{",
"fields",
":=",
"\"\"",
"\n",
"for",
"_",
",",
"tableColumn",
":=",
"range",
"table",
".",
"Columns",
"{",
"if",
"fields",
"!=",
"\"\"",
"{",
"fields",
"+=",
"\", \"",
"\n",
"}",
"\n",
"fields",
"+=",
"db",
".",
"DBAdapter",
".",
"SecureName",
"(",
"tableColumn",
".",
"Name",
")",
"\n",
"}",
"\n",
"if",
"fields",
"==",
"\"\"",
"{",
"return",
"\"\"",
",",
"errors",
".",
"New",
"(",
"\"error table does not contain any fields\"",
")",
"\n",
"}",
"\n",
"query",
":=",
"db",
".",
"DBAdapter",
".",
"SelectRowQuery",
"(",
"table",
".",
"Name",
",",
"fields",
",",
"strconv",
".",
"FormatUint",
"(",
"height",
",",
"10",
")",
")",
"\n",
"return",
"query",
",",
"nil",
"\n",
"}"
] | // getSelectQuery builds a select query for a specific SQL table and a given block | [
"getSelectQuery",
"builds",
"a",
"select",
"query",
"for",
"a",
"specific",
"SQL",
"table",
"and",
"a",
"given",
"block"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L398-L415 | train |
hyperledger/burrow | vent/sqldb/utils.go | getBlockTables | func (db *SQLDB) getBlockTables(height uint64) (types.EventTables, error) {
tables := make(types.EventTables)
query := db.DBAdapter.SelectLogQuery()
db.Log.Info("msg", "QUERY LOG", "query", query, "value", height)
rows, err := db.DB.Query(query, height)
if err != nil {
db.Log.Info("msg", "Error querying log", "err", err)
return tables, err
}
defer rows.Close()
for rows.Next() {
var eventName, tableName string
var table *types.SQLTable
err = rows.Scan(&tableName, &eventName)
if err != nil {
db.Log.Info("msg", "Error scanning table structure", "err", err)
return tables, err
}
err = rows.Err()
if err != nil {
db.Log.Info("msg", "Error scanning table structure", "err", err)
return tables, err
}
table, err = db.getTableDef(tableName)
if err != nil {
return tables, err
}
tables[tableName] = table
}
return tables, nil
} | go | func (db *SQLDB) getBlockTables(height uint64) (types.EventTables, error) {
tables := make(types.EventTables)
query := db.DBAdapter.SelectLogQuery()
db.Log.Info("msg", "QUERY LOG", "query", query, "value", height)
rows, err := db.DB.Query(query, height)
if err != nil {
db.Log.Info("msg", "Error querying log", "err", err)
return tables, err
}
defer rows.Close()
for rows.Next() {
var eventName, tableName string
var table *types.SQLTable
err = rows.Scan(&tableName, &eventName)
if err != nil {
db.Log.Info("msg", "Error scanning table structure", "err", err)
return tables, err
}
err = rows.Err()
if err != nil {
db.Log.Info("msg", "Error scanning table structure", "err", err)
return tables, err
}
table, err = db.getTableDef(tableName)
if err != nil {
return tables, err
}
tables[tableName] = table
}
return tables, nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"getBlockTables",
"(",
"height",
"uint64",
")",
"(",
"types",
".",
"EventTables",
",",
"error",
")",
"{",
"tables",
":=",
"make",
"(",
"types",
".",
"EventTables",
")",
"\n",
"query",
":=",
"db",
".",
"DBAdapter",
".",
"SelectLogQuery",
"(",
")",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"QUERY LOG\"",
",",
"\"query\"",
",",
"query",
",",
"\"value\"",
",",
"height",
")",
"\n",
"rows",
",",
"err",
":=",
"db",
".",
"DB",
".",
"Query",
"(",
"query",
",",
"height",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error querying log\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"tables",
",",
"err",
"\n",
"}",
"\n",
"defer",
"rows",
".",
"Close",
"(",
")",
"\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"var",
"eventName",
",",
"tableName",
"string",
"\n",
"var",
"table",
"*",
"types",
".",
"SQLTable",
"\n",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"tableName",
",",
"&",
"eventName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error scanning table structure\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"tables",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"rows",
".",
"Err",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error scanning table structure\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"tables",
",",
"err",
"\n",
"}",
"\n",
"table",
",",
"err",
"=",
"db",
".",
"getTableDef",
"(",
"tableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"tables",
",",
"err",
"\n",
"}",
"\n",
"tables",
"[",
"tableName",
"]",
"=",
"table",
"\n",
"}",
"\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] | // getBlockTables return all SQL tables that have been involved
// in a given batch transaction for a specific block | [
"getBlockTables",
"return",
"all",
"SQL",
"tables",
"that",
"have",
"been",
"involved",
"in",
"a",
"given",
"batch",
"transaction",
"for",
"a",
"specific",
"block"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L419-L457 | train |
hyperledger/burrow | vent/sqldb/utils.go | safe | func safe(parameter string) string {
replacer := strings.NewReplacer(";", "", ",", "")
return replacer.Replace(parameter)
} | go | func safe(parameter string) string {
replacer := strings.NewReplacer(";", "", ",", "")
return replacer.Replace(parameter)
} | [
"func",
"safe",
"(",
"parameter",
"string",
")",
"string",
"{",
"replacer",
":=",
"strings",
".",
"NewReplacer",
"(",
"\";\"",
",",
"\"\"",
",",
"\",\"",
",",
"\"\"",
")",
"\n",
"return",
"replacer",
".",
"Replace",
"(",
"parameter",
")",
"\n",
"}"
] | // safe sanitizes a parameter | [
"safe",
"sanitizes",
"a",
"parameter"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L460-L463 | train |
hyperledger/burrow | vent/sqldb/utils.go | getJSON | func (db *SQLDB) getJSON(JSON interface{}) ([]byte, error) {
if JSON != nil {
return json.Marshal(JSON)
}
return json.Marshal("")
} | go | func (db *SQLDB) getJSON(JSON interface{}) ([]byte, error) {
if JSON != nil {
return json.Marshal(JSON)
}
return json.Marshal("")
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"getJSON",
"(",
"JSON",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"JSON",
"!=",
"nil",
"{",
"return",
"json",
".",
"Marshal",
"(",
"JSON",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"\"\"",
")",
"\n",
"}"
] | //getJSON returns marshaled json from JSON single column | [
"getJSON",
"returns",
"marshaled",
"json",
"from",
"JSON",
"single",
"column"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L466-L471 | train |
hyperledger/burrow | vent/sqldb/utils.go | getJSONFromValues | func (db *SQLDB) getJSONFromValues(values []interface{}) ([]byte, error) {
if values != nil {
return json.Marshal(values)
}
return json.Marshal("")
} | go | func (db *SQLDB) getJSONFromValues(values []interface{}) ([]byte, error) {
if values != nil {
return json.Marshal(values)
}
return json.Marshal("")
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"getJSONFromValues",
"(",
"values",
"[",
"]",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"values",
"!=",
"nil",
"{",
"return",
"json",
".",
"Marshal",
"(",
"values",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"\"\"",
")",
"\n",
"}"
] | //getJSONFromValues returns marshaled json from query values | [
"getJSONFromValues",
"returns",
"marshaled",
"json",
"from",
"query",
"values"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L474-L479 | train |
hyperledger/burrow | vent/sqldb/utils.go | getValuesFromJSON | func (db *SQLDB) getValuesFromJSON(JSON string) ([]interface{}, error) {
pointers := make([]interface{}, 0)
bytes := []byte(JSON)
err := json.Unmarshal(bytes, &pointers)
return pointers, err
} | go | func (db *SQLDB) getValuesFromJSON(JSON string) ([]interface{}, error) {
pointers := make([]interface{}, 0)
bytes := []byte(JSON)
err := json.Unmarshal(bytes, &pointers)
return pointers, err
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"getValuesFromJSON",
"(",
"JSON",
"string",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"pointers",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"bytes",
":=",
"[",
"]",
"byte",
"(",
"JSON",
")",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"pointers",
")",
"\n",
"return",
"pointers",
",",
"err",
"\n",
"}"
] | //getValuesFromJSON returns query values from unmarshaled JSON column | [
"getValuesFromJSON",
"returns",
"query",
"values",
"from",
"unmarshaled",
"JSON",
"column"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/utils.go#L482-L487 | train |
hyperledger/burrow | execution/errors/errors.go | AsException | func AsException(err error) *Exception {
if err == nil {
return nil
}
switch e := err.(type) {
case *Exception:
return e
case CodedError:
return NewException(e.ErrorCode(), e.String())
default:
return NewException(ErrorCodeGeneric, err.Error())
}
} | go | func AsException(err error) *Exception {
if err == nil {
return nil
}
switch e := err.(type) {
case *Exception:
return e
case CodedError:
return NewException(e.ErrorCode(), e.String())
default:
return NewException(ErrorCodeGeneric, err.Error())
}
} | [
"func",
"AsException",
"(",
"err",
"error",
")",
"*",
"Exception",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"switch",
"e",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Exception",
":",
"return",
"e",
"\n",
"case",
"CodedError",
":",
"return",
"NewException",
"(",
"e",
".",
"ErrorCode",
"(",
")",
",",
"e",
".",
"String",
"(",
")",
")",
"\n",
"default",
":",
"return",
"NewException",
"(",
"ErrorCodeGeneric",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Wraps any error as a Exception | [
"Wraps",
"any",
"error",
"as",
"a",
"Exception"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/errors/errors.go#L171-L183 | train |
hyperledger/burrow | crypto/private_key.go | PublicKeyFromBytes | func PublicKeyFromBytes(bs []byte, curveType CurveType) (PublicKey, error) {
switch curveType {
case CurveTypeEd25519:
if len(bs) != ed25519.PublicKeySize {
return PublicKey{}, fmt.Errorf("bytes passed have length %v but ed25519 public keys have %v bytes",
len(bs), ed25519.PublicKeySize)
}
case CurveTypeSecp256k1:
if len(bs) != btcec.PubKeyBytesLenCompressed {
return PublicKey{}, fmt.Errorf("bytes passed have length %v but secp256k1 public keys have %v bytes",
len(bs), btcec.PubKeyBytesLenCompressed)
}
case CurveTypeUnset:
if len(bs) > 0 {
return PublicKey{}, fmt.Errorf("attempting to create an 'unset' PublicKey but passed non-empty key bytes: %X", bs)
}
return PublicKey{}, nil
default:
return PublicKey{}, ErrInvalidCurve(curveType)
}
return PublicKey{PublicKey: bs, CurveType: curveType}, nil
} | go | func PublicKeyFromBytes(bs []byte, curveType CurveType) (PublicKey, error) {
switch curveType {
case CurveTypeEd25519:
if len(bs) != ed25519.PublicKeySize {
return PublicKey{}, fmt.Errorf("bytes passed have length %v but ed25519 public keys have %v bytes",
len(bs), ed25519.PublicKeySize)
}
case CurveTypeSecp256k1:
if len(bs) != btcec.PubKeyBytesLenCompressed {
return PublicKey{}, fmt.Errorf("bytes passed have length %v but secp256k1 public keys have %v bytes",
len(bs), btcec.PubKeyBytesLenCompressed)
}
case CurveTypeUnset:
if len(bs) > 0 {
return PublicKey{}, fmt.Errorf("attempting to create an 'unset' PublicKey but passed non-empty key bytes: %X", bs)
}
return PublicKey{}, nil
default:
return PublicKey{}, ErrInvalidCurve(curveType)
}
return PublicKey{PublicKey: bs, CurveType: curveType}, nil
} | [
"func",
"PublicKeyFromBytes",
"(",
"bs",
"[",
"]",
"byte",
",",
"curveType",
"CurveType",
")",
"(",
"PublicKey",
",",
"error",
")",
"{",
"switch",
"curveType",
"{",
"case",
"CurveTypeEd25519",
":",
"if",
"len",
"(",
"bs",
")",
"!=",
"ed25519",
".",
"PublicKeySize",
"{",
"return",
"PublicKey",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"bytes passed have length %v but ed25519 public keys have %v bytes\"",
",",
"len",
"(",
"bs",
")",
",",
"ed25519",
".",
"PublicKeySize",
")",
"\n",
"}",
"\n",
"case",
"CurveTypeSecp256k1",
":",
"if",
"len",
"(",
"bs",
")",
"!=",
"btcec",
".",
"PubKeyBytesLenCompressed",
"{",
"return",
"PublicKey",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"bytes passed have length %v but secp256k1 public keys have %v bytes\"",
",",
"len",
"(",
"bs",
")",
",",
"btcec",
".",
"PubKeyBytesLenCompressed",
")",
"\n",
"}",
"\n",
"case",
"CurveTypeUnset",
":",
"if",
"len",
"(",
"bs",
")",
">",
"0",
"{",
"return",
"PublicKey",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"attempting to create an 'unset' PublicKey but passed non-empty key bytes: %X\"",
",",
"bs",
")",
"\n",
"}",
"\n",
"return",
"PublicKey",
"{",
"}",
",",
"nil",
"\n",
"default",
":",
"return",
"PublicKey",
"{",
"}",
",",
"ErrInvalidCurve",
"(",
"curveType",
")",
"\n",
"}",
"\n",
"return",
"PublicKey",
"{",
"PublicKey",
":",
"bs",
",",
"CurveType",
":",
"curveType",
"}",
",",
"nil",
"\n",
"}"
] | // Currently this is a stub that reads the raw bytes returned by key_client and returns
// an ed25519 public key. | [
"Currently",
"this",
"is",
"a",
"stub",
"that",
"reads",
"the",
"raw",
"bytes",
"returned",
"by",
"key_client",
"and",
"returns",
"an",
"ed25519",
"public",
"key",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/crypto/private_key.go#L16-L38 | train |
hyperledger/burrow | crypto/private_key.go | Reinitialise | func (p *PrivateKey) Reinitialise() error {
initP, err := PrivateKeyFromRawBytes(p.RawBytes(), p.CurveType)
if err != nil {
return err
}
*p = initP
return nil
} | go | func (p *PrivateKey) Reinitialise() error {
initP, err := PrivateKeyFromRawBytes(p.RawBytes(), p.CurveType)
if err != nil {
return err
}
*p = initP
return nil
} | [
"func",
"(",
"p",
"*",
"PrivateKey",
")",
"Reinitialise",
"(",
")",
"error",
"{",
"initP",
",",
"err",
":=",
"PrivateKeyFromRawBytes",
"(",
"p",
".",
"RawBytes",
"(",
")",
",",
"p",
".",
"CurveType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"*",
"p",
"=",
"initP",
"\n",
"return",
"nil",
"\n",
"}"
] | // Reinitialise after serialisation | [
"Reinitialise",
"after",
"serialisation"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/crypto/private_key.go#L74-L81 | train |
hyperledger/burrow | crypto/private_key.go | EnsureEd25519PrivateKeyCorrect | func EnsureEd25519PrivateKeyCorrect(candidatePrivateKey ed25519.PrivateKey) error {
if len(candidatePrivateKey) != ed25519.PrivateKeySize {
return fmt.Errorf("ed25519 key has size %v but %v bytes passed as key", ed25519.PrivateKeySize,
len(candidatePrivateKey))
}
_, derivedPrivateKey, err := ed25519.GenerateKey(bytes.NewBuffer(candidatePrivateKey))
if err != nil {
return err
}
if !bytes.Equal(derivedPrivateKey, candidatePrivateKey) {
return fmt.Errorf("ed25519 key generated from prefix of %X should equal %X, but is %X",
candidatePrivateKey, candidatePrivateKey, derivedPrivateKey)
}
return nil
} | go | func EnsureEd25519PrivateKeyCorrect(candidatePrivateKey ed25519.PrivateKey) error {
if len(candidatePrivateKey) != ed25519.PrivateKeySize {
return fmt.Errorf("ed25519 key has size %v but %v bytes passed as key", ed25519.PrivateKeySize,
len(candidatePrivateKey))
}
_, derivedPrivateKey, err := ed25519.GenerateKey(bytes.NewBuffer(candidatePrivateKey))
if err != nil {
return err
}
if !bytes.Equal(derivedPrivateKey, candidatePrivateKey) {
return fmt.Errorf("ed25519 key generated from prefix of %X should equal %X, but is %X",
candidatePrivateKey, candidatePrivateKey, derivedPrivateKey)
}
return nil
} | [
"func",
"EnsureEd25519PrivateKeyCorrect",
"(",
"candidatePrivateKey",
"ed25519",
".",
"PrivateKey",
")",
"error",
"{",
"if",
"len",
"(",
"candidatePrivateKey",
")",
"!=",
"ed25519",
".",
"PrivateKeySize",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"ed25519 key has size %v but %v bytes passed as key\"",
",",
"ed25519",
".",
"PrivateKeySize",
",",
"len",
"(",
"candidatePrivateKey",
")",
")",
"\n",
"}",
"\n",
"_",
",",
"derivedPrivateKey",
",",
"err",
":=",
"ed25519",
".",
"GenerateKey",
"(",
"bytes",
".",
"NewBuffer",
"(",
"candidatePrivateKey",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"bytes",
".",
"Equal",
"(",
"derivedPrivateKey",
",",
"candidatePrivateKey",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"ed25519 key generated from prefix of %X should equal %X, but is %X\"",
",",
"candidatePrivateKey",
",",
"candidatePrivateKey",
",",
"derivedPrivateKey",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Ensures the last 32 bytes of the ed25519 private key is the public key derived from the first 32 private bytes | [
"Ensures",
"the",
"last",
"32",
"bytes",
"of",
"the",
"ed25519",
"private",
"key",
"is",
"the",
"public",
"key",
"derived",
"from",
"the",
"first",
"32",
"private",
"bytes"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/crypto/private_key.go#L142-L156 | train |
hyperledger/burrow | storage/content_addressed_store.go | Put | func (cas *ContentAddressedStore) Put(data []byte) ([]byte, error) {
hasher := sha256.New()
_, err := hasher.Write(data)
if err != nil {
return nil, fmt.Errorf("ContentAddressedStore could not hash data: %v", err)
}
hash := hasher.Sum(nil)
cas.db.SetSync(hash, data)
return hash, nil
} | go | func (cas *ContentAddressedStore) Put(data []byte) ([]byte, error) {
hasher := sha256.New()
_, err := hasher.Write(data)
if err != nil {
return nil, fmt.Errorf("ContentAddressedStore could not hash data: %v", err)
}
hash := hasher.Sum(nil)
cas.db.SetSync(hash, data)
return hash, nil
} | [
"func",
"(",
"cas",
"*",
"ContentAddressedStore",
")",
"Put",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"hasher",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"hasher",
".",
"Write",
"(",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"ContentAddressedStore could not hash data: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"hash",
":=",
"hasher",
".",
"Sum",
"(",
"nil",
")",
"\n",
"cas",
".",
"db",
".",
"SetSync",
"(",
"hash",
",",
"data",
")",
"\n",
"return",
"hash",
",",
"nil",
"\n",
"}"
] | // These function match those used in Hoard
// Put data in the database by saving data with a key that is its sha256 hash | [
"These",
"function",
"match",
"those",
"used",
"in",
"Hoard",
"Put",
"data",
"in",
"the",
"database",
"by",
"saving",
"data",
"with",
"a",
"key",
"that",
"is",
"its",
"sha256",
"hash"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/storage/content_addressed_store.go#L24-L33 | train |
hyperledger/burrow | logging/logconfig/presets/instructions.go | push | func push(stack []*logconfig.SinkConfig, sinkConfigs ...*logconfig.SinkConfig) []*logconfig.SinkConfig {
for _, sinkConfig := range sinkConfigs {
peek(stack).AddSinks(sinkConfig)
stack = append(stack, sinkConfig)
}
return stack
} | go | func push(stack []*logconfig.SinkConfig, sinkConfigs ...*logconfig.SinkConfig) []*logconfig.SinkConfig {
for _, sinkConfig := range sinkConfigs {
peek(stack).AddSinks(sinkConfig)
stack = append(stack, sinkConfig)
}
return stack
} | [
"func",
"push",
"(",
"stack",
"[",
"]",
"*",
"logconfig",
".",
"SinkConfig",
",",
"sinkConfigs",
"...",
"*",
"logconfig",
".",
"SinkConfig",
")",
"[",
"]",
"*",
"logconfig",
".",
"SinkConfig",
"{",
"for",
"_",
",",
"sinkConfig",
":=",
"range",
"sinkConfigs",
"{",
"peek",
"(",
"stack",
")",
".",
"AddSinks",
"(",
"sinkConfig",
")",
"\n",
"stack",
"=",
"append",
"(",
"stack",
",",
"sinkConfig",
")",
"\n",
"}",
"\n",
"return",
"stack",
"\n",
"}"
] | // Push a path sequence of sinks onto the stack | [
"Push",
"a",
"path",
"sequence",
"of",
"sinks",
"onto",
"the",
"stack"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/logging/logconfig/presets/instructions.go#L266-L272 | train |
hyperledger/burrow | vent/service/consumer.go | NewConsumer | func NewConsumer(cfg *config.VentConfig, log *logger.Logger, eventChannel chan types.EventData) *Consumer {
return &Consumer{
Config: cfg,
Log: log,
Closing: false,
EventsChannel: eventChannel,
}
} | go | func NewConsumer(cfg *config.VentConfig, log *logger.Logger, eventChannel chan types.EventData) *Consumer {
return &Consumer{
Config: cfg,
Log: log,
Closing: false,
EventsChannel: eventChannel,
}
} | [
"func",
"NewConsumer",
"(",
"cfg",
"*",
"config",
".",
"VentConfig",
",",
"log",
"*",
"logger",
".",
"Logger",
",",
"eventChannel",
"chan",
"types",
".",
"EventData",
")",
"*",
"Consumer",
"{",
"return",
"&",
"Consumer",
"{",
"Config",
":",
"cfg",
",",
"Log",
":",
"log",
",",
"Closing",
":",
"false",
",",
"EventsChannel",
":",
"eventChannel",
",",
"}",
"\n",
"}"
] | // NewConsumer constructs a new consumer configuration.
// The event channel will be passed a collection of rows generated from all of the events in a single block
// It will be closed by the consumer when it is finished | [
"NewConsumer",
"constructs",
"a",
"new",
"consumer",
"configuration",
".",
"The",
"event",
"channel",
"will",
"be",
"passed",
"a",
"collection",
"of",
"rows",
"generated",
"from",
"all",
"of",
"the",
"events",
"in",
"a",
"single",
"block",
"It",
"will",
"be",
"closed",
"by",
"the",
"consumer",
"when",
"it",
"is",
"finished"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/service/consumer.go#L47-L54 | train |
hyperledger/burrow | vent/service/consumer.go | Health | func (c *Consumer) Health() error {
if c.Closing {
return errors.New("closing service")
}
// check db status
if c.DB == nil {
return errors.New("database disconnected")
}
if err := c.DB.Ping(); err != nil {
return errors.New("database unavailable")
}
// check grpc connection status
if c.GRPCConnection == nil {
return errors.New("grpc disconnected")
}
if grpcState := c.GRPCConnection.GetState(); grpcState != connectivity.Ready {
return errors.New("grpc connection not ready")
}
return nil
} | go | func (c *Consumer) Health() error {
if c.Closing {
return errors.New("closing service")
}
// check db status
if c.DB == nil {
return errors.New("database disconnected")
}
if err := c.DB.Ping(); err != nil {
return errors.New("database unavailable")
}
// check grpc connection status
if c.GRPCConnection == nil {
return errors.New("grpc disconnected")
}
if grpcState := c.GRPCConnection.GetState(); grpcState != connectivity.Ready {
return errors.New("grpc connection not ready")
}
return nil
} | [
"func",
"(",
"c",
"*",
"Consumer",
")",
"Health",
"(",
")",
"error",
"{",
"if",
"c",
".",
"Closing",
"{",
"return",
"errors",
".",
"New",
"(",
"\"closing service\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"DB",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"database disconnected\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"DB",
".",
"Ping",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"database unavailable\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"GRPCConnection",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"grpc disconnected\"",
")",
"\n",
"}",
"\n",
"if",
"grpcState",
":=",
"c",
".",
"GRPCConnection",
".",
"GetState",
"(",
")",
";",
"grpcState",
"!=",
"connectivity",
".",
"Ready",
"{",
"return",
"errors",
".",
"New",
"(",
"\"grpc connection not ready\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Health returns the health status for the consumer | [
"Health",
"returns",
"the",
"health",
"status",
"for",
"the",
"consumer"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/service/consumer.go#L320-L344 | train |
hyperledger/burrow | vent/service/consumer.go | Shutdown | func (c *Consumer) Shutdown() {
c.Log.Info("msg", "Shutting down vent consumer...")
c.Closing = true
c.GRPCConnection.Close()
} | go | func (c *Consumer) Shutdown() {
c.Log.Info("msg", "Shutting down vent consumer...")
c.Closing = true
c.GRPCConnection.Close()
} | [
"func",
"(",
"c",
"*",
"Consumer",
")",
"Shutdown",
"(",
")",
"{",
"c",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Shutting down vent consumer...\"",
")",
"\n",
"c",
".",
"Closing",
"=",
"true",
"\n",
"c",
".",
"GRPCConnection",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Shutdown gracefully shuts down the events consumer | [
"Shutdown",
"gracefully",
"shuts",
"down",
"the",
"events",
"consumer"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/service/consumer.go#L347-L351 | train |
hyperledger/burrow | vent/sqlsol/block_data.go | NewBlockData | func NewBlockData(height uint64) *BlockData {
data := types.EventData{
Tables: make(map[string]types.EventDataTable),
BlockHeight: height,
}
return &BlockData{
Data: data,
}
} | go | func NewBlockData(height uint64) *BlockData {
data := types.EventData{
Tables: make(map[string]types.EventDataTable),
BlockHeight: height,
}
return &BlockData{
Data: data,
}
} | [
"func",
"NewBlockData",
"(",
"height",
"uint64",
")",
"*",
"BlockData",
"{",
"data",
":=",
"types",
".",
"EventData",
"{",
"Tables",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"types",
".",
"EventDataTable",
")",
",",
"BlockHeight",
":",
"height",
",",
"}",
"\n",
"return",
"&",
"BlockData",
"{",
"Data",
":",
"data",
",",
"}",
"\n",
"}"
] | // NewBlockData returns a pointer to an empty BlockData structure | [
"NewBlockData",
"returns",
"a",
"pointer",
"to",
"an",
"empty",
"BlockData",
"structure"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqlsol/block_data.go#L15-L24 | train |
hyperledger/burrow | vent/sqlsol/block_data.go | AddRow | func (b *BlockData) AddRow(tableName string, row types.EventDataRow) {
if _, ok := b.Data.Tables[tableName]; !ok {
b.Data.Tables[tableName] = types.EventDataTable{}
}
b.Data.Tables[tableName] = append(b.Data.Tables[tableName], row)
} | go | func (b *BlockData) AddRow(tableName string, row types.EventDataRow) {
if _, ok := b.Data.Tables[tableName]; !ok {
b.Data.Tables[tableName] = types.EventDataTable{}
}
b.Data.Tables[tableName] = append(b.Data.Tables[tableName], row)
} | [
"func",
"(",
"b",
"*",
"BlockData",
")",
"AddRow",
"(",
"tableName",
"string",
",",
"row",
"types",
".",
"EventDataRow",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"b",
".",
"Data",
".",
"Tables",
"[",
"tableName",
"]",
";",
"!",
"ok",
"{",
"b",
".",
"Data",
".",
"Tables",
"[",
"tableName",
"]",
"=",
"types",
".",
"EventDataTable",
"{",
"}",
"\n",
"}",
"\n",
"b",
".",
"Data",
".",
"Tables",
"[",
"tableName",
"]",
"=",
"append",
"(",
"b",
".",
"Data",
".",
"Tables",
"[",
"tableName",
"]",
",",
"row",
")",
"\n",
"}"
] | // AddRow appends a row to a specific table name in structure | [
"AddRow",
"appends",
"a",
"row",
"to",
"a",
"specific",
"table",
"name",
"in",
"structure"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqlsol/block_data.go#L27-L32 | train |
hyperledger/burrow | vent/sqlsol/block_data.go | GetRows | func (b *BlockData) GetRows(tableName string) (types.EventDataTable, error) {
if table, ok := b.Data.Tables[tableName]; ok {
return table, nil
}
return nil, fmt.Errorf("GetRows: tableName does not exists as a table in data structure: %s ", tableName)
} | go | func (b *BlockData) GetRows(tableName string) (types.EventDataTable, error) {
if table, ok := b.Data.Tables[tableName]; ok {
return table, nil
}
return nil, fmt.Errorf("GetRows: tableName does not exists as a table in data structure: %s ", tableName)
} | [
"func",
"(",
"b",
"*",
"BlockData",
")",
"GetRows",
"(",
"tableName",
"string",
")",
"(",
"types",
".",
"EventDataTable",
",",
"error",
")",
"{",
"if",
"table",
",",
"ok",
":=",
"b",
".",
"Data",
".",
"Tables",
"[",
"tableName",
"]",
";",
"ok",
"{",
"return",
"table",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"GetRows: tableName does not exists as a table in data structure: %s \"",
",",
"tableName",
")",
"\n",
"}"
] | // GetRows gets data rows for a given table name from structure | [
"GetRows",
"gets",
"data",
"rows",
"for",
"a",
"given",
"table",
"name",
"from",
"structure"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqlsol/block_data.go#L35-L40 | train |
hyperledger/burrow | vent/sqlsol/block_data.go | PendingRows | func (b *BlockData) PendingRows(height uint64) bool {
hasRows := false
// TODO: understand why the guard on height is needed - what does it prevent?
if b.Data.BlockHeight == height && len(b.Data.Tables) > 0 {
hasRows = true
}
return hasRows
} | go | func (b *BlockData) PendingRows(height uint64) bool {
hasRows := false
// TODO: understand why the guard on height is needed - what does it prevent?
if b.Data.BlockHeight == height && len(b.Data.Tables) > 0 {
hasRows = true
}
return hasRows
} | [
"func",
"(",
"b",
"*",
"BlockData",
")",
"PendingRows",
"(",
"height",
"uint64",
")",
"bool",
"{",
"hasRows",
":=",
"false",
"\n",
"if",
"b",
".",
"Data",
".",
"BlockHeight",
"==",
"height",
"&&",
"len",
"(",
"b",
".",
"Data",
".",
"Tables",
")",
">",
"0",
"{",
"hasRows",
"=",
"true",
"\n",
"}",
"\n",
"return",
"hasRows",
"\n",
"}"
] | // PendingRows returns true if the given block has at least one pending row to upsert | [
"PendingRows",
"returns",
"true",
"if",
"the",
"given",
"block",
"has",
"at",
"least",
"one",
"pending",
"row",
"to",
"upsert"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqlsol/block_data.go#L43-L50 | train |
hyperledger/burrow | execution/evm/memory.go | NewDynamicMemory | func NewDynamicMemory(initialCapacity, maximumCapacity uint64, errSink errors.Sink) Memory {
return &dynamicMemory{
slice: make([]byte, initialCapacity),
maximumCapacity: maximumCapacity,
errSink: errSink,
}
} | go | func NewDynamicMemory(initialCapacity, maximumCapacity uint64, errSink errors.Sink) Memory {
return &dynamicMemory{
slice: make([]byte, initialCapacity),
maximumCapacity: maximumCapacity,
errSink: errSink,
}
} | [
"func",
"NewDynamicMemory",
"(",
"initialCapacity",
",",
"maximumCapacity",
"uint64",
",",
"errSink",
"errors",
".",
"Sink",
")",
"Memory",
"{",
"return",
"&",
"dynamicMemory",
"{",
"slice",
":",
"make",
"(",
"[",
"]",
"byte",
",",
"initialCapacity",
")",
",",
"maximumCapacity",
":",
"maximumCapacity",
",",
"errSink",
":",
"errSink",
",",
"}",
"\n",
"}"
] | // Get a new DynamicMemory (note that although we take a maximumCapacity of uint64 we currently
// limit the maximum to int32 at runtime because we are using a single slice which we cannot guarantee
// to be indexable above int32 or all validators | [
"Get",
"a",
"new",
"DynamicMemory",
"(",
"note",
"that",
"although",
"we",
"take",
"a",
"maximumCapacity",
"of",
"uint64",
"we",
"currently",
"limit",
"the",
"maximum",
"to",
"int32",
"at",
"runtime",
"because",
"we",
"are",
"using",
"a",
"single",
"slice",
"which",
"we",
"cannot",
"guarantee",
"to",
"be",
"indexable",
"above",
"int32",
"or",
"all",
"validators"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/evm/memory.go#L48-L54 | train |
hyperledger/burrow | execution/simulated_call.go | CallSim | func CallSim(reader acmstate.Reader, tip bcm.BlockchainInfo, fromAddress, address crypto.Address, data []byte,
logger *logging.Logger) (*exec.TxExecution, error) {
cache := acmstate.NewCache(reader)
exe := contexts.CallContext{
RunCall: true,
StateWriter: cache,
Blockchain: tip,
Logger: logger,
}
txe := exec.NewTxExecution(txs.Enclose(tip.ChainID(), &payload.CallTx{
Input: &payload.TxInput{
Address: fromAddress,
},
Address: &address,
Data: data,
GasLimit: contexts.GasLimit,
}))
err := exe.Execute(txe, txe.Envelope.Tx.Payload)
if err != nil {
return nil, err
}
return txe, nil
} | go | func CallSim(reader acmstate.Reader, tip bcm.BlockchainInfo, fromAddress, address crypto.Address, data []byte,
logger *logging.Logger) (*exec.TxExecution, error) {
cache := acmstate.NewCache(reader)
exe := contexts.CallContext{
RunCall: true,
StateWriter: cache,
Blockchain: tip,
Logger: logger,
}
txe := exec.NewTxExecution(txs.Enclose(tip.ChainID(), &payload.CallTx{
Input: &payload.TxInput{
Address: fromAddress,
},
Address: &address,
Data: data,
GasLimit: contexts.GasLimit,
}))
err := exe.Execute(txe, txe.Envelope.Tx.Payload)
if err != nil {
return nil, err
}
return txe, nil
} | [
"func",
"CallSim",
"(",
"reader",
"acmstate",
".",
"Reader",
",",
"tip",
"bcm",
".",
"BlockchainInfo",
",",
"fromAddress",
",",
"address",
"crypto",
".",
"Address",
",",
"data",
"[",
"]",
"byte",
",",
"logger",
"*",
"logging",
".",
"Logger",
")",
"(",
"*",
"exec",
".",
"TxExecution",
",",
"error",
")",
"{",
"cache",
":=",
"acmstate",
".",
"NewCache",
"(",
"reader",
")",
"\n",
"exe",
":=",
"contexts",
".",
"CallContext",
"{",
"RunCall",
":",
"true",
",",
"StateWriter",
":",
"cache",
",",
"Blockchain",
":",
"tip",
",",
"Logger",
":",
"logger",
",",
"}",
"\n",
"txe",
":=",
"exec",
".",
"NewTxExecution",
"(",
"txs",
".",
"Enclose",
"(",
"tip",
".",
"ChainID",
"(",
")",
",",
"&",
"payload",
".",
"CallTx",
"{",
"Input",
":",
"&",
"payload",
".",
"TxInput",
"{",
"Address",
":",
"fromAddress",
",",
"}",
",",
"Address",
":",
"&",
"address",
",",
"Data",
":",
"data",
",",
"GasLimit",
":",
"contexts",
".",
"GasLimit",
",",
"}",
")",
")",
"\n",
"err",
":=",
"exe",
".",
"Execute",
"(",
"txe",
",",
"txe",
".",
"Envelope",
".",
"Tx",
".",
"Payload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"txe",
",",
"nil",
"\n",
"}"
] | // Run a contract's code on an isolated and unpersisted state
// Cannot be used to create new contracts | [
"Run",
"a",
"contract",
"s",
"code",
"on",
"an",
"isolated",
"and",
"unpersisted",
"state",
"Cannot",
"be",
"used",
"to",
"create",
"new",
"contracts"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/simulated_call.go#L17-L41 | train |
hyperledger/burrow | execution/simulated_call.go | CallCodeSim | func CallCodeSim(reader acmstate.Reader, tip bcm.BlockchainInfo, fromAddress, address crypto.Address, code, data []byte,
logger *logging.Logger) (*exec.TxExecution, error) {
// Attach code to target account (overwriting target)
cache := acmstate.NewCache(reader)
err := cache.UpdateAccount(&acm.Account{
Address: address,
Code: code,
})
if err != nil {
return nil, err
}
return CallSim(cache, tip, fromAddress, address, data, logger)
} | go | func CallCodeSim(reader acmstate.Reader, tip bcm.BlockchainInfo, fromAddress, address crypto.Address, code, data []byte,
logger *logging.Logger) (*exec.TxExecution, error) {
// Attach code to target account (overwriting target)
cache := acmstate.NewCache(reader)
err := cache.UpdateAccount(&acm.Account{
Address: address,
Code: code,
})
if err != nil {
return nil, err
}
return CallSim(cache, tip, fromAddress, address, data, logger)
} | [
"func",
"CallCodeSim",
"(",
"reader",
"acmstate",
".",
"Reader",
",",
"tip",
"bcm",
".",
"BlockchainInfo",
",",
"fromAddress",
",",
"address",
"crypto",
".",
"Address",
",",
"code",
",",
"data",
"[",
"]",
"byte",
",",
"logger",
"*",
"logging",
".",
"Logger",
")",
"(",
"*",
"exec",
".",
"TxExecution",
",",
"error",
")",
"{",
"cache",
":=",
"acmstate",
".",
"NewCache",
"(",
"reader",
")",
"\n",
"err",
":=",
"cache",
".",
"UpdateAccount",
"(",
"&",
"acm",
".",
"Account",
"{",
"Address",
":",
"address",
",",
"Code",
":",
"code",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"CallSim",
"(",
"cache",
",",
"tip",
",",
"fromAddress",
",",
"address",
",",
"data",
",",
"logger",
")",
"\n",
"}"
] | // Run the given code on an isolated and unpersisted state
// Cannot be used to create new contracts. | [
"Run",
"the",
"given",
"code",
"on",
"an",
"isolated",
"and",
"unpersisted",
"state",
"Cannot",
"be",
"used",
"to",
"create",
"new",
"contracts",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/simulated_call.go#L45-L59 | train |
hyperledger/burrow | core/config.go | LoadKeysFromConfig | func (kern *Kernel) LoadKeysFromConfig(conf *keys.KeysConfig) (err error) {
kern.keyStore = keys.NewKeyStore(conf.KeysDirectory, conf.AllowBadFilePermissions)
if conf.RemoteAddress != "" {
kern.keyClient, err = keys.NewRemoteKeyClient(conf.RemoteAddress, kern.Logger)
if err != nil {
return err
}
} else {
kern.keyClient = keys.NewLocalKeyClient(kern.keyStore, kern.Logger)
}
return nil
} | go | func (kern *Kernel) LoadKeysFromConfig(conf *keys.KeysConfig) (err error) {
kern.keyStore = keys.NewKeyStore(conf.KeysDirectory, conf.AllowBadFilePermissions)
if conf.RemoteAddress != "" {
kern.keyClient, err = keys.NewRemoteKeyClient(conf.RemoteAddress, kern.Logger)
if err != nil {
return err
}
} else {
kern.keyClient = keys.NewLocalKeyClient(kern.keyStore, kern.Logger)
}
return nil
} | [
"func",
"(",
"kern",
"*",
"Kernel",
")",
"LoadKeysFromConfig",
"(",
"conf",
"*",
"keys",
".",
"KeysConfig",
")",
"(",
"err",
"error",
")",
"{",
"kern",
".",
"keyStore",
"=",
"keys",
".",
"NewKeyStore",
"(",
"conf",
".",
"KeysDirectory",
",",
"conf",
".",
"AllowBadFilePermissions",
")",
"\n",
"if",
"conf",
".",
"RemoteAddress",
"!=",
"\"\"",
"{",
"kern",
".",
"keyClient",
",",
"err",
"=",
"keys",
".",
"NewRemoteKeyClient",
"(",
"conf",
".",
"RemoteAddress",
",",
"kern",
".",
"Logger",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"kern",
".",
"keyClient",
"=",
"keys",
".",
"NewLocalKeyClient",
"(",
"kern",
".",
"keyStore",
",",
"kern",
".",
"Logger",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // LoadKeysFromConfig sets the keyClient & keyStore based on the given config | [
"LoadKeysFromConfig",
"sets",
"the",
"keyClient",
"&",
"keyStore",
"based",
"on",
"the",
"given",
"config"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/core/config.go#L23-L34 | train |
hyperledger/burrow | core/config.go | LoadLoggerFromConfig | func (kern *Kernel) LoadLoggerFromConfig(conf *logconfig.LoggingConfig) error {
logger, err := lifecycle.NewLoggerFromLoggingConfig(conf)
kern.SetLogger(logger)
return err
} | go | func (kern *Kernel) LoadLoggerFromConfig(conf *logconfig.LoggingConfig) error {
logger, err := lifecycle.NewLoggerFromLoggingConfig(conf)
kern.SetLogger(logger)
return err
} | [
"func",
"(",
"kern",
"*",
"Kernel",
")",
"LoadLoggerFromConfig",
"(",
"conf",
"*",
"logconfig",
".",
"LoggingConfig",
")",
"error",
"{",
"logger",
",",
"err",
":=",
"lifecycle",
".",
"NewLoggerFromLoggingConfig",
"(",
"conf",
")",
"\n",
"kern",
".",
"SetLogger",
"(",
"logger",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // LoadLoggerFromConfig adds a logging configuration to the kernel | [
"LoadLoggerFromConfig",
"adds",
"a",
"logging",
"configuration",
"to",
"the",
"kernel"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/core/config.go#L37-L41 | train |
hyperledger/burrow | core/config.go | LoadExecutionOptionsFromConfig | func (kern *Kernel) LoadExecutionOptionsFromConfig(conf *execution.ExecutionConfig) error {
if conf != nil {
exeOptions, err := conf.ExecutionOptions()
if err != nil {
return err
}
kern.exeOptions = exeOptions
kern.timeoutFactor = conf.TimeoutFactor
}
return nil
} | go | func (kern *Kernel) LoadExecutionOptionsFromConfig(conf *execution.ExecutionConfig) error {
if conf != nil {
exeOptions, err := conf.ExecutionOptions()
if err != nil {
return err
}
kern.exeOptions = exeOptions
kern.timeoutFactor = conf.TimeoutFactor
}
return nil
} | [
"func",
"(",
"kern",
"*",
"Kernel",
")",
"LoadExecutionOptionsFromConfig",
"(",
"conf",
"*",
"execution",
".",
"ExecutionConfig",
")",
"error",
"{",
"if",
"conf",
"!=",
"nil",
"{",
"exeOptions",
",",
"err",
":=",
"conf",
".",
"ExecutionOptions",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"kern",
".",
"exeOptions",
"=",
"exeOptions",
"\n",
"kern",
".",
"timeoutFactor",
"=",
"conf",
".",
"TimeoutFactor",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // LoadExecutionOptionsFromConfig builds the execution options for the kernel | [
"LoadExecutionOptionsFromConfig",
"builds",
"the",
"execution",
"options",
"for",
"the",
"kernel"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/core/config.go#L44-L54 | train |
hyperledger/burrow | core/config.go | LoadTendermintFromConfig | func (kern *Kernel) LoadTendermintFromConfig(conf *config.BurrowConfig, privVal tmTypes.PrivValidator) (err error) {
if conf.Tendermint == nil || !conf.Tendermint.Enabled {
return nil
}
authorizedPeersProvider := conf.Tendermint.DefaultAuthorizedPeersProvider()
kern.database.Stats()
kern.info = fmt.Sprintf("Burrow_%s_%s_ValidatorID:%X", project.History.CurrentVersion().String(),
kern.Blockchain.ChainID(), privVal.GetPubKey().Address())
app := abci.NewApp(kern.info, kern.Blockchain, kern.State, kern.checker, kern.committer, kern.txCodec,
authorizedPeersProvider, kern.Panic, kern.Logger)
// We could use this to provide/register our own metrics (though this will register them with us). Unfortunately
// Tendermint currently ignores the metrics passed unless its own server is turned on.
metricsProvider := node.DefaultMetricsProvider(&tmConfig.InstrumentationConfig{
Prometheus: false,
PrometheusListenAddr: "",
})
genesisDoc := kern.Blockchain.GenesisDoc()
// find node key
var nodeKey *crypto.PrivateKey
for _, v := range genesisDoc.Validators {
thisAddress, err := crypto.AddressFromHexString(privVal.GetPubKey().Address().String())
if err != nil {
break
}
if v.Address == thisAddress && v.NodeAddress != nil {
k, err := kern.keyStore.GetKey("", v.NodeAddress.Bytes())
if err == nil {
nodeKey = &k.PrivateKey
}
break
}
}
tmGenesisDoc := tendermint.DeriveGenesisDoc(&genesisDoc, kern.Blockchain.AppHashAfterLastBlock())
heightValuer := log.Valuer(func() interface{} { return kern.Blockchain.LastBlockHeight() })
tmLogger := kern.Logger.With(structure.CallerKey, log.Caller(LoggingCallerDepth+1)).With("height", heightValuer)
kern.Node, err = tendermint.NewNode(conf.TendermintConfig(), privVal, tmGenesisDoc, app, metricsProvider, nodeKey, tmLogger)
return err
} | go | func (kern *Kernel) LoadTendermintFromConfig(conf *config.BurrowConfig, privVal tmTypes.PrivValidator) (err error) {
if conf.Tendermint == nil || !conf.Tendermint.Enabled {
return nil
}
authorizedPeersProvider := conf.Tendermint.DefaultAuthorizedPeersProvider()
kern.database.Stats()
kern.info = fmt.Sprintf("Burrow_%s_%s_ValidatorID:%X", project.History.CurrentVersion().String(),
kern.Blockchain.ChainID(), privVal.GetPubKey().Address())
app := abci.NewApp(kern.info, kern.Blockchain, kern.State, kern.checker, kern.committer, kern.txCodec,
authorizedPeersProvider, kern.Panic, kern.Logger)
// We could use this to provide/register our own metrics (though this will register them with us). Unfortunately
// Tendermint currently ignores the metrics passed unless its own server is turned on.
metricsProvider := node.DefaultMetricsProvider(&tmConfig.InstrumentationConfig{
Prometheus: false,
PrometheusListenAddr: "",
})
genesisDoc := kern.Blockchain.GenesisDoc()
// find node key
var nodeKey *crypto.PrivateKey
for _, v := range genesisDoc.Validators {
thisAddress, err := crypto.AddressFromHexString(privVal.GetPubKey().Address().String())
if err != nil {
break
}
if v.Address == thisAddress && v.NodeAddress != nil {
k, err := kern.keyStore.GetKey("", v.NodeAddress.Bytes())
if err == nil {
nodeKey = &k.PrivateKey
}
break
}
}
tmGenesisDoc := tendermint.DeriveGenesisDoc(&genesisDoc, kern.Blockchain.AppHashAfterLastBlock())
heightValuer := log.Valuer(func() interface{} { return kern.Blockchain.LastBlockHeight() })
tmLogger := kern.Logger.With(structure.CallerKey, log.Caller(LoggingCallerDepth+1)).With("height", heightValuer)
kern.Node, err = tendermint.NewNode(conf.TendermintConfig(), privVal, tmGenesisDoc, app, metricsProvider, nodeKey, tmLogger)
return err
} | [
"func",
"(",
"kern",
"*",
"Kernel",
")",
"LoadTendermintFromConfig",
"(",
"conf",
"*",
"config",
".",
"BurrowConfig",
",",
"privVal",
"tmTypes",
".",
"PrivValidator",
")",
"(",
"err",
"error",
")",
"{",
"if",
"conf",
".",
"Tendermint",
"==",
"nil",
"||",
"!",
"conf",
".",
"Tendermint",
".",
"Enabled",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"authorizedPeersProvider",
":=",
"conf",
".",
"Tendermint",
".",
"DefaultAuthorizedPeersProvider",
"(",
")",
"\n",
"kern",
".",
"database",
".",
"Stats",
"(",
")",
"\n",
"kern",
".",
"info",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"Burrow_%s_%s_ValidatorID:%X\"",
",",
"project",
".",
"History",
".",
"CurrentVersion",
"(",
")",
".",
"String",
"(",
")",
",",
"kern",
".",
"Blockchain",
".",
"ChainID",
"(",
")",
",",
"privVal",
".",
"GetPubKey",
"(",
")",
".",
"Address",
"(",
")",
")",
"\n",
"app",
":=",
"abci",
".",
"NewApp",
"(",
"kern",
".",
"info",
",",
"kern",
".",
"Blockchain",
",",
"kern",
".",
"State",
",",
"kern",
".",
"checker",
",",
"kern",
".",
"committer",
",",
"kern",
".",
"txCodec",
",",
"authorizedPeersProvider",
",",
"kern",
".",
"Panic",
",",
"kern",
".",
"Logger",
")",
"\n",
"metricsProvider",
":=",
"node",
".",
"DefaultMetricsProvider",
"(",
"&",
"tmConfig",
".",
"InstrumentationConfig",
"{",
"Prometheus",
":",
"false",
",",
"PrometheusListenAddr",
":",
"\"\"",
",",
"}",
")",
"\n",
"genesisDoc",
":=",
"kern",
".",
"Blockchain",
".",
"GenesisDoc",
"(",
")",
"\n",
"var",
"nodeKey",
"*",
"crypto",
".",
"PrivateKey",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"genesisDoc",
".",
"Validators",
"{",
"thisAddress",
",",
"err",
":=",
"crypto",
".",
"AddressFromHexString",
"(",
"privVal",
".",
"GetPubKey",
"(",
")",
".",
"Address",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"if",
"v",
".",
"Address",
"==",
"thisAddress",
"&&",
"v",
".",
"NodeAddress",
"!=",
"nil",
"{",
"k",
",",
"err",
":=",
"kern",
".",
"keyStore",
".",
"GetKey",
"(",
"\"\"",
",",
"v",
".",
"NodeAddress",
".",
"Bytes",
"(",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"nodeKey",
"=",
"&",
"k",
".",
"PrivateKey",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"tmGenesisDoc",
":=",
"tendermint",
".",
"DeriveGenesisDoc",
"(",
"&",
"genesisDoc",
",",
"kern",
".",
"Blockchain",
".",
"AppHashAfterLastBlock",
"(",
")",
")",
"\n",
"heightValuer",
":=",
"log",
".",
"Valuer",
"(",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"return",
"kern",
".",
"Blockchain",
".",
"LastBlockHeight",
"(",
")",
"}",
")",
"\n",
"tmLogger",
":=",
"kern",
".",
"Logger",
".",
"With",
"(",
"structure",
".",
"CallerKey",
",",
"log",
".",
"Caller",
"(",
"LoggingCallerDepth",
"+",
"1",
")",
")",
".",
"With",
"(",
"\"height\"",
",",
"heightValuer",
")",
"\n",
"kern",
".",
"Node",
",",
"err",
"=",
"tendermint",
".",
"NewNode",
"(",
"conf",
".",
"TendermintConfig",
"(",
")",
",",
"privVal",
",",
"tmGenesisDoc",
",",
"app",
",",
"metricsProvider",
",",
"nodeKey",
",",
"tmLogger",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // LoadTendermintFromConfig loads our consensus engine into the kernel | [
"LoadTendermintFromConfig",
"loads",
"our",
"consensus",
"engine",
"into",
"the",
"kernel"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/core/config.go#L57-L101 | train |
hyperledger/burrow | core/config.go | LoadKernelFromConfig | func LoadKernelFromConfig(conf *config.BurrowConfig) (*Kernel, error) {
kern, err := NewKernel(conf.BurrowDir)
if err != nil {
return nil, fmt.Errorf("could not create initial kernel: %v", err)
}
if err = kern.LoadLoggerFromConfig(conf.Logging); err != nil {
return nil, fmt.Errorf("could not configure logger: %v", err)
}
err = kern.LoadKeysFromConfig(conf.Keys)
if err != nil {
return nil, fmt.Errorf("could not configure keys: %v", err)
}
err = kern.LoadExecutionOptionsFromConfig(conf.Execution)
if err != nil {
return nil, fmt.Errorf("could not add execution options: %v", err)
}
err = kern.LoadState(conf.GenesisDoc)
if err != nil {
return nil, fmt.Errorf("could not load state: %v", err)
}
if conf.ValidatorAddress == nil {
return nil, fmt.Errorf("ValidatorAddress must be set")
}
privVal, err := kern.PrivValidator(*conf.ValidatorAddress)
if err != nil {
return nil, fmt.Errorf("could not form PrivValidator from ValidatorAddress: %v", err)
}
err = kern.LoadTendermintFromConfig(conf, privVal)
if err != nil {
return nil, fmt.Errorf("could not configure Tendermint: %v", err)
}
kern.AddProcesses(DefaultProcessLaunchers(kern, conf.RPC, conf.Keys)...)
return kern, nil
} | go | func LoadKernelFromConfig(conf *config.BurrowConfig) (*Kernel, error) {
kern, err := NewKernel(conf.BurrowDir)
if err != nil {
return nil, fmt.Errorf("could not create initial kernel: %v", err)
}
if err = kern.LoadLoggerFromConfig(conf.Logging); err != nil {
return nil, fmt.Errorf("could not configure logger: %v", err)
}
err = kern.LoadKeysFromConfig(conf.Keys)
if err != nil {
return nil, fmt.Errorf("could not configure keys: %v", err)
}
err = kern.LoadExecutionOptionsFromConfig(conf.Execution)
if err != nil {
return nil, fmt.Errorf("could not add execution options: %v", err)
}
err = kern.LoadState(conf.GenesisDoc)
if err != nil {
return nil, fmt.Errorf("could not load state: %v", err)
}
if conf.ValidatorAddress == nil {
return nil, fmt.Errorf("ValidatorAddress must be set")
}
privVal, err := kern.PrivValidator(*conf.ValidatorAddress)
if err != nil {
return nil, fmt.Errorf("could not form PrivValidator from ValidatorAddress: %v", err)
}
err = kern.LoadTendermintFromConfig(conf, privVal)
if err != nil {
return nil, fmt.Errorf("could not configure Tendermint: %v", err)
}
kern.AddProcesses(DefaultProcessLaunchers(kern, conf.RPC, conf.Keys)...)
return kern, nil
} | [
"func",
"LoadKernelFromConfig",
"(",
"conf",
"*",
"config",
".",
"BurrowConfig",
")",
"(",
"*",
"Kernel",
",",
"error",
")",
"{",
"kern",
",",
"err",
":=",
"NewKernel",
"(",
"conf",
".",
"BurrowDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not create initial kernel: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"kern",
".",
"LoadLoggerFromConfig",
"(",
"conf",
".",
"Logging",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not configure logger: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"kern",
".",
"LoadKeysFromConfig",
"(",
"conf",
".",
"Keys",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not configure keys: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"kern",
".",
"LoadExecutionOptionsFromConfig",
"(",
"conf",
".",
"Execution",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not add execution options: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"kern",
".",
"LoadState",
"(",
"conf",
".",
"GenesisDoc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not load state: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"conf",
".",
"ValidatorAddress",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"ValidatorAddress must be set\"",
")",
"\n",
"}",
"\n",
"privVal",
",",
"err",
":=",
"kern",
".",
"PrivValidator",
"(",
"*",
"conf",
".",
"ValidatorAddress",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not form PrivValidator from ValidatorAddress: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"kern",
".",
"LoadTendermintFromConfig",
"(",
"conf",
",",
"privVal",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not configure Tendermint: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"kern",
".",
"AddProcesses",
"(",
"DefaultProcessLaunchers",
"(",
"kern",
",",
"conf",
".",
"RPC",
",",
"conf",
".",
"Keys",
")",
"...",
")",
"\n",
"return",
"kern",
",",
"nil",
"\n",
"}"
] | // LoadKernelFromConfig builds and returns a Kernel based solely on the supplied configuration | [
"LoadKernelFromConfig",
"builds",
"and",
"returns",
"a",
"Kernel",
"based",
"solely",
"on",
"the",
"supplied",
"configuration"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/core/config.go#L104-L145 | train |
hyperledger/burrow | binary/integer.go | U256 | func U256(x *big.Int) *big.Int {
// Note that the And operation induces big.Int to hold a positive representation of a negative number
return new(big.Int).And(x, tt256m1)
} | go | func U256(x *big.Int) *big.Int {
// Note that the And operation induces big.Int to hold a positive representation of a negative number
return new(big.Int).And(x, tt256m1)
} | [
"func",
"U256",
"(",
"x",
"*",
"big",
".",
"Int",
")",
"*",
"big",
".",
"Int",
"{",
"return",
"new",
"(",
"big",
".",
"Int",
")",
".",
"And",
"(",
"x",
",",
"tt256m1",
")",
"\n",
"}"
] | // Converts a possibly negative big int x into a positive big int encoding a twos complement representation of x
// truncated to 32 bytes | [
"Converts",
"a",
"possibly",
"negative",
"big",
"int",
"x",
"into",
"a",
"positive",
"big",
"int",
"encoding",
"a",
"twos",
"complement",
"representation",
"of",
"x",
"truncated",
"to",
"32",
"bytes"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/binary/integer.go#L70-L73 | train |
hyperledger/burrow | binary/integer.go | SignExtend | func SignExtend(back uint64, x *big.Int) *big.Int {
// we assume x contains a signed integer of back + 1 bytes width
// most significant bit of the back'th byte,
signBit := back*8 + 7
// single bit set at sign bit position
mask := new(big.Int).Lsh(big1, uint(signBit))
// all bits below sign bit set to 1 all above (including sign bit) set to 0
mask.Sub(mask, big1)
if x.Bit(int(signBit)) == 1 {
// Number represented is negative - set all bits above sign bit (including sign bit)
return x.Or(x, mask.Not(mask))
} else {
// Number represented is positive - clear all bits above sign bit (including sign bit)
return x.And(x, mask)
}
} | go | func SignExtend(back uint64, x *big.Int) *big.Int {
// we assume x contains a signed integer of back + 1 bytes width
// most significant bit of the back'th byte,
signBit := back*8 + 7
// single bit set at sign bit position
mask := new(big.Int).Lsh(big1, uint(signBit))
// all bits below sign bit set to 1 all above (including sign bit) set to 0
mask.Sub(mask, big1)
if x.Bit(int(signBit)) == 1 {
// Number represented is negative - set all bits above sign bit (including sign bit)
return x.Or(x, mask.Not(mask))
} else {
// Number represented is positive - clear all bits above sign bit (including sign bit)
return x.And(x, mask)
}
} | [
"func",
"SignExtend",
"(",
"back",
"uint64",
",",
"x",
"*",
"big",
".",
"Int",
")",
"*",
"big",
".",
"Int",
"{",
"signBit",
":=",
"back",
"*",
"8",
"+",
"7",
"\n",
"mask",
":=",
"new",
"(",
"big",
".",
"Int",
")",
".",
"Lsh",
"(",
"big1",
",",
"uint",
"(",
"signBit",
")",
")",
"\n",
"mask",
".",
"Sub",
"(",
"mask",
",",
"big1",
")",
"\n",
"if",
"x",
".",
"Bit",
"(",
"int",
"(",
"signBit",
")",
")",
"==",
"1",
"{",
"return",
"x",
".",
"Or",
"(",
"x",
",",
"mask",
".",
"Not",
"(",
"mask",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"x",
".",
"And",
"(",
"x",
",",
"mask",
")",
"\n",
"}",
"\n",
"}"
] | // Treats the positive big int x as if it contains an embedded a back + 1 byte signed integer in its least significant
// bits and extends that sign | [
"Treats",
"the",
"positive",
"big",
"int",
"x",
"as",
"if",
"it",
"contains",
"an",
"embedded",
"a",
"back",
"+",
"1",
"byte",
"signed",
"integer",
"in",
"its",
"least",
"significant",
"bits",
"and",
"extends",
"that",
"sign"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/binary/integer.go#L88-L103 | train |
hyperledger/burrow | keys/key_client.go | HealthCheck | func (l *remoteKeyClient) HealthCheck() error {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
_, err := l.kc.List(ctx, &ListRequest{})
return err
} | go | func (l *remoteKeyClient) HealthCheck() error {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
_, err := l.kc.List(ctx, &ListRequest{})
return err
} | [
"func",
"(",
"l",
"*",
"remoteKeyClient",
")",
"HealthCheck",
"(",
")",
"error",
"{",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"Background",
"(",
")",
",",
"10",
"*",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"l",
".",
"kc",
".",
"List",
"(",
"ctx",
",",
"&",
"ListRequest",
"{",
"}",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // HealthCheck returns nil if the keys instance is healthy, error otherwise | [
"HealthCheck",
"returns",
"nil",
"if",
"the",
"keys",
"instance",
"is",
"healthy",
"error",
"otherwise"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/keys/key_client.go#L177-L182 | train |
hyperledger/burrow | keys/key_client.go | NewRemoteKeyClient | func NewRemoteKeyClient(rpcAddress string, logger *logging.Logger) (KeyClient, error) {
logger = logger.WithScope("RemoteKeyClient")
var opts []grpc.DialOption
opts = append(opts, grpc.WithInsecure())
conn, err := grpc.Dial(rpcAddress, opts...)
if err != nil {
return nil, err
}
kc := NewKeysClient(conn)
return &remoteKeyClient{kc: kc, rpcAddress: rpcAddress, logger: logger}, nil
} | go | func NewRemoteKeyClient(rpcAddress string, logger *logging.Logger) (KeyClient, error) {
logger = logger.WithScope("RemoteKeyClient")
var opts []grpc.DialOption
opts = append(opts, grpc.WithInsecure())
conn, err := grpc.Dial(rpcAddress, opts...)
if err != nil {
return nil, err
}
kc := NewKeysClient(conn)
return &remoteKeyClient{kc: kc, rpcAddress: rpcAddress, logger: logger}, nil
} | [
"func",
"NewRemoteKeyClient",
"(",
"rpcAddress",
"string",
",",
"logger",
"*",
"logging",
".",
"Logger",
")",
"(",
"KeyClient",
",",
"error",
")",
"{",
"logger",
"=",
"logger",
".",
"WithScope",
"(",
"\"RemoteKeyClient\"",
")",
"\n",
"var",
"opts",
"[",
"]",
"grpc",
".",
"DialOption",
"\n",
"opts",
"=",
"append",
"(",
"opts",
",",
"grpc",
".",
"WithInsecure",
"(",
")",
")",
"\n",
"conn",
",",
"err",
":=",
"grpc",
".",
"Dial",
"(",
"rpcAddress",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"kc",
":=",
"NewKeysClient",
"(",
"conn",
")",
"\n",
"return",
"&",
"remoteKeyClient",
"{",
"kc",
":",
"kc",
",",
"rpcAddress",
":",
"rpcAddress",
",",
"logger",
":",
"logger",
"}",
",",
"nil",
"\n",
"}"
] | // NewRemoteKeyClient returns a new keys client for provided rpc location | [
"NewRemoteKeyClient",
"returns",
"a",
"new",
"keys",
"client",
"for",
"provided",
"rpc",
"location"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/keys/key_client.go#L185-L196 | train |
hyperledger/burrow | keys/key_client.go | NewLocalKeyClient | func NewLocalKeyClient(ks *KeyStore, logger *logging.Logger) KeyClient {
logger = logger.WithScope("LocalKeyClient")
return &localKeyClient{ks: ks, logger: logger}
} | go | func NewLocalKeyClient(ks *KeyStore, logger *logging.Logger) KeyClient {
logger = logger.WithScope("LocalKeyClient")
return &localKeyClient{ks: ks, logger: logger}
} | [
"func",
"NewLocalKeyClient",
"(",
"ks",
"*",
"KeyStore",
",",
"logger",
"*",
"logging",
".",
"Logger",
")",
"KeyClient",
"{",
"logger",
"=",
"logger",
".",
"WithScope",
"(",
"\"LocalKeyClient\"",
")",
"\n",
"return",
"&",
"localKeyClient",
"{",
"ks",
":",
"ks",
",",
"logger",
":",
"logger",
"}",
"\n",
"}"
] | // NewLocalKeyClient returns a new keys client, backed by the local filesystem | [
"NewLocalKeyClient",
"returns",
"a",
"new",
"keys",
"client",
"backed",
"by",
"the",
"local",
"filesystem"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/keys/key_client.go#L199-L202 | train |
hyperledger/burrow | keys/key_client.go | AddressableSigner | func AddressableSigner(keyClient KeyClient, address crypto.Address) (*Signer, error) {
publicKey, err := keyClient.PublicKey(address)
if err != nil {
return nil, err
}
// TODO: we can do better than this and return a typed signature when we reform the keys service
return &Signer{
keyClient: keyClient,
address: address,
publicKey: publicKey,
}, nil
} | go | func AddressableSigner(keyClient KeyClient, address crypto.Address) (*Signer, error) {
publicKey, err := keyClient.PublicKey(address)
if err != nil {
return nil, err
}
// TODO: we can do better than this and return a typed signature when we reform the keys service
return &Signer{
keyClient: keyClient,
address: address,
publicKey: publicKey,
}, nil
} | [
"func",
"AddressableSigner",
"(",
"keyClient",
"KeyClient",
",",
"address",
"crypto",
".",
"Address",
")",
"(",
"*",
"Signer",
",",
"error",
")",
"{",
"publicKey",
",",
"err",
":=",
"keyClient",
".",
"PublicKey",
"(",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Signer",
"{",
"keyClient",
":",
"keyClient",
",",
"address",
":",
"address",
",",
"publicKey",
":",
"publicKey",
",",
"}",
",",
"nil",
"\n",
"}"
] | // AddressableSigner creates a signer that assumes the address holds an Ed25519 key | [
"AddressableSigner",
"creates",
"a",
"signer",
"that",
"assumes",
"the",
"address",
"holds",
"an",
"Ed25519",
"key"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/keys/key_client.go#L211-L222 | train |
hyperledger/burrow | vent/sqldb/adapters/sqlite_adapter.go | Open | func (adapter *SQLiteAdapter) Open(dbURL string) (*sql.DB, error) {
db, err := sql.Open("sqlite3", dbURL)
if err != nil {
adapter.Log.Info("msg", "Error creating database connection", "err", err)
return nil, err
}
return db, nil
} | go | func (adapter *SQLiteAdapter) Open(dbURL string) (*sql.DB, error) {
db, err := sql.Open("sqlite3", dbURL)
if err != nil {
adapter.Log.Info("msg", "Error creating database connection", "err", err)
return nil, err
}
return db, nil
} | [
"func",
"(",
"adapter",
"*",
"SQLiteAdapter",
")",
"Open",
"(",
"dbURL",
"string",
")",
"(",
"*",
"sql",
".",
"DB",
",",
"error",
")",
"{",
"db",
",",
"err",
":=",
"sql",
".",
"Open",
"(",
"\"sqlite3\"",
",",
"dbURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"adapter",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error creating database connection\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"db",
",",
"nil",
"\n",
"}"
] | // Open connects to a SQLiteQL database, opens it & create default schema if provided | [
"Open",
"connects",
"to",
"a",
"SQLiteQL",
"database",
"opens",
"it",
"&",
"create",
"default",
"schema",
"if",
"provided"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/adapters/sqlite_adapter.go#L42-L50 | train |
hyperledger/burrow | vent/sqldb/adapters/sqlite_adapter.go | AlterColumnQuery | func (adapter *SQLiteAdapter) AlterColumnQuery(tableName, columnName string, sqlColumnType types.SQLColumnType, length, order int) (string, string) {
sqlType, _ := adapter.TypeMapping(sqlColumnType)
if length > 0 {
sqlType = Cleanf("%s(%d)", sqlType, length)
}
query := Cleanf("ALTER TABLE %s ADD COLUMN %s %s;",
adapter.SecureName(tableName),
adapter.SecureName(columnName),
sqlType)
dictionaryQuery := Cleanf(`
INSERT INTO %s (%s,%s,%s,%s,%s,%s)
VALUES ('%s','%s',%d,%d,%d,%d);`,
types.SQLDictionaryTableName,
types.SQLColumnLabelTableName, types.SQLColumnLabelColumnName,
types.SQLColumnLabelColumnType, types.SQLColumnLabelColumnLength,
types.SQLColumnLabelPrimaryKey, types.SQLColumnLabelColumnOrder,
tableName, columnName, sqlColumnType, length, 0, order)
return query, dictionaryQuery
} | go | func (adapter *SQLiteAdapter) AlterColumnQuery(tableName, columnName string, sqlColumnType types.SQLColumnType, length, order int) (string, string) {
sqlType, _ := adapter.TypeMapping(sqlColumnType)
if length > 0 {
sqlType = Cleanf("%s(%d)", sqlType, length)
}
query := Cleanf("ALTER TABLE %s ADD COLUMN %s %s;",
adapter.SecureName(tableName),
adapter.SecureName(columnName),
sqlType)
dictionaryQuery := Cleanf(`
INSERT INTO %s (%s,%s,%s,%s,%s,%s)
VALUES ('%s','%s',%d,%d,%d,%d);`,
types.SQLDictionaryTableName,
types.SQLColumnLabelTableName, types.SQLColumnLabelColumnName,
types.SQLColumnLabelColumnType, types.SQLColumnLabelColumnLength,
types.SQLColumnLabelPrimaryKey, types.SQLColumnLabelColumnOrder,
tableName, columnName, sqlColumnType, length, 0, order)
return query, dictionaryQuery
} | [
"func",
"(",
"adapter",
"*",
"SQLiteAdapter",
")",
"AlterColumnQuery",
"(",
"tableName",
",",
"columnName",
"string",
",",
"sqlColumnType",
"types",
".",
"SQLColumnType",
",",
"length",
",",
"order",
"int",
")",
"(",
"string",
",",
"string",
")",
"{",
"sqlType",
",",
"_",
":=",
"adapter",
".",
"TypeMapping",
"(",
"sqlColumnType",
")",
"\n",
"if",
"length",
">",
"0",
"{",
"sqlType",
"=",
"Cleanf",
"(",
"\"%s(%d)\"",
",",
"sqlType",
",",
"length",
")",
"\n",
"}",
"\n",
"query",
":=",
"Cleanf",
"(",
"\"ALTER TABLE %s ADD COLUMN %s %s;\"",
",",
"adapter",
".",
"SecureName",
"(",
"tableName",
")",
",",
"adapter",
".",
"SecureName",
"(",
"columnName",
")",
",",
"sqlType",
")",
"\n",
"dictionaryQuery",
":=",
"Cleanf",
"(",
"`\t\tINSERT INTO %s (%s,%s,%s,%s,%s,%s)\t\tVALUES ('%s','%s',%d,%d,%d,%d);`",
",",
"types",
".",
"SQLDictionaryTableName",
",",
"types",
".",
"SQLColumnLabelTableName",
",",
"types",
".",
"SQLColumnLabelColumnName",
",",
"types",
".",
"SQLColumnLabelColumnType",
",",
"types",
".",
"SQLColumnLabelColumnLength",
",",
"types",
".",
"SQLColumnLabelPrimaryKey",
",",
"types",
".",
"SQLColumnLabelColumnOrder",
",",
"tableName",
",",
"columnName",
",",
"sqlColumnType",
",",
"length",
",",
"0",
",",
"order",
")",
"\n",
"return",
"query",
",",
"dictionaryQuery",
"\n",
"}"
] | // AlterColumnQuery returns a query for adding a new column to a table | [
"AlterColumnQuery",
"returns",
"a",
"query",
"for",
"adding",
"a",
"new",
"column",
"to",
"a",
"table"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/adapters/sqlite_adapter.go#L184-L208 | train |
hyperledger/burrow | permission/perm_flag.go | String | func (pf PermFlag) String() string {
switch pf {
case AllPermFlags:
return AllString
case Root:
return RootString
case Send:
return SendString
case Call:
return CallString
case CreateContract:
return CreateContractString
case CreateAccount:
return CreateAccountString
case Bond:
return BondString
case Name:
return NameString
case Proposal:
return ProposalString
case Input:
return InputString
case Batch:
return BatchString
case HasBase:
return HasBaseString
case SetBase:
return SetBaseString
case UnsetBase:
return UnsetBaseString
case SetGlobal:
return SetGlobalString
case HasRole:
return HasRoleString
case AddRole:
return AddRoleString
case RemoveRole:
return RemoveRoleString
default:
return UnknownString
}
} | go | func (pf PermFlag) String() string {
switch pf {
case AllPermFlags:
return AllString
case Root:
return RootString
case Send:
return SendString
case Call:
return CallString
case CreateContract:
return CreateContractString
case CreateAccount:
return CreateAccountString
case Bond:
return BondString
case Name:
return NameString
case Proposal:
return ProposalString
case Input:
return InputString
case Batch:
return BatchString
case HasBase:
return HasBaseString
case SetBase:
return SetBaseString
case UnsetBase:
return UnsetBaseString
case SetGlobal:
return SetGlobalString
case HasRole:
return HasRoleString
case AddRole:
return AddRoleString
case RemoveRole:
return RemoveRoleString
default:
return UnknownString
}
} | [
"func",
"(",
"pf",
"PermFlag",
")",
"String",
"(",
")",
"string",
"{",
"switch",
"pf",
"{",
"case",
"AllPermFlags",
":",
"return",
"AllString",
"\n",
"case",
"Root",
":",
"return",
"RootString",
"\n",
"case",
"Send",
":",
"return",
"SendString",
"\n",
"case",
"Call",
":",
"return",
"CallString",
"\n",
"case",
"CreateContract",
":",
"return",
"CreateContractString",
"\n",
"case",
"CreateAccount",
":",
"return",
"CreateAccountString",
"\n",
"case",
"Bond",
":",
"return",
"BondString",
"\n",
"case",
"Name",
":",
"return",
"NameString",
"\n",
"case",
"Proposal",
":",
"return",
"ProposalString",
"\n",
"case",
"Input",
":",
"return",
"InputString",
"\n",
"case",
"Batch",
":",
"return",
"BatchString",
"\n",
"case",
"HasBase",
":",
"return",
"HasBaseString",
"\n",
"case",
"SetBase",
":",
"return",
"SetBaseString",
"\n",
"case",
"UnsetBase",
":",
"return",
"UnsetBaseString",
"\n",
"case",
"SetGlobal",
":",
"return",
"SetGlobalString",
"\n",
"case",
"HasRole",
":",
"return",
"HasRoleString",
"\n",
"case",
"AddRole",
":",
"return",
"AddRoleString",
"\n",
"case",
"RemoveRole",
":",
"return",
"RemoveRoleString",
"\n",
"default",
":",
"return",
"UnknownString",
"\n",
"}",
"\n",
"}"
] | // Returns the string name of a single bit non-composite PermFlag, or otherwise UnknownString
// See BasePermissionsToStringList to generate a string representation of a composite PermFlag | [
"Returns",
"the",
"string",
"name",
"of",
"a",
"single",
"bit",
"non",
"-",
"composite",
"PermFlag",
"or",
"otherwise",
"UnknownString",
"See",
"BasePermissionsToStringList",
"to",
"generate",
"a",
"string",
"representation",
"of",
"a",
"composite",
"PermFlag"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/permission/perm_flag.go#L95-L136 | train |
hyperledger/burrow | permission/perm_flag.go | PermStringToFlag | func PermStringToFlag(perm string) (PermFlag, error) {
switch strings.ToLower(perm) {
case AllString:
return AllPermFlags, nil
case RootString:
return Root, nil
case SendString:
return Send, nil
case CallString:
return Call, nil
case CreateContractString, "createcontract", "create_contract":
return CreateContract, nil
case CreateAccountString, "createaccount", "create_account":
return CreateAccount, nil
case BondString:
return Bond, nil
case NameString:
return Name, nil
case ProposalString:
return Proposal, nil
case InputString:
return Input, nil
case BatchString:
return Batch, nil
case HasBaseString, "hasbase", "has_base":
return HasBase, nil
case SetBaseString, "setbase", "set_base":
return SetBase, nil
case UnsetBaseString, "unsetbase", "unset_base":
return UnsetBase, nil
case SetGlobalString, "setglobal", "set_global":
return SetGlobal, nil
case HasRoleString, "hasrole", "has_role":
return HasRole, nil
case AddRoleString, "addrole", "add_role":
return AddRole, nil
case RemoveRoleString, "removerole", "rmrole", "rm_role":
return RemoveRole, nil
default:
return 0, fmt.Errorf("unknown permission %s", perm)
}
} | go | func PermStringToFlag(perm string) (PermFlag, error) {
switch strings.ToLower(perm) {
case AllString:
return AllPermFlags, nil
case RootString:
return Root, nil
case SendString:
return Send, nil
case CallString:
return Call, nil
case CreateContractString, "createcontract", "create_contract":
return CreateContract, nil
case CreateAccountString, "createaccount", "create_account":
return CreateAccount, nil
case BondString:
return Bond, nil
case NameString:
return Name, nil
case ProposalString:
return Proposal, nil
case InputString:
return Input, nil
case BatchString:
return Batch, nil
case HasBaseString, "hasbase", "has_base":
return HasBase, nil
case SetBaseString, "setbase", "set_base":
return SetBase, nil
case UnsetBaseString, "unsetbase", "unset_base":
return UnsetBase, nil
case SetGlobalString, "setglobal", "set_global":
return SetGlobal, nil
case HasRoleString, "hasrole", "has_role":
return HasRole, nil
case AddRoleString, "addrole", "add_role":
return AddRole, nil
case RemoveRoleString, "removerole", "rmrole", "rm_role":
return RemoveRole, nil
default:
return 0, fmt.Errorf("unknown permission %s", perm)
}
} | [
"func",
"PermStringToFlag",
"(",
"perm",
"string",
")",
"(",
"PermFlag",
",",
"error",
")",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"perm",
")",
"{",
"case",
"AllString",
":",
"return",
"AllPermFlags",
",",
"nil",
"\n",
"case",
"RootString",
":",
"return",
"Root",
",",
"nil",
"\n",
"case",
"SendString",
":",
"return",
"Send",
",",
"nil",
"\n",
"case",
"CallString",
":",
"return",
"Call",
",",
"nil",
"\n",
"case",
"CreateContractString",
",",
"\"createcontract\"",
",",
"\"create_contract\"",
":",
"return",
"CreateContract",
",",
"nil",
"\n",
"case",
"CreateAccountString",
",",
"\"createaccount\"",
",",
"\"create_account\"",
":",
"return",
"CreateAccount",
",",
"nil",
"\n",
"case",
"BondString",
":",
"return",
"Bond",
",",
"nil",
"\n",
"case",
"NameString",
":",
"return",
"Name",
",",
"nil",
"\n",
"case",
"ProposalString",
":",
"return",
"Proposal",
",",
"nil",
"\n",
"case",
"InputString",
":",
"return",
"Input",
",",
"nil",
"\n",
"case",
"BatchString",
":",
"return",
"Batch",
",",
"nil",
"\n",
"case",
"HasBaseString",
",",
"\"hasbase\"",
",",
"\"has_base\"",
":",
"return",
"HasBase",
",",
"nil",
"\n",
"case",
"SetBaseString",
",",
"\"setbase\"",
",",
"\"set_base\"",
":",
"return",
"SetBase",
",",
"nil",
"\n",
"case",
"UnsetBaseString",
",",
"\"unsetbase\"",
",",
"\"unset_base\"",
":",
"return",
"UnsetBase",
",",
"nil",
"\n",
"case",
"SetGlobalString",
",",
"\"setglobal\"",
",",
"\"set_global\"",
":",
"return",
"SetGlobal",
",",
"nil",
"\n",
"case",
"HasRoleString",
",",
"\"hasrole\"",
",",
"\"has_role\"",
":",
"return",
"HasRole",
",",
"nil",
"\n",
"case",
"AddRoleString",
",",
"\"addrole\"",
",",
"\"add_role\"",
":",
"return",
"AddRole",
",",
"nil",
"\n",
"case",
"RemoveRoleString",
",",
"\"removerole\"",
",",
"\"rmrole\"",
",",
"\"rm_role\"",
":",
"return",
"RemoveRole",
",",
"nil",
"\n",
"default",
":",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"unknown permission %s\"",
",",
"perm",
")",
"\n",
"}",
"\n",
"}"
] | // PermStringToFlag maps camel- and snake case strings to the
// the corresponding permission flag. | [
"PermStringToFlag",
"maps",
"camel",
"-",
"and",
"snake",
"case",
"strings",
"to",
"the",
"the",
"corresponding",
"permission",
"flag",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/permission/perm_flag.go#L140-L181 | train |
hyperledger/burrow | consensus/tendermint/tendermint.go | DBProvider | func (n *Node) DBProvider(ctx *node.DBContext) (dbm.DB, error) {
db := DBProvider(ctx.ID, dbm.DBBackendType(ctx.Config.DBBackend), ctx.Config.DBDir())
n.closers = append(n.closers, db)
return db, nil
} | go | func (n *Node) DBProvider(ctx *node.DBContext) (dbm.DB, error) {
db := DBProvider(ctx.ID, dbm.DBBackendType(ctx.Config.DBBackend), ctx.Config.DBDir())
n.closers = append(n.closers, db)
return db, nil
} | [
"func",
"(",
"n",
"*",
"Node",
")",
"DBProvider",
"(",
"ctx",
"*",
"node",
".",
"DBContext",
")",
"(",
"dbm",
".",
"DB",
",",
"error",
")",
"{",
"db",
":=",
"DBProvider",
"(",
"ctx",
".",
"ID",
",",
"dbm",
".",
"DBBackendType",
"(",
"ctx",
".",
"Config",
".",
"DBBackend",
")",
",",
"ctx",
".",
"Config",
".",
"DBDir",
"(",
")",
")",
"\n",
"n",
".",
"closers",
"=",
"append",
"(",
"n",
".",
"closers",
",",
"db",
")",
"\n",
"return",
"db",
",",
"nil",
"\n",
"}"
] | // Since Tendermint doesn't close its DB connections | [
"Since",
"Tendermint",
"doesn",
"t",
"close",
"its",
"DB",
"connections"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/consensus/tendermint/tendermint.go#L35-L39 | train |
hyperledger/burrow | vent/logger/logger.go | NewLogger | func NewLogger(level string) *Logger {
log := kitlog.NewJSONLogger(kitlog.NewSyncWriter(os.Stdout))
switch level {
case "error":
log = kitlevel.NewFilter(log, kitlevel.AllowError()) // only error logs
case "warn":
log = kitlevel.NewFilter(log, kitlevel.AllowWarn()) // warn + error logs
case "info":
log = kitlevel.NewFilter(log, kitlevel.AllowInfo()) // info + warn + error logs
case "debug":
log = kitlevel.NewFilter(log, kitlevel.AllowDebug()) // all logs
default:
log = kitlevel.NewFilter(log, kitlevel.AllowNone()) // no logs
}
log = kitlog.With(log, "service", "vent")
log = kitlog.With(log, "ts", kitlog.DefaultTimestampUTC)
log = kitlog.With(log, "caller", kitlog.Caller(4))
return &Logger{
Log: log,
}
} | go | func NewLogger(level string) *Logger {
log := kitlog.NewJSONLogger(kitlog.NewSyncWriter(os.Stdout))
switch level {
case "error":
log = kitlevel.NewFilter(log, kitlevel.AllowError()) // only error logs
case "warn":
log = kitlevel.NewFilter(log, kitlevel.AllowWarn()) // warn + error logs
case "info":
log = kitlevel.NewFilter(log, kitlevel.AllowInfo()) // info + warn + error logs
case "debug":
log = kitlevel.NewFilter(log, kitlevel.AllowDebug()) // all logs
default:
log = kitlevel.NewFilter(log, kitlevel.AllowNone()) // no logs
}
log = kitlog.With(log, "service", "vent")
log = kitlog.With(log, "ts", kitlog.DefaultTimestampUTC)
log = kitlog.With(log, "caller", kitlog.Caller(4))
return &Logger{
Log: log,
}
} | [
"func",
"NewLogger",
"(",
"level",
"string",
")",
"*",
"Logger",
"{",
"log",
":=",
"kitlog",
".",
"NewJSONLogger",
"(",
"kitlog",
".",
"NewSyncWriter",
"(",
"os",
".",
"Stdout",
")",
")",
"\n",
"switch",
"level",
"{",
"case",
"\"error\"",
":",
"log",
"=",
"kitlevel",
".",
"NewFilter",
"(",
"log",
",",
"kitlevel",
".",
"AllowError",
"(",
")",
")",
"\n",
"case",
"\"warn\"",
":",
"log",
"=",
"kitlevel",
".",
"NewFilter",
"(",
"log",
",",
"kitlevel",
".",
"AllowWarn",
"(",
")",
")",
"\n",
"case",
"\"info\"",
":",
"log",
"=",
"kitlevel",
".",
"NewFilter",
"(",
"log",
",",
"kitlevel",
".",
"AllowInfo",
"(",
")",
")",
"\n",
"case",
"\"debug\"",
":",
"log",
"=",
"kitlevel",
".",
"NewFilter",
"(",
"log",
",",
"kitlevel",
".",
"AllowDebug",
"(",
")",
")",
"\n",
"default",
":",
"log",
"=",
"kitlevel",
".",
"NewFilter",
"(",
"log",
",",
"kitlevel",
".",
"AllowNone",
"(",
")",
")",
"\n",
"}",
"\n",
"log",
"=",
"kitlog",
".",
"With",
"(",
"log",
",",
"\"service\"",
",",
"\"vent\"",
")",
"\n",
"log",
"=",
"kitlog",
".",
"With",
"(",
"log",
",",
"\"ts\"",
",",
"kitlog",
".",
"DefaultTimestampUTC",
")",
"\n",
"log",
"=",
"kitlog",
".",
"With",
"(",
"log",
",",
"\"caller\"",
",",
"kitlog",
".",
"Caller",
"(",
"4",
")",
")",
"\n",
"return",
"&",
"Logger",
"{",
"Log",
":",
"log",
",",
"}",
"\n",
"}"
] | // NewLogger creates a new logger based on the given level | [
"NewLogger",
"creates",
"a",
"new",
"logger",
"based",
"on",
"the",
"given",
"level"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/logger/logger.go#L16-L38 | train |
hyperledger/burrow | vent/logger/logger.go | Error | func (l *Logger) Error(args ...interface{}) {
kitlevel.Error(l.Log).Log(args...)
} | go | func (l *Logger) Error(args ...interface{}) {
kitlevel.Error(l.Log).Log(args...)
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Error",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"kitlevel",
".",
"Error",
"(",
"l",
".",
"Log",
")",
".",
"Log",
"(",
"args",
"...",
")",
"\n",
"}"
] | // Error prints an error log | [
"Error",
"prints",
"an",
"error",
"log"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/logger/logger.go#L48-L50 | train |
hyperledger/burrow | vent/logger/logger.go | Warn | func (l *Logger) Warn(args ...interface{}) {
kitlevel.Warn(l.Log).Log(args...)
} | go | func (l *Logger) Warn(args ...interface{}) {
kitlevel.Warn(l.Log).Log(args...)
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Warn",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"kitlevel",
".",
"Warn",
"(",
"l",
".",
"Log",
")",
".",
"Log",
"(",
"args",
"...",
")",
"\n",
"}"
] | // Warn prints a warning log | [
"Warn",
"prints",
"a",
"warning",
"log"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/logger/logger.go#L53-L55 | train |
hyperledger/burrow | vent/logger/logger.go | Info | func (l *Logger) Info(args ...interface{}) {
kitlevel.Info(l.Log).Log(args...)
} | go | func (l *Logger) Info(args ...interface{}) {
kitlevel.Info(l.Log).Log(args...)
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Info",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"kitlevel",
".",
"Info",
"(",
"l",
".",
"Log",
")",
".",
"Log",
"(",
"args",
"...",
")",
"\n",
"}"
] | // Info prints an information log | [
"Info",
"prints",
"an",
"information",
"log"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/logger/logger.go#L58-L60 | train |
hyperledger/burrow | vent/logger/logger.go | Debug | func (l *Logger) Debug(args ...interface{}) {
kitlevel.Debug(l.Log).Log(args...)
} | go | func (l *Logger) Debug(args ...interface{}) {
kitlevel.Debug(l.Log).Log(args...)
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Debug",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"kitlevel",
".",
"Debug",
"(",
"l",
".",
"Log",
")",
".",
"Log",
"(",
"args",
"...",
")",
"\n",
"}"
] | // Debug prints a debug log | [
"Debug",
"prints",
"a",
"debug",
"log"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/logger/logger.go#L63-L65 | train |
hyperledger/burrow | genesis/spec/template_account.go | RealisePublicKeyAndAddress | func (ta TemplateAccount) RealisePublicKeyAndAddress(keyClient keys.KeyClient) (pubKey crypto.PublicKey, address crypto.Address, err error) {
if ta.PublicKey == nil {
if ta.Address == nil {
// If neither PublicKey or Address set then generate a new one
address, err = keyClient.Generate(ta.Name, crypto.CurveTypeEd25519)
if err != nil {
return
}
} else {
address = *ta.Address
}
// Get the (possibly existing) key
pubKey, err = keyClient.PublicKey(address)
if err != nil {
return
}
} else {
address = (*ta.PublicKey).GetAddress()
if ta.Address != nil && *ta.Address != address {
err = fmt.Errorf("template address %s does not match public key derived address %s", ta.Address,
ta.PublicKey)
}
pubKey = *ta.PublicKey
}
return
} | go | func (ta TemplateAccount) RealisePublicKeyAndAddress(keyClient keys.KeyClient) (pubKey crypto.PublicKey, address crypto.Address, err error) {
if ta.PublicKey == nil {
if ta.Address == nil {
// If neither PublicKey or Address set then generate a new one
address, err = keyClient.Generate(ta.Name, crypto.CurveTypeEd25519)
if err != nil {
return
}
} else {
address = *ta.Address
}
// Get the (possibly existing) key
pubKey, err = keyClient.PublicKey(address)
if err != nil {
return
}
} else {
address = (*ta.PublicKey).GetAddress()
if ta.Address != nil && *ta.Address != address {
err = fmt.Errorf("template address %s does not match public key derived address %s", ta.Address,
ta.PublicKey)
}
pubKey = *ta.PublicKey
}
return
} | [
"func",
"(",
"ta",
"TemplateAccount",
")",
"RealisePublicKeyAndAddress",
"(",
"keyClient",
"keys",
".",
"KeyClient",
")",
"(",
"pubKey",
"crypto",
".",
"PublicKey",
",",
"address",
"crypto",
".",
"Address",
",",
"err",
"error",
")",
"{",
"if",
"ta",
".",
"PublicKey",
"==",
"nil",
"{",
"if",
"ta",
".",
"Address",
"==",
"nil",
"{",
"address",
",",
"err",
"=",
"keyClient",
".",
"Generate",
"(",
"ta",
".",
"Name",
",",
"crypto",
".",
"CurveTypeEd25519",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"else",
"{",
"address",
"=",
"*",
"ta",
".",
"Address",
"\n",
"}",
"\n",
"pubKey",
",",
"err",
"=",
"keyClient",
".",
"PublicKey",
"(",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"else",
"{",
"address",
"=",
"(",
"*",
"ta",
".",
"PublicKey",
")",
".",
"GetAddress",
"(",
")",
"\n",
"if",
"ta",
".",
"Address",
"!=",
"nil",
"&&",
"*",
"ta",
".",
"Address",
"!=",
"address",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"template address %s does not match public key derived address %s\"",
",",
"ta",
".",
"Address",
",",
"ta",
".",
"PublicKey",
")",
"\n",
"}",
"\n",
"pubKey",
"=",
"*",
"ta",
".",
"PublicKey",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Adds a public key and address to the template. If PublicKey will try to fetch it by Address.
// If both PublicKey and Address are not set will use the keyClient to generate a new keypair | [
"Adds",
"a",
"public",
"key",
"and",
"address",
"to",
"the",
"template",
".",
"If",
"PublicKey",
"will",
"try",
"to",
"fetch",
"it",
"by",
"Address",
".",
"If",
"both",
"PublicKey",
"and",
"Address",
"are",
"not",
"set",
"will",
"use",
"the",
"keyClient",
"to",
"generate",
"a",
"new",
"keypair"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/genesis/spec/template_account.go#L81-L106 | train |
hyperledger/burrow | consensus/abci/execute_tx.go | ExecuteTx | func ExecuteTx(logHeader string, executor execution.Executor, txDecoder txs.Decoder, txBytes []byte) types.ResponseCheckTx {
logf := func(format string, args ...interface{}) string {
return fmt.Sprintf("%s: "+format, append([]interface{}{logHeader}, args...)...)
}
txEnv, err := txDecoder.DecodeTx(txBytes)
if err != nil {
return types.ResponseCheckTx{
Code: codes.EncodingErrorCode,
Log: logf("Decoding error: %s", err),
}
}
tags := []common.KVPair{{Key: []byte(structure.TxHashKey), Value: []byte(txEnv.Tx.Hash().String())}}
txe, err := executor.Execute(txEnv)
if err != nil {
ex := errors.AsException(err)
return types.ResponseCheckTx{
Code: codes.TxExecutionErrorCode,
Tags: tags,
Log: logf("Could not execute transaction: %s, error: %v", txEnv, ex.Exception),
}
}
if txe.Receipt.CreatesContract {
tags = append(tags, common.KVPair{
Key: []byte("created_contract_address"),
Value: []byte(txe.Receipt.ContractAddress.String()),
})
}
bs, err := txe.Receipt.Encode()
if err != nil {
return types.ResponseCheckTx{
Code: codes.EncodingErrorCode,
Tags: tags,
Log: logf("Could not serialise receipt: %s", err),
}
}
return types.ResponseCheckTx{
Code: codes.TxExecutionSuccessCode,
Tags: tags,
Log: logf("Execution success - TxExecution in data"),
Data: bs,
}
} | go | func ExecuteTx(logHeader string, executor execution.Executor, txDecoder txs.Decoder, txBytes []byte) types.ResponseCheckTx {
logf := func(format string, args ...interface{}) string {
return fmt.Sprintf("%s: "+format, append([]interface{}{logHeader}, args...)...)
}
txEnv, err := txDecoder.DecodeTx(txBytes)
if err != nil {
return types.ResponseCheckTx{
Code: codes.EncodingErrorCode,
Log: logf("Decoding error: %s", err),
}
}
tags := []common.KVPair{{Key: []byte(structure.TxHashKey), Value: []byte(txEnv.Tx.Hash().String())}}
txe, err := executor.Execute(txEnv)
if err != nil {
ex := errors.AsException(err)
return types.ResponseCheckTx{
Code: codes.TxExecutionErrorCode,
Tags: tags,
Log: logf("Could not execute transaction: %s, error: %v", txEnv, ex.Exception),
}
}
if txe.Receipt.CreatesContract {
tags = append(tags, common.KVPair{
Key: []byte("created_contract_address"),
Value: []byte(txe.Receipt.ContractAddress.String()),
})
}
bs, err := txe.Receipt.Encode()
if err != nil {
return types.ResponseCheckTx{
Code: codes.EncodingErrorCode,
Tags: tags,
Log: logf("Could not serialise receipt: %s", err),
}
}
return types.ResponseCheckTx{
Code: codes.TxExecutionSuccessCode,
Tags: tags,
Log: logf("Execution success - TxExecution in data"),
Data: bs,
}
} | [
"func",
"ExecuteTx",
"(",
"logHeader",
"string",
",",
"executor",
"execution",
".",
"Executor",
",",
"txDecoder",
"txs",
".",
"Decoder",
",",
"txBytes",
"[",
"]",
"byte",
")",
"types",
".",
"ResponseCheckTx",
"{",
"logf",
":=",
"func",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s: \"",
"+",
"format",
",",
"append",
"(",
"[",
"]",
"interface",
"{",
"}",
"{",
"logHeader",
"}",
",",
"args",
"...",
")",
"...",
")",
"\n",
"}",
"\n",
"txEnv",
",",
"err",
":=",
"txDecoder",
".",
"DecodeTx",
"(",
"txBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"types",
".",
"ResponseCheckTx",
"{",
"Code",
":",
"codes",
".",
"EncodingErrorCode",
",",
"Log",
":",
"logf",
"(",
"\"Decoding error: %s\"",
",",
"err",
")",
",",
"}",
"\n",
"}",
"\n",
"tags",
":=",
"[",
"]",
"common",
".",
"KVPair",
"{",
"{",
"Key",
":",
"[",
"]",
"byte",
"(",
"structure",
".",
"TxHashKey",
")",
",",
"Value",
":",
"[",
"]",
"byte",
"(",
"txEnv",
".",
"Tx",
".",
"Hash",
"(",
")",
".",
"String",
"(",
")",
")",
"}",
"}",
"\n",
"txe",
",",
"err",
":=",
"executor",
".",
"Execute",
"(",
"txEnv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ex",
":=",
"errors",
".",
"AsException",
"(",
"err",
")",
"\n",
"return",
"types",
".",
"ResponseCheckTx",
"{",
"Code",
":",
"codes",
".",
"TxExecutionErrorCode",
",",
"Tags",
":",
"tags",
",",
"Log",
":",
"logf",
"(",
"\"Could not execute transaction: %s, error: %v\"",
",",
"txEnv",
",",
"ex",
".",
"Exception",
")",
",",
"}",
"\n",
"}",
"\n",
"if",
"txe",
".",
"Receipt",
".",
"CreatesContract",
"{",
"tags",
"=",
"append",
"(",
"tags",
",",
"common",
".",
"KVPair",
"{",
"Key",
":",
"[",
"]",
"byte",
"(",
"\"created_contract_address\"",
")",
",",
"Value",
":",
"[",
"]",
"byte",
"(",
"txe",
".",
"Receipt",
".",
"ContractAddress",
".",
"String",
"(",
")",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"bs",
",",
"err",
":=",
"txe",
".",
"Receipt",
".",
"Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"types",
".",
"ResponseCheckTx",
"{",
"Code",
":",
"codes",
".",
"EncodingErrorCode",
",",
"Tags",
":",
"tags",
",",
"Log",
":",
"logf",
"(",
"\"Could not serialise receipt: %s\"",
",",
"err",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"types",
".",
"ResponseCheckTx",
"{",
"Code",
":",
"codes",
".",
"TxExecutionSuccessCode",
",",
"Tags",
":",
"tags",
",",
"Log",
":",
"logf",
"(",
"\"Execution success - TxExecution in data\"",
")",
",",
"Data",
":",
"bs",
",",
"}",
"\n",
"}"
] | // Attempt to execute a transaction using ABCI conventions and codes | [
"Attempt",
"to",
"execute",
"a",
"transaction",
"using",
"ABCI",
"conventions",
"and",
"codes"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/consensus/abci/execute_tx.go#L17-L62 | train |
hyperledger/burrow | consensus/abci/execute_tx.go | WithTags | func WithTags(logger *logging.Logger, tags []common.KVPair) *logging.Logger {
keyvals := make([]interface{}, len(tags)*2)
for i, kvp := range tags {
keyvals[i] = string(kvp.Key)
keyvals[i+1] = string(kvp.Value)
}
return logger.With(keyvals...)
} | go | func WithTags(logger *logging.Logger, tags []common.KVPair) *logging.Logger {
keyvals := make([]interface{}, len(tags)*2)
for i, kvp := range tags {
keyvals[i] = string(kvp.Key)
keyvals[i+1] = string(kvp.Value)
}
return logger.With(keyvals...)
} | [
"func",
"WithTags",
"(",
"logger",
"*",
"logging",
".",
"Logger",
",",
"tags",
"[",
"]",
"common",
".",
"KVPair",
")",
"*",
"logging",
".",
"Logger",
"{",
"keyvals",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"tags",
")",
"*",
"2",
")",
"\n",
"for",
"i",
",",
"kvp",
":=",
"range",
"tags",
"{",
"keyvals",
"[",
"i",
"]",
"=",
"string",
"(",
"kvp",
".",
"Key",
")",
"\n",
"keyvals",
"[",
"i",
"+",
"1",
"]",
"=",
"string",
"(",
"kvp",
".",
"Value",
")",
"\n",
"}",
"\n",
"return",
"logger",
".",
"With",
"(",
"keyvals",
"...",
")",
"\n",
"}"
] | // Some ABCI type helpers | [
"Some",
"ABCI",
"type",
"helpers"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/consensus/abci/execute_tx.go#L66-L73 | train |
hyperledger/burrow | rpc/lib/server/handlers.go | jsonParamsToArgsWS | func jsonParamsToArgsWS(rpcFunc *RPCFunc, params json.RawMessage, wsCtx types.WSRPCContext) ([]reflect.Value, error) {
values, err := jsonParamsToArgs(rpcFunc, params, 1)
if err != nil {
return nil, err
}
return append([]reflect.Value{reflect.ValueOf(wsCtx)}, values...), nil
} | go | func jsonParamsToArgsWS(rpcFunc *RPCFunc, params json.RawMessage, wsCtx types.WSRPCContext) ([]reflect.Value, error) {
values, err := jsonParamsToArgs(rpcFunc, params, 1)
if err != nil {
return nil, err
}
return append([]reflect.Value{reflect.ValueOf(wsCtx)}, values...), nil
} | [
"func",
"jsonParamsToArgsWS",
"(",
"rpcFunc",
"*",
"RPCFunc",
",",
"params",
"json",
".",
"RawMessage",
",",
"wsCtx",
"types",
".",
"WSRPCContext",
")",
"(",
"[",
"]",
"reflect",
".",
"Value",
",",
"error",
")",
"{",
"values",
",",
"err",
":=",
"jsonParamsToArgs",
"(",
"rpcFunc",
",",
"params",
",",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"append",
"(",
"[",
"]",
"reflect",
".",
"Value",
"{",
"reflect",
".",
"ValueOf",
"(",
"wsCtx",
")",
"}",
",",
"values",
"...",
")",
",",
"nil",
"\n",
"}"
] | // Same as above, but with the first param the websocket connection | [
"Same",
"as",
"above",
"but",
"with",
"the",
"first",
"param",
"the",
"websocket",
"connection"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/rpc/lib/server/handlers.go#L228-L234 | train |
hyperledger/burrow | rpc/lib/server/handlers.go | NewWebsocketManager | func NewWebsocketManager(funcMap map[string]*RPCFunc, logger *logging.Logger,
wsConnOptions ...func(*wsConnection)) *WebsocketManager {
return &WebsocketManager{
funcMap: funcMap,
Upgrader: websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
// TODO ???
return true
},
},
logger: logger,
wsConnOptions: wsConnOptions,
}
} | go | func NewWebsocketManager(funcMap map[string]*RPCFunc, logger *logging.Logger,
wsConnOptions ...func(*wsConnection)) *WebsocketManager {
return &WebsocketManager{
funcMap: funcMap,
Upgrader: websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
// TODO ???
return true
},
},
logger: logger,
wsConnOptions: wsConnOptions,
}
} | [
"func",
"NewWebsocketManager",
"(",
"funcMap",
"map",
"[",
"string",
"]",
"*",
"RPCFunc",
",",
"logger",
"*",
"logging",
".",
"Logger",
",",
"wsConnOptions",
"...",
"func",
"(",
"*",
"wsConnection",
")",
")",
"*",
"WebsocketManager",
"{",
"return",
"&",
"WebsocketManager",
"{",
"funcMap",
":",
"funcMap",
",",
"Upgrader",
":",
"websocket",
".",
"Upgrader",
"{",
"CheckOrigin",
":",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"return",
"true",
"\n",
"}",
",",
"}",
",",
"logger",
":",
"logger",
",",
"wsConnOptions",
":",
"wsConnOptions",
",",
"}",
"\n",
"}"
] | // NewWebsocketManager returns a new WebsocketManager that routes according to
// the given funcMap and connects to the server with the given connection
// options. | [
"NewWebsocketManager",
"returns",
"a",
"new",
"WebsocketManager",
"that",
"routes",
"according",
"to",
"the",
"given",
"funcMap",
"and",
"connects",
"to",
"the",
"server",
"with",
"the",
"given",
"connection",
"options",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/rpc/lib/server/handlers.go#L686-L699 | train |
hyperledger/burrow | consensus/tendermint/sign_info.go | checkHRS | func (lsi *LastSignedInfo) checkHRS(height int64, round int, step int8) (bool, error) {
if lsi.Height > height {
return false, errors.New("Height regression")
}
if lsi.Height == height {
if lsi.Round > round {
return false, errors.New("Round regression")
}
if lsi.Round == round {
if lsi.Step > step {
return false, errors.New("Step regression")
} else if lsi.Step == step {
if lsi.SignBytes != nil {
if lsi.Signature == nil {
panic("pv: Signature is nil but SignBytes is not!")
}
return true, nil
}
return false, errors.New("No Signature found")
}
}
}
return false, nil
} | go | func (lsi *LastSignedInfo) checkHRS(height int64, round int, step int8) (bool, error) {
if lsi.Height > height {
return false, errors.New("Height regression")
}
if lsi.Height == height {
if lsi.Round > round {
return false, errors.New("Round regression")
}
if lsi.Round == round {
if lsi.Step > step {
return false, errors.New("Step regression")
} else if lsi.Step == step {
if lsi.SignBytes != nil {
if lsi.Signature == nil {
panic("pv: Signature is nil but SignBytes is not!")
}
return true, nil
}
return false, errors.New("No Signature found")
}
}
}
return false, nil
} | [
"func",
"(",
"lsi",
"*",
"LastSignedInfo",
")",
"checkHRS",
"(",
"height",
"int64",
",",
"round",
"int",
",",
"step",
"int8",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"lsi",
".",
"Height",
">",
"height",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"Height regression\"",
")",
"\n",
"}",
"\n",
"if",
"lsi",
".",
"Height",
"==",
"height",
"{",
"if",
"lsi",
".",
"Round",
">",
"round",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"Round regression\"",
")",
"\n",
"}",
"\n",
"if",
"lsi",
".",
"Round",
"==",
"round",
"{",
"if",
"lsi",
".",
"Step",
">",
"step",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"Step regression\"",
")",
"\n",
"}",
"else",
"if",
"lsi",
".",
"Step",
"==",
"step",
"{",
"if",
"lsi",
".",
"SignBytes",
"!=",
"nil",
"{",
"if",
"lsi",
".",
"Signature",
"==",
"nil",
"{",
"panic",
"(",
"\"pv: Signature is nil but SignBytes is not!\"",
")",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"No Signature found\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // returns error if HRS regression or no SignBytes. returns true if HRS is unchanged | [
"returns",
"error",
"if",
"HRS",
"regression",
"or",
"no",
"SignBytes",
".",
"returns",
"true",
"if",
"HRS",
"is",
"unchanged"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/consensus/tendermint/sign_info.go#L77-L102 | train |
hyperledger/burrow | consensus/tendermint/sign_info.go | String | func (lsi *LastSignedInfo) String() string {
return fmt.Sprintf("PrivValidator{LH:%v, LR:%v, LS:%v}", lsi.Height, lsi.Round, lsi.Step)
} | go | func (lsi *LastSignedInfo) String() string {
return fmt.Sprintf("PrivValidator{LH:%v, LR:%v, LS:%v}", lsi.Height, lsi.Round, lsi.Step)
} | [
"func",
"(",
"lsi",
"*",
"LastSignedInfo",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"PrivValidator{LH:%v, LR:%v, LS:%v}\"",
",",
"lsi",
".",
"Height",
",",
"lsi",
".",
"Round",
",",
"lsi",
".",
"Step",
")",
"\n",
"}"
] | // String returns a string representation of the LastSignedInfo. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"LastSignedInfo",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/consensus/tendermint/sign_info.go#L188-L190 | train |
hyperledger/burrow | util/snatives/templates/solidity_templates.go | InstanceName | func (contract *solidityContract) InstanceName() string {
// Hopefully the contract name is UpperCamelCase. If it's not, oh well, this
// is meant to be illustrative rather than cast iron compilable
instanceName := strings.ToLower(contract.Name[:1]) + contract.Name[1:]
if instanceName == contract.Name {
return "contractInstance"
}
return instanceName
} | go | func (contract *solidityContract) InstanceName() string {
// Hopefully the contract name is UpperCamelCase. If it's not, oh well, this
// is meant to be illustrative rather than cast iron compilable
instanceName := strings.ToLower(contract.Name[:1]) + contract.Name[1:]
if instanceName == contract.Name {
return "contractInstance"
}
return instanceName
} | [
"func",
"(",
"contract",
"*",
"solidityContract",
")",
"InstanceName",
"(",
")",
"string",
"{",
"instanceName",
":=",
"strings",
".",
"ToLower",
"(",
"contract",
".",
"Name",
"[",
":",
"1",
"]",
")",
"+",
"contract",
".",
"Name",
"[",
"1",
":",
"]",
"\n",
"if",
"instanceName",
"==",
"contract",
".",
"Name",
"{",
"return",
"\"contractInstance\"",
"\n",
"}",
"\n",
"return",
"instanceName",
"\n",
"}"
] | // Get a version of the contract name to be used for an instance of the contract | [
"Get",
"a",
"version",
"of",
"the",
"contract",
"name",
"to",
"be",
"used",
"for",
"an",
"instance",
"of",
"the",
"contract"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/util/snatives/templates/solidity_templates.go#L94-L102 | train |
hyperledger/burrow | util/snatives/templates/solidity_templates.go | Solidity | func (contract *solidityContract) Solidity() (string, error) {
buf := new(bytes.Buffer)
err := contractTemplate.Execute(buf, contract)
if err != nil {
return "", err
}
return buf.String(), nil
} | go | func (contract *solidityContract) Solidity() (string, error) {
buf := new(bytes.Buffer)
err := contractTemplate.Execute(buf, contract)
if err != nil {
return "", err
}
return buf.String(), nil
} | [
"func",
"(",
"contract",
"*",
"solidityContract",
")",
"Solidity",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"err",
":=",
"contractTemplate",
".",
"Execute",
"(",
"buf",
",",
"contract",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
",",
"nil",
"\n",
"}"
] | // Generate Solidity code for this SNative contract | [
"Generate",
"Solidity",
"code",
"for",
"this",
"SNative",
"contract"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/util/snatives/templates/solidity_templates.go#L110-L117 | train |
hyperledger/burrow | vent/sqldb/adapters/db_adapter.go | clean | func clean(parameter string) string {
replacer := strings.NewReplacer("\n", " ", "\t", "")
return replacer.Replace(parameter)
} | go | func clean(parameter string) string {
replacer := strings.NewReplacer("\n", " ", "\t", "")
return replacer.Replace(parameter)
} | [
"func",
"clean",
"(",
"parameter",
"string",
")",
"string",
"{",
"replacer",
":=",
"strings",
".",
"NewReplacer",
"(",
"\"\\n\"",
",",
"\\n",
",",
"\" \"",
",",
"\"\\t\"",
")",
"\n",
"\\t",
"\n",
"}"
] | // clean queries from tabs, spaces and returns | [
"clean",
"queries",
"from",
"tabs",
"spaces",
"and",
"returns"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/adapters/db_adapter.go#L59-L62 | train |
hyperledger/burrow | logging/loggers/channel_logger.go | WaitReadLogLine | func (cl *ChannelLogger) WaitReadLogLine() []interface{} {
logLine, ok := <-cl.ch.Out()
return readLogLine(logLine, ok)
} | go | func (cl *ChannelLogger) WaitReadLogLine() []interface{} {
logLine, ok := <-cl.ch.Out()
return readLogLine(logLine, ok)
} | [
"func",
"(",
"cl",
"*",
"ChannelLogger",
")",
"WaitReadLogLine",
"(",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"logLine",
",",
"ok",
":=",
"<-",
"cl",
".",
"ch",
".",
"Out",
"(",
")",
"\n",
"return",
"readLogLine",
"(",
"logLine",
",",
"ok",
")",
"\n",
"}"
] | // Read a log line by waiting until one is available and returning it | [
"Read",
"a",
"log",
"line",
"by",
"waiting",
"until",
"one",
"is",
"available",
"and",
"returning",
"it"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/logging/loggers/channel_logger.go#L68-L71 | train |
hyperledger/burrow | logging/loggers/channel_logger.go | ReadLogLine | func (cl *ChannelLogger) ReadLogLine() []interface{} {
select {
case logLine, ok := <-cl.ch.Out():
return readLogLine(logLine, ok)
default:
return nil
}
} | go | func (cl *ChannelLogger) ReadLogLine() []interface{} {
select {
case logLine, ok := <-cl.ch.Out():
return readLogLine(logLine, ok)
default:
return nil
}
} | [
"func",
"(",
"cl",
"*",
"ChannelLogger",
")",
"ReadLogLine",
"(",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"select",
"{",
"case",
"logLine",
",",
"ok",
":=",
"<-",
"cl",
".",
"ch",
".",
"Out",
"(",
")",
":",
"return",
"readLogLine",
"(",
"logLine",
",",
"ok",
")",
"\n",
"default",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Tries to read a log line from the channel buffer or returns nil if none is
// immediately available | [
"Tries",
"to",
"read",
"a",
"log",
"line",
"from",
"the",
"channel",
"buffer",
"or",
"returns",
"nil",
"if",
"none",
"is",
"immediately",
"available"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/logging/loggers/channel_logger.go#L75-L82 | train |
hyperledger/burrow | logging/loggers/channel_logger.go | DrainForever | func (cl *ChannelLogger) DrainForever(logger log.Logger, errCh channels.Channel) {
// logLine could be nil if channel was closed while waiting for next line
for logLine := cl.WaitReadLogLine(); logLine != nil; logLine = cl.WaitReadLogLine() {
err := logger.Log(logLine...)
if err != nil && errCh != nil {
errCh.In() <- err
}
}
} | go | func (cl *ChannelLogger) DrainForever(logger log.Logger, errCh channels.Channel) {
// logLine could be nil if channel was closed while waiting for next line
for logLine := cl.WaitReadLogLine(); logLine != nil; logLine = cl.WaitReadLogLine() {
err := logger.Log(logLine...)
if err != nil && errCh != nil {
errCh.In() <- err
}
}
} | [
"func",
"(",
"cl",
"*",
"ChannelLogger",
")",
"DrainForever",
"(",
"logger",
"log",
".",
"Logger",
",",
"errCh",
"channels",
".",
"Channel",
")",
"{",
"for",
"logLine",
":=",
"cl",
".",
"WaitReadLogLine",
"(",
")",
";",
"logLine",
"!=",
"nil",
";",
"logLine",
"=",
"cl",
".",
"WaitReadLogLine",
"(",
")",
"{",
"err",
":=",
"logger",
".",
"Log",
"(",
"logLine",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"errCh",
"!=",
"nil",
"{",
"errCh",
".",
"In",
"(",
")",
"<-",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Enters an infinite loop that will drain any log lines from the passed logger.
// You may pass in a channel
//
// Exits if the channel is closed. | [
"Enters",
"an",
"infinite",
"loop",
"that",
"will",
"drain",
"any",
"log",
"lines",
"from",
"the",
"passed",
"logger",
".",
"You",
"may",
"pass",
"in",
"a",
"channel",
"Exits",
"if",
"the",
"channel",
"is",
"closed",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/logging/loggers/channel_logger.go#L99-L107 | train |
hyperledger/burrow | logging/loggers/channel_logger.go | Flush | func (cl *ChannelLogger) Flush(logger log.Logger) error {
// Grab the buffer at the here rather than within loop condition so that we
// do not drain the buffer forever
cl.Lock()
defer cl.Unlock()
bufferLength := cl.BufferLength()
var errs []error
for i := 0; i < bufferLength; i++ {
logLine := cl.WaitReadLogLine()
if logLine != nil {
err := logger.Log(logLine...)
if err != nil {
errs = append(errs, err)
}
}
}
return errors.CombineErrors(errs)
} | go | func (cl *ChannelLogger) Flush(logger log.Logger) error {
// Grab the buffer at the here rather than within loop condition so that we
// do not drain the buffer forever
cl.Lock()
defer cl.Unlock()
bufferLength := cl.BufferLength()
var errs []error
for i := 0; i < bufferLength; i++ {
logLine := cl.WaitReadLogLine()
if logLine != nil {
err := logger.Log(logLine...)
if err != nil {
errs = append(errs, err)
}
}
}
return errors.CombineErrors(errs)
} | [
"func",
"(",
"cl",
"*",
"ChannelLogger",
")",
"Flush",
"(",
"logger",
"log",
".",
"Logger",
")",
"error",
"{",
"cl",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cl",
".",
"Unlock",
"(",
")",
"\n",
"bufferLength",
":=",
"cl",
".",
"BufferLength",
"(",
")",
"\n",
"var",
"errs",
"[",
"]",
"error",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"bufferLength",
";",
"i",
"++",
"{",
"logLine",
":=",
"cl",
".",
"WaitReadLogLine",
"(",
")",
"\n",
"if",
"logLine",
"!=",
"nil",
"{",
"err",
":=",
"logger",
".",
"Log",
"(",
"logLine",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"errors",
".",
"CombineErrors",
"(",
"errs",
")",
"\n",
"}"
] | // Drains everything that is available at the time of calling | [
"Drains",
"everything",
"that",
"is",
"available",
"at",
"the",
"time",
"of",
"calling"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/logging/loggers/channel_logger.go#L110-L127 | train |
hyperledger/burrow | logging/loggers/channel_logger.go | FlushLogLines | func (cl *ChannelLogger) FlushLogLines() [][]interface{} {
logLines := make([][]interface{}, 0, cl.ch.Len())
cl.Flush(log.LoggerFunc(func(keyvals ...interface{}) error {
logLines = append(logLines, keyvals)
return nil
}))
return logLines
} | go | func (cl *ChannelLogger) FlushLogLines() [][]interface{} {
logLines := make([][]interface{}, 0, cl.ch.Len())
cl.Flush(log.LoggerFunc(func(keyvals ...interface{}) error {
logLines = append(logLines, keyvals)
return nil
}))
return logLines
} | [
"func",
"(",
"cl",
"*",
"ChannelLogger",
")",
"FlushLogLines",
"(",
")",
"[",
"]",
"[",
"]",
"interface",
"{",
"}",
"{",
"logLines",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
",",
"cl",
".",
"ch",
".",
"Len",
"(",
")",
")",
"\n",
"cl",
".",
"Flush",
"(",
"log",
".",
"LoggerFunc",
"(",
"func",
"(",
"keyvals",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"logLines",
"=",
"append",
"(",
"logLines",
",",
"keyvals",
")",
"\n",
"return",
"nil",
"\n",
"}",
")",
")",
"\n",
"return",
"logLines",
"\n",
"}"
] | // Drains the next contiguous segment of loglines up to the buffer cap waiting
// for at least one line | [
"Drains",
"the",
"next",
"contiguous",
"segment",
"of",
"loglines",
"up",
"to",
"the",
"buffer",
"cap",
"waiting",
"for",
"at",
"least",
"one",
"line"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/logging/loggers/channel_logger.go#L131-L138 | train |
hyperledger/burrow | logging/loggers/channel_logger.go | Reset | func (cl *ChannelLogger) Reset() {
cl.RWMutex.Lock()
defer cl.RWMutex.Unlock()
cl.ch.Close()
cl.ch = channels.NewRingChannel(cl.ch.Cap())
} | go | func (cl *ChannelLogger) Reset() {
cl.RWMutex.Lock()
defer cl.RWMutex.Unlock()
cl.ch.Close()
cl.ch = channels.NewRingChannel(cl.ch.Cap())
} | [
"func",
"(",
"cl",
"*",
"ChannelLogger",
")",
"Reset",
"(",
")",
"{",
"cl",
".",
"RWMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cl",
".",
"RWMutex",
".",
"Unlock",
"(",
")",
"\n",
"cl",
".",
"ch",
".",
"Close",
"(",
")",
"\n",
"cl",
".",
"ch",
"=",
"channels",
".",
"NewRingChannel",
"(",
"cl",
".",
"ch",
".",
"Cap",
"(",
")",
")",
"\n",
"}"
] | // Close the existing channel halting goroutines that are draining the channel
// and create a new channel to buffer into. Should not cause any log lines
// arriving concurrently to be lost, but any that have not been drained from
// old channel may be. | [
"Close",
"the",
"existing",
"channel",
"halting",
"goroutines",
"that",
"are",
"draining",
"the",
"channel",
"and",
"create",
"a",
"new",
"channel",
"to",
"buffer",
"into",
".",
"Should",
"not",
"cause",
"any",
"log",
"lines",
"arriving",
"concurrently",
"to",
"be",
"lost",
"but",
"any",
"that",
"have",
"not",
"been",
"drained",
"from",
"old",
"channel",
"may",
"be",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/logging/loggers/channel_logger.go#L144-L149 | train |
hyperledger/burrow | logging/loggers/channel_logger.go | NonBlockingLogger | func NonBlockingLogger(outputLogger log.Logger) (*ChannelLogger, channels.Channel) {
cl := NewChannelLogger(DefaultLoggingRingBufferCap)
errCh := channels.NewRingChannel(cl.BufferCap())
go cl.DrainForever(outputLogger, errCh)
return cl, errCh
} | go | func NonBlockingLogger(outputLogger log.Logger) (*ChannelLogger, channels.Channel) {
cl := NewChannelLogger(DefaultLoggingRingBufferCap)
errCh := channels.NewRingChannel(cl.BufferCap())
go cl.DrainForever(outputLogger, errCh)
return cl, errCh
} | [
"func",
"NonBlockingLogger",
"(",
"outputLogger",
"log",
".",
"Logger",
")",
"(",
"*",
"ChannelLogger",
",",
"channels",
".",
"Channel",
")",
"{",
"cl",
":=",
"NewChannelLogger",
"(",
"DefaultLoggingRingBufferCap",
")",
"\n",
"errCh",
":=",
"channels",
".",
"NewRingChannel",
"(",
"cl",
".",
"BufferCap",
"(",
")",
")",
"\n",
"go",
"cl",
".",
"DrainForever",
"(",
"outputLogger",
",",
"errCh",
")",
"\n",
"return",
"cl",
",",
"errCh",
"\n",
"}"
] | // Returns a Logger that wraps the outputLogger passed and does not block on
// calls to Log and a channel of any errors from the underlying logger | [
"Returns",
"a",
"Logger",
"that",
"wraps",
"the",
"outputLogger",
"passed",
"and",
"does",
"not",
"block",
"on",
"calls",
"to",
"Log",
"and",
"a",
"channel",
"of",
"any",
"errors",
"from",
"the",
"underlying",
"logger"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/logging/loggers/channel_logger.go#L153-L158 | train |
hyperledger/burrow | execution/state/state.go | NewState | func NewState(db dbm.DB) *State {
forest, err := storage.NewMutableForest(storage.NewPrefixDB(db, forestPrefix), defaultCacheCapacity)
if err != nil {
// This should only happen if we have negative cache capacity, which for us is a positive compile-time constant
panic(fmt.Errorf("could not create new state because error creating MutableForest"))
}
ring := validator.NewRing(nil, DefaultValidatorsWindowSize)
rs := ReadState{Forest: forest, History: ring}
ws := writeState{forest: forest, ring: ring}
return &State{
db: db,
ReadState: rs,
writeState: ws,
logger: logging.NewNoopLogger(),
}
} | go | func NewState(db dbm.DB) *State {
forest, err := storage.NewMutableForest(storage.NewPrefixDB(db, forestPrefix), defaultCacheCapacity)
if err != nil {
// This should only happen if we have negative cache capacity, which for us is a positive compile-time constant
panic(fmt.Errorf("could not create new state because error creating MutableForest"))
}
ring := validator.NewRing(nil, DefaultValidatorsWindowSize)
rs := ReadState{Forest: forest, History: ring}
ws := writeState{forest: forest, ring: ring}
return &State{
db: db,
ReadState: rs,
writeState: ws,
logger: logging.NewNoopLogger(),
}
} | [
"func",
"NewState",
"(",
"db",
"dbm",
".",
"DB",
")",
"*",
"State",
"{",
"forest",
",",
"err",
":=",
"storage",
".",
"NewMutableForest",
"(",
"storage",
".",
"NewPrefixDB",
"(",
"db",
",",
"forestPrefix",
")",
",",
"defaultCacheCapacity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"could not create new state because error creating MutableForest\"",
")",
")",
"\n",
"}",
"\n",
"ring",
":=",
"validator",
".",
"NewRing",
"(",
"nil",
",",
"DefaultValidatorsWindowSize",
")",
"\n",
"rs",
":=",
"ReadState",
"{",
"Forest",
":",
"forest",
",",
"History",
":",
"ring",
"}",
"\n",
"ws",
":=",
"writeState",
"{",
"forest",
":",
"forest",
",",
"ring",
":",
"ring",
"}",
"\n",
"return",
"&",
"State",
"{",
"db",
":",
"db",
",",
"ReadState",
":",
"rs",
",",
"writeState",
":",
"ws",
",",
"logger",
":",
"logging",
".",
"NewNoopLogger",
"(",
")",
",",
"}",
"\n",
"}"
] | // Create a new State object | [
"Create",
"a",
"new",
"State",
"object"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/state/state.go#L115-L130 | train |
hyperledger/burrow | execution/state/state.go | MakeGenesisState | func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error) {
s := NewState(db)
const errHeader = "MakeGenesisState():"
// Make accounts state tree
for _, genAcc := range genesisDoc.Accounts {
perm := genAcc.Permissions
acc := &acm.Account{
Address: genAcc.Address,
Balance: genAcc.Amount,
Permissions: perm,
}
err := s.writeState.UpdateAccount(acc)
if err != nil {
return nil, fmt.Errorf("%s %v", errHeader, err)
}
}
// Make genesis validators
err := s.writeState.MakeGenesisValidators(genesisDoc)
if err != nil {
return nil, fmt.Errorf("%s %v", errHeader, err)
}
// global permissions are saved as the 0 address
// so they are included in the accounts tree
globalPerms := permission.DefaultAccountPermissions
globalPerms = genesisDoc.GlobalPermissions
// XXX: make sure the set bits are all true
// Without it the HasPermission() functions will fail
globalPerms.Base.SetBit = permission.AllPermFlags
permsAcc := &acm.Account{
Address: acm.GlobalPermissionsAddress,
Balance: 1337,
Permissions: globalPerms,
}
err = s.writeState.UpdateAccount(permsAcc)
if err != nil {
return nil, fmt.Errorf("%s %v", errHeader, err)
}
return s, nil
} | go | func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error) {
s := NewState(db)
const errHeader = "MakeGenesisState():"
// Make accounts state tree
for _, genAcc := range genesisDoc.Accounts {
perm := genAcc.Permissions
acc := &acm.Account{
Address: genAcc.Address,
Balance: genAcc.Amount,
Permissions: perm,
}
err := s.writeState.UpdateAccount(acc)
if err != nil {
return nil, fmt.Errorf("%s %v", errHeader, err)
}
}
// Make genesis validators
err := s.writeState.MakeGenesisValidators(genesisDoc)
if err != nil {
return nil, fmt.Errorf("%s %v", errHeader, err)
}
// global permissions are saved as the 0 address
// so they are included in the accounts tree
globalPerms := permission.DefaultAccountPermissions
globalPerms = genesisDoc.GlobalPermissions
// XXX: make sure the set bits are all true
// Without it the HasPermission() functions will fail
globalPerms.Base.SetBit = permission.AllPermFlags
permsAcc := &acm.Account{
Address: acm.GlobalPermissionsAddress,
Balance: 1337,
Permissions: globalPerms,
}
err = s.writeState.UpdateAccount(permsAcc)
if err != nil {
return nil, fmt.Errorf("%s %v", errHeader, err)
}
return s, nil
} | [
"func",
"MakeGenesisState",
"(",
"db",
"dbm",
".",
"DB",
",",
"genesisDoc",
"*",
"genesis",
".",
"GenesisDoc",
")",
"(",
"*",
"State",
",",
"error",
")",
"{",
"s",
":=",
"NewState",
"(",
"db",
")",
"\n",
"const",
"errHeader",
"=",
"\"MakeGenesisState():\"",
"\n",
"for",
"_",
",",
"genAcc",
":=",
"range",
"genesisDoc",
".",
"Accounts",
"{",
"perm",
":=",
"genAcc",
".",
"Permissions",
"\n",
"acc",
":=",
"&",
"acm",
".",
"Account",
"{",
"Address",
":",
"genAcc",
".",
"Address",
",",
"Balance",
":",
"genAcc",
".",
"Amount",
",",
"Permissions",
":",
"perm",
",",
"}",
"\n",
"err",
":=",
"s",
".",
"writeState",
".",
"UpdateAccount",
"(",
"acc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"%s %v\"",
",",
"errHeader",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"writeState",
".",
"MakeGenesisValidators",
"(",
"genesisDoc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"%s %v\"",
",",
"errHeader",
",",
"err",
")",
"\n",
"}",
"\n",
"globalPerms",
":=",
"permission",
".",
"DefaultAccountPermissions",
"\n",
"globalPerms",
"=",
"genesisDoc",
".",
"GlobalPermissions",
"\n",
"globalPerms",
".",
"Base",
".",
"SetBit",
"=",
"permission",
".",
"AllPermFlags",
"\n",
"permsAcc",
":=",
"&",
"acm",
".",
"Account",
"{",
"Address",
":",
"acm",
".",
"GlobalPermissionsAddress",
",",
"Balance",
":",
"1337",
",",
"Permissions",
":",
"globalPerms",
",",
"}",
"\n",
"err",
"=",
"s",
".",
"writeState",
".",
"UpdateAccount",
"(",
"permsAcc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"%s %v\"",
",",
"errHeader",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] | // Make genesis state from GenesisDoc and save to DB | [
"Make",
"genesis",
"state",
"from",
"GenesisDoc",
"and",
"save",
"to",
"DB"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/state/state.go#L133-L174 | train |
hyperledger/burrow | execution/state/state.go | Update | func (s *State) Update(updater func(up Updatable) error) ([]byte, int64, error) {
s.Lock()
defer s.Unlock()
err := updater(&s.writeState)
if err != nil {
return nil, 0, err
}
return s.commit()
} | go | func (s *State) Update(updater func(up Updatable) error) ([]byte, int64, error) {
s.Lock()
defer s.Unlock()
err := updater(&s.writeState)
if err != nil {
return nil, 0, err
}
return s.commit()
} | [
"func",
"(",
"s",
"*",
"State",
")",
"Update",
"(",
"updater",
"func",
"(",
"up",
"Updatable",
")",
"error",
")",
"(",
"[",
"]",
"byte",
",",
"int64",
",",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"err",
":=",
"updater",
"(",
"&",
"s",
".",
"writeState",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"s",
".",
"commit",
"(",
")",
"\n",
"}"
] | // Perform updates to state whilst holding the write lock, allows a commit to hold the write lock across multiple
// operations while preventing interlaced reads and writes | [
"Perform",
"updates",
"to",
"state",
"whilst",
"holding",
"the",
"write",
"lock",
"allows",
"a",
"commit",
"to",
"hold",
"the",
"write",
"lock",
"across",
"multiple",
"operations",
"while",
"preventing",
"interlaced",
"reads",
"and",
"writes"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/state/state.go#L244-L252 | train |
hyperledger/burrow | execution/state/state.go | Copy | func (s *State) Copy(db dbm.DB) (*State, error) {
stateCopy := NewState(db)
err := s.writeState.forest.IterateRWTree(nil, nil, true,
func(prefix []byte, tree *storage.RWTree) error {
treeCopy, err := stateCopy.writeState.forest.Writer(prefix)
if err != nil {
return err
}
return tree.IterateWriteTree(nil, nil, true, func(key []byte, value []byte) error {
treeCopy.Set(key, value)
return nil
})
})
if err != nil {
return nil, err
}
_, _, err = stateCopy.commit()
if err != nil {
return nil, err
}
return stateCopy, nil
} | go | func (s *State) Copy(db dbm.DB) (*State, error) {
stateCopy := NewState(db)
err := s.writeState.forest.IterateRWTree(nil, nil, true,
func(prefix []byte, tree *storage.RWTree) error {
treeCopy, err := stateCopy.writeState.forest.Writer(prefix)
if err != nil {
return err
}
return tree.IterateWriteTree(nil, nil, true, func(key []byte, value []byte) error {
treeCopy.Set(key, value)
return nil
})
})
if err != nil {
return nil, err
}
_, _, err = stateCopy.commit()
if err != nil {
return nil, err
}
return stateCopy, nil
} | [
"func",
"(",
"s",
"*",
"State",
")",
"Copy",
"(",
"db",
"dbm",
".",
"DB",
")",
"(",
"*",
"State",
",",
"error",
")",
"{",
"stateCopy",
":=",
"NewState",
"(",
"db",
")",
"\n",
"err",
":=",
"s",
".",
"writeState",
".",
"forest",
".",
"IterateRWTree",
"(",
"nil",
",",
"nil",
",",
"true",
",",
"func",
"(",
"prefix",
"[",
"]",
"byte",
",",
"tree",
"*",
"storage",
".",
"RWTree",
")",
"error",
"{",
"treeCopy",
",",
"err",
":=",
"stateCopy",
".",
"writeState",
".",
"forest",
".",
"Writer",
"(",
"prefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"tree",
".",
"IterateWriteTree",
"(",
"nil",
",",
"nil",
",",
"true",
",",
"func",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"error",
"{",
"treeCopy",
".",
"Set",
"(",
"key",
",",
"value",
")",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"_",
",",
"err",
"=",
"stateCopy",
".",
"commit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"stateCopy",
",",
"nil",
"\n",
"}"
] | // Creates a copy of the database to the supplied db | [
"Creates",
"a",
"copy",
"of",
"the",
"database",
"to",
"the",
"supplied",
"db"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/state/state.go#L272-L293 | train |
hyperledger/burrow | vent/sqldb/sqldb.go | NewSQLDB | func NewSQLDB(connection types.SQLConnection) (*SQLDB, error) {
db := &SQLDB{
Schema: connection.DBSchema,
Log: connection.Log,
}
var url string
switch connection.DBAdapter {
case types.PostgresDB:
db.DBAdapter = adapters.NewPostgresAdapter(safe(connection.DBSchema), connection.Log)
url = connection.DBURL
case types.SQLiteDB:
db.DBAdapter = adapters.NewSQLiteAdapter(connection.Log)
// "?_journal_mode=WAL" parameter is necessary to prevent database locking
url = connection.DBURL + "?_journal_mode=WAL"
default:
return nil, errors.New("invalid database adapter")
}
var err error
db.DB, err = db.DBAdapter.Open(url)
if err != nil {
db.Log.Info("msg", "Error opening database connection", "err", err)
return nil, err
}
if err = db.Ping(); err != nil {
db.Log.Info("msg", "Error database not available", "err", err)
return nil, err
}
db.Log.Info("msg", "Initializing DB")
// Create dictionary and log tables
sysTables := db.getSysTablesDefinition()
// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (1)
if err = db.createTable(sysTables[types.SQLDictionaryTableName], true); err != nil {
if !db.DBAdapter.ErrorEquals(err, types.SQLErrorTypeDuplicatedTable) {
db.Log.Info("msg", "Error creating Dictionary table", "err", err)
return nil, err
}
}
// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (2)
if err = db.createTable(sysTables[types.SQLLogTableName], true); err != nil {
if !db.DBAdapter.ErrorEquals(err, types.SQLErrorTypeDuplicatedTable) {
db.Log.Info("msg", "Error creating Log table", "err", err)
return nil, err
}
}
// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (3)
if err = db.createTable(sysTables[types.SQLChainInfoTableName], true); err != nil {
if !db.DBAdapter.ErrorEquals(err, types.SQLErrorTypeDuplicatedTable) {
db.Log.Info("msg", "Error creating Chain Info table", "err", err)
return nil, err
}
}
if err = db.CleanTables(connection.ChainID, connection.BurrowVersion); err != nil {
db.Log.Info("msg", "Error cleaning tables", "err", err)
return nil, err
}
return db, nil
} | go | func NewSQLDB(connection types.SQLConnection) (*SQLDB, error) {
db := &SQLDB{
Schema: connection.DBSchema,
Log: connection.Log,
}
var url string
switch connection.DBAdapter {
case types.PostgresDB:
db.DBAdapter = adapters.NewPostgresAdapter(safe(connection.DBSchema), connection.Log)
url = connection.DBURL
case types.SQLiteDB:
db.DBAdapter = adapters.NewSQLiteAdapter(connection.Log)
// "?_journal_mode=WAL" parameter is necessary to prevent database locking
url = connection.DBURL + "?_journal_mode=WAL"
default:
return nil, errors.New("invalid database adapter")
}
var err error
db.DB, err = db.DBAdapter.Open(url)
if err != nil {
db.Log.Info("msg", "Error opening database connection", "err", err)
return nil, err
}
if err = db.Ping(); err != nil {
db.Log.Info("msg", "Error database not available", "err", err)
return nil, err
}
db.Log.Info("msg", "Initializing DB")
// Create dictionary and log tables
sysTables := db.getSysTablesDefinition()
// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (1)
if err = db.createTable(sysTables[types.SQLDictionaryTableName], true); err != nil {
if !db.DBAdapter.ErrorEquals(err, types.SQLErrorTypeDuplicatedTable) {
db.Log.Info("msg", "Error creating Dictionary table", "err", err)
return nil, err
}
}
// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (2)
if err = db.createTable(sysTables[types.SQLLogTableName], true); err != nil {
if !db.DBAdapter.ErrorEquals(err, types.SQLErrorTypeDuplicatedTable) {
db.Log.Info("msg", "Error creating Log table", "err", err)
return nil, err
}
}
// IMPORTANT: DO NOT CHANGE TABLE CREATION ORDER (3)
if err = db.createTable(sysTables[types.SQLChainInfoTableName], true); err != nil {
if !db.DBAdapter.ErrorEquals(err, types.SQLErrorTypeDuplicatedTable) {
db.Log.Info("msg", "Error creating Chain Info table", "err", err)
return nil, err
}
}
if err = db.CleanTables(connection.ChainID, connection.BurrowVersion); err != nil {
db.Log.Info("msg", "Error cleaning tables", "err", err)
return nil, err
}
return db, nil
} | [
"func",
"NewSQLDB",
"(",
"connection",
"types",
".",
"SQLConnection",
")",
"(",
"*",
"SQLDB",
",",
"error",
")",
"{",
"db",
":=",
"&",
"SQLDB",
"{",
"Schema",
":",
"connection",
".",
"DBSchema",
",",
"Log",
":",
"connection",
".",
"Log",
",",
"}",
"\n",
"var",
"url",
"string",
"\n",
"switch",
"connection",
".",
"DBAdapter",
"{",
"case",
"types",
".",
"PostgresDB",
":",
"db",
".",
"DBAdapter",
"=",
"adapters",
".",
"NewPostgresAdapter",
"(",
"safe",
"(",
"connection",
".",
"DBSchema",
")",
",",
"connection",
".",
"Log",
")",
"\n",
"url",
"=",
"connection",
".",
"DBURL",
"\n",
"case",
"types",
".",
"SQLiteDB",
":",
"db",
".",
"DBAdapter",
"=",
"adapters",
".",
"NewSQLiteAdapter",
"(",
"connection",
".",
"Log",
")",
"\n",
"url",
"=",
"connection",
".",
"DBURL",
"+",
"\"?_journal_mode=WAL\"",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"invalid database adapter\"",
")",
"\n",
"}",
"\n",
"var",
"err",
"error",
"\n",
"db",
".",
"DB",
",",
"err",
"=",
"db",
".",
"DBAdapter",
".",
"Open",
"(",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error opening database connection\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"db",
".",
"Ping",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error database not available\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Initializing DB\"",
")",
"\n",
"sysTables",
":=",
"db",
".",
"getSysTablesDefinition",
"(",
")",
"\n",
"if",
"err",
"=",
"db",
".",
"createTable",
"(",
"sysTables",
"[",
"types",
".",
"SQLDictionaryTableName",
"]",
",",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"!",
"db",
".",
"DBAdapter",
".",
"ErrorEquals",
"(",
"err",
",",
"types",
".",
"SQLErrorTypeDuplicatedTable",
")",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error creating Dictionary table\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"=",
"db",
".",
"createTable",
"(",
"sysTables",
"[",
"types",
".",
"SQLLogTableName",
"]",
",",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"!",
"db",
".",
"DBAdapter",
".",
"ErrorEquals",
"(",
"err",
",",
"types",
".",
"SQLErrorTypeDuplicatedTable",
")",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error creating Log table\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"=",
"db",
".",
"createTable",
"(",
"sysTables",
"[",
"types",
".",
"SQLChainInfoTableName",
"]",
",",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"!",
"db",
".",
"DBAdapter",
".",
"ErrorEquals",
"(",
"err",
",",
"types",
".",
"SQLErrorTypeDuplicatedTable",
")",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error creating Chain Info table\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"=",
"db",
".",
"CleanTables",
"(",
"connection",
".",
"ChainID",
",",
"connection",
".",
"BurrowVersion",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error cleaning tables\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"db",
",",
"nil",
"\n",
"}"
] | // NewSQLDB delegates work to a specific database adapter implementation,
// opens database connection and create log tables | [
"NewSQLDB",
"delegates",
"work",
"to",
"a",
"specific",
"database",
"adapter",
"implementation",
"opens",
"database",
"connection",
"and",
"create",
"log",
"tables"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/sqldb.go#L26-L94 | train |
hyperledger/burrow | vent/sqldb/sqldb.go | Close | func (db *SQLDB) Close() {
if err := db.DB.Close(); err != nil {
db.Log.Error("msg", "Error closing database", "err", err)
}
} | go | func (db *SQLDB) Close() {
if err := db.DB.Close(); err != nil {
db.Log.Error("msg", "Error closing database", "err", err)
}
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"Close",
"(",
")",
"{",
"if",
"err",
":=",
"db",
".",
"DB",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Error",
"(",
"\"msg\"",
",",
"\"Error closing database\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // Close database connection | [
"Close",
"database",
"connection"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/sqldb.go#L222-L226 | train |
hyperledger/burrow | vent/sqldb/sqldb.go | GetLastBlockHeight | func (db *SQLDB) GetLastBlockHeight() (uint64, error) {
query := db.DBAdapter.LastBlockIDQuery()
id := ""
db.Log.Info("msg", "MAX ID", "query", query)
if err := db.DB.QueryRow(query).Scan(&id); err != nil {
db.Log.Info("msg", "Error selecting last block id", "err", err)
return 0, err
}
height, err := strconv.ParseUint(id, 10, 64)
if err != nil {
return 0, fmt.Errorf("could not parse height from block ID: %v", err)
}
return height, nil
} | go | func (db *SQLDB) GetLastBlockHeight() (uint64, error) {
query := db.DBAdapter.LastBlockIDQuery()
id := ""
db.Log.Info("msg", "MAX ID", "query", query)
if err := db.DB.QueryRow(query).Scan(&id); err != nil {
db.Log.Info("msg", "Error selecting last block id", "err", err)
return 0, err
}
height, err := strconv.ParseUint(id, 10, 64)
if err != nil {
return 0, fmt.Errorf("could not parse height from block ID: %v", err)
}
return height, nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"GetLastBlockHeight",
"(",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"query",
":=",
"db",
".",
"DBAdapter",
".",
"LastBlockIDQuery",
"(",
")",
"\n",
"id",
":=",
"\"\"",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"MAX ID\"",
",",
"\"query\"",
",",
"query",
")",
"\n",
"if",
"err",
":=",
"db",
".",
"DB",
".",
"QueryRow",
"(",
"query",
")",
".",
"Scan",
"(",
"&",
"id",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error selecting last block id\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"height",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"id",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not parse height from block ID: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"height",
",",
"nil",
"\n",
"}"
] | // GetLastBlockID returns last inserted blockId from log table | [
"GetLastBlockID",
"returns",
"last",
"inserted",
"blockId",
"from",
"log",
"table"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/sqldb.go#L239-L254 | train |
hyperledger/burrow | vent/sqldb/sqldb.go | SynchronizeDB | func (db *SQLDB) SynchronizeDB(eventTables types.EventTables) error {
db.Log.Info("msg", "Synchronizing DB")
for _, table := range eventTables {
found, err := db.findTable(table.Name)
if err != nil {
return err
}
if found {
err = db.alterTable(table)
} else {
err = db.createTable(table, false)
}
if err != nil {
return err
}
}
return nil
} | go | func (db *SQLDB) SynchronizeDB(eventTables types.EventTables) error {
db.Log.Info("msg", "Synchronizing DB")
for _, table := range eventTables {
found, err := db.findTable(table.Name)
if err != nil {
return err
}
if found {
err = db.alterTable(table)
} else {
err = db.createTable(table, false)
}
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"SynchronizeDB",
"(",
"eventTables",
"types",
".",
"EventTables",
")",
"error",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Synchronizing DB\"",
")",
"\n",
"for",
"_",
",",
"table",
":=",
"range",
"eventTables",
"{",
"found",
",",
"err",
":=",
"db",
".",
"findTable",
"(",
"table",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"found",
"{",
"err",
"=",
"db",
".",
"alterTable",
"(",
"table",
")",
"\n",
"}",
"else",
"{",
"err",
"=",
"db",
".",
"createTable",
"(",
"table",
",",
"false",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SynchronizeDB synchronize db tables structures from given tables specifications | [
"SynchronizeDB",
"synchronize",
"db",
"tables",
"structures",
"from",
"given",
"tables",
"specifications"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/sqldb.go#L257-L277 | train |
hyperledger/burrow | vent/sqldb/sqldb.go | GetBlock | func (db *SQLDB) GetBlock(height uint64) (types.EventData, error) {
var data types.EventData
data.BlockHeight = height
data.Tables = make(map[string]types.EventDataTable)
// get all table structures involved in the block
tables, err := db.getBlockTables(height)
if err != nil {
return data, err
}
query := ""
// for each table
for _, table := range tables {
// get query for table
query, err = db.getSelectQuery(table, height)
if err != nil {
db.Log.Info("msg", "Error building table query", "err", err)
return data, err
}
db.Log.Info("msg", "Query table data", "query", query)
rows, err := db.DB.Query(query)
if err != nil {
db.Log.Info("msg", "Error querying table data", "err", err)
return data, err
}
defer rows.Close()
cols, err := rows.Columns()
if err != nil {
db.Log.Info("msg", "Error getting row columns", "err", err)
return data, err
}
// builds pointers
length := len(cols)
pointers := make([]interface{}, length)
containers := make([]sql.NullString, length)
for i := range pointers {
pointers[i] = &containers[i]
}
// for each row in table
var dataRows []types.EventDataRow
for rows.Next() {
row := make(map[string]interface{})
if err = rows.Scan(pointers...); err != nil {
db.Log.Info("msg", "Error scanning data", "err", err)
return data, err
}
db.Log.Info("msg", "Query resultset", "value", fmt.Sprintf("%+v", containers))
// for each column in row
for i, col := range cols {
// add value if not null
if containers[i].Valid {
row[col] = containers[i].String
}
}
dataRows = append(dataRows, types.EventDataRow{Action: types.ActionRead, RowData: row})
}
if err = rows.Err(); err != nil {
db.Log.Info("msg", "Error during rows iteration", "err", err)
return data, err
}
data.Tables[table.Name] = dataRows
}
return data, nil
} | go | func (db *SQLDB) GetBlock(height uint64) (types.EventData, error) {
var data types.EventData
data.BlockHeight = height
data.Tables = make(map[string]types.EventDataTable)
// get all table structures involved in the block
tables, err := db.getBlockTables(height)
if err != nil {
return data, err
}
query := ""
// for each table
for _, table := range tables {
// get query for table
query, err = db.getSelectQuery(table, height)
if err != nil {
db.Log.Info("msg", "Error building table query", "err", err)
return data, err
}
db.Log.Info("msg", "Query table data", "query", query)
rows, err := db.DB.Query(query)
if err != nil {
db.Log.Info("msg", "Error querying table data", "err", err)
return data, err
}
defer rows.Close()
cols, err := rows.Columns()
if err != nil {
db.Log.Info("msg", "Error getting row columns", "err", err)
return data, err
}
// builds pointers
length := len(cols)
pointers := make([]interface{}, length)
containers := make([]sql.NullString, length)
for i := range pointers {
pointers[i] = &containers[i]
}
// for each row in table
var dataRows []types.EventDataRow
for rows.Next() {
row := make(map[string]interface{})
if err = rows.Scan(pointers...); err != nil {
db.Log.Info("msg", "Error scanning data", "err", err)
return data, err
}
db.Log.Info("msg", "Query resultset", "value", fmt.Sprintf("%+v", containers))
// for each column in row
for i, col := range cols {
// add value if not null
if containers[i].Valid {
row[col] = containers[i].String
}
}
dataRows = append(dataRows, types.EventDataRow{Action: types.ActionRead, RowData: row})
}
if err = rows.Err(); err != nil {
db.Log.Info("msg", "Error during rows iteration", "err", err)
return data, err
}
data.Tables[table.Name] = dataRows
}
return data, nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"GetBlock",
"(",
"height",
"uint64",
")",
"(",
"types",
".",
"EventData",
",",
"error",
")",
"{",
"var",
"data",
"types",
".",
"EventData",
"\n",
"data",
".",
"BlockHeight",
"=",
"height",
"\n",
"data",
".",
"Tables",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"types",
".",
"EventDataTable",
")",
"\n",
"tables",
",",
"err",
":=",
"db",
".",
"getBlockTables",
"(",
"height",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"data",
",",
"err",
"\n",
"}",
"\n",
"query",
":=",
"\"\"",
"\n",
"for",
"_",
",",
"table",
":=",
"range",
"tables",
"{",
"query",
",",
"err",
"=",
"db",
".",
"getSelectQuery",
"(",
"table",
",",
"height",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error building table query\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"data",
",",
"err",
"\n",
"}",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Query table data\"",
",",
"\"query\"",
",",
"query",
")",
"\n",
"rows",
",",
"err",
":=",
"db",
".",
"DB",
".",
"Query",
"(",
"query",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error querying table data\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"data",
",",
"err",
"\n",
"}",
"\n",
"defer",
"rows",
".",
"Close",
"(",
")",
"\n",
"cols",
",",
"err",
":=",
"rows",
".",
"Columns",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error getting row columns\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"data",
",",
"err",
"\n",
"}",
"\n",
"length",
":=",
"len",
"(",
"cols",
")",
"\n",
"pointers",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"length",
")",
"\n",
"containers",
":=",
"make",
"(",
"[",
"]",
"sql",
".",
"NullString",
",",
"length",
")",
"\n",
"for",
"i",
":=",
"range",
"pointers",
"{",
"pointers",
"[",
"i",
"]",
"=",
"&",
"containers",
"[",
"i",
"]",
"\n",
"}",
"\n",
"var",
"dataRows",
"[",
"]",
"types",
".",
"EventDataRow",
"\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"row",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"err",
"=",
"rows",
".",
"Scan",
"(",
"pointers",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error scanning data\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"data",
",",
"err",
"\n",
"}",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Query resultset\"",
",",
"\"value\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%+v\"",
",",
"containers",
")",
")",
"\n",
"for",
"i",
",",
"col",
":=",
"range",
"cols",
"{",
"if",
"containers",
"[",
"i",
"]",
".",
"Valid",
"{",
"row",
"[",
"col",
"]",
"=",
"containers",
"[",
"i",
"]",
".",
"String",
"\n",
"}",
"\n",
"}",
"\n",
"dataRows",
"=",
"append",
"(",
"dataRows",
",",
"types",
".",
"EventDataRow",
"{",
"Action",
":",
"types",
".",
"ActionRead",
",",
"RowData",
":",
"row",
"}",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"rows",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error during rows iteration\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"data",
",",
"err",
"\n",
"}",
"\n",
"data",
".",
"Tables",
"[",
"table",
".",
"Name",
"]",
"=",
"dataRows",
"\n",
"}",
"\n",
"return",
"data",
",",
"nil",
"\n",
"}"
] | // GetBlock returns all tables structures and row data for given block | [
"GetBlock",
"returns",
"all",
"tables",
"structures",
"and",
"row",
"data",
"for",
"given",
"block"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/sqldb.go#L428-L502 | train |
hyperledger/burrow | vent/sqldb/sqldb.go | RestoreDB | func (db *SQLDB) RestoreDB(time time.Time, prefix string) error {
const yymmddhhmmss = "2006-01-02 15:04:05"
var pointers []interface{}
if prefix == "" {
return fmt.Errorf("error prefix mus not be empty")
}
// Get Restore DB query
query := db.DBAdapter.RestoreDBQuery()
strTime := time.Format(yymmddhhmmss)
db.Log.Info("msg", "RESTORING DB..................................")
// Open rows
db.Log.Info("msg", "open log", "query", query)
rows, err := db.DB.Query(query, strTime)
if err != nil {
db.Log.Info("msg", "error querying log", "err", err)
return err
}
defer rows.Close()
// For each row returned
for rows.Next() {
var tableName, sqlSmt, sqlValues string
var action types.DBAction
if err = rows.Scan(&tableName, &action, &sqlSmt, &sqlValues); err != nil {
db.Log.Info("msg", "error scanning table structure", "err", err)
return err
}
if err = rows.Err(); err != nil {
db.Log.Info("msg", "error scanning table structure", "err", err)
return err
}
restoreTable := fmt.Sprintf("%s_%s", prefix, tableName)
switch action {
case types.ActionUpsert, types.ActionDelete:
// get row values
if pointers, err = db.getValuesFromJSON(sqlValues); err != nil {
db.Log.Info("msg", "error unmarshaling json", "err", err, "value", sqlValues)
return err
}
// Prepare Upsert/delete
query = strings.Replace(sqlSmt, tableName, restoreTable, -1)
db.Log.Info("msg", "SQL COMMAND", "sql", query)
if _, err = db.DB.Exec(query, pointers...); err != nil {
db.Log.Info("msg", "Error executing upsert/delete ", "err", err, "value", sqlSmt, "data", sqlValues)
return err
}
case types.ActionAlterTable, types.ActionCreateTable:
// Prepare Alter/Create Table
query = strings.Replace(sqlSmt, tableName, restoreTable, -1)
db.Log.Info("msg", "SQL COMMAND", "sql", query)
if _, err = db.DB.Exec(query); err != nil {
db.Log.Info("msg", "Error executing alter/create table command ", "err", err, "value", sqlSmt)
return err
}
default:
// Invalid Action
db.Log.Info("msg", "invalid action", "value", action)
return fmt.Errorf("invalid row action %s", action)
}
}
return nil
} | go | func (db *SQLDB) RestoreDB(time time.Time, prefix string) error {
const yymmddhhmmss = "2006-01-02 15:04:05"
var pointers []interface{}
if prefix == "" {
return fmt.Errorf("error prefix mus not be empty")
}
// Get Restore DB query
query := db.DBAdapter.RestoreDBQuery()
strTime := time.Format(yymmddhhmmss)
db.Log.Info("msg", "RESTORING DB..................................")
// Open rows
db.Log.Info("msg", "open log", "query", query)
rows, err := db.DB.Query(query, strTime)
if err != nil {
db.Log.Info("msg", "error querying log", "err", err)
return err
}
defer rows.Close()
// For each row returned
for rows.Next() {
var tableName, sqlSmt, sqlValues string
var action types.DBAction
if err = rows.Scan(&tableName, &action, &sqlSmt, &sqlValues); err != nil {
db.Log.Info("msg", "error scanning table structure", "err", err)
return err
}
if err = rows.Err(); err != nil {
db.Log.Info("msg", "error scanning table structure", "err", err)
return err
}
restoreTable := fmt.Sprintf("%s_%s", prefix, tableName)
switch action {
case types.ActionUpsert, types.ActionDelete:
// get row values
if pointers, err = db.getValuesFromJSON(sqlValues); err != nil {
db.Log.Info("msg", "error unmarshaling json", "err", err, "value", sqlValues)
return err
}
// Prepare Upsert/delete
query = strings.Replace(sqlSmt, tableName, restoreTable, -1)
db.Log.Info("msg", "SQL COMMAND", "sql", query)
if _, err = db.DB.Exec(query, pointers...); err != nil {
db.Log.Info("msg", "Error executing upsert/delete ", "err", err, "value", sqlSmt, "data", sqlValues)
return err
}
case types.ActionAlterTable, types.ActionCreateTable:
// Prepare Alter/Create Table
query = strings.Replace(sqlSmt, tableName, restoreTable, -1)
db.Log.Info("msg", "SQL COMMAND", "sql", query)
if _, err = db.DB.Exec(query); err != nil {
db.Log.Info("msg", "Error executing alter/create table command ", "err", err, "value", sqlSmt)
return err
}
default:
// Invalid Action
db.Log.Info("msg", "invalid action", "value", action)
return fmt.Errorf("invalid row action %s", action)
}
}
return nil
} | [
"func",
"(",
"db",
"*",
"SQLDB",
")",
"RestoreDB",
"(",
"time",
"time",
".",
"Time",
",",
"prefix",
"string",
")",
"error",
"{",
"const",
"yymmddhhmmss",
"=",
"\"2006-01-02 15:04:05\"",
"\n",
"var",
"pointers",
"[",
"]",
"interface",
"{",
"}",
"\n",
"if",
"prefix",
"==",
"\"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"error prefix mus not be empty\"",
")",
"\n",
"}",
"\n",
"query",
":=",
"db",
".",
"DBAdapter",
".",
"RestoreDBQuery",
"(",
")",
"\n",
"strTime",
":=",
"time",
".",
"Format",
"(",
"yymmddhhmmss",
")",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"RESTORING DB..................................\"",
")",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"open log\"",
",",
"\"query\"",
",",
"query",
")",
"\n",
"rows",
",",
"err",
":=",
"db",
".",
"DB",
".",
"Query",
"(",
"query",
",",
"strTime",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"error querying log\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"rows",
".",
"Close",
"(",
")",
"\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"var",
"tableName",
",",
"sqlSmt",
",",
"sqlValues",
"string",
"\n",
"var",
"action",
"types",
".",
"DBAction",
"\n",
"if",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"tableName",
",",
"&",
"action",
",",
"&",
"sqlSmt",
",",
"&",
"sqlValues",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"error scanning table structure\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"rows",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"error scanning table structure\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"restoreTable",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s_%s\"",
",",
"prefix",
",",
"tableName",
")",
"\n",
"switch",
"action",
"{",
"case",
"types",
".",
"ActionUpsert",
",",
"types",
".",
"ActionDelete",
":",
"if",
"pointers",
",",
"err",
"=",
"db",
".",
"getValuesFromJSON",
"(",
"sqlValues",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"error unmarshaling json\"",
",",
"\"err\"",
",",
"err",
",",
"\"value\"",
",",
"sqlValues",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"query",
"=",
"strings",
".",
"Replace",
"(",
"sqlSmt",
",",
"tableName",
",",
"restoreTable",
",",
"-",
"1",
")",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"SQL COMMAND\"",
",",
"\"sql\"",
",",
"query",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"db",
".",
"DB",
".",
"Exec",
"(",
"query",
",",
"pointers",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error executing upsert/delete \"",
",",
"\"err\"",
",",
"err",
",",
"\"value\"",
",",
"sqlSmt",
",",
"\"data\"",
",",
"sqlValues",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"case",
"types",
".",
"ActionAlterTable",
",",
"types",
".",
"ActionCreateTable",
":",
"query",
"=",
"strings",
".",
"Replace",
"(",
"sqlSmt",
",",
"tableName",
",",
"restoreTable",
",",
"-",
"1",
")",
"\n",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"SQL COMMAND\"",
",",
"\"sql\"",
",",
"query",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"db",
".",
"DB",
".",
"Exec",
"(",
"query",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"Error executing alter/create table command \"",
",",
"\"err\"",
",",
"err",
",",
"\"value\"",
",",
"sqlSmt",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"default",
":",
"db",
".",
"Log",
".",
"Info",
"(",
"\"msg\"",
",",
"\"invalid action\"",
",",
"\"value\"",
",",
"action",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"invalid row action %s\"",
",",
"action",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // RestoreDB restores the DB to a given moment in time | [
"RestoreDB",
"restores",
"the",
"DB",
"to",
"a",
"given",
"moment",
"in",
"time"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqldb/sqldb.go#L505-L580 | train |
hyperledger/burrow | storage/immutable_forest.go | Reader | func (imf *ImmutableForest) Reader(prefix []byte) (KVCallbackIterableReader, error) {
return imf.tree(prefix)
} | go | func (imf *ImmutableForest) Reader(prefix []byte) (KVCallbackIterableReader, error) {
return imf.tree(prefix)
} | [
"func",
"(",
"imf",
"*",
"ImmutableForest",
")",
"Reader",
"(",
"prefix",
"[",
"]",
"byte",
")",
"(",
"KVCallbackIterableReader",
",",
"error",
")",
"{",
"return",
"imf",
".",
"tree",
"(",
"prefix",
")",
"\n",
"}"
] | // Get the tree at prefix for making reads | [
"Get",
"the",
"tree",
"at",
"prefix",
"for",
"making",
"reads"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/storage/immutable_forest.go#L69-L71 | train |
hyperledger/burrow | storage/immutable_forest.go | tree | func (imf *ImmutableForest) tree(prefix []byte) (*RWTree, error) {
// Try cache
if value, ok := imf.treeCache.Get(string(prefix)); ok {
return value.(*RWTree), nil
}
// Not in caches but non-negative version - we should be able to load into memory
return imf.loadOrCreateTree(prefix)
} | go | func (imf *ImmutableForest) tree(prefix []byte) (*RWTree, error) {
// Try cache
if value, ok := imf.treeCache.Get(string(prefix)); ok {
return value.(*RWTree), nil
}
// Not in caches but non-negative version - we should be able to load into memory
return imf.loadOrCreateTree(prefix)
} | [
"func",
"(",
"imf",
"*",
"ImmutableForest",
")",
"tree",
"(",
"prefix",
"[",
"]",
"byte",
")",
"(",
"*",
"RWTree",
",",
"error",
")",
"{",
"if",
"value",
",",
"ok",
":=",
"imf",
".",
"treeCache",
".",
"Get",
"(",
"string",
"(",
"prefix",
")",
")",
";",
"ok",
"{",
"return",
"value",
".",
"(",
"*",
"RWTree",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"imf",
".",
"loadOrCreateTree",
"(",
"prefix",
")",
"\n",
"}"
] | // Lazy load tree | [
"Lazy",
"load",
"tree"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/storage/immutable_forest.go#L74-L81 | train |
hyperledger/burrow | storage/immutable_forest.go | newTree | func (imf *ImmutableForest) newTree(prefix []byte) *RWTree {
p := string(prefix)
tree := NewRWTree(NewPrefixDB(imf.treeDB, p), imf.cacheSize)
imf.treeCache.Add(p, tree)
return tree
} | go | func (imf *ImmutableForest) newTree(prefix []byte) *RWTree {
p := string(prefix)
tree := NewRWTree(NewPrefixDB(imf.treeDB, p), imf.cacheSize)
imf.treeCache.Add(p, tree)
return tree
} | [
"func",
"(",
"imf",
"*",
"ImmutableForest",
")",
"newTree",
"(",
"prefix",
"[",
"]",
"byte",
")",
"*",
"RWTree",
"{",
"p",
":=",
"string",
"(",
"prefix",
")",
"\n",
"tree",
":=",
"NewRWTree",
"(",
"NewPrefixDB",
"(",
"imf",
".",
"treeDB",
",",
"p",
")",
",",
"imf",
".",
"cacheSize",
")",
"\n",
"imf",
".",
"treeCache",
".",
"Add",
"(",
"p",
",",
"tree",
")",
"\n",
"return",
"tree",
"\n",
"}"
] | // Create a new in-memory IAVL tree | [
"Create",
"a",
"new",
"in",
"-",
"memory",
"IAVL",
"tree"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/storage/immutable_forest.go#L114-L119 | train |
hyperledger/burrow | deploy/def/rule/rules.go | stripBraces | func stripBraces(str string) string {
bs := []byte(str)
const lb = byte('{')
const rb = byte('}')
start := 0
for i := 0; i < len(bs); i++ {
switch bs[i] {
case lb:
start = i + 1
case rb:
return `\$` + str[start:i]
}
}
return str[start:]
} | go | func stripBraces(str string) string {
bs := []byte(str)
const lb = byte('{')
const rb = byte('}')
start := 0
for i := 0; i < len(bs); i++ {
switch bs[i] {
case lb:
start = i + 1
case rb:
return `\$` + str[start:i]
}
}
return str[start:]
} | [
"func",
"stripBraces",
"(",
"str",
"string",
")",
"string",
"{",
"bs",
":=",
"[",
"]",
"byte",
"(",
"str",
")",
"\n",
"const",
"lb",
"=",
"byte",
"(",
"'{'",
")",
"\n",
"const",
"rb",
"=",
"byte",
"(",
"'}'",
")",
"\n",
"start",
":=",
"0",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"bs",
")",
";",
"i",
"++",
"{",
"switch",
"bs",
"[",
"i",
"]",
"{",
"case",
"lb",
":",
"start",
"=",
"i",
"+",
"1",
"\n",
"case",
"rb",
":",
"return",
"`\\$`",
"+",
"str",
"[",
"start",
":",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"str",
"[",
"start",
":",
"]",
"\n",
"}"
] | // Strips braces and return simple variable confined between braces | [
"Strips",
"braces",
"and",
"return",
"simple",
"variable",
"confined",
"between",
"braces"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/deploy/def/rule/rules.go#L76-L90 | train |
hyperledger/burrow | deploy/def/rule/rules.go | IsOmitted | func IsOmitted(value interface{}) bool {
value, isNil := validation.Indirect(value)
if isNil || validation.IsEmpty(value) {
return true
}
// Accept and empty slice or map
length, err := validation.LengthOfValue(value)
if err == nil && length == 0 {
return true
}
return false
} | go | func IsOmitted(value interface{}) bool {
value, isNil := validation.Indirect(value)
if isNil || validation.IsEmpty(value) {
return true
}
// Accept and empty slice or map
length, err := validation.LengthOfValue(value)
if err == nil && length == 0 {
return true
}
return false
} | [
"func",
"IsOmitted",
"(",
"value",
"interface",
"{",
"}",
")",
"bool",
"{",
"value",
",",
"isNil",
":=",
"validation",
".",
"Indirect",
"(",
"value",
")",
"\n",
"if",
"isNil",
"||",
"validation",
".",
"IsEmpty",
"(",
"value",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"length",
",",
"err",
":=",
"validation",
".",
"LengthOfValue",
"(",
"value",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"length",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // Returns true IFF value is zero value or has length 0 | [
"Returns",
"true",
"IFF",
"value",
"is",
"zero",
"value",
"or",
"has",
"length",
"0"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/deploy/def/rule/rules.go#L171-L182 | train |
hyperledger/burrow | util/fs.go | EnsureDir | func EnsureDir(dir string, mode os.FileMode) error {
if fileOptions, err := os.Stat(dir); os.IsNotExist(err) {
if errMake := os.MkdirAll(dir, mode); errMake != nil {
return fmt.Errorf("Could not create directory %s. %v", dir, err)
}
} else if err != nil {
return fmt.Errorf("Error asserting directory %s: %v", dir, err)
} else if !fileOptions.IsDir() {
return fmt.Errorf("Path already exists as a file: %s", dir)
}
return nil
} | go | func EnsureDir(dir string, mode os.FileMode) error {
if fileOptions, err := os.Stat(dir); os.IsNotExist(err) {
if errMake := os.MkdirAll(dir, mode); errMake != nil {
return fmt.Errorf("Could not create directory %s. %v", dir, err)
}
} else if err != nil {
return fmt.Errorf("Error asserting directory %s: %v", dir, err)
} else if !fileOptions.IsDir() {
return fmt.Errorf("Path already exists as a file: %s", dir)
}
return nil
} | [
"func",
"EnsureDir",
"(",
"dir",
"string",
",",
"mode",
"os",
".",
"FileMode",
")",
"error",
"{",
"if",
"fileOptions",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
";",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"if",
"errMake",
":=",
"os",
".",
"MkdirAll",
"(",
"dir",
",",
"mode",
")",
";",
"errMake",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Could not create directory %s. %v\"",
",",
"dir",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Error asserting directory %s: %v\"",
",",
"dir",
",",
"err",
")",
"\n",
"}",
"else",
"if",
"!",
"fileOptions",
".",
"IsDir",
"(",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Path already exists as a file: %s\"",
",",
"dir",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Ensure the directory exists or create it if needed. | [
"Ensure",
"the",
"directory",
"exists",
"or",
"create",
"it",
"if",
"needed",
"."
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/util/fs.go#L24-L35 | train |
hyperledger/burrow | util/fs.go | IsDir | func IsDir(directory string) bool {
fileInfo, err := os.Stat(directory)
if err != nil {
return false
}
return fileInfo.IsDir()
} | go | func IsDir(directory string) bool {
fileInfo, err := os.Stat(directory)
if err != nil {
return false
}
return fileInfo.IsDir()
} | [
"func",
"IsDir",
"(",
"directory",
"string",
")",
"bool",
"{",
"fileInfo",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"directory",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"fileInfo",
".",
"IsDir",
"(",
")",
"\n",
"}"
] | // Check whether the provided directory exists | [
"Check",
"whether",
"the",
"provided",
"directory",
"exists"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/util/fs.go#L38-L44 | train |
hyperledger/burrow | keys/mock/key.go | MonaxKeysJSON | func (key *Key) MonaxKeysJSON() string {
jsonKey := plainKeyJSON{
Address: key.Address.String(),
Type: "ed25519",
PrivateKey: PrivateKeyplainKeyJSON{Plain: key.PrivateKey},
}
bs, err := json.Marshal(jsonKey)
if err != nil {
return errors.Wrap(err, "could not create monax key json").Error()
}
return string(bs)
} | go | func (key *Key) MonaxKeysJSON() string {
jsonKey := plainKeyJSON{
Address: key.Address.String(),
Type: "ed25519",
PrivateKey: PrivateKeyplainKeyJSON{Plain: key.PrivateKey},
}
bs, err := json.Marshal(jsonKey)
if err != nil {
return errors.Wrap(err, "could not create monax key json").Error()
}
return string(bs)
} | [
"func",
"(",
"key",
"*",
"Key",
")",
"MonaxKeysJSON",
"(",
")",
"string",
"{",
"jsonKey",
":=",
"plainKeyJSON",
"{",
"Address",
":",
"key",
".",
"Address",
".",
"String",
"(",
")",
",",
"Type",
":",
"\"ed25519\"",
",",
"PrivateKey",
":",
"PrivateKeyplainKeyJSON",
"{",
"Plain",
":",
"key",
".",
"PrivateKey",
"}",
",",
"}",
"\n",
"bs",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"jsonKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"could not create monax key json\"",
")",
".",
"Error",
"(",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"bs",
")",
"\n",
"}"
] | // Returns JSON string compatible with that stored by monax-keys | [
"Returns",
"JSON",
"string",
"compatible",
"with",
"that",
"stored",
"by",
"monax",
"-",
"keys"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/keys/mock/key.go#L87-L98 | train |
hyperledger/burrow | execution/evm/snative.go | NewSNativeContract | func NewSNativeContract(comment, name string,
functions ...*SNativeFunctionDescription) *SNativeContractDescription {
functionsByID := make(map[abi.FunctionID]*SNativeFunctionDescription, len(functions))
for _, f := range functions {
f.Abi = *abi.SpecFromStructReflect(f.Name, f.Arguments, f.Returns)
fid := f.Abi.FunctionID
otherF, ok := functionsByID[fid]
if ok {
panic(fmt.Errorf("function with ID %x already defined: %s", fid, otherF.Signature()))
}
functionsByID[fid] = f
}
return &SNativeContractDescription{
Comment: comment,
Name: name,
functionsByID: functionsByID,
functions: functions,
}
} | go | func NewSNativeContract(comment, name string,
functions ...*SNativeFunctionDescription) *SNativeContractDescription {
functionsByID := make(map[abi.FunctionID]*SNativeFunctionDescription, len(functions))
for _, f := range functions {
f.Abi = *abi.SpecFromStructReflect(f.Name, f.Arguments, f.Returns)
fid := f.Abi.FunctionID
otherF, ok := functionsByID[fid]
if ok {
panic(fmt.Errorf("function with ID %x already defined: %s", fid, otherF.Signature()))
}
functionsByID[fid] = f
}
return &SNativeContractDescription{
Comment: comment,
Name: name,
functionsByID: functionsByID,
functions: functions,
}
} | [
"func",
"NewSNativeContract",
"(",
"comment",
",",
"name",
"string",
",",
"functions",
"...",
"*",
"SNativeFunctionDescription",
")",
"*",
"SNativeContractDescription",
"{",
"functionsByID",
":=",
"make",
"(",
"map",
"[",
"abi",
".",
"FunctionID",
"]",
"*",
"SNativeFunctionDescription",
",",
"len",
"(",
"functions",
")",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"functions",
"{",
"f",
".",
"Abi",
"=",
"*",
"abi",
".",
"SpecFromStructReflect",
"(",
"f",
".",
"Name",
",",
"f",
".",
"Arguments",
",",
"f",
".",
"Returns",
")",
"\n",
"fid",
":=",
"f",
".",
"Abi",
".",
"FunctionID",
"\n",
"otherF",
",",
"ok",
":=",
"functionsByID",
"[",
"fid",
"]",
"\n",
"if",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"function with ID %x already defined: %s\"",
",",
"fid",
",",
"otherF",
".",
"Signature",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"functionsByID",
"[",
"fid",
"]",
"=",
"f",
"\n",
"}",
"\n",
"return",
"&",
"SNativeContractDescription",
"{",
"Comment",
":",
"comment",
",",
"Name",
":",
"name",
",",
"functionsByID",
":",
"functionsByID",
",",
"functions",
":",
"functions",
",",
"}",
"\n",
"}"
] | // Create a new SNative contract description object by passing a comment, name
// and a list of member functions descriptions | [
"Create",
"a",
"new",
"SNative",
"contract",
"description",
"object",
"by",
"passing",
"a",
"comment",
"name",
"and",
"a",
"list",
"of",
"member",
"functions",
"descriptions"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/evm/snative.go#L190-L210 | train |
hyperledger/burrow | execution/evm/snative.go | Dispatch | func (contract *SNativeContractDescription) Dispatch(st Interface, caller crypto.Address,
args []byte, gas *uint64, logger *logging.Logger) (output []byte, err error) {
logger = logger.With(structure.ScopeKey, "Dispatch", "contract_name", contract.Name)
if len(args) < abi.FunctionIDSize {
return nil, errors.ErrorCodef(errors.ErrorCodeNativeFunction,
"SNatives dispatch requires a 4-byte function identifier but arguments are only %v bytes long",
len(args))
}
var id abi.FunctionID
copy(id[:], args)
function, err := contract.FunctionByID(id)
if err != nil {
return nil, err
}
logger.TraceMsg("Dispatching to function",
"caller", caller,
"function_name", function.Name)
remainingArgs := args[abi.FunctionIDSize:]
// check if we have permission to call this function
if !HasPermission(st, caller, function.PermFlag) {
return nil, errors.LacksSNativePermission{Address: caller, SNative: function.Name}
}
nativeArgs := reflect.New(function.Arguments).Interface()
err = abi.UnpackIntoStruct(function.Abi.Inputs, remainingArgs, nativeArgs)
if err != nil {
return nil, err
}
nativeRets, err := function.F(st, caller, gas, logger, nativeArgs)
if err != nil {
return nil, err
}
err = st.Error()
if err != nil {
return nil, fmt.Errorf("state error in %v: %v", function, err)
}
return abi.PackIntoStruct(function.Abi.Outputs, nativeRets)
} | go | func (contract *SNativeContractDescription) Dispatch(st Interface, caller crypto.Address,
args []byte, gas *uint64, logger *logging.Logger) (output []byte, err error) {
logger = logger.With(structure.ScopeKey, "Dispatch", "contract_name", contract.Name)
if len(args) < abi.FunctionIDSize {
return nil, errors.ErrorCodef(errors.ErrorCodeNativeFunction,
"SNatives dispatch requires a 4-byte function identifier but arguments are only %v bytes long",
len(args))
}
var id abi.FunctionID
copy(id[:], args)
function, err := contract.FunctionByID(id)
if err != nil {
return nil, err
}
logger.TraceMsg("Dispatching to function",
"caller", caller,
"function_name", function.Name)
remainingArgs := args[abi.FunctionIDSize:]
// check if we have permission to call this function
if !HasPermission(st, caller, function.PermFlag) {
return nil, errors.LacksSNativePermission{Address: caller, SNative: function.Name}
}
nativeArgs := reflect.New(function.Arguments).Interface()
err = abi.UnpackIntoStruct(function.Abi.Inputs, remainingArgs, nativeArgs)
if err != nil {
return nil, err
}
nativeRets, err := function.F(st, caller, gas, logger, nativeArgs)
if err != nil {
return nil, err
}
err = st.Error()
if err != nil {
return nil, fmt.Errorf("state error in %v: %v", function, err)
}
return abi.PackIntoStruct(function.Abi.Outputs, nativeRets)
} | [
"func",
"(",
"contract",
"*",
"SNativeContractDescription",
")",
"Dispatch",
"(",
"st",
"Interface",
",",
"caller",
"crypto",
".",
"Address",
",",
"args",
"[",
"]",
"byte",
",",
"gas",
"*",
"uint64",
",",
"logger",
"*",
"logging",
".",
"Logger",
")",
"(",
"output",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"logger",
"=",
"logger",
".",
"With",
"(",
"structure",
".",
"ScopeKey",
",",
"\"Dispatch\"",
",",
"\"contract_name\"",
",",
"contract",
".",
"Name",
")",
"\n",
"if",
"len",
"(",
"args",
")",
"<",
"abi",
".",
"FunctionIDSize",
"{",
"return",
"nil",
",",
"errors",
".",
"ErrorCodef",
"(",
"errors",
".",
"ErrorCodeNativeFunction",
",",
"\"SNatives dispatch requires a 4-byte function identifier but arguments are only %v bytes long\"",
",",
"len",
"(",
"args",
")",
")",
"\n",
"}",
"\n",
"var",
"id",
"abi",
".",
"FunctionID",
"\n",
"copy",
"(",
"id",
"[",
":",
"]",
",",
"args",
")",
"\n",
"function",
",",
"err",
":=",
"contract",
".",
"FunctionByID",
"(",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"logger",
".",
"TraceMsg",
"(",
"\"Dispatching to function\"",
",",
"\"caller\"",
",",
"caller",
",",
"\"function_name\"",
",",
"function",
".",
"Name",
")",
"\n",
"remainingArgs",
":=",
"args",
"[",
"abi",
".",
"FunctionIDSize",
":",
"]",
"\n",
"if",
"!",
"HasPermission",
"(",
"st",
",",
"caller",
",",
"function",
".",
"PermFlag",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"LacksSNativePermission",
"{",
"Address",
":",
"caller",
",",
"SNative",
":",
"function",
".",
"Name",
"}",
"\n",
"}",
"\n",
"nativeArgs",
":=",
"reflect",
".",
"New",
"(",
"function",
".",
"Arguments",
")",
".",
"Interface",
"(",
")",
"\n",
"err",
"=",
"abi",
".",
"UnpackIntoStruct",
"(",
"function",
".",
"Abi",
".",
"Inputs",
",",
"remainingArgs",
",",
"nativeArgs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"nativeRets",
",",
"err",
":=",
"function",
".",
"F",
"(",
"st",
",",
"caller",
",",
"gas",
",",
"logger",
",",
"nativeArgs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"st",
".",
"Error",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"state error in %v: %v\"",
",",
"function",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"abi",
".",
"PackIntoStruct",
"(",
"function",
".",
"Abi",
".",
"Outputs",
",",
"nativeRets",
")",
"\n",
"}"
] | // This function is designed to be called from the EVM once a SNative contract
// has been selected. It is also placed in a registry by registerSNativeContracts
// So it can be looked up by SNative address | [
"This",
"function",
"is",
"designed",
"to",
"be",
"called",
"from",
"the",
"EVM",
"once",
"a",
"SNative",
"contract",
"has",
"been",
"selected",
".",
"It",
"is",
"also",
"placed",
"in",
"a",
"registry",
"by",
"registerSNativeContracts",
"So",
"it",
"can",
"be",
"looked",
"up",
"by",
"SNative",
"address"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/evm/snative.go#L215-L260 | train |
hyperledger/burrow | execution/evm/snative.go | Address | func (contract *SNativeContractDescription) Address() (address crypto.Address) {
hash := sha3.Sha3([]byte(contract.Name))
copy(address[:], hash[len(hash)-crypto.AddressLength:])
return
} | go | func (contract *SNativeContractDescription) Address() (address crypto.Address) {
hash := sha3.Sha3([]byte(contract.Name))
copy(address[:], hash[len(hash)-crypto.AddressLength:])
return
} | [
"func",
"(",
"contract",
"*",
"SNativeContractDescription",
")",
"Address",
"(",
")",
"(",
"address",
"crypto",
".",
"Address",
")",
"{",
"hash",
":=",
"sha3",
".",
"Sha3",
"(",
"[",
"]",
"byte",
"(",
"contract",
".",
"Name",
")",
")",
"\n",
"copy",
"(",
"address",
"[",
":",
"]",
",",
"hash",
"[",
"len",
"(",
"hash",
")",
"-",
"crypto",
".",
"AddressLength",
":",
"]",
")",
"\n",
"return",
"\n",
"}"
] | // We define the address of an SNative contact as the last 20 bytes of the sha3
// hash of its name | [
"We",
"define",
"the",
"address",
"of",
"an",
"SNative",
"contact",
"as",
"the",
"last",
"20",
"bytes",
"of",
"the",
"sha3",
"hash",
"of",
"its",
"name"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/evm/snative.go#L264-L268 | train |
hyperledger/burrow | execution/evm/snative.go | FunctionByID | func (contract *SNativeContractDescription) FunctionByID(id abi.FunctionID) (*SNativeFunctionDescription, errors.CodedError) {
f, ok := contract.functionsByID[id]
if !ok {
return nil,
errors.ErrorCodef(errors.ErrorCodeNativeFunction, "unknown SNative function with ID %x", id)
}
return f, nil
} | go | func (contract *SNativeContractDescription) FunctionByID(id abi.FunctionID) (*SNativeFunctionDescription, errors.CodedError) {
f, ok := contract.functionsByID[id]
if !ok {
return nil,
errors.ErrorCodef(errors.ErrorCodeNativeFunction, "unknown SNative function with ID %x", id)
}
return f, nil
} | [
"func",
"(",
"contract",
"*",
"SNativeContractDescription",
")",
"FunctionByID",
"(",
"id",
"abi",
".",
"FunctionID",
")",
"(",
"*",
"SNativeFunctionDescription",
",",
"errors",
".",
"CodedError",
")",
"{",
"f",
",",
"ok",
":=",
"contract",
".",
"functionsByID",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"ErrorCodef",
"(",
"errors",
".",
"ErrorCodeNativeFunction",
",",
"\"unknown SNative function with ID %x\"",
",",
"id",
")",
"\n",
"}",
"\n",
"return",
"f",
",",
"nil",
"\n",
"}"
] | // Get function by calling identifier FunctionSelector | [
"Get",
"function",
"by",
"calling",
"identifier",
"FunctionSelector"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/evm/snative.go#L271-L278 | train |
hyperledger/burrow | execution/evm/snative.go | FunctionByName | func (contract *SNativeContractDescription) FunctionByName(name string) (*SNativeFunctionDescription, error) {
for _, f := range contract.functions {
if f.Name == name {
return f, nil
}
}
return nil, fmt.Errorf("unknown SNative function with name %s", name)
} | go | func (contract *SNativeContractDescription) FunctionByName(name string) (*SNativeFunctionDescription, error) {
for _, f := range contract.functions {
if f.Name == name {
return f, nil
}
}
return nil, fmt.Errorf("unknown SNative function with name %s", name)
} | [
"func",
"(",
"contract",
"*",
"SNativeContractDescription",
")",
"FunctionByName",
"(",
"name",
"string",
")",
"(",
"*",
"SNativeFunctionDescription",
",",
"error",
")",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"contract",
".",
"functions",
"{",
"if",
"f",
".",
"Name",
"==",
"name",
"{",
"return",
"f",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"unknown SNative function with name %s\"",
",",
"name",
")",
"\n",
"}"
] | // Get function by name | [
"Get",
"function",
"by",
"name"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/evm/snative.go#L281-L288 | train |
hyperledger/burrow | execution/evm/snative.go | Functions | func (contract *SNativeContractDescription) Functions() []*SNativeFunctionDescription {
functions := make([]*SNativeFunctionDescription, len(contract.functions))
copy(functions, contract.functions)
return functions
} | go | func (contract *SNativeContractDescription) Functions() []*SNativeFunctionDescription {
functions := make([]*SNativeFunctionDescription, len(contract.functions))
copy(functions, contract.functions)
return functions
} | [
"func",
"(",
"contract",
"*",
"SNativeContractDescription",
")",
"Functions",
"(",
")",
"[",
"]",
"*",
"SNativeFunctionDescription",
"{",
"functions",
":=",
"make",
"(",
"[",
"]",
"*",
"SNativeFunctionDescription",
",",
"len",
"(",
"contract",
".",
"functions",
")",
")",
"\n",
"copy",
"(",
"functions",
",",
"contract",
".",
"functions",
")",
"\n",
"return",
"functions",
"\n",
"}"
] | // Get functions in order of declaration | [
"Get",
"functions",
"in",
"order",
"of",
"declaration"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/evm/snative.go#L291-L295 | train |
hyperledger/burrow | execution/evm/snative.go | Signature | func (function *SNativeFunctionDescription) Signature() string {
argTypeNames := make([]string, len(function.Abi.Inputs))
for i, arg := range function.Abi.Inputs {
argTypeNames[i] = arg.EVM.GetSignature()
}
return fmt.Sprintf("%s(%s)", function.Name,
strings.Join(argTypeNames, ","))
} | go | func (function *SNativeFunctionDescription) Signature() string {
argTypeNames := make([]string, len(function.Abi.Inputs))
for i, arg := range function.Abi.Inputs {
argTypeNames[i] = arg.EVM.GetSignature()
}
return fmt.Sprintf("%s(%s)", function.Name,
strings.Join(argTypeNames, ","))
} | [
"func",
"(",
"function",
"*",
"SNativeFunctionDescription",
")",
"Signature",
"(",
")",
"string",
"{",
"argTypeNames",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"function",
".",
"Abi",
".",
"Inputs",
")",
")",
"\n",
"for",
"i",
",",
"arg",
":=",
"range",
"function",
".",
"Abi",
".",
"Inputs",
"{",
"argTypeNames",
"[",
"i",
"]",
"=",
"arg",
".",
"EVM",
".",
"GetSignature",
"(",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s(%s)\"",
",",
"function",
".",
"Name",
",",
"strings",
".",
"Join",
"(",
"argTypeNames",
",",
"\",\"",
")",
")",
"\n",
"}"
] | //
// SNative functions
//
// Get function signature | [
"SNative",
"functions",
"Get",
"function",
"signature"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/execution/evm/snative.go#L302-L309 | train |
hyperledger/burrow | event/query/tags.go | AddTags | func (ct *CombinedTags) AddTags(concat bool, tagsList ...Tagged) {
for _, t := range tagsList {
for _, k := range t.Keys() {
if len(ct.ks[k]) == 0 {
ct.keys = append(ct.keys, k)
// Store reference to key-holder amongst Taggeds
ct.ks[k] = append(ct.ks[k], t)
} else if concat {
// Store additional tag reference only if concat, otherwise first key-holder wins
ct.ks[k] = append(ct.ks[k], t)
}
}
}
} | go | func (ct *CombinedTags) AddTags(concat bool, tagsList ...Tagged) {
for _, t := range tagsList {
for _, k := range t.Keys() {
if len(ct.ks[k]) == 0 {
ct.keys = append(ct.keys, k)
// Store reference to key-holder amongst Taggeds
ct.ks[k] = append(ct.ks[k], t)
} else if concat {
// Store additional tag reference only if concat, otherwise first key-holder wins
ct.ks[k] = append(ct.ks[k], t)
}
}
}
} | [
"func",
"(",
"ct",
"*",
"CombinedTags",
")",
"AddTags",
"(",
"concat",
"bool",
",",
"tagsList",
"...",
"Tagged",
")",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"tagsList",
"{",
"for",
"_",
",",
"k",
":=",
"range",
"t",
".",
"Keys",
"(",
")",
"{",
"if",
"len",
"(",
"ct",
".",
"ks",
"[",
"k",
"]",
")",
"==",
"0",
"{",
"ct",
".",
"keys",
"=",
"append",
"(",
"ct",
".",
"keys",
",",
"k",
")",
"\n",
"ct",
".",
"ks",
"[",
"k",
"]",
"=",
"append",
"(",
"ct",
".",
"ks",
"[",
"k",
"]",
",",
"t",
")",
"\n",
"}",
"else",
"if",
"concat",
"{",
"ct",
".",
"ks",
"[",
"k",
"]",
"=",
"append",
"(",
"ct",
".",
"ks",
"[",
"k",
"]",
",",
"t",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Adds each of tagsList to CombinedTags - choosing whether values for the same key should
// be concatenated or whether the first should value should stick | [
"Adds",
"each",
"of",
"tagsList",
"to",
"CombinedTags",
"-",
"choosing",
"whether",
"values",
"for",
"the",
"same",
"key",
"should",
"be",
"concatenated",
"or",
"whether",
"the",
"first",
"should",
"value",
"should",
"stick"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/event/query/tags.go#L80-L93 | train |
hyperledger/burrow | config/source/source.go | SetSkip | func (cs *configSource) SetSkip(skip bool) ConfigProvider {
return &configSource{
skip: skip,
from: cs.from,
apply: cs.apply,
}
} | go | func (cs *configSource) SetSkip(skip bool) ConfigProvider {
return &configSource{
skip: skip,
from: cs.from,
apply: cs.apply,
}
} | [
"func",
"(",
"cs",
"*",
"configSource",
")",
"SetSkip",
"(",
"skip",
"bool",
")",
"ConfigProvider",
"{",
"return",
"&",
"configSource",
"{",
"skip",
":",
"skip",
",",
"from",
":",
"cs",
".",
"from",
",",
"apply",
":",
"cs",
".",
"apply",
",",
"}",
"\n",
"}"
] | // Returns a copy of the configSource with skip set as passed in | [
"Returns",
"a",
"copy",
"of",
"the",
"configSource",
"with",
"skip",
"set",
"as",
"passed",
"in"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/config/source/source.go#L73-L79 | train |
hyperledger/burrow | config/source/source.go | XDGBaseDir | func XDGBaseDir(configFileName string) *configSource {
skip := false
// Look for config in standard XDG specified locations
configFile, err := xdgbasedir.GetConfigFileLocation(configFileName)
if err == nil {
_, err := os.Stat(configFile)
// Skip if config file does not exist at default location
skip = os.IsNotExist(err)
}
return &configSource{
skip: skip,
from: fmt.Sprintf("XDG base dir"),
apply: func(baseConfig interface{}) error {
if err != nil {
return err
}
return FromFile(configFile, baseConfig)
},
}
} | go | func XDGBaseDir(configFileName string) *configSource {
skip := false
// Look for config in standard XDG specified locations
configFile, err := xdgbasedir.GetConfigFileLocation(configFileName)
if err == nil {
_, err := os.Stat(configFile)
// Skip if config file does not exist at default location
skip = os.IsNotExist(err)
}
return &configSource{
skip: skip,
from: fmt.Sprintf("XDG base dir"),
apply: func(baseConfig interface{}) error {
if err != nil {
return err
}
return FromFile(configFile, baseConfig)
},
}
} | [
"func",
"XDGBaseDir",
"(",
"configFileName",
"string",
")",
"*",
"configSource",
"{",
"skip",
":=",
"false",
"\n",
"configFile",
",",
"err",
":=",
"xdgbasedir",
".",
"GetConfigFileLocation",
"(",
"configFileName",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"configFile",
")",
"\n",
"skip",
"=",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"configSource",
"{",
"skip",
":",
"skip",
",",
"from",
":",
"fmt",
".",
"Sprintf",
"(",
"\"XDG base dir\"",
")",
",",
"apply",
":",
"func",
"(",
"baseConfig",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"FromFile",
"(",
"configFile",
",",
"baseConfig",
")",
"\n",
"}",
",",
"}",
"\n",
"}"
] | // Try to find config by using XDG base dir spec | [
"Try",
"to",
"find",
"config",
"by",
"using",
"XDG",
"base",
"dir",
"spec"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/config/source/source.go#L150-L169 | train |
hyperledger/burrow | config/source/source.go | Environment | func Environment(key string) *configSource {
configString := os.Getenv(key)
return &configSource{
skip: configString == "",
from: fmt.Sprintf("'%s' environment variable", key),
apply: func(baseConfig interface{}) error {
return FromString(configString, baseConfig)
},
}
} | go | func Environment(key string) *configSource {
configString := os.Getenv(key)
return &configSource{
skip: configString == "",
from: fmt.Sprintf("'%s' environment variable", key),
apply: func(baseConfig interface{}) error {
return FromString(configString, baseConfig)
},
}
} | [
"func",
"Environment",
"(",
"key",
"string",
")",
"*",
"configSource",
"{",
"configString",
":=",
"os",
".",
"Getenv",
"(",
"key",
")",
"\n",
"return",
"&",
"configSource",
"{",
"skip",
":",
"configString",
"==",
"\"\"",
",",
"from",
":",
"fmt",
".",
"Sprintf",
"(",
"\"'%s' environment variable\"",
",",
"key",
")",
",",
"apply",
":",
"func",
"(",
"baseConfig",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"FromString",
"(",
"configString",
",",
"baseConfig",
")",
"\n",
"}",
",",
"}",
"\n",
"}"
] | // Source from a single environment variable with config embedded in JSON | [
"Source",
"from",
"a",
"single",
"environment",
"variable",
"with",
"config",
"embedded",
"in",
"JSON"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/config/source/source.go#L172-L181 | train |
hyperledger/burrow | config/source/source.go | DeepCopy | func DeepCopy(conf interface{}) (interface{}, error) {
// Create a zero value
confCopy := reflect.New(reflect.TypeOf(conf).Elem()).Interface()
// Perform a merge into that value to effect the copy
err := mergo.Merge(confCopy, conf)
if err != nil {
return nil, err
}
return confCopy, nil
} | go | func DeepCopy(conf interface{}) (interface{}, error) {
// Create a zero value
confCopy := reflect.New(reflect.TypeOf(conf).Elem()).Interface()
// Perform a merge into that value to effect the copy
err := mergo.Merge(confCopy, conf)
if err != nil {
return nil, err
}
return confCopy, nil
} | [
"func",
"DeepCopy",
"(",
"conf",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"confCopy",
":=",
"reflect",
".",
"New",
"(",
"reflect",
".",
"TypeOf",
"(",
"conf",
")",
".",
"Elem",
"(",
")",
")",
".",
"Interface",
"(",
")",
"\n",
"err",
":=",
"mergo",
".",
"Merge",
"(",
"confCopy",
",",
"conf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"confCopy",
",",
"nil",
"\n",
"}"
] | // Passed a pointer to struct creates a deep copy of the struct | [
"Passed",
"a",
"pointer",
"to",
"struct",
"creates",
"a",
"deep",
"copy",
"of",
"the",
"struct"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/config/source/source.go#L266-L275 | train |
hyperledger/burrow | vent/sqlsol/projection.go | NewProjectionFromBytes | func NewProjectionFromBytes(bs []byte) (*Projection, error) {
eventSpec := types.EventSpec{}
err := ValidateJSONEventSpec(bs)
if err != nil {
return nil, err
}
err = json.Unmarshal(bs, &eventSpec)
if err != nil {
return nil, errors.Wrap(err, "Error unmarshalling eventSpec")
}
return NewProjectionFromEventSpec(eventSpec)
} | go | func NewProjectionFromBytes(bs []byte) (*Projection, error) {
eventSpec := types.EventSpec{}
err := ValidateJSONEventSpec(bs)
if err != nil {
return nil, err
}
err = json.Unmarshal(bs, &eventSpec)
if err != nil {
return nil, errors.Wrap(err, "Error unmarshalling eventSpec")
}
return NewProjectionFromEventSpec(eventSpec)
} | [
"func",
"NewProjectionFromBytes",
"(",
"bs",
"[",
"]",
"byte",
")",
"(",
"*",
"Projection",
",",
"error",
")",
"{",
"eventSpec",
":=",
"types",
".",
"EventSpec",
"{",
"}",
"\n",
"err",
":=",
"ValidateJSONEventSpec",
"(",
"bs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"bs",
",",
"&",
"eventSpec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"Error unmarshalling eventSpec\"",
")",
"\n",
"}",
"\n",
"return",
"NewProjectionFromEventSpec",
"(",
"eventSpec",
")",
"\n",
"}"
] | // NewProjectionFromBytes creates a Projection from a stream of bytes | [
"NewProjectionFromBytes",
"creates",
"a",
"Projection",
"from",
"a",
"stream",
"of",
"bytes"
] | 59993f5aad71a8e16ab6ed4e57e138e2398eae4e | https://github.com/hyperledger/burrow/blob/59993f5aad71a8e16ab6ed4e57e138e2398eae4e/vent/sqlsol/projection.go#L26-L40 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.