_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q173300 | FloatOr | validation | func (t Typed) FloatOr(key string, d float64) float64 {
if value, exists := t.FloatIf(key); exists {
return value
}
return d
} | go | {
"resource": ""
} |
q173301 | FloatMust | validation | func (t Typed) FloatMust(key string) float64 {
f, exists := t.FloatIf(key)
if exists == false {
panic("expected float value for " + key)
}
return f
} | go | {
"resource": ""
} |
q173302 | FloatIf | validation | func (t Typed) FloatIf(key string) (float64, bool) {
value, exists := t[key]
if exists == false {
return 0, false
}
switch t := value.(type) {
case float64:
return t, true
case string:
f, err := strconv.ParseFloat(t, 10)
return f, err == nil
}
return 0, false
} | go | {
"resource": ""
} |
q173303 | StringOr | validation | func (t Typed) StringOr(key string, d string) string {
if value, exists := t.StringIf(key); exists {
return value
}
return d
} | go | {
"resource": ""
} |
q173304 | StringMust | validation | func (t Typed) StringMust(key string) string {
s, exists := t.StringIf(key)
if exists == false {
panic("expected string value for " + key)
}
return s
} | go | {
"resource": ""
} |
q173305 | TimeOr | validation | func (t Typed) TimeOr(key string, d time.Time) time.Time {
if value, exists := t.TimeIf(key); exists {
return value
}
return d
} | go | {
"resource": ""
} |
q173306 | TimeMust | validation | func (t Typed) TimeMust(key string) time.Time {
tt, exists := t.TimeIf(key)
if exists == false {
panic("expected time.Time value for " + key)
}
return tt
} | go | {
"resource": ""
} |
q173307 | TimeIf | validation | func (t Typed) TimeIf(key string) (time.Time, bool) {
value, exists := t[key]
if exists == false {
return time.Time{}, false
}
if n, ok := value.(time.Time); ok {
return n, true
}
return time.Time{}, false
} | go | {
"resource": ""
} |
q173308 | ObjectMust | validation | func (t Typed) ObjectMust(key string) Typed {
t, exists := t.ObjectIf(key)
if exists == false {
panic("expected map for " + key)
}
return t
} | go | {
"resource": ""
} |
q173309 | InterfaceOr | validation | func (t Typed) InterfaceOr(key string, d interface{}) interface{} {
if value, exists := t.InterfaceIf(key); exists {
return value
}
return d
} | go | {
"resource": ""
} |
q173310 | InterfaceMust | validation | func (t Typed) InterfaceMust(key string) interface{} {
i, exists := t.InterfaceIf(key)
if exists == false {
panic("expected map for " + key)
}
return i
} | go | {
"resource": ""
} |
q173311 | InterfaceIf | validation | func (t Typed) InterfaceIf(key string) (interface{}, bool) {
value, exists := t[key]
if exists == false {
return nil, false
}
return value, true
} | go | {
"resource": ""
} |
q173312 | Bools | validation | func (t Typed) Bools(key string) []bool {
return t.BoolsOr(key, nil)
} | go | {
"resource": ""
} |
q173313 | BoolsOr | validation | func (t Typed) BoolsOr(key string, d []bool) []bool {
n, ok := t.BoolsIf(key)
if ok {
return n
}
return d
} | go | {
"resource": ""
} |
q173314 | Ints | validation | func (t Typed) Ints(key string) []int {
return t.IntsOr(key, nil)
} | go | {
"resource": ""
} |
q173315 | Ints64 | validation | func (t Typed) Ints64(key string) []int64 {
return t.Ints64Or(key, nil)
} | go | {
"resource": ""
} |
q173316 | Floats | validation | func (t Typed) Floats(key string) []float64 {
return t.FloatsOr(key, nil)
} | go | {
"resource": ""
} |
q173317 | Strings | validation | func (t Typed) Strings(key string) []string {
return t.StringsOr(key, nil)
} | go | {
"resource": ""
} |
q173318 | Objects | validation | func (t Typed) Objects(key string) []Typed {
value, _ := t.ObjectsIf(key)
return value
} | go | {
"resource": ""
} |
q173319 | ObjectsIf | validation | func (t Typed) ObjectsIf(key string) ([]Typed, bool) {
value, exists := t[key]
if exists == true {
switch t := value.(type) {
case []interface{}:
l := len(t)
n := make([]Typed, l)
for i := 0; i < l; i++ {
switch it := t[i].(type) {
case map[string]interface{}:
n[i] = Typed(it)
case Typed... | go | {
"resource": ""
} |
q173320 | GetSessions | validation | func (h *Handler) GetSessions(tkn, channel string) ([]data.Session, error) {
logger := h.logger.Add("method", "GetSessions", "channel", channel)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
tail, args := h.getSessionsConditions(channel)
result, err := h.selectAllFrom(
... | go | {
"resource": ""
} |
q173321 | ObjectChange | validation | func (h *Handler) ObjectChange(ctx context.Context, tkn, objectType string,
objectIDs []string) (*rpc.Subscription, error) {
logger := h.logger.Add("method", "ObjectChange",
"objectType", objectType, "objectIDs", objectIDs)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
... | go | {
"resource": ""
} |
q173322 | AutoOfferingPopUp | validation | func AutoOfferingPopUp(logger log.Logger, abi abi.ABI, db *reform.DB,
ethBack eth.Backend, timeNowFunc func() time.Time,
period uint) []*data.Job {
logger = logger.Add("method", "AutoOfferingPopUp")
do, err := data.ReadBoolSetting(
db.Querier, data.SettingOfferingAutoPopUp)
if err != nil {
logger.Warn(err.Err... | go | {
"resource": ""
} |
q173323 | MarshalJSON | validation | func (n Base64BigInt) MarshalJSON() ([]byte, error) {
buf, err := ToBytes(Base64String(n))
if err != nil {
return nil, fmt.Errorf("could not decode base64: %v", err)
}
v := big.NewInt(0)
v.SetBytes(buf)
return []byte(v.String()), nil
} | go | {
"resource": ""
} |
q173324 | Scan | validation | func (t *LogTopics) Scan(src interface{}) error {
somcData, ok := src.([]byte)
if !ok {
return fmt.Errorf(
"type assertion .([]byte) failed, actual type is %T",
src,
)
}
return json.Unmarshal(somcData, &t)
} | go | {
"resource": ""
} |
q173325 | NewWorker | validation | func NewWorker(logger log.Logger, db *reform.DB, ethBack eth.Backend,
gasConc *GasConf, pscAddr common.Address, payAddr string,
pwdGetter data.PWDGetter, countryConf *country.Config,
decryptKeyFunc data.ToPrivateKeyFunc, eptConf *ept.Config,
torHostname string, somcClientBuilder somc.ClientBuilderInterface) (*Worke... | go | {
"resource": ""
} |
q173326 | NewLoggerBase | validation | func NewLoggerBase(conf *BaseConfig, log LoggerFunc) (*LoggerBase, error) {
if _, ok := levelNums[conf.Level]; !ok {
return nil, ErrBadLevel
}
if _, ok := levelNums[conf.StackLevel]; !ok {
return nil, ErrBadStackLevel
}
ctx := map[string]interface{}{}
return &LoggerBase{conf: conf, log: log, ctx: ctx}, nil... | go | {
"resource": ""
} |
q173327 | Log | validation | func (l *LoggerBase) Log(lvl Level, msg string) {
lvln, ok := levelNums[lvl]
if !ok {
panic("bad log level")
}
if lvln < levelNums[l.conf.Level] {
return
}
var stack *string
if lvln >= levelNums[l.conf.StackLevel] {
tmp := string(debug.Stack())
stack = &tmp
}
if err := l.log(lvl, msg, l.ctx, stack);... | go | {
"resource": ""
} |
q173328 | PreAccountAddBalanceApprove | validation | func (w *Worker) PreAccountAddBalanceApprove(job *data.Job) error {
logger := w.logger.Add("method", "PreAccountAddBalanceApprove", "job", job)
acc, err := w.relatedAccount(logger, job,
data.JobPreAccountAddBalanceApprove)
if err != nil {
return err
}
logger = logger.Add("account", acc)
jobData, err := w.b... | go | {
"resource": ""
} |
q173329 | PreAccountAddBalance | validation | func (w *Worker) PreAccountAddBalance(job *data.Job) error {
logger := w.logger.Add("method", "PreAccountAddBalance", "job", job)
acc, err := w.relatedAccount(logger, job, data.JobPreAccountAddBalance)
if err != nil {
return err
}
jobData, err := w.approvedBalanceData(logger, job)
if err != nil {
return err... | go | {
"resource": ""
} |
q173330 | AfterAccountAddBalance | validation | func (w *Worker) AfterAccountAddBalance(job *data.Job) error {
return w.updateAccountBalancesJob(job, data.JobAfterAccountAddBalance)
} | go | {
"resource": ""
} |
q173331 | AfterAccountReturnBalance | validation | func (w *Worker) AfterAccountReturnBalance(job *data.Job) error {
return w.updateAccountBalancesJob(job, data.JobAfterAccountReturnBalance)
} | go | {
"resource": ""
} |
q173332 | AccountUpdateBalances | validation | func (w *Worker) AccountUpdateBalances(job *data.Job) error {
return w.updateAccountBalancesJob(job, data.JobAccountUpdateBalances)
} | go | {
"resource": ""
} |
q173333 | PreAccountReturnBalance | validation | func (w *Worker) PreAccountReturnBalance(job *data.Job) error {
logger := w.logger.Add("method", "PreAccountReturnBalance", "job", job)
acc, err := w.relatedAccount(logger, job, data.JobPreAccountReturnBalance)
if err != nil {
return err
}
key, err := w.key(logger, acc.PrivateKey)
if err != nil {
return err
... | go | {
"resource": ""
} |
q173334 | GetOfferingUsage | validation | func (h *Handler) GetOfferingUsage(password, offeringID string) (*uint, error) {
logger := h.logger.Add("method", "GetOfferingUsage",
"offeringID", offeringID)
return h.uintFromQuery(logger, password,
`SELECT SUM(sessions.units_used)
FROM channels
JOIN sessions
ON sessions.channel=channels.id
... | go | {
"resource": ""
} |
q173335 | GetProductUsage | validation | func (h *Handler) GetProductUsage(password, productID string) (*uint, error) {
logger := h.logger.Add("method", "GetProductUsage",
"productID", productID)
return h.uintFromQuery(logger, password,
`SELECT SUM(sessions.units_used)
FROM offerings
JOIN channels
ON channels.offering=offerings.id
A... | go | {
"resource": ""
} |
q173336 | AddMapping | validation | func (n *upnp) AddMapping(protocol string, extPort, intPort int,
desc string, lifetime time.Duration) error {
ip, err := n.internalAddress()
if err != nil {
return nil
}
protocol = strings.ToUpper(protocol)
lifetimeS := uint32(lifetime / time.Second)
n.DeleteMapping(protocol, extPort, intPort)
return n.client... | go | {
"resource": ""
} |
q173337 | DeleteMapping | validation | func (n *upnp) DeleteMapping(protocol string, extPort, intPort int) error {
return n.client.DeletePortMapping(
"", uint16(extPort), strings.ToUpper(protocol))
} | go | {
"resource": ""
} |
q173338 | PostCheque | validation | func PostCheque(db *reform.DB, channel string,
pscAddr data.HexString, pass string, amount uint64,
tls bool, timeout uint, pr *proc.Processor) error {
pld, err := newPayload(db, channel, pscAddr, pass, amount)
if err != nil {
return err
}
return postPayload(db, channel, pld, tls, timeout, pr, srv.Send)
} | go | {
"resource": ""
} |
q173339 | NewHTTPClient | validation | func NewHTTPClient(sock uint) (*http.Client, error) {
torProxyURL, err := url.Parse(fmt.Sprint("socks5://127.0.0.1:", sock))
if err != nil {
return nil, err
}
// Set up a custom HTTP transport to use the proxy and create the client
torTransport := &http.Transport{Proxy: http.ProxyURL(torProxyURL)}
return &http... | go | {
"resource": ""
} |
q173340 | NewServer | validation | func NewServer(conf *Config) (*Server, error) {
rpcsrv := rpc.NewServer()
mux := http.NewServeMux()
mux.HandleFunc(HTTPPath, rpcsrv.ServeHTTP)
mux.Handle(WSPath, rpcsrv.WebsocketHandler(conf.AllowedOrigins))
httpsrv := &http.Server{
Addr: conf.Addr,
Handler: mux,
}
return &Server{
conf: conf,
rp... | go | {
"resource": ""
} |
q173341 | AddHandler | validation | func (s *Server) AddHandler(namespace string, handler interface{}) error {
return s.rpcsrv.RegisterName(namespace, handler)
} | go | {
"resource": ""
} |
q173342 | ListenAndServe | validation | func (s *Server) ListenAndServe() error {
if s.conf.TLS != nil {
return s.httpsrv.ListenAndServeTLS(
s.conf.TLS.CertFile, s.conf.TLS.KeyFile)
}
return s.httpsrv.ListenAndServe()
} | go | {
"resource": ""
} |
q173343 | Recover | validation | func Recover(db *reform.DB) error {
if err := recoverServiceStatuses(db); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q173344 | ConnStr | validation | func (c DBConfig) ConnStr() string {
comps := []string{}
for k, v := range c.Conn {
comps = append(comps, k+"="+v)
}
return strings.Join(comps, " ")
} | go | {
"resource": ""
} |
q173345 | NewDBFromConnStr | validation | func NewDBFromConnStr(connStr string) (*reform.DB, error) {
conn, err := dbConnect(connStr)
if err != nil {
return nil, err
}
return newReform(conn), nil
} | go | {
"resource": ""
} |
q173346 | NewDB | validation | func NewDB(conf *DBConfig) (*reform.DB, error) {
conn, err := dbConnect(conf.ConnStr())
if err != nil {
return nil, err
}
conn.SetMaxOpenConns(conf.MaxOpen)
conn.SetMaxIdleConns(conf.MaxIddle)
return newReform(conn), nil
} | go | {
"resource": ""
} |
q173347 | GetCountry | validation | func GetCountry(timeout uint64, url, field string) (string, error) {
ctx, cancel := context.WithTimeout(
context.Background(), time.Millisecond*time.Duration(timeout))
defer cancel()
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
return "", err
}
res, err := do(ctx, req)
if err != nil... | go | {
"resource": ""
} |
q173348 | Endpoint | validation | func (h *Handler) Endpoint(key data.Base64String) (*data.Base64String, error) {
logger := h.logger.Add("type", "agent/tor-somc.Handler")
channelsStructs, err := h.db.SelectAllFrom(data.ChannelTable, "")
if err != nil {
h.logger.Error(err.Error())
return nil, ErrInternal
}
for _, chanStruct := range channelsS... | go | {
"resource": ""
} |
q173349 | NewServer | validation | func NewServer(conf *Config, logger log.Logger, db *reform.DB) *Server {
s := &Server{
Server: srv.NewServer(conf.Config),
logger: logger.Add("type", "pay.Server"),
db: db,
}
s.HandleFunc(payPath,
s.RequireHTTPMethods(s.logger, s.handlePay, http.MethodPost))
return s
} | go | {
"resource": ""
} |
q173350 | NewMonitor | validation | func NewMonitor(conf *Config, c Client, db *reform.DB, l log.Logger, psc,
ptc common.Address, role string, q Queue) (*Monitor, error) {
abiJSON := contract.PrivatixServiceContractABI
pscABI, err := abi.JSON(strings.NewReader(abiJSON))
if err != nil {
l.Error(err.Error())
return nil, ErrFailedToParseABI
}
abiJ... | go | {
"resource": ""
} |
q173351 | initLastProcessedBlock | validation | func (m *Monitor) initLastProcessedBlock(role string, initialBlocks uint64) {
logger := m.logger.Add("method", "initLastProcessedBlock",
"role", role, "initialBlocks", initialBlocks)
block, err := m.getLastProcessedBlockNumber()
if block > 0 || err != nil || role != data.RoleClient ||
initialBlocks == 0 {
ret... | go | {
"resource": ""
} |
q173352 | Start | validation | func (m *Monitor) Start() {
logger := m.logger.Add("method", "Start")
ctx, cancel := context.WithCancel(context.Background())
ticker := time.NewTicker(m.queryPause)
m.stopMonitor = func() {
ticker.Stop()
cancel()
}
go func() {
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
err :=... | go | {
"resource": ""
} |
q173353 | newClient | validation | func newClient(cfg *Config, logger log.Logger) (*client, error) {
logger2 := logger.Add("method", "newClient", "config", cfg)
u, err := url.Parse(cfg.GethURL)
if err != nil {
return nil, err
}
ctx, cancel := context.WithCancel(context.Background())
c := &client{cancel: cancel, cfg: cfg, logger: logger}
var... | go | {
"resource": ""
} |
q173354 | Loop | validation | func Loop(ctx context.Context, logger log.Logger, db *reform.DB,
queue job.Queue, duration time.Duration, f func() []*data.Job) {
tik := time.NewTicker(duration)
logger = logger.Add("method", "Loop")
go loop(ctx, tik, db, queue, f, logger, nil)
} | go | {
"resource": ""
} |
q173355 | Offering | validation | func (c *Client) Offering(hash data.HexString) (data.Base64String, error) {
return c.requestWithPayload("api_offering", string(hash))
} | go | {
"resource": ""
} |
q173356 | Endpoint | validation | func (c *Client) Endpoint(channelKey data.Base64String) (data.Base64String, error) {
return c.requestWithPayload("api_endpoint", string(channelKey))
} | go | {
"resource": ""
} |
q173357 | Ping | validation | func (c *Client) Ping() error {
_, err := c.client.Head(c.url())
return err
} | go | {
"resource": ""
} |
q173358 | GetEthTransactions | validation | func (h *Handler) GetEthTransactions(tkn, relType, relID string,
offset, limit uint) (*GetEthTransactionsResult, error) {
logger := h.logger.Add("method", "GetEthTransactions", "relatedType",
relType, "relatedID", relID, "limit", limit, "offset", offset)
if !h.token.Check(tkn) {
logger.Warn("access denied")
r... | go | {
"resource": ""
} |
q173359 | AgentSeal | validation | func AgentSeal(msg, clientPub []byte, agentKey *ecdsa.PrivateKey) ([]byte, error) {
pubKey, err := ethcrypto.UnmarshalPubkey(clientPub)
if err != nil {
return nil, err
}
pub := ecies.ImportECDSAPublic(pubKey)
msgEncrypted, err := ecies.Encrypt(rand.Reader, pub, msg, nil, nil)
if err != nil {
return nil, err
... | go | {
"resource": ""
} |
q173360 | ClientOpen | validation | func ClientOpen(c, agentPub []byte, clientPrv *ecdsa.PrivateKey) ([]byte, error) {
sealed, sig := UnpackSignature(c)
hash := ethcrypto.Keccak256(sealed)
if !VerifySignature(agentPub, hash, sig) {
return nil, ErrWrongSignature
}
prv := ecies.ImportECDSA(clientPrv)
opened, err := prv.Decrypt(sealed, nil, nil)
... | go | {
"resource": ""
} |
q173361 | PackWithSignature | validation | func PackWithSignature(msg []byte, key *ecdsa.PrivateKey) ([]byte, error) {
sig, err := signature(key, msg)
if err != nil {
return nil, err
}
return packSignature(msg, sig), nil
} | go | {
"resource": ""
} |
q173362 | UnpackSignature | validation | func UnpackSignature(c []byte) (msg []byte, sig []byte) {
msg = c[:len(c)-sigLen]
sig = c[len(c)-sigLen:]
return
} | go | {
"resource": ""
} |
q173363 | VerifySignature | validation | func VerifySignature(pubk, msg, sig []byte) bool {
return ethcrypto.VerifySignature(pubk, msg, sig)
} | go | {
"resource": ""
} |
q173364 | signature | validation | func signature(key *ecdsa.PrivateKey, msg []byte) ([]byte, error) {
hash := ethcrypto.Keccak256(msg)
sig, err := ethcrypto.Sign(hash, key)
if err != nil {
return nil, err
}
sig = sig[:len(sig)-1]
return sig, nil
} | go | {
"resource": ""
} |
q173365 | GetObject | validation | func (h *Handler) GetObject(
tkn, objectType, id string) (json.RawMessage, error) {
logger := h.logger.Add("method", "GetObject",
"type", objectType, "id", id)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
table, ok := objectTypes[objectType]
if !ok {
logger.Warn(Er... | go | {
"resource": ""
} |
q173366 | GetObjectByHash | validation | func (h *Handler) GetObjectByHash(
tkn, objectType, hash string) (json.RawMessage, error) {
logger := h.logger.Add("method", "GetObjectByHash",
"type", objectType, "hash", hash)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
table, ok := objectWithHashTypes[objectType]
... | go | {
"resource": ""
} |
q173367 | ToError | validation | func ToError(err error) *Error {
if err == nil {
return nil
}
if err, ok := err.(rpc.Error); ok {
return &Error{Code: err.ErrorCode(), Message: err.Error()}
}
return &Error{Message: err.Error()}
} | go | {
"resource": ""
} |
q173368 | SetPassword | validation | func (h *Handler) SetPassword(password string) error {
logger := h.logger.Add("method", "SetPassword")
logger.Debug("trying to set password")
if password == "" {
logger.Warn("received empty password")
return ErrEmptyPassword
}
if err := h.validatePasswordNotSet(logger); err != nil {
return err
}
salt :... | go | {
"resource": ""
} |
q173369 | UpdatePassword | validation | func (h *Handler) UpdatePassword(current, new string) error {
logger := h.logger.Add("method", "UpdatePassword")
if err := h.checkPassword(logger, current); err != nil {
return err
}
logger.Debug("updating password")
if new == "" {
logger.Warn("received empty password for update")
return ErrEmptyPassword
... | go | {
"resource": ""
} |
q173370 | GetToken | validation | func (h *Handler) GetToken(password string) (*string, error) {
logger := h.logger.Add("method", "GetToken")
if err := h.checkPassword(logger, password); err != nil {
return nil, err
}
logger.Debug("making access token")
v, err := h.token.Make()
if err != nil {
logger.Error(err.Error())
return nil, ErrInt... | go | {
"resource": ""
} |
q173371 | NewProcessor | validation | func NewProcessor(
conf *Config, db *reform.DB, queue job.Queue) *Processor {
return &Processor{
conf: conf,
db: db,
queue: queue,
}
} | go | {
"resource": ""
} |
q173372 | NewConfig | validation | func NewConfig() *Config {
return &Config{
CollectJobs: 100,
CollectPeriod: 1000,
WorkerBufLen: 10,
Workers: 0,
TypeConfig: TypeConfig{
TryLimit: 3,
TryPeriod: 60000,
},
Types: make(map[string]TypeConfig),
}
} | go | {
"resource": ""
} |
q173373 | NewQueue | validation | func NewQueue(conf *Config, logger log.Logger, db *reform.DB,
handlers HandlerMap) Queue {
l := logger.Add("type", "job.Queue")
return &queue{
conf: conf,
logger: l,
db: db,
handlers: handlers,
subs: map[string][]subEntry{},
}
} | go | {
"resource": ""
} |
q173374 | AddWithDataAndDelay | validation | func AddWithDataAndDelay(q Queue, tx *reform.TX,
jobType, relatedType, relatedID, creator string,
jobData interface{}, delay time.Duration) error {
data2, err := json.Marshal(jobData)
if err != nil {
return err
}
return q.Add(tx, &data.Job{
Type: jobType,
RelatedType: relatedType,
RelatedID: rel... | go | {
"resource": ""
} |
q173375 | AddWithData | validation | func AddWithData(q Queue, tx *reform.TX,
jobType, relatedType, relatedID, creator string,
jobData interface{}) error {
return AddWithDataAndDelay(q, tx, jobType,
relatedType, relatedID, creator, jobData, time.Duration(0))
} | go | {
"resource": ""
} |
q173376 | AddSimple | validation | func AddSimple(q Queue, tx *reform.TX,
jobType, relatedType, relatedID, creator string) error {
return AddWithData(q, tx,
jobType, relatedType, relatedID, creator, &struct{}{})
} | go | {
"resource": ""
} |
q173377 | AddWithDelay | validation | func AddWithDelay(q Queue, tx *reform.TX,
jobType, relatedType, relatedID, creator string,
delay time.Duration) error {
return AddWithDataAndDelay(q, tx,
jobType, relatedType, relatedID, creator, &struct{}{}, delay)
} | go | {
"resource": ""
} |
q173378 | Subscribe | validation | func (q *queue) Subscribe(
subKeys []string, subID string, subFunc SubFunc) error {
q.subsMtx.Lock()
defer q.subsMtx.Unlock()
for i, v := range subKeys {
if err := q.subscribe(v, subID, subFunc); err != nil {
for j := 0; j < i; j++ {
q.unsubscribe(subKeys[j], subID)
}
return err
}
}
return nil
... | go | {
"resource": ""
} |
q173379 | Unsubscribe | validation | func (q *queue) Unsubscribe(subKeys []string, subID string) error {
q.subsMtx.Lock()
defer q.subsMtx.Unlock()
var err error
for _, v := range subKeys {
if err2 := q.unsubscribe(v, subID); err == nil {
err = err2
}
}
return err
} | go | {
"resource": ""
} |
q173380 | TopUpChannel | validation | func (h *Handler) TopUpChannel(
tkn, channel string, deposit, gasPrice uint64) error {
logger := h.logger.Add("method", "TopUpChannel",
"channel", channel, "deposit", deposit, "gasPrice", gasPrice)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
ch := &data.Channel{}
if err ... | go | {
"resource": ""
} |
q173381 | ChangeChannelStatus | validation | func (h *Handler) ChangeChannelStatus(tkn, channel, action string) error {
logger := h.logger.Add("method", "ChangeChannelStatus",
"channel", channel, "action", action, "userRole", h.userRole)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
condition := fmt.Sprintf("WHERE id =... | go | {
"resource": ""
} |
q173382 | GetAgentChannels | validation | func (h *Handler) GetAgentChannels(tkn string,
channelStatus, serviceStatus []string,
offset, limit uint) (*GetAgentChannelsResult, error) {
logger := h.logger.Add("method", "GetAgentChannels",
"channelStatus", channelStatus, "serviceStatus", serviceStatus)
if !h.token.Check(tkn) {
logger.Warn("access denied")... | go | {
"resource": ""
} |
q173383 | GetChannelsUsage | validation | func (h *Handler) GetChannelsUsage(tkn string, ids []string) (map[string]Usage, error) {
logger := h.logger.Add("method", "GetChannelsUsage", "objectType", "channel", "objectIDs", ids)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
return h.getChannelsUsages(logger, ids)
} | go | {
"resource": ""
} |
q173384 | GetClientChannels | validation | func (h *Handler) GetClientChannels(tkn string, channelStatus,
serviceStatus []string, offset,
limit uint) (*GetClientChannelsResult, error) {
logger := h.logger.Add("method", "GetClientChannels",
"channelStatus", channelStatus, "serviceStatus", serviceStatus)
if !h.token.Check(tkn) {
logger.Warn("access denie... | go | {
"resource": ""
} |
q173385 | ReadSetting | validation | func ReadSetting(db *reform.Querier, key string) (string, error) {
var st Setting
if err := FindByPrimaryKeyTo(db, &st, key); err != nil {
return "", fmt.Errorf(
"failed to find '%s' setting: %s", key, err)
}
return st.Value, nil
} | go | {
"resource": ""
} |
q173386 | ReadUintSetting | validation | func ReadUintSetting(db *reform.Querier, key string) (uint, error) {
val, err := ReadSetting(db, key)
if err != nil {
return 0, err
}
val2, err := strconv.ParseUint(val, 10, 32)
if err != nil {
return 0, newSettingParseError(key, err)
}
return uint(val2), nil
} | go | {
"resource": ""
} |
q173387 | ReadBoolSetting | validation | func ReadBoolSetting(db *reform.Querier, key string) (bool, error) {
val, err := ReadSetting(db, key)
if err != nil {
return false, err
}
val2, err := strconv.ParseBool(val)
if err != nil {
return false, newSettingParseError(key, err)
}
return bool(val2), nil
} | go | {
"resource": ""
} |
q173388 | SuspendChannel | validation | func (p *Processor) SuspendChannel(id, jobCreator string,
agent bool) (string, error) {
var jobType string
if agent {
jobType = data.JobAgentPreServiceSuspend
} else {
jobType = data.JobClientPreServiceSuspend
}
return p.alterServiceStatus(id, jobCreator,
jobType, "", suspendTransitions, false)
} | go | {
"resource": ""
} |
q173389 | ActivateChannel | validation | func (p *Processor) ActivateChannel(id, jobCreator string,
agent bool) (string, error) {
var jobType string
if agent {
jobType = data.JobAgentPreServiceUnsuspend
} else {
jobType = data.JobClientPreServiceUnsuspend
}
return p.alterServiceStatus(id, jobCreator,
jobType, "", activateTransitions, false)
} | go | {
"resource": ""
} |
q173390 | TerminateChannel | validation | func (p *Processor) TerminateChannel(id, jobCreator string,
agent bool) (string, error) {
var jobType string
if agent {
jobType = data.JobAgentPreServiceTerminate
} else {
jobType = data.JobClientPreServiceTerminate
}
return p.alterServiceStatus(id, jobCreator,
jobType, jobType, terminateTransitions, true)... | go | {
"resource": ""
} |
q173391 | ExportPrivateKey | validation | func (h *Handler) ExportPrivateKey(tkn, account string) ([]byte, error) {
logger := h.logger.Add("method", "ExportPrivateKey",
"account", account)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
var acc data.Account
err := h.db.FindByPrimaryKeyTo(&acc, account)
if err !=... | go | {
"resource": ""
} |
q173392 | GetAccounts | validation | func (h *Handler) GetAccounts(tkn string) ([]data.Account, error) {
logger := h.logger.Add("method", "GetAccounts")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
accounts, err := h.selectAllFrom(logger, data.AccountTable, "")
if err != nil {
return nil, err
}
result... | go | {
"resource": ""
} |
q173393 | GenerateAccount | validation | func (h *Handler) GenerateAccount(
tkn string, params *AccountParams) (*string, error) {
logger := h.logger.Add("method", "GenerateAccount")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
account := params.prefilledAccount()
id, err := h.fillAndSaveAccount(
logger, ac... | go | {
"resource": ""
} |
q173394 | ImportAccountFromHex | validation | func (h *Handler) ImportAccountFromHex(
tkn string, params *AccountParamsWithHexKey) (*string, error) {
logger := h.logger.Add("method", "ImportAccountFromHex")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
makeECDSAFunc := h.hexPrivateKeyToECDSA(params.PrivateKeyHex)
... | go | {
"resource": ""
} |
q173395 | ImportAccountFromJSON | validation | func (h *Handler) ImportAccountFromJSON(
tkn string, params *AccountParams, jsonBlob json.RawMessage,
jsonKeyStorePassword string) (*string, error) {
logger := h.logger.Add("method", "ImportAccountFromJSON")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
account := param... | go | {
"resource": ""
} |
q173396 | TransferTokens | validation | func (h *Handler) TransferTokens(
tkn, account, destination string, amount, gasPrice uint64) error {
logger := h.logger.Add("method", "TransferTokens", "destination",
destination, "amount", amount, "gasPrice", gasPrice)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
if amoun... | go | {
"resource": ""
} |
q173397 | UpdateBalance | validation | func (h *Handler) UpdateBalance(tkn, account string) error {
logger := h.logger.Add("method", "UpdateBalance",
"account", account)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
err := h.findByPrimaryKey(
logger, ErrAccountNotFound, &data.Account{}, account)
if err != nil ... | go | {
"resource": ""
} |
q173398 | UpdateAccount | validation | func (h *Handler) UpdateAccount(tkn, account, name string,
isDefault, inUse bool) error {
logger := h.logger.Add("method", "UpdateAccount",
"account", account)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
acc := data.Account{}
err := h.findByPrimaryKey(
logger, ErrAccou... | go | {
"resource": ""
} |
q173399 | GetLastBlockNumber | validation | func (h *Handler) GetLastBlockNumber(tkn string) (*uint64, error) {
logger := h.logger.Add("method", "GetLastBlockNumber")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
minConfirmations, err := h.minConfirmations(logger)
if err != nil {
return nil, err
}
var queryRe... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.