_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q174400 | Options | validation | func (c *Config) Options(section string) []string {
var options []string
for _, sect := range c.sections {
if sect.name == section {
for _, opt := range sect.options {
options = append(options, opt.name)
}
break
}
}
return options
} | go | {
"resource": ""
} |
q174401 | OptionMap | validation | func (c *Config) OptionMap(section string) map[string]string {
options := make(map[string]string)
for _, sect := range c.sections {
if sect.name == section {
for _, opt := range sect.options {
options[opt.name] = opt.value
}
break
}
}
return options
} | go | {
"resource": ""
} |
q174402 | Comments | validation | func (c *Config) Comments(section string) []string {
if section == "" {
return c.comments
}
for _, sect := range c.sections {
if sect.name == section {
return sect.comments
}
}
return nil
} | go | {
"resource": ""
} |
q174403 | AddComment | validation | func (c *Config) AddComment(sect, comment string) {
if sect == "" {
c.comments = append(c.comments, comment)
return
}
for i, s := range c.sections {
if s.name == sect {
c.sections[i].comments = append(s.comments, comment)
return
}
}
c.sections = append(c.sections, section{
name: sect,
comme... | go | {
"resource": ""
} |
q174404 | Parse | validation | func Parse(stream io.Reader) Config {
var cfg Config
var curSection string
scanner := bufio.NewScanner(bufio.NewReader(stream))
for scanner.Scan() {
line := strings.TrimSpace(scanner.Text())
if strings.HasPrefix(line, "#") || strings.HasPrefix(line, ";") {
comment := strings.TrimLeft(line, ";# ")
cfg.Add... | go | {
"resource": ""
} |
q174405 | Write | validation | func (c *Config) Write(out io.Writer) error {
for _, cmt := range c.comments {
fmt.Fprintln(out, "; "+cmt)
}
if len(c.comments) > 0 {
fmt.Fprintln(out)
}
for _, sect := range c.sections {
fmt.Fprintf(out, "[%s]\n", sect.name)
for _, cmt := range sect.comments {
fmt.Fprintln(out, "; "+cmt)
}
for _, ... | go | {
"resource": ""
} |
q174406 | Get | validation | func (c *Config) Get(section, key string) string {
for _, sect := range c.sections {
if sect.name == section {
for _, opt := range sect.options {
if opt.name == key {
return opt.value
}
}
return ""
}
}
return ""
} | go | {
"resource": ""
} |
q174407 | Set | validation | func (c *Config) Set(sectionName, key, value string) {
for i, sect := range c.sections {
if sect.name == sectionName {
for j, opt := range sect.options {
if opt.name == key {
c.sections[i].options[j].value = value
return
}
}
c.sections[i].options = append(sect.options, option{key, value})
... | go | {
"resource": ""
} |
q174408 | Delete | validation | func (c *Config) Delete(section, key string) {
for sn, sect := range c.sections {
if sect.name == section {
for i, opt := range sect.options {
if opt.name == key {
c.sections[sn].options = append(sect.options[:i], sect.options[i+1:]...)
return
}
}
return
}
}
} | go | {
"resource": ""
} |
q174409 | Convert | validation | func Convert(val interface{}, targetType reflect.Type) reflect.Value {
value := reflect.ValueOf(val)
if !value.IsValid() {
return reflect.Zero(targetType)
}
valType := value.Type()
if valType.ConvertibleTo(targetType) {
return value.Convert(targetType)
}
//fmt.Printf("Value type is %v, emptyInterfaceType i... | go | {
"resource": ""
} |
q174410 | Postpone | validation | func (i *cacheItem) Postpone() {
i.expireAt = time.Now().Add(i.lifetime)
} | go | {
"resource": ""
} |
q174411 | Filter | validation | func Filter(l LogBackend, r Ruler) LogBackend {
return &filter{
LogBackend: l,
r: r,
}
} | go | {
"resource": ""
} |
q174412 | Op | validation | func Op(o Operation, field string, vleft ...interface{}) Ruler {
if len(vleft) > 1 {
panic("Op accept only zero or one val")
}
var val reflect.Value
if len(vleft) == 1 {
val = reflect.Indirect(reflect.ValueOf(vleft[0]))
if val.IsValid() && val.Kind() == reflect.Interface {
val = val.Elem()
}
}
return &... | go | {
"resource": ""
} |
q174413 | ApplyRuleIf | validation | func ApplyRuleIf(condition, rule Ruler) Ruler {
return &apply{
condition: condition,
rule: rule,
}
} | go | {
"resource": ""
} |
q174414 | ApplyRuleIfElse | validation | func ApplyRuleIfElse(condition, rule, el Ruler) Ruler {
return &applyelse{
condition: condition,
rule: rule,
el: el,
}
} | go | {
"resource": ""
} |
q174415 | AuthHandler | validation | func (self HttpBasicAuthenticator) AuthHandler(next http.Handler) http.Handler {
if self.HttpAuthenticable == nil {
panic("HttpAuthenticable cannot be nil")
}
f := func(w http.ResponseWriter, r *http.Request) {
user, secret := self.parseAuthHeader(r.Header.Get("Authorization"))
if len(user) > 0 &&
len(secr... | go | {
"resource": ""
} |
q174416 | HasBin | validation | func (s *Docker) HasBin() bool {
_, err := exec.LookPath(s.binCmd)
return err == nil
} | go | {
"resource": ""
} |
q174417 | Run | validation | func (s *Docker) Run(cmd string, args ...string) (string, error) {
cmdArgs := make([]string, 0, len(args)+1)
cmdArgs = append(cmdArgs, cmd)
cmdArgs = append(cmdArgs, args...)
exe := exec.Command(s.binCmd, cmdArgs...)
var stdout, stderr bytes.Buffer
exe.Stdout, exe.Stderr = &stdout, &stderr
if err := exe.Run();... | go | {
"resource": ""
} |
q174418 | GetReader | validation | func (s *HttpHeader) GetReader(h http.Header) *HttpHeader {
s.Value = h.Get(s.Name)
return s
} | go | {
"resource": ""
} |
q174419 | SetName | validation | func (s *HttpHeader) SetName(name string) *HttpHeader {
s.Name = name
return s
} | go | {
"resource": ""
} |
q174420 | SetValue | validation | func (s *HttpHeader) SetValue(value string) *HttpHeader {
s.Value = value
return s
} | go | {
"resource": ""
} |
q174421 | SetWriter | validation | func (s *HttpHeader) SetWriter(h http.Header) *HttpHeader {
h.Set(s.Name, s.Value)
return s
} | go | {
"resource": ""
} |
q174422 | encryptionKey | validation | func (e *Entity) encryptionKey(now time.Time) (Key, bool) {
candidateSubkey := -1
for i, subkey := range e.Subkeys {
if subkey.Sig.FlagsValid &&
subkey.Sig.FlagEncryptCommunications &&
subkey.PublicKey.PubKeyAlgo.CanEncrypt() &&
!subkey.Sig.KeyExpired(now) {
candidateSubkey = i
break
}
}
if can... | go | {
"resource": ""
} |
q174423 | NewContentNegotiator | validation | func NewContentNegotiator(defaultEncoder Encoder, responseWriter http.ResponseWriter) *ContentNegotiator {
result := &ContentNegotiator{}
result.DefaultEncoder = defaultEncoder
result.ResponseWriter = responseWriter
return result
} | go | {
"resource": ""
} |
q174424 | NewJsonXmlContentNegotiator | validation | func NewJsonXmlContentNegotiator(defaultEncoder Encoder, responseWriter http.ResponseWriter, prettyPrint bool) *ContentNegotiator {
result := NewContentNegotiator(defaultEncoder, responseWriter)
result.AddEncoder(MimeJSON, JsonEncoder{prettyPrint})
result.AddEncoder(MimeXML, XmlEncoder{prettyPrint})
return result
} | go | {
"resource": ""
} |
q174425 | Negotiate | validation | func (cn *ContentNegotiator) Negotiate(req *http.Request, data interface{}) ([]byte, error) {
if len(cn.encoderMap) <= 0 {
panic("No Encoders present. Please add them using ContentNegotiator.AddEncoder()")
}
var e = cn.getEncoder(req)
cn.ResponseWriter.Header().Set("Content-Type", e.ContentType())
return e.Encod... | go | {
"resource": ""
} |
q174426 | AddEncoder | validation | func (cn *ContentNegotiator) AddEncoder(mimeType string, enc Encoder) {
if cn.encoderMap == nil {
cn.encoderMap = make(map[string]Encoder)
}
cn.encoderMap[mimeType] = enc
} | go | {
"resource": ""
} |
q174427 | getEncoder | validation | func (cn *ContentNegotiator) getEncoder(req *http.Request) Encoder {
var result = cn.DefaultEncoder
accept := req.Header.Get("Accept")
for k, v := range cn.encoderMap {
if strings.Contains(accept, k) {
result = v
break
}
}
return result
} | go | {
"resource": ""
} |
q174428 | CanSign | validation | func (pka PublicKeyAlgorithm) CanSign() bool {
switch pka {
case PubKeyAlgoRSA, PubKeyAlgoRSASignOnly, PubKeyAlgoDSA:
return true
}
return false
} | go | {
"resource": ""
} |
q174429 | ByWinnings | validation | func (s PlayerStandings) ByWinnings(oldTieBreak bool) {
if oldTieBreak {
sort.Sort(sort.Reverse(ByWinningsOld{s}))
} else {
sort.Sort(sort.Reverse(ByWinnings{s}))
}
} | go | {
"resource": ""
} |
q174430 | WaitFunc | validation | func WaitFunc(interval, timeout time.Duration, f func() bool) bool {
after := time.After(timeout)
for {
select {
case <-time.After(interval):
if f() {
return true
}
case <-after:
return false
}
}
return false
} | go | {
"resource": ""
} |
q174431 | FormatDialAddress | validation | func (s NetworkNode) FormatDialAddress() string {
return fmt.Sprintf("%s:%d", s.IpAddress, s.Port)
} | go | {
"resource": ""
} |
q174432 | SetFromDocker | validation | func (s *NetworkNode) SetFromDocker(port string) error {
split := strings.Split(port, "/")
iPort, err := strconv.ParseUint(split[0], 10, 16)
if err != nil {
return err
}
s.Port, s.Protocol = uint16(iPort), split[1]
return nil
} | go | {
"resource": ""
} |
q174433 | Read | validation | func (s *Random) Read(b []byte) (n int, err error) {
s.mutex.Lock()
defer s.mutex.Unlock()
for i, _ := range b {
b[i] = s.readByte()
}
return len(b), nil
} | go | {
"resource": ""
} |
q174434 | readByte | validation | func (s *Random) readByte() byte {
before := time.Now()
rndDuration := time.Duration(getUInt16FromBytes(s.val))
time.Sleep(DEFAULT_SLEEP_TIME + rndDuration)
diff := time.Now().Sub(before)
n := byte(diff.Nanoseconds())
s.val[s.index] = n
s.index ^= 1
return n
} | go | {
"resource": ""
} |
q174435 | RecoverHandlerJson | validation | func RecoverHandlerJson(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
jerr := NewJsonErrorFromError(
http.StatusInternalServerError, fmt.Errorf("panic: %+v", err))
JsonWrite(w, jerr.Status, jerr)
}
}()
n... | go | {
"resource": ""
} |
q174436 | DefaultServiceConfig | validation | func DefaultServiceConfig() ServiceConfig {
return ServiceConfig{
// Dependencies.
BackoffFactory: func() Backoff {
return &backoff.StopBackOff{}
},
RandFactory: rand.Int,
// Settings.
RandReader: rand.Reader,
Timeout: 1 * time.Second,
}
} | go | {
"resource": ""
} |
q174437 | NewService | validation | func NewService(config ServiceConfig) (Service, error) {
// Dependencies.
if config.BackoffFactory == nil {
return nil, maskAnyf(invalidConfigError, "backoff factory must not be empty")
}
if config.RandFactory == nil {
return nil, maskAnyf(invalidConfigError, "rand factory must not be empty")
}
// Settings.
... | go | {
"resource": ""
} |
q174438 | RunLight | validation | func (s *ImageMongoDB) RunLight(cfg *RunConfig) (*Container, error) {
cfg.AddArgs("--smallfiles", "--nojournal")
return s.Image.Run(cfg)
} | go | {
"resource": ""
} |
q174439 | initConfig | validation | func initConfig() {
if cfgFile != "" { // enable ability to specify config file via flag
viper.SetConfigFile(cfgFile)
}
viper.SetConfigName(".fstack") // name of config file (without extension)
viper.AddConfigPath("$HOME") // adding home directory as first search path
viper.AutomaticEnv() // read in... | go | {
"resource": ""
} |
q174440 | HasExposedPorts | validation | func (s *Container) HasExposedPorts() bool {
nodes, err := s.NetworkNodes()
if err != nil {
return false
}
for _, v := range nodes {
if v.Port > 0 || len(v.Protocol) > 0 {
return true
}
}
return false
} | go | {
"resource": ""
} |
q174441 | Inspect | validation | func (s *Container) Inspect() ([]Inspect, error) {
out, err := s.docker.Run("inspect", s.id)
if err != nil {
return nil, err
}
var list []Inspect
err = json.NewDecoder(strings.NewReader(out)).Decode(&list)
if err != nil {
return nil, UnexpectedOutputError(fmt.Sprintf(
"Error parsing output when inspecting... | go | {
"resource": ""
} |
q174442 | Kill | validation | func (s *Container) Kill() error {
err := exec.Command(s.docker.binCmd, "kill", s.id).Run()
if err != nil {
return err
}
stopped := raiqub.WaitFunc(
250*time.Millisecond, 30*time.Second, func() bool {
inspect, err := s.Inspect()
if err != nil || len(inspect) == 0 {
return true
}
if !inspect[0].... | go | {
"resource": ""
} |
q174443 | NetworkNodes | validation | func (s *Container) NetworkNodes() ([]NetworkNode, error) {
inspect, err := s.Inspect()
if err != nil {
return nil, err
}
if len(inspect) == 0 {
return nil, fmt.Errorf("Container inspect is empty")
}
nodes := make([]NetworkNode, 0)
for _, i := range inspect {
ip := i.NetworkSettings.IPAddress
if ip == ... | go | {
"resource": ""
} |
q174444 | Remove | validation | func (s *Container) Remove() error {
return exec.Command(s.docker.binCmd, "rm", s.id).Run()
} | go | {
"resource": ""
} |
q174445 | WaitStartup | validation | func (s *Container) WaitStartup(timeout time.Duration) error {
nodes, err := s.NetworkNodes()
if err != nil {
return fmt.Errorf("Error getting network nodes: %v", err)
}
if !s.HasExposedPorts() {
return fmt.Errorf("Current container has no exposed ports")
}
ok := raiqub.WaitPeerListening(
nodes[0].Protoco... | go | {
"resource": ""
} |
q174446 | NewHandler | validation | func NewHandler(counter *Counter, level logging.Level) (h *Handler) {
return &Handler{
Counter: counter,
Level: level,
}
} | go | {
"resource": ""
} |
q174447 | Handle | validation | func (h *Handler) Handle(record *logging.Record) error {
switch record.Level {
case logging.EMERGENCY:
h.Counter.emergencyCounter.Inc()
case logging.ALERT:
h.Counter.alertCounter.Inc()
case logging.CRITICAL:
h.Counter.criticalCounter.Inc()
case logging.ERROR:
h.Counter.errorCounter.Inc()
case logging.WARN... | go | {
"resource": ""
} |
q174448 | NewCounter | validation | func NewCounter(options *CounterOptions) (c *Counter) {
if options == nil {
options = new(CounterOptions)
}
if options.Name == "" {
options.Name = "logging_messages_total"
}
if options.Help == "" {
options.Help = "Number of log messages processed, partitioned by log level."
}
vector := prometheus.NewCounte... | go | {
"resource": ""
} |
q174449 | Metrics | validation | func (c *Counter) Metrics() (cs []prometheus.Collector) {
return []prometheus.Collector{c.vector}
} | go | {
"resource": ""
} |
q174450 | Retrieve | validation | func Retrieve(sources []*Source) (http.FileSystem, error) {
files := make(mfs.Files)
for i, source := range sources {
log.Printf("Processing asset source (%d/%d): %s ...", i+1, len(sources), source.Location)
// Retrieve the file or files
retFiles, err := retrieve(source.Location)
if err != nil {
return n... | go | {
"resource": ""
} |
q174451 | Compile | validation | func Compile(sources []*Source, filePath string, pkgName string, varName string, opts *Opts) error {
fs, err := Retrieve(sources)
if err != nil {
return err
}
if opts == nil {
opts = &Opts{}
}
if opts.VariableComment == "" {
opts.VariableComment = fmt.Sprintf("%s implements a http.FileSystem.", varName)
... | go | {
"resource": ""
} |
q174452 | readBlockAt | validation | func readBlockAt(reader io.ReadSeeker, offset int64) (fileBlock, error) {
var block fileBlock
_, err := reader.Seek(offset, os.SEEK_SET)
if err != nil {
return block, err
}
return block, binary.Read(reader, binary.LittleEndian, &block)
} | go | {
"resource": ""
} |
q174453 | writeTo | validation | func (fb *fileBlock) writeTo(writer io.WriteSeeker, offset int64) error {
_, err := writer.Seek(offset, os.SEEK_SET)
if err != nil {
return err
}
return binary.Write(writer, binary.LittleEndian, *fb)
} | go | {
"resource": ""
} |
q174454 | Push | validation | func (s *Stack) Push(header, data []byte) (depth int, err error) {
s.guard.Lock()
defer s.guard.Unlock()
s.lastAccess = time.Now()
file, err := s.getFile()
if err != nil {
return -1, err
}
// Seek to place for next block
currentOffset, err := file.Seek(s.currentBlock.NextBlockPoint(), os.SEEK_SET)
if err != ... | go | {
"resource": ""
} |
q174455 | Pop | validation | func (s *Stack) Pop() (header, data []byte, err error) {
if s.depth == 0 {
return nil, nil, nil
}
s.guard.Lock()
defer s.guard.Unlock()
s.lastAccess = time.Now()
file, err := s.getFile()
if err != nil {
return nil, nil, err
}
data = make([]byte, s.currentBlock.DataSize)
header = make([]byte, s.currentBloc... | go | {
"resource": ""
} |
q174456 | Peak | validation | func (s *Stack) Peak() (header, data []byte, err error) {
if s.depth == 0 {
return nil, nil, nil
}
s.guard.Lock()
defer s.guard.Unlock()
s.lastAccess = time.Now()
file, err := s.getFile()
if err != nil {
return nil, nil, err
}
data = make([]byte, s.currentBlock.DataSize)
header = make([]byte, s.currentBlo... | go | {
"resource": ""
} |
q174457 | PeakHeader | validation | func (s *Stack) PeakHeader() (header []byte, err error) {
if s.depth == 0 {
return nil, nil
}
s.guard.Lock()
defer s.guard.Unlock()
s.lastAccess = time.Now()
file, err := s.getFile()
if err != nil {
return nil, err
}
header = make([]byte, s.currentBlock.HeaderSize)
// Read header
_, err = file.ReadAt(hea... | go | {
"resource": ""
} |
q174458 | IterateBackward | validation | func (s *Stack) IterateBackward(handler func(depth int, header io.Reader, body io.Reader) bool) error {
s.guard.Lock()
defer s.guard.Unlock()
if s.depth == 0 {
return nil
}
file, err := s.getFile()
if err != nil {
return err
}
defer file.Seek(0, os.SEEK_END)
var (
currentBlock fileBlock // Current ... | go | {
"resource": ""
} |
q174459 | IterateForward | validation | func (s *Stack) IterateForward(handler func(depth int, header io.Reader, body io.Reader) bool) error {
// This operation does not relies on depth counter, so can be used for repare
s.guard.Lock()
defer s.guard.Unlock()
s.lastAccess = time.Now()
file, err := s.getFile()
if err != nil {
return err
}
//Get file ... | go | {
"resource": ""
} |
q174460 | Close | validation | func (s *Stack) Close() error {
s.guard.Lock()
defer s.guard.Unlock()
if s.file != nil {
err := s.file.Close()
s.file = nil
return err
}
return nil
} | go | {
"resource": ""
} |
q174461 | OpenStack | validation | func OpenStack(filename string) (*Stack, error) {
file, err := os.OpenFile(filename, os.O_CREATE|os.O_RDWR, 0755)
if err != nil {
return nil, err
}
return NewStack(file)
} | go | {
"resource": ""
} |
q174462 | NewStack | validation | func NewStack(file *os.File) (*Stack, error) {
stack := &Stack{file: file, fileName: file.Name()}
err := stack.Repare()
if err != nil {
stack.Close()
return nil, err
}
return stack, nil
} | go | {
"resource": ""
} |
q174463 | NewSessionCache | validation | func NewSessionCache(d time.Duration, salt string) *SessionCache {
return &SessionCache{
cache: data.NewCache(d),
salter: crypt.NewSalter(
crypt.NewRandomSourceListSecure(), []byte(salt)),
}
} | go | {
"resource": ""
} |
q174464 | getInvalidTokenError | validation | func (s *SessionCache) getInvalidTokenError(token string) error {
return errors.New(fmt.Sprintf(
"The requested token '%s' is invalid or is expired", token))
} | go | {
"resource": ""
} |
q174465 | Get | validation | func (s *SessionCache) Get(token string) (interface{}, error) {
v, err := s.cache.Get(token)
if err != nil {
return nil, s.getInvalidTokenError(token)
}
return v, err
} | go | {
"resource": ""
} |
q174466 | Add | validation | func (s *SessionCache) Add() string {
strSum := s.salter.DefaultToken()
err := s.cache.Add(strSum, nil)
if err != nil {
panic("Something is seriously wrong, a duplicated token was generated")
}
return strSum
} | go | {
"resource": ""
} |
q174467 | Delete | validation | func (s *SessionCache) Delete(token string) error {
err := s.cache.Delete(token)
if err != nil {
return s.getInvalidTokenError(token)
}
return nil
} | go | {
"resource": ""
} |
q174468 | Set | validation | func (s *SessionCache) Set(token string, value interface{}) error {
err := s.cache.Set(token, value)
if err != nil {
return s.getInvalidTokenError(token)
}
return nil
} | go | {
"resource": ""
} |
q174469 | NewClient | validation | func NewClient(nick, serverHost string, serverPort uint16) *Client {
return &Client{
nick: nick,
serverHost: serverHost,
serverPort: serverPort,
writeTimeout: 30 * time.Second,
readTimeout: 100 * time.Millisecond,
channels: map[string]struct{}{},
mutex: &sync.Mutex{},
}
} | go | {
"resource": ""
} |
q174470 | connect | validation | func (c *Client) connect() error {
dialer := &net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
}
conn, err := dialer.Dial("tcp", fmt.Sprintf("%s:%d", c.serverHost,
c.serverPort))
if err != nil {
return fmt.Errorf("error dialing: %s", err)
}
c.conn = conn
c.rw = bufio.NewReadWriter(... | go | {
"resource": ""
} |
q174471 | writeMessage | validation | func (c Client) writeMessage(m irc.Message) error {
buf, err := m.Encode()
if err != nil && err != irc.ErrTruncated {
return fmt.Errorf("unable to encode message: %s", err)
}
if err := c.conn.SetWriteDeadline(time.Now().Add(
c.writeTimeout)); err != nil {
return fmt.Errorf("unable to set deadline: %s", err)
... | go | {
"resource": ""
} |
q174472 | readMessage | validation | func (c Client) readMessage() (irc.Message, error) {
if err := c.conn.SetReadDeadline(time.Now().Add(c.readTimeout)); err != nil {
return irc.Message{}, fmt.Errorf("unable to set deadline: %s", err)
}
line, err := c.rw.ReadString('\n')
if err != nil {
return irc.Message{}, err
}
log.Printf("client %s: read:... | go | {
"resource": ""
} |
q174473 | Stop | validation | func (c *Client) Stop() {
// Tell reader and writer to end.
close(c.doneChan)
// We won't be sending anything further to writer. Let it clean up.
close(c.sendChan)
// Wait for reader and writer to end.
c.wg.Wait()
// We know the reader and writer won't be sending on the error channel any
// more.
close(c.er... | go | {
"resource": ""
} |
q174474 | GetChannels | validation | func (c Client) GetChannels() []string {
var channels []string
c.mutex.Lock()
for k := range c.channels {
channels = append(channels, k)
}
c.mutex.Unlock()
return channels
} | go | {
"resource": ""
} |
q174475 | JsonWrite | validation | func JsonWrite(w http.ResponseWriter, status int, content interface{}) {
HttpHeader_ContentType_Json().SetWriter(w.Header())
w.WriteHeader(status)
if content != nil {
json.NewEncoder(w).Encode(content)
}
} | go | {
"resource": ""
} |
q174476 | JsonRead | validation | func JsonRead(body io.ReadCloser, obj interface{}, w http.ResponseWriter) bool {
content, err := ioutil.ReadAll(io.LimitReader(body, HTTP_BODY_MAX_LENGTH))
if err != nil {
jerr := NewJsonErrorFromError(http.StatusInternalServerError, err)
JsonWrite(w, jerr.Status, jerr)
return false
}
if err := body.Close();... | go | {
"resource": ""
} |
q174477 | VerifyKeySignature | validation | func (pk *PublicKey) VerifyKeySignature(signed *PublicKey, sig *Signature) (err error) {
h, err := keySignatureHash(pk, signed, sig.Hash)
if err != nil {
return err
}
return pk.VerifySignature(h, sig)
} | go | {
"resource": ""
} |
q174478 | NewUser | validation | func NewUser(player uuid.UUID, userdata *User) (*User, error) {
p, err := storage.Load(player)
if err != nil {
return nil, err
}
p.User = *userdata
//fmt.Println("Creating user:")
//fmt.Printf("%v", p.User)
err = storage.Store(p)
if err != nil {
return nil,
errors.New(err.Error() + " - Could not write us... | go | {
"resource": ""
} |
q174479 | Next | validation | func (c *Context) Next(w http.ResponseWriter, r *http.Request) {
if c.route == nil {
return
}
if next := c.route.next; next != nil {
c.route = next
next.ServeHTTPContext(w, r, c)
} else {
c.holdUp = true
}
} | go | {
"resource": ""
} |
q174480 | ServeHTTP | validation | func (route *Route) ServeHTTP(w http.ResponseWriter, r *http.Request) {
c := &Context{route: route}
route.ServeHTTPContext(w, r, c)
} | go | {
"resource": ""
} |
q174481 | UseHandler | validation | func (r *Route) UseHandler(h Handler) {
if r.f == nil {
r.f = h
return
}
route := r.getLeaf()
route.next = &Route{f: h}
} | go | {
"resource": ""
} |
q174482 | HandleMethod | validation | func (r *Route) HandleMethod(pat, method string, f ...HandlerFunc) {
entry := r.addPattern(pat)
batch := batchRoute(f)
if err := entry.SetMethodHandler(method, batch); err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q174483 | Handle | validation | func (r *Route) Handle(pat string, f ...HandlerFunc) {
entry := r.addPattern(pat)
batch := batchRoute(f)
if err := entry.SetHandler(batch); err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q174484 | Get | validation | func (r *Route) Get(pat string, f ...HandlerFunc) {
r.HandleMethod(pat, "GET", f...)
r.HandleMethod(pat, "HEAD", f...)
} | go | {
"resource": ""
} |
q174485 | Post | validation | func (r *Route) Post(pat string, f ...HandlerFunc) {
r.HandleMethod(pat, "POST", f...)
} | go | {
"resource": ""
} |
q174486 | Put | validation | func (r *Route) Put(pat string, f ...HandlerFunc) {
r.HandleMethod(pat, "PUT", f...)
} | go | {
"resource": ""
} |
q174487 | Patch | validation | func (r *Route) Patch(pat string, f ...HandlerFunc) {
r.HandleMethod(pat, "PATCH", f...)
} | go | {
"resource": ""
} |
q174488 | Delete | validation | func (r *Route) Delete(pat string, f ...HandlerFunc) {
r.HandleMethod(pat, "DELETE", f...)
} | go | {
"resource": ""
} |
q174489 | Options | validation | func (r *Route) Options(pat string, f ...HandlerFunc) {
r.HandleMethod(pat, "OPTIONS", f...)
} | go | {
"resource": ""
} |
q174490 | NewSalter | validation | func NewSalter(sources RandomSourceList, input []byte) *Salter {
if input == nil {
input = []byte("")
}
hash := sha256.New()
hash.Write(input)
sum := 0
for _, v := range sources {
sum += v.Weight
}
return &Salter{
salt: hash.Sum(nil),
rndSources: sources,
sumWeight: sum,
}
} | go | {
"resource": ""
} |
q174491 | BToken | validation | func (self *Salter) BToken(size int) []byte {
mac := hmac.New(sha256.New, self.salt)
for _, v := range self.rndSources {
itemSize := float32(size) * (float32(v.Weight) / float32(self.sumWeight))
mac.Write(getRandomBytes(v.Reader, int(itemSize)))
}
macSum := mac.Sum(nil)
self.salt = macSum
return macSum
} | go | {
"resource": ""
} |
q174492 | Token | validation | func (self *Salter) Token(size int) string {
return base64.URLEncoding.EncodeToString(self.BToken(size))
} | go | {
"resource": ""
} |
q174493 | getRandomBytes | validation | func getRandomBytes(r io.Reader, n int) []byte {
b := make([]byte, n)
_, err := r.Read(b)
if err != nil {
panic("Could not access secure random generator")
}
return b
} | go | {
"resource": ""
} |
q174494 | NewNewsItem | validation | func NewNewsItem(itemdata NewsItem, author uuid.UUID) (*NewsItem, error) {
c := new(NewsItem)
if err := mergo.MergeWithOverwrite(c, itemdata); err != nil {
return nil, errors.New(err.Error() + " - Could not set initial NewsItem data")
}
c.UUID, _ = uuid.V4()
c.Author = author
c.Created = time.Now()
if err := s... | go | {
"resource": ""
} |
q174495 | Write | validation | func (lw DebugLogWriter) Write(p []byte) (int, error) {
lw.Debug(string(bytes.TrimRightFunc(p, unicode.IsSpace)))
return len(p), nil
} | go | {
"resource": ""
} |
q174496 | Write | validation | func (lw InfoLogWriter) Write(p []byte) (int, error) {
lw.Info(string(bytes.TrimRightFunc(p, unicode.IsSpace)))
return len(p), nil
} | go | {
"resource": ""
} |
q174497 | Write | validation | func (lw WarningLogWriter) Write(p []byte) (int, error) {
lw.Warning(string(bytes.TrimRightFunc(p, unicode.IsSpace)))
return len(p), nil
} | go | {
"resource": ""
} |
q174498 | Write | validation | func (lw ErrorLogWriter) Write(p []byte) (int, error) {
lw.Error(string(bytes.TrimRightFunc(p, unicode.IsSpace)))
return len(p), nil
} | go | {
"resource": ""
} |
q174499 | GetLogger | validation | func GetLogger(name string) (*Logger, error) {
if name == "default" {
return getDefaultLogger(), nil
}
lock.RLock()
logger, ok := loggers[name]
lock.RUnlock()
if !ok {
return nil, fmt.Errorf("unknown logger %s", name)
}
return logger, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.