id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c173300 | exists := t.FloatIf(key); exists {
return value
}
return d
} | |
c173301 |
if exists == false {
panic("expected float value for " + key)
}
return f
} | |
c173302 | case string:
f, err := strconv.ParseFloat(t, 10)
return f, err == nil
}
return 0, false
} | |
c173303 | exists := t.StringIf(key); exists {
return value
}
return d
} | |
c173304 |
if exists == false {
panic("expected string value for " + key)
}
return s
} | |
c173305 | exists := t.TimeIf(key); exists {
return value
}
return d
} | |
c173306 |
if exists == false {
panic("expected time.Time value for " + key)
}
return tt
} | |
c173307 | false {
return time.Time{}, false
}
if n, ok := value.(time.Time); ok {
return n, true
}
return time.Time{}, false
} | |
c173308 | panic("expected map for " + key)
}
return t
} | |
c173309 | exists := t.InterfaceIf(key); exists {
return value
}
return d
} | |
c173310 | panic("expected map for " + key)
}
return i
} | |
c173311 | false {
return nil, false
}
return value, true
} | |
c173312 | t.BoolsOr(key, nil)
} | |
c173313 | {
n, ok := t.BoolsIf(key)
if ok {
return n
}
return d
} | |
c173314 | t.IntsOr(key, nil)
} | |
c173315 | t.Ints64Or(key, nil)
} | |
c173316 | t.FloatsOr(key, nil)
} | |
c173317 | t.StringsOr(key, nil)
} | |
c173318 | := t.ObjectsIf(key)
return value
} | |
c173319 | }
}
return n, true
case []map[string]interface{}:
l := len(t)
n := make([]Typed, l)
for i := 0; i < l; i++ {
n[i] = Typed(t[i])
}
return n, true
case []Typed:
return t, true
}
}
return nil, false
} | |
c173320 | tail, args...)
if err != nil {
return nil, err
}
sessions := make([]data.Session, len(result))
for i, item := range result {
sessions[i] = *item.(*data.Session)
}
return sessions, nil
} | |
c173321 |
}
err = ntf.Notify(sub.ID,
&ObjectChangeResult{odata, job, rpcsrv.ToError(result)})
if err != nil {
logger.Warn(err.Error())
}
}
sid := string(sub.ID)
err := h.queue.Subscribe(objectIDs, sid, cb)
if err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
go func() {
for err, ok := <-sub.Err(); ok; {
if err != nil {
logger.Warn(err.Error())
}
}
err := h.queue.Unsubscribe(objectIDs, sid)
if err != nil {
logger.Error(err.Error())
}
}()
return sub, nil
} | |
c173322 | var jobs []*data.Job
if do {
jobs = autoOfferingPopUp(logger, abi, db, ethBack,
timeNowFunc, period)
logger.Debug(fmt.Sprintf("found %d offerings to pop upped",
len(jobs)))
}
return jobs
} | |
c173323 | decode base64: %v", err)
}
v := big.NewInt(0)
v.SetBytes(buf)
return []byte(v.String()), nil
} | |
c173324 | .([]byte) failed, actual type is %T",
src,
)
}
return json.Unmarshal(somcData, &t)
} | |
c173325 | db: db,
decryptKeyFunc: decryptKeyFunc,
gasConf: gasConc,
ept: eptService,
ethBack: ethBack,
pscAddr: pscAddr,
pwdGetter: pwdGetter,
countryConfig: countryConf,
torHostName: data.FromBytes([]byte(torHostname)),
somcClientBuilder: somcClientBuilder,
}, nil
} | |
c173326 |
}
if _, ok := levelNums[conf.StackLevel]; !ok {
return nil, ErrBadStackLevel
}
ctx := map[string]interface{}{}
return &LoggerBase{conf: conf, log: log, ctx: ctx}, nil
} | |
c173327 |
}
if err := l.log(lvl, msg, l.ctx, stack); err != nil {
panic("failed to log: " + err.Error())
}
if lvl == Fatal {
panic("fatal log event")
}
} | |
c173328 | nil {
return err
}
auth := bind.NewKeyedTransactor(key)
auth.GasLimit = w.gasConf.PTC.Approve
auth.GasPrice = new(big.Int).SetUint64(jobData.GasPrice)
tx, err := w.ethBack.PTCIncreaseApproval(auth,
w.pscAddr, new(big.Int).SetUint64(jobData.Amount))
if err != nil {
logger.Error(err.Error())
return ErrPTCIncreaseApproval
}
return w.saveEthTX(logger, job, tx, "PTCIncreaseApproval", job.RelatedType,
job.RelatedID, acc.EthAddr, data.HexFromBytes(w.pscAddr.Bytes()))
} | |
c173329 | acc.PrivateKey)
if err != nil {
return err
}
auth := bind.NewKeyedTransactor(key)
auth.GasLimit = w.gasConf.PSC.AddBalanceERC20
auth.GasPrice = new(big.Int).SetUint64(jobData.GasPrice)
tx, err := w.ethBack.PSCAddBalanceERC20(auth, uint64(jobData.Amount))
if err != nil {
logger.Error(err.Error())
return ErrPSCAddBalance
}
return w.saveEthTX(logger, job, tx, "PSCAddBalanceERC20", job.RelatedType,
job.RelatedID, acc.EthAddr, data.HexFromBytes(w.pscAddr.Bytes()))
} | |
c173330 | w.updateAccountBalancesJob(job, data.JobAfterAccountAddBalance)
} | |
c173331 | w.updateAccountBalancesJob(job, data.JobAfterAccountReturnBalance)
} | |
c173332 | w.updateAccountBalancesJob(job, data.JobAccountUpdateBalances)
} | |
c173333 |
}
if amount < uint64(jobData.Amount) {
return ErrInsufficientPSCBalance
}
ethAmount, err := w.ethBalance(logger, auth.From)
if err != nil {
return err
}
wantedEthBalance := w.gasConf.PSC.ReturnBalanceERC20 * jobData.GasPrice
if wantedEthBalance > ethAmount.Uint64() {
return ErrInsufficientEthBalance
}
auth.GasLimit = w.gasConf.PSC.ReturnBalanceERC20
auth.GasPrice = new(big.Int).SetUint64(jobData.GasPrice)
tx, err := w.ethBack.PSCReturnBalanceERC20(auth, uint64(jobData.Amount))
if err != nil {
logger.Add("GasLimit", auth.GasLimit,
"GasPrice", auth.GasPrice).Error(err.Error())
return ErrPSCRetrieveBalance
}
return w.saveEthTX(logger, job, tx, "PSCReturnBalanceERC20", job.RelatedType,
job.RelatedID, data.HexFromBytes(w.pscAddr.Bytes()), acc.EthAddr)
} | |
c173334 |
return h.uintFromQuery(logger, password,
`SELECT SUM(sessions.units_used)
FROM channels
JOIN sessions
ON sessions.channel=channels.id
AND channels.offering=$1`,
offeringID)
} | |
c173335 | JOIN channels
ON channels.offering=offerings.id
AND offerings.product=$1
JOIN sessions
ON sessions.channel=channels.id`, productID)
} | |
c173336 | }
protocol = strings.ToUpper(protocol)
lifetimeS := uint32(lifetime / time.Second)
n.DeleteMapping(protocol, extPort, intPort)
return n.client.AddPortMapping("", uint16(extPort),
protocol, uint16(intPort), ip.String(), true, desc, lifetimeS)
} | |
c173337 | error {
return n.client.DeletePortMapping(
"", uint16(extPort), strings.ToUpper(protocol))
} | |
c173338 | pscAddr, pass, amount)
if err != nil {
return err
}
return postPayload(db, channel, pld, tls, timeout, pr, srv.Send)
} | |
c173339 | client
torTransport := &http.Transport{Proxy: http.ProxyURL(torProxyURL)}
return &http.Client{
Transport: torTransport,
Timeout: time.Second * 10,
}, nil
} | |
c173340 | Addr: conf.Addr,
Handler: mux,
}
return &Server{
conf: conf,
rpcsrv: rpcsrv,
httpsrv: httpsrv,
}, nil
} | |
c173341 | return s.rpcsrv.RegisterName(namespace, handler)
} | |
c173342 | s.conf.TLS.KeyFile)
}
return s.httpsrv.ListenAndServe()
} | |
c173343 | nil {
return err
}
return nil
} | |
c173344 | = append(comps, k+"="+v)
}
return strings.Join(comps, " ")
} | |
c173345 |
return nil, err
}
return newReform(conn), nil
} | |
c173346 |
}
conn.SetMaxOpenConns(conf.MaxOpen)
conn.SetMaxIdleConns(conf.MaxIddle)
return newReform(conn), nil
} | |
c173347 | return "", err
}
f, ok := object[field]
if !ok {
return "", ErrMissingRequiredField
}
country, ok := f.(string)
if !ok {
return "", ErrBadCountryValueType
}
return strings.TrimSpace(strings.ToUpper(country)), nil
} | |
c173348 | nil, ErrInternal
}
if channelKey == key {
endpoint, err := h.endpointByChannelID(logger, channel.ID)
if err != nil {
return nil, err
}
return &endpoint.RawMsg, nil
}
}
return nil, ErrChannelNotFound
} | |
c173349 | logger: logger.Add("type", "pay.Server"),
db: db,
}
s.HandleFunc(payPath,
s.RequireHTTPMethods(s.logger, s.handlePay, http.MethodPost))
return s
} | |
c173350 | ethCallTimeout: ethCallTimeout,
pscABI: pscABI,
ptcABI: ptcABI,
pscAddr: psc,
queryPause: queryPause,
}
m.initLastProcessedBlock(role, conf.InitialBlocks)
f := m.clientQueries
m.jobsProducers = m.clientJobsProducers()
if role == data.RoleAgent {
f = m.agentQueries
m.jobsProducers = m.agentJobsProducers()
}
m.getFilterLogQueries = func(from, to uint64) ([]ethereum.FilterQuery, error) {
return f(from, to, psc, ptc)
}
return m, nil
} | |
c173351 | lastEthBlockNum {
logger.Warn("initialBlocks value is very big")
return
}
lastProcessedBlock := lastEthBlockNum - initialBlocks
_, err = m.db.Exec(`UPDATE settings SET value=$1 WHERE key=$2`,
lastProcessedBlock, data.SettingLastProcessedBlock)
if err != nil {
logger.Error(err.Error())
}
logger.Debug(fmt.Sprintf("last processed block: %d",
lastProcessedBlock))
} | |
c173352 | <-ticker.C:
err := m.queryLogsAndCreateJobs(
m.getFilterLogQueries, m.jobsProducers)
if err != nil {
logger.Warn(err.Error())
}
}
}
}()
} | |
c173353 | rpcClient, err = rpc.DialStdIO(ctx)
case ipc:
rpcClient, err = rpc.DialIPC(ctx, cfg.GethURL)
default:
logger2.Add("scheme", u.Scheme).Error(err.Error())
return nil, ErrURLScheme
}
if err != nil {
logger2.Error(err.Error())
return nil, ErrCreateClient
}
c.client = ethclient.NewClient(rpcClient)
return c, nil
} | |
c173354 | logger = logger.Add("method", "Loop")
go loop(ctx, tik, db, queue, f, logger, nil)
} | |
c173355 | c.requestWithPayload("api_offering", string(hash))
} | |
c173356 | c.requestWithPayload("api_endpoint", string(channelKey))
} | |
c173357 | c.client.Head(c.url())
return err
} | |
c173358 | args = append(args, relID)
conds = append(
conds,
"related_id="+h.db.Placeholder(len(args)))
}
tail := ""
if len(conds) > 0 {
tail = "WHERE " + strings.Join(conds, " AND ")
}
count, err := h.numberOfObjects(
logger, data.EthTxTable.Name(), tail, args)
if err != nil {
return nil, err
}
offsetLimit := h.offsetLimit(offset, limit)
sorting := `ORDER BY issued DESC`
tail = fmt.Sprintf("%s %s %s", tail, sorting, offsetLimit)
txs, err := h.selectAllFrom(logger, data.EthTxTable, tail, args...)
if err != nil {
return nil, err
}
ret := make([]data.EthTx, len(txs))
for i, v := range txs {
ret[i] = *v.(*data.EthTx)
}
return &GetEthTransactionsResult{ret, count}, nil
} | |
c173359 |
return nil, err
}
pub := ecies.ImportECDSAPublic(pubKey)
msgEncrypted, err := ecies.Encrypt(rand.Reader, pub, msg, nil, nil)
if err != nil {
return nil, err
}
return PackWithSignature(msgEncrypted, agentKey)
} | |
c173360 | ecies.ImportECDSA(clientPrv)
opened, err := prv.Decrypt(sealed, nil, nil)
if err != nil {
return nil, err
}
return opened, nil
} | |
c173361 | != nil {
return nil, err
}
return packSignature(msg, sig), nil
} | |
c173362 | = c[:len(c)-sigLen]
sig = c[len(c)-sigLen:]
return
} | |
c173363 | ethcrypto.VerifySignature(pubk, msg, sig)
} | |
c173364 | != nil {
return nil, err
}
sig = sig[:len(sig)-1]
return sig, nil
} | |
c173365 | table, ok := objectTypes[objectType]
if !ok {
logger.Warn(ErrBadObjectType.Error())
return nil, ErrBadObjectType
}
obj, err := h.db.FindByPrimaryKeyFrom(table, id)
if err != nil {
logger.Error(err.Error())
return nil, ErrObjectNotFound
}
raw, err := json.Marshal(obj)
if err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
return raw, nil
} | |
c173366 |
table, ok := objectWithHashTypes[objectType]
if !ok {
logger.Warn(ErrBadObjectType.Error())
return nil, ErrBadObjectType
}
obj, err := h.db.FindOneFrom(table, "hash", hash)
if err != nil {
logger.Error(err.Error())
return nil, ErrObjectNotFound
}
raw, err := json.Marshal(obj)
if err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
return raw, nil
} | |
c173367 | ok {
return &Error{Code: err.ErrorCode(), Message: err.Error()}
}
return &Error{Message: err.Error()}
} | |
c173368 |
tx, err := beginTX(logger, h.db)
if err != nil {
return err
}
defer tx.Rollback()
if err := insert(logger, tx.Querier,
saltSetting(salt), passwordHashSetting(hashed)); err != nil {
return err
}
return commitTX(logger, tx)
} | |
c173369 | return err
}
defer tx.Rollback()
if err := h.updatePrivateKeys(logger, tx, current, new); err != nil {
return err
}
if err := update(logger, tx.Querier,
saltSetting(salt), passwordHashSetting(hashed)); err != nil {
return err
}
err = commitTX(logger, tx)
if err != nil {
return err
}
h.token.Make()
return nil
} | |
c173370 |
v, err := h.token.Make()
if err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
return &v, nil
} | |
c173371 | *Processor {
return &Processor{
conf: conf,
db: db,
queue: queue,
}
} | |
c173372 | TryLimit: 3,
TryPeriod: 60000,
},
Types: make(map[string]TypeConfig),
}
} | |
c173373 |
db: db,
handlers: handlers,
subs: map[string][]subEntry{},
}
} | |
c173374 | err != nil {
return err
}
return q.Add(tx, &data.Job{
Type: jobType,
RelatedType: relatedType,
RelatedID: relatedID,
CreatedBy: creator,
Data: data2,
NotBefore: time.Now().Add(delay),
})
} | |
c173375 | jobData interface{}) error {
return AddWithDataAndDelay(q, tx, jobType,
relatedType, relatedID, creator, jobData, time.Duration(0))
} | |
c173376 | jobType, relatedType, relatedID, creator, &struct{}{})
} | |
c173377 |
delay time.Duration) error {
return AddWithDataAndDelay(q, tx,
jobType, relatedType, relatedID, creator, &struct{}{}, delay)
} | |
c173378 | != nil {
for j := 0; j < i; j++ {
q.unsubscribe(subKeys[j], subID)
}
return err
}
}
return nil
} | |
c173379 | q.unsubscribe(v, subID); err == nil {
err = err2
}
}
return err
} | |
c173380 | h.topUpChannelJobData(logger, deposit, gasPrice)
if err != nil {
return err
}
return job.AddWithData(h.queue, nil, data.JobClientPreChannelTopUp,
data.JobChannel, ch.ID, data.JobUser, jobData)
} | |
c173381 |
return ErrInternal
}
if len(items) != 1 {
logger.Error(ErrChannelNotFound.Error())
return ErrChannelNotFound
}
switch action {
case ChannelPauseAction:
_, err = h.processor.SuspendChannel(
channel, data.JobUser, isAgent)
case ChannelResumeAction:
_, err = h.processor.ActivateChannel(
channel, data.JobUser, isAgent)
case ChannelTerminateAction:
_, err = h.processor.TerminateChannel(
channel, data.JobUser, isAgent)
case ChannelCloseAction:
if isAgent {
logger.Error(ErrNotAllowedForAgent.Error())
return ErrNotAllowedForAgent
}
if err := h.createPreUncooperativeCloseRequest(
channel, logger); err != nil {
return ErrInternal
}
default:
logger.Warn(ErrBadAction.Error())
return ErrBadAction
}
if err != nil {
logger.Error(err.Error())
return ErrInternal
}
return nil
} | |
c173382 |
channels, total, err := h.getChannels(
logger, channelStatus, serviceStatus,
agentChannelsCondition, offset, limit)
if err != nil {
return nil, err
}
return &GetAgentChannelsResult{channels, total}, err
} | |
c173383 |
logger.Warn("access denied")
return nil, ErrAccessDenied
}
return h.getChannelsUsages(logger, ids)
} | |
c173384 |
items := make([]ClientChannelInfo, 0)
for _, channel := range chs {
result, err := h.createClientChannelResult(logger, &channel)
if err != nil {
return nil, err
}
items = append(items, *result)
}
return &GetClientChannelsResult{items, total}, nil
} | |
c173385 | "", fmt.Errorf(
"failed to find '%s' setting: %s", key, err)
}
return st.Value, nil
} | |
c173386 |
if err != nil {
return 0, newSettingParseError(key, err)
}
return uint(val2), nil
} | |
c173387 | err != nil {
return false, newSettingParseError(key, err)
}
return bool(val2), nil
} | |
c173388 | = data.JobClientPreServiceSuspend
}
return p.alterServiceStatus(id, jobCreator,
jobType, "", suspendTransitions, false)
} | |
c173389 | = data.JobClientPreServiceUnsuspend
}
return p.alterServiceStatus(id, jobCreator,
jobType, "", activateTransitions, false)
} | |
c173390 | = data.JobClientPreServiceTerminate
}
return p.alterServiceStatus(id, jobCreator,
jobType, jobType, terminateTransitions, true)
} | |
c173391 |
var acc data.Account
err := h.db.FindByPrimaryKeyTo(&acc, account)
if err != nil {
logger.Error(err.Error())
if err == reform.ErrNoRows {
return nil, ErrAccountNotFound
}
return nil, ErrInternal
}
key, err := data.ToBytes(acc.PrivateKey)
if err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
return key, nil
} | |
c173392 |
return nil, err
}
result := make([]data.Account, len(accounts))
for k, v := range accounts {
result[k] = *v.(*data.Account)
}
return result, nil
} | |
c173393 |
id, err := h.fillAndSaveAccount(
logger, account, crypto.GenerateKey, false)
if err != nil {
return nil, err
}
return &id, nil
} | |
c173394 |
return nil, ErrAccessDenied
}
makeECDSAFunc := h.hexPrivateKeyToECDSA(params.PrivateKeyHex)
account := params.prefilledAccount()
id, err := h.fillAndSaveAccount(logger, account, makeECDSAFunc, true)
if err != nil {
return nil, err
}
return &id, nil
} | |
c173395 |
makeECDSAFunc := h.jsonPrivateKeyToECDSA(
jsonBlob, jsonKeyStorePassword)
id, err := h.fillAndSaveAccount(
logger, account, makeECDSAFunc, true)
if err != nil {
return nil, err
}
return &id, nil
} | |
c173396 |
}
jobType := data.JobPreAccountAddBalanceApprove
if destination == data.ContractPTC {
jobType = data.JobPreAccountReturnBalance
}
jobData := &data.JobBalanceData{
Amount: amount,
GasPrice: gasPrice,
}
err = job.AddWithData(h.queue, nil, jobType,
data.JobAccount, account, data.JobUser, jobData)
if err != nil {
logger.Error(err.Error())
return ErrInternal
}
return nil
} | |
c173397 | {
return err
}
err = job.AddSimple(h.queue, nil, data.JobAccountUpdateBalances,
data.JobAccount, account, data.JobUser)
if err != nil {
logger.Error(err.Error())
return ErrInternal
}
return nil
} | |
c173398 | logger, ErrAccountNotFound, &acc, account)
if err != nil {
return err
}
if name != "" {
acc.Name = name
}
acc.IsDefault = isDefault
acc.InUse = inUse
return update(logger, h.db.Querier, &acc)
} | |
c173399 | err != nil {
return nil, err
}
var queryRet sql.NullInt64
row := h.db.QueryRow("SELECT max((data->'ethereumLog'->>'block') :: bigint) from jobs")
if err := row.Scan(&queryRet); err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
logger.Error(fmt.Sprint(queryRet.Int64))
ret := uint64(queryRet.Int64) + minConfirmations
return &ret, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.