_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q173500 | CheckConnection | validation | func CheckConnection(network, ip string, port int, timeout time.Duration) bool {
conn, _ := net.DialTimeout(network,
net.JoinHostPort(ip, strconv.Itoa(port)), timeout)
if conn != nil {
conn.Close()
return true
}
return false
} | go | {
"resource": ""
} |
q173501 | ClientAfterChannelCreate | validation | func (w *Worker) ClientAfterChannelCreate(job *data.Job) error {
logger := w.logger.Add("method", "ClientAfterChannelCreate", "job", job)
ch, err := w.relatedChannel(logger, job, data.JobClientAfterChannelCreate)
if err != nil {
return err
}
ethLog, err := w.ethLog(logger, job)
if err != nil {
return err
}... | go | {
"resource": ""
} |
q173502 | ClientEndpointCreate | validation | func (w *Worker) ClientEndpointCreate(job *data.Job) error {
logger := w.logger.Add("method", "ClientEndpointCreate",
"job", job)
ch, err := w.relatedChannel(logger, job,
data.JobClientEndpointRestore)
if err != nil {
return err
}
var jdata data.JobEndpointCreateData
if err := w.unmarshalDataTo(logger, jo... | go | {
"resource": ""
} |
q173503 | ClientAfterUncooperativeClose | validation | func (w *Worker) ClientAfterUncooperativeClose(job *data.Job) error {
logger := w.logger.Add("method", "ClientAfterUncooperativeClose",
"job", job)
ch, err := w.relatedChannel(logger, job, data.JobClientAfterUncooperativeClose)
if err != nil {
return err
}
logger = logger.Add("channel", ch)
ch.ChannelStatus... | go | {
"resource": ""
} |
q173504 | ClientAfterCooperativeClose | validation | func (w *Worker) ClientAfterCooperativeClose(job *data.Job) error {
logger := w.logger.Add("method", "ClientAfterCooperativeClose",
"job", job)
ch, err := w.relatedChannel(logger, job,
data.JobClientAfterCooperativeClose)
if err != nil {
return err
}
logger = logger.Add("channel", ch)
ch.ChannelStatus = ... | go | {
"resource": ""
} |
q173505 | ClientPreServiceTerminate | validation | func (w *Worker) ClientPreServiceTerminate(job *data.Job) error {
logger := w.logger.Add("method", "ClientPreServiceTerminate", "job", job)
ch, err := w.relatedChannel(logger,
job, data.JobClientPreServiceTerminate)
if err != nil {
return err
}
logger = logger.Add("channel", ch)
if ch.ServiceStatus == data... | go | {
"resource": ""
} |
q173506 | ClientPreServiceSuspend | validation | func (w *Worker) ClientPreServiceSuspend(job *data.Job) error {
logger := w.logger.Add("method", "ClientPreServiceSuspend", "job", job)
ch, err := w.relatedChannel(logger, job, data.JobClientPreServiceSuspend)
if err != nil {
return err
}
logger = logger.Add("channel", ch)
ch.ServiceStatus = data.ServiceSusp... | go | {
"resource": ""
} |
q173507 | ClientPreServiceUnsuspend | validation | func (w *Worker) ClientPreServiceUnsuspend(job *data.Job) error {
logger := w.logger.Add("method", "ClientPreServiceUnsuspend",
"job", job)
ch, err := w.relatedChannel(logger, job, data.JobClientPreServiceUnsuspend)
if err != nil {
return err
}
logger = logger.Add("channel", ch)
ch.ServiceStatus = data.Ser... | go | {
"resource": ""
} |
q173508 | ClientPreUncooperativeClose | validation | func (w *Worker) ClientPreUncooperativeClose(job *data.Job) error {
logger := w.logger.Add("method", "ClientPreUncooperativeClose",
"job", job)
// If cooperative close was created for this channel, skip this job.
err := w.db.SelectOneTo(&data.Job{},
"WHERE related_id=$1 AND related_type=$2 AND type=$3",
job.R... | go | {
"resource": ""
} |
q173509 | ClientPreChannelTopUp | validation | func (w *Worker) ClientPreChannelTopUp(job *data.Job) error {
logger := w.logger.Add("method", "ClientPreChannelTopUp", "job", job)
ch, err := w.relatedChannel(logger, job, data.JobClientPreChannelTopUp)
if err != nil {
return err
}
offer, err := w.offering(logger, ch.Offering)
if err != nil {
return err
}... | go | {
"resource": ""
} |
q173510 | ClientAfterChannelTopUp | validation | func (w *Worker) ClientAfterChannelTopUp(job *data.Job) error {
return w.afterChannelTopUp(job, data.JobClientAfterChannelTopUp)
} | go | {
"resource": ""
} |
q173511 | ClientPreUncooperativeCloseRequest | validation | func (w *Worker) ClientPreUncooperativeCloseRequest(job *data.Job) error {
logger := w.logger.Add("method", "ClientPreUncooperativeCloseRequest",
"job", job)
ch, err := w.relatedChannel(logger, job,
data.JobClientPreUncooperativeCloseRequest)
if err != nil {
return err
}
jdata, err := w.publishData(logger,... | go | {
"resource": ""
} |
q173512 | ClientAfterUncooperativeCloseRequest | validation | func (w *Worker) ClientAfterUncooperativeCloseRequest(job *data.Job) error {
logger := w.logger.Add("method", "ClientAfterUncooperativeCloseRequest",
"job", job)
ch, err := w.relatedChannel(logger, job,
data.JobClientAfterUncooperativeCloseRequest)
if err != nil {
return err
}
ch.ChannelStatus = data.Chann... | go | {
"resource": ""
} |
q173513 | ClientAfterOfferingMsgBCPublish | validation | func (w *Worker) ClientAfterOfferingMsgBCPublish(job *data.Job) error {
logger := w.logger.Add("method", "ClientAfterOfferingMsgBCPublish",
"job", job)
ethLog, err := w.ethLog(logger, job)
if err != nil {
return err
}
logOfferingCreated, err := extractLogOfferingCreated(logger, ethLog)
if err != nil {
ret... | go | {
"resource": ""
} |
q173514 | ClientAfterOfferingPopUp | validation | func (w *Worker) ClientAfterOfferingPopUp(job *data.Job) error {
logger := w.logger.Add("method", "ClientAfterOfferingPopUp", "job", job)
ethLog, err := w.ethLog(logger, job)
if err != nil {
return err
}
logger = logger.Add("ethLog", ethLog)
logOfferingPopUp, err := extractLogOfferingPopUp(logger, ethLog)
i... | go | {
"resource": ""
} |
q173515 | ClientAfterOfferingDelete | validation | func (w *Worker) ClientAfterOfferingDelete(job *data.Job) error {
return w.updateRelatedOffering(
job, data.JobClientAfterOfferingDelete, data.OfferRemoved)
} | go | {
"resource": ""
} |
q173516 | DecrementCurrentSupply | validation | func (w *Worker) DecrementCurrentSupply(job *data.Job) error {
logger := w.logger.Add("method", "DecrementCurrentSupply", "job", job)
offering, err := w.relatedOffering(logger, job, data.JobDecrementCurrentSupply)
if err != nil {
return err
}
offering.CurrentSupply--
err = data.Save(w.db.Querier, offering)
i... | go | {
"resource": ""
} |
q173517 | GetEndpoints | validation | func (h *Handler) GetEndpoints(
tkn, channel, template string) ([]data.Endpoint, error) {
logger := h.logger.Add("method", "GetEndpoints",
"channel", channel, "template", template)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
tail, args := h.getEndpointsConditions(cha... | go | {
"resource": ""
} |
q173518 | GetGUISettings | validation | func (h *Handler) GetGUISettings(tkn string) (map[string]interface{}, error) {
logger := h.logger.Add("method", "GetGUISettings")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
retStr, err := data.ReadSetting(h.db.Querier, data.SettingGUI)
if err != nil {
logger.Error(e... | go | {
"resource": ""
} |
q173519 | SetGUISettings | validation | func (h *Handler) SetGUISettings(tkn string, v map[string]interface{}) error {
logger := h.logger.Add("method", "SetGUISettings")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
d, err := json.Marshal(&v)
if err != nil {
logger.Error(err.Error())
return ErrInternal
}
_, ... | go | {
"resource": ""
} |
q173520 | HandleFunc | validation | func (s *Server) HandleFunc(pattern string, handler HandlerFunc) {
s.Mux().HandleFunc(pattern,
func(w http.ResponseWriter, r *http.Request) {
handler(w, r, &Context{})
})
} | go | {
"resource": ""
} |
q173521 | RequireHTTPMethods | validation | func (s *Server) RequireHTTPMethods(logger log.Logger,
handler HandlerFunc, methods ...string) HandlerFunc {
l := logger.Add("method", "RequireHTTPMethods")
return func(w http.ResponseWriter, r *http.Request, ctx *Context) {
for _, v := range methods {
if v == r.Method {
handler(w, r, ctx)
return
}
... | go | {
"resource": ""
} |
q173522 | RequireBasicAuth | validation | func (s *Server) RequireBasicAuth(logger log.Logger,
handler HandlerFunc, auth AuthFunc) HandlerFunc {
l := logger.Add("method", "RequireBasicAuth")
return func(w http.ResponseWriter, r *http.Request, ctx *Context) {
name, pass, ok := r.BasicAuth()
if !ok || !auth(name, pass) {
l.Add("sender", r.RemoteAddr).W... | go | {
"resource": ""
} |
q173523 | New | validation | func New(db *reform.DB, logger log.Logger, payAddr string,
timeout uint) (*Service, error) {
return &Service{
db: db,
msgChan: make(chan *req),
payAddr: payAddr,
timeout: time.Duration(timeout) * time.Millisecond,
logger: logger.Add("type", "messages/ept.Service"),
}, nil
} | go | {
"resource": ""
} |
q173524 | EndpointMessage | validation | func (s *Service) EndpointMessage(channelID string) (*Message, error) {
c := make(chan *result)
done := make(chan bool)
req := &req{channelID: channelID, callback: c, done: done}
go s.processing(req)
select {
case result := <-c:
return result.msg, result.err
case <-time.After(s.timeout):
close(done)
ret... | go | {
"resource": ""
} |
q173525 | ConnChange | validation | func (h *Handler) ConnChange(ctx context.Context,
product, productPassword string) (*rpc.Subscription, error) {
logger := h.logger.Add("method", "ConnChange", "product", product)
logger.Info("subscribing to adapter connection changes")
_, err := h.checkProductPassword(logger, product, productPassword)
if err != ... | go | {
"resource": ""
} |
q173526 | FromBase64ToHex | validation | func FromBase64ToHex(s Base64String) (string, error) {
b, err := ToBytes(s)
if err != nil {
return "", err
}
return hex.EncodeToString(b), nil
} | go | {
"resource": ""
} |
q173527 | HexToBytes | validation | func HexToBytes(s HexString) ([]byte, error) {
s2 := string(s)
if strings.HasPrefix(s2, "0x") || strings.HasPrefix(s2, "0X") {
s2 = s2[2:]
}
return hex.DecodeString(s2)
} | go | {
"resource": ""
} |
q173528 | ToBytes | validation | func ToBytes(s Base64String) ([]byte, error) {
return base64.URLEncoding.DecodeString(strings.TrimSpace(string(s)))
} | go | {
"resource": ""
} |
q173529 | ToHash | validation | func ToHash(h Base64String) (common.Hash, error) {
hashBytes, err := ToBytes(h)
if err != nil {
err = fmt.Errorf("unable to parse ethereum hash: %s", err)
}
return common.BytesToHash(hashBytes), err
} | go | {
"resource": ""
} |
q173530 | HexToHash | validation | func HexToHash(h HexString) (common.Hash, error) {
hashBytes, err := HexToBytes(h)
if err != nil {
err = fmt.Errorf("unable to parse ethereum hash: %s", err)
}
return common.BytesToHash(hashBytes), err
} | go | {
"resource": ""
} |
q173531 | HexToAddress | validation | func HexToAddress(addr HexString) (common.Address, error) {
addrBytes, err := HexToBytes(addr)
if err != nil {
err = fmt.Errorf("unable to parse ethereum addr: %s", err)
}
return common.BytesToAddress(addrBytes), err
} | go | {
"resource": ""
} |
q173532 | BytesToUint32 | validation | func BytesToUint32(b []byte) (uint32, error) {
if len(b) != 4 {
return 0, fmt.Errorf("wrong len")
}
return binary.BigEndian.Uint32(b), nil
} | go | {
"resource": ""
} |
q173533 | Uint32ToBytes | validation | func Uint32ToBytes(x uint32) [4]byte {
var xBytes [4]byte
binary.BigEndian.PutUint32(xBytes[:], x)
return xBytes
} | go | {
"resource": ""
} |
q173534 | Uint64ToBytes | validation | func Uint64ToBytes(x uint64) [8]byte {
var xBytes [8]byte
binary.BigEndian.PutUint64(xBytes[:], x)
return xBytes
} | go | {
"resource": ""
} |
q173535 | Uint192ToBytes | validation | func Uint192ToBytes(x *big.Int) [24]byte {
var ret [24]byte
xBytes := x.Bytes()
for i, v := range xBytes {
ret[24-len(xBytes)+i] = v
}
return ret
} | go | {
"resource": ""
} |
q173536 | HashPassword | validation | func HashPassword(password, salt string) (Base64String, error) {
salted := []byte(password + salt)
passwordHash, err := bcrypt.GenerateFromPassword(salted, bcrypt.DefaultCost)
if err != nil {
return "", err
}
return FromBytes(passwordHash), nil
} | go | {
"resource": ""
} |
q173537 | ValidatePassword | validation | func ValidatePassword(hash Base64String, password, salt string) error {
salted := []byte(fmt.Sprint(password, salt))
hashB, err := ToBytes(hash)
if err != nil {
return err
}
return bcrypt.CompareHashAndPassword(hashB, salted)
} | go | {
"resource": ""
} |
q173538 | GetUint64Setting | validation | func GetUint64Setting(db *reform.DB, key string) (uint64, error) {
var setting Setting
err := db.FindByPrimaryKeyTo(&setting, key)
if err != nil {
if err == sql.ErrNoRows {
return 0, fmt.Errorf("key %s is not exist"+
" in Setting table", key)
}
return 0, err
}
value, err := strconv.ParseUint(setting.... | go | {
"resource": ""
} |
q173539 | ChannelKey | validation | func ChannelKey(client, agent HexString, block uint32,
offeringHash HexString) ([]byte, error) {
clientAddr, err := HexToAddress(client)
if err != nil {
return nil, err
}
agentAddr, err := HexToAddress(agent)
if err != nil {
return nil, err
}
hash, err := base64.URLEncoding.DecodeString(
strings.TrimSpa... | go | {
"resource": ""
} |
q173540 | MinDeposit | validation | func MinDeposit(offering *Offering) uint64 {
return offering.MinUnits*offering.UnitPrice + offering.SetupPrice
} | go | {
"resource": ""
} |
q173541 | AcceptOffering | validation | func (h *Handler) AcceptOffering(tkn string, account data.HexString,
offering string, deposit, gasPrice uint64) (*string, error) {
logger := h.logger.Add("method", "AcceptOffering",
"account", account, "offering", offering,
"deposit", deposit, "gasPrice", gasPrice)
if !h.token.Check(tkn) {
logger.Warn("access... | go | {
"resource": ""
} |
q173542 | ChangeOfferingStatus | validation | func (h *Handler) ChangeOfferingStatus(
tkn, offering, action string, gasPrice uint64) error {
logger := h.logger.Add("method", "ChangeOfferingStatus",
"offering", offering, "action", action, "gasPrice", gasPrice)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
jobType, ok :=... | go | {
"resource": ""
} |
q173543 | GetClientOfferings | validation | func (h *Handler) GetClientOfferings(tkn string, agent data.HexString,
minUnitPrice, maxUnitPrice uint64, countries []string,
offset, limit uint) (*GetClientOfferingsResult, error) {
logger := h.logger.Add("method", "GetClientOfferings",
"agent", agent, "minUnitPrice", minUnitPrice,
"maxUnitPrice", maxUnitPrice,... | go | {
"resource": ""
} |
q173544 | GetAgentOfferings | validation | func (h *Handler) GetAgentOfferings(tkn, product string, statuses []string,
offset, limit uint) (*GetAgentOfferingsResult, error) {
logger := h.logger.Add("method", "GetAgentOfferings",
"product", product, "status", statuses)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}... | go | {
"resource": ""
} |
q173545 | setOfferingHash | validation | func (h *Handler) setOfferingHash(logger log.Logger, offering *data.Offering,
template *data.Template, agent *data.Account) error {
handleErr := func(err error) error {
logger.Error(err.Error())
return ErrInternal
}
msg := offer.OfferingMessage(agent, template, offering)
msgBytes, err := json.Marshal(msg)
if... | go | {
"resource": ""
} |
q173546 | fillOffering | validation | func (h *Handler) fillOffering(
logger log.Logger, offering *data.Offering) error {
agent := &data.Account{}
// TODO: This is definitely wrong, should be:
// `h.findByColumn(..., "eth_addr", offering.Agent)`
if err := h.findByPrimaryKey(logger,
ErrAccountNotFound, agent, string(offering.Agent)); err != nil {
r... | go | {
"resource": ""
} |
q173547 | UpdateOffering | validation | func (h *Handler) UpdateOffering(tkn string, offering *data.Offering) error {
logger := h.logger.Add(
"method", "UpdateOffering", "offering", offering)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return ErrAccessDenied
}
err := h.findByPrimaryKey(
logger, ErrOfferingNotFound, &data.Offering{}, o... | go | {
"resource": ""
} |
q173548 | CreateOffering | validation | func (h *Handler) CreateOffering(tkn string,
offering *data.Offering) (*string, error) {
logger := h.logger.Add(
"method", "CreateOffering", "offering", offering)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
err := h.prepareOffering(logger, offering)
if err != nil {
... | go | {
"resource": ""
} |
q173549 | GetClientOfferingsFilterParams | validation | func (h *Handler) GetClientOfferingsFilterParams(
tkn string) (*GetClientOfferingsFilterParamsResult, error) {
logger := h.logger.Add("method", "GetClientOfferingsFilterParams")
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
countries, err := h.offeringCountries(logger)
... | go | {
"resource": ""
} |
q173550 | PingOfferings | validation | func (h *Handler) PingOfferings(tkn string, ids []string) (map[string]bool, error) {
logger := h.logger.Add("method", "PingOfferings", "ids", ids)
if !h.token.Check(tkn) {
logger.Warn("access denied")
return nil, ErrAccessDenied
}
now := time.Now()
ret := make(map[string]bool)
wg := new(sync.WaitGroup)
wg... | go | {
"resource": ""
} |
q173551 | NewServer | validation | func NewServer(conf *Config) *Server {
s := &Server{
conf: conf,
srv: http.Server{
Addr: conf.Addr,
Handler: http.NewServeMux(),
},
}
return s
} | go | {
"resource": ""
} |
q173552 | Mux | validation | func (s *Server) Mux() *http.ServeMux {
return s.srv.Handler.(*http.ServeMux)
} | go | {
"resource": ""
} |
q173553 | NewLogger | validation | func NewLogger(conf *Config) (log.Logger, error) {
l := &reportLogger{}
base, err := log.NewLoggerBase(conf.BaseConfig, l.log)
if err != nil {
return nil, err
}
l.LoggerBase = base
return l, nil
} | go | {
"resource": ""
} |
q173554 | Printf | validation | func (l *reportLogger) Printf(format string, v ...interface{}) {
if l.logger != nil {
l.logger.Debug(fmt.Sprintf(format, v...))
}
} | go | {
"resource": ""
} |
q173555 | GetURL | validation | func GetURL(conf *Config, path string) string {
var proto = "http"
if conf.TLS != nil {
proto += "s"
}
return proto + "://" + conf.Addr + path
} | go | {
"resource": ""
} |
q173556 | NewHTTPRequest | validation | func NewHTTPRequest(conf *Config, method,
path string, req *Request) (*http.Request, error) {
return NewHTTPRequestWithURL(method, GetURL(conf, path), req)
} | go | {
"resource": ""
} |
q173557 | NewHTTPRequestWithURL | validation | func NewHTTPRequestWithURL(method, url string, req *Request) (*http.Request, error) {
data, err := json.Marshal(req)
if err != nil {
return nil, err
}
return http.NewRequest(
method, url, bytes.NewReader(data))
} | go | {
"resource": ""
} |
q173558 | Send | validation | func Send(req *http.Request) (*Response, error) {
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var resp2 Response
if err = json.NewDecoder(resp.Body).Decode(&resp2); err != nil {
return nil, err
}
return &resp2, nil
} | go | {
"resource": ""
} |
q173559 | Check | validation | func (t *SimpleToken) Check(s string) bool {
t.mtx.RLock()
defer t.mtx.RUnlock()
return s == t.token
} | go | {
"resource": ""
} |
q173560 | Make | validation | func (t *SimpleToken) Make() (string, error) {
b := make([]byte, 32)
_, err := rand.Read(b)
if err != nil {
return "", err
}
t.mtx.Lock()
defer t.mtx.Unlock()
t.token = string(data.FromBytes(b))
return t.token, nil
} | go | {
"resource": ""
} |
q173561 | GetLogs | validation | func (h *Handler) GetLogs(tkn string, levels []string, searchText,
dateFrom, dateTo string, offset, limit uint) (*GetLogsResult, error) {
logger := h.logger.Add("method", "GetLogs", "searchText",
searchText, "levels", levels, "dateFrom", dateFrom, "dateTo",
dateTo, "offset", offset, "limit", limit)
if !h.token.... | go | {
"resource": ""
} |
q173562 | AuthClient | validation | func (h *Handler) AuthClient(product, productPassword,
clientKey, clientPassword string) error {
logger := h.logger.Add("method", "AuthClient",
"product", product, "clientKey", clientKey)
logger.Info("session auth request")
prod, err := h.checkProductPassword(logger, product, productPassword)
if err != nil {
... | go | {
"resource": ""
} |
q173563 | StartSession | validation | func (h *Handler) StartSession(product, productPassword,
clientKey, ip string, port uint16) (*data.Offering, error) {
logger := h.logger.Add("method", "StartSession", "product", product,
"clientKey", clientKey, "ip", ip, "port", port)
logger.Info("session start request")
prod, err := h.checkProductPassword(logg... | go | {
"resource": ""
} |
q173564 | UpdateSession | validation | func (h *Handler) UpdateSession(product, productPassword, clientKey string,
units uint64, stopSession bool) error {
logger := h.logger.Add("method", "UpdateSession", "product", product,
"clientKey", clientKey, "units", units,
"stopSession", stopSession)
if stopSession {
logger.Info("session stop request")
} ... | go | {
"resource": ""
} |
q173565 | OfferingMessage | validation | func OfferingMessage(agent *data.Account, template *data.Template,
offering *data.Offering) *Message {
msg := &Message{
AgentPubKey: agent.PublicKey,
TemplateHash: template.Hash,
Country: offering.Country,
ServiceSupply: offering.Supply,
UnitName: offering.UnitName,
... | go | {
"resource": ""
} |
q173566 | ValidMsg | validation | func ValidMsg(schema json.RawMessage, msg Message) bool {
sch := gojsonschema.NewBytesLoader(schema)
loader := gojsonschema.NewGoLoader(msg)
result, err := gojsonschema.Validate(sch, loader)
if err != nil || !result.Valid() || len(result.Errors()) != 0 {
return false
}
return true
} | go | {
"resource": ""
} |
q173567 | NewClient | validation | func NewClient(
cfg *Config, db *reform.DB, log Log, version string) (*Client, error) {
if log == nil {
return nil, fmt.Errorf("no log object specified")
}
excludedPackagesMap := make(map[string]bool)
for _, pkg := range cfg.ExcludedPackages {
excludedPackagesMap[pkg] = true
}
pkgSlice, err := pkgList(exc... | go | {
"resource": ""
} |
q173568 | PanicHunter | validation | func PanicHunter() {
if panicIgnore {
return
}
if err := recover(); err != nil {
if enable && notifier != nil {
notifier.NotifySync(
errors.New(err, 3), true,
metadata([]data.HexString{defaultAccEth}))
}
panic(err)
}
} | go | {
"resource": ""
} |
q173569 | ParseRequest | validation | func (s *Server) ParseRequest(logger log.Logger,
w http.ResponseWriter, r *http.Request, args interface{}) bool {
var req Request
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
logger.Warn("failed to parse request: " + err.Error())
s.RespondError(logger, w, ErrFailedToParseRequest)
return false
... | go | {
"resource": ""
} |
q173570 | Save | validation | func (i *Ipvs) Save() error {
out, err := backendRun([]string{"ipvsadm", "-S", "-n"})
if err != nil {
return err
}
i.Services = make([]Service, 0, 0)
serviceStrings := strings.Split(string(out), "-A")
for j := range serviceStrings {
if serviceStrings[j] == "" {
continue
}
serverStrings := strings.Spli... | go | {
"resource": ""
} |
q173571 | NewClient | validation | func NewClient(httpClient *http.Client, mode, clientID, clientSecret, accessToken string) *Client {
b := sling.New().Client(httpClient).Base(baseURL)
b.QueryStruct(struct {
V string `url:"v"`
M string `url:"m"`
ClientID string `url:"client_id"`
ClientSecret string `url:"client_secret... | go | {
"resource": ""
} |
q173572 | ParseRate | validation | func ParseRate(resp *http.Response) *RateLimit {
limit := resp.Header.Get(headerRateLimit)
path := resp.Header.Get(headerRatePath)
remain := resp.Header.Get(headerRateRemaining)
l, _ := strconv.Atoi(limit)
r, _ := strconv.Atoi(remain)
return &RateLimit{
Limit: l,
Path: path,
Remaining: r,
}
} | go | {
"resource": ""
} |
q173573 | SetOutputPath | validation | func (t *BTTracer) SetOutputPath(path string, perm os.FileMode) error {
return nil
} | go | {
"resource": ""
} |
q173574 | UpdateConfig | validation | func UpdateConfig(c GlobalConfig) {
state.m.Lock()
defer state.m.Unlock()
state.c = c
} | go | {
"resource": ""
} |
q173575 | SetTracerPath | validation | func (t *BTTracer) SetTracerPath(path string) {
t.m.Lock()
defer t.m.Unlock()
t.cmd = path
} | go | {
"resource": ""
} |
q173576 | SetOutputPath | validation | func (t *BTTracer) SetOutputPath(path string, perm os.FileMode) error {
if perm == 0 {
perm = 0755
}
if err := os.MkdirAll(path, perm); err != nil {
t.Logf(LogError, "Failed to create output directory: %v\n", err)
return err
}
t.m.Lock()
defer t.m.Unlock()
t.outputDir = path
return nil
} | go | {
"resource": ""
} |
q173577 | SetPipes | validation | func (t *BTTracer) SetPipes(stdin io.Reader, stderr io.Writer) {
t.m.Lock()
defer t.m.Unlock()
t.p.stdin = stdin
t.p.stderr = stderr
} | go | {
"resource": ""
} |
q173578 | AppendOptionWithPrefix | validation | func AppendOptionWithPrefix(options []string, prefix string, v string) []string {
for i, opt := range options {
if strings.HasPrefix(opt, prefix) == true {
new_opt := opt + "," + v
options[i] = new_opt
return options
}
}
return append(options, prefix + v)
} | go | {
"resource": ""
} |
q173579 | MarshalRaw | validation | func (m *Marshaller) MarshalRaw(bs []byte) {
if m.Error != nil {
return
}
if len(m.Data) < m.offset+len(bs) {
m.Error = io.ErrShortBuffer
return
}
m.offset += copy(m.Data[m.offset:], bs)
} | go | {
"resource": ""
} |
q173580 | MarshalString | validation | func (m *Marshaller) MarshalString(s string) {
if m.Error != nil {
return
}
if len(m.Data) < m.offset+4+len(s)+Padding(len(s)) {
m.Error = io.ErrShortBuffer
return
}
m.MarshalUint32(uint32(len(s)))
m.offset += copy(m.Data[m.offset:], s)
m.offset += copy(m.Data[m.offset:], padBytes[:Padding(len(s))])
} | go | {
"resource": ""
} |
q173581 | MarshalBytes | validation | func (m *Marshaller) MarshalBytes(bs []byte) {
if m.Error != nil {
return
}
if len(m.Data) < m.offset+4+len(bs)+Padding(len(bs)) {
m.Error = io.ErrShortBuffer
return
}
m.MarshalUint32(uint32(len(bs)))
m.offset += copy(m.Data[m.offset:], bs)
m.offset += copy(m.Data[m.offset:], padBytes[:Padding(len(bs))])
... | go | {
"resource": ""
} |
q173582 | MarshalBool | validation | func (m *Marshaller) MarshalBool(v bool) {
if v {
m.MarshalUint8(1)
} else {
m.MarshalUint8(0)
}
} | go | {
"resource": ""
} |
q173583 | MarshalUint32 | validation | func (m *Marshaller) MarshalUint32(v uint32) {
if m.Error != nil {
return
}
if len(m.Data) < m.offset+4 {
m.Error = io.ErrShortBuffer
return
}
m.Data[m.offset+0] = byte(v >> 24)
m.Data[m.offset+1] = byte(v >> 16)
m.Data[m.offset+2] = byte(v >> 8)
m.Data[m.offset+3] = byte(v)
m.offset += 4
} | go | {
"resource": ""
} |
q173584 | MarshalUint64 | validation | func (m *Marshaller) MarshalUint64(v uint64) {
if m.Error != nil {
return
}
if len(m.Data) < m.offset+8 {
m.Error = io.ErrShortBuffer
return
}
m.Data[m.offset+0] = byte(v >> 56)
m.Data[m.offset+1] = byte(v >> 48)
m.Data[m.offset+2] = byte(v >> 40)
m.Data[m.offset+3] = byte(v >> 32)
m.Data[m.offset+4] = ... | go | {
"resource": ""
} |
q173585 | ElementSizeExceeded | validation | func ElementSizeExceeded(field string, size, limit int) error {
return fmt.Errorf("%s exceeds size limit; %d > %d", field, size, limit)
} | go | {
"resource": ""
} |
q173586 | nextSpecialChar | validation | func (e *encoder) nextSpecialChar(p []byte) (i int) {
for i = 0; i < len(p); i++ {
// ASCII 32-126 (printable) + '\t' - '=' can appear in the qprintable stream
if !((p[i] >= 32 && p[i] <= 126 && p[i] != byte('=')) || p[i] == byte('\t')) {
return i
}
}
return i
} | go | {
"resource": ""
} |
q173587 | nextSpecialChar | validation | func (d *decoder) nextSpecialChar(p []byte) (i int) {
for i = 0; i < len(p); i++ {
if p[i] == byte('=') || (d.enc.isText && p[i] == byte('\r')) {
return i
}
}
return i
} | go | {
"resource": ""
} |
q173588 | NewDecoder | validation | func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
return &decoder{enc: enc, r: r,
buf: bytes.NewBuffer(nil),
leftovers: bytes.NewBuffer(nil)}
} | go | {
"resource": ""
} |
q173589 | Register | validation | func (di *dependencyInjector) Register(constructorFunc interface{}) error {
constructorType := reflect.TypeOf(constructorFunc)
if (constructorType.Kind() != reflect.Func) || (constructorType.NumOut() != 1) {
return constructorErr
}
outType := constructorType.Out(0)
// make sure we can resolve the constuctor ar... | go | {
"resource": ""
} |
q173590 | MustRegister | validation | func (di *dependencyInjector) MustRegister(constructorFunc interface{}) {
err := di.Register(constructorFunc)
if err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q173591 | Create | validation | func (di *dependencyInjector) Create(avar interface{}) interface{} {
varType := reflect.TypeOf(avar)
if di.caching {
return di.cachedCreateFromType(varType).Interface()
} else {
return di.CreateFromType(varType).Interface()
}
} | go | {
"resource": ""
} |
q173592 | cachedCreateFromType | validation | func (di *dependencyInjector) cachedCreateFromType(atype reflect.Type) reflect.Value {
_, exists := di.instances[atype]
if !exists {
di.instances[atype] = di.createFromType(atype)
}
return di.instances[atype]
} | go | {
"resource": ""
} |
q173593 | NewDependencyInjector | validation | func NewDependencyInjector() DependencyInjector {
return &dependencyInjector{
registry: make(map[reflect.Type]interface{}),
instances: make(map[reflect.Type]reflect.Value),
}
} | go | {
"resource": ""
} |
q173594 | NewServiceContainer | validation | func NewServiceContainer() ServiceContainer {
return &dependencyInjector{
registry: make(map[reflect.Type]interface{}),
instances: make(map[reflect.Type]reflect.Value),
caching: true,
}
} | go | {
"resource": ""
} |
q173595 | AssetUrl | validation | func (s *prefixPipeline) AssetUrl(name string) (url string, err error) {
url, err = s.AssetPipeline.AssetUrl(name)
if err == nil {
url = s.prefix + url
}
return
} | go | {
"resource": ""
} |
q173596 | Prefix | validation | func Prefix(prefix string, p AssetPipeline) AssetPipeline {
if prefix == "" {
return p
}
return &prefixPipeline{
prefix: prefix,
AssetPipeline: p,
}
} | go | {
"resource": ""
} |
q173597 | ServeHTTP | validation | func (handler ControllerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
handler.getResponse(r).Send(w)
} | go | {
"resource": ""
} |
q173598 | getResponse | validation | func (handler ControllerHandler) getResponse(r *http.Request) Response {
controller := handler.factory()
controller.SetRequest(r)
controller.Init()
rController := reflect.ValueOf(controller)
method := rController.MethodByName(handler.methodName)
// get args from gorilla mux
var args []reflect.Value
for _, val ... | go | {
"resource": ""
} |
q173599 | isValid | validation | func (handler ControllerHandler) isValid() bool {
controller := handler.factory()
rController := reflect.ValueOf(controller)
method := rController.MethodByName(handler.methodName)
if (method == reflect.Value{}) {
panic("No such method: " + handler.methodName)
}
typeOfMethod := method.Type()
var r *Response
r... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.