_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q173400 | GetEndpoint | validation | func (h *Handler) GetEndpoint(
product, productPassword, clientKey string) (*data.Endpoint, error) {
logger := h.logger.Add("method", "GetEndpoint",
"product", product, "clientKey", clientKey)
logger.Info("channel endpoint request")
prod, err := h.checkProductPassword(logger, product, productPassword)
if err !... | go | {
"resource": ""
} |
q173401 | SetProductConfig | validation | func (h *Handler) SetProductConfig(
product, productPassword string, config map[string]string) error {
logger := h.logger.Add("method", "SetProductConfig",
"product", product, "config", config)
logger.Info("product config update")
prod, err := h.checkProductPassword(logger, product, productPassword)
if err != ... | go | {
"resource": ""
} |
q173402 | NewWriterLogger | validation | func NewWriterLogger(conf *WriterConfig, out io.Writer) (Logger, error) {
l := &writerLogger{}
base, err := NewLoggerBase(conf.BaseConfig, l.log)
if err != nil {
return nil, err
}
flags := log.LstdFlags
if conf.UTC {
flags |= log.LUTC
}
l.logger = log.New(out, conf.Prefix, flags)
l.LoggerBase = base
r... | go | {
"resource": ""
} |
q173403 | NewFileLogger | validation | func NewFileLogger(conf *FileConfig) (Logger, io.Closer, error) {
now := time.Now()
if conf.UTC {
now = now.UTC()
}
file, err := os.OpenFile(
timeutil.Strftime(&now, conf.Filename),
os.O_APPEND|os.O_CREATE|os.O_WRONLY, conf.FileMode)
if err != nil {
return nil, nil, err
}
logger, err := NewWriterLogger... | go | {
"resource": ""
} |
q173404 | NewClient | validation | func (b *ClientBuilder) NewClient(somcType uint8, somcData data.Base64String) (Client, error) {
if somcType == data.OfferingSOMCTor {
hostnameBytes, err := data.ToBytes(somcData)
if err != nil {
return nil, err
}
torClient, err := tor.NewHTTPClient(b.torSocks)
return somcsrv.NewClient(torClient, string(ho... | go | {
"resource": ""
} |
q173405 | Parse | validation | func Parse(config *Config) (Interface, error) {
switch config.Mechanism {
case "any":
return any(config), nil
case "upnp":
return uPnP(config), nil
case "pmp":
return pmp(), nil
default:
return nil, ErrBadMechanism
}
} | go | {
"resource": ""
} |
q173406 | Map | validation | func Map(ctx context.Context, conf *Config, logger log.Logger, m Interface,
protocol string, extPort, intPort int, name string) error {
mapUpdateInterval := time.Duration(
conf.MapUpdateInterval) * time.Millisecond
mapTimeout := time.Duration(conf.MapTimeout) * time.Millisecond
logger = logger.Add("proto", pro... | go | {
"resource": ""
} |
q173407 | AddMapping | validation | func (n *discovery) AddMapping(protocol string, extPort, intPort int,
name string, lifetime time.Duration) error {
if err := n.wait(); err != nil {
return err
}
return n.found.AddMapping(protocol, extPort, intPort, name, lifetime)
} | go | {
"resource": ""
} |
q173408 | DeleteMapping | validation | func (n *discovery) DeleteMapping(protocol string, extPort, intPort int) error {
if err := n.wait(); err != nil {
return err
}
return n.found.DeleteMapping(protocol, extPort, intPort)
} | go | {
"resource": ""
} |
q173409 | ReadFile | validation | func ReadFile(name string) ([]byte, error) {
fs, err := fs.New()
if err != nil {
return nil, ErrOpenFS
}
file, err := fs.Open(name)
if err != nil {
return nil, ErrOpenFile
}
defer file.Close()
data, err := ioutil.ReadAll(file)
if err != nil {
return nil, ErrReadFile
}
return data, nil
} | go | {
"resource": ""
} |
q173410 | GetUserRole | validation | func (h *Handler) GetUserRole(tkn string) (*string, error) {
logger := h.logger.Add("method", "GetUserRole")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
return &h.userRole, nil
} | go | {
"resource": ""
} |
q173411 | NewHandler | validation | func NewHandler(logger log.Logger, db *reform.DB,
queue job.Queue, pwdStorage data.PWDGetSetter,
encryptKeyFunc data.EncryptedKeyFunc,
decryptKeyFunc data.ToPrivateKeyFunc, userRole string,
processor *proc.Processor,
somcClientBuilder somc.ClientBuilderInterface,
token TokenMakeChecker) *Handler {
logger = logge... | go | {
"resource": ""
} |
q173412 | NewBackend | validation | func NewBackend(cfg *Config, logger log.Logger) Backend {
conn, ptc, psc, err := newInstance(cfg, logger)
if err != nil {
logger.Fatal(err.Error())
}
b := &backendInstance{cfg: cfg, ptc: ptc, psc: psc,
conn: conn, logger: logger,
}
go b.connectionControl()
return b
} | go | {
"resource": ""
} |
q173413 | addTimeout | validation | func (b *backendInstance) addTimeout(
ctx context.Context) (context.Context, context.CancelFunc) {
if ctx == nil {
ctx = context.Background()
}
return context.WithTimeout(ctx,
time.Duration(b.cfg.Timeout)*time.Millisecond)
} | go | {
"resource": ""
} |
q173414 | PendingNonceAt | validation | func (b *backendInstance) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
ctx, cancel := b.addTimeout(ctx)
defer cancel()
return b.conn.ethClient().PendingNonceAt(ctx, account)
} | go | {
"resource": ""
} |
q173415 | SuggestGasPrice | validation | func (b *backendInstance) SuggestGasPrice(
ctx context.Context) (*big.Int, error) {
ctx2, cancel := b.addTimeout(ctx)
defer cancel()
gasPrice, err := b.conn.ethClient().SuggestGasPrice(ctx2)
if err != nil {
return nil, fmt.Errorf("failed to get"+
" suggested gas price: %s", err)
}
return gasPrice, err
} | go | {
"resource": ""
} |
q173416 | EstimateGas | validation | func (b *backendInstance) EstimateGas(
ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) {
ctx2, cancel := b.addTimeout(ctx)
defer cancel()
gas, err = b.conn.ethClient().EstimateGas(ctx2, call)
if err != nil {
return 0, fmt.Errorf("failed to estimated gas: %s", err)
}
return gas, err
} | go | {
"resource": ""
} |
q173417 | CooperativeClose | validation | func (b *backendInstance) CooperativeClose(opts *bind.TransactOpts,
agent common.Address, block uint32, offeringHash [common.HashLength]byte,
balance uint64, balanceSig, closingSig []byte) (*types.Transaction, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
tx, err := b.ps... | go | {
"resource": ""
} |
q173418 | GetTransactionByHash | validation | func (b *backendInstance) GetTransactionByHash(ctx context.Context,
hash common.Hash) (*types.Transaction, bool, error) {
ctx2, cancel := b.addTimeout(ctx)
defer cancel()
tx, pending, err := b.conn.ethClient().TransactionByHash(ctx2, hash)
if err != nil {
err = fmt.Errorf("failed to get transaction by hash: %s"... | go | {
"resource": ""
} |
q173419 | RegisterServiceOffering | validation | func (b *backendInstance) RegisterServiceOffering(opts *bind.TransactOpts,
offeringHash [common.HashLength]byte,
minDeposit uint64, maxSupply uint16,
somcType uint8, somcData data.Base64String) (*types.Transaction, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
tx, err :... | go | {
"resource": ""
} |
q173420 | PTCBalanceOf | validation | func (b *backendInstance) PTCBalanceOf(opts *bind.CallOpts,
owner common.Address) (*big.Int, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
val, err := b.ptc.BalanceOf(opts, owner)
if err != nil {
err = fmt.Errorf("failed to get PTC balance: %s", err)
}
return val, er... | go | {
"resource": ""
} |
q173421 | PTCIncreaseApproval | validation | func (b *backendInstance) PTCIncreaseApproval(opts *bind.TransactOpts,
spender common.Address, addedVal *big.Int) (*types.Transaction, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
tx, err := b.ptc.IncreaseApproval(opts, spender, addedVal)
if err != nil {
return nil, f... | go | {
"resource": ""
} |
q173422 | PSCBalanceOf | validation | func (b *backendInstance) PSCBalanceOf(opts *bind.CallOpts,
owner common.Address) (uint64, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
val, err := b.psc.BalanceOf(opts, owner)
if err != nil {
err = fmt.Errorf("failed to get PSC balance: %s", err)
}
return val, err
... | go | {
"resource": ""
} |
q173423 | PSCAddBalanceERC20 | validation | func (b *backendInstance) PSCAddBalanceERC20(opts *bind.TransactOpts,
amount uint64) (*types.Transaction, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
tx, err := b.psc.AddBalanceERC20(opts, amount)
if err != nil {
return nil, fmt.Errorf("failed to add ERC20 balance: %... | go | {
"resource": ""
} |
q173424 | PSCGetOfferingInfo | validation | func (b *backendInstance) PSCGetOfferingInfo(opts *bind.CallOpts,
hash [common.HashLength]byte) (agentAddr common.Address,
minDeposit uint64, maxSupply uint16, currentSupply uint16,
updateBlockNumber uint32, active bool, err error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
... | go | {
"resource": ""
} |
q173425 | PSCGetChannelInfo | validation | func (b *backendInstance) PSCGetChannelInfo(opts *bind.CallOpts,
client common.Address, agent common.Address,
blockNumber uint32,
hash [common.HashLength]byte) (uint64, uint32, uint64, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
return b.psc.GetChannelInfo(opts, client... | go | {
"resource": ""
} |
q173426 | EthBalanceAt | validation | func (b *backendInstance) EthBalanceAt(ctx context.Context,
owner common.Address) (*big.Int, error) {
ctx2, cancel := b.addTimeout(ctx)
defer cancel()
return b.conn.ethClient().BalanceAt(ctx2, owner, nil)
} | go | {
"resource": ""
} |
q173427 | PSCSettle | validation | func (b *backendInstance) PSCSettle(opts *bind.TransactOpts,
agent common.Address, blockNumber uint32,
hash [common.HashLength]byte) (*types.Transaction, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
tx, err := b.psc.Settle(opts, agent, blockNumber, hash)
if err != nil ... | go | {
"resource": ""
} |
q173428 | PSCRemoveServiceOffering | validation | func (b *backendInstance) PSCRemoveServiceOffering(opts *bind.TransactOpts,
offeringHash [32]byte) (*types.Transaction, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
tx, err := b.psc.RemoveServiceOffering(opts, offeringHash)
if err != nil {
err = fmt.Errorf("failed to ... | go | {
"resource": ""
} |
q173429 | PSCPopupServiceOffering | validation | func (b *backendInstance) PSCPopupServiceOffering(opts *bind.TransactOpts,
offeringHash [32]byte, somcType uint8, somcData data.Base64String) (*types.Transaction, error) {
ctx2, cancel := b.addTimeout(opts.Context)
defer cancel()
opts.Context = ctx2
tx, err := b.psc.PopupServiceOffering(opts, offeringHash,
som... | go | {
"resource": ""
} |
q173430 | FilterLogs | validation | func (b *backendInstance) FilterLogs(ctx context.Context,
q ethereum.FilterQuery) ([]types.Log, error) {
return b.conn.ethClient().FilterLogs(ctx, q)
} | go | {
"resource": ""
} |
q173431 | HeaderByNumber | validation | func (b *backendInstance) HeaderByNumber(ctx context.Context,
number *big.Int) (*types.Header, error) {
return b.conn.ethClient().HeaderByNumber(ctx, number)
} | go | {
"resource": ""
} |
q173432 | PTCAddress | validation | func (b *backendInstance) PTCAddress() common.Address {
return common.HexToAddress(b.cfg.Contract.PTCAddrHex)
} | go | {
"resource": ""
} |
q173433 | PSCAddress | validation | func (b *backendInstance) PSCAddress() common.Address {
return common.HexToAddress(b.cfg.Contract.PSCAddrHex)
} | go | {
"resource": ""
} |
q173434 | NewHandler | validation | func NewHandler(db *reform.DB, logger log.Logger) *Handler {
return &Handler{db: db, logger: logger.Add("type", "tor-somc.Handler")}
} | go | {
"resource": ""
} |
q173435 | keyFromChannelData | validation | func (w *Worker) keyFromChannelData(logger log.Logger,
channel string) (data.Base64String, error) {
ch, err := w.channel(logger, channel)
if err != nil {
return "", err
}
offering, err := w.offering(logger, ch.Offering)
if err != nil {
return "", err
}
key, err := data.ChannelKey(ch.Client, ch.Agent,
ch... | go | {
"resource": ""
} |
q173436 | AgentAfterChannelCreate | validation | func (w *Worker) AgentAfterChannelCreate(job *data.Job) error {
if w.isJobInvalid(job, data.JobAgentAfterChannelCreate, data.JobChannel) {
return ErrInvalidJob
}
logger := w.logger.Add("method", "AgentAfterChannelCreate", "job", job)
ethLog, err := w.ethLog(logger, job)
if err != nil {
return err
}
ethLog... | go | {
"resource": ""
} |
q173437 | AgentAfterChannelTopUp | validation | func (w *Worker) AgentAfterChannelTopUp(job *data.Job) error {
return w.afterChannelTopUp(job, data.JobAgentAfterChannelTopUp)
} | go | {
"resource": ""
} |
q173438 | AgentAfterUncooperativeCloseRequest | validation | func (w *Worker) AgentAfterUncooperativeCloseRequest(job *data.Job) error {
logger := w.logger.Add("method", "AgentAfterUncooperativeCloseRequest",
"job", job)
channel, err := w.relatedChannel(logger, job,
data.JobAgentAfterUncooperativeCloseRequest)
if err != nil {
return err
}
logger = logger.Add("channel... | go | {
"resource": ""
} |
q173439 | AgentAfterUncooperativeClose | validation | func (w *Worker) AgentAfterUncooperativeClose(job *data.Job) error {
logger := w.logger.Add("method", "AgentAfterUncooperativeClose",
"job", job)
channel, err := w.relatedChannel(logger, job,
data.JobAgentAfterUncooperativeClose)
if err != nil {
return err
}
if channel.ServiceStatus != data.ServiceTerminat... | go | {
"resource": ""
} |
q173440 | AgentAfterCooperativeClose | validation | func (w *Worker) AgentAfterCooperativeClose(job *data.Job) error {
logger := w.logger.Add("method", "AgentAfterCooperativeClose",
"job", job)
channel, err := w.relatedChannel(logger,
job, data.JobAgentAfterCooperativeClose)
if err != nil {
return err
}
return w.db.InTransaction(func(tx *reform.TX) error {
... | go | {
"resource": ""
} |
q173441 | AgentPreServiceSuspend | validation | func (w *Worker) AgentPreServiceSuspend(job *data.Job) error {
logger := w.logger.Add("method", "AgentPreServiceSuspend", "job", job)
_, err := w.agentUpdateServiceStatus(logger, job,
data.JobAgentPreServiceSuspend)
return err
} | go | {
"resource": ""
} |
q173442 | AgentPreServiceUnsuspend | validation | func (w *Worker) AgentPreServiceUnsuspend(job *data.Job) error {
logger := w.logger.Add("method", "AgentPreServiceSuspend", "job", job)
_, err := w.agentUpdateServiceStatus(logger, job,
data.JobAgentPreServiceUnsuspend)
return err
} | go | {
"resource": ""
} |
q173443 | AgentPreServiceTerminate | validation | func (w *Worker) AgentPreServiceTerminate(job *data.Job) error {
logger := w.logger.Add("method", "AgentPreServiceSuspend", "job", job)
channel, err := w.agentUpdateServiceStatus(logger, job,
data.JobAgentPreServiceTerminate)
if err != nil {
return err
}
if channel.ReceiptBalance == 0 {
return nil
}
retu... | go | {
"resource": ""
} |
q173444 | AgentAfterOfferingMsgBCPublish | validation | func (w *Worker) AgentAfterOfferingMsgBCPublish(job *data.Job) error {
logger := w.logger.Add("method", "AgentAfterOfferingMsgBCPublish",
"job", job)
offering, err := w.relatedOffering(logger, job,
data.JobAgentAfterOfferingMsgBCPublish)
if err != nil {
return err
}
ethLog, err := w.ethLog(logger, job)
if ... | go | {
"resource": ""
} |
q173445 | AgentAfterOfferingDelete | validation | func (w *Worker) AgentAfterOfferingDelete(job *data.Job) error {
logger := w.logger.Add(
"method", "AgentAfterOfferingDelete", "job", job)
offering, err := w.relatedOffering(
logger, job, data.JobAgentAfterOfferingDelete)
if err != nil {
return err
}
offering.Status = data.OfferRemoved
if err := w.saveRec... | go | {
"resource": ""
} |
q173446 | AgentPreOfferingDelete | validation | func (w *Worker) AgentPreOfferingDelete(job *data.Job) error {
logger := w.logger.Add("method", "AgentPreOfferingDelete", "job", job)
offering, err := w.relatedOffering(logger,
job, data.JobAgentPreOfferingDelete)
if err != nil {
return err
}
if offering.Status != data.OfferRegistered &&
offering.Status !=... | go | {
"resource": ""
} |
q173447 | checkInPeriod | validation | func (w *Worker) checkInPeriod(logger log.Logger, hash common.Hash,
periodKey string, periodErr error) error {
updateBlockNumber, err := w.getOfferingBlockNumber(logger, hash)
if err != nil {
return err
}
lastBlock, err := w.ethBack.LatestBlockNumber(context.Background())
if err != nil {
logger.Error(err.Err... | go | {
"resource": ""
} |
q173448 | AgentPreOfferingPopUp | validation | func (w *Worker) AgentPreOfferingPopUp(job *data.Job) error {
logger := w.logger.Add("method", "AgentPreOfferingPopUp", "job", job)
offering, err := w.relatedOffering(logger,
job, data.JobAgentPreOfferingPopUp)
if err != nil {
return err
}
logger = logger.Add("offering", offering.ID)
if offering.Status != d... | go | {
"resource": ""
} |
q173449 | AgentAfterOfferingPopUp | validation | func (w *Worker) AgentAfterOfferingPopUp(job *data.Job) error {
logger := w.logger.Add("method", "AgentAfterOfferingPopUp", "job", job)
ethLog, err := w.ethLog(logger, job)
if err != nil {
return err
}
logger = logger.Add("ethLog", ethLog)
logOfferingPopUp, err := extractLogOfferingPopUp(logger, ethLog)
if ... | go | {
"resource": ""
} |
q173450 | Print | validation | func Print(run bool, commit, version string) {
if run {
fmt.Println(Message(commit, version))
os.Exit(0)
}
} | go | {
"resource": ""
} |
q173451 | Error | validation | func (e Error) Error() string {
if msg, ok := Message(e); ok {
return fmt.Sprintf("%s (%d)", msg, e)
}
return "unknown error"
} | go | {
"resource": ""
} |
q173452 | Message | validation | func Message(e Error) (string, bool) {
msg, ok := msgs[e]
return msg, ok
} | go | {
"resource": ""
} |
q173453 | RespondResult | validation | func (s *Server) RespondResult(logger log.Logger, w http.ResponseWriter,
result interface{}) {
logger = logger.Add("result", result)
data, err := json.Marshal(result)
if err != nil {
logger.Error("failed to marhsal respond result: " + err.Error())
s.RespondError(logger, w, ErrInternalServerError)
return
}
... | go | {
"resource": ""
} |
q173454 | RespondError | validation | func (s *Server) RespondError(logger log.Logger, w http.ResponseWriter, err *Error) {
s.respond(logger, w, &Response{Error: err})
} | go | {
"resource": ""
} |
q173455 | handlePay | validation | func (s *Server) handlePay(
w http.ResponseWriter, r *http.Request, ctx *srv.Context) {
logger := s.logger.Add("method", "handlePay", "sender", r.RemoteAddr)
payload := &paymentPayload{}
if !s.ParseRequest(logger, w, r, payload) {
return
}
logger = logger.Add("payload", *payload)
ch, ok := s.findChannel(logg... | go | {
"resource": ""
} |
q173456 | getOpenBlockNumber | validation | func (m *Monitor) getOpenBlockNumber(
el *data.JobEthLog) (block uint32, ok bool, err error) {
var event string
switch el.Topics[0] {
case eth.ServiceChannelToppedUp:
event = logChannelToppedUp
case eth.ServiceChannelCloseRequested:
event = logChannelCloseRequested
case eth.ServiceCooperativeChannelClose:
e... | go | {
"resource": ""
} |
q173457 | Offering | validation | func (h *Handler) Offering(hash data.HexString) (*data.Base64String, error) {
logger := h.logger.Add("method", "Offering")
offering, err := h.offeringByHash(logger, hash)
if err != nil {
if err == ErrOfferingNotFound {
logger.Warn("unexpected request for offering: " + string(hash))
}
return nil, err
}
r... | go | {
"resource": ""
} |
q173458 | HandlersMap | validation | func HandlersMap(worker *worker.Worker) job.HandlerMap {
return job.HandlerMap{
// Agent jobs.
data.JobAgentAfterChannelCreate: worker.AgentAfterChannelCreate,
data.JobAgentAfterChannelTopUp: worker.AgentAfterChannelTopUp,
data.JobAgentAfterUncooperativeCloseRequest: worker.AgentAfterU... | go | {
"resource": ""
} |
q173459 | Version | validation | func Version(connStr string) (int64, error) {
db, err := sql.Open("postgres", connStr)
if err != nil {
return 0, err
}
defer db.Close()
return goose.GetDBVersion(db)
} | go | {
"resource": ""
} |
q173460 | Migrate | validation | func Migrate(connStr string, version int64) error {
db, err := sql.Open("postgres", connStr)
if err != nil {
return err
}
defer db.Close()
if version == 0 {
migrations, err := goose.CollectMigrations(".", minVersion, maxVersion)
if err != nil {
return err
}
last, err := migrations.Last()
if err !=... | go | {
"resource": ""
} |
q173461 | NewMonitor | validation | func NewMonitor(interval uint64, db *reform.DB,
logger log.Logger, pr *proc.Processor) (*Monitor, error) {
if db == nil || logger == nil || pr == nil || interval == 0 {
return nil, ErrInput
}
return &Monitor{
db: db,
logger: logger.Add("type", "agent/bill.Monitor"),
pr: pr,
interval: interv... | go | {
"resource": ""
} |
q173462 | Run | validation | func (m *Monitor) Run() error {
m.logger.Info("Billing monitor started")
for {
if err := m.processRound(); err != nil {
return err
}
time.Sleep(time.Duration(m.interval) * time.Millisecond)
}
} | go | {
"resource": ""
} |
q173463 | VerifyBillingLags | validation | func (m *Monitor) VerifyBillingLags() error {
// Checking billing lags.
// All channels, that are not suspended and are not terminated,
// but are suffering from the billing lags - must be suspended.
query := `
SELECT channels.id :: text
FROM channels
LEFT JOIN sessions ses
... | go | {
"resource": ""
} |
q173464 | VerifySuspendedChannelsAndTryToUnsuspend | validation | func (m *Monitor) VerifySuspendedChannelsAndTryToUnsuspend() error {
// All channels, that are suspended,
// but now seems to be payed - must be unsuspended.
query := `
SELECT channels.id :: text
FROM channels
LEFT JOIN sessions ses
ON channels.id = ses.chann... | go | {
"resource": ""
} |
q173465 | VerifyChannelsForInactivity | validation | func (m *Monitor) VerifyChannelsForInactivity() error {
query := `
SELECT channels.id::text
FROM channels
LEFT JOIN sessions ses
ON channels.id = ses.channel
LEFT JOIN offerings offer
ON channels.offering = offer.id
... | go | {
"resource": ""
} |
q173466 | VerifySuspendedChannelsAndTryToTerminate | validation | func (m *Monitor) VerifySuspendedChannelsAndTryToTerminate() error {
query := `
SELECT channels.id::text
FROM channels
LEFT JOIN offerings offer
ON channels.offering = offer.id
INNER JOIN accounts acc
ON channels.agent... | go | {
"resource": ""
} |
q173467 | NewLogger | validation | func NewLogger(conf *Config, db *reform.DB) (log.Logger, error) {
l := &dbLogger{db: db}
base, err := log.NewLoggerBase(conf.BaseConfig, l.log)
if err != nil {
return nil, err
}
l.LoggerBase = base
return l, nil
} | go | {
"resource": ""
} |
q173468 | BalanceClosingHash | validation | func BalanceClosingHash(clientAddr, pscAddr common.Address, block uint32,
offeringHash common.Hash, balance uint64) []byte {
blockBytes := data.Uint32ToBytes(block)
balanceBytes := data.Uint64ToBytes(balance)
return crypto.Keccak256(
[]byte("\x19Ethereum Signed Message:\n32"),
crypto.Keccak256(
[]byte("Priva... | go | {
"resource": ""
} |
q173469 | Run | validation | func Run(ctx context.Context, conf *Config,
logger log.Logger, ports []uint16) {
if conf.Mechanism == "" {
logger.Debug("traversal NAT is not needed.")
return
}
service, err := Parse(conf)
if err != nil {
logger.Error(err.Error())
return
}
for k := range ports {
// Remove old rules.
service.DeleteM... | go | {
"resource": ""
} |
q173470 | RecoverPubKey | validation | func RecoverPubKey(signer types.Signer, tx *types.Transaction) (*ecdsa.PublicKey, error) {
V, R, S := tx.RawSignatureValues()
hash := signer.Hash(tx)
r, s := R.Bytes(), S.Bytes()
sig := make([]byte, 65)
copy(sig[32-len(r):32], r)
copy(sig[64-len(s):64], s)
sig[64] = byte(V.Uint64() - 27)
// recover the public k... | go | {
"resource": ""
} |
q173471 | GetTemplates | validation | func (h *Handler) GetTemplates(tkn, tplType string) ([]data.Template, error) {
logger := h.logger.Add(
"method", "GetTemplates", "type", tplType)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
var templates []reform.Struct
var err error
if tplType != "" {
templates,... | go | {
"resource": ""
} |
q173472 | CreateTemplate | validation | func (h *Handler) CreateTemplate(
tkn string, template *data.Template) (*string, error) {
logger := h.logger.Add("method", "CreateTemplate",
"template", template)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
err := checkTemplate(logger, template)
if err != nil {
re... | go | {
"resource": ""
} |
q173473 | CreateProduct | validation | func (h *Handler) CreateProduct(tkn string,
product data.Product) (*string, error) {
logger := h.logger.Add("method", "CreateProduct", "product", product)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
if product.ServiceEndpointAddress != nil &&
!isValidSEAddress(*produ... | go | {
"resource": ""
} |
q173474 | UpdateProduct | validation | func (h *Handler) UpdateProduct(tkn string, product data.Product) error {
logger := h.logger.Add("method", "UpdateProduct", "product", product)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
oldProduct := &data.Product{}
if err := h.findByPrimaryKey(logger,
ErrProductNotFoun... | go | {
"resource": ""
} |
q173475 | GetProducts | validation | func (h *Handler) GetProducts(tkn string) ([]data.Product, error) {
logger := h.logger.Add("method", "GetProducts")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
result, err := h.db.SelectAllFrom(data.ProductTable,
"WHERE products.is_server")
if err != nil {
logger.E... | go | {
"resource": ""
} |
q173476 | NewHandler | validation | func NewHandler(logger log.Logger, db *reform.DB,
countryConf *country.Config, queue job.Queue) *Handler {
logger = logger.Add("type", "sess.Handler")
return &Handler{
db: db,
logger: logger,
countryConf: countryConf,
queue: queue,
}
} | go | {
"resource": ""
} |
q173477 | EncryptedKey | validation | func EncryptedKey(pkey *ecdsa.PrivateKey, auth string) (Base64String, error) {
key := keystore.NewKeyForDirectICAP(rand.Reader)
key.Address = crypto.PubkeyToAddress(pkey.PublicKey)
key.PrivateKey = pkey
encryptedBytes, err := keystore.EncryptKey(key, auth,
keystore.StandardScryptN,
keystore.StandardScryptP)
if... | go | {
"resource": ""
} |
q173478 | ExecuteCommand | validation | func ExecuteCommand(args []string) error {
if len(args) == 0 {
return nil
}
switch args[0] {
case "db-create":
f := readFlags(args)
if err := createDatabase(f.connection); err != nil {
panic("failed to create database: " + err.Error())
}
os.Exit(0)
case "db-migrate":
f := readFlags(args)
err := m... | go | {
"resource": ""
} |
q173479 | AddMapping | validation | func (n *npmp) AddMapping(protocol string, extPort, intPort int,
name string, lifetime time.Duration) error {
if lifetime <= 0 {
return ErrTooShortLifetime
}
_, err := n.c.AddPortMapping(strings.ToLower(protocol),
intPort, extPort, int(lifetime/time.Second))
return err
} | go | {
"resource": ""
} |
q173480 | DeleteMapping | validation | func (n *npmp) DeleteMapping(protocol string, extPort, intPort int) (err error) {
_, err = n.c.AddPortMapping(strings.ToLower(protocol), intPort, 0, 0)
return err
} | go | {
"resource": ""
} |
q173481 | NewMonitor | validation | func NewMonitor(conf *Config, logger log.Logger, db *reform.DB,
pr *proc.Processor, pscAddr string, pw data.PWDGetter) *Monitor {
return &Monitor{
conf: conf,
logger: logger.Add("type", "client/bill.Monitor"),
db: db,
pr: pr,
psc: pscAddr,
pw: pw,
post: pay.PostCheque,
}
} | go | {
"resource": ""
} |
q173482 | GetOfferingIncome | validation | func (h *Handler) GetOfferingIncome(
tkn, offeringID string) (*uint, error) {
logger := h.logger.Add("method", "GetOfferingIncome",
"offeringID", offeringID)
return h.uintFromQuery(logger, tkn,
`SELECT SUM(channels.receipt_balance)
FROM channels
WHERE channels.offering=$1`, offeringID)
} | go | {
"resource": ""
} |
q173483 | GetProductIncome | validation | func (h *Handler) GetProductIncome(
tkn, productID string) (*uint, error) {
logger := h.logger.Add("method", "GetProductIncome",
"productID", productID)
return h.uintFromQuery(logger, tkn,
`SELECT SUM(channels.receipt_balance)
FROM offerings
JOIN channels
ON channels.offering=offerings.id
... | go | {
"resource": ""
} |
q173484 | GetTotalIncome | validation | func (h *Handler) GetTotalIncome(tkn string) (*uint, error) {
logger := h.logger.Add("method", "GetTotalIncome")
return h.uintFromQuery(logger, tkn,
`SELECT SUM(channels.receipt_balance)
FROM channels`)
} | go | {
"resource": ""
} |
q173485 | Up00001 | validation | func Up00001(tx *sql.Tx) error {
query, err := statik.ReadFile("/scripts/migration/00001_schema_up.sql")
if err != nil {
return err
}
return exec(string(query), tx)
} | go | {
"resource": ""
} |
q173486 | GetSettings | validation | func (h *Handler) GetSettings(tkn string) (map[string]SettingUI, error) {
logger := h.logger.Add("method", "GetSettings")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
result := make(map[string]SettingUI)
settings, err := h.selectAllFrom(
logger, data.SettingTable, se... | go | {
"resource": ""
} |
q173487 | UpdateSettings | validation | func (h *Handler) UpdateSettings(tkn string, items map[string]string) error {
logger := h.logger.Add("method", "UpdateSettings")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
err := h.db.InTransaction(func(tx *reform.TX) error {
for k, v := range items {
if err := h.valid... | go | {
"resource": ""
} |
q173488 | IsIPv4 | validation | func IsIPv4(s string) bool {
ip := net.ParseIP(s)
return ip != nil
} | go | {
"resource": ""
} |
q173489 | IsHostname | validation | func IsHostname(s string) bool {
addrs, err := net.LookupHost(s)
if err != nil || len(addrs) == 0 {
return false
}
return true
} | go | {
"resource": ""
} |
q173490 | IsNetPort | validation | func IsNetPort(str string) bool {
if _, err := strconv.ParseUint(
str, 10, 16); err != nil {
return false
}
return true
} | go | {
"resource": ""
} |
q173491 | IsTLSCert | validation | func IsTLSCert(block string) bool {
var cert tls.Certificate
pemBlock := []byte(block)
for {
var derBlock *pem.Block
derBlock, pemBlock = pem.Decode(pemBlock)
if derBlock == nil {
break
}
if derBlock.Type == certificate {
cert.Certificate =
append(cert.Certificate, derBlock.Bytes)
}
}
if ... | go | {
"resource": ""
} |
q173492 | ValidateJSON | validation | func ValidateJSON(schema, data []byte) bool {
sloader := gojsonschema.NewBytesLoader(schema)
dloader := gojsonschema.NewBytesLoader(data)
result, err := gojsonschema.Validate(sloader, dloader)
return err == nil && result.Valid() && len(result.Errors()) == 0
} | go | {
"resource": ""
} |
q173493 | NewConfig | validation | func NewConfig() *Config {
return &Config{
CheckTimeout: 20000,
Timeout: 10000,
HTTPClient: &httpClientConf{
DialTimeout: 5,
TLSHandshakeTimeout: 2,
ResponseHeaderTimeout: 8,
RequestTimeout: 10,
IdleConnTimeout: 30,
KeepAliveTimeout: 60,
},
}
} | go | {
"resource": ""
} |
q173494 | ReadJSONFile | validation | func ReadJSONFile(name string, data interface{}) error {
file, err := os.Open(name)
if err != nil {
return err
}
defer file.Close()
return json.NewDecoder(file).Decode(data)
} | go | {
"resource": ""
} |
q173495 | WriteJSONFile | validation | func WriteJSONFile(name, prefix, indent string, data interface{}) error {
file, err := os.Create(name)
if err != nil {
return err
}
defer file.Close()
enc := json.NewEncoder(file)
enc.SetIndent(prefix, indent)
return enc.Encode(data)
} | go | {
"resource": ""
} |
q173496 | IsUUID | validation | func IsUUID(s string) bool {
_, err := uuid.FromString(s)
return err == nil
} | go | {
"resource": ""
} |
q173497 | ExeDirJoin | validation | func ExeDirJoin(elem ...string) string {
exe, err := os.Executable()
if err != nil {
panic(err)
}
elem = append([]string{filepath.Dir(exe)}, elem...)
return filepath.Join(elem...)
} | go | {
"resource": ""
} |
q173498 | RootPath | validation | func RootPath() string {
_, file, _, ok := runtime.Caller(0)
if !ok {
return "?"
}
return filepath.Dir(filepath.Dir(file))
} | go | {
"resource": ""
} |
q173499 | Caller | validation | func Caller() string {
_, file, line, ok := runtime.Caller(2)
if !ok {
return "?"
}
rel, err := filepath.Rel(RootPath(), file)
if err != nil {
return "?"
}
return fmt.Sprintf("%s:%d", rel, line)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.