_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q27000 | UnsubscribeAll | train | func (em *Emitter) UnsubscribeAll(ctx context.Context, subscriber string) error {
return em.pubsubServer.UnsubscribeAll(ctx, subscriber)
} | go | {
"resource": ""
} |
q27001 | SetPassthrough | train | func (cl *CaptureLogger) SetPassthrough(passthrough bool) {
cl.Lock()
defer cl.Unlock()
cl.passthrough = passthrough
} | go | {
"resource": ""
} |
q27002 | Passthrough | train | func (cl *CaptureLogger) Passthrough() bool {
cl.RLock()
defer cl.RUnlock()
return cl.passthrough
} | go | {
"resource": ""
} |
q27003 | main | train | func main() {
loggingConfig := &LoggingConfig{
RootSink: Sink().
AddSinks(
// Log everything to Stderr
Sink().SetOutput(StderrOutput()),
Sink().SetTransform(FilterTransform(ExcludeWhenAllMatch,
"module", "p2p",
"captured_logging_source", "tendermint_log15")).
AddSinks(
Sink().SetO... | go | {
"resource": ""
} |
q27004 | NewLogger | train | func NewLogger(outputLogger log.Logger) *Logger {
// We will never halt the progress of a log emitter. If log output takes too
// long will start dropping log lines by using a ring buffer.
swapLogger := new(log.SwapLogger)
swapLogger.Swap(outputLogger)
return &Logger{
Output: swapLogger,
// logging contexts
... | go | {
"resource": ""
} |
q27005 | SwapOutput | train | func (l *Logger) SwapOutput(infoLogger log.Logger) {
l.Output.Swap(infoLogger)
} | go | {
"resource": ""
} |
q27006 | InfoMsg | train | func (l *Logger) InfoMsg(message string, keyvals ...interface{}) error {
return Msg(l.Info, message, keyvals...)
} | go | {
"resource": ""
} |
q27007 | TraceMsg | train | func (l *Logger) TraceMsg(message string, keyvals ...interface{}) error {
return Msg(l.Trace, message, keyvals...)
} | go | {
"resource": ""
} |
q27008 | WithScope | train | func (l *Logger) WithScope(scopeName string) *Logger {
// InfoTraceLogger will collapse successive (ScopeKey, scopeName) pairs into a vector in the order which they appear
return l.With(structure.ScopeKey, scopeName)
} | go | {
"resource": ""
} |
q27009 | Msg | train | func Msg(logger log.Logger, message string, keyvals ...interface{}) error {
prepended := structure.CopyPrepend(keyvals, structure.MessageKey, message)
return logger.Log(prepended...)
} | go | {
"resource": ""
} |
q27010 | unalignedAbsorb | train | func (d *digest) unalignedAbsorb(p []byte) {
var t uint64
for i := len(p) - 1; i >= 0; i-- {
t <<= 8
t |= uint64(p[i])
}
offset := (d.absorbed) % d.rate()
t <<= 8 * uint(offset%laneSize)
d.a[offset/laneSize] ^= t
d.absorbed += len(p)
} | go | {
"resource": ""
} |
q27011 | Sum | train | func (d *digest) Sum(in []byte) []byte {
// Make a copy of the original hash so that caller can keep writing and summing.
dup := *d
dup.finalize()
return dup.squeeze(in, dup.outputSize)
} | go | {
"resource": ""
} |
q27012 | NewLoggerFromLoggingConfig | train | func NewLoggerFromLoggingConfig(loggingConfig *logconfig.LoggingConfig) (*logging.Logger, error) {
if loggingConfig == nil {
return NewStdErrLogger()
} else {
outputLogger, errCh, err := loggerFromLoggingConfig(loggingConfig)
if err != nil {
return nil, err
}
logger := logging.NewLogger(outputLogger)
i... | go | {
"resource": ""
} |
q27013 | SwapOutputLoggersFromLoggingConfig | train | func SwapOutputLoggersFromLoggingConfig(logger *logging.Logger, loggingConfig *logconfig.LoggingConfig) (error, channels.Channel) {
outputLogger, errCh, err := loggerFromLoggingConfig(loggingConfig)
if err != nil {
return err, channels.NewDeadChannel()
}
logger.SwapOutput(outputLogger)
return nil, errCh
} | go | {
"resource": ""
} |
q27014 | MergeAbiSpec | train | func MergeAbiSpec(abiSpec []*AbiSpec) *AbiSpec {
newSpec := AbiSpec{
Events: make(map[string]EventSpec),
EventsById: make(map[EventID]EventSpec),
Functions: make(map[string]FunctionSpec),
}
for _, s := range abiSpec {
for n, f := range s.Functions {
newSpec.Functions[n] = f
}
// Different Abis ... | go | {
"resource": ""
} |
q27015 | UnpackRevert | train | func UnpackRevert(data []byte) (message *string, err error) {
if len(data) > 0 {
var msg string
err = RevertAbi.UnpackWithID(data, &msg)
message = &msg
}
return
} | go | {
"resource": ""
} |
q27016 | pad | train | func pad(input []byte, size int, left bool) []byte {
if len(input) >= size {
return input[:size]
}
padded := make([]byte, size)
if left {
copy(padded[size-len(input):], input)
} else {
copy(padded, input)
}
return padded
} | go | {
"resource": ""
} |
q27017 | Get | train | func (bp BasePermissions) Get(ty PermFlag) (bool, error) {
if ty == 0 {
return false, ErrInvalidPermission(ty)
}
if !bp.IsSet(ty) {
return false, ErrValueNotSet(ty)
}
return bp.Perms&ty == ty, nil
} | go | {
"resource": ""
} |
q27018 | Set | train | func (bp *BasePermissions) Set(ty PermFlag, value bool) error {
if ty == 0 {
return ErrInvalidPermission(ty)
}
bp.SetBit |= ty
if value {
bp.Perms |= ty
} else {
bp.Perms &= ^ty
}
return nil
} | go | {
"resource": ""
} |
q27019 | Unset | train | func (bp *BasePermissions) Unset(ty PermFlag) error {
if ty == 0 {
return ErrInvalidPermission(ty)
}
bp.SetBit &= ^ty
return nil
} | go | {
"resource": ""
} |
q27020 | IsSet | train | func (bp BasePermissions) IsSet(ty PermFlag) bool {
if ty == 0 {
return false
}
return bp.SetBit&ty == ty
} | go | {
"resource": ""
} |
q27021 | Compose | train | func (bp BasePermissions) Compose(bpFallthrough BasePermissions) BasePermissions {
return BasePermissions{
// Combine set perm flags from bp with set perm flags in fallthrough NOT set in bp
Perms: (bp.Perms & bp.SetBit) | (bpFallthrough.Perms & (^bp.SetBit & bpFallthrough.SetBit)),
SetBit: bp.SetBit | bpFallthr... | go | {
"resource": ""
} |
q27022 | NewKernel | train | func NewKernel(dbDir string) (*Kernel, error) {
if dbDir == "" {
return nil, fmt.Errorf("Burrow requires a database directory")
}
runID, err := simpleuuid.NewTime(time.Now()) // Create a random ID based on start time
return &Kernel{
Logger: logging.NewNoopLogger(),
RunID: runID,
Emitter: ... | go | {
"resource": ""
} |
q27023 | SetLogger | train | func (kern *Kernel) SetLogger(logger *logging.Logger) {
logger = logger.WithScope("NewKernel()").With(structure.TimeKey,
log.DefaultTimestampUTC, structure.RunId, kern.RunID.String())
heightValuer := log.Valuer(func() interface{} { return kern.Blockchain.LastBlockHeight() })
kern.Logger = logger.WithInfo(structure... | go | {
"resource": ""
} |
q27024 | LoadState | train | func (kern *Kernel) LoadState(genesisDoc *genesis.GenesisDoc) (err error) {
var existing bool
existing, kern.Blockchain, err = bcm.LoadOrNewBlockchain(kern.database, genesisDoc, kern.Logger)
if err != nil {
return fmt.Errorf("error creating or loading blockchain state: %v", err)
}
if existing {
kern.Logger.In... | go | {
"resource": ""
} |
q27025 | LoadDump | train | func (kern *Kernel) LoadDump(genesisDoc *genesis.GenesisDoc, restoreFile string, silent bool) (err error) {
var exists bool
if exists, kern.Blockchain, err = bcm.LoadOrNewBlockchain(kern.database, genesisDoc, kern.Logger); err != nil {
return fmt.Errorf("error creating or loading blockchain state: %v", err)
}
if... | go | {
"resource": ""
} |
q27026 | GetNodeView | train | func (kern *Kernel) GetNodeView() (*tendermint.NodeView, error) {
if kern.Node == nil {
return nil, nil
}
return tendermint.NewNodeView(kern.Node, kern.txCodec, kern.RunID)
} | go | {
"resource": ""
} |
q27027 | AddExecutionOptions | train | func (kern *Kernel) AddExecutionOptions(opts ...execution.ExecutionOption) {
kern.exeOptions = append(kern.exeOptions, opts...)
} | go | {
"resource": ""
} |
q27028 | AddProcesses | train | func (kern *Kernel) AddProcesses(pl ...process.Launcher) {
kern.Launchers = append(kern.Launchers, pl...)
} | go | {
"resource": ""
} |
q27029 | Boot | train | func (kern *Kernel) Boot() (err error) {
for _, launcher := range kern.Launchers {
if launcher.Enabled {
srvr, err := launcher.Launch()
if err != nil {
return fmt.Errorf("error launching %s server: %v", launcher.Name, err)
}
kern.processes[launcher.Name] = srvr
}
}
go kern.supervise()
return ni... | go | {
"resource": ""
} |
q27030 | supervise | train | func (kern *Kernel) supervise() {
// perform disaster restarts of the kernel; rejoining the network as if we were a new node.
shutdownCh := make(chan os.Signal, 1)
reloadCh := make(chan os.Signal, 1)
syncCh := make(chan os.Signal, 1)
signal.Notify(shutdownCh, syscall.SIGINT, syscall.SIGTERM, syscall.SIGKILL)
sign... | go | {
"resource": ""
} |
q27031 | Shutdown | train | func (kern *Kernel) Shutdown(ctx context.Context) (err error) {
kern.shutdownOnce.Do(func() {
logger := kern.Logger.WithScope("Shutdown")
logger.InfoMsg("Attempting graceful shutdown...")
logger.InfoMsg("Shutting down servers")
// Shutdown servers in reverse order to boot
for i := len(kern.Launchers) - 1; i ... | go | {
"resource": ""
} |
q27032 | registerNameTx | train | func registerNameTx(name *def.RegisterName, do *def.DeployArgs, account string, client *def.Client, logger *logging.Logger) (*payload.NameTx, error) {
// Set Defaults
name.Source = useDefault(name.Source, account)
name.Fee = useDefault(name.Fee, do.DefaultFee)
name.Amount = useDefault(name.Amount, do.DefaultAmount)... | go | {
"resource": ""
} |
q27033 | decodeEvent | train | func decodeEvent(header *exec.Header, log *exec.LogEvent, abiSpec *abi.AbiSpec) (map[string]interface{}, error) {
// to prepare decoded data and map to event item name
data := make(map[string]interface{})
var eventID abi.EventID
copy(eventID[:], log.Topics[0].Bytes())
evAbi, ok := abiSpec.EventsById[eventID]
if... | go | {
"resource": ""
} |
q27034 | NewBatchChecker | train | func NewBatchChecker(backend ExecutorState, params Params, blockchain contexts.Blockchain, logger *logging.Logger,
options ...ExecutionOption) BatchExecutor {
return newExecutor("CheckCache", false, params, backend, blockchain, nil,
logger.WithScope("NewBatchExecutor"), options...)
} | go | {
"resource": ""
} |
q27035 | Commit | train | func (exe *executor) Commit(header *abciTypes.Header) (stateHash []byte, err error) {
// The write lock to the executor is controlled by the caller (e.g. abci.App) so we do not acquire it here to avoid
// deadlock
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("recovered from panic in executor.Co... | go | {
"resource": ""
} |
q27036 | updateSignatories | train | func (exe *executor) updateSignatories(txEnv *txs.Envelope) error {
for _, sig := range txEnv.Signatories {
// pointer dereferences are safe since txEnv.Validate() is run by txEnv.Verify() above which checks they are
// non-nil
acc, err := exe.stateCache.GetAccount(*sig.Address)
if err != nil {
return fmt.E... | go | {
"resource": ""
} |
q27037 | ABCIPubKey | train | func (p PublicKey) ABCIPubKey() abci.PubKey {
return abci.PubKey{
Type: p.CurveType.ABCIType(),
Data: p.PublicKey,
}
} | go | {
"resource": ""
} |
q27038 | SpecLoader | train | func SpecLoader(specFileOrDirs []string, createBlkTxTables bool) (*Projection, error) {
var projection *Projection
var err error
if len(specFileOrDirs) == 0 {
return nil, fmt.Errorf("please provide a spec file or directory")
}
projection, err = NewProjectionFromFolder(specFileOrDirs...)
if err != nil {
retu... | go | {
"resource": ""
} |
q27039 | getBlockTxTablesDefinition | train | func getBlockTxTablesDefinition() types.EventTables {
return types.EventTables{
types.SQLBlockTableName: &types.SQLTable{
Name: types.SQLBlockTableName,
Columns: []*types.SQLTableColumn{
{
Name: types.SQLColumnLabelHeight,
Type: types.SQLColumnTypeVarchar,
Length: 100,
Primary: t... | go | {
"resource": ""
} |
q27040 | DecodeFunctionReturnFromFile | train | func DecodeFunctionReturnFromFile(abiLocation, binPath, funcName string, resultRaw []byte, logger *logging.Logger) ([]*Variable, error) {
abiSpecBytes, err := readAbi(binPath, abiLocation, logger)
if err != nil {
return nil, err
}
logger.TraceMsg("ABI Specification (Decode)", "spec", abiSpecBytes)
// Unpack the... | go | {
"resource": ""
} |
q27041 | LoadPath | train | func LoadPath(abiFileOrDirs ...string) (*AbiSpec, error) {
if len(abiFileOrDirs) == 0 {
return &AbiSpec{}, fmt.Errorf("no ABI file or directory provided")
}
specs := make([]*AbiSpec, 0)
for _, dir := range abiFileOrDirs {
err := filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error {
if err... | go | {
"resource": ""
} |
q27042 | MempoolTransactions | train | func (nv *NodeView) MempoolTransactions(maxTxs int) ([]*txs.Envelope, error) {
var transactions []*txs.Envelope
for _, txBytes := range nv.tmNode.MempoolReactor().Mempool.ReapMaxTxs(maxTxs) {
txEnv, err := nv.txDecoder.DecodeTx(txBytes)
if err != nil {
return nil, err
}
transactions = append(transactions, ... | go | {
"resource": ""
} |
q27043 | FullAccount | train | func FullAccount(name string) GenesisSpec {
// Inheriting from the arbitrary figures used by monax tool for now
amount := uint64(99999999999999)
Power := uint64(9999999999)
return GenesisSpec{
Accounts: []TemplateAccount{{
Name: name,
Amounts: balance.New().Native(amount).Power(Power),
Permiss... | go | {
"resource": ""
} |
q27044 | mergeAccounts | train | func mergeAccounts(bases, overrides []TemplateAccount) []TemplateAccount {
indexOfBase := make(map[string]int, len(bases))
for i, ta := range bases {
if ta.Name != "" {
indexOfBase[ta.Name] = i
}
}
for _, override := range overrides {
if override.Name != "" {
if i, ok := indexOfBase[override.Name]; ok ... | go | {
"resource": ""
} |
q27045 | getNameAddr | train | func getNameAddr(keysDir, name, addr string) (string, error) {
if name == "" && addr == "" {
return "", fmt.Errorf("at least one of name or addr must be provided")
}
// name takes precedent if both are given
var err error
if name != "" {
addr, err = coreNameGet(keysDir, name)
if err != nil {
return "", e... | go | {
"resource": ""
} |
q27046 | RunPlaybooks | train | func RunPlaybooks(args *def.DeployArgs, playbooks []string, logger *logging.Logger) (int, error) {
// if bin and abi paths are default cli settings then use the
// stated defaults of do.Path plus bin|abi
if args.Path == "" {
var err error
args.Path, err = os.Getwd()
if err != nil {
panic(fmt.Sprintf("fail... | go | {
"resource": ""
} |
q27047 | LoadOrNewBlockchain | train | func LoadOrNewBlockchain(db dbm.DB, genesisDoc *genesis.GenesisDoc, logger *logging.Logger) (bool, *Blockchain, error) {
logger = logger.WithScope("LoadOrNewBlockchain")
logger.InfoMsg("Trying to load blockchain state from database",
"database_key", stateKey)
bc, err := loadBlockchain(db)
if err != nil {
return... | go | {
"resource": ""
} |
q27048 | NewBlockchain | train | func NewBlockchain(db dbm.DB, genesisDoc *genesis.GenesisDoc) *Blockchain {
bc := &Blockchain{
db: db,
genesisHash: genesisDoc.Hash(),
genesisDoc: *genesisDoc,
chainID: genesisDoc.ChainID(),
lastBlockTime: genesisDoc.GenesisTime,
appHashAfterLas... | go | {
"resource": ""
} |
q27049 | IsNumeric | train | func (ct SQLColumnType) IsNumeric() bool {
return ct == SQLColumnTypeInt || ct == SQLColumnTypeSerial || ct == SQLColumnTypeNumeric || ct == SQLColumnTypeBigInt
} | go | {
"resource": ""
} |
q27050 | ConvertPermissionsMapAndRolesToAccountPermissions | train | func ConvertPermissionsMapAndRolesToAccountPermissions(permissions map[string]bool,
roles []string) (*AccountPermissions, error) {
var err error
accountPermissions := &AccountPermissions{}
accountPermissions.Base, err = convertPermissionsMapStringIntToBasePermissions(permissions)
if err != nil {
return nil, err
... | go | {
"resource": ""
} |
q27051 | convertPermissionsMapStringIntToBasePermissions | train | func convertPermissionsMapStringIntToBasePermissions(permissions map[string]bool) (BasePermissions, error) {
// initialise basePermissions as ZeroBasePermissions
basePermissions := ZeroBasePermissions
for permissionName, value := range permissions {
permissionsFlag, err := PermStringToFlag(permissionName)
if er... | go | {
"resource": ""
} |
q27052 | BasePermissionsFromStringList | train | func BasePermissionsFromStringList(permissions []string) (BasePermissions, error) {
permFlag, err := PermFlagFromStringList(permissions)
if err != nil {
return ZeroBasePermissions, err
}
return BasePermissions{
Perms: permFlag,
SetBit: permFlag,
}, nil
} | go | {
"resource": ""
} |
q27053 | PermFlagFromStringList | train | func PermFlagFromStringList(permissions []string) (PermFlag, error) {
var permFlag PermFlag
for _, perm := range permissions {
s := strings.TrimSpace(perm)
if s == "" {
continue
}
flag, err := PermStringToFlag(s)
if err != nil {
return permFlag, err
}
permFlag |= flag
}
return permFlag, nil
} | go | {
"resource": ""
} |
q27054 | PermFlagToStringList | train | 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 | {
"resource": ""
} |
q27055 | NewService | train | 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: validat... | go | {
"resource": ""
} |
q27056 | Blocks | train | 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 || la... | go | {
"resource": ""
} |
q27057 | NewDeterministicGenesis | train | func NewDeterministicGenesis(seed int64) *deterministicGenesis {
return &deterministicGenesis{
random: rand.New(rand.NewSource(seed)),
}
} | go | {
"resource": ""
} |
q27058 | Execute | train | 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 :=... | go | {
"resource": ""
} |
q27059 | findTable | train | 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 findin... | go | {
"resource": ""
} |
q27060 | getTableDef | train | 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 ... | go | {
"resource": ""
} |
q27061 | alterTable | train | 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 er... | go | {
"resource": ""
} |
q27062 | createTable | train | 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(safeTa... | go | {
"resource": ""
} |
q27063 | getSelectQuery | train | 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 contai... | go | {
"resource": ""
} |
q27064 | getBlockTables | train | 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", ... | go | {
"resource": ""
} |
q27065 | safe | train | func safe(parameter string) string {
replacer := strings.NewReplacer(";", "", ",", "")
return replacer.Replace(parameter)
} | go | {
"resource": ""
} |
q27066 | getJSON | train | func (db *SQLDB) getJSON(JSON interface{}) ([]byte, error) {
if JSON != nil {
return json.Marshal(JSON)
}
return json.Marshal("")
} | go | {
"resource": ""
} |
q27067 | getJSONFromValues | train | func (db *SQLDB) getJSONFromValues(values []interface{}) ([]byte, error) {
if values != nil {
return json.Marshal(values)
}
return json.Marshal("")
} | go | {
"resource": ""
} |
q27068 | getValuesFromJSON | train | func (db *SQLDB) getValuesFromJSON(JSON string) ([]interface{}, error) {
pointers := make([]interface{}, 0)
bytes := []byte(JSON)
err := json.Unmarshal(bytes, &pointers)
return pointers, err
} | go | {
"resource": ""
} |
q27069 | AsException | train | 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 | {
"resource": ""
} |
q27070 | PublicKeyFromBytes | train | 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 CurveTypeS... | go | {
"resource": ""
} |
q27071 | Reinitialise | train | func (p *PrivateKey) Reinitialise() error {
initP, err := PrivateKeyFromRawBytes(p.RawBytes(), p.CurveType)
if err != nil {
return err
}
*p = initP
return nil
} | go | {
"resource": ""
} |
q27072 | EnsureEd25519PrivateKeyCorrect | train | 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... | go | {
"resource": ""
} |
q27073 | Put | train | 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 | {
"resource": ""
} |
q27074 | push | train | 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 | {
"resource": ""
} |
q27075 | NewConsumer | train | func NewConsumer(cfg *config.VentConfig, log *logger.Logger, eventChannel chan types.EventData) *Consumer {
return &Consumer{
Config: cfg,
Log: log,
Closing: false,
EventsChannel: eventChannel,
}
} | go | {
"resource": ""
} |
q27076 | Health | train | 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... | go | {
"resource": ""
} |
q27077 | Shutdown | train | func (c *Consumer) Shutdown() {
c.Log.Info("msg", "Shutting down vent consumer...")
c.Closing = true
c.GRPCConnection.Close()
} | go | {
"resource": ""
} |
q27078 | NewBlockData | train | func NewBlockData(height uint64) *BlockData {
data := types.EventData{
Tables: make(map[string]types.EventDataTable),
BlockHeight: height,
}
return &BlockData{
Data: data,
}
} | go | {
"resource": ""
} |
q27079 | AddRow | train | 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 | {
"resource": ""
} |
q27080 | GetRows | train | 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 | {
"resource": ""
} |
q27081 | PendingRows | train | 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 | {
"resource": ""
} |
q27082 | NewDynamicMemory | train | func NewDynamicMemory(initialCapacity, maximumCapacity uint64, errSink errors.Sink) Memory {
return &dynamicMemory{
slice: make([]byte, initialCapacity),
maximumCapacity: maximumCapacity,
errSink: errSink,
}
} | go | {
"resource": ""
} |
q27083 | CallSim | train | 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,
}... | go | {
"resource": ""
} |
q27084 | CallCodeSim | train | 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: ... | go | {
"resource": ""
} |
q27085 | LoadKeysFromConfig | train | 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 {
... | go | {
"resource": ""
} |
q27086 | LoadLoggerFromConfig | train | func (kern *Kernel) LoadLoggerFromConfig(conf *logconfig.LoggingConfig) error {
logger, err := lifecycle.NewLoggerFromLoggingConfig(conf)
kern.SetLogger(logger)
return err
} | go | {
"resource": ""
} |
q27087 | LoadExecutionOptionsFromConfig | train | 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 | {
"resource": ""
} |
q27088 | LoadTendermintFromConfig | train | 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("Bu... | go | {
"resource": ""
} |
q27089 | LoadKernelFromConfig | train | 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: ... | go | {
"resource": ""
} |
q27090 | U256 | train | 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 | {
"resource": ""
} |
q27091 | SignExtend | train | 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... | go | {
"resource": ""
} |
q27092 | HealthCheck | train | 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 | {
"resource": ""
} |
q27093 | NewRemoteKeyClient | train | 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)
retu... | go | {
"resource": ""
} |
q27094 | NewLocalKeyClient | train | func NewLocalKeyClient(ks *KeyStore, logger *logging.Logger) KeyClient {
logger = logger.WithScope("LocalKeyClient")
return &localKeyClient{ks: ks, logger: logger}
} | go | {
"resource": ""
} |
q27095 | AddressableSigner | train | 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,
addres... | go | {
"resource": ""
} |
q27096 | Open | train | 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 | {
"resource": ""
} |
q27097 | AlterColumnQuery | train | 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;",
... | go | {
"resource": ""
} |
q27098 | String | train | 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
... | go | {
"resource": ""
} |
q27099 | PermStringToFlag | train | 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 Crea... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.