input stringlengths 24 2.11k | output stringlengths 7 948 |
|---|---|
package glw
import "golang.org/x/mobile/gl"
type A2fv gl.Attrib
func (a A2fv) Enable() { ctx.EnableVertexAttribArray(gl.Attrib(a)) }
func (a A2fv) Disable() { ctx.DisableVertexAttribArray(gl.Attrib(a)) }
func (a A2fv) Pointer() {
a.Enable()
ctx.VertexAttribPointer(gl.Attrib(a), 2, gl.FLOAT, false, 0, 0)
}
type A... | {
a.Enable()
ctx.VertexAttribPointer(gl.Attrib(a), 4, gl.FLOAT, false, 0, 0)
} |
package cli
import (
"errors"
"fmt"
"log"
"github.com/alexyer/ghost/client"
)
func ObtainUnixSocketClient(socket string) (*client.GhostClient, error) {
return connect(socket, "unix")
}
func connect(addr, network string) (*client.GhostClient, error) {
c := client.New(&client.Options{
Addr: addr,
Ne... | {
addr := fmt.Sprintf("%s:%d", host, port)
return connect(addr, "tcp")
} |
package command
import (
"errors"
"os"
"strings"
"github.com/bitrise-io/go-utils/pathutil"
)
func CopyFile(src, dst string) error {
isDir, err := pathutil.IsDirExists(src)
if err != nil {
return err
}
if isDir {
return errors.New("Source is a directory: " + src)
}
args := []string{src, dst}
return Ru... | {
if isOnlyContent && !strings.HasSuffix(src, "/") {
src = src + "/"
}
args := []string{"-ar", src, dst}
return RunCommand("rsync", args...)
} |
package watch
type FilterFunc func(in Event) (out Event, keep bool)
func Filter(w Interface, f FilterFunc) Interface {
fw := &filteredWatch{
incoming: w,
result: make(chan Event),
f: f,
}
go fw.loop()
return fw
}
type filteredWatch struct {
incoming Interface
result chan Event
f ... | {
return fw.result
} |
package controller
import (
"fmt"
)
type AdminParams struct {
Name *string
InviteId *string
InviteKey *string
ConfirmDelete *string
}
func NewAdminParams() *AdminParams {
return new(AdminParams)
}
func (params *AdminParams) ValidateName(required bool) error {
if required && *params.Name == ... | { return nil } |
package main
import (
"net/http"
"os"
"gopkg.in/gin-gonic/gin.v1"
)
var router *gin.Engine
func main() {
if os.Getenv("GIN_ENV") == "production" {
gin.SetMode(gin.ReleaseMode)
} else {
gin.SetMode(gin.DebugMode)
}
router = gin.Default()
router.LoadHTMLGlob("templates/*")
initializeRoutes()
router.... | {
c.HTML(http.StatusOK, templateName, data)
} |
package bc
import (
"io"
"log"
"os"
"os/exec"
)
type Bc interface {
Exec(string) error
Quit()
}
type bc struct {
cmd *exec.Cmd
stdin io.WriteCloser
stdout io.ReadCloser
}
func Start() Bc {
cmd := exec.Command("bc")
stdin, err := cmd.StdinPipe()
if err != nil {
log.Fatal(err)
}
stdout, err := cmd... | {
bc.stdin.Write([]byte(code))
bc.stdin.Write(inputSuffix)
for {
b, err := readByte(bc.stdout)
if err != nil {
return err
}
if b == 0x04 {
break
}
os.Stdout.Write([]byte{b})
}
return nil
} |
package wxdata
import (
"fmt"
"sync"
"time"
)
func DownloadGfs(targetFolder string) {
for _,t:= range GetGfsCandidateAnatimes(){
downloadGfs(targetFolder, t)
}
}
func downloadGfs(targetFolder string, date time.Time) | {
items := GetGfsDownloadItems(date)
var wg sync.WaitGroup
wg.Add(len(items))
for _,item := range items {
go (func(item DownloadItem){
defer wg.Done()
Download(item, targetFolder)
})(item)
fmt.Println(item.Url)
}
wg.Wait()
} |
package tc
import (
"encoding/json"
)
type CRStates struct {
Caches map[CacheName]IsAvailable `json:"caches"`
DeliveryService map[DeliveryServiceName]CRStatesDeliveryService `json:"deliveryServices"`
}
type CRStatesDeliveryService struct {
DisabledLocations []CacheGroupName `js... | {
b := map[CacheName]IsAvailable{}
for k, v := range a.Caches {
b[k] = v
}
return b
} |
package main
import (
"fmt"
"strconv"
)
func simpleEvalInt(a, b int, op string) int {
switch op {
case "+":
return a + b
case "-":
return a - b
case "/":
return a / b
case "*":
return a * b
case "^":
return power(a, b)
default:
return 0
}
}
func power(a, b int) int {
ans := 1
for i := ... | {
var stack []int
for _, val := range postfix {
if isOp(val) {
a := stack[len(stack)-2]
b := stack[len(stack)-1]
retVal := simpleEvalInt(a, b, val)
stack = append(stack[0:len(stack)-2], retVal)
} else {
num, err := strconv.Atoi(val)
if err != nil {
return 0, nil
}
stack = append(stack,... |
package dns
import (
"github.com/cilium/cilium/pkg/hubble/metrics/api"
)
type dnsPlugin struct{}
func (p *dnsPlugin) NewHandler() api.Handler {
return &dnsHandler{}
}
func (p *dnsPlugin) HelpText() string {
return `dns - DNS related metrics
Reports metrics related to DNS queries and responses
Metrics:
hubble_... | {
api.DefaultRegistry().Register("dns", &dnsPlugin{})
} |
package srpc
import (
"crypto/tls"
"github.com/Symantec/Dominator/lib/connpool"
)
func newClientResource(network, address string) *ClientResource {
clientResource := &ClientResource{
network: network,
address: address,
}
clientResource.privateClientResource.clientResource = clientResource
rp := connpool.Ge... | {
client.resource.resource.Put()
if client.resource.inUse {
clientMetricsMutex.Lock()
numInUseClientConnections--
clientMetricsMutex.Unlock()
client.resource.inUse = false
}
} |
package scripts
import (
"bytes"
"io/ioutil"
"github.com/lfkeitel/inca-tool/devices"
)
func getHostVariables(host *devices.Device) map[string]string {
argList := make(map[string]string)
argList["protocol"] = host.GetSetting("protocol")
if argList["protocol"] == "" {
argList["protocol"] = "ssh"
}
argList... | {
file, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
for n, v := range vars {
if n[0] == '_' {
n = n[1:]
}
file = bytes.Replace(file, []byte("{{"+n+"}}"), []byte(v), -1)
}
if err := ioutil.WriteFile(filename, file, 0744); err != nil {
return err
}
return nil
} |
package wait
import (
"fmt"
"time"
)
func Predicate(pred func() bool, timeout time.Duration) error {
const pollInterval = 20 * time.Millisecond
exitTimer := time.After(timeout)
for {
<-time.After(pollInterval)
select {
case <-exitTimer:
return fmt.Errorf("predicate not satisfied after time out")
... | {
var predErr error
pred := func() bool {
if err := f(); err != nil {
predErr = err
return false
}
return true
}
if err := Predicate(pred, timeout); err != nil {
return predErr
}
return nil
} |
package minicon
import "container/ring"
type History struct {
r *ring.Ring
}
type HistoryMarker *ring.Ring
func NewHistory(capacity int) *History {
return &History{ring.New(capacity)}
}
func (hs *History) Add(s string, mark HistoryMarker) HistoryMarker {
hs.Restore(mark)
if s != "" && hs.r.Value ... | {
return hs.r
} |
package lmath
func selfDividingNumbers(left int, right int) []int | {
res := []int{}
for i := left; i <= right; i++ {
j := i
for ; j > 0; j /= 10 {
if j%10 == 0 || i%(j%10) != 0 {
break
}
}
if j == 0 {
res = append(res, i)
}
}
return res
} |
package atomic
import (
"encoding/json"
"strconv"
"sync/atomic"
)
type Uint32 struct {
_ nocmp
v uint32
}
func NewUint32(val uint32) *Uint32 {
return &Uint32{v: val}
}
func (i *Uint32) Load() uint32 {
return atomic.LoadUint32(&i.v)
}
func (i *Uint32) Sub(delta uint32) uint32 {
return atomic.AddUin... | {
return atomic.AddUint32(&i.v, delta)
} |
package v1alpha1
import (
"testing"
"github.com/google/go-cmp/cmp"
corev1 "k8s.io/api/core/v1"
)
func TestBuildTemplateSpec(t *testing.T) {
c := BuildTemplate{
Spec: BuildTemplateSpec{
Steps: []corev1.Container{{
Name: "build-spec",
}},
},
}
expectedBuildSpec := BuildTemplateSpec{Steps: []corev1... | {
c := BuildTemplate{}
expectedKind := "BuildTemplate"
if c.GetGroupVersionKind().Kind != expectedKind {
t.Errorf("GetGroupVersionKind mismatch; expected: %v got: %v", expectedKind, c.GetGroupVersionKind().Kind)
}
} |
package main
import (
"os"
"runtime"
)
func main() {
}
func init() | {
c := make(chan int, 1)
defer func() {
c <- 0
}()
go func() {
os.Exit(<-c)
}()
runtime.Goexit()
} |
package mock
import (
"github.com/eventials/goevents/messaging"
"github.com/stretchr/testify/mock"
)
type Connection struct {
mock.Mock
}
func NewMockConnection() messaging.Connection {
return &Connection{}
}
func (c *Connection) Consumer(autoAck bool, exchange, queue string) (messaging.Consumer, error) {
args... | {
args := c.Called()
return args.Get(0).(bool)
} |
package miniredis
import (
"reflect"
"testing"
)
func assert(tb testing.TB, condition bool, msg string, v ...interface{}) {
tb.Helper()
if !condition {
tb.Errorf(msg, v...)
}
}
func ok(tb testing.TB, err error) {
tb.Helper()
if err != nil {
tb.Errorf("unexpected error: %s", err.Error())
}
}
func eq... | {
tb.Helper()
if err == nil {
tb.Errorf("expected an error, but got a nil")
}
if have := err.Error(); have != want {
tb.Errorf("have %q, want %q", have, want)
}
} |
package handlers
import (
"net/http"
"appengine/user"
"appengine"
"appengine/datastore"
"text/template"
"time"
"model"
"model/booth"
"util"
)
func handleGetAllBooths(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
util.RedirectIfNotLoggedIn(w, r)
q := datastore.NewQuery("Boot... | {
switch r.Method {
case "GET":
handleGetAllBooths(w, r)
break;
case "POST":
handleCreateBooth(w, r)
break;
default:
http.Error(w, "", http.StatusMethodNotAllowed)
}
} |
package models
import (
strfmt "github.com/go-openapi/strfmt"
"github.com/go-openapi/errors"
"github.com/go-openapi/validate"
)
type TaskIDRange struct {
End *int32 `json:"end"`
Start *int32 `json:"start"`
}
func (m *TaskIDRange) validateEnd(formats strfmt.Registry) error {
if err := validate.Req... | {
var res []error
if err := m.validateEnd(formats); err != nil {
res = append(res, err)
}
if err := m.validateStart(formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} |
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccGoogleSqlDatabaseInstance_importBasic(t *testing.T) {
t.Parallel()
resourceName := "google_sql_database_instance.instance"
databaseID := acctest.RandInt()
... | {
t.Parallel()
resourceName := "google_sql_database_instance.instance"
databaseID := acctest.RandInt()
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccGoogleSqlDatabaseInstanceDestroy,
Steps: []resource.TestStep{
reso... |
package plugin
type Kind uint8
const (
Audit Kind = 1 + iota
Authentication
Schema
Daemon
)
type State uint8
const (
Uninitialized State = iota
Ready
Dying
Disable
)
func (s State) String() (str string) {
switch s {
case Uninitialized:
str = "Uninitialized"
case Ready:
str = "Ready"
case Dying:... | {
switch k {
case Audit:
str = "Audit"
case Authentication:
str = "Authentication"
case Schema:
str = "Schema"
case Daemon:
str = "Daemon"
}
return
} |
package common
import (
"fmt"
v1 "k8s.io/api/core/v1"
"k8s.io/client-go/tools/cache"
"k8s.io/component-helpers/storage/ephemeral"
)
const (
PodPVCIndex = "pod-pvc-index"
)
func PodPVCIndexFunc() func(obj interface{}) ([]string, error) {
return func(obj interface{}) ([]string, error) {
pod, ok := obj.(*v1... | {
return AddIndexerIfNotPresent(indexer, PodPVCIndex, PodPVCIndexFunc())
} |
package aws
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
)
func TestAccAWSInspectorResourceGroup_basic(t *testing.T) {
resource.ParallelTest(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
... | {
return func(s *terraform.State) error {
_, ok := s.RootModule().Resources[name]
if !ok {
return fmt.Errorf("Not found: %s", name)
}
return nil
}
} |
package browser
import (
"os"
"os/exec"
"runtime"
)
func Open(url string) bool {
for _, args := range Commands() {
cmd := exec.Command(args[0], append(args[1:], url)...)
if cmd.Start() == nil {
return true
}
}
return false
}
func Commands() [][]string | {
var cmds [][]string
if exe := os.Getenv("BROWSER"); exe != "" {
cmds = append(cmds, []string{exe})
}
switch runtime.GOOS {
case "darwin":
cmds = append(cmds, []string{"/usr/bin/open"})
case "windows":
cmds = append(cmds, []string{"cmd", "/c", "start"})
default:
cmds = append(cmds, []string{"xdg-open"})... |
package nogo
type Permission int
type Principal interface {
GetId() string
GetSid() string
GetRoleNames() []string
}
type Role interface {
GetName() string
IsAdmin() bool
HasPermission(permission Permission) (bool, error)
}
func NewRole(name string, mask Permission) Role {
return &defaultRole{RoleName: n... | {
return this.Admin
} |
package coverage
import "testing"
func TestCoverage(t *testing.T) | {
live()
} |
package windows
import (
"fmt"
"io"
"io/ioutil"
"net/http"
)
func downloadFile(url string) (string, error) | {
response, err := http.Get(url)
if err != nil {
return "", fmt.Errorf("unable to download from %q: %w", url, err)
}
defer response.Body.Close()
tempFile, err := ioutil.TempFile("", "")
if err != nil {
return "", fmt.Errorf("unable to create temp file: %w", err)
}
defer tempFile.Close()
_, err = io.Copy(... |
package buckets
import (
"github.com/campadrenalin/scrap"
"testing"
)
func TestAnyBucket_Empty(t *testing.T) {
b := AnyBucket{}
if b.Check("foo") {
t.Fatal("Should always return false when there are no children")
}
}
func TestAnyBucket_OneItem(t *testing.T) {
b := AnyBucket{
Children: []scrap.Bucket{
sc... | {
b := AnyBucket{
Children: []scrap.Bucket{
scrap.NewCountBucket(1),
scrap.NewCountBucket(2),
},
}
tests := bt_slice{
bt{"foo", true, "First bucket says yes"},
bt{"foo", true, "First bucket exhausted, second says yes"},
bt{"foo", true, "Second bucket says yes for the final time"},
bt{"foo", false, ... |
package git
import (
"fmt"
"os"
"github.com/Originate/git-town/src/command"
"github.com/Originate/git-town/src/util"
)
func EnsureDoesNotHaveOpenChanges(message string) {
util.Ensure(!HasOpenChanges(), "You have uncommitted changes. "+message)
}
var rootDirectory string
func GetRootDirectory() string... | {
util.Ensure(!HasConflicts(), "You must resolve the conflicts before continuing")
} |
package checker
import (
"crypto/hmac"
"crypto/sha1"
"encoding/hex"
"errors"
"net/http"
)
type tokenChecker struct {
}
func (checker *tokenChecker) Support(eventMap map[string]string) bool {
return true
}
func (checker *tokenChecker) Check(eventMap map[string]string, expectedToken string, reqHeader http.Hea... | {
passCheck := false
switch eventMap["sourceType"] {
case "customize":
if expectedToken == eventMap["token"] {
passCheck = true
}
case "gitlab":
if expectedToken == eventMap["token"] {
passCheck = true
}
case "github":
mac := hmac.New(sha1.New, []byte(expectedToken))
mac.Write(reqBody)
expecte... |
package main
import (
"encoding/hex"
"errors"
)
type User struct {
Id uint32
Name string
Password string
CertHash string
Email string
TextureBlob string
CommentBlob string
LastChannelId int
LastActive uint64
}
func NewUser(id uint32, name string) (user *Us... | {
buf, err := hex.DecodeString(user.TextureBlob)
if err != nil {
return nil
}
return buf
} |
package plus
func keySearch(keys keys, key Key) int {
low, high := 0, len(keys)-1
var mid int
for low <= high {
mid = (high + low) / 2
switch keys[mid].Compare(key) {
case 1:
low = mid + 1
case -1:
high = mid - 1
case 0:
return mid
}
}
return low
}
type btree struct {
root node
... | {
if tree.root == nil {
n := newLeafNode(tree.nodeSize)
n.insert(tree, key)
tree.number = 1
return
}
result := tree.root.insert(tree, key)
if result {
tree.number++
}
if tree.root.needsSplit(tree.nodeSize) {
tree.root = split(tree, nil, tree.root)
}
} |
package slice
import (
"fmt"
"testing"
"github.com/speedland/go/x/xtesting/assert"
)
func ExampleSplitByLength() {
var a = []int{0, 1, 2, 3, 4}
var b = SplitByLength(a, 2).([][]int)
fmt.Println(b)
}
func Test_ToInterface(t *testing.T) {
a := assert.New(t)
type T struct {
i int
}
intSlice := []int{1, ... | {
a := assert.New(t)
var a1 = []int{1, 2, 3, 4, 5}
var a2 = SplitByLength(a1, 3).([][]int)
a.EqInt(1, a2[0][0])
a.EqInt(2, a2[0][1])
a.EqInt(3, a2[0][2])
a.EqInt(2, len(a2[1]))
a.EqInt(4, a2[1][0])
a.EqInt(5, a2[1][1])
} |
package local
import (
"time"
"github.com/prometheus/prometheus/util/testutil"
)
type testStorageCloser struct {
storage Storage
directory testutil.Closer
}
func NewTestStorage(t testutil.T, encoding chunkEncoding) (*memorySeriesStorage, testutil.Closer) {
DefaultChunkEncoding = encoding
directory := t... | {
t.storage.Stop()
t.directory.Close()
} |
package tlv
import (
"bytes"
"io"
)
type ByteTLV struct {
T uint64
V []byte
}
func (t ByteTLV) Type() uint64 {
return t.T
}
func (t ByteTLV) WriteTo(w io.Writer) (n int64, err error) {
n, err = WriteNumber(w, t.T)
if err != nil {
return
}
written, err := WriteNumber(w, uint64(len(t.V)))
n += written
... | {
t, _, err := ReadNumber(r)
if err != nil {
return ByteTLV{}, err
}
length, _, err := ReadNumber(r)
if err != nil {
return ByteTLV{}, err
}
value := make([]byte, length)
n, err := r.Read(value)
if err != nil {
return ByteTLV{}, err
}
if uint64(n) < length {
return ByteTLV{}, io.ErrUnexpectedEOF
... |
package tagquery
import (
"io"
"github.com/grafana/metrictank/schema"
)
type expressionMatchNone struct {
expressionCommon
originalOperator ExpressionOperator
}
func (e *expressionMatchNone) Equals(other Expression) bool {
return e.key == other.GetKey() && e.GetOperator() == other.GetOperator() && e.value == o... | {
return e.key
} |
package main
import (
"log"
"net/http"
"os/exec"
"github.com/gin-gonic/gin"
)
func addRouteWithArg(name string, cmd string, router *gin.RouterGroup) {
log.Printf("Configuring route %v with command %s and argument\n", name, cmd)
path := name + "/:arg"
router.GET(path, func(c *gin.Context) {
arg := c.Param... | {
c.String(200, "pong")
} |
package controller
import (
"github.com/tmacychen/UFG/framework"
"github.com/tmacychen/UFG/framework/outer"
)
type AttachableOuter interface {
outer.Relayouter
}
type Attachable struct {
outer AttachableOuter
onAttach framework.Event
onDetach framework.Event
attached bool
}
func (a *Attachable) Init(outer... | {
if a.attached {
panic("Control already attached")
}
a.attached = true
if a.onAttach != nil {
a.onAttach.Fire()
}
} |
package errors
import (
"fmt"
"github.com/GoogleContainerTools/skaffold/proto/v1"
)
type Error interface {
Error() string
StatusCode() proto.StatusCode
Suggestions() []*proto.Suggestion
Unwrap() error
}
type ErrDef struct {
err error
ae *proto.ActionableErr
}
var _ error = (*ErrDef)(nil)
func (e *ErrDe... | {
if s := concatSuggestions(e.Suggestions()); s != "" {
return fmt.Sprintf("%s. %s", e.ae.Message, concatSuggestions(e.Suggestions()))
}
return e.ae.Message
} |
package chatwork
import (
"encoding/json"
"net/url"
"strings"
)
type MessageResult struct {
MessageId int `json:"message_id"`
}
var format string = "/rooms/{roomId}/messages"
func escapeMessage(message string) string {
replacer := strings.NewReplacer("&", "&", "<", "<", ">", ">")
return replacer.R... | {
text = escapeMessage(text)
apiUrl := CHATWORK_API + strings.Replace(format, "{roomId}", roomId, 1)
values := url.Values{}
values.Add("body", text)
contents := api.Request("POST", apiUrl, values.Encode())
var result MessageResult
json.Unmarshal(contents, &result)
return result.MessageId
} |
package underscore
func Select(source, predicate interface{}) interface{} {
return filter(source, predicate, true)
}
func (this *Query) Select(predicate interface{}) Queryer {
this.source = Select(this.source, predicate)
return this
}
func (this *Query) SelectBy(properties map[string]interface{}) Queryer {
th... | {
return Select(source, func (value, _ interface{}) bool {
return IsMatch(value, properties)
})
} |
package camelcase
import (
"bytes"
"unicode/utf8"
"github.com/blevesearch/bleve/analysis"
"github.com/blevesearch/bleve/registry"
)
const Name = "camelCase"
type CamelCaseFilter struct{}
func NewCamelCaseFilter() *CamelCaseFilter {
return &CamelCaseFilter{}
}
func CamelCaseFilterConstructo... | {
rv := make(analysis.TokenStream, 0, len(input))
nextPosition := 1
for _, token := range input {
runeCount := utf8.RuneCount(token.Term)
runes := bytes.Runes(token.Term)
p := NewParser(runeCount, nextPosition, token.Start)
for i := 0; i < runeCount; i++ {
if i+1 >= runeCount {
p.Push(runes[i], nil)... |
package enforcer
import (
"bufio"
"encoding/binary"
)
type hashWriter struct {
*bufio.Writer
}
func (w hashWriter) WriteString(s string) {
w.WriteInt(len(s))
w.Writer.WriteString(s)
}
func (w hashWriter) WriteInt(v int) | {
var buf [8]byte
binary.LittleEndian.PutUint64(buf[:], uint64(v))
w.Write(buf[:])
} |
package iso20022
type SecuritiesCertificate5 struct {
Number *RestrictedFINXMax30Text `xml:"Nb"`
Issuer *Max4AlphaNumericText `xml:"Issr,omitempty"`
SchemeName *Max4AlphaNumericText `xml:"SchmeNm,omitempty"`
}
func (s *SecuritiesCertificate5) SetNumber(value string) {
s.Number = (*RestrictedFINXMax30Text)(&va... | {
s.SchemeName = (*Max4AlphaNumericText)(&value)
} |
package logrus_papertrail
import (
"fmt"
"net"
"os"
"time"
"github.com/botemout/consul-alerts/Godeps/_workspace/src/github.com/Sirupsen/logrus"
)
const (
format = "Jan 2 15:04:05"
)
type PapertrailHook struct {
Host string
Port int
AppName string
UDPConn net.Conn
}
func NewPapertrailHook(host str... | {
date := time.Now().Format(format)
msg, _ := entry.String()
payload := fmt.Sprintf("<22> %s %s: %s", date, hook.AppName, msg)
bytesWritten, err := hook.UDPConn.Write([]byte(payload))
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to send log line to Papertrail via UDP. Wrote %d bytes before error: %v", bytesWr... |
package trie
import "fmt"
type FullNode struct {
trie *Trie
nodes [17]Node
}
func NewFullNode(t *Trie) *FullNode {
return &FullNode{trie: t}
}
func (self *FullNode) Dirty() bool { return true }
func (self *FullNode) Value() Node {
self.nodes[16] = self.trie.trans(self.nodes[16])
return self.nodes[16]
}
func (... | {
nnode := NewFullNode(t)
for i, node := range self.nodes {
if node != nil {
nnode.nodes[i] = node.Copy(t)
}
}
return nnode
} |
package main
import (
"log"
"net/http"
"os"
"os/user"
)
func main() {
startServer()
}
func certsExists(certFile string, keyFile string) bool {
for _, file := range []string{certFile, keyFile} {
_, err := os.Stat(file)
if os.IsNotExist(err) {
return false
}
}
return true
}
func findPort(ssl bool)... | {
usr, _ := user.Current()
return usr.Uid == "0"
} |
package private
import "testing"
func TestGetFreePort(t *testing.T) | {
p, _ := GetFreePort()
if p <= 0 {
t.Fatal("expecting > 0 port, got:", p)
}
} |
package simple
import (
"testing"
)
func TestEqualShouldFail(t *testing.T) | {
a := 1
b := 1
shouldNotBe := false
if real := equal(a, b); real == shouldNotBe {
t.Errorf("equal(%d, %d) should not be %v, but is:%v\n", a, b, shouldNotBe, real)
}
} |
package apigateway
import (
"github.com/oracle/oci-go-sdk/v46/common"
)
type RenameQueryParameterPolicyItem struct {
From *string `mandatory:"true" json:"from"`
To *string `mandatory:"true" json:"to"`
}
func (m RenameQueryParameterPolicyItem) String() string | {
return common.PointerString(m)
} |
package cpf
import (
"errors"
"strconv"
"strings"
)
func Valid(digits string) (bool, error) {
return valid(digits)
}
func sanitize(data string) string {
data = strings.Replace(data, ".", "", -1)
data = strings.Replace(data, "-", "", -1)
return data
}
const blacklist = `00000000000
11111111111
22222222222
... | {
data = sanitize(data)
if len(data) != 11 {
return false, errors.New("Invalid length")
}
if strings.Contains(blacklist, data) || !check(data) {
return false, errors.New("Invalid value")
}
return true, nil
} |
package api
import (
"github.com/gin-gonic/gin"
"github.com/mundipagg/boleto-api/models"
)
func validateRegisterV1(c *gin.Context) {
rules := getBoletoFromContext(c).Title.Rules
bn := getBankFromContext(c).GetBankNumber()
if rules != nil {
c.AbortWithStatusJSON(400, models.NewSingleErrorCollection("MP400", "... | {
r := getBoletoFromContext(c).Title.Rules
bn := getBankFromContext(c).GetBankNumber()
if r != nil && bn != models.Caixa {
c.AbortWithStatusJSON(400, models.NewSingleErrorCollection("MP400", "title.rules not available for this bank"))
return
}
} |
package commands
import (
log "github.com/sirupsen/logrus"
"github.com/jamesread/ovress/pkg/indexer"
"github.com/spf13/cobra"
)
func newIndexCmd() *cobra.Command {
var indexCmd = &cobra.Command{
Use: "index",
Short: "Indexes a file path",
Run: runIndexCmd,
Args: cobra.MinimumNArgs(1),
}
return inde... | {
rootCmd.AddCommand(newIndexCmd())
} |
package iptables
import (
"github.com/google/netstack/tcpip/buffer"
)
type Hook uint
const (
Prerouting Hook = iota
Input
Forward
Output
Postrouting
NumHooks
)
type Verdict int
const (
Accept Verdict = iota
Drop
Stolen
Queue
Repeat
None
Jump
Continue
Return
)
type IPTa... | {
return table.metadata
} |
package memory
import (
"github.com/golang/glog"
"github.com/google/trillian/monitoring"
"github.com/google/trillian/storage"
)
func init() {
if err := storage.RegisterProvider("memory", newMemoryStorageProvider); err != nil {
glog.Fatalf("Failed to register storage provider memory: %v", err)
}
}
type memProv... | {
return &memProvider{
mf: mf,
ts: NewTreeStorage(),
}, nil
} |
package core
import (
"fmt"
)
func PodContainerKey(namespace, podName, containerName string) string {
return fmt.Sprintf("namespace:%s/pod:%s/container:%s", namespace, podName, containerName)
}
func PodKey(namespace, podName string) string {
return fmt.Sprintf("namespace:%s/pod:%s", namespace, podName)
}
... | {
return fmt.Sprintf("namespace:%s", namespace)
} |
package fake
import (
"encoding/json"
"fmt"
"net/http"
"strings"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
)
type CFAPI struct {
server *ghttp.Server
}
type CFAPIConfig struct {
Routes map[string]Response
}
type Response struct {
Code int
Body interface{}
}
func NewCFAPI() *CFAPI {
serv... | {
result := map[string][]*http.Request{}
for _, req := range a.server.ReceivedRequests() {
key := fmt.Sprintf("%s %s", req.Method, req.URL.Path)
result[key] = append(result[key], req)
}
return result
} |
package next_permutation
func nextPermutation(nums []int) {
n := len(nums)
if n < 2 {
return
}
index := n - 1
for ; index > 0; index-- {
if nums[index-1] < nums[index] {
break
}
}
if index == 0 {
reverseSort(nums, 0, n-1)
return
}
val := nums[index-1]
j := n - 1
for ; j >= index && nums[j] <=... | {
if start > end {
return
}
for i := start; i <= (end+start)/2; i++ {
nums[i], nums[start+end-i] = nums[start+end-i], nums[i]
}
} |
package v1
import (
v1 "k8s.io/api/networking/v1"
"k8s.io/client-go/deprecated/scheme"
rest "k8s.io/client-go/rest"
)
type NetworkingV1Interface interface {
RESTClient() rest.Interface
NetworkPoliciesGetter
}
type NetworkingV1Client struct {
restClient rest.Interface
}
func (c *NetworkingV1Client) NetworkPol... | {
config := *c
if err := setConfigDefaults(&config); err != nil {
return nil, err
}
client, err := rest.RESTClientFor(&config)
if err != nil {
return nil, err
}
return &NetworkingV1Client{client}, nil
} |
package runtime
import (
"strings"
"github.com/Shopify/go-lua"
"github.com/fsouza/go-dockerclient"
"github.com/involucro/involucro/auth"
"github.com/involucro/involucro/ilog"
)
type pushStepBuilderState struct {
pushStep
upper fm
registerStep func(Step)
}
type pushStep struct {
docker.PushImageOptio... | {
parts := strings.Split(name, "/")
if len(parts) < 3 {
return ""
}
return strings.Join(parts[:len(parts)-2], "/")
} |
package main
import (
"flag"
"log"
"net/http"
"github.com/jackmanlabs/rpc/v2"
"github.com/jackmanlabs/rpc/v2/json2"
)
type Counter struct {
Count int
}
type IncrReq struct {
Delta int
}
func (c *Counter) Incr(r *http.Request, req *IncrReq, res *json2.EmptyResponse) error {
log.Printf("<- Incr %+v", *req)
... | {
log.Printf("<- Get %+v", *req)
*res = *c
log.Printf("-> %v", *res)
return nil
} |
package main
import (
"context"
"fmt"
"github.com/codegangsta/cli"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
)
func imagesCmd(ctx *cli.Context) {
client := getDockerClient()
if ctx.GlobalBool("force") {
cd := getCacheFile()
cd.reset()
}
if imgs, err := clie... | {
suseImages := make([]types.ImageSummary, 0, len(images))
cache := getCacheFile()
counter := 0
for _, img := range images {
select {
case <-killChannel:
return
default:
fmt.Printf("Inspecting image %d/%d\r", (counter + 1), len(images))
if cache.isSUSE(img.ID) {
suseImages = append(suseImages, i... |
package sample
import (
"fmt"
"math/rand"
)
type sampleState struct {
rate uint64
seed int64
sampleCount uint64
trueCount uint64
rnd *rand.Rand
}
type Sampler interface {
Sample() bool
SampleFrom(probe uint64) bool
State
}
type State interface {
Reset()
String() string
Rate() ... | {
if state != nil {
return state.rate
}
return 0
} |
package gce
import (
"context"
"github.com/supergiant/control/pkg/clouds/gcesdk"
"io"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
"github.com/supergiant/control/pkg/workflows/steps"
"google.golang.org/api/compute/v1"
)
const DeleteTargetPoolStepName = "gce_delete_target_pool"
type DeleteTargetPoolSt... | {
return &DeleteTargetPoolStep{
getComputeSvc: func(ctx context.Context, config steps.GCEConfig) (*computeService, error) {
client, err := gcesdk.GetClient(ctx, config)
if err != nil {
return nil, err
}
return &computeService{
deleteTargetPool: func(ctx context.Context, config steps.GCEConfig, ... |
package local
import (
"context"
"os"
"path/filepath"
"github.com/grafana/loki/pkg/storage/chunk"
)
type TableClient struct {
directory string
}
func NewTableClient(directory string) (chunk.TableClient, error) {
return &TableClient{directory: directory}, nil
}
func (c *TableClient) ListTables(ctx context.Co... | {
return nil
} |
package main
func Build(srcPath, targetPath string) (files Files, err error) | {
files, err = ReadFiles(srcPath)
if err != nil {
logger.Error("Read", "err", err)
return
}
err = TransformFiles(files)
if err != nil {
logger.Error("Transform", "err", err)
return
}
err = WriteFiles(files, targetPath)
if err != nil {
logger.Error("Write", "err", err)
return
}
return
} |
package ftp
import "io"
type debugWrapper struct {
conn io.ReadWriteCloser
io.Reader
io.Writer
}
func newDebugWrapper(conn io.ReadWriteCloser, w io.Writer) io.ReadWriteCloser {
return &debugWrapper{
Reader: io.TeeReader(conn, w),
Writer: io.MultiWriter(w, conn),
conn: conn,
}
}
func (w *debugWrapper) C... | {
return w.closer.Close()
} |
package database
import (
"github.com/oracle/oci-go-sdk/common"
"net/http"
)
type TerminateDbSystemRequest struct {
DbSystemId *string `mandatory:"true" contributesTo:"path" name:"dbSystemId"`
IfMatch *string `mandatory:"false" contributesTo:"header" name:"if-match"`
OpcRequestId *string `mandatory:"false" c... | {
return request.RequestMetadata.RetryPolicy
} |
package graph
import (
"fmt"
"github.com/gonum/graph"
"github.com/gonum/graph/concrete"
"github.com/gonum/graph/encoding/dot"
)
type Node struct {
Id int
UniqueName string
LabelName string
Color string
}
func (n Node) ID() int {
return n.Id
}
func (n Node) DOTAttributes() []dot.Attribute {
... | {
if _, exists := g.nodesByName[n.UniqueName]; exists {
return fmt.Errorf("node .UniqueName collision: %s", n.UniqueName)
}
g.nodesByName[n.UniqueName] = n
g.DirectedGraph.AddNode(n)
return nil
} |
package tcp
import (
"net"
"strconv"
"github.com/reinit/coward/roles/common/network"
)
type listener struct {
host net.IP
port uint16
connectionWrapper network.ConnectionWrapper
}
type acceptor struct {
listener *net.TCPListener
connectionWrapper network.ConnectionWrappe... | {
accepted, acceptErr := a.listener.AcceptTCP()
if acceptErr != nil {
return nil, acceptErr
}
optErr := accepted.SetLinger(0)
if optErr != nil {
return nil, optErr
}
optErr = accepted.SetNoDelay(false)
if optErr != nil {
return nil, optErr
}
return a.connectionWrapper(accepted), nil
} |
package clipboard
import (
ps "github.com/mitchellh/go-ps"
)
func killPrecedessors() error | {
procs, err := ps.Processes()
if err != nil {
return err
}
for _, proc := range procs {
walkFn(proc.Pid(), killProc)
}
return nil
} |
package collector
import (
"fmt"
"strconv"
"github.com/go-kit/kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
type softnetCollector struct {
fs procfs.FS
processed *prometheus.Desc
dropped *prometheus.Desc
timeSqueezed *prometheus.Desc
logger ... | {
stats, err := c.fs.NetSoftnetStat()
if err != nil {
return fmt.Errorf("could not get softnet statistics: %s", err)
}
for cpuNumber, cpuStats := range stats {
cpu := strconv.Itoa(cpuNumber)
ch <- prometheus.MustNewConstMetric(
c.processed,
prometheus.CounterValue,
float64(cpuStats.Processed),
c... |
package aes
import (
"crypto/aes"
"crypto/cipher"
"github.com/golang/glog"
)
type aesInfo struct {
keyLen int
ivLen int
}
var info = map[string]aesInfo{
"aes-128-cfb": aesInfo{keyLen: 16, ivLen: 16},
"aes-192-cfb": aesInfo{keyLen: 24, ivLen: 16},
"aes-256-cfb": aesInfo{keyLen: 32, ivLen: 16},
}
type AES ... | {
v, ok := info[a.Name]
if !ok {
return 0
}
return v.ivLen
} |
package utils
import (
"github.com/labstack/gommon/log"
"io/ioutil"
"os"
"path/filepath"
)
func UpdateFile(file, val string) error {
dir := filepath.Dir(file)
log.Info("creating dir %s", dir)
dir, err := CreateDirIfReqd(dir)
if err != nil {
return err
}
ioutil.WriteFile(filepath.Join(dir, filepath.Base(fi... | {
dirAbsPath, err := filepath.Abs(dir)
if err != nil {
return dirAbsPath, err
}
if _, err := os.Stat(dirAbsPath); err == nil {
return dirAbsPath, nil
}
err = os.MkdirAll(dirAbsPath, 0777)
return dirAbsPath, err
} |
package main
import (
"fmt"
"math"
)
func main() {
fmt.Println(Reverse(-27))
fmt.Println(Reverse(314))
}
func Reverse(d int) (r int) | {
factors := make([]int, 0, 0)
isNeg := false
if d < 0 {
isNeg = true
d *= -1
}
for {
if d == 0 {
break
} else {
factors = append(factors, d%10)
d = d / 10
}
}
for i, v := range factors {
r += v * int(math.Pow10(len(factors)-1-i))
}
if isNeg {
r *= -1
}
return r
} |
package test_helpers
import (
"encoding/json"
"errors"
datatypes "github.com/maximilien/softlayer-go/data_types"
)
type MockProductPackageService struct{}
func (mock *MockProductPackageService) GetName() string {
return "Mock_Product_Package_Service"
}
func (mock *MockProductPackageService) GetItemsByType(packa... | {
return []datatypes.SoftLayer_Product_Item_Price{}, errors.New("Not supported")
} |
package train
import (
"io"
"log"
"net/http"
"path"
"strings"
)
var assetServer *http.Handler
var publicAssetServer *http.Handler
func servePublicAssets(w http.ResponseWriter, r *http.Request) {
(*publicAssetServer).ServeHTTP(w, r)
}
var contentTypes = map[string]string{
".js": "application/javascript",
".... | {
if assetServer == nil {
server := http.FileServer(http.Dir(Config.AssetsPath + "/.."))
assetServer = &server
}
if publicAssetServer == nil {
server := http.FileServer(http.Dir("public"))
publicAssetServer = &server
}
} |
package p10
import (
"fmt"
c "s13g.com/euler/common"
)
func Solve(input string) (string, string) {
return c.ToString(solveA(c.ParseIntArray(c.SplitByCommaTrim(input)))), solveB(input)
}
func solveA(lengths []int) int {
numbers := ProcessLengths(lengths, 1)
return numbers[0] * numbers[1]
}
func solveB(input ... | {
reverseCircular := func(list []int, start int, length int) {
for l, r := start, start+length-1; l < r; l, r = l+1, r-1 {
ll, rr := l%len(list), r%len(list)
list[ll], list[rr] = list[rr], list[ll]
}
}
numbers := make([]int, 256)
for i := range numbers {
numbers[i] = i
}
currPos, skipSize := 0, 0
f... |
package operations
import (
"github.com/asuleymanov/golos-go/encoding/transaction"
)
type BreakFreeReferralOperation struct {
Referral string `json:"referral"`
Extensions []interface{} `json:"extensions"`
}
func (op *BreakFreeReferralOperation) Type() OpType {
return TypeBreakFreeReferral
}
func (op... | {
enc := transaction.NewRollingEncoder(encoder)
enc.EncodeUVarint(uint64(TypeBreakFreeReferral.Code()))
enc.Encode(op.Referral)
enc.Encode(byte(0))
return enc.Err()
} |
package misc
import (
"net/http"
"strconv"
"time"
)
type Writer interface {
http.ResponseWriter
http.Hijacker
}
func ElapsedTime(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
nw := elapsedTimeResponseWriter{
Writer: w.(Writer),
Timestamp: time.Now().UnixNano(),
written: false,
... | {
if e.written == false {
e.WriteHeader(http.StatusOK)
}
return e.Writer.Write(data)
} |
package events
import (
"fmt"
corev1 "k8s.io/api/core/v1"
"k8s.io/klog"
)
type LoggingEventRecorder struct {
component string
}
func NewLoggingEventRecorder(component string) Recorder {
return &LoggingEventRecorder{component: component}
}
func (r *LoggingEventRecorder) ComponentName() string {
return r.comp... | {
r.Event(reason, fmt.Sprintf(messageFmt, args...))
} |
package custom_commands
import (
"github.com/jmoiron/sqlx"
"github.com/sgt-kabukiman/kabukibot/bot"
)
type pluginStruct struct {
db *sqlx.DB
}
func NewPlugin() *pluginStruct {
return &pluginStruct{}
}
func (self *pluginStruct) Name() string {
return "custom_commands"
}
func (self *pluginStruct) Setup(bot *bot... | {
return &worker{
channel: channel,
acl: channel.ACL(),
db: self.db,
}
} |
package thread
import "time"
type ThreadStatistic struct {
ThreadId int `json:"thread_id"`
ProcessedLines int `json:"processed_lines"`
StartTime time.Time `json:"start_time"`
EndTime time.Time `json:"end_time"`
DeltaTime time.Duration `json:"delta_time"`
}
func... | {
ts.ProcessedLines += 1
} |
package osc
import (
"net"
"testing"
)
func TestValidateAddress(t *testing.T) {
if err := ValidateAddress("/foo"); err != nil {
t.Fatal(err)
}
if err := ValidateAddress("/foo@^#&*$^*%)()#($*@"); err == nil {
t.Fatal("expected error, got nil")
}
}
func TestUDPConn(t *testing.T) | {
laddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
lc, err := ListenUDP("udp", laddr)
if err != nil {
t.Fatal(err)
}
var c Conn = lc
_ = c
} |
package main
import (
"log"
"net/http"
)
func main() {
http.HandleFunc("/", droneServer)
err := http.ListenAndServe(":8080", nil)
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
}
func droneServer(w http.ResponseWriter, req *http.Request) | {
w.Write([]byte("Built by Drone in Kubernetes!"))
} |
package vflag
import "strings"
import "net/url"
type URL struct {
Raw string
Solt *url.URL
Schemes *[]string
RequirePort bool
}
func (val URL) String() string {
return val.Raw
}
func (val URL) Set(urlArg string) error | {
var err error = nil
var u *url.URL = nil
var isValid bool = false
if u, err = url.Parse(urlArg); err != nil {
return err
}
if strings.Index(u.Host, ":") == -1 && val.RequirePort {
return ErrUrlNoPort
}
if val.Schemes != nil {
for _, s := range *val.Schemes {
if s == u.Scheme {
isValid = true
... |
package main
import "fmt"
func main() {
c := incrementor()
cSum := puller(c)
for n := range cSum {
fmt.Println(n)
}
}
func puller(c chan int) chan int {
out := make(chan int)
go func() {
var sum int
for n := range c {
sum += n
}
out <- sum
close(out)
}()
return out
}
func incrementor() chan... | {
out := make(chan int)
go func() {
for i := 0; i < 10; i++ {
out <- i
}
close(out)
}()
return out
} |
package keys
import "context"
type keySetType int
const keySet = keySetType(0)
func WithValue(ctx context.Context, key interface{}, value interface{}) context.Context {
old, _ := ctx.Value(keySet).(*Link)
ctx = context.WithValue(ctx, key, value)
return context.WithValue(ctx, keySet, &Link{Value: key, Next:... | {
seen := map[interface{}]bool{}
result := make([]interface{}, 0, 10)
for link, _ := ctx.Value(keySet).(*Link); link != nil; link = link.Next {
if !seen[link.Value] {
seen[link.Value] = true
result = append(result, link.Value)
}
}
return result
} |
package memdb
type Changes []Change
type Change struct {
Table string
Before interface{}
After interface{}
primaryKey []byte
}
func (m *Change) Updated() bool {
return m.Before != nil && m.After != nil
}
func (m *Change) Deleted() bool {
return m.Before != nil && m.After == nil
}
func (m *Change... | {
return m.Before == nil && m.After != nil
} |
package collector
import (
"errors"
"strconv"
"unsafe"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
import "C"
const maxCPUTimesLen = C.MAXCPU * C.CPUSTATES
type statCollector struct {
cpu *prometheus.Desc
logger log.Logger
}
func init() {
registerCollector("cpu", default... | {
var fieldsCount = 5
cpuTimes, err := getDragonFlyCPUTimes()
if err != nil {
return err
}
cpuFields := []string{"user", "nice", "sys", "interrupt", "idle"}
for i, value := range cpuTimes {
cpux := strconv.Itoa(i / fieldsCount)
ch <- prometheus.MustNewConstMetric(c.cpu, prometheus.CounterValue, value, cpux... |
package models
import (
"database/sql"
"github.com/BrandonRomano/serf"
db "github.com/carrot/burrow/db/postgres"
"time"
)
type Topic struct {
serf.Worker `json:"-"`
Id int64 `json:"id"`
Name string `json:"name"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"upd... | {
database := db.Get()
rows, err := database.Query("SELECT * FROM topics ORDER BY created_at LIMIT $1 OFFSET $2", limit, offset)
if err != nil {
return nil, err
}
defer rows.Close()
var topics []Topic = []Topic{}
for rows.Next() {
t := new(Topic)
err = t.consumeNextRow(rows)
if err != nil {
return n... |
package chapter3_cf
type SourceFileAttribute struct {
cp ConstantPool
sourceFileIndex uint16
}
func (self *SourceFileAttribute) FileName() string {
return self.cp.getUtf8(self.sourceFileIndex)
}
func (self *SourceFileAttribute) readInfo(reader *ClassReader) | {
self.sourceFileIndex = reader.readUint16()
} |
package server
import (
"encoding/json"
"fmt"
"net/http"
"github.com/Arvinderpal/go-storage-server/challenge/common/backend"
"github.com/Arvinderpal/go-storage-server/challenge/common/types"
"github.com/gorilla/mux"
)
type Router struct {
*mux.Router
routes routes
daemon backend.DaemonBackend
}
func New... | {
w.WriteHeader(http.StatusInternalServerError)
w.Header().Set("Content-Type", "application/json")
sErr := types.ServerError{
Code: http.StatusInternalServerError,
Text: fmt.Sprintf("an unexpected internal error has occurred: \"%s\"", err),
}
logger.Debugf("Processing error %s\n", sErr)
logger.Errorf("Error w... |
package main
import (
"encoding/json"
"log"
"os"
"path/filepath"
"time"
)
type Player struct {
log *os.File
logTime time.Time
decoder *json.Decoder
dir string
offset time.Duration
}
func NewPlayer(dir string) *Player {
var p Player
p.dir = dir
return &p
}
func (p *Player) Reset() error {
n :=... | {
log.Printf("Playing back starting at %s\n", t)
p.offset = time.Now().Sub(t)
err := p.Reset()
if err != nil {
return err
}
for {
var m Msg
err := p.decoder.Decode(&m)
if err != nil {
return err
}
d := m.Timestamp.Time.Sub(p.Then())
debugf("difference is %f seconds", d.Seconds())
if d > 0 {
... |
package requestutil
import (
"bytes"
"crypto/tls"
"net/http"
"net/url"
"github.com/hashicorp/vault/helper/compressutil"
"github.com/hashicorp/vault/helper/jsonutil"
)
type bufCloser struct {
*bytes.Buffer
}
func (b bufCloser) Close() error {
b.Reset()
return nil
}
type ForwardedRequest struct {
Method st... | {
buf := bufCloser{
Buffer: bytes.NewBuffer(nil),
}
_, err := buf.ReadFrom(req.Body)
if err != nil {
return nil, err
}
var fq ForwardedRequest
err = jsonutil.DecodeJSON(buf.Bytes(), &fq)
if err != nil {
return nil, err
}
buf.Reset()
_, err = buf.Write(fq.Body)
if err != nil {
return nil, err
}
... |
package cronsun
import (
"encoding/hex"
"github.com/rogpeppe/fastuuid"
)
var generator *fastuuid.Generator
func NextID() string {
id := generator.Next()
return hex.EncodeToString(id[:])
}
func initID() (err error) | {
generator, err = fastuuid.NewGenerator()
return
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.