_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q174200 | DeleteEntity | validation | func (s *Session) DeleteEntity(object Identifiable) *Error {
url, berr := s.getPersonalURL(object)
if berr != nil {
return berr
}
url = url + "?responseChoice=1"
request, err := http.NewRequest("DELETE", url, nil)
if err != nil {
return NewBambouError("HTTP transaction error", err.Error())
}
response, b... | go | {
"resource": ""
} |
q174201 | FetchChildren | validation | func (s *Session) FetchChildren(parent Identifiable, identity Identity, dest interface{}, info *FetchingInfo) *Error {
url, berr := s.getURLForChildrenIdentity(parent, identity)
if berr != nil {
return berr
}
request, err := http.NewRequest("GET", url, nil)
if err != nil {
return NewBambouError("HTTP transac... | go | {
"resource": ""
} |
q174202 | CreateChild | validation | func (s *Session) CreateChild(parent Identifiable, child Identifiable) *Error {
url, berr := s.getURLForChildrenIdentity(parent, child.Identity())
if berr != nil {
return berr
}
buffer := &bytes.Buffer{}
if err := json.NewEncoder(buffer).Encode(child); err != nil {
return NewBambouError("JSON error", err.Err... | go | {
"resource": ""
} |
q174203 | AssignChildren | validation | func (s *Session) AssignChildren(parent Identifiable, children []Identifiable, identity Identity) *Error {
url, berr := s.getURLForChildrenIdentity(parent, identity)
if berr != nil {
return berr
}
var ids []string
for _, c := range children {
if i := c.Identifier(); i != "" {
ids = append(ids, c.Identifi... | go | {
"resource": ""
} |
q174204 | NextEvent | validation | func (s *Session) NextEvent(channel NotificationsChannel, lastEventID string) *Error {
currentURL := s.URL + "/events"
if lastEventID != "" {
currentURL += "?uuid=" + lastEventID
}
request, err := http.NewRequest("GET", currentURL, nil)
if err != nil {
return NewBambouError("HTTP transaction error", err.Erro... | go | {
"resource": ""
} |
q174205 | String | validation | func (i Identity) String() string {
return fmt.Sprintf("<Identity %s|%s>", i.Name, i.Category)
} | go | {
"resource": ""
} |
q174206 | NewPushCenter | validation | func NewPushCenter(session *Session) *PushCenter {
return &PushCenter{
Channel: make(NotificationsChannel),
stop: make(chan bool),
handlers: eventHandlers{},
session: session,
}
} | go | {
"resource": ""
} |
q174207 | RegisterHandlerForIdentity | validation | func (p *PushCenter) RegisterHandlerForIdentity(handler EventHandler, identity Identity) {
if identity.Name == AllIdentity.Name {
p.defaultHander = handler
return
}
p.handlers[identity.Name] = handler
} | go | {
"resource": ""
} |
q174208 | UnregisterHandlerForIdentity | validation | func (p *PushCenter) UnregisterHandlerForIdentity(identity Identity) {
if identity.Name == AllIdentity.Name {
p.defaultHander = nil
return
}
if _, exists := p.handlers[identity.Name]; exists {
delete(p.handlers, identity.Name)
}
} | go | {
"resource": ""
} |
q174209 | HasHandlerForIdentity | validation | func (p *PushCenter) HasHandlerForIdentity(identity Identity) bool {
if identity.Name == AllIdentity.Name {
return p.defaultHander != nil
}
_, exists := p.handlers[identity.Name]
return exists
} | go | {
"resource": ""
} |
q174210 | Start | validation | func (p *PushCenter) Start() error {
if p.isRunning {
return errors.New("the push center is already started")
}
p.isRunning = true
go func() {
lastEventID := ""
for {
go p.session.NextEvent(p.Channel, lastEventID)
select {
case notification := <-p.Channel:
for _, event := range notification.Ev... | go | {
"resource": ""
} |
q174211 | Stop | validation | func (p *PushCenter) Stop() error {
if !p.isRunning {
return errors.New("the push center is not started")
}
p.stop <- true
p.isRunning = false
return nil
} | go | {
"resource": ""
} |
q174212 | Logger | validation | func Logger() *logging.Logger {
if defaultLogger == nil {
logger, _ := logging.SimpleLogger("bambou")
defaultLogger = logger
logger.SetLevel(logging.ERROR)
}
return defaultLogger
} | go | {
"resource": ""
} |
q174213 | String | validation | func (f *FetchingInfo) String() string {
return fmt.Sprintf("<FetchingInfo page: %d, pagesize: %d, totalcount: %d>", f.Page, f.PageSize, f.TotalCount)
} | go | {
"resource": ""
} |
q174214 | NewClient | validation | func NewClient(apiKey string) *Client {
return &Client{
client: &http.Client{Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
DisableKeepAlives: true,
TLSH... | go | {
"resource": ""
} |
q174215 | Post | validation | func (c *Client) Post(metrics []Metric) error {
series := struct {
Series []Metric `json:"series,omitempty"`
}{Series: metrics}
buf := fetchBuffer()
defer bufferPool.Put(buf)
var dst io.Writer = buf
if !c.DisableCompression {
zlw := fetcZlibWriter(buf)
defer zlibWriterPool.Put(zlw)
defer zlw.Close()
... | go | {
"resource": ""
} |
q174216 | MetricID | validation | func MetricID(name string, tags []string) string {
if len(tags) == 0 {
return name
}
sort.Strings(tags)
return name + "|" + strings.Join(tags, ",")
} | go | {
"resource": ""
} |
q174217 | SplitMetricID | validation | func SplitMetricID(metricID string) (name string, tags []string) {
if metricID == "" {
return "", nil
}
pos := strings.LastIndexByte(metricID, '|')
if pos > 0 && pos < len(metricID)-1 {
return metricID[:pos], strings.Split(metricID[pos+1:], ",")
}
return metricID, nil
} | go | {
"resource": ""
} |
q174218 | NewRateScale | validation | func NewRateScale(d time.Duration) *Rate {
return &Rate{
time: time.Now().UnixNano(),
unit: d.Seconds(),
}
} | go | {
"resource": ""
} |
q174219 | Snapshot | validation | func (r *Rate) Snapshot() float64 {
now := time.Now().UnixNano()
dur := time.Duration(now - atomic.SwapInt64(&r.time, now))
return r.count.Snapshot() / dur.Seconds() * r.unit
} | go | {
"resource": ""
} |
q174220 | NewDeriveScale | validation | func NewDeriveScale(v float64, d time.Duration) *Derive {
return &Derive{
value: math.Float64bits(v),
rate: Rate{
time: time.Now().UnixNano(),
unit: d.Seconds(),
},
}
} | go | {
"resource": ""
} |
q174221 | Update | validation | func (d *Derive) Update(v float64) {
p := atomic.SwapUint64(&d.value, math.Float64bits(v))
d.rate.Update(v - math.Float64frombits(p))
} | go | {
"resource": ""
} |
q174222 | Snapshot | validation | func (r *Reservoir) Snapshot() Distribution {
h := newHistogram(defaultHistogramSize)
r.m.Lock()
h = r.hist.Copy(h)
r.m.Unlock()
return h
} | go | {
"resource": ""
} |
q174223 | Update | validation | func (g *Gauge) Update(v float64) {
atomic.StoreUint64(&g.value, math.Float64bits(v))
} | go | {
"resource": ""
} |
q174224 | Snapshot | validation | func (g *Gauge) Snapshot() float64 {
u := atomic.LoadUint64(&g.value)
return math.Float64frombits(u)
} | go | {
"resource": ""
} |
q174225 | NewUnstarted | validation | func NewUnstarted(prefix string, tags ...string) *Registry {
return &Registry{
instruments: make(map[string]interface{}),
prefix: prefix,
tags: tags,
}
} | go | {
"resource": ""
} |
q174226 | Subscribe | validation | func (r *Registry) Subscribe(rep Reporter) {
r.mutex.Lock()
r.reporters = append(r.reporters, rep)
r.mutex.Unlock()
} | go | {
"resource": ""
} |
q174227 | Get | validation | func (r *Registry) Get(name string, tags []string) interface{} {
key := MetricID(name, tags)
r.mutex.RLock()
v := r.instruments[key]
r.mutex.RUnlock()
return v
} | go | {
"resource": ""
} |
q174228 | Register | validation | func (r *Registry) Register(name string, tags []string, v interface{}) {
switch v.(type) {
case Discrete, Sample:
key := MetricID(name, tags)
r.mutex.Lock()
r.instruments[key] = v
r.mutex.Unlock()
}
} | go | {
"resource": ""
} |
q174229 | Fetch | validation | func (r *Registry) Fetch(name string, tags []string, factory func() interface{}) interface{} {
key := MetricID(name, tags)
r.mutex.RLock()
v, ok := r.instruments[key]
r.mutex.RUnlock()
if ok {
return v
}
r.mutex.Lock()
defer r.mutex.Unlock()
if v, ok = r.instruments[key]; !ok {
switch v = factory(); v.(... | go | {
"resource": ""
} |
q174230 | Size | validation | func (r *Registry) Size() int {
r.mutex.RLock()
size := len(r.instruments)
r.mutex.RUnlock()
return size
} | go | {
"resource": ""
} |
q174231 | Tags | validation | func (r *Registry) Tags() []string {
r.mutex.RLock()
tags := r.tags
r.mutex.RUnlock()
return tags
} | go | {
"resource": ""
} |
q174232 | SetTags | validation | func (r *Registry) SetTags(tags ...string) {
r.mutex.Lock()
r.tags = tags
r.mutex.Unlock()
} | go | {
"resource": ""
} |
q174233 | AddTags | validation | func (r *Registry) AddTags(tags ...string) {
r.mutex.Lock()
r.tags = append(r.tags, tags...)
r.mutex.Unlock()
} | go | {
"resource": ""
} |
q174234 | Close | validation | func (r *Registry) Close() error {
if r.closing == nil {
return nil
}
close(r.closing)
return <-r.closed
} | go | {
"resource": ""
} |
q174235 | New | validation | func New(apiKey string) *Reporter {
hostname, _ := os.Hostname()
return &Reporter{
Client: NewClient(apiKey),
Hostname: hostname,
refs: make(map[string]int8),
}
} | go | {
"resource": ""
} |
q174236 | Metric | validation | func (r *Reporter) Metric(name string, tags []string, v float32) {
r.metrics = append(r.metrics, Metric{
Name: name,
Points: [][2]interface{}{[2]interface{}{r.timestamp, v}},
Tags: tags,
Host: r.Hostname,
})
} | go | {
"resource": ""
} |
q174237 | FilterBefore | validation | func (s RethinkStore) FilterBefore(id string, filter map[string]interface{}, count int, skip int, store string, opts ObjectStoreOptions) (rows ObjectRows, err error) {
rootTerm := r.DB(s.Database).Table(store).Between(
r.MinVal, id, r.BetweenOpts{RightBound: "closed"}).OrderBy(
r.OrderByOpts{Index: r.Desc("id")}).... | go | {
"resource": ""
} |
q174238 | Set | validation | func (e *EnvVar) Set(key, value string) {
keyVal := key + "=" + value
for i, v := range *e {
env := strings.SplitN(v, "=", 2)
if len(env) < 2 {
continue
}
if env[0] == key {
(*e)[i] = keyVal
return
}
}
*e = append(*e, keyVal)
} | go | {
"resource": ""
} |
q174239 | SetStr | validation | func (e *EnvVar) SetStr(keyVal string) {
s := strings.SplitN(keyVal, "=", 2)
if len(s) == 2 {
e.Set(s[0], s[1])
}
} | go | {
"resource": ""
} |
q174240 | Get | validation | func (e EnvVar) Get(key string) string {
for _, v := range e {
env := strings.SplitN(v, "=", 2)
if len(env) < 2 {
continue
}
if env[0] == key {
return env[1]
}
}
return ""
} | go | {
"resource": ""
} |
q174241 | String | validation | func (e EnvVar) String() string {
b := bytes.NewBuffer(nil)
for _, env := range e {
// don't include invalid strings
if len(strings.SplitN(env, "=", 2)) < 2 {
continue
}
fmt.Fprintln(b, env)
}
return b.String()
} | go | {
"resource": ""
} |
q174242 | Add | validation | func (s *Set) Add(value interface{}) {
s.Lock()
defer s.Unlock()
s.m[value] = struct{}{}
} | go | {
"resource": ""
} |
q174243 | AddAll | validation | func (s *Set) AddAll(values ...interface{}) {
s.Lock()
defer s.Unlock()
for _, value := range values {
s.m[value] = struct{}{}
}
} | go | {
"resource": ""
} |
q174244 | Remove | validation | func (s *Set) Remove(value interface{}) {
s.Lock()
defer s.Unlock()
delete(s.m, value)
} | go | {
"resource": ""
} |
q174245 | RemoveAll | validation | func (s *Set) RemoveAll(values ...interface{}) {
s.Lock()
defer s.Unlock()
for _, value := range values {
delete(s.m, value)
}
} | go | {
"resource": ""
} |
q174246 | Contains | validation | func (s *Set) Contains(value interface{}) bool {
s.RLock()
defer s.RUnlock()
_, ok := s.m[value]
return ok
} | go | {
"resource": ""
} |
q174247 | ContainsAll | validation | func (s *Set) ContainsAll(values ...interface{}) bool {
s.RLock()
defer s.RUnlock()
for _, value := range values {
_, ok := s.m[value]
if !ok {
return false
}
}
return true
} | go | {
"resource": ""
} |
q174248 | ContainsFunc | validation | func (s *Set) ContainsFunc(f func(interface{}) bool) bool {
s.RLock()
defer s.RUnlock()
for k := range s.m {
if f(k) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q174249 | Clear | validation | func (s *Set) Clear() {
s.Lock()
defer s.Unlock()
s.m = make(map[interface{}]struct{})
} | go | {
"resource": ""
} |
q174250 | Iterator | validation | func (s *Set) Iterator() Iterator {
s.RLock()
defer s.RUnlock()
iterChan := make(chan interface{}, len(s.m))
for k := range s.m {
iterChan <- k
}
close(iterChan)
return IterFunc(func() (interface{}, bool) {
value, ok := <-iterChan
return value, ok
})
} | go | {
"resource": ""
} |
q174251 | Items | validation | func (s *Set) Items() []interface{} {
s.RLock()
defer s.RUnlock()
items := make([]interface{}, len(s.m))
i := 0
for k := range s.m {
items[i] = k
i++
}
return items
} | go | {
"resource": ""
} |
q174252 | ItemsFunc | validation | func (s *Set) ItemsFunc(f func(value interface{}) bool) []interface{} {
s.RLock()
defer s.RUnlock()
items := []interface{}{}
for k := range s.m {
if f(k) {
items = append(items, k)
}
}
return items
} | go | {
"resource": ""
} |
q174253 | fixWeekend | validation | func (h holidaysUSNational) fixWeekend(in time.Time) time.Time {
switch in.Weekday() {
case time.Saturday:
return in.Add(-1 * 24 * time.Hour)
case time.Sunday:
return in.Add(1 * 24 * time.Hour)
default:
return in
}
} | go | {
"resource": ""
} |
q174254 | GetHolidays | validation | func GetHolidays(countryCode string, year int) ([]Holiday, error) {
requiredCodes := []string{countryCode}
result := []Holiday{}
for len(requiredCodes) > 0 {
cc := requiredCodes[0]
hds, ok := holidayProviders[cc]
if !ok {
return nil, HolidayDataNotFoundError
}
requiredCodes = append(requiredCodes, hds... | go | {
"resource": ""
} |
q174255 | GetInt | validation | func (c GConfig) GetInt(key string) int {
i, _ := strconv.Atoi(c.getStringValue(key))
return i
} | go | {
"resource": ""
} |
q174256 | GetFloat | validation | func (c GConfig) GetFloat(key string) float64 {
v, _ := strconv.ParseFloat(c.getStringValue(key), 32)
return v
} | go | {
"resource": ""
} |
q174257 | GetBool | validation | func (c GConfig) GetBool(key string) bool {
b, _ := strconv.ParseBool(c.getStringValue(key))
return b
} | go | {
"resource": ""
} |
q174258 | Exists | validation | func (c GConfig) Exists(key string) bool {
v := c.getValue(key)
if v != nil {
return true
}
return false
} | go | {
"resource": ""
} |
q174259 | getValue | validation | func (c GConfig) getValue(key string) interface{} {
v := c.defaultConfig.configs[key]
if c.profileConfig.fileInfo != nil && s.Contains(c.profileConfig.fileInfo.Name(), c.Profile) {
v = c.profileConfig.configs[key]
}
if v == nil {
v = c.defaultConfig.configs[key]
}
return v
} | go | {
"resource": ""
} |
q174260 | Load | validation | func Load() (*GConfig, error) {
flag.Parse()
gc := new(GConfig)
gc.Profile = loadProfile()
p, err := loadPath()
if err != nil {
return configError(err, "Error reading config directory path %s", p)
}
files, err := ioutil.ReadDir(p)
if err != nil {
return configError(err, "Error reading config directory i... | go | {
"resource": ""
} |
q174261 | loadPath | validation | func loadPath() (string, error) {
path := ""
if len(*cpath) == 0 {
path = os.Getenv("GC_PATH")
} else {
path = *cpath
}
//if empty, load default config path
if len(path) == 0 {
gp, err := getGoPath()
if err != nil {
return "", err
}
path = gp + "/config"
}
log.Printf("Loading configuration file... | go | {
"resource": ""
} |
q174262 | New | validation | func New(filename string, utf8 bool) *Reader {
return &Reader{filename, utf8, nil, sync.Mutex{}}
} | go | {
"resource": ""
} |
q174263 | readMimetypes | validation | func readMimetypes(filename string) (map[string]string, error) {
mimetypes := make(map[string]string)
// Read the mimetype file
data, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
// For each line, store extensions and mimetypes in the hash map
for _, line := range bytes.Split(data, []byte... | go | {
"resource": ""
} |
q174264 | Get | validation | func (mr *Reader) Get(ext string) string {
var err error
// No extension
if len(ext) == 0 {
return ""
}
// Strip the leading dot
if ext[0] == '.' {
ext = ext[1:]
}
mr.mu.Lock()
defer mr.mu.Unlock()
if mr.mimetypes == nil {
mr.mimetypes, err = readMimetypes(mr.filename)
if err != nil {
// Using the ... | go | {
"resource": ""
} |
q174265 | SetHeader | validation | func (mr *Reader) SetHeader(w http.ResponseWriter, ext string) {
mimestring := mr.Get(ext)
if mimestring == "" {
// Default mime type
mimestring = "application/octet-stream"
}
if mr.utf8 {
mimestring += "; charset=utf-8"
}
w.Header().Add("Content-Type", mimestring)
} | go | {
"resource": ""
} |
q174266 | GetFileSize | validation | func GetFileSize(filename string) (fileSize int64) {
var (
fileInfo os.FileInfo
err error
file *os.File
)
if file, err = os.Open(filename); err == nil {
fileInfo, err = file.Stat()
fileSize = fileInfo.Size()
} else {
fileSize = -1
}
return
} | go | {
"resource": ""
} |
q174267 | ListenAndServe | validation | func (s *Server) ListenAndServe() error {
mux := http.NewServeMux()
mux.Handle("/", websocket.Server{
Config: s.wsConfig,
Handler: s.wsConnHandler,
Handshake: func(config *websocket.Config, req *http.Request) error {
s.wg.Add(1) // todo: this needs to happen inside the gorot... | go | {
"resource": ""
} |
q174268 | SendRequest | validation | func (s *Server) SendRequest(connID string, method string, params interface{}, resHandler func(ctx *ResCtx) error) (reqID string, err error) {
if !s.running.Load().(bool) {
return "", errors.New("use of closed server")
}
if conn, ok := s.conns.GetOk(connID); ok {
reqID, err = conn.(*Conn).SendRequest(method, pa... | go | {
"resource": ""
} |
q174269 | SendRequestArr | validation | func (s *Server) SendRequestArr(connID string, method string, resHandler func(ctx *ResCtx) error, params ...interface{}) (reqID string, err error) {
return s.SendRequest(connID, method, params, resHandler)
} | go | {
"resource": ""
} |
q174270 | Close | validation | func (s *Server) Close() error {
if !s.running.Load().(bool) {
return nil
}
s.running.Store(false)
err := s.listener.Close()
// close all active connections discarding any read/writes that is going on currently
s.conns.Range(func(c interface{}) {
c.(*Conn).Close()
})
if err != nil {
return fmt.Errorf("a... | go | {
"resource": ""
} |
q174271 | wsConnHandler | validation | func (s *Server) wsConnHandler(ws *websocket.Conn) {
c, err := NewConn()
if err != nil {
log.Printf("server: error while accepting connection: %v", err)
return
}
defer recoverAndLog(c, &s.wg)
c.MiddlewareFunc(s.middleware...)
log.Printf("server: client connected %v: %v", c.ID, ws.RemoteAddr())
s.conns.Set(... | go | {
"resource": ""
} |
q174272 | SafeCreateS3Bucket | validation | func SafeCreateS3Bucket(domain, bucket, accessKey, secretKey string) (*S3Bucket, error) {
s := &S3Bucket{
Bucket: bucket,
Name: "s3",
Domain: domain,
AccessKey: accessKey,
SecretKey: secretKey,
}
if s.Bucket == "" {
return nil, errors.New("bucket name is undefined")
}
var k s3gof3r.Keys
var... | go | {
"resource": ""
} |
q174273 | NewWriter | validation | func (s *S3Bucket) NewWriter(path string) (io.WriteCloser, error) {
return s.bucket.PutWriter(path, nil, nil)
} | go | {
"resource": ""
} |
q174274 | NewReader | validation | func (s *S3Bucket) NewReader(path string) (io.ReadCloser, error) {
r, _, err := s.bucket.GetReader(path, nil)
return r, err
} | go | {
"resource": ""
} |
q174275 | Delete | validation | func (s *S3Bucket) Delete(path string) error {
return s.bucket.Delete(path)
} | go | {
"resource": ""
} |
q174276 | CertAtuh | validation | func CertAtuh(ctx *neptulon.ReqCtx) error {
if _, ok := ctx.Session.GetOk("userid"); ok {
return ctx.Next()
}
// if provided, client certificate is verified by the TLS listener so the peerCerts list in the connection is trusted
// connState, _ := ctx.Conn.ConnectionState()
// certs := connState.PeerCertificates... | go | {
"resource": ""
} |
q174277 | Params | validation | func (ctx *ReqCtx) Params(v interface{}) error {
if ctx.params == nil {
return errors.New("ctx: request did not have any request parameters")
}
if err := json.Unmarshal(ctx.params, v); err != nil {
return fmt.Errorf("ctx: cannot deserialize request params: %v", err)
}
return nil
} | go | {
"resource": ""
} |
q174278 | Next | validation | func (ctx *ReqCtx) Next() error {
ctx.mwIndex++
// call next middleware in the stack, if any
if ctx.mwIndex <= len(ctx.mw) {
return ctx.mw[ctx.mwIndex-1](ctx)
}
return nil
} | go | {
"resource": ""
} |
q174279 | Result | validation | func (ctx *ResCtx) Result(v interface{}) error {
if !ctx.Success {
return errors.New("ctx: cannot read result data since server returned an error")
}
if ctx.result == nil {
return errors.New("ctx: server did not return any response data")
}
if err := json.Unmarshal(ctx.result, v); err != nil {
return fmt.Er... | go | {
"resource": ""
} |
q174280 | ErrorData | validation | func (ctx *ResCtx) ErrorData(v interface{}) error {
if ctx.Success {
return errors.New("ctx: cannot read error data since server returned a success response")
}
if ctx.errorData == nil {
return errors.New("ctx: server did not return any error data")
}
if err := json.Unmarshal(ctx.errorData, v); err != nil {
... | go | {
"resource": ""
} |
q174281 | MiddlewareList | validation | func MiddlewareList(middlware []Middleware) Middleware {
return Middleware(func(next Handler) Handler {
for _, m := range middlware {
next = m(next)
}
return next
})
} | go | {
"resource": ""
} |
q174282 | LogFactory | validation | func LogFactory(name string, logType LogType, writer io.Writer) Logger {
log := &logger{Name: name, LogLevel: minLogLevel, Writer: writer}
if logType == Lager {
return NewLager(log)
}
return NewLager(log)
} | go | {
"resource": ""
} |
q174283 | NewRouter | validation | func NewRouter() *Router {
return &Router{routes: make(map[string]func(ctx *neptulon.ReqCtx) error)}
} | go | {
"resource": ""
} |
q174284 | Request | validation | func (r *Router) Request(route string, handler func(ctx *neptulon.ReqCtx) error) {
r.routes[route] = handler
} | go | {
"resource": ""
} |
q174285 | Middleware | validation | func (r *Router) Middleware(ctx *neptulon.ReqCtx) error {
if handler, ok := r.routes[ctx.Method]; ok {
return handler(ctx)
}
return ctx.Next()
} | go | {
"resource": ""
} |
q174286 | NotFound | validation | func NotFound(ctx context.Context, w http.ResponseWriter, r *http.Request) {
http.NotFound(w, r)
} | go | {
"resource": ""
} |
q174287 | NewMysqlDump | validation | func NewMysqlDump(ip, username, password string) *MysqlDump {
lo.G.Debug("setting up a new local mysqldump object")
m := &MysqlDump{
IP: ip,
Username: username,
Password: password,
Caller: command.NewLocalExecuter(),
}
return m
} | go | {
"resource": ""
} |
q174288 | NewRemoteMysqlDump | validation | func NewRemoteMysqlDump(username, password string, sshCfg command.SshConfig) (*MysqlDump, error) {
return NewRemoteMysqlDumpWithPath(username, password, sshCfg, "")
} | go | {
"resource": ""
} |
q174289 | Import | validation | func (s *MysqlDump) Import(lfile io.Reader) (err error) {
if err = s.RemoteOps.UploadFile(lfile); err != nil {
return err
}
err = s.restore()
lo.G.Debug("mysqldump Import called: ", err)
if err != nil {
return
}
err = s.RemoteOps.RemoveRemoteFile()
lo.G.Debug("mysqldump remove remote file called: ", err... | go | {
"resource": ""
} |
q174290 | Dump | validation | func (s *MysqlDump) Dump(dest io.Writer) (err error) {
err = s.Caller.Execute(dest, s.getDumpCommand())
lo.G.Debug("mysqldump command called")
return
} | go | {
"resource": ""
} |
q174291 | NewRemoteExecutor | validation | func NewRemoteExecutor(sshCfg SshConfig) (executor Executer, err error) {
clientconfig := &ssh.ClientConfig{
User: sshCfg.Username,
Auth: sshCfg.GetAuthMethod(),
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
}
remoteExecutor := &DefaultRemoteExecutor{}
remoteExecutor.LazyClientDial = fun... | go | {
"resource": ""
} |
q174292 | Execute | validation | func (executor *DefaultRemoteExecutor) Execute(dest io.Writer, command string) (err error) {
var session SSHSession
var stdoutReader io.Reader
if executor.once.Do(executor.LazyClientDial); executor.Client != nil {
session, err = executor.Client.NewSession()
defer session.Close()
if err != nil {
return
}
... | go | {
"resource": ""
} |
q174293 | World | validation | func (h *Hello) World(ctx context.Context, w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello World!"))
} | go | {
"resource": ""
} |
q174294 | Name | validation | func (h *Hello) Name(ctx context.Context, w http.ResponseWriter, r *http.Request) {
name := scaffold.GetParam(ctx, "name")
msg := fmt.Sprintf("Hello %s!", name)
w.Write([]byte(msg))
} | go | {
"resource": ""
} |
q174295 | NewPgDump | validation | func NewPgDump(ip string, port int, database, username, password string) *PgDump {
return &PgDump{
IP: ip,
Port: port,
Database: database,
Username: username,
Password: password,
Caller: command.NewLocalExecuter(),
RecreateOnRestore: false... | go | {
"resource": ""
} |
q174296 | NewPgRemoteDump | validation | func NewPgRemoteDump(port int, database, username, password string, sshCfg command.SshConfig) (*PgDump, error) {
return NewPgRemoteDumpWithPath(port, database, username, password, sshCfg, "")
} | go | {
"resource": ""
} |
q174297 | Import | validation | func (s *PgDump) Import(lfile io.Reader) (err error) {
lo.G.Debug("pgdump Import being called")
if err = s.RemoteOps.UploadFile(lfile); err == nil {
err = s.restore()
}
return
} | go | {
"resource": ""
} |
q174298 | New | validation | func New(s string) *IrcText {
return &IrcText{text: s, bgColor: None, fgColor: None}
} | go | {
"resource": ""
} |
q174299 | SetFg | validation | func (i *IrcText) SetFg(c int) *IrcText {
i.fgColor = c
return i
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.