_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q182600 | Close | test | func (m *Nitro) Close() {
// Wait until all snapshot iterators have finished
for s := m.snapshots.GetStats(); int(s.NodeCount) != 0; s = m.snapshots.GetStats() {
time.Sleep(time.Millisecond)
}
m.hasShutdown = true
// Acquire gc chan ownership
// This will make sure that no other goroutine will write to gcchan
for !atomic.CompareAndSwapInt32(&m.isGCRunning, 0, 1) {
time.Sleep(time.Millisecond)
}
close(m.gcchan)
buf := dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
dbInstances.Delete(unsafe.Pointer(m), CompareNitro, buf, &dbInstances.Stats)
if m.useMemoryMgmt {
buf := m.snapshots.MakeBuf()
defer m.snapshots.FreeBuf(buf)
m.shutdownWg1.Wait()
close(m.freechan)
m.shutdownWg2.Wait()
// Manually free up all nodes
iter := m.store.NewIterator(m.iterCmp, buf)
defer iter.Close()
var lastNode *skiplist.Node
iter.SeekFirst()
if iter.Valid() {
lastNode = iter.GetNode()
iter.Next()
}
for lastNode != nil {
m.freeItem((*Item)(lastNode.Item()))
m.store.FreeNode(lastNode, &m.store.Stats)
lastNode = nil
if iter.Valid() {
lastNode = iter.GetNode()
iter.Next()
}
}
}
} | go | {
"resource": ""
} |
q182601 | NewWriter | test | func (m *Nitro) NewWriter() *Writer {
w := m.newWriter()
w.next = m.wlist
m.wlist = w
w.dwrCtx.Init()
m.shutdownWg1.Add(1)
go m.collectionWorker(w)
if m.useMemoryMgmt {
m.shutdownWg2.Add(1)
go m.freeWorker(w)
}
return w
} | go | {
"resource": ""
} |
q182602 | SnapshotSize | test | func SnapshotSize(p unsafe.Pointer) int {
s := (*Snapshot)(p)
return int(unsafe.Sizeof(s.sn) + unsafe.Sizeof(s.refCount) + unsafe.Sizeof(s.db) +
unsafe.Sizeof(s.count) + unsafe.Sizeof(s.gclist))
} | go | {
"resource": ""
} |
q182603 | Encode | test | func (s *Snapshot) Encode(buf []byte, w io.Writer) error {
l := 4
if len(buf) < l {
return errNotEnoughSpace
}
binary.BigEndian.PutUint32(buf[0:4], s.sn)
if _, err := w.Write(buf[0:4]); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q182604 | Decode | test | func (s *Snapshot) Decode(buf []byte, r io.Reader) error {
if _, err := io.ReadFull(r, buf[0:4]); err != nil {
return err
}
s.sn = binary.BigEndian.Uint32(buf[0:4])
return nil
} | go | {
"resource": ""
} |
q182605 | Open | test | func (s *Snapshot) Open() bool {
if atomic.LoadInt32(&s.refCount) == 0 {
return false
}
atomic.AddInt32(&s.refCount, 1)
return true
} | go | {
"resource": ""
} |
q182606 | CompareSnapshot | test | func CompareSnapshot(this, that unsafe.Pointer) int {
thisItem := (*Snapshot)(this)
thatItem := (*Snapshot)(that)
return int(thisItem.sn) - int(thatItem.sn)
} | go | {
"resource": ""
} |
q182607 | GC | test | func (m *Nitro) GC() {
if atomic.CompareAndSwapInt32(&m.isGCRunning, 0, 1) {
m.collectDead()
atomic.CompareAndSwapInt32(&m.isGCRunning, 1, 0)
}
} | go | {
"resource": ""
} |
q182608 | GetSnapshots | test | func (m *Nitro) GetSnapshots() []*Snapshot {
var snaps []*Snapshot
buf := m.snapshots.MakeBuf()
defer m.snapshots.FreeBuf(buf)
iter := m.snapshots.NewIterator(CompareSnapshot, buf)
iter.SeekFirst()
for ; iter.Valid(); iter.Next() {
snaps = append(snaps, (*Snapshot)(iter.Get()))
}
return snaps
} | go | {
"resource": ""
} |
q182609 | MemoryInUse | test | func MemoryInUse() (sz int64) {
buf := dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
iter := dbInstances.NewIterator(CompareNitro, buf)
for iter.SeekFirst(); iter.Valid(); iter.Next() {
db := (*Nitro)(iter.Get())
sz += db.MemoryInUse()
}
return
} | go | {
"resource": ""
} |
q182610 | CompareBS | test | func CompareBS(this, that unsafe.Pointer) int {
thisItm := (*BarrierSession)(this)
thatItm := (*BarrierSession)(that)
return int(thisItm.seqno) - int(thatItm.seqno)
} | go | {
"resource": ""
} |
q182611 | Acquire | test | func (ab *AccessBarrier) Acquire() *BarrierSession {
if ab.active {
retry:
bs := (*BarrierSession)(atomic.LoadPointer(&ab.session))
liveCount := atomic.AddInt32(bs.liveCount, 1)
if liveCount > barrierFlushOffset {
ab.Release(bs)
goto retry
}
return bs
}
return nil
} | go | {
"resource": ""
} |
q182612 | Release | test | func (ab *AccessBarrier) Release(bs *BarrierSession) {
if ab.active {
liveCount := atomic.AddInt32(bs.liveCount, -1)
if liveCount == barrierFlushOffset {
buf := ab.freeq.MakeBuf()
defer ab.freeq.FreeBuf(buf)
// Accessors which entered a closed barrier session steps down automatically
// But, they may try to close an already closed session.
if atomic.AddInt32(&bs.closed, 1) == 1 {
ab.freeq.Insert(unsafe.Pointer(bs), CompareBS, buf, &ab.freeq.Stats)
if atomic.CompareAndSwapInt32(&ab.isDestructorRunning, 0, 1) {
ab.doCleanup()
atomic.CompareAndSwapInt32(&ab.isDestructorRunning, 1, 0)
}
}
}
}
} | go | {
"resource": ""
} |
q182613 | FlushSession | test | func (ab *AccessBarrier) FlushSession(ref unsafe.Pointer) {
if ab.active {
ab.Lock()
defer ab.Unlock()
bsPtr := atomic.LoadPointer(&ab.session)
newBsPtr := unsafe.Pointer(newBarrierSession())
atomic.CompareAndSwapPointer(&ab.session, bsPtr, newBsPtr)
bs := (*BarrierSession)(bsPtr)
bs.objectRef = ref
ab.activeSeqno++
bs.seqno = ab.activeSeqno
atomic.AddInt32(bs.liveCount, barrierFlushOffset+1)
ab.Release(bs)
}
} | go | {
"resource": ""
} |
q182614 | Apply | test | func (report *StatsReport) Apply(s *Stats) {
var totalNextPtrs int
var totalNodes int
report.ReadConflicts += s.readConflicts
report.InsertConflicts += s.insertConflicts
for i, c := range s.levelNodesCount {
report.NodeDistribution[i] += c
nodesAtlevel := report.NodeDistribution[i]
totalNodes += int(nodesAtlevel)
totalNextPtrs += (i + 1) * int(nodesAtlevel)
}
report.SoftDeletes += s.softDeletes
report.NodeCount = totalNodes
report.NextPointersPerNode = float64(totalNextPtrs) / float64(totalNodes)
report.NodeAllocs += s.nodeAllocs
report.NodeFrees += s.nodeFrees
report.Memory += s.usedBytes
} | go | {
"resource": ""
} |
q182615 | AddInt64 | test | func (s *Stats) AddInt64(src *int64, val int64) {
if s.isLocal {
*src += val
} else {
atomic.AddInt64(src, val)
}
} | go | {
"resource": ""
} |
q182616 | AddUint64 | test | func (s *Stats) AddUint64(src *uint64, val uint64) {
if s.isLocal {
*src += val
} else {
atomic.AddUint64(src, val)
}
} | go | {
"resource": ""
} |
q182617 | Merge | test | func (s *Stats) Merge(sts *Stats) {
atomic.AddUint64(&s.insertConflicts, sts.insertConflicts)
sts.insertConflicts = 0
atomic.AddUint64(&s.readConflicts, sts.readConflicts)
sts.readConflicts = 0
atomic.AddInt64(&s.softDeletes, sts.softDeletes)
sts.softDeletes = 0
atomic.AddInt64(&s.nodeAllocs, sts.nodeAllocs)
sts.nodeAllocs = 0
atomic.AddInt64(&s.nodeFrees, sts.nodeFrees)
sts.nodeFrees = 0
atomic.AddInt64(&s.usedBytes, sts.usedBytes)
sts.usedBytes = 0
for i, val := range sts.levelNodesCount {
if val != 0 {
atomic.AddInt64(&s.levelNodesCount[i], val)
sts.levelNodesCount[i] = 0
}
}
} | go | {
"resource": ""
} |
q182618 | GetStats | test | func (s *Skiplist) GetStats() StatsReport {
var report StatsReport
report.Apply(&s.Stats)
return report
} | go | {
"resource": ""
} |
q182619 | NewIterator | test | func (s *Skiplist) NewIterator(cmp CompareFn,
buf *ActionBuffer) *Iterator {
return &Iterator{
cmp: cmp,
s: s,
buf: buf,
bs: s.barrier.Acquire(),
}
} | go | {
"resource": ""
} |
q182620 | SeekFirst | test | func (it *Iterator) SeekFirst() {
it.prev = it.s.head
it.curr, _ = it.s.head.getNext(0)
it.valid = true
} | go | {
"resource": ""
} |
q182621 | SeekWithCmp | test | func (it *Iterator) SeekWithCmp(itm unsafe.Pointer, cmp CompareFn, eqCmp CompareFn) bool {
var found bool
if found = it.s.findPath(itm, cmp, it.buf, &it.s.Stats) != nil; found {
it.prev = it.buf.preds[0]
it.curr = it.buf.succs[0]
} else {
if found = eqCmp != nil && compare(eqCmp, itm, it.buf.preds[0].Item()) == 0; found {
it.prev = nil
it.curr = it.buf.preds[0]
}
}
return found
} | go | {
"resource": ""
} |
q182622 | Seek | test | func (it *Iterator) Seek(itm unsafe.Pointer) bool {
it.valid = true
found := it.s.findPath(itm, it.cmp, it.buf, &it.s.Stats) != nil
it.prev = it.buf.preds[0]
it.curr = it.buf.succs[0]
return found
} | go | {
"resource": ""
} |
q182623 | Valid | test | func (it *Iterator) Valid() bool {
if it.valid && it.curr == it.s.tail {
it.valid = false
}
return it.valid
} | go | {
"resource": ""
} |
q182624 | Delete | test | func (it *Iterator) Delete() {
it.s.softDelete(it.curr, &it.s.Stats)
// It will observe that current item is deleted
// Run delete helper and move to the next possible item
it.Next()
it.deleted = true
} | go | {
"resource": ""
} |
q182625 | Next | test | func (it *Iterator) Next() {
if it.deleted {
it.deleted = false
return
}
retry:
it.valid = true
next, deleted := it.curr.getNext(0)
if deleted {
// Current node is deleted. Unlink current node from the level
// and make next node as current node.
// If it fails, refresh the path buffer and obtain new current node.
if it.s.helpDelete(0, it.prev, it.curr, next, &it.s.Stats) {
it.curr = next
} else {
atomic.AddUint64(&it.s.Stats.readConflicts, 1)
found := it.s.findPath(it.curr.Item(), it.cmp, it.buf, &it.s.Stats) != nil
last := it.curr
it.prev = it.buf.preds[0]
it.curr = it.buf.succs[0]
if found && last == it.curr {
goto retry
}
}
} else {
it.prev = it.curr
it.curr = next
}
} | go | {
"resource": ""
} |
q182626 | Init | test | func Init() {
s := new(SkuM1SmallBuilder)
s.Client, _ = new(SkuM1Small).GetInnkeeperClient()
skurepo.Register(SkuName, s)
} | go | {
"resource": ""
} |
q182627 | FromURL | test | func FromURL(url string) string {
result := url
for _, replace := range replaces {
result = strings.Replace(result, replace.a, replace.b, -1)
}
return result
} | go | {
"resource": ""
} |
q182628 | ToURL | test | func ToURL(folder string) string {
result := folder
for _, replace := range replaces {
result = strings.Replace(result, replace.b, replace.a, -1)
}
return result
} | go | {
"resource": ""
} |
q182629 | Size | test | func (t *TupleHeader) Size() int {
return VersionOneTupleHeaderSize + int(t.FieldSize)*int(t.FieldCount)
} | go | {
"resource": ""
} |
q182630 | WriteTo | test | func (t *TupleHeader) WriteTo(w io.Writer) (int64, error) {
if len(t.Offsets) != int(t.FieldCount) {
return 0, errors.New("Invalid Header: Field count does not equal number of field offsets")
}
// Encode Header
dst := make([]byte, t.Size())
dst[0] = byte(t.TupleVersion)
binary.LittleEndian.PutUint32(dst[1:], t.NamespaceHash)
binary.LittleEndian.PutUint32(dst[5:], t.Hash)
binary.LittleEndian.PutUint32(dst[9:], t.FieldCount)
pos := int64(13)
switch t.FieldSize {
case 1:
// Write field offsets
for _, offset := range t.Offsets {
dst[pos] = byte(offset)
pos++
}
case 2:
// Set size enum
dst[0] |= 64
// Write field offsets
for _, offset := range t.Offsets {
binary.LittleEndian.PutUint16(dst[pos:], uint16(offset))
pos += 2
}
case 4:
// Set size enum
dst[0] |= 128
// Write field offsets
for _, offset := range t.Offsets {
binary.LittleEndian.PutUint32(dst[pos:], uint32(offset))
pos += 4
}
case 8:
// Set size enum
dst[0] |= 192
// Write field offsets
for _, offset := range t.Offsets {
binary.LittleEndian.PutUint64(dst[pos:], offset)
pos += 8
}
default:
return pos, errors.New("Invalid Header: Field size must be 1,2,4 or 8 bytes")
}
n, err := w.Write(dst)
return int64(n), err
} | go | {
"resource": ""
} |
q182631 | Static | test | func Static(directory string, staticOpt ...StaticOptions) Handler {
if !path.IsAbs(directory) {
directory = path.Join(Root, directory)
}
dir := http.Dir(directory)
opt := prepareStaticOptions(staticOpt)
return func(res http.ResponseWriter, req *http.Request, log *log.Logger) {
if req.Method != "GET" && req.Method != "HEAD" {
return
}
file := req.URL.Path
// if we have a prefix, filter requests by stripping the prefix
if opt.Prefix != "" {
if !strings.HasPrefix(file, opt.Prefix) {
return
}
file = file[len(opt.Prefix):]
if file != "" && file[0] != '/' {
return
}
}
f, err := dir.Open(file)
if err != nil {
// discard the error?
return
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return
}
// try to serve index file
if fi.IsDir() {
// redirect if missing trailing slash
if !strings.HasSuffix(req.URL.Path, "/") {
http.Redirect(res, req, req.URL.Path+"/", http.StatusFound)
return
}
file = path.Join(file, opt.IndexFile)
f, err = dir.Open(file)
if err != nil {
return
}
defer f.Close()
fi, err = f.Stat()
if err != nil || fi.IsDir() {
return
}
}
if !opt.SkipLogging {
log.Println("[Static] Serving " + file)
}
// Add an Expires header to the static content
if opt.Expires != nil {
res.Header().Set("Expires", opt.Expires())
}
http.ServeContent(res, req, file, fi.ModTime(), f)
}
} | go | {
"resource": ""
} |
q182632 | Read | test | func (c *Config) Read() error {
in, err := os.Open(c.filename)
if err != nil {
return err
}
defer in.Close()
scanner := bufio.NewScanner(in)
line := ""
section := ""
for scanner.Scan() {
if scanner.Text() == "" {
continue
}
if line == "" {
sec, ok := checkSection(scanner.Text())
if ok {
section = sec
continue
}
}
if checkComment(scanner.Text()) {
continue
}
line += scanner.Text()
if strings.HasSuffix(line, "\\") {
line = line[:len(line)-1]
continue
}
key, value, ok := checkLine(line)
if !ok {
return errors.New("WRONG: " + line)
}
c.Set(section, key, value)
line = ""
}
return nil
} | go | {
"resource": ""
} |
q182633 | Del | test | func (c *Config) Del(section string, key string) {
_, ok := c.config[section]
if ok {
delete(c.config[section], key)
if len(c.config[section]) == 0 {
delete(c.config, section)
}
}
} | go | {
"resource": ""
} |
q182634 | WriteTo | test | func (c *Config) WriteTo(filename string) error {
content := ""
for k, v := range c.config {
format := "%v = %v\n"
if k != "" {
content += fmt.Sprintf("[%v]\n", k)
format = "\t" + format
}
for key, value := range v {
content += fmt.Sprintf(format, key, value)
}
}
return ioutil.WriteFile(filename, []byte(content), 0644)
} | go | {
"resource": ""
} |
q182635 | checkSection | test | func checkSection(line string) (string, bool) {
line = strings.TrimSpace(line)
lineLen := len(line)
if lineLen < 2 {
return "", false
}
if line[0] == '[' && line[lineLen-1] == ']' {
return line[1 : lineLen-1], true
}
return "", false
} | go | {
"resource": ""
} |
q182636 | checkLine | test | func checkLine(line string) (string, string, bool) {
key := ""
value := ""
sp := strings.SplitN(line, "=", 2)
if len(sp) != 2 {
return key, value, false
}
key = strings.TrimSpace(sp[0])
value = strings.TrimSpace(sp[1])
return key, value, true
} | go | {
"resource": ""
} |
q182637 | checkComment | test | func checkComment(line string) bool {
line = strings.TrimSpace(line)
for p := range commentPrefix {
if strings.HasPrefix(line, commentPrefix[p]) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q182638 | NewResponseWrapper | test | func NewResponseWrapper(w http.ResponseWriter) *ResponseWrapper {
return &ResponseWrapper{ResponseRecorder: httptest.NewRecorder(), writer: w}
} | go | {
"resource": ""
} |
q182639 | Hijack | test | func (w *ResponseWrapper) Hijack() (net.Conn, *bufio.ReadWriter, error) {
if hijacker, ok := w.writer.(http.Hijacker); ok {
c, rw, err := hijacker.Hijack()
if err == nil {
w.Hijacked = true
}
return c, rw, err
}
return nil, nil, errors.New("Wrapped ResponseWriter is not a Hijacker")
} | go | {
"resource": ""
} |
q182640 | CloseNotify | test | func (w *ResponseWrapper) CloseNotify() <-chan bool {
if notifier, ok := w.writer.(http.CloseNotifier); ok {
c := notifier.CloseNotify()
return c
}
return make(chan bool)
} | go | {
"resource": ""
} |
q182641 | DateFormat | test | func DateFormat(f string) Option {
return Option{func(o *options) {
o.dateFormat = f
}}
} | go | {
"resource": ""
} |
q182642 | Logger | test | func Logger(next http.Handler) http.HandlerFunc {
stdlogger := log.New(os.Stdout, "", 0)
//errlogger := log.New(os.Stderr, "", 0)
return func(w http.ResponseWriter, r *http.Request) {
// Start timer
start := time.Now()
// Process request
writer := statusWriter{w, 0}
next.ServeHTTP(&writer, r)
// Stop timer
end := time.Now()
latency := end.Sub(start)
clientIP := r.RemoteAddr
method := r.Method
statusCode := writer.status
statusColor := colorForStatus(statusCode)
methodColor := colorForMethod(method)
stdlogger.Printf("[HTTP] %v |%s %3d %s| %12v | %s |%s %s %-7s %s\n",
end.Format("2006/01/02 - 15:04:05"),
statusColor, statusCode, reset,
latency,
clientIP,
methodColor, reset, method,
r.URL.Path,
)
}
} | go | {
"resource": ""
} |
q182643 | GetAvailableInventory | test | func GetAvailableInventory(taskCollection integrations.Collection) (inventory map[string]skurepo.SkuBuilder) {
inventory = skurepo.GetRegistry()
onceLoadInventoryPoller.Do(func() {
startTaskPollingForRegisteredSkus(taskCollection)
})
return
} | go | {
"resource": ""
} |
q182644 | Expiration | test | func Expiration(e time.Duration) TokenOpt {
return TokenOpt{func(o *options) {
o.expiration = e
}}
} | go | {
"resource": ""
} |
q182645 | Claimer | test | func Claimer(c func(claims *jwt.StandardClaims) jwt.Claims) TokenOpt {
return TokenOpt{func(o *options) {
o.claimer = c
}}
} | go | {
"resource": ""
} |
q182646 | Issuer | test | func Issuer(issuer string) TokenOpt {
return TokenOpt{func(o *options) {
o.issuer = issuer
}}
} | go | {
"resource": ""
} |
q182647 | User | test | func User(user string) TokenOpt {
return TokenOpt{func(o *options) {
o.user = user
}}
} | go | {
"resource": ""
} |
q182648 | Password | test | func Password(password string) TokenOpt {
return TokenOpt{func(o *options) {
o.password = password
}}
} | go | {
"resource": ""
} |
q182649 | Extractor | test | func Extractor(e request.Extractor) TokenOpt {
return TokenOpt{func(o *options) {
o.extractor = e
}}
} | go | {
"resource": ""
} |
q182650 | TokenGenerator | test | func TokenGenerator(h http.Handler, auth Authenticator, secret []byte, opts ...TokenOpt) http.Handler {
o := options{
logger: handler.NopLogger(),
claimer: func(c *jwt.StandardClaims) jwt.Claims { return c },
expiration: time.Hour * 24 * 15,
user: "user",
password: "password",
}
o.apply(opts)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var err error
if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data") {
err = r.ParseMultipartForm(0)
} else {
err = r.ParseForm()
}
if err != nil {
o.logger.Print("Invalid request form: ", err)
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
user := r.FormValue(o.user)
password := r.FormValue(o.password)
if user == "" || password == "" || !auth.Authenticate(user, password) {
w.WriteHeader(http.StatusUnauthorized)
return
}
expiration := time.Now().Add(o.expiration)
t := jwt.NewWithClaims(jwt.SigningMethodHS512, o.claimer(&jwt.StandardClaims{
Subject: user,
ExpiresAt: expiration.Unix(),
Issuer: o.issuer,
}))
if token, err := t.SignedString(secret); err == nil {
if h == nil {
w.Header().Add("Authorization", "Bearer "+token)
w.Write([]byte(token))
return
}
r = r.WithContext(context.WithValue(r.Context(), TokenKey, token))
h.ServeHTTP(w, r)
} else {
o.logger.Print("Error authenticating user:", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
})
} | go | {
"resource": ""
} |
q182651 | Token | test | func Token(r *http.Request) string {
if token, ok := r.Context().Value(TokenKey).(string); ok {
return token
}
return ""
} | go | {
"resource": ""
} |
q182652 | Claims | test | func Claims(r *http.Request) jwt.Claims {
if claims, ok := r.Context().Value(ClaimsKey).(jwt.Claims); ok {
return claims
}
return nil
} | go | {
"resource": ""
} |
q182653 | String | test | func (t Token) String() string {
switch t.Type {
case TokenEOF:
return "EOF"
case TokenError:
return t.Value
}
if len(t.Value) > 10 {
return fmt.Sprintf("%.25q...", t.Value)
}
return fmt.Sprintf("%q", t.Value)
} | go | {
"resource": ""
} |
q182654 | NewLexer | test | func NewLexer(name, input string, h Handler) *Lexer {
return &Lexer{
Name: name,
input: input + "\n",
state: lexText,
handler: h,
}
} | go | {
"resource": ""
} |
q182655 | run | test | func (l *Lexer) run() {
for state := lexText; state != nil; {
state = state(l)
}
} | go | {
"resource": ""
} |
q182656 | emit | test | func (l *Lexer) emit(t TokenType) {
// if the position is the same as the start, do not emit a token
if l.Pos == l.Start {
return
}
tok := Token{t, l.input[l.Start:l.Pos]}
l.handler(tok)
l.Start = l.Pos
} | go | {
"resource": ""
} |
q182657 | skipWhitespace | test | func (l *Lexer) skipWhitespace() {
for unicode.Is(unicode.White_Space, l.next()) {
}
l.backup()
l.ignore()
} | go | {
"resource": ""
} |
q182658 | next | test | func (l *Lexer) next() (r rune) {
if l.Pos >= len(l.input) {
l.Width = 0
return eof
}
r, l.Width = utf8.DecodeRuneInString(l.remaining())
l.advance(l.Width)
return
} | go | {
"resource": ""
} |
q182659 | LineNum | test | func (l *Lexer) LineNum() int {
return strings.Count(l.input[:l.Pos], "\n")
} | go | {
"resource": ""
} |
q182660 | Offset | test | func (l *Lexer) Offset() int {
// find last line break
lineoffset := strings.LastIndex(l.input[:l.Pos], "\n")
if lineoffset != -1 {
// calculate current offset from last line break
return l.Pos - lineoffset
}
// first line
return l.Pos
} | go | {
"resource": ""
} |
q182661 | errorf | test | func (l *Lexer) errorf(format string, args ...interface{}) stateFn {
l.handler(Token{TokenError, fmt.Sprintf(fmt.Sprintf("%s[%d:%d] ", l.Name, l.LineNum(), l.Offset())+format, args...)})
return nil
} | go | {
"resource": ""
} |
q182662 | lexText | test | func lexText(l *Lexer) stateFn {
OUTER:
for {
l.skipWhitespace()
remaining := l.remaining()
if strings.HasPrefix(remaining, comment) { // Start comment
// state function which lexes a comment
return lexComment
} else if strings.HasPrefix(remaining, pkg) { // Start package decl
// state function which lexes a package decl
return lexPackage
} else if strings.HasPrefix(remaining, from) { // Start from decl
// state function which lexes a from decl
return lexFrom
} else if strings.HasPrefix(remaining, typeDef) { // Start type def
// state function which lexes a type
return lexTypeDef
} else if strings.HasPrefix(remaining, version) { // Start version
// state function which lexes a version
return lexVersion
} else if strings.HasPrefix(remaining, required) { // Start required field
// state function which lexes a field
l.Pos += len(required)
l.emit(TokenRequired)
l.skipWhitespace()
return lexType
} else if strings.HasPrefix(remaining, optional) { // Start optional field
// state function which lexes a field
l.Pos += len(optional)
l.emit(TokenOptional)
l.skipWhitespace()
return lexType
} else if strings.HasPrefix(remaining, openScope) { // Open scope
l.Pos += len(openScope)
l.emit(TokenOpenCurlyBracket)
} else if strings.HasPrefix(remaining, closeScope) { // Close scope
l.Pos += len(closeScope)
l.emit(TokenCloseCurlyBracket)
} else {
switch r := l.next(); {
case r == eof: // reached EOF?
l.emit(TokenEOF)
break OUTER
default:
l.errorf("unknown token: %#v", string(r))
}
}
}
// Stops the run loop
return nil
} | go | {
"resource": ""
} |
q182663 | lexComment | test | func lexComment(l *Lexer) stateFn {
l.skipWhitespace()
// if strings.HasPrefix(l.remaining(), comment) {
// skip comment //
l.Pos += len(comment)
// find next new line and add location to pos which
// advances the scanner
if index := strings.Index(l.remaining(), "\n"); index > 0 {
l.Pos += index
} else {
l.Pos += len(l.remaining())
// l.emit(TokenComment)
// break
}
// emit the comment string
l.emit(TokenComment)
l.skipWhitespace()
// }
// continue on scanner
return lexText
} | go | {
"resource": ""
} |
q182664 | New | test | func New(namespace string, name string) (t TupleType) {
hash := syncHash.Hash([]byte(name))
ns_hash := syncHash.Hash([]byte(namespace))
t = TupleType{namespace, name, ns_hash, hash, make([][]Field, 0), make(map[string]int)}
return
} | go | {
"resource": ""
} |
q182665 | AddVersion | test | func (t *TupleType) AddVersion(fields ...Field) {
t.versions = append(t.versions, fields)
for _, field := range fields {
t.fields[field.Name] = len(t.fields)
}
} | go | {
"resource": ""
} |
q182666 | Contains | test | func (t *TupleType) Contains(field string) bool {
_, exists := t.fields[field]
return exists
} | go | {
"resource": ""
} |
q182667 | Offset | test | func (t *TupleType) Offset(field string) (offset int, exists bool) {
offset, exists = t.fields[field]
return
} | go | {
"resource": ""
} |
q182668 | Versions | test | func (t *TupleType) Versions() (vers []Version) {
vers = make([]Version, t.NumVersions())
for i := 0; i < t.NumVersions(); i++ {
vers[i] = Version{uint8(i + 1), t.versions[i]}
}
return
} | go | {
"resource": ""
} |
q182669 | SetPrivateMeta | test | func (s *Task) SetPrivateMeta(name string, value interface{}) {
if s.PrivateMetaData == nil {
s.PrivateMetaData = make(map[string]interface{})
}
s.PrivateMetaData[name] = value
} | go | {
"resource": ""
} |
q182670 | SetPublicMeta | test | func (s *Task) SetPublicMeta(name string, value interface{}) {
if s.MetaData == nil {
s.MetaData = make(map[string]interface{})
}
s.MetaData[name] = value
} | go | {
"resource": ""
} |
q182671 | GetRedactedVersion | test | func (s *Task) GetRedactedVersion() RedactedTask {
s.mutex.RLock()
rt := RedactedTask{
ID: s.ID,
Timestamp: s.Timestamp,
Expires: s.Expires,
Status: s.Status,
Profile: s.Profile,
CallerName: s.CallerName,
MetaData: s.MetaData,
}
s.mutex.RUnlock()
return rt
} | go | {
"resource": ""
} |
q182672 | Equal | test | func (s Task) Equal(b Task) bool {
return (s.ID == b.ID &&
s.Timestamp == b.Timestamp &&
s.Expires == b.Expires &&
s.Status == b.Status &&
s.Profile == b.Profile &&
s.CallerName == b.CallerName)
} | go | {
"resource": ""
} |
q182673 | HTTP | test | func HTTP(h http.Handler, verb Verb, verbs ...Verb) http.Handler {
verbSet := map[Verb]struct{}{verb: struct{}{}}
for _, v := range verbs {
verbSet[v] = struct{}{}
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if _, ok := verbSet[Verb(r.Method)]; ok {
h.ServeHTTP(w, r)
} else {
w.WriteHeader(http.StatusBadRequest)
}
})
} | go | {
"resource": ""
} |
q182674 | PutUint8 | test | func (b *TupleBuilder) PutUint8(field string, value uint8) (wrote uint64, err error) {
// field type should be a Uint8Field
if err = b.typeCheck(field, Uint8Field); err != nil {
return 0, err
}
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[b.pos] = byte(UnsignedInt8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
} | go | {
"resource": ""
} |
q182675 | PutInt8 | test | func (b *TupleBuilder) PutInt8(field string, value int8) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Int8Field); err != nil {
return 0, err
}
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[b.pos] = byte(Int8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
} | go | {
"resource": ""
} |
q182676 | PutUint16 | test | func (b *TupleBuilder) PutUint16(field string, value uint16) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Uint16Field); err != nil {
return 0, err
}
if value < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[b.pos] = byte(UnsignedShort8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint16(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedShort16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
} | go | {
"resource": ""
} |
q182677 | PutInt16 | test | func (b *TupleBuilder) PutInt16(field string, value int16) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Int16Field); err != nil {
return 0, err
}
if uint16(value) < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[b.pos] = byte(Short8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt16(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Short16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
} | go | {
"resource": ""
} |
q182678 | PutUint32 | test | func (b *TupleBuilder) PutUint32(field string, value uint32) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Uint32Field); err != nil {
return 0, err
}
if value < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[b.pos] = byte(UnsignedInt8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
} else if value < math.MaxUint16 {
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint16(b.buffer, b.pos+1, uint16(value))
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedInt16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint32(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedInt32Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
// wrote 5 bytes
return 5, nil
} | go | {
"resource": ""
} |
q182679 | PutInt32 | test | func (b *TupleBuilder) PutInt32(field string, value int32) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Int32Field); err != nil {
return 0, err
}
unsigned := uint32(value)
if unsigned < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[b.pos] = byte(Int8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
} else if unsigned < math.MaxUint16 {
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt16(b.buffer, b.pos+1, int16(value))
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Int16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt32(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Int32Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
// wrote 5 bytes
return 5, nil
} | go | {
"resource": ""
} |
q182680 | PutUint64 | test | func (b *TupleBuilder) PutUint64(field string, value uint64) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Uint64Field); err != nil {
return 0, err
}
if value < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[b.pos] = byte(UnsignedLong8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
} else if value < math.MaxUint16 {
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint16(b.buffer, b.pos+1, uint16(value))
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedLong16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
} else if value < math.MaxUint32 {
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint32(b.buffer, b.pos+1, uint32(value))
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedLong32Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
// wrote 5 bytes
return 5, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint64(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedLong64Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 9
// wrote 9 bytes
return 9, nil
} | go | {
"resource": ""
} |
q182681 | PutInt64 | test | func (b *TupleBuilder) PutInt64(field string, value int64) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Int64Field); err != nil {
return 0, err
}
unsigned := uint64(value)
if unsigned < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[b.pos] = byte(Long8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
} else if unsigned < math.MaxUint16 {
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt16(b.buffer, b.pos+1, int16(value))
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Long16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
} else if unsigned < math.MaxUint32 {
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt32(b.buffer, b.pos+1, int32(value))
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Long32Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
// wrote 5 bytes
return 5, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt64(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Long64Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 9
// wrote 9 bytes
return 9, nil
} | go | {
"resource": ""
} |
q182682 | NewPackageList | test | func NewPackageList() PackageList {
var lock sync.Mutex
return &packageList{make(map[string]Package), lock}
} | go | {
"resource": ""
} |
q182683 | PutFloat32 | test | func (b *TupleBuilder) PutFloat32(field string, value float32) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Float32Field); err != nil {
return 0, err
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutFloat32(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(FloatCode.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
return 5, nil
} | go | {
"resource": ""
} |
q182684 | Classic | test | func Classic() *ClassicMartini {
r := NewRouter()
m := New()
m.Use(Logger())
m.Use(Recovery())
m.Use(Static("static"))
m.Use(ContextRender("", RenderOptions{
Extensions: []string{".html", ".tmpl", "tpl"},
}))
m.MapTo(r, (*Routes)(nil))
m.Action(r.Handle)
return &ClassicMartini{m, r}
} | go | {
"resource": ""
} |
q182685 | Languages | test | func Languages(tags []xlang.Tag) Option {
return Option{func(o *options) {
o.languages = tags
}}
} | go | {
"resource": ""
} |
q182686 | Session | test | func Session(s handler.Session) Option {
return Option{func(o *options) {
o.session = s
}}
} | go | {
"resource": ""
} |
q182687 | Data | test | func Data(r *http.Request) ContextValue {
if v, ok := r.Context().Value(ContextKey).(ContextValue); ok {
return v
}
return ContextValue{}
} | go | {
"resource": ""
} |
q182688 | URL | test | func URL(url, prefix string, data ContextValue) string {
if data.Current.IsRoot() {
return url
}
if prefix == "" {
prefix = "/"
} else if prefix[len(prefix)-1] != '/' {
prefix += "/"
}
if url == "" {
url = "/"
}
if url[0] != '/' {
url = "/" + url
}
return prefix + data.Current.String() + url
} | go | {
"resource": ""
} |
q182689 | Size | test | func Size() (w, h int, err error) {
if !IsInit {
err = errors.New("termsize not yet iniitialied")
return
}
return get_size()
} | go | {
"resource": ""
} |
q182690 | GetRequestIDFromTaskResponse | test | func GetRequestIDFromTaskResponse(taskResponse TaskResponse) (requestID string, err error) {
var provisionHostInfoBytes []byte
firstRecordIndex := 0
meta := taskResponse.MetaData
provisionHostInfo := ProvisionHostInfo{}
lo.G.Debug("taskResponse: ", taskResponse)
lo.G.Debug("metadata: ", meta)
if provisionHostInfoBytes, err = json.Marshal(meta[ProvisionHostInformationFieldname]); err == nil {
if err = json.Unmarshal(provisionHostInfoBytes, &provisionHostInfo); err == nil {
if len(provisionHostInfo.Data) > firstRecordIndex {
requestID = provisionHostInfo.Data[firstRecordIndex].RequestID
} else {
lo.G.Error("no request id found in: ", provisionHostInfo)
}
} else {
lo.G.Error("error unmarshalling: ", err, meta)
lo.G.Error("metadata: ", meta)
}
} else {
lo.G.Error("error marshalling: ", err)
}
return
} | go | {
"resource": ""
} |
q182691 | PutString | test | func (b *TupleBuilder) PutString(field string, value string) (wrote int, err error) {
// field type should be
if err = b.typeCheck(field, StringField); err != nil {
return 0, err
}
size := len(value)
if size < math.MaxUint8 {
if b.available() < size+2 {
return 0, xbinary.ErrOutOfRange
}
// write length
xbinary.LittleEndian.PutString(b.buffer, b.pos+2, value)
// write type code
b.buffer[b.pos] = byte(String8Code.OpCode)
// write length
b.buffer[b.pos+1] = byte(size)
wrote += size + 2
} else if size < math.MaxUint16 {
if b.available() < size+3 {
return 0, xbinary.ErrOutOfRange
}
// write length
xbinary.LittleEndian.PutUint16(b.buffer, b.pos+1, uint16(size))
// write value
xbinary.LittleEndian.PutString(b.buffer, b.pos+3, value)
// write type code
b.buffer[b.pos] = byte(String16Code.OpCode)
wrote += 3 + size
} else if size < math.MaxUint32 {
if b.available() < size+5 {
return 0, xbinary.ErrOutOfRange
}
// write length
xbinary.LittleEndian.PutUint32(b.buffer, b.pos+1, uint32(size))
// write value
xbinary.LittleEndian.PutString(b.buffer, b.pos+5, value)
// write type code
b.buffer[b.pos] = byte(String32Code.OpCode)
wrote += 5 + size
} else {
if b.available() < size+9 {
return 0, xbinary.ErrOutOfRange
}
// write length
xbinary.LittleEndian.PutUint64(b.buffer, b.pos+1, uint64(size))
// write value
xbinary.LittleEndian.PutString(b.buffer, b.pos+9, value)
// write type code
b.buffer[b.pos] = byte(String64Code.OpCode)
wrote += 9 + size
}
b.offsets[field] = b.pos
b.pos += wrote
return
} | go | {
"resource": ""
} |
q182692 | LoadDirectory | test | func LoadDirectory(dir string, parser Parser) (err error) {
// Open dir for reading
d, err := os.Open(dir)
if err != nil {
return
}
// Iterate over all the files in the directory.
for {
// Only read 128 files at a time.
if fis, err := d.Readdir(128); err == nil {
// Read each entry
for _, fi := range fis {
// fmt.Println("%#v", fi)
// If the FileInfo is a directory, read the directory.
// Otherwise, read the file.
switch fi.IsDir() {
case true:
// return error if there is one
if err := LoadDirectory(fi.Name(), parser); err != nil {
return err
}
case false:
// All schema files should end with .nt
if !strings.HasSuffix(fi.Name(), ".ent") {
break
}
// Read the file
if _, err := LoadFile(filepath.Join(dir, fi.Name()), parser); err != nil {
return err
}
}
}
} else if err == io.EOF {
// If there are no more files in the directory, break.
break
} else {
// If there is any other error, return it.
return err
}
}
// If you have reached this far, you are done.
return nil
} | go | {
"resource": ""
} |
q182693 | LoadFile | test | func LoadFile(filename string, parser Parser) (Package, error) {
file, err := os.Open(filename)
if err != nil {
return Package{}, err
}
defer file.Close()
// read file
bytes, err := ioutil.ReadAll(file)
if err != nil {
return Package{}, err
}
// convert to string and load
return parser.Parse(file.Name(), string(bytes))
} | go | {
"resource": ""
} |
q182694 | LoadPackage | test | func LoadPackage(parser Parser, name, text string) (Package, error) {
return parser.Parse(name, text)
} | go | {
"resource": ""
} |
q182695 | NewDecoder | test | func NewDecoder(reg Registry, r io.Reader) Decoder {
var buf []byte
return decoder{reg, DefaultMaxSize, bytes.NewBuffer(buf), bufio.NewReader(r)}
} | go | {
"resource": ""
} |
q182696 | NewDecoderSize | test | func NewDecoderSize(reg Registry, maxSize uint64, r io.Reader) Decoder {
var buf []byte
return decoder{reg, maxSize, bytes.NewBuffer(buf), bufio.NewReader(r)}
} | go | {
"resource": ""
} |
q182697 | Panic | test | func Panic(h http.Handler, opts ...Option) http.Handler {
o := options{logger: handler.ErrLogger(), dateFormat: PanicDateFormat}
o.apply(opts)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rec := recover(); rec != nil {
stack := debug.Stack()
timestamp := time.Now().Format(o.dateFormat)
message := fmt.Sprintf("%s - %s\n%s\n", timestamp, rec, stack)
o.logger.Print(message)
w.WriteHeader(http.StatusInternalServerError)
if !o.showStack {
message = "Internal Server Error"
}
w.Write([]byte(message))
}
}()
h.ServeHTTP(w, r)
})
} | go | {
"resource": ""
} |
q182698 | DeployVApp | test | func (s *FakeVCDClient) DeployVApp(templateName, templateHref, vcdHref string) (vapp *vcloudclient.VApp, err error) {
return s.FakeVApp, s.ErrUnDeployFake
} | go | {
"resource": ""
} |
q182699 | UnDeployVApp | test | func (s *FakeVCDClient) UnDeployVApp(vappID string) (task *vcloudclient.TaskElem, err error) {
return &s.FakeVApp.Tasks.Task, s.ErrDeployFake
} | go | {
"resource": ""
} |