_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q16000 | DefaultOptions | train | func DefaultOptions() EncoderOptions {
opt := EncoderOptions{}
opt.Eol = "\n"
opt.BracesSameLine = false
opt.EmitRootBraces = true
opt.QuoteAlways = false
opt.IndentBy = " "
opt.AllowMinusZero = false
opt.UnknownAsNull = false
return opt
} | go | {
"resource": ""
} |
q16001 | Unmarshal | train | func Unmarshal(data []byte, v interface{}) (err error) {
var value interface{}
parser := &hjsonParser{data, 0, ' '}
parser.resetAt()
value, err = parser.rootValue()
if err != nil {
return err
}
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Ptr || rv.IsNil() {
return errors.New("non-pointer " + reflect.TypeOf(v).String())
}
for rv.Kind() == reflect.Ptr {
rv = rv.Elem()
}
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
rv.Set(reflect.ValueOf(value))
return err
} | go | {
"resource": ""
} |
q16002 | Sprint | train | func (cfg *Config) Sprint(vals ...interface{}) string {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.String()
} | go | {
"resource": ""
} |
q16003 | Fprint | train | func Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
return DefaultConfig.Fprint(w, vals...)
} | go | {
"resource": ""
} |
q16004 | Fprint | train | func (cfg *Config) Fprint(w io.Writer, vals ...interface{}) (n int64, err error) {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.WriteTo(w)
} | go | {
"resource": ""
} |
q16005 | Compare | train | func (cfg *Config) Compare(a, b interface{}) string {
diffCfg := *cfg
diffCfg.Diffable = true
return diff.Diff(cfg.Sprint(a), cfg.Sprint(b))
} | go | {
"resource": ""
} |
q16006 | Diff | train | func Diff(A, B string) string {
aLines := strings.Split(A, "\n")
bLines := strings.Split(B, "\n")
chunks := DiffChunks(aLines, bLines)
buf := new(bytes.Buffer)
for _, c := range chunks {
for _, line := range c.Added {
fmt.Fprintf(buf, "+%s\n", line)
}
for _, line := range c.Deleted {
fmt.Fprintf(buf, "-%s\n", line)
}
for _, line := range c.Equal {
fmt.Fprintf(buf, " %s\n", line)
}
}
return strings.TrimRight(buf.String(), "\n")
} | go | {
"resource": ""
} |
q16007 | ValidatedStatusCode | train | func (f *FailureResponse) ValidatedStatusCode(logger lager.Logger) int {
if f.statusCode < 400 || 600 <= f.statusCode {
if logger != nil {
logger.Error("validating-status-code", fmt.Errorf("Invalid failure http response code: 600, expected 4xx or 5xx, returning internal server error: 500."))
}
return http.StatusInternalServerError
}
return f.statusCode
} | go | {
"resource": ""
} |
q16008 | AppendErrorMessage | train | func (f *FailureResponse) AppendErrorMessage(msg string) *FailureResponse {
return &FailureResponse{
error: errors.New(fmt.Sprintf("%s %s", f.Error(), msg)),
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
} | go | {
"resource": ""
} |
q16009 | NewFailureResponseBuilder | train | func NewFailureResponseBuilder(err error, statusCode int, loggerAction string) *FailureResponseBuilder {
return &FailureResponseBuilder{
error: err,
statusCode: statusCode,
loggerAction: loggerAction,
emptyResponse: false,
}
} | go | {
"resource": ""
} |
q16010 | WithErrorKey | train | func (f *FailureResponseBuilder) WithErrorKey(errorKey string) *FailureResponseBuilder {
f.errorKey = errorKey
return f
} | go | {
"resource": ""
} |
q16011 | Build | train | func (f *FailureResponseBuilder) Build() *FailureResponse {
return &FailureResponse{
error: f.error,
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
} | go | {
"resource": ""
} |
q16012 | DecodeFrame | train | func DecodeFrame(r io.Reader) (frame []byte, err error) {
var size int16
err = binary.Read(r, binary.LittleEndian, &size)
if err != nil {
return
}
if size < 0 {
return nil, ErrNegativeFrameSize
}
frame = make([]byte, size)
err = binary.Read(r, binary.LittleEndian, &frame)
return
} | go | {
"resource": ""
} |
q16013 | NewDecoder | train | func NewDecoder(r io.Reader) *Decoder {
decoder := &Decoder{
r: bufio.NewReader(r),
}
return decoder
} | go | {
"resource": ""
} |
q16014 | ReadMetadata | train | func (d *Decoder) ReadMetadata() error {
if d.firstFrameProcessed {
return ErrNotFirstFrame
}
d.firstFrameProcessed = true
fingerprint, err := d.r.Peek(4)
if err != nil {
return err
}
if string(fingerprint[:3]) != "DCA" {
return ErrNotDCA
}
// We just peeked earlier, mark this portion as read
d.r.Discard(4)
// Read the format version
version, err := strconv.ParseInt(string(fingerprint[3:]), 10, 32)
if err != nil {
return err
}
d.FormatVersion = int(version)
// The length of the metadata
var metaLen int32
err = binary.Read(d.r, binary.LittleEndian, &metaLen)
if err != nil {
return err
}
// Read in the metadata itself
jsonBuf := make([]byte, metaLen)
err = binary.Read(d.r, binary.LittleEndian, &jsonBuf)
if err != nil {
return err
}
// And unmarshal it
var metadata *Metadata
err = json.Unmarshal(jsonBuf, &metadata)
d.Metadata = metadata
return err
} | go | {
"resource": ""
} |
q16015 | OpusFrame | train | func (d *Decoder) OpusFrame() (frame []byte, err error) {
if !d.firstFrameProcessed {
// Check to see if this contains metadata and read the metadata if so
magic, err := d.r.Peek(3)
if err != nil {
return nil, err
}
if string(magic) == "DCA" {
err = d.ReadMetadata()
if err != nil {
return nil, err
}
}
}
frame, err = DecodeFrame(d.r)
return
} | go | {
"resource": ""
} |
q16016 | FrameDuration | train | func (d *Decoder) FrameDuration() time.Duration {
if d.Metadata == nil {
return 20
}
// I don't understand nick, why does it have to be like this nick, please nick, im not having a good time nick.
// 960B = pcm framesize of 20ms 1 channel audio
return time.Duration(((d.Metadata.Opus.FrameSize/d.Metadata.Opus.Channels)/960)*20) * time.Millisecond
} | go | {
"resource": ""
} |
q16017 | PlaybackPosition | train | func (s *StreamingSession) PlaybackPosition() time.Duration {
s.Lock()
dur := time.Duration(s.framesSent) * s.source.FrameDuration()
s.Unlock()
return dur
} | go | {
"resource": ""
} |
q16018 | Finished | train | func (s *StreamingSession) Finished() (bool, error) {
s.Lock()
err := s.err
fin := s.finished
s.Unlock()
return fin, err
} | go | {
"resource": ""
} |
q16019 | Paused | train | func (s *StreamingSession) Paused() bool {
s.Lock()
p := s.paused
s.Unlock()
return p
} | go | {
"resource": ""
} |
q16020 | Validate | train | func (opts *EncodeOptions) Validate() error {
if opts.Volume < 0 || opts.Volume > 512 {
return errors.New("Out of bounds volume (0-512)")
}
if opts.FrameDuration != 20 && opts.FrameDuration != 40 && opts.FrameDuration != 60 {
return errors.New("Invalid FrameDuration")
}
if opts.PacketLoss < 0 || opts.PacketLoss > 100 {
return errors.New("Invalid packet loss percentage")
}
if opts.Application != AudioApplicationAudio && opts.Application != AudioApplicationVoip && opts.Application != AudioApplicationLowDelay {
return errors.New("Invalid audio application")
}
if opts.CompressionLevel < 0 || opts.CompressionLevel > 10 {
return errors.New("Compression level out of bounds (0-10)")
}
if opts.Threads < 0 {
return errors.New("Number of threads can't be less than 0")
}
return nil
} | go | {
"resource": ""
} |
q16021 | EncodeMem | train | func EncodeMem(r io.Reader, options *EncodeOptions) (session *EncodeSession, err error) {
err = options.Validate()
if err != nil {
return
}
session = &EncodeSession{
options: options,
pipeReader: r,
frameChannel: make(chan *Frame, options.BufferedFrames),
}
go session.run()
return
} | go | {
"resource": ""
} |
q16022 | Stop | train | func (e *EncodeSession) Stop() error {
e.Lock()
defer e.Unlock()
if !e.running || e.process == nil {
return errors.New("Not running")
}
err := e.process.Kill()
return err
} | go | {
"resource": ""
} |
q16023 | OpusFrame | train | func (e *EncodeSession) OpusFrame() (frame []byte, err error) {
f := <-e.frameChannel
if f == nil {
return nil, io.EOF
}
if f.metaData {
// Return the next one then...
return e.OpusFrame()
}
if len(f.data) < 2 {
return nil, ErrBadFrame
}
return f.data[2:], nil
} | go | {
"resource": ""
} |
q16024 | Running | train | func (e *EncodeSession) Running() (running bool) {
e.Lock()
running = e.running
e.Unlock()
return
} | go | {
"resource": ""
} |
q16025 | FrameDuration | train | func (e *EncodeSession) FrameDuration() time.Duration {
return time.Duration(e.options.FrameDuration) * time.Millisecond
} | go | {
"resource": ""
} |
q16026 | Error | train | func (e *EncodeSession) Error() error {
e.Lock()
defer e.Unlock()
return e.err
} | go | {
"resource": ""
} |
q16027 | FFMPEGMessages | train | func (e *EncodeSession) FFMPEGMessages() string {
e.Lock()
output := e.ffmpegOutput
e.Unlock()
return output
} | go | {
"resource": ""
} |
q16028 | init | train | func init() {
flag.StringVar(&InFile, "i", "pipe:0", "infile")
flag.IntVar(&Volume, "vol", 256, "change audio volume (256=normal)")
flag.IntVar(&Channels, "ac", 2, "audio channels")
flag.IntVar(&FrameRate, "ar", 48000, "audio sampling rate")
flag.IntVar(&FrameDuration, "as", 20, "audio frame duration can be 20, 40, or 60 (ms)")
flag.IntVar(&Bitrate, "ab", 128, "audio encoding bitrate in kb/s can be 8 - 128")
flag.IntVar(&Threads, "threads", 0, "number of threads to use, 0 for auto")
flag.BoolVar(&VBR, "vbr", true, "variable bitrate")
flag.BoolVar(&RawOutput, "raw", false, "Raw opus output (no metadata or magic bytes)")
flag.StringVar(&Application, "aa", "audio", "audio application can be voip, audio, or lowdelay")
flag.StringVar(&CoverFormat, "cf", "jpeg", "format the cover art will be encoded with")
flag.StringVar(&Comment, "com", "", "leave a comment in the metadata")
flag.BoolVar(&Quiet, "quiet", false, "disable stats output to stderr")
flag.Parse()
} | go | {
"resource": ""
} |
q16029 | main | train | func main() {
//////////////////////////////////////////////////////////////////////////
// BLOCK : Basic setup and validation
//////////////////////////////////////////////////////////////////////////
// If only one argument provided assume it's a filename.
if len(os.Args) == 2 {
InFile = os.Args[1]
}
// If reading from a file, verify it exists.
if InFile != "pipe:0" {
if _, err := os.Stat(InFile); os.IsNotExist(err) {
fmt.Fprintln(os.Stderr, "warning: infile does not exist as a file on this system, will still continue on incase this is something else that ffmpeg accepts")
}
}
// If reading from pipe, make sure pipe is open
if InFile == "pipe:0" {
fi, err := os.Stdin.Stat()
if err != nil {
fmt.Println(err)
return
}
if (fi.Mode() & os.ModeCharDevice) == 0 {
} else {
fmt.Fprintln(os.Stderr, "error: stdin is not a pipe.")
flag.Usage()
return
}
}
if Bitrate < 1 || Bitrate > 512 {
Bitrate = 64 // Set to Discord default
}
//////////////////////////////////////////////////////////////////////////
// BLOCK : Start reader and writer workers
//////////////////////////////////////////////////////////////////////////
options := &dca.EncodeOptions{
Volume: Volume,
Channels: Channels,
FrameRate: FrameRate,
FrameDuration: FrameDuration,
Bitrate: Bitrate,
RawOutput: RawOutput,
Application: dca.AudioApplication(Application),
CoverFormat: CoverFormat,
VBR: VBR,
Comment: Comment,
Threads: Threads,
}
var session *dca.EncodeSession
var output = os.Stdout
if InFile == "pipe:0" {
session, err = dca.EncodeMem(os.Stdin, options)
} else {
session, err = dca.EncodeFile(InFile, options)
}
if err != nil {
fmt.Fprintf(os.Stderr, "Failed creating an encoding session: ", err)
os.Exit(1)
}
if !Quiet {
go statusPrinter(session)
}
_, err := io.Copy(output, session)
if err != nil {
fmt.Fprintln(os.Stderr, "\nError writing:", err)
os.Exit(1)
} else if !Quiet {
fmt.Fprintf(os.Stderr, "\nFinished encoding\n")
fmt.Fprint(os.Stderr, "ffmpeg output\n\n", session.FFMPEGMessages())
}
} | go | {
"resource": ""
} |
q16030 | WithSuitableAuthentication | train | func WithSuitableAuthentication(authenticator *auth.BasicAuth, handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
if !guestAccessAllowed {
//All requests require authentication
requireBasicAuth(authenticator, handler)(w, r)
} else if _, _, basicAuthPresent := r.BasicAuth(); !basicAuthPresent {
//Run the handler as unauthenticated user
confLock.RLock()
_, ok := quota[guestUserName]
confLock.RUnlock()
if !ok {
reply(w, errMsg("Guest access is unavailable"), http.StatusUnauthorized)
} else {
handler(w, r)
}
} else {
//Run the handler using basic authentication
if fileExists(users) {
requireBasicAuth(authenticator, handler)(w, r)
} else {
handler(w, r)
}
}
}
} | go | {
"resource": ""
} |
q16031 | Parse | train | func Parse(b []byte) (u *UUID, err error) {
if len(b) != 16 {
err = errors.New("Given slice is not valid UUID sequence")
return
}
u = new(UUID)
copy(u[:], b)
return
} | go | {
"resource": ""
} |
q16032 | NewV3 | train | func NewV3(ns *UUID, name []byte) (u *UUID, err error) {
if ns == nil {
err = errors.New("Invalid namespace UUID")
return
}
u = new(UUID)
// Set all bits to MD5 hash generated from namespace and name.
u.setBytesFromHash(md5.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(3)
return
} | go | {
"resource": ""
} |
q16033 | NewV4 | train | func NewV4() (u *UUID, err error) {
u = new(UUID)
// Set all bits to randomly (or pseudo-randomly) chosen values.
_, err = rand.Read(u[:])
if err != nil {
return
}
u.setVariant(ReservedRFC4122)
u.setVersion(4)
return
} | go | {
"resource": ""
} |
q16034 | NewV5 | train | func NewV5(ns *UUID, name []byte) (u *UUID, err error) {
u = new(UUID)
// Set all bits to truncated SHA1 hash generated from namespace
// and name.
u.setBytesFromHash(sha1.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(5)
return
} | go | {
"resource": ""
} |
q16035 | setBytesFromHash | train | func (u *UUID) setBytesFromHash(hash hash.Hash, ns, name []byte) {
hash.Write(ns[:])
hash.Write(name)
copy(u[:], hash.Sum([]byte{})[:16])
} | go | {
"resource": ""
} |
q16036 | ListVhosts | train | func (c *Client) ListVhosts() (rec []VhostInfo, err error) {
req, err := newGETRequest(c, "vhosts")
if err != nil {
return []VhostInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []VhostInfo{}, err
}
return rec, nil
} | go | {
"resource": ""
} |
q16037 | PutVhost | train | func (c *Client) PutVhost(vhostname string, settings VhostSettings) (res *http.Response, err error) {
body, err := json.Marshal(settings)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "vhosts/"+PathEscape(vhostname), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | go | {
"resource": ""
} |
q16038 | NewTLSClient | train | func NewTLSClient(uri string, username string, password string, transport http.RoundTripper) (me *Client, err error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
me = &Client{
Endpoint: uri,
host: u.Host,
Username: username,
Password: password,
transport: transport,
}
return me, nil
} | go | {
"resource": ""
} |
q16039 | ListPermissions | train | func (c *Client) ListPermissions() (rec []PermissionInfo, err error) {
req, err := newGETRequest(c, "permissions/")
if err != nil {
return []PermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []PermissionInfo{}, err
}
return rec, nil
} | go | {
"resource": ""
} |
q16040 | UpdatePermissionsIn | train | func (c *Client) UpdatePermissionsIn(vhost, username string, permissions Permissions) (res *http.Response, err error) {
body, err := json.Marshal(permissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | go | {
"resource": ""
} |
q16041 | ListTopicPermissions | train | func (c *Client) ListTopicPermissions() (rec []TopicPermissionInfo, err error) {
req, err := newGETRequest(c, "topic-permissions/")
if err != nil {
return []TopicPermissionInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []TopicPermissionInfo{}, err
}
return rec, nil
} | go | {
"resource": ""
} |
q16042 | UpdateTopicPermissionsIn | train | func (c *Client) UpdateTopicPermissionsIn(vhost, username string, TopicPermissions TopicPermissions) (res *http.Response, err error) {
body, err := json.Marshal(TopicPermissions)
if err != nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "topic-permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | go | {
"resource": ""
} |
q16043 | ListBindings | train | func (c *Client) ListBindings() (rec []BindingInfo, err error) {
req, err := newGETRequest(c, "bindings/")
if err != nil {
return []BindingInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []BindingInfo{}, err
}
return rec, nil
} | go | {
"resource": ""
} |
q16044 | NewDecoder | train | func NewDecoder(r io.Reader) Decoder {
return Decoder{
r: r,
buf: &bytes.Buffer{},
}
} | go | {
"resource": ""
} |
q16045 | read | train | func (d Decoder) read() (*bytes.Buffer, error) {
output := &bytes.Buffer{}
for {
lengthBytes := make([]byte, 2)
if numRead, err := io.ReadFull(d.r, lengthBytes); numRead != 2 {
return nil, errors.Wrap(err, "Couldn't read expected bytes for message length. Read: %d Expected: 2.", numRead)
}
// Chunk header contains length of current message
messageLen := binary.BigEndian.Uint16(lengthBytes)
if messageLen == 0 {
// If the length is 0, the chunk is done.
return output, nil
}
data, err := d.readData(messageLen)
if err != nil {
return output, errors.Wrap(err, "An error occurred reading message data")
}
numWritten, err := output.Write(data)
if numWritten < len(data) {
return output, errors.New("Didn't write full data on output. Expected: %d Wrote: %d", len(data), numWritten)
} else if err != nil {
return output, errors.Wrap(err, "Error writing data to output")
}
}
} | go | {
"resource": ""
} |
q16046 | Decode | train | func (d Decoder) Decode() (interface{}, error) {
data, err := d.read()
if err != nil {
return nil, err
}
return d.decode(data)
} | go | {
"resource": ""
} |
q16047 | New | train | func New(msg string, args ...interface{}) *Error {
return &Error{
msg: fmt.Sprintf(msg, args...),
stack: debug.Stack(),
level: 0,
}
} | go | {
"resource": ""
} |
q16048 | Wrap | train | func Wrap(err error, msg string, args ...interface{}) *Error {
if e, ok := err.(*Error); ok {
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: e,
}
}
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: err,
stack: debug.Stack(),
}
} | go | {
"resource": ""
} |
q16049 | InnerMost | train | func (e *Error) InnerMost() error {
if e.wrapped == nil {
return e
}
if inner, ok := e.wrapped.(*Error); ok {
return inner.InnerMost()
}
return e.wrapped
} | go | {
"resource": ""
} |
q16050 | sprintByteHex | train | func sprintByteHex(b []byte) string {
output := "\t"
for i, b := range b {
output += fmt.Sprintf("%x", b)
if (i+1)%16 == 0 {
output += "\n\n\t"
} else if (i+1)%4 == 0 {
output += " "
} else {
output += " "
}
}
output += "\n"
return output
} | go | {
"resource": ""
} |
q16051 | driverArgsToMap | train | func driverArgsToMap(args []driver.Value) (map[string]interface{}, error) {
output := map[string]interface{}{}
for _, arg := range args {
argBytes, ok := arg.([]byte)
if !ok {
return nil, errors.New("You must pass only a gob encoded map to the Exec/Query args")
}
m, err := encoding.Unmarshal(argBytes)
if err != nil {
return nil, err
}
for k, v := range m.(map[string]interface{}) {
output[k] = v
}
}
return output, nil
} | go | {
"resource": ""
} |
q16052 | Commit | train | func (t *boltTx) Commit() error {
if t.closed {
return errors.New("Transaction already closed")
}
if t.conn.statement != nil {
if err := t.conn.statement.Close(); err != nil {
return errors.Wrap(err, "An error occurred closing open rows in transaction Commit")
}
}
successInt, pullInt, err := t.conn.sendRunPullAllConsumeSingle("COMMIT", nil)
if err != nil {
return errors.Wrap(err, "An error occurred committing transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type committing transaction: %#v", success)
}
log.Infof("Got success message committing transaction: %#v", success)
pull, ok := pullInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type pulling transaction: %#v", pull)
}
log.Infof("Got success message pulling transaction: %#v", pull)
t.conn.transaction = nil
t.closed = true
return err
} | go | {
"resource": ""
} |
q16053 | Open | train | func (d *boltDriver) Open(connStr string) (driver.Conn, error) {
return newBoltConn(connStr, d) // Never use pooling when using SQL driver
} | go | {
"resource": ""
} |
q16054 | NewDriverPool | train | func NewDriverPool(connStr string, max int) (DriverPool, error) {
return createDriverPool(connStr, max)
} | go | {
"resource": ""
} |
q16055 | NewClosableDriverPool | train | func NewClosableDriverPool(connStr string, max int) (ClosableDriverPool, error) {
return createDriverPool(connStr, max)
} | go | {
"resource": ""
} |
q16056 | OpenPool | train | func (d *boltDriverPool) OpenPool() (Conn, error) {
// For each connection request we need to block in case the Close function is called. This gives us a guarantee
// when closing the pool no new connections are made.
d.refLock.Lock()
defer d.refLock.Unlock()
if !d.closed {
conn := <-d.pool
if connectionNilOrClosed(conn) {
if err := conn.initialize(); err != nil {
return nil, err
}
d.connRefs = append(d.connRefs, conn)
}
return conn, nil
}
return nil, errors.New("Driver pool has been closed")
} | go | {
"resource": ""
} |
q16057 | Close | train | func (d *boltDriverPool) Close() error {
// Lock the connection ref so no new connections can be added
d.refLock.Lock()
defer d.refLock.Unlock()
for _, conn := range d.connRefs {
// Remove the reference to the pool, to allow a clean up of the connection
conn.poolDriver = nil
err := conn.Close()
if err != nil {
d.closed = true
return err
}
}
// Mark the pool as closed to stop any new connections
d.closed = true
return nil
} | go | {
"resource": ""
} |
q16058 | newBoltConn | train | func newBoltConn(connStr string, driver *boltDriver) (*boltConn, error) {
c := createBoltConn(connStr)
c.driver = driver
err := c.initialize()
if err != nil {
return nil, errors.Wrap(err, "An error occurred initializing connection")
}
return c, nil
} | go | {
"resource": ""
} |
q16059 | newPooledBoltConn | train | func newPooledBoltConn(connStr string, driver DriverPool) (*boltConn, error) {
c := createBoltConn(connStr)
c.poolDriver = driver
return c, nil
} | go | {
"resource": ""
} |
q16060 | Read | train | func (c *boltConn) Read(b []byte) (n int, err error) {
if err := c.conn.SetReadDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting read deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Read(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Read %d bytes from stream:\n\n%s\n", n, sprintByteHex(b))
}
if err != nil && err != io.EOF {
c.connErr = errors.Wrap(err, "An error occurred reading from stream")
err = driver.ErrBadConn
}
return n, err
} | go | {
"resource": ""
} |
q16061 | Write | train | func (c *boltConn) Write(b []byte) (n int, err error) {
if err := c.conn.SetWriteDeadline(time.Now().Add(c.timeout)); err != nil {
c.connErr = errors.Wrap(err, "An error occurred setting write deadline")
return 0, driver.ErrBadConn
}
n, err = c.conn.Write(b)
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Wrote %d of %d bytes to stream:\n\n%s\n", len(b), n, sprintByteHex(b[:n]))
}
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred writing to stream")
err = driver.ErrBadConn
}
return n, err
} | go | {
"resource": ""
} |
q16062 | Close | train | func (c *boltConn) Close() error {
if c.closed {
return nil
}
if c.statement != nil {
if err := c.statement.Close(); err != nil {
return err
}
}
if c.transaction != nil {
if err := c.transaction.Rollback(); err != nil {
return errors.Wrap(err, "Error rolling back transaction when closing connection")
}
}
if c.poolDriver != nil {
// If using connection pooling, don't close connection, just reclaim it
err := c.poolDriver.reclaim(c)
if err != nil {
log.Errorf("An error occurred reclaiming connection for pool: %s", err)
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
}
err := c.conn.Close()
c.closed = true
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
} | go | {
"resource": ""
} |
q16063 | Prepare | train | func (c *boltConn) Prepare(query string) (driver.Stmt, error) {
return c.prepare(query)
} | go | {
"resource": ""
} |
q16064 | PreparePipeline | train | func (c *boltConn) PreparePipeline(queries ...string) (PipelineStmt, error) {
if c.statement != nil {
return nil, errors.New("An open statement already exists")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
c.statement = newPipelineStmt(queries, c)
return c.statement, nil
} | go | {
"resource": ""
} |
q16065 | Begin | train | func (c *boltConn) Begin() (driver.Tx, error) {
if c.transaction != nil {
return nil, errors.New("An open transaction already exists")
}
if c.statement != nil {
return nil, errors.New("Cannot open a transaction when you already have an open statement")
}
if c.closed {
return nil, errors.New("Connection already closed")
}
successInt, pullInt, err := c.sendRunPullAllConsumeSingle("BEGIN", nil)
if err != nil {
return nil, errors.Wrap(err, "An error occurred beginning transaction")
}
success, ok := successInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type beginning transaction: %#v", success)
}
log.Infof("Got success message beginning transaction: %#v", success)
success, ok = pullInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type pulling transaction: %#v", success)
}
log.Infof("Got success message pulling transaction: %#v", success)
return newTx(c), nil
} | go | {
"resource": ""
} |
q16066 | NewRunMessage | train | func NewRunMessage(statement string, parameters map[string]interface{}) RunMessage {
return RunMessage{
statement: statement,
parameters: parameters,
}
} | go | {
"resource": ""
} |
q16067 | Columns | train | func (r *boltRows) Columns() []string {
fieldsInt, ok := r.metadata["fields"]
if !ok {
return []string{}
}
fields, ok := fieldsInt.([]interface{})
if !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
fieldsStr := make([]string, len(fields))
for i, f := range fields {
if fieldsStr[i], ok = f.(string); !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
}
return fieldsStr
} | go | {
"resource": ""
} |
q16068 | Close | train | func (r *boltRows) Close() error {
if r.closed {
return nil
}
if !r.consumed {
// Discard all messages if not consumed
respInt, err := r.statement.conn.sendDiscardAllConsume()
if err != nil {
return errors.Wrap(err, "An error occurred discarding messages on row close")
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
default:
return errors.New("Unrecognized response type discarding all rows: Value: %#v", resp)
}
} else if !r.finishedConsume {
// If this is a pipeline statement, we need to "consume all" multiple times
numConsume := 1
if r.statement.queries != nil {
numQueries := len(r.statement.queries)
if numQueries > 0 {
// So, every pipeline statement has two successes
// but by the time you get to the row object, one has
// been consumed. Hence we need to clear out the
// rest of the messages on close by taking the current
// index * 2 but removing the first success
numConsume = ((numQueries - r.pipelineIndex) * 2) - 1
}
}
// Clear out all unconsumed messages if we
// never finished consuming them.
_, _, err := r.statement.conn.consumeAllMultiple(numConsume)
if err != nil {
return errors.Wrap(err, "An error occurred clearing out unconsumed stream")
}
}
r.closed = true
r.statement.rows = nil
if r.closeStatement {
return r.statement.Close()
}
return nil
} | go | {
"resource": ""
} |
q16069 | Next | train | func (r *boltRows) Next(dest []driver.Value) error {
data, _, err := r.NextNeo()
if err != nil {
return err
}
for i, item := range data {
switch item := item.(type) {
case []interface{}, map[string]interface{}, graph.Node, graph.Path, graph.Relationship, graph.UnboundRelationship:
dest[i], err = encoding.Marshal(item)
if err != nil {
return err
}
default:
dest[i], err = driver.DefaultParameterConverter.ConvertValue(item)
if err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q16070 | NextNeo | train | func (r *boltRows) NextNeo() ([]interface{}, map[string]interface{}, error) {
if r.closed {
return nil, nil, errors.New("Rows are already closed")
}
if !r.consumed {
r.consumed = true
if err := r.statement.conn.sendPullAll(); err != nil {
r.finishedConsume = true
return nil, nil, err
}
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
r.finishedConsume = true
return nil, resp.Metadata, io.EOF
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil
default:
return nil, nil, errors.New("Unrecognized response type getting next query row: %#v", resp)
}
} | go | {
"resource": ""
} |
q16071 | NextPipeline | train | func (r *boltRows) NextPipeline() ([]interface{}, map[string]interface{}, PipelineRows, error) {
if r.closed {
return nil, nil, nil, errors.New("Rows are already closed")
}
respInt, err := r.statement.conn.consume()
if err != nil {
return nil, nil, nil, err
}
switch resp := respInt.(type) {
case messages.SuccessMessage:
log.Infof("Got success message: %#v", resp)
if r.pipelineIndex == len(r.statement.queries)-1 {
r.finishedConsume = true
return nil, nil, nil, err
}
successResp, err := r.statement.conn.consume()
if err != nil && err != io.EOF {
return nil, nil, nil, errors.Wrap(err, "An error occurred getting next set of rows from pipeline command: %#v", successResp)
}
success, ok := successResp.(messages.SuccessMessage)
if !ok {
return nil, nil, nil, errors.New("Unexpected response getting next set of rows from pipeline command: %#v", successResp)
}
r.statement.rows = newPipelineRows(r.statement, success.Metadata, r.pipelineIndex+1)
r.statement.rows.closeStatement = r.closeStatement
return nil, success.Metadata, r.statement.rows, nil
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil, nil
default:
return nil, nil, nil, errors.New("Unrecognized response type getting next pipeline row: %#v", resp)
}
} | go | {
"resource": ""
} |
q16072 | NewInitMessage | train | func NewInitMessage(clientName string, user string, password string) InitMessage {
var authToken map[string]interface{}
if user == "" {
authToken = map[string]interface{}{
"scheme": "none",
}
} else {
authToken = map[string]interface{}{
"scheme": "basic",
"principal": user,
"credentials": password,
}
}
return InitMessage{
clientName: clientName,
authToken: authToken,
}
} | go | {
"resource": ""
} |
q16073 | SetLevel | train | func SetLevel(levelStr string) {
switch strings.ToLower(levelStr) {
case "trace":
level = TraceLevel
case "info":
level = InfoLevel
case "error":
level = ErrorLevel
default:
level = NoneLevel
}
} | go | {
"resource": ""
} |
q16074 | Tracef | train | func Tracef(msg string, args ...interface{}) {
if level >= TraceLevel {
TraceLog.Printf(msg, args...)
}
} | go | {
"resource": ""
} |
q16075 | Infof | train | func Infof(msg string, args ...interface{}) {
if level >= InfoLevel {
InfoLog.Printf(msg, args...)
}
} | go | {
"resource": ""
} |
q16076 | Errorf | train | func Errorf(msg string, args ...interface{}) {
if level >= ErrorLevel {
ErrorLog.Printf(msg, args...)
}
} | go | {
"resource": ""
} |
q16077 | NewEncoder | train | func NewEncoder(w io.Writer, chunkSize uint16) Encoder {
return Encoder{
w: w,
buf: &bytes.Buffer{},
chunkSize: chunkSize,
}
} | go | {
"resource": ""
} |
q16078 | Marshal | train | func Marshal(v interface{}) ([]byte, error) {
x := &bytes.Buffer{}
err := NewEncoder(x, math.MaxUint16).Encode(v)
return x.Bytes(), err
} | go | {
"resource": ""
} |
q16079 | Write | train | func (e Encoder) Write(p []byte) (n int, err error) {
n, err = e.buf.Write(p)
if err != nil {
err = errors.Wrap(err, "An error occurred writing to encoder temp buffer")
return n, err
}
length := e.buf.Len()
for length >= int(e.chunkSize) {
if err := binary.Write(e.w, binary.BigEndian, e.chunkSize); err != nil {
return 0, errors.Wrap(err, "An error occured writing chunksize")
}
numWritten, err := e.w.Write(e.buf.Next(int(e.chunkSize)))
if err != nil {
err = errors.Wrap(err, "An error occured writing a chunk")
}
return numWritten, err
}
return n, nil
} | go | {
"resource": ""
} |
q16080 | flush | train | func (e Encoder) flush() error {
length := e.buf.Len()
if length > 0 {
if err := binary.Write(e.w, binary.BigEndian, uint16(length)); err != nil {
return errors.Wrap(err, "An error occured writing length bytes during flush")
}
if _, err := e.buf.WriteTo(e.w); err != nil {
return errors.Wrap(err, "An error occured writing message bytes during flush")
}
}
_, err := e.w.Write(EndMessage)
if err != nil {
return errors.Wrap(err, "An error occurred ending encoding message")
}
e.buf.Reset()
return nil
} | go | {
"resource": ""
} |
q16081 | Read | train | func (r *recorder) Read(b []byte) (n int, err error) {
if r.Conn != nil {
numRead, err := r.Conn.Read(b)
if numRead > 0 {
r.record(b[:numRead], false)
}
if err != nil {
r.recordErr(err, false)
}
return numRead, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to read past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if event.IsWrite {
return 0, errors.New("Recorder expected Read, got Write! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to read past current event in recorder! Bytes: %s. Recorder %#v, Event; %#v", b, r, event)
}
b[i] = event.Event[0]
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
} | go | {
"resource": ""
} |
q16082 | Close | train | func (r *recorder) Close() error {
if r.Conn != nil {
err := r.flush()
if err != nil {
return err
}
return r.Conn.Close()
} else if len(r.events) > 0 {
if r.currentEvent != len(r.events) {
return errors.New("Didn't read all of the events in the recorder on close! %#v", r)
}
if len(r.events[len(r.events)-1].Event) != 0 {
return errors.New("Left data in an event in the recorder on close! %#v", r)
}
return nil
}
return nil
} | go | {
"resource": ""
} |
q16083 | Write | train | func (r *recorder) Write(b []byte) (n int, err error) {
if r.Conn != nil {
numWritten, err := r.Conn.Write(b)
if numWritten > 0 {
r.record(b[:numWritten], true)
}
if err != nil {
r.recordErr(err, true)
}
return numWritten, err
}
if r.currentEvent >= len(r.events) {
return 0, errors.New("Trying to write past all of the events in the recorder! %#v", r)
}
event := r.events[r.currentEvent]
if !event.IsWrite {
return 0, errors.New("Recorder expected Write, got Read! %#v, Event: %#v", r, event)
}
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to write past current event in recorder! %#v, Event: %#v", r, event)
}
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
} | go | {
"resource": ""
} |
q16084 | init | train | func init() {
revel.RegisterServerEngine("fasthttp", func() revel.ServerEngine {
return &FastHTTPServer{}
})
revel.RegisterModuleInit(func(m *revel.Module) {
serverLog = m.Log
})
} | go | {
"resource": ""
} |
q16085 | Init | train | func (f *FastHTTPServer) Init(init *revel.EngineInit) {
f.MaxMultipartSize = int64(revel.Config.IntDefault("server.request.max.multipart.filesize", 32)) << 20 /* 32 MB */
fastHttpContextStack = utils.NewStackLock(revel.Config.IntDefault("server.context.stack", 100),
revel.Config.IntDefault("server.context.maxstack", 200),
func() interface{} { return NewFastHttpContext(f) })
fastHttpMultipartFormStack = utils.NewStackLock(revel.Config.IntDefault("server.form.stack", 100),
revel.Config.IntDefault("server.form.maxstack", 200),
func() interface{} { return &FastHttpMultipartForm{} })
requestHandler := func(ctx *fasthttp.RequestCtx) {
f.RequestHandler(ctx)
}
// Adds the mux list
f.HttpMuxList = init.HTTPMuxList
sort.Sort(f.HttpMuxList)
f.HasAppMux = len(f.HttpMuxList) > 0
f.signalChan = make(chan os.Signal)
f.ServerInit = init
f.Server = &fasthttp.Server{
ReadTimeout: time.Duration(revel.Config.IntDefault("http.timeout.read", 0)) * time.Second,
WriteTimeout: time.Duration(revel.Config.IntDefault("http.timeout.write", 0)) * time.Second,
Handler: requestHandler,
}
} | go | {
"resource": ""
} |
q16086 | RequestHandler | train | func (f *FastHTTPServer) RequestHandler(ctx *fasthttp.RequestCtx) {
// This section is called if the developer has added custom mux to the app
if f.HasAppMux && f.handleAppMux(ctx) {
return
}
f.handleMux(ctx)
} | go | {
"resource": ""
} |
q16087 | Event | train | func (f *FastHTTPServer) Event(event revel.Event, args interface{}) revel.EventResponse {
switch event {
case revel.ENGINE_STARTED:
signal.Notify(f.signalChan, os.Interrupt, os.Kill)
go func() {
_ = <-f.signalChan
serverLog.Info("Received quit singal Please wait ... ")
revel.StopServer(nil)
}()
case revel.ENGINE_SHUTDOWN_REQUEST:
if err := f.graceful.Close(); err != nil {
serverLog.Fatal("Failed to close fasthttp server gracefully, exiting using os.exit", "error", err)
}
default:
}
return 0
} | go | {
"resource": ""
} |
q16088 | NewFastHttpContext | train | func NewFastHttpContext(instance *FastHTTPServer) *FastHttpContext {
if instance == nil {
instance = &FastHTTPServer{MaxMultipartSize: 32 << 20}
}
c := &FastHttpContext{
Request: &FastHttpRequest{header: &FastHttpHeader{isResponse: false},
Engine: instance},
Response: &FastHttpResponse{header: &FastHttpHeader{isResponse: true},
Engine: instance},
}
c.Response.header.Source = c.Response
c.Request.header.Source = c.Request
return c
} | go | {
"resource": ""
} |
q16089 | SetContext | train | func (c *FastHttpContext) SetContext(context *fasthttp.RequestCtx) {
c.Response.SetContext(context)
c.Request.SetContext(context)
} | go | {
"resource": ""
} |
q16090 | Get | train | func (r *FastHttpRequest) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.GetHeader()
case revel.HTTP_MULTIPART_FORM:
value, err = r.GetMultipartForm()
case revel.HTTP_QUERY:
value = r.GetQuery()
case revel.HTTP_FORM:
value, err = r.GetForm()
case revel.HTTP_REQUEST_URI:
value = string(r.Original.RequestURI())
case revel.HTTP_REMOTE_ADDR:
value = r.Original.RemoteAddr().String()
case revel.HTTP_METHOD:
value = string(r.Original.Method())
case revel.HTTP_PATH:
value = string(r.Original.Path())
case revel.HTTP_HOST:
value = string(r.Original.Request.Host())
case revel.HTTP_URL:
if r.url == nil {
r.url, _ = url.Parse(string(r.Original.Request.URI().FullURI()))
}
value = r.url
case revel.HTTP_BODY:
value = bytes.NewBuffer(r.Original.Request.Body())
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
} | go | {
"resource": ""
} |
q16091 | GetQuery | train | func (r *FastHttpRequest) GetQuery() url.Values {
if !r.toQuery {
// Attempt to convert to query
r.query = url.Values{}
r.Original.QueryArgs().VisitAll(func(key, value []byte) {
r.query.Set(string(key), string(value))
})
r.toQuery = true
}
return r.query
} | go | {
"resource": ""
} |
q16092 | Destroy | train | func (r *FastHttpRequest) Destroy() {
r.Original = nil
r.FormParsed = false
r.MultiFormParsed = false
r.ParsedForm = nil
r.toQuery = false
} | go | {
"resource": ""
} |
q16093 | Get | train | func (r *FastHttpResponse) Get(key int) (value interface{}, err error) {
switch key {
case revel.HTTP_SERVER_HEADER:
value = r.Header()
case revel.HTTP_STREAM_WRITER:
value = r
case revel.HTTP_WRITER:
value = r.Writer
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
} | go | {
"resource": ""
} |
q16094 | Set | train | func (r *FastHttpResponse) Set(key int, value interface{}) (set bool) {
switch key {
case revel.ENGINE_RESPONSE_STATUS:
r.Header().SetStatus(value.(int))
set = true
case revel.HTTP_WRITER:
r.SetWriter(value.(io.Writer))
set = true
}
return
} | go | {
"resource": ""
} |
q16095 | WriteStream | train | func (r *FastHttpResponse) WriteStream(name string, contentlen int64, modtime time.Time, reader io.Reader) error {
// do a simple io.Copy, we do it directly into the writer which may be configured to be a compressed
// writer
ius := r.Original.Request.Header.Peek("If-Unmodified-Since")
if t, err := http.ParseTime(string(ius)); ius != nil && err == nil && !modtime.IsZero() {
// The Date-Modified header truncates sub-second precision, so
// use mtime < t+1s instead of mtime <= t to check for unmodified.
if modtime.Before(t.Add(1 * time.Second)) {
h := r.Original.Response.Header
h.Del("Content-Type")
h.Del("Content-Length")
if h.Peek("Etag") != nil {
h.Del("Last-Modified")
}
h.SetStatusCode(http.StatusNotModified)
return nil
}
}
if contentlen != -1 {
r.Original.Response.Header.Set("Content-Length", strconv.FormatInt(contentlen, 10))
}
if _, err := io.Copy(r.Writer, reader); err != nil {
r.Original.Response.Header.SetStatusCode(http.StatusInternalServerError)
return err
} else {
r.Original.Response.Header.SetStatusCode(http.StatusOK)
}
return nil
} | go | {
"resource": ""
} |
q16096 | Destroy | train | func (r *FastHttpResponse) Destroy() {
if c, ok := r.Writer.(io.Closer); ok {
c.Close()
}
r.Original = nil
r.Writer = nil
} | go | {
"resource": ""
} |
q16097 | SetContext | train | func (r *FastHttpResponse) SetContext(w *fasthttp.RequestCtx) {
r.Original = w
r.Writer = w.Response.BodyWriter()
} | go | {
"resource": ""
} |
q16098 | SetCookie | train | func (r *FastHttpHeader) SetCookie(cookie string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Add("Set-Cookie", cookie)
}
} | go | {
"resource": ""
} |
q16099 | Del | train | func (r *FastHttpHeader) Del(key string) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.Header.Del(key)
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.