repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
docker/swarmkit | manager/state/raft/membership/cluster.go | UpdateMember | func (c *Cluster) UpdateMember(id uint64, m *api.RaftMember) error {
c.mu.Lock()
defer c.mu.Unlock()
if c.removed[id] {
return ErrIDRemoved
}
oldMember, ok := c.members[id]
if !ok {
return ErrIDNotFound
}
if oldMember.NodeID != m.NodeID {
// Should never happen; this is a sanity check
return errors.New("node ID mismatch match on node update")
}
if oldMember.Addr == m.Addr {
// nothing to do
return nil
}
oldMember.RaftMember = m
c.broadcastUpdate()
return nil
} | go | func (c *Cluster) UpdateMember(id uint64, m *api.RaftMember) error {
c.mu.Lock()
defer c.mu.Unlock()
if c.removed[id] {
return ErrIDRemoved
}
oldMember, ok := c.members[id]
if !ok {
return ErrIDNotFound
}
if oldMember.NodeID != m.NodeID {
// Should never happen; this is a sanity check
return errors.New("node ID mismatch match on node update")
}
if oldMember.Addr == m.Addr {
// nothing to do
return nil
}
oldMember.RaftMember = m
c.broadcastUpdate()
return nil
} | [
"func",
"(",
"c",
"*",
"Cluster",
")",
"UpdateMember",
"(",
"id",
"uint64",
",",
"m",
"*",
"api",
".",
"RaftMember",
")",
"error",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
... | // UpdateMember updates member address. | [
"UpdateMember",
"updates",
"member",
"address",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/membership/cluster.go#L123-L148 | train |
docker/swarmkit | manager/state/raft/membership/cluster.go | ClearMember | func (c *Cluster) ClearMember(id uint64) error {
c.mu.Lock()
defer c.mu.Unlock()
return c.clearMember(id)
} | go | func (c *Cluster) ClearMember(id uint64) error {
c.mu.Lock()
defer c.mu.Unlock()
return c.clearMember(id)
} | [
"func",
"(",
"c",
"*",
"Cluster",
")",
"ClearMember",
"(",
"id",
"uint64",
")",
"error",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"c",
".",
"clearMember",
"(",
"id",
")"... | // ClearMember removes a node from the Cluster Memberlist, but does NOT add it
// to the removed list. | [
"ClearMember",
"removes",
"a",
"node",
"from",
"the",
"Cluster",
"Memberlist",
"but",
"does",
"NOT",
"add",
"it",
"to",
"the",
"removed",
"list",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/membership/cluster.go#L152-L157 | train |
docker/swarmkit | manager/state/raft/membership/cluster.go | IsIDRemoved | func (c *Cluster) IsIDRemoved(id uint64) bool {
c.mu.RLock()
defer c.mu.RUnlock()
return c.removed[id]
} | go | func (c *Cluster) IsIDRemoved(id uint64) bool {
c.mu.RLock()
defer c.mu.RUnlock()
return c.removed[id]
} | [
"func",
"(",
"c",
"*",
"Cluster",
")",
"IsIDRemoved",
"(",
"id",
"uint64",
")",
"bool",
"{",
"c",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"c",
".",
"removed",
"[",
"id",
"]",
... | // IsIDRemoved checks if a Member is in the remove set. | [
"IsIDRemoved",
"checks",
"if",
"a",
"Member",
"is",
"in",
"the",
"remove",
"set",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/membership/cluster.go#L168-L172 | train |
docker/swarmkit | manager/state/raft/membership/cluster.go | Clear | func (c *Cluster) Clear() {
c.mu.Lock()
c.members = make(map[uint64]*Member)
c.removed = make(map[uint64]bool)
c.mu.Unlock()
} | go | func (c *Cluster) Clear() {
c.mu.Lock()
c.members = make(map[uint64]*Member)
c.removed = make(map[uint64]bool)
c.mu.Unlock()
} | [
"func",
"(",
"c",
"*",
"Cluster",
")",
"Clear",
"(",
")",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"members",
"=",
"make",
"(",
"map",
"[",
"uint64",
"]",
"*",
"Member",
")",
"\n",
"c",
".",
"removed",
"=",
"make",
"(",
"... | // Clear resets the list of active Members and removed Members. | [
"Clear",
"resets",
"the",
"list",
"of",
"active",
"Members",
"and",
"removed",
"Members",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/membership/cluster.go#L175-L181 | train |
docker/swarmkit | manager/state/raft/membership/cluster.go | ValidateConfigurationChange | func (c *Cluster) ValidateConfigurationChange(cc raftpb.ConfChange) error {
c.mu.Lock()
defer c.mu.Unlock()
if c.removed[cc.NodeID] {
return ErrIDRemoved
}
switch cc.Type {
case raftpb.ConfChangeAddNode:
if c.members[cc.NodeID] != nil {
return ErrIDExists
}
case raftpb.ConfChangeRemoveNode:
if c.members[cc.NodeID] == nil {
return ErrIDNotFound
}
case raftpb.ConfChangeUpdateNode:
if c.members[cc.NodeID] == nil {
return ErrIDNotFound
}
default:
return ErrConfigChangeInvalid
}
m := &api.RaftMember{}
if err := proto.Unmarshal(cc.Context, m); err != nil {
return ErrCannotUnmarshalConfig
}
return nil
} | go | func (c *Cluster) ValidateConfigurationChange(cc raftpb.ConfChange) error {
c.mu.Lock()
defer c.mu.Unlock()
if c.removed[cc.NodeID] {
return ErrIDRemoved
}
switch cc.Type {
case raftpb.ConfChangeAddNode:
if c.members[cc.NodeID] != nil {
return ErrIDExists
}
case raftpb.ConfChangeRemoveNode:
if c.members[cc.NodeID] == nil {
return ErrIDNotFound
}
case raftpb.ConfChangeUpdateNode:
if c.members[cc.NodeID] == nil {
return ErrIDNotFound
}
default:
return ErrConfigChangeInvalid
}
m := &api.RaftMember{}
if err := proto.Unmarshal(cc.Context, m); err != nil {
return ErrCannotUnmarshalConfig
}
return nil
} | [
"func",
"(",
"c",
"*",
"Cluster",
")",
"ValidateConfigurationChange",
"(",
"cc",
"raftpb",
".",
"ConfChange",
")",
"error",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"c",
".",
... | // ValidateConfigurationChange takes a proposed ConfChange and
// ensures that it is valid. | [
"ValidateConfigurationChange",
"takes",
"a",
"proposed",
"ConfChange",
"and",
"ensures",
"that",
"it",
"is",
"valid",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/membership/cluster.go#L185-L213 | train |
docker/swarmkit | manager/state/store/memory.go | Unlock | func (m *timedMutex) Unlock() {
unlockedTimestamp := m.lockedAt.Load()
m.lockedAt.Store(time.Time{})
m.Mutex.Unlock()
lockedFor := time.Since(unlockedTimestamp.(time.Time))
storeLockDurationTimer.Update(lockedFor)
} | go | func (m *timedMutex) Unlock() {
unlockedTimestamp := m.lockedAt.Load()
m.lockedAt.Store(time.Time{})
m.Mutex.Unlock()
lockedFor := time.Since(unlockedTimestamp.(time.Time))
storeLockDurationTimer.Update(lockedFor)
} | [
"func",
"(",
"m",
"*",
"timedMutex",
")",
"Unlock",
"(",
")",
"{",
"unlockedTimestamp",
":=",
"m",
".",
"lockedAt",
".",
"Load",
"(",
")",
"\n",
"m",
".",
"lockedAt",
".",
"Store",
"(",
"time",
".",
"Time",
"{",
"}",
")",
"\n",
"m",
".",
"Mutex",... | // Unlocks the timedMutex and captures the duration
// for which it was locked in a metric. | [
"Unlocks",
"the",
"timedMutex",
"and",
"captures",
"the",
"duration",
"for",
"which",
"it",
"was",
"locked",
"in",
"a",
"metric",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L130-L136 | train |
docker/swarmkit | manager/state/store/memory.go | NewMemoryStore | func NewMemoryStore(proposer state.Proposer) *MemoryStore {
memDB, err := memdb.NewMemDB(schema)
if err != nil {
// This shouldn't fail
panic(err)
}
return &MemoryStore{
memDB: memDB,
queue: watch.NewQueue(),
proposer: proposer,
}
} | go | func NewMemoryStore(proposer state.Proposer) *MemoryStore {
memDB, err := memdb.NewMemDB(schema)
if err != nil {
// This shouldn't fail
panic(err)
}
return &MemoryStore{
memDB: memDB,
queue: watch.NewQueue(),
proposer: proposer,
}
} | [
"func",
"NewMemoryStore",
"(",
"proposer",
"state",
".",
"Proposer",
")",
"*",
"MemoryStore",
"{",
"memDB",
",",
"err",
":=",
"memdb",
".",
"NewMemDB",
"(",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n"... | // NewMemoryStore returns an in-memory store. The argument is an optional
// Proposer which will be used to propagate changes to other members in a
// cluster. | [
"NewMemoryStore",
"returns",
"an",
"in",
"-",
"memory",
"store",
".",
"The",
"argument",
"is",
"an",
"optional",
"Proposer",
"which",
"will",
"be",
"used",
"to",
"propagate",
"changes",
"to",
"other",
"members",
"in",
"a",
"cluster",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L161-L173 | train |
docker/swarmkit | manager/state/store/memory.go | View | func (s *MemoryStore) View(cb func(ReadTx)) {
defer metrics.StartTimer(viewLatencyTimer)()
memDBTx := s.memDB.Txn(false)
readTx := readTx{
memDBTx: memDBTx,
}
cb(readTx)
memDBTx.Commit()
} | go | func (s *MemoryStore) View(cb func(ReadTx)) {
defer metrics.StartTimer(viewLatencyTimer)()
memDBTx := s.memDB.Txn(false)
readTx := readTx{
memDBTx: memDBTx,
}
cb(readTx)
memDBTx.Commit()
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"View",
"(",
"cb",
"func",
"(",
"ReadTx",
")",
")",
"{",
"defer",
"metrics",
".",
"StartTimer",
"(",
"viewLatencyTimer",
")",
"(",
")",
"\n",
"memDBTx",
":=",
"s",
".",
"memDB",
".",
"Txn",
"(",
"false",
"... | // View executes a read transaction. | [
"View",
"executes",
"a",
"read",
"transaction",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L222-L231 | train |
docker/swarmkit | manager/state/store/memory.go | changelistBetweenVersions | func (s *MemoryStore) changelistBetweenVersions(from, to api.Version) ([]api.Event, error) {
if s.proposer == nil {
return nil, errors.New("store does not support versioning")
}
changes, err := s.proposer.ChangesBetween(from, to)
if err != nil {
return nil, err
}
var changelist []api.Event
for _, change := range changes {
for _, sa := range change.StoreActions {
event, err := api.EventFromStoreAction(sa, nil)
if err != nil {
return nil, err
}
changelist = append(changelist, event)
}
changelist = append(changelist, state.EventCommit{Version: change.Version.Copy()})
}
return changelist, nil
} | go | func (s *MemoryStore) changelistBetweenVersions(from, to api.Version) ([]api.Event, error) {
if s.proposer == nil {
return nil, errors.New("store does not support versioning")
}
changes, err := s.proposer.ChangesBetween(from, to)
if err != nil {
return nil, err
}
var changelist []api.Event
for _, change := range changes {
for _, sa := range change.StoreActions {
event, err := api.EventFromStoreAction(sa, nil)
if err != nil {
return nil, err
}
changelist = append(changelist, event)
}
changelist = append(changelist, state.EventCommit{Version: change.Version.Copy()})
}
return changelist, nil
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"changelistBetweenVersions",
"(",
"from",
",",
"to",
"api",
".",
"Version",
")",
"(",
"[",
"]",
"api",
".",
"Event",
",",
"error",
")",
"{",
"if",
"s",
".",
"proposer",
"==",
"nil",
"{",
"return",
"nil",
"... | // changelistBetweenVersions returns the changes after "from" up to and
// including "to". | [
"changelistBetweenVersions",
"returns",
"the",
"changes",
"after",
"from",
"up",
"to",
"and",
"including",
"to",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L252-L275 | train |
docker/swarmkit | manager/state/store/memory.go | ApplyStoreActions | func (s *MemoryStore) ApplyStoreActions(actions []api.StoreAction) error {
s.updateLock.Lock()
memDBTx := s.memDB.Txn(true)
tx := tx{
readTx: readTx{
memDBTx: memDBTx,
},
}
for _, sa := range actions {
if err := applyStoreAction(&tx, sa); err != nil {
memDBTx.Abort()
s.updateLock.Unlock()
return err
}
}
memDBTx.Commit()
for _, c := range tx.changelist {
s.queue.Publish(c)
}
if len(tx.changelist) != 0 {
s.queue.Publish(state.EventCommit{})
}
s.updateLock.Unlock()
return nil
} | go | func (s *MemoryStore) ApplyStoreActions(actions []api.StoreAction) error {
s.updateLock.Lock()
memDBTx := s.memDB.Txn(true)
tx := tx{
readTx: readTx{
memDBTx: memDBTx,
},
}
for _, sa := range actions {
if err := applyStoreAction(&tx, sa); err != nil {
memDBTx.Abort()
s.updateLock.Unlock()
return err
}
}
memDBTx.Commit()
for _, c := range tx.changelist {
s.queue.Publish(c)
}
if len(tx.changelist) != 0 {
s.queue.Publish(state.EventCommit{})
}
s.updateLock.Unlock()
return nil
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"ApplyStoreActions",
"(",
"actions",
"[",
"]",
"api",
".",
"StoreAction",
")",
"error",
"{",
"s",
".",
"updateLock",
".",
"Lock",
"(",
")",
"\n",
"memDBTx",
":=",
"s",
".",
"memDB",
".",
"Txn",
"(",
"true",
... | // ApplyStoreActions updates a store based on StoreAction messages. | [
"ApplyStoreActions",
"updates",
"a",
"store",
"based",
"on",
"StoreAction",
"messages",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L278-L306 | train |
docker/swarmkit | manager/state/store/memory.go | Update | func (batch *Batch) Update(cb func(Tx) error) error {
if batch.err != nil {
return batch.err
}
if err := cb(&batch.tx); err != nil {
return err
}
batch.applied++
for batch.changelistLen < len(batch.tx.changelist) {
sa, err := api.NewStoreAction(batch.tx.changelist[batch.changelistLen])
if err != nil {
return err
}
batch.transactionSizeEstimate += sa.Size()
batch.changelistLen++
}
if batch.changelistLen >= MaxChangesPerTransaction || batch.transactionSizeEstimate >= (MaxTransactionBytes*3)/4 {
if err := batch.commit(); err != nil {
return err
}
// Yield the update lock
batch.store.updateLock.Unlock()
runtime.Gosched()
batch.store.updateLock.Lock()
batch.newTx()
}
return nil
} | go | func (batch *Batch) Update(cb func(Tx) error) error {
if batch.err != nil {
return batch.err
}
if err := cb(&batch.tx); err != nil {
return err
}
batch.applied++
for batch.changelistLen < len(batch.tx.changelist) {
sa, err := api.NewStoreAction(batch.tx.changelist[batch.changelistLen])
if err != nil {
return err
}
batch.transactionSizeEstimate += sa.Size()
batch.changelistLen++
}
if batch.changelistLen >= MaxChangesPerTransaction || batch.transactionSizeEstimate >= (MaxTransactionBytes*3)/4 {
if err := batch.commit(); err != nil {
return err
}
// Yield the update lock
batch.store.updateLock.Unlock()
runtime.Gosched()
batch.store.updateLock.Lock()
batch.newTx()
}
return nil
} | [
"func",
"(",
"batch",
"*",
"Batch",
")",
"Update",
"(",
"cb",
"func",
"(",
"Tx",
")",
"error",
")",
"error",
"{",
"if",
"batch",
".",
"err",
"!=",
"nil",
"{",
"return",
"batch",
".",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"cb",
"(",
"&",
... | // Update adds a single change to a batch. Each call to Update is atomic, but
// different calls to Update may be spread across multiple transactions to
// circumvent transaction size limits. | [
"Update",
"adds",
"a",
"single",
"change",
"to",
"a",
"batch",
".",
"Each",
"call",
"to",
"Update",
"is",
"atomic",
"but",
"different",
"calls",
"to",
"Update",
"may",
"be",
"spread",
"across",
"multiple",
"transactions",
"to",
"circumvent",
"transaction",
"... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L399-L433 | train |
docker/swarmkit | manager/state/store/memory.go | Batch | func (s *MemoryStore) Batch(cb func(*Batch) error) error {
defer metrics.StartTimer(batchLatencyTimer)()
s.updateLock.Lock()
batch := Batch{
store: s,
}
batch.newTx()
if err := cb(&batch); err != nil {
batch.tx.memDBTx.Abort()
s.updateLock.Unlock()
return err
}
err := batch.commit()
s.updateLock.Unlock()
return err
} | go | func (s *MemoryStore) Batch(cb func(*Batch) error) error {
defer metrics.StartTimer(batchLatencyTimer)()
s.updateLock.Lock()
batch := Batch{
store: s,
}
batch.newTx()
if err := cb(&batch); err != nil {
batch.tx.memDBTx.Abort()
s.updateLock.Unlock()
return err
}
err := batch.commit()
s.updateLock.Unlock()
return err
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"Batch",
"(",
"cb",
"func",
"(",
"*",
"Batch",
")",
"error",
")",
"error",
"{",
"defer",
"metrics",
".",
"StartTimer",
"(",
"batchLatencyTimer",
")",
"(",
")",
"\n",
"s",
".",
"updateLock",
".",
"Lock",
"(",... | // Batch performs one or more transactions that allow reads and writes
// It invokes a callback that is passed a Batch object. The callback may
// call batch.Update for each change it wants to make as part of the
// batch. The changes in the batch may be split over multiple
// transactions if necessary to keep transactions below the size limit.
// Batch holds a lock over the state, but will yield this lock every
// it creates a new transaction to allow other writers to proceed.
// Thus, unrelated changes to the state may occur between calls to
// batch.Update.
//
// This method allows the caller to iterate over a data set and apply
// changes in sequence without holding the store write lock for an
// excessive time, or producing a transaction that exceeds the maximum
// size.
//
// If Batch returns an error, no guarantees are made about how many updates
// were committed successfully. | [
"Batch",
"performs",
"one",
"or",
"more",
"transactions",
"that",
"allow",
"reads",
"and",
"writes",
"It",
"invokes",
"a",
"callback",
"that",
"is",
"passed",
"a",
"Batch",
"object",
".",
"The",
"callback",
"may",
"call",
"batch",
".",
"Update",
"for",
"ea... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L497-L515 | train |
docker/swarmkit | manager/state/store/memory.go | lookup | func (tx readTx) lookup(table, index, id string) api.StoreObject {
defer metrics.StartTimer(lookupLatencyTimer)()
j, err := tx.memDBTx.First(table, index, id)
if err != nil {
return nil
}
if j != nil {
return j.(api.StoreObject)
}
return nil
} | go | func (tx readTx) lookup(table, index, id string) api.StoreObject {
defer metrics.StartTimer(lookupLatencyTimer)()
j, err := tx.memDBTx.First(table, index, id)
if err != nil {
return nil
}
if j != nil {
return j.(api.StoreObject)
}
return nil
} | [
"func",
"(",
"tx",
"readTx",
")",
"lookup",
"(",
"table",
",",
"index",
",",
"id",
"string",
")",
"api",
".",
"StoreObject",
"{",
"defer",
"metrics",
".",
"StartTimer",
"(",
"lookupLatencyTimer",
")",
"(",
")",
"\n",
"j",
",",
"err",
":=",
"tx",
".",... | // lookup is an internal typed wrapper around memdb. | [
"lookup",
"is",
"an",
"internal",
"typed",
"wrapper",
"around",
"memdb",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L538-L548 | train |
docker/swarmkit | manager/state/store/memory.go | create | func (tx *tx) create(table string, o api.StoreObject) error {
if tx.lookup(table, indexID, o.GetID()) != nil {
return ErrExist
}
copy := o.CopyStoreObject()
meta := copy.GetMeta()
if err := touchMeta(&meta, tx.curVersion); err != nil {
return err
}
copy.SetMeta(meta)
err := tx.memDBTx.Insert(table, copy)
if err == nil {
tx.changelist = append(tx.changelist, copy.EventCreate())
o.SetMeta(meta)
}
return err
} | go | func (tx *tx) create(table string, o api.StoreObject) error {
if tx.lookup(table, indexID, o.GetID()) != nil {
return ErrExist
}
copy := o.CopyStoreObject()
meta := copy.GetMeta()
if err := touchMeta(&meta, tx.curVersion); err != nil {
return err
}
copy.SetMeta(meta)
err := tx.memDBTx.Insert(table, copy)
if err == nil {
tx.changelist = append(tx.changelist, copy.EventCreate())
o.SetMeta(meta)
}
return err
} | [
"func",
"(",
"tx",
"*",
"tx",
")",
"create",
"(",
"table",
"string",
",",
"o",
"api",
".",
"StoreObject",
")",
"error",
"{",
"if",
"tx",
".",
"lookup",
"(",
"table",
",",
"indexID",
",",
"o",
".",
"GetID",
"(",
")",
")",
"!=",
"nil",
"{",
"retu... | // create adds a new object to the store.
// Returns ErrExist if the ID is already taken. | [
"create",
"adds",
"a",
"new",
"object",
"to",
"the",
"store",
".",
"Returns",
"ErrExist",
"if",
"the",
"ID",
"is",
"already",
"taken",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L552-L570 | train |
docker/swarmkit | manager/state/store/memory.go | update | func (tx *tx) update(table string, o api.StoreObject) error {
oldN := tx.lookup(table, indexID, o.GetID())
if oldN == nil {
return ErrNotExist
}
meta := o.GetMeta()
if tx.curVersion != nil {
if oldN.GetMeta().Version != meta.Version {
return ErrSequenceConflict
}
}
copy := o.CopyStoreObject()
if err := touchMeta(&meta, tx.curVersion); err != nil {
return err
}
copy.SetMeta(meta)
err := tx.memDBTx.Insert(table, copy)
if err == nil {
tx.changelist = append(tx.changelist, copy.EventUpdate(oldN))
o.SetMeta(meta)
}
return err
} | go | func (tx *tx) update(table string, o api.StoreObject) error {
oldN := tx.lookup(table, indexID, o.GetID())
if oldN == nil {
return ErrNotExist
}
meta := o.GetMeta()
if tx.curVersion != nil {
if oldN.GetMeta().Version != meta.Version {
return ErrSequenceConflict
}
}
copy := o.CopyStoreObject()
if err := touchMeta(&meta, tx.curVersion); err != nil {
return err
}
copy.SetMeta(meta)
err := tx.memDBTx.Insert(table, copy)
if err == nil {
tx.changelist = append(tx.changelist, copy.EventUpdate(oldN))
o.SetMeta(meta)
}
return err
} | [
"func",
"(",
"tx",
"*",
"tx",
")",
"update",
"(",
"table",
"string",
",",
"o",
"api",
".",
"StoreObject",
")",
"error",
"{",
"oldN",
":=",
"tx",
".",
"lookup",
"(",
"table",
",",
"indexID",
",",
"o",
".",
"GetID",
"(",
")",
")",
"\n",
"if",
"ol... | // Update updates an existing object in the store.
// Returns ErrNotExist if the object doesn't exist. | [
"Update",
"updates",
"an",
"existing",
"object",
"in",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"object",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L574-L600 | train |
docker/swarmkit | manager/state/store/memory.go | delete | func (tx *tx) delete(table, id string) error {
n := tx.lookup(table, indexID, id)
if n == nil {
return ErrNotExist
}
err := tx.memDBTx.Delete(table, n)
if err == nil {
tx.changelist = append(tx.changelist, n.EventDelete())
}
return err
} | go | func (tx *tx) delete(table, id string) error {
n := tx.lookup(table, indexID, id)
if n == nil {
return ErrNotExist
}
err := tx.memDBTx.Delete(table, n)
if err == nil {
tx.changelist = append(tx.changelist, n.EventDelete())
}
return err
} | [
"func",
"(",
"tx",
"*",
"tx",
")",
"delete",
"(",
"table",
",",
"id",
"string",
")",
"error",
"{",
"n",
":=",
"tx",
".",
"lookup",
"(",
"table",
",",
"indexID",
",",
"id",
")",
"\n",
"if",
"n",
"==",
"nil",
"{",
"return",
"ErrNotExist",
"\n",
"... | // Delete removes an object from the store.
// Returns ErrNotExist if the object doesn't exist. | [
"Delete",
"removes",
"an",
"object",
"from",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"object",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L604-L615 | train |
docker/swarmkit | manager/state/store/memory.go | get | func (tx readTx) get(table, id string) api.StoreObject {
o := tx.lookup(table, indexID, id)
if o == nil {
return nil
}
return o.CopyStoreObject()
} | go | func (tx readTx) get(table, id string) api.StoreObject {
o := tx.lookup(table, indexID, id)
if o == nil {
return nil
}
return o.CopyStoreObject()
} | [
"func",
"(",
"tx",
"readTx",
")",
"get",
"(",
"table",
",",
"id",
"string",
")",
"api",
".",
"StoreObject",
"{",
"o",
":=",
"tx",
".",
"lookup",
"(",
"table",
",",
"indexID",
",",
"id",
")",
"\n",
"if",
"o",
"==",
"nil",
"{",
"return",
"nil",
"... | // Get looks up an object by ID.
// Returns nil if the object doesn't exist. | [
"Get",
"looks",
"up",
"an",
"object",
"by",
"ID",
".",
"Returns",
"nil",
"if",
"the",
"object",
"doesn",
"t",
"exist",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L619-L625 | train |
docker/swarmkit | manager/state/store/memory.go | find | func (tx readTx) find(table string, by By, checkType func(By) error, appendResult func(api.StoreObject)) error {
fromResultIterators := func(its ...memdb.ResultIterator) {
ids := make(map[string]struct{})
for _, it := range its {
for {
obj := it.Next()
if obj == nil {
break
}
o := obj.(api.StoreObject)
id := o.GetID()
if _, exists := ids[id]; !exists {
appendResult(o.CopyStoreObject())
ids[id] = struct{}{}
}
}
}
}
iters, err := tx.findIterators(table, by, checkType)
if err != nil {
return err
}
fromResultIterators(iters...)
return nil
} | go | func (tx readTx) find(table string, by By, checkType func(By) error, appendResult func(api.StoreObject)) error {
fromResultIterators := func(its ...memdb.ResultIterator) {
ids := make(map[string]struct{})
for _, it := range its {
for {
obj := it.Next()
if obj == nil {
break
}
o := obj.(api.StoreObject)
id := o.GetID()
if _, exists := ids[id]; !exists {
appendResult(o.CopyStoreObject())
ids[id] = struct{}{}
}
}
}
}
iters, err := tx.findIterators(table, by, checkType)
if err != nil {
return err
}
fromResultIterators(iters...)
return nil
} | [
"func",
"(",
"tx",
"readTx",
")",
"find",
"(",
"table",
"string",
",",
"by",
"By",
",",
"checkType",
"func",
"(",
"By",
")",
"error",
",",
"appendResult",
"func",
"(",
"api",
".",
"StoreObject",
")",
")",
"error",
"{",
"fromResultIterators",
":=",
"fun... | // find selects a set of objects calls a callback for each matching object. | [
"find",
"selects",
"a",
"set",
"of",
"objects",
"calls",
"a",
"callback",
"for",
"each",
"matching",
"object",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L775-L802 | train |
docker/swarmkit | manager/state/store/memory.go | Save | func (s *MemoryStore) Save(tx ReadTx) (*pb.StoreSnapshot, error) {
var snapshot pb.StoreSnapshot
for _, os := range objectStorers {
if err := os.Save(tx, &snapshot); err != nil {
return nil, err
}
}
return &snapshot, nil
} | go | func (s *MemoryStore) Save(tx ReadTx) (*pb.StoreSnapshot, error) {
var snapshot pb.StoreSnapshot
for _, os := range objectStorers {
if err := os.Save(tx, &snapshot); err != nil {
return nil, err
}
}
return &snapshot, nil
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"Save",
"(",
"tx",
"ReadTx",
")",
"(",
"*",
"pb",
".",
"StoreSnapshot",
",",
"error",
")",
"{",
"var",
"snapshot",
"pb",
".",
"StoreSnapshot",
"\n",
"for",
"_",
",",
"os",
":=",
"range",
"objectStorers",
"{"... | // Save serializes the data in the store. | [
"Save",
"serializes",
"the",
"data",
"in",
"the",
"store",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L805-L814 | train |
docker/swarmkit | manager/state/store/memory.go | Restore | func (s *MemoryStore) Restore(snapshot *pb.StoreSnapshot) error {
return s.updateLocal(func(tx Tx) error {
for _, os := range objectStorers {
if err := os.Restore(tx, snapshot); err != nil {
return err
}
}
return nil
})
} | go | func (s *MemoryStore) Restore(snapshot *pb.StoreSnapshot) error {
return s.updateLocal(func(tx Tx) error {
for _, os := range objectStorers {
if err := os.Restore(tx, snapshot); err != nil {
return err
}
}
return nil
})
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"Restore",
"(",
"snapshot",
"*",
"pb",
".",
"StoreSnapshot",
")",
"error",
"{",
"return",
"s",
".",
"updateLocal",
"(",
"func",
"(",
"tx",
"Tx",
")",
"error",
"{",
"for",
"_",
",",
"os",
":=",
"range",
"ob... | // Restore sets the contents of the store to the serialized data in the
// argument. | [
"Restore",
"sets",
"the",
"contents",
"of",
"the",
"store",
"to",
"the",
"serialized",
"data",
"in",
"the",
"argument",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L818-L827 | train |
docker/swarmkit | manager/state/store/memory.go | ViewAndWatch | func ViewAndWatch(store *MemoryStore, cb func(ReadTx) error, specifiers ...api.Event) (watch chan events.Event, cancel func(), err error) {
// Using Update to lock the store and guarantee consistency between
// the watcher and the the state seen by the callback. snapshotReadTx
// exposes this Tx as a ReadTx so the callback can't modify it.
err = store.Update(func(tx Tx) error {
if err := cb(tx); err != nil {
return err
}
watch, cancel = state.Watch(store.WatchQueue(), specifiers...)
return nil
})
if watch != nil && err != nil {
cancel()
cancel = nil
watch = nil
}
return
} | go | func ViewAndWatch(store *MemoryStore, cb func(ReadTx) error, specifiers ...api.Event) (watch chan events.Event, cancel func(), err error) {
// Using Update to lock the store and guarantee consistency between
// the watcher and the the state seen by the callback. snapshotReadTx
// exposes this Tx as a ReadTx so the callback can't modify it.
err = store.Update(func(tx Tx) error {
if err := cb(tx); err != nil {
return err
}
watch, cancel = state.Watch(store.WatchQueue(), specifiers...)
return nil
})
if watch != nil && err != nil {
cancel()
cancel = nil
watch = nil
}
return
} | [
"func",
"ViewAndWatch",
"(",
"store",
"*",
"MemoryStore",
",",
"cb",
"func",
"(",
"ReadTx",
")",
"error",
",",
"specifiers",
"...",
"api",
".",
"Event",
")",
"(",
"watch",
"chan",
"events",
".",
"Event",
",",
"cancel",
"func",
"(",
")",
",",
"err",
"... | // ViewAndWatch calls a callback which can observe the state of this
// MemoryStore. It also returns a channel that will return further events from
// this point so the snapshot can be kept up to date. The watch channel must be
// released with watch.StopWatch when it is no longer needed. The channel is
// guaranteed to get all events after the moment of the snapshot, and only
// those events. | [
"ViewAndWatch",
"calls",
"a",
"callback",
"which",
"can",
"observe",
"the",
"state",
"of",
"this",
"MemoryStore",
".",
"It",
"also",
"returns",
"a",
"channel",
"that",
"will",
"return",
"further",
"events",
"from",
"this",
"point",
"so",
"the",
"snapshot",
"... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L840-L857 | train |
docker/swarmkit | manager/state/store/memory.go | touchMeta | func touchMeta(meta *api.Meta, version *api.Version) error {
// Skip meta update if version is not defined as it means we're applying
// from raft or restoring from a snapshot.
if version == nil {
return nil
}
now, err := gogotypes.TimestampProto(time.Now())
if err != nil {
return err
}
meta.Version = *version
// Updated CreatedAt if not defined
if meta.CreatedAt == nil {
meta.CreatedAt = now
}
meta.UpdatedAt = now
return nil
} | go | func touchMeta(meta *api.Meta, version *api.Version) error {
// Skip meta update if version is not defined as it means we're applying
// from raft or restoring from a snapshot.
if version == nil {
return nil
}
now, err := gogotypes.TimestampProto(time.Now())
if err != nil {
return err
}
meta.Version = *version
// Updated CreatedAt if not defined
if meta.CreatedAt == nil {
meta.CreatedAt = now
}
meta.UpdatedAt = now
return nil
} | [
"func",
"touchMeta",
"(",
"meta",
"*",
"api",
".",
"Meta",
",",
"version",
"*",
"api",
".",
"Version",
")",
"error",
"{",
"if",
"version",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"now",
",",
"err",
":=",
"gogotypes",
".",
"TimestampProto"... | // touchMeta updates an object's timestamps when necessary and bumps the version
// if provided. | [
"touchMeta",
"updates",
"an",
"object",
"s",
"timestamps",
"when",
"necessary",
"and",
"bumps",
"the",
"version",
"if",
"provided",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L946-L968 | train |
docker/swarmkit | manager/state/store/memory.go | Wedged | func (s *MemoryStore) Wedged() bool {
lockedAt := s.updateLock.LockedAt()
if lockedAt.IsZero() {
return false
}
return time.Since(lockedAt) > WedgeTimeout
} | go | func (s *MemoryStore) Wedged() bool {
lockedAt := s.updateLock.LockedAt()
if lockedAt.IsZero() {
return false
}
return time.Since(lockedAt) > WedgeTimeout
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"Wedged",
"(",
")",
"bool",
"{",
"lockedAt",
":=",
"s",
".",
"updateLock",
".",
"LockedAt",
"(",
")",
"\n",
"if",
"lockedAt",
".",
"IsZero",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"ti... | // Wedged returns true if the store lock has been held for a long time,
// possibly indicating a deadlock. | [
"Wedged",
"returns",
"true",
"if",
"the",
"store",
"lock",
"has",
"been",
"held",
"for",
"a",
"long",
"time",
"possibly",
"indicating",
"a",
"deadlock",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/memory.go#L972-L979 | train |
docker/swarmkit | template/getter.go | NewTemplatedSecretGetter | func NewTemplatedSecretGetter(dependencies exec.DependencyGetter, t *api.Task, node *api.NodeDescription) exec.SecretGetter {
return templatedSecretGetter{dependencies: dependencies, t: t, node: node}
} | go | func NewTemplatedSecretGetter(dependencies exec.DependencyGetter, t *api.Task, node *api.NodeDescription) exec.SecretGetter {
return templatedSecretGetter{dependencies: dependencies, t: t, node: node}
} | [
"func",
"NewTemplatedSecretGetter",
"(",
"dependencies",
"exec",
".",
"DependencyGetter",
",",
"t",
"*",
"api",
".",
"Task",
",",
"node",
"*",
"api",
".",
"NodeDescription",
")",
"exec",
".",
"SecretGetter",
"{",
"return",
"templatedSecretGetter",
"{",
"dependen... | // NewTemplatedSecretGetter returns a SecretGetter that evaluates templates. | [
"NewTemplatedSecretGetter",
"returns",
"a",
"SecretGetter",
"that",
"evaluates",
"templates",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/template/getter.go#L16-L18 | train |
docker/swarmkit | template/getter.go | NewTemplatedConfigGetter | func NewTemplatedConfigGetter(dependencies exec.DependencyGetter, t *api.Task, node *api.NodeDescription) TemplatedConfigGetter {
return templatedConfigGetter{dependencies: dependencies, t: t, node: node}
} | go | func NewTemplatedConfigGetter(dependencies exec.DependencyGetter, t *api.Task, node *api.NodeDescription) TemplatedConfigGetter {
return templatedConfigGetter{dependencies: dependencies, t: t, node: node}
} | [
"func",
"NewTemplatedConfigGetter",
"(",
"dependencies",
"exec",
".",
"DependencyGetter",
",",
"t",
"*",
"api",
".",
"Task",
",",
"node",
"*",
"api",
".",
"NodeDescription",
")",
"TemplatedConfigGetter",
"{",
"return",
"templatedConfigGetter",
"{",
"dependencies",
... | // NewTemplatedConfigGetter returns a ConfigGetter that evaluates templates. | [
"NewTemplatedConfigGetter",
"returns",
"a",
"ConfigGetter",
"that",
"evaluates",
"templates",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/template/getter.go#L64-L66 | train |
docker/swarmkit | template/getter.go | NewTemplatedDependencyGetter | func NewTemplatedDependencyGetter(dependencies exec.DependencyGetter, t *api.Task, node *api.NodeDescription) exec.DependencyGetter {
return templatedDependencyGetter{
secrets: NewTemplatedSecretGetter(dependencies, t, node),
configs: NewTemplatedConfigGetter(dependencies, t, node),
}
} | go | func NewTemplatedDependencyGetter(dependencies exec.DependencyGetter, t *api.Task, node *api.NodeDescription) exec.DependencyGetter {
return templatedDependencyGetter{
secrets: NewTemplatedSecretGetter(dependencies, t, node),
configs: NewTemplatedConfigGetter(dependencies, t, node),
}
} | [
"func",
"NewTemplatedDependencyGetter",
"(",
"dependencies",
"exec",
".",
"DependencyGetter",
",",
"t",
"*",
"api",
".",
"Task",
",",
"node",
"*",
"api",
".",
"NodeDescription",
")",
"exec",
".",
"DependencyGetter",
"{",
"return",
"templatedDependencyGetter",
"{",... | // NewTemplatedDependencyGetter returns a DependencyGetter that evaluates templates. | [
"NewTemplatedDependencyGetter",
"returns",
"a",
"DependencyGetter",
"that",
"evaluates",
"templates",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/template/getter.go#L104-L109 | train |
docker/swarmkit | manager/state/raft/storage/storage.go | BootstrapNew | func (e *EncryptedRaftLogger) BootstrapNew(metadata []byte) error {
e.encoderMu.Lock()
defer e.encoderMu.Unlock()
encrypter, decrypter := encryption.Defaults(e.EncryptionKey, e.FIPS)
walFactory := NewWALFactory(encrypter, decrypter)
for _, dirpath := range []string{filepath.Dir(e.walDir()), e.snapDir()} {
if err := os.MkdirAll(dirpath, 0700); err != nil {
return errors.Wrapf(err, "failed to create %s", dirpath)
}
}
var err error
// the wal directory must not already exist upon creation
e.wal, err = walFactory.Create(e.walDir(), metadata)
if err != nil {
return errors.Wrap(err, "failed to create WAL")
}
e.snapshotter = NewSnapFactory(encrypter, decrypter).New(e.snapDir())
return nil
} | go | func (e *EncryptedRaftLogger) BootstrapNew(metadata []byte) error {
e.encoderMu.Lock()
defer e.encoderMu.Unlock()
encrypter, decrypter := encryption.Defaults(e.EncryptionKey, e.FIPS)
walFactory := NewWALFactory(encrypter, decrypter)
for _, dirpath := range []string{filepath.Dir(e.walDir()), e.snapDir()} {
if err := os.MkdirAll(dirpath, 0700); err != nil {
return errors.Wrapf(err, "failed to create %s", dirpath)
}
}
var err error
// the wal directory must not already exist upon creation
e.wal, err = walFactory.Create(e.walDir(), metadata)
if err != nil {
return errors.Wrap(err, "failed to create WAL")
}
e.snapshotter = NewSnapFactory(encrypter, decrypter).New(e.snapDir())
return nil
} | [
"func",
"(",
"e",
"*",
"EncryptedRaftLogger",
")",
"BootstrapNew",
"(",
"metadata",
"[",
"]",
"byte",
")",
"error",
"{",
"e",
".",
"encoderMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"encoderMu",
".",
"Unlock",
"(",
")",
"\n",
"encrypter",
"... | // BootstrapNew creates a new snapshotter and WAL writer, expecting that there is nothing on disk | [
"BootstrapNew",
"creates",
"a",
"new",
"snapshotter",
"and",
"WAL",
"writer",
"expecting",
"that",
"there",
"is",
"nothing",
"on",
"disk"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/storage.go#L143-L163 | train |
docker/swarmkit | manager/state/raft/storage/storage.go | RotateEncryptionKey | func (e *EncryptedRaftLogger) RotateEncryptionKey(newKey []byte) {
e.encoderMu.Lock()
defer e.encoderMu.Unlock()
if e.wal != nil { // if the wal exists, the snapshotter exists
// We don't want to have to close the WAL, because we can't open a new one.
// We need to know the previous snapshot, because when you open a WAL you
// have to read out all the entries from a particular snapshot, or you can't
// write. So just rotate the encoders out from under it. We already
// have a lock on writing to snapshots and WALs.
wrapped, ok := e.wal.(*wrappedWAL)
if !ok {
panic(fmt.Errorf("EncryptedRaftLogger's WAL is not a wrappedWAL"))
}
wrapped.encrypter, wrapped.decrypter = encryption.Defaults(newKey, e.FIPS)
e.snapshotter = NewSnapFactory(wrapped.encrypter, wrapped.decrypter).New(e.snapDir())
}
e.EncryptionKey = newKey
} | go | func (e *EncryptedRaftLogger) RotateEncryptionKey(newKey []byte) {
e.encoderMu.Lock()
defer e.encoderMu.Unlock()
if e.wal != nil { // if the wal exists, the snapshotter exists
// We don't want to have to close the WAL, because we can't open a new one.
// We need to know the previous snapshot, because when you open a WAL you
// have to read out all the entries from a particular snapshot, or you can't
// write. So just rotate the encoders out from under it. We already
// have a lock on writing to snapshots and WALs.
wrapped, ok := e.wal.(*wrappedWAL)
if !ok {
panic(fmt.Errorf("EncryptedRaftLogger's WAL is not a wrappedWAL"))
}
wrapped.encrypter, wrapped.decrypter = encryption.Defaults(newKey, e.FIPS)
e.snapshotter = NewSnapFactory(wrapped.encrypter, wrapped.decrypter).New(e.snapDir())
}
e.EncryptionKey = newKey
} | [
"func",
"(",
"e",
"*",
"EncryptedRaftLogger",
")",
"RotateEncryptionKey",
"(",
"newKey",
"[",
"]",
"byte",
")",
"{",
"e",
".",
"encoderMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"encoderMu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"e",
".",
... | // RotateEncryptionKey swaps out the encoders and decoders used by the wal and snapshotter | [
"RotateEncryptionKey",
"swaps",
"out",
"the",
"encoders",
"and",
"decoders",
"used",
"by",
"the",
"wal",
"and",
"snapshotter"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/storage.go#L174-L194 | train |
docker/swarmkit | manager/state/raft/storage/storage.go | SaveSnapshot | func (e *EncryptedRaftLogger) SaveSnapshot(snapshot raftpb.Snapshot) error {
walsnap := walpb.Snapshot{
Index: snapshot.Metadata.Index,
Term: snapshot.Metadata.Term,
}
e.encoderMu.RLock()
if err := e.wal.SaveSnapshot(walsnap); err != nil {
e.encoderMu.RUnlock()
return err
}
snapshotter := e.snapshotter
e.encoderMu.RUnlock()
if err := snapshotter.SaveSnap(snapshot); err != nil {
return err
}
return e.wal.ReleaseLockTo(snapshot.Metadata.Index)
} | go | func (e *EncryptedRaftLogger) SaveSnapshot(snapshot raftpb.Snapshot) error {
walsnap := walpb.Snapshot{
Index: snapshot.Metadata.Index,
Term: snapshot.Metadata.Term,
}
e.encoderMu.RLock()
if err := e.wal.SaveSnapshot(walsnap); err != nil {
e.encoderMu.RUnlock()
return err
}
snapshotter := e.snapshotter
e.encoderMu.RUnlock()
if err := snapshotter.SaveSnap(snapshot); err != nil {
return err
}
return e.wal.ReleaseLockTo(snapshot.Metadata.Index)
} | [
"func",
"(",
"e",
"*",
"EncryptedRaftLogger",
")",
"SaveSnapshot",
"(",
"snapshot",
"raftpb",
".",
"Snapshot",
")",
"error",
"{",
"walsnap",
":=",
"walpb",
".",
"Snapshot",
"{",
"Index",
":",
"snapshot",
".",
"Metadata",
".",
"Index",
",",
"Term",
":",
"... | // SaveSnapshot actually saves a given snapshot to both the WAL and the snapshot. | [
"SaveSnapshot",
"actually",
"saves",
"a",
"given",
"snapshot",
"to",
"both",
"the",
"WAL",
"and",
"the",
"snapshot",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/storage.go#L197-L217 | train |
docker/swarmkit | manager/state/raft/storage/storage.go | GC | func (e *EncryptedRaftLogger) GC(index uint64, term uint64, keepOldSnapshots uint64) error {
// Delete any older snapshots
curSnapshot := fmt.Sprintf("%016x-%016x%s", term, index, ".snap")
snapshots, err := ListSnapshots(e.snapDir())
if err != nil {
return err
}
// Ignore any snapshots that are older than the current snapshot.
// Delete the others. Rather than doing lexical comparisons, we look
// at what exists before/after the current snapshot in the slice.
// This means that if the current snapshot doesn't appear in the
// directory for some strange reason, we won't delete anything, which
// is the safe behavior.
curSnapshotIdx := -1
var (
removeErr error
oldestSnapshot string
)
for i, snapFile := range snapshots {
if curSnapshotIdx >= 0 && i > curSnapshotIdx {
if uint64(i-curSnapshotIdx) > keepOldSnapshots {
err := os.Remove(filepath.Join(e.snapDir(), snapFile))
if err != nil && removeErr == nil {
removeErr = err
}
continue
}
} else if snapFile == curSnapshot {
curSnapshotIdx = i
}
oldestSnapshot = snapFile
}
if removeErr != nil {
return removeErr
}
// Remove any WAL files that only contain data from before the oldest
// remaining snapshot.
if oldestSnapshot == "" {
return nil
}
// Parse index out of oldest snapshot's filename
var snapTerm, snapIndex uint64
_, err = fmt.Sscanf(oldestSnapshot, "%016x-%016x.snap", &snapTerm, &snapIndex)
if err != nil {
return errors.Wrapf(err, "malformed snapshot filename %s", oldestSnapshot)
}
wals, err := ListWALs(e.walDir())
if err != nil {
return err
}
found := false
deleteUntil := -1
for i, walName := range wals {
var walSeq, walIndex uint64
_, err = fmt.Sscanf(walName, "%016x-%016x.wal", &walSeq, &walIndex)
if err != nil {
return errors.Wrapf(err, "could not parse WAL name %s", walName)
}
if walIndex >= snapIndex {
deleteUntil = i - 1
found = true
break
}
}
// If all WAL files started with indices below the oldest snapshot's
// index, we can delete all but the newest WAL file.
if !found && len(wals) != 0 {
deleteUntil = len(wals) - 1
}
for i := 0; i < deleteUntil; i++ {
walPath := filepath.Join(e.walDir(), wals[i])
l, err := fileutil.TryLockFile(walPath, os.O_WRONLY, fileutil.PrivateFileMode)
if err != nil {
return errors.Wrapf(err, "could not lock old WAL file %s for removal", wals[i])
}
err = os.Remove(walPath)
l.Close()
if err != nil {
return errors.Wrapf(err, "error removing old WAL file %s", wals[i])
}
}
return nil
} | go | func (e *EncryptedRaftLogger) GC(index uint64, term uint64, keepOldSnapshots uint64) error {
// Delete any older snapshots
curSnapshot := fmt.Sprintf("%016x-%016x%s", term, index, ".snap")
snapshots, err := ListSnapshots(e.snapDir())
if err != nil {
return err
}
// Ignore any snapshots that are older than the current snapshot.
// Delete the others. Rather than doing lexical comparisons, we look
// at what exists before/after the current snapshot in the slice.
// This means that if the current snapshot doesn't appear in the
// directory for some strange reason, we won't delete anything, which
// is the safe behavior.
curSnapshotIdx := -1
var (
removeErr error
oldestSnapshot string
)
for i, snapFile := range snapshots {
if curSnapshotIdx >= 0 && i > curSnapshotIdx {
if uint64(i-curSnapshotIdx) > keepOldSnapshots {
err := os.Remove(filepath.Join(e.snapDir(), snapFile))
if err != nil && removeErr == nil {
removeErr = err
}
continue
}
} else if snapFile == curSnapshot {
curSnapshotIdx = i
}
oldestSnapshot = snapFile
}
if removeErr != nil {
return removeErr
}
// Remove any WAL files that only contain data from before the oldest
// remaining snapshot.
if oldestSnapshot == "" {
return nil
}
// Parse index out of oldest snapshot's filename
var snapTerm, snapIndex uint64
_, err = fmt.Sscanf(oldestSnapshot, "%016x-%016x.snap", &snapTerm, &snapIndex)
if err != nil {
return errors.Wrapf(err, "malformed snapshot filename %s", oldestSnapshot)
}
wals, err := ListWALs(e.walDir())
if err != nil {
return err
}
found := false
deleteUntil := -1
for i, walName := range wals {
var walSeq, walIndex uint64
_, err = fmt.Sscanf(walName, "%016x-%016x.wal", &walSeq, &walIndex)
if err != nil {
return errors.Wrapf(err, "could not parse WAL name %s", walName)
}
if walIndex >= snapIndex {
deleteUntil = i - 1
found = true
break
}
}
// If all WAL files started with indices below the oldest snapshot's
// index, we can delete all but the newest WAL file.
if !found && len(wals) != 0 {
deleteUntil = len(wals) - 1
}
for i := 0; i < deleteUntil; i++ {
walPath := filepath.Join(e.walDir(), wals[i])
l, err := fileutil.TryLockFile(walPath, os.O_WRONLY, fileutil.PrivateFileMode)
if err != nil {
return errors.Wrapf(err, "could not lock old WAL file %s for removal", wals[i])
}
err = os.Remove(walPath)
l.Close()
if err != nil {
return errors.Wrapf(err, "error removing old WAL file %s", wals[i])
}
}
return nil
} | [
"func",
"(",
"e",
"*",
"EncryptedRaftLogger",
")",
"GC",
"(",
"index",
"uint64",
",",
"term",
"uint64",
",",
"keepOldSnapshots",
"uint64",
")",
"error",
"{",
"curSnapshot",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%016x-%016x%s\"",
",",
"term",
",",
"index",
"... | // GC garbage collects snapshots and wals older than the provided index and term | [
"GC",
"garbage",
"collects",
"snapshots",
"and",
"wals",
"older",
"than",
"the",
"provided",
"index",
"and",
"term"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/storage.go#L220-L316 | train |
docker/swarmkit | manager/state/raft/storage/storage.go | SaveEntries | func (e *EncryptedRaftLogger) SaveEntries(st raftpb.HardState, entries []raftpb.Entry) error {
e.encoderMu.RLock()
defer e.encoderMu.RUnlock()
if e.wal == nil {
return fmt.Errorf("raft WAL has either been closed or has never been created")
}
return e.wal.Save(st, entries)
} | go | func (e *EncryptedRaftLogger) SaveEntries(st raftpb.HardState, entries []raftpb.Entry) error {
e.encoderMu.RLock()
defer e.encoderMu.RUnlock()
if e.wal == nil {
return fmt.Errorf("raft WAL has either been closed or has never been created")
}
return e.wal.Save(st, entries)
} | [
"func",
"(",
"e",
"*",
"EncryptedRaftLogger",
")",
"SaveEntries",
"(",
"st",
"raftpb",
".",
"HardState",
",",
"entries",
"[",
"]",
"raftpb",
".",
"Entry",
")",
"error",
"{",
"e",
".",
"encoderMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"enc... | // SaveEntries saves only entries to disk | [
"SaveEntries",
"saves",
"only",
"entries",
"to",
"disk"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/storage.go#L319-L327 | train |
docker/swarmkit | manager/state/raft/storage/storage.go | Close | func (e *EncryptedRaftLogger) Close(ctx context.Context) {
e.encoderMu.Lock()
defer e.encoderMu.Unlock()
if e.wal != nil {
if err := e.wal.Close(); err != nil {
log.G(ctx).WithError(err).Error("error closing raft WAL")
}
}
e.wal = nil
e.snapshotter = nil
} | go | func (e *EncryptedRaftLogger) Close(ctx context.Context) {
e.encoderMu.Lock()
defer e.encoderMu.Unlock()
if e.wal != nil {
if err := e.wal.Close(); err != nil {
log.G(ctx).WithError(err).Error("error closing raft WAL")
}
}
e.wal = nil
e.snapshotter = nil
} | [
"func",
"(",
"e",
"*",
"EncryptedRaftLogger",
")",
"Close",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"e",
".",
"encoderMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"encoderMu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"e",
".",
"wal",
... | // Close closes the logger - it will have to be bootstrapped again to start writing | [
"Close",
"closes",
"the",
"logger",
"-",
"it",
"will",
"have",
"to",
"be",
"bootstrapped",
"again",
"to",
"start",
"writing"
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/storage.go#L330-L342 | train |
docker/swarmkit | manager/state/raft/storage/storage.go | Clear | func (e *EncryptedRaftLogger) Clear(ctx context.Context) error {
e.encoderMu.Lock()
defer e.encoderMu.Unlock()
if e.wal != nil {
if err := e.wal.Close(); err != nil {
log.G(ctx).WithError(err).Error("error closing raft WAL")
}
}
e.snapshotter = nil
os.RemoveAll(e.walDir())
os.RemoveAll(e.snapDir())
return nil
} | go | func (e *EncryptedRaftLogger) Clear(ctx context.Context) error {
e.encoderMu.Lock()
defer e.encoderMu.Unlock()
if e.wal != nil {
if err := e.wal.Close(); err != nil {
log.G(ctx).WithError(err).Error("error closing raft WAL")
}
}
e.snapshotter = nil
os.RemoveAll(e.walDir())
os.RemoveAll(e.snapDir())
return nil
} | [
"func",
"(",
"e",
"*",
"EncryptedRaftLogger",
")",
"Clear",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"e",
".",
"encoderMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"encoderMu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"e",
".",... | // Clear closes the existing WAL and removes the WAL and snapshot. | [
"Clear",
"closes",
"the",
"existing",
"WAL",
"and",
"removes",
"the",
"WAL",
"and",
"snapshot",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/storage.go#L345-L359 | train |
docker/swarmkit | agent/worker.go | Init | func (w *worker) Init(ctx context.Context) error {
w.mu.Lock()
defer w.mu.Unlock()
ctx = log.WithModule(ctx, "worker")
// TODO(stevvooe): Start task cleanup process.
// read the tasks from the database and start any task managers that may be needed.
return w.db.Update(func(tx *bolt.Tx) error {
return WalkTasks(tx, func(task *api.Task) error {
if !TaskAssigned(tx, task.ID) {
// NOTE(stevvooe): If tasks can survive worker restart, we need
// to startup the controller and ensure they are removed. For
// now, we can simply remove them from the database.
if err := DeleteTask(tx, task.ID); err != nil {
log.G(ctx).WithError(err).Errorf("error removing task %v", task.ID)
}
return nil
}
status, err := GetTaskStatus(tx, task.ID)
if err != nil {
log.G(ctx).WithError(err).Error("unable to read tasks status")
return nil
}
task.Status = *status // merges the status into the task, ensuring we start at the right point.
return w.startTask(ctx, tx, task)
})
})
} | go | func (w *worker) Init(ctx context.Context) error {
w.mu.Lock()
defer w.mu.Unlock()
ctx = log.WithModule(ctx, "worker")
// TODO(stevvooe): Start task cleanup process.
// read the tasks from the database and start any task managers that may be needed.
return w.db.Update(func(tx *bolt.Tx) error {
return WalkTasks(tx, func(task *api.Task) error {
if !TaskAssigned(tx, task.ID) {
// NOTE(stevvooe): If tasks can survive worker restart, we need
// to startup the controller and ensure they are removed. For
// now, we can simply remove them from the database.
if err := DeleteTask(tx, task.ID); err != nil {
log.G(ctx).WithError(err).Errorf("error removing task %v", task.ID)
}
return nil
}
status, err := GetTaskStatus(tx, task.ID)
if err != nil {
log.G(ctx).WithError(err).Error("unable to read tasks status")
return nil
}
task.Status = *status // merges the status into the task, ensuring we start at the right point.
return w.startTask(ctx, tx, task)
})
})
} | [
"func",
"(",
"w",
"*",
"worker",
")",
"Init",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"w",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"w",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"ctx",
"=",
"log",
".",
"WithModule",
... | // Init prepares the worker for assignments. | [
"Init",
"prepares",
"the",
"worker",
"for",
"assignments",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/worker.go#L84-L115 | train |
docker/swarmkit | agent/worker.go | Close | func (w *worker) Close() {
w.mu.Lock()
w.closed = true
w.mu.Unlock()
w.taskevents.Close()
} | go | func (w *worker) Close() {
w.mu.Lock()
w.closed = true
w.mu.Unlock()
w.taskevents.Close()
} | [
"func",
"(",
"w",
"*",
"worker",
")",
"Close",
"(",
")",
"{",
"w",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"w",
".",
"closed",
"=",
"true",
"\n",
"w",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"w",
".",
"taskevents",
".",
"Close",
"(",
")",... | // Close performs worker cleanup when no longer needed. | [
"Close",
"performs",
"worker",
"cleanup",
"when",
"no",
"longer",
"needed",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/worker.go#L118-L124 | train |
docker/swarmkit | agent/worker.go | Assign | func (w *worker) Assign(ctx context.Context, assignments []*api.AssignmentChange) error {
w.mu.Lock()
defer w.mu.Unlock()
if w.closed {
return ErrClosed
}
log.G(ctx).WithFields(logrus.Fields{
"len(assignments)": len(assignments),
}).Debug("(*worker).Assign")
// Need to update dependencies before tasks
err := reconcileSecrets(ctx, w, assignments, true)
if err != nil {
return err
}
err = reconcileConfigs(ctx, w, assignments, true)
if err != nil {
return err
}
return reconcileTaskState(ctx, w, assignments, true)
} | go | func (w *worker) Assign(ctx context.Context, assignments []*api.AssignmentChange) error {
w.mu.Lock()
defer w.mu.Unlock()
if w.closed {
return ErrClosed
}
log.G(ctx).WithFields(logrus.Fields{
"len(assignments)": len(assignments),
}).Debug("(*worker).Assign")
// Need to update dependencies before tasks
err := reconcileSecrets(ctx, w, assignments, true)
if err != nil {
return err
}
err = reconcileConfigs(ctx, w, assignments, true)
if err != nil {
return err
}
return reconcileTaskState(ctx, w, assignments, true)
} | [
"func",
"(",
"w",
"*",
"worker",
")",
"Assign",
"(",
"ctx",
"context",
".",
"Context",
",",
"assignments",
"[",
"]",
"*",
"api",
".",
"AssignmentChange",
")",
"error",
"{",
"w",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"w",
".",
"mu",
"."... | // Assign assigns a full set of tasks, configs, and secrets to the worker.
// Any tasks not previously known will be started. Any tasks that are in the task set
// and already running will be updated, if possible. Any tasks currently running on
// the worker outside the task set will be terminated.
// Anything not in the set of assignments will be removed. | [
"Assign",
"assigns",
"a",
"full",
"set",
"of",
"tasks",
"configs",
"and",
"secrets",
"to",
"the",
"worker",
".",
"Any",
"tasks",
"not",
"previously",
"known",
"will",
"be",
"started",
".",
"Any",
"tasks",
"that",
"are",
"in",
"the",
"task",
"set",
"and",... | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/worker.go#L131-L156 | train |
docker/swarmkit | agent/worker.go | updateTaskStatus | func (w *worker) updateTaskStatus(ctx context.Context, tx *bolt.Tx, taskID string, status *api.TaskStatus) error {
if err := PutTaskStatus(tx, taskID, status); err != nil {
log.G(ctx).WithError(err).Error("failed writing status to disk")
return err
}
// broadcast the task status out.
for key := range w.listeners {
if err := key.StatusReporter.UpdateTaskStatus(ctx, taskID, status); err != nil {
log.G(ctx).WithError(err).Errorf("failed updating status for reporter %v", key.StatusReporter)
}
}
return nil
} | go | func (w *worker) updateTaskStatus(ctx context.Context, tx *bolt.Tx, taskID string, status *api.TaskStatus) error {
if err := PutTaskStatus(tx, taskID, status); err != nil {
log.G(ctx).WithError(err).Error("failed writing status to disk")
return err
}
// broadcast the task status out.
for key := range w.listeners {
if err := key.StatusReporter.UpdateTaskStatus(ctx, taskID, status); err != nil {
log.G(ctx).WithError(err).Errorf("failed updating status for reporter %v", key.StatusReporter)
}
}
return nil
} | [
"func",
"(",
"w",
"*",
"worker",
")",
"updateTaskStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"tx",
"*",
"bolt",
".",
"Tx",
",",
"taskID",
"string",
",",
"status",
"*",
"api",
".",
"TaskStatus",
")",
"error",
"{",
"if",
"err",
":=",
"PutTaskS... | // updateTaskStatus reports statuses to listeners, read lock must be held. | [
"updateTaskStatus",
"reports",
"statuses",
"to",
"listeners",
"read",
"lock",
"must",
"be",
"held",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/worker.go#L501-L515 | train |
docker/swarmkit | agent/worker.go | Subscribe | func (w *worker) Subscribe(ctx context.Context, subscription *api.SubscriptionMessage) error {
log.G(ctx).Debugf("Received subscription %s (selector: %v)", subscription.ID, subscription.Selector)
publisher, cancel, err := w.publisherProvider.Publisher(ctx, subscription.ID)
if err != nil {
return err
}
// Send a close once we're done
defer cancel()
match := func(t *api.Task) bool {
// TODO(aluzzardi): Consider using maps to limit the iterations.
for _, tid := range subscription.Selector.TaskIDs {
if t.ID == tid {
return true
}
}
for _, sid := range subscription.Selector.ServiceIDs {
if t.ServiceID == sid {
return true
}
}
for _, nid := range subscription.Selector.NodeIDs {
if t.NodeID == nid {
return true
}
}
return false
}
wg := sync.WaitGroup{}
w.mu.Lock()
for _, tm := range w.taskManagers {
if match(tm.task) {
wg.Add(1)
go func(tm *taskManager) {
defer wg.Done()
tm.Logs(ctx, *subscription.Options, publisher)
}(tm)
}
}
w.mu.Unlock()
// If follow mode is disabled, wait for the current set of matched tasks
// to finish publishing logs, then close the subscription by returning.
if subscription.Options == nil || !subscription.Options.Follow {
waitCh := make(chan struct{})
go func() {
defer close(waitCh)
wg.Wait()
}()
select {
case <-ctx.Done():
return ctx.Err()
case <-waitCh:
return nil
}
}
// In follow mode, watch for new tasks. Don't close the subscription
// until it's cancelled.
ch, cancel := w.taskevents.Watch()
defer cancel()
for {
select {
case v := <-ch:
task := v.(*api.Task)
if match(task) {
w.mu.RLock()
tm, ok := w.taskManagers[task.ID]
w.mu.RUnlock()
if !ok {
continue
}
go tm.Logs(ctx, *subscription.Options, publisher)
}
case <-ctx.Done():
return ctx.Err()
}
}
} | go | func (w *worker) Subscribe(ctx context.Context, subscription *api.SubscriptionMessage) error {
log.G(ctx).Debugf("Received subscription %s (selector: %v)", subscription.ID, subscription.Selector)
publisher, cancel, err := w.publisherProvider.Publisher(ctx, subscription.ID)
if err != nil {
return err
}
// Send a close once we're done
defer cancel()
match := func(t *api.Task) bool {
// TODO(aluzzardi): Consider using maps to limit the iterations.
for _, tid := range subscription.Selector.TaskIDs {
if t.ID == tid {
return true
}
}
for _, sid := range subscription.Selector.ServiceIDs {
if t.ServiceID == sid {
return true
}
}
for _, nid := range subscription.Selector.NodeIDs {
if t.NodeID == nid {
return true
}
}
return false
}
wg := sync.WaitGroup{}
w.mu.Lock()
for _, tm := range w.taskManagers {
if match(tm.task) {
wg.Add(1)
go func(tm *taskManager) {
defer wg.Done()
tm.Logs(ctx, *subscription.Options, publisher)
}(tm)
}
}
w.mu.Unlock()
// If follow mode is disabled, wait for the current set of matched tasks
// to finish publishing logs, then close the subscription by returning.
if subscription.Options == nil || !subscription.Options.Follow {
waitCh := make(chan struct{})
go func() {
defer close(waitCh)
wg.Wait()
}()
select {
case <-ctx.Done():
return ctx.Err()
case <-waitCh:
return nil
}
}
// In follow mode, watch for new tasks. Don't close the subscription
// until it's cancelled.
ch, cancel := w.taskevents.Watch()
defer cancel()
for {
select {
case v := <-ch:
task := v.(*api.Task)
if match(task) {
w.mu.RLock()
tm, ok := w.taskManagers[task.ID]
w.mu.RUnlock()
if !ok {
continue
}
go tm.Logs(ctx, *subscription.Options, publisher)
}
case <-ctx.Done():
return ctx.Err()
}
}
} | [
"func",
"(",
"w",
"*",
"worker",
")",
"Subscribe",
"(",
"ctx",
"context",
".",
"Context",
",",
"subscription",
"*",
"api",
".",
"SubscriptionMessage",
")",
"error",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Debugf",
"(",
"\"Received subscription %s (sel... | // Subscribe to log messages matching the subscription. | [
"Subscribe",
"to",
"log",
"messages",
"matching",
"the",
"subscription",
"."
] | 59163bf75df38489d4a10392265d27156dc473c5 | https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/worker.go#L518-L603 | train |
spf13/afero | ioutil.go | ReadDir | func (a Afero) ReadDir(dirname string) ([]os.FileInfo, error) {
return ReadDir(a.Fs, dirname)
} | go | func (a Afero) ReadDir(dirname string) ([]os.FileInfo, error) {
return ReadDir(a.Fs, dirname)
} | [
"func",
"(",
"a",
"Afero",
")",
"ReadDir",
"(",
"dirname",
"string",
")",
"(",
"[",
"]",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"return",
"ReadDir",
"(",
"a",
".",
"Fs",
",",
"dirname",
")",
"\n",
"}"
] | // ReadDir reads the directory named by dirname and returns
// a list of sorted directory entries. | [
"ReadDir",
"reads",
"the",
"directory",
"named",
"by",
"dirname",
"and",
"returns",
"a",
"list",
"of",
"sorted",
"directory",
"entries",
"."
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/ioutil.go#L38-L40 | train |
spf13/afero | ioutil.go | ReadFile | func (a Afero) ReadFile(filename string) ([]byte, error) {
return ReadFile(a.Fs, filename)
} | go | func (a Afero) ReadFile(filename string) ([]byte, error) {
return ReadFile(a.Fs, filename)
} | [
"func",
"(",
"a",
"Afero",
")",
"ReadFile",
"(",
"filename",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"ReadFile",
"(",
"a",
".",
"Fs",
",",
"filename",
")",
"\n",
"}"
] | // ReadFile reads the file named by filename and returns the contents.
// A successful call returns err == nil, not err == EOF. Because ReadFile
// reads the whole file, it does not treat an EOF from Read as an error
// to be reported. | [
"ReadFile",
"reads",
"the",
"file",
"named",
"by",
"filename",
"and",
"returns",
"the",
"contents",
".",
"A",
"successful",
"call",
"returns",
"err",
"==",
"nil",
"not",
"err",
"==",
"EOF",
".",
"Because",
"ReadFile",
"reads",
"the",
"whole",
"file",
"it",... | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/ioutil.go#L60-L62 | train |
spf13/afero | ioutil.go | readAll | func readAll(r io.Reader, capacity int64) (b []byte, err error) {
buf := bytes.NewBuffer(make([]byte, 0, capacity))
// If the buffer overflows, we will get bytes.ErrTooLarge.
// Return that as an error. Any other panic remains.
defer func() {
e := recover()
if e == nil {
return
}
if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
err = panicErr
} else {
panic(e)
}
}()
_, err = buf.ReadFrom(r)
return buf.Bytes(), err
} | go | func readAll(r io.Reader, capacity int64) (b []byte, err error) {
buf := bytes.NewBuffer(make([]byte, 0, capacity))
// If the buffer overflows, we will get bytes.ErrTooLarge.
// Return that as an error. Any other panic remains.
defer func() {
e := recover()
if e == nil {
return
}
if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
err = panicErr
} else {
panic(e)
}
}()
_, err = buf.ReadFrom(r)
return buf.Bytes(), err
} | [
"func",
"readAll",
"(",
"r",
"io",
".",
"Reader",
",",
"capacity",
"int64",
")",
"(",
"b",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"capacity",
"... | // readAll reads from r until an error or EOF and returns the data it read
// from the internal buffer allocated with a specified capacity. | [
"readAll",
"reads",
"from",
"r",
"until",
"an",
"error",
"or",
"EOF",
"and",
"returns",
"the",
"data",
"it",
"read",
"from",
"the",
"internal",
"buffer",
"allocated",
"with",
"a",
"specified",
"capacity",
"."
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/ioutil.go#L90-L107 | train |
spf13/afero | ioutil.go | WriteFile | func (a Afero) WriteFile(filename string, data []byte, perm os.FileMode) error {
return WriteFile(a.Fs, filename, data, perm)
} | go | func (a Afero) WriteFile(filename string, data []byte, perm os.FileMode) error {
return WriteFile(a.Fs, filename, data, perm)
} | [
"func",
"(",
"a",
"Afero",
")",
"WriteFile",
"(",
"filename",
"string",
",",
"data",
"[",
"]",
"byte",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"return",
"WriteFile",
"(",
"a",
".",
"Fs",
",",
"filename",
",",
"data",
",",
"perm",
")"... | // WriteFile writes data to a file named by filename.
// If the file does not exist, WriteFile creates it with permissions perm;
// otherwise WriteFile truncates it before writing. | [
"WriteFile",
"writes",
"data",
"to",
"a",
"file",
"named",
"by",
"filename",
".",
"If",
"the",
"file",
"does",
"not",
"exist",
"WriteFile",
"creates",
"it",
"with",
"permissions",
"perm",
";",
"otherwise",
"WriteFile",
"truncates",
"it",
"before",
"writing",
... | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/ioutil.go#L120-L122 | train |
spf13/afero | util.go | WriteReader | func (a Afero) WriteReader(path string, r io.Reader) (err error) {
return WriteReader(a.Fs, path, r)
} | go | func (a Afero) WriteReader(path string, r io.Reader) (err error) {
return WriteReader(a.Fs, path, r)
} | [
"func",
"(",
"a",
"Afero",
")",
"WriteReader",
"(",
"path",
"string",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"err",
"error",
")",
"{",
"return",
"WriteReader",
"(",
"a",
".",
"Fs",
",",
"path",
",",
"r",
")",
"\n",
"}"
] | // Takes a reader and a path and writes the content | [
"Takes",
"a",
"reader",
"and",
"a",
"path",
"and",
"writes",
"the",
"content"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/util.go#L36-L38 | train |
spf13/afero | util.go | GetTempDir | func GetTempDir(fs Fs, subPath string) string {
addSlash := func(p string) string {
if FilePathSeparator != p[len(p)-1:] {
p = p + FilePathSeparator
}
return p
}
dir := addSlash(os.TempDir())
if subPath != "" {
// preserve windows backslash :-(
if FilePathSeparator == "\\" {
subPath = strings.Replace(subPath, "\\", "____", -1)
}
dir = dir + UnicodeSanitize((subPath))
if FilePathSeparator == "\\" {
dir = strings.Replace(dir, "____", "\\", -1)
}
if exists, _ := Exists(fs, dir); exists {
return addSlash(dir)
}
err := fs.MkdirAll(dir, 0777)
if err != nil {
panic(err)
}
dir = addSlash(dir)
}
return dir
} | go | func GetTempDir(fs Fs, subPath string) string {
addSlash := func(p string) string {
if FilePathSeparator != p[len(p)-1:] {
p = p + FilePathSeparator
}
return p
}
dir := addSlash(os.TempDir())
if subPath != "" {
// preserve windows backslash :-(
if FilePathSeparator == "\\" {
subPath = strings.Replace(subPath, "\\", "____", -1)
}
dir = dir + UnicodeSanitize((subPath))
if FilePathSeparator == "\\" {
dir = strings.Replace(dir, "____", "\\", -1)
}
if exists, _ := Exists(fs, dir); exists {
return addSlash(dir)
}
err := fs.MkdirAll(dir, 0777)
if err != nil {
panic(err)
}
dir = addSlash(dir)
}
return dir
} | [
"func",
"GetTempDir",
"(",
"fs",
"Fs",
",",
"subPath",
"string",
")",
"string",
"{",
"addSlash",
":=",
"func",
"(",
"p",
"string",
")",
"string",
"{",
"if",
"FilePathSeparator",
"!=",
"p",
"[",
"len",
"(",
"p",
")",
"-",
"1",
":",
"]",
"{",
"p",
... | // GetTempDir returns the default temp directory with trailing slash
// if subPath is not empty then it will be created recursively with mode 777 rwx rwx rwx | [
"GetTempDir",
"returns",
"the",
"default",
"temp",
"directory",
"with",
"trailing",
"slash",
"if",
"subPath",
"is",
"not",
"empty",
"then",
"it",
"will",
"be",
"created",
"recursively",
"with",
"mode",
"777",
"rwx",
"rwx",
"rwx"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/util.go#L103-L133 | train |
spf13/afero | util.go | UnicodeSanitize | func UnicodeSanitize(s string) string {
source := []rune(s)
target := make([]rune, 0, len(source))
for _, r := range source {
if unicode.IsLetter(r) ||
unicode.IsDigit(r) ||
unicode.IsMark(r) ||
r == '.' ||
r == '/' ||
r == '\\' ||
r == '_' ||
r == '-' ||
r == '%' ||
r == ' ' ||
r == '#' {
target = append(target, r)
}
}
return string(target)
} | go | func UnicodeSanitize(s string) string {
source := []rune(s)
target := make([]rune, 0, len(source))
for _, r := range source {
if unicode.IsLetter(r) ||
unicode.IsDigit(r) ||
unicode.IsMark(r) ||
r == '.' ||
r == '/' ||
r == '\\' ||
r == '_' ||
r == '-' ||
r == '%' ||
r == ' ' ||
r == '#' {
target = append(target, r)
}
}
return string(target)
} | [
"func",
"UnicodeSanitize",
"(",
"s",
"string",
")",
"string",
"{",
"source",
":=",
"[",
"]",
"rune",
"(",
"s",
")",
"\n",
"target",
":=",
"make",
"(",
"[",
"]",
"rune",
",",
"0",
",",
"len",
"(",
"source",
")",
")",
"\n",
"for",
"_",
",",
"r",
... | // Rewrite string to remove non-standard path characters | [
"Rewrite",
"string",
"to",
"remove",
"non",
"-",
"standard",
"path",
"characters"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/util.go#L136-L157 | train |
spf13/afero | util.go | NeuterAccents | func NeuterAccents(s string) string {
t := transform.Chain(norm.NFD, transform.RemoveFunc(isMn), norm.NFC)
result, _, _ := transform.String(t, string(s))
return result
} | go | func NeuterAccents(s string) string {
t := transform.Chain(norm.NFD, transform.RemoveFunc(isMn), norm.NFC)
result, _, _ := transform.String(t, string(s))
return result
} | [
"func",
"NeuterAccents",
"(",
"s",
"string",
")",
"string",
"{",
"t",
":=",
"transform",
".",
"Chain",
"(",
"norm",
".",
"NFD",
",",
"transform",
".",
"RemoveFunc",
"(",
"isMn",
")",
",",
"norm",
".",
"NFC",
")",
"\n",
"result",
",",
"_",
",",
"_",... | // Transform characters with accents into plain forms. | [
"Transform",
"characters",
"with",
"accents",
"into",
"plain",
"forms",
"."
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/util.go#L160-L165 | train |
spf13/afero | util.go | FileContainsBytes | func FileContainsBytes(fs Fs, filename string, subslice []byte) (bool, error) {
f, err := fs.Open(filename)
if err != nil {
return false, err
}
defer f.Close()
return readerContainsAny(f, subslice), nil
} | go | func FileContainsBytes(fs Fs, filename string, subslice []byte) (bool, error) {
f, err := fs.Open(filename)
if err != nil {
return false, err
}
defer f.Close()
return readerContainsAny(f, subslice), nil
} | [
"func",
"FileContainsBytes",
"(",
"fs",
"Fs",
",",
"filename",
"string",
",",
"subslice",
"[",
"]",
"byte",
")",
"(",
"bool",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"fs",
".",
"Open",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // Check if a file contains a specified byte slice. | [
"Check",
"if",
"a",
"file",
"contains",
"a",
"specified",
"byte",
"slice",
"."
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/util.go#L176-L184 | train |
spf13/afero | util.go | FileContainsAnyBytes | func FileContainsAnyBytes(fs Fs, filename string, subslices [][]byte) (bool, error) {
f, err := fs.Open(filename)
if err != nil {
return false, err
}
defer f.Close()
return readerContainsAny(f, subslices...), nil
} | go | func FileContainsAnyBytes(fs Fs, filename string, subslices [][]byte) (bool, error) {
f, err := fs.Open(filename)
if err != nil {
return false, err
}
defer f.Close()
return readerContainsAny(f, subslices...), nil
} | [
"func",
"FileContainsAnyBytes",
"(",
"fs",
"Fs",
",",
"filename",
"string",
",",
"subslices",
"[",
"]",
"[",
"]",
"byte",
")",
"(",
"bool",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"fs",
".",
"Open",
"(",
"filename",
")",
"\n",
"if",
"err",
... | // Check if a file contains any of the specified byte slices. | [
"Check",
"if",
"a",
"file",
"contains",
"any",
"of",
"the",
"specified",
"byte",
"slices",
"."
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/util.go#L191-L199 | train |
spf13/afero | util.go | readerContainsAny | func readerContainsAny(r io.Reader, subslices ...[]byte) bool {
if r == nil || len(subslices) == 0 {
return false
}
largestSlice := 0
for _, sl := range subslices {
if len(sl) > largestSlice {
largestSlice = len(sl)
}
}
if largestSlice == 0 {
return false
}
bufflen := largestSlice * 4
halflen := bufflen / 2
buff := make([]byte, bufflen)
var err error
var n, i int
for {
i++
if i == 1 {
n, err = io.ReadAtLeast(r, buff[:halflen], halflen)
} else {
if i != 2 {
// shift left to catch overlapping matches
copy(buff[:], buff[halflen:])
}
n, err = io.ReadAtLeast(r, buff[halflen:], halflen)
}
if n > 0 {
for _, sl := range subslices {
if bytes.Contains(buff, sl) {
return true
}
}
}
if err != nil {
break
}
}
return false
} | go | func readerContainsAny(r io.Reader, subslices ...[]byte) bool {
if r == nil || len(subslices) == 0 {
return false
}
largestSlice := 0
for _, sl := range subslices {
if len(sl) > largestSlice {
largestSlice = len(sl)
}
}
if largestSlice == 0 {
return false
}
bufflen := largestSlice * 4
halflen := bufflen / 2
buff := make([]byte, bufflen)
var err error
var n, i int
for {
i++
if i == 1 {
n, err = io.ReadAtLeast(r, buff[:halflen], halflen)
} else {
if i != 2 {
// shift left to catch overlapping matches
copy(buff[:], buff[halflen:])
}
n, err = io.ReadAtLeast(r, buff[halflen:], halflen)
}
if n > 0 {
for _, sl := range subslices {
if bytes.Contains(buff, sl) {
return true
}
}
}
if err != nil {
break
}
}
return false
} | [
"func",
"readerContainsAny",
"(",
"r",
"io",
".",
"Reader",
",",
"subslices",
"...",
"[",
"]",
"byte",
")",
"bool",
"{",
"if",
"r",
"==",
"nil",
"||",
"len",
"(",
"subslices",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n",
"largestSlice",
... | // readerContains reports whether any of the subslices is within r. | [
"readerContains",
"reports",
"whether",
"any",
"of",
"the",
"subslices",
"is",
"within",
"r",
"."
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/util.go#L202-L251 | train |
spf13/afero | util.go | IsEmpty | func IsEmpty(fs Fs, path string) (bool, error) {
if b, _ := Exists(fs, path); !b {
return false, fmt.Errorf("%q path does not exist", path)
}
fi, err := fs.Stat(path)
if err != nil {
return false, err
}
if fi.IsDir() {
f, err := fs.Open(path)
if err != nil {
return false, err
}
defer f.Close()
list, err := f.Readdir(-1)
return len(list) == 0, nil
}
return fi.Size() == 0, nil
} | go | func IsEmpty(fs Fs, path string) (bool, error) {
if b, _ := Exists(fs, path); !b {
return false, fmt.Errorf("%q path does not exist", path)
}
fi, err := fs.Stat(path)
if err != nil {
return false, err
}
if fi.IsDir() {
f, err := fs.Open(path)
if err != nil {
return false, err
}
defer f.Close()
list, err := f.Readdir(-1)
return len(list) == 0, nil
}
return fi.Size() == 0, nil
} | [
"func",
"IsEmpty",
"(",
"fs",
"Fs",
",",
"path",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"b",
",",
"_",
":=",
"Exists",
"(",
"fs",
",",
"path",
")",
";",
"!",
"b",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"%... | // IsEmpty checks if a given file or directory is empty. | [
"IsEmpty",
"checks",
"if",
"a",
"given",
"file",
"or",
"directory",
"is",
"empty",
"."
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/util.go#L287-L305 | train |
spf13/afero | mem/file.go | Name | func (s *FileInfo) Name() string {
s.Lock()
_, name := filepath.Split(s.name)
s.Unlock()
return name
} | go | func (s *FileInfo) Name() string {
s.Lock()
_, name := filepath.Split(s.name)
s.Unlock()
return name
} | [
"func",
"(",
"s",
"*",
"FileInfo",
")",
"Name",
"(",
")",
"string",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"_",
",",
"name",
":=",
"filepath",
".",
"Split",
"(",
"s",
".",
"name",
")",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n",
"return",
"name... | // Implements os.FileInfo | [
"Implements",
"os",
".",
"FileInfo"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/mem/file.go#L279-L284 | train |
spf13/afero | memmap.go | normalizePath | func normalizePath(path string) string {
path = filepath.Clean(path)
switch path {
case ".":
return FilePathSeparator
case "..":
return FilePathSeparator
default:
return path
}
} | go | func normalizePath(path string) string {
path = filepath.Clean(path)
switch path {
case ".":
return FilePathSeparator
case "..":
return FilePathSeparator
default:
return path
}
} | [
"func",
"normalizePath",
"(",
"path",
"string",
")",
"string",
"{",
"path",
"=",
"filepath",
".",
"Clean",
"(",
"path",
")",
"\n",
"switch",
"path",
"{",
"case",
"\".\"",
":",
"return",
"FilePathSeparator",
"\n",
"case",
"\"..\"",
":",
"return",
"FilePathS... | // Handle some relative paths | [
"Handle",
"some",
"relative",
"paths"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/memmap.go#L161-L172 | train |
spf13/afero | basepath.go | RealPath | func (b *BasePathFs) RealPath(name string) (path string, err error) {
if err := validateBasePathName(name); err != nil {
return name, err
}
bpath := filepath.Clean(b.path)
path = filepath.Clean(filepath.Join(bpath, name))
if !strings.HasPrefix(path, bpath) {
return name, os.ErrNotExist
}
return path, nil
} | go | func (b *BasePathFs) RealPath(name string) (path string, err error) {
if err := validateBasePathName(name); err != nil {
return name, err
}
bpath := filepath.Clean(b.path)
path = filepath.Clean(filepath.Join(bpath, name))
if !strings.HasPrefix(path, bpath) {
return name, os.ErrNotExist
}
return path, nil
} | [
"func",
"(",
"b",
"*",
"BasePathFs",
")",
"RealPath",
"(",
"name",
"string",
")",
"(",
"path",
"string",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"validateBasePathName",
"(",
"name",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"name",
",",
... | // on a file outside the base path it returns the given file name and an error,
// else the given file with the base path prepended | [
"on",
"a",
"file",
"outside",
"the",
"base",
"path",
"it",
"returns",
"the",
"given",
"file",
"name",
"and",
"an",
"error",
"else",
"the",
"given",
"file",
"with",
"the",
"base",
"path",
"prepended"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/basepath.go#L42-L54 | train |
spf13/afero | unionFile.go | Readdir | func (f *UnionFile) Readdir(c int) (ofi []os.FileInfo, err error) {
var merge DirsMerger = f.Merger
if merge == nil {
merge = defaultUnionMergeDirsFn
}
if f.off == 0 {
var lfi []os.FileInfo
if f.Layer != nil {
lfi, err = f.Layer.Readdir(-1)
if err != nil {
return nil, err
}
}
var bfi []os.FileInfo
if f.Base != nil {
bfi, err = f.Base.Readdir(-1)
if err != nil {
return nil, err
}
}
merged, err := merge(lfi, bfi)
if err != nil {
return nil, err
}
f.files = append(f.files, merged...)
}
if c <= 0 && len(f.files) == 0 {
return f.files, nil
}
if f.off >= len(f.files) {
return nil, io.EOF
}
if c <= 0 {
return f.files[f.off:], nil
}
if c > len(f.files) {
c = len(f.files)
}
defer func() { f.off += c }()
return f.files[f.off:c], nil
} | go | func (f *UnionFile) Readdir(c int) (ofi []os.FileInfo, err error) {
var merge DirsMerger = f.Merger
if merge == nil {
merge = defaultUnionMergeDirsFn
}
if f.off == 0 {
var lfi []os.FileInfo
if f.Layer != nil {
lfi, err = f.Layer.Readdir(-1)
if err != nil {
return nil, err
}
}
var bfi []os.FileInfo
if f.Base != nil {
bfi, err = f.Base.Readdir(-1)
if err != nil {
return nil, err
}
}
merged, err := merge(lfi, bfi)
if err != nil {
return nil, err
}
f.files = append(f.files, merged...)
}
if c <= 0 && len(f.files) == 0 {
return f.files, nil
}
if f.off >= len(f.files) {
return nil, io.EOF
}
if c <= 0 {
return f.files[f.off:], nil
}
if c > len(f.files) {
c = len(f.files)
}
defer func() { f.off += c }()
return f.files[f.off:c], nil
} | [
"func",
"(",
"f",
"*",
"UnionFile",
")",
"Readdir",
"(",
"c",
"int",
")",
"(",
"ofi",
"[",
"]",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"{",
"var",
"merge",
"DirsMerger",
"=",
"f",
".",
"Merger",
"\n",
"if",
"merge",
"==",
"nil",
"{",
... | // Readdir will weave the two directories together and
// return a single view of the overlayed directories.
// At the end of the directory view, the error is io.EOF if c > 0. | [
"Readdir",
"will",
"weave",
"the",
"two",
"directories",
"together",
"and",
"return",
"a",
"single",
"view",
"of",
"the",
"overlayed",
"directories",
".",
"At",
"the",
"end",
"of",
"the",
"directory",
"view",
"the",
"error",
"is",
"io",
".",
"EOF",
"if",
... | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/unionFile.go#L160-L208 | train |
spf13/afero | copyOnWriteFs.go | isBaseFile | func (u *CopyOnWriteFs) isBaseFile(name string) (bool, error) {
if _, err := u.layer.Stat(name); err == nil {
return false, nil
}
_, err := u.base.Stat(name)
if err != nil {
if oerr, ok := err.(*os.PathError); ok {
if oerr.Err == os.ErrNotExist || oerr.Err == syscall.ENOENT || oerr.Err == syscall.ENOTDIR {
return false, nil
}
}
if err == syscall.ENOENT {
return false, nil
}
}
return true, err
} | go | func (u *CopyOnWriteFs) isBaseFile(name string) (bool, error) {
if _, err := u.layer.Stat(name); err == nil {
return false, nil
}
_, err := u.base.Stat(name)
if err != nil {
if oerr, ok := err.(*os.PathError); ok {
if oerr.Err == os.ErrNotExist || oerr.Err == syscall.ENOENT || oerr.Err == syscall.ENOTDIR {
return false, nil
}
}
if err == syscall.ENOENT {
return false, nil
}
}
return true, err
} | [
"func",
"(",
"u",
"*",
"CopyOnWriteFs",
")",
"isBaseFile",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"u",
".",
"layer",
".",
"Stat",
"(",
"name",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"... | // Returns true if the file is not in the overlay | [
"Returns",
"true",
"if",
"the",
"file",
"is",
"not",
"in",
"the",
"overlay"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/copyOnWriteFs.go#L30-L46 | train |
spf13/afero | copyOnWriteFs.go | Rename | func (u *CopyOnWriteFs) Rename(oldname, newname string) error {
b, err := u.isBaseFile(oldname)
if err != nil {
return err
}
if b {
return syscall.EPERM
}
return u.layer.Rename(oldname, newname)
} | go | func (u *CopyOnWriteFs) Rename(oldname, newname string) error {
b, err := u.isBaseFile(oldname)
if err != nil {
return err
}
if b {
return syscall.EPERM
}
return u.layer.Rename(oldname, newname)
} | [
"func",
"(",
"u",
"*",
"CopyOnWriteFs",
")",
"Rename",
"(",
"oldname",
",",
"newname",
"string",
")",
"error",
"{",
"b",
",",
"err",
":=",
"u",
".",
"isBaseFile",
"(",
"oldname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",... | // Renaming files present only in the base layer is not permitted | [
"Renaming",
"files",
"present",
"only",
"in",
"the",
"base",
"layer",
"is",
"not",
"permitted"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/copyOnWriteFs.go#L131-L140 | train |
spf13/afero | copyOnWriteFs.go | Remove | func (u *CopyOnWriteFs) Remove(name string) error {
err := u.layer.Remove(name)
switch err {
case syscall.ENOENT:
_, err = u.base.Stat(name)
if err == nil {
return syscall.EPERM
}
return syscall.ENOENT
default:
return err
}
} | go | func (u *CopyOnWriteFs) Remove(name string) error {
err := u.layer.Remove(name)
switch err {
case syscall.ENOENT:
_, err = u.base.Stat(name)
if err == nil {
return syscall.EPERM
}
return syscall.ENOENT
default:
return err
}
} | [
"func",
"(",
"u",
"*",
"CopyOnWriteFs",
")",
"Remove",
"(",
"name",
"string",
")",
"error",
"{",
"err",
":=",
"u",
".",
"layer",
".",
"Remove",
"(",
"name",
")",
"\n",
"switch",
"err",
"{",
"case",
"syscall",
".",
"ENOENT",
":",
"_",
",",
"err",
... | // Removing files present only in the base layer is not permitted. If
// a file is present in the base layer and the overlay, only the overlay
// will be removed. | [
"Removing",
"files",
"present",
"only",
"in",
"the",
"base",
"layer",
"is",
"not",
"permitted",
".",
"If",
"a",
"file",
"is",
"present",
"in",
"the",
"base",
"layer",
"and",
"the",
"overlay",
"only",
"the",
"overlay",
"will",
"be",
"removed",
"."
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/copyOnWriteFs.go#L145-L157 | train |
spf13/afero | path.go | lstatIfPossible | func lstatIfPossible(fs Fs, path string) (os.FileInfo, error) {
if lfs, ok := fs.(Lstater); ok {
fi, _, err := lfs.LstatIfPossible(path)
return fi, err
}
return fs.Stat(path)
} | go | func lstatIfPossible(fs Fs, path string) (os.FileInfo, error) {
if lfs, ok := fs.(Lstater); ok {
fi, _, err := lfs.LstatIfPossible(path)
return fi, err
}
return fs.Stat(path)
} | [
"func",
"lstatIfPossible",
"(",
"fs",
"Fs",
",",
"path",
"string",
")",
"(",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"if",
"lfs",
",",
"ok",
":=",
"fs",
".",
"(",
"Lstater",
")",
";",
"ok",
"{",
"fi",
",",
"_",
",",
"err",
":=",
"lfs",
... | // if the filesystem supports it, use Lstat, else use fs.Stat | [
"if",
"the",
"filesystem",
"supports",
"it",
"use",
"Lstat",
"else",
"use",
"fs",
".",
"Stat"
] | 588a75ec4f32903aa5e39a2619ba6a4631e28424 | https://github.com/spf13/afero/blob/588a75ec4f32903aa5e39a2619ba6a4631e28424/path.go#L81-L87 | train |
requilence/integram | types.go | toBson | func (o *OAuthProvider) toBson() bson.M {
return bson.M{"baseurl": struct {
Scheme string
Host string
Path string
}{o.BaseURL.Scheme, o.BaseURL.Host, o.BaseURL.Path},
"id": o.ID,
"secret": o.Secret,
"service": o.Service}
} | go | func (o *OAuthProvider) toBson() bson.M {
return bson.M{"baseurl": struct {
Scheme string
Host string
Path string
}{o.BaseURL.Scheme, o.BaseURL.Host, o.BaseURL.Path},
"id": o.ID,
"secret": o.Secret,
"service": o.Service}
} | [
"func",
"(",
"o",
"*",
"OAuthProvider",
")",
"toBson",
"(",
")",
"bson",
".",
"M",
"{",
"return",
"bson",
".",
"M",
"{",
"\"baseurl\"",
":",
"struct",
"{",
"Scheme",
"string",
"\n",
"Host",
"string",
"\n",
"Path",
"string",
"\n",
"}",
"{",
"o",
"."... | // workaround to save urls as struct | [
"workaround",
"to",
"save",
"urls",
"as",
"struct"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/types.go#L50-L60 | train |
requilence/integram | helpers.go | URLMustParse | func URLMustParse(s string) *url.URL {
u, err := url.Parse(s)
if err != nil {
log.Errorf("Expected URL to parse: %q, got error: %v", s, err)
}
return u
} | go | func URLMustParse(s string) *url.URL {
u, err := url.Parse(s)
if err != nil {
log.Errorf("Expected URL to parse: %q, got error: %v", s, err)
}
return u
} | [
"func",
"URLMustParse",
"(",
"s",
"string",
")",
"*",
"url",
".",
"URL",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Expected URL to parse: %q, got error: %v\"",
","... | // URLMustParse returns url.URL from static string. Don't use it with a dynamic param | [
"URLMustParse",
"returns",
"url",
".",
"URL",
"from",
"static",
"string",
".",
"Don",
"t",
"use",
"it",
"with",
"a",
"dynamic",
"param"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/helpers.go#L165-L171 | train |
requilence/integram | helpers.go | GetVersion | func GetVersion() string {
if currentGitHead == "" {
b, err := ioutil.ReadFile(".git/HEAD")
if err != nil {
currentGitHead = "unknown"
return currentGitHead
}
p := refRE.FindStringSubmatch(string(b))
if len(p) < 2 {
currentGitHead = string(b)
return currentGitHead
}
b, err = ioutil.ReadFile(".git/" + p[1])
if err != nil {
currentGitHead = p[1]
return currentGitHead
}
currentGitHead = string(b)
}
return currentGitHead
} | go | func GetVersion() string {
if currentGitHead == "" {
b, err := ioutil.ReadFile(".git/HEAD")
if err != nil {
currentGitHead = "unknown"
return currentGitHead
}
p := refRE.FindStringSubmatch(string(b))
if len(p) < 2 {
currentGitHead = string(b)
return currentGitHead
}
b, err = ioutil.ReadFile(".git/" + p[1])
if err != nil {
currentGitHead = p[1]
return currentGitHead
}
currentGitHead = string(b)
}
return currentGitHead
} | [
"func",
"GetVersion",
"(",
")",
"string",
"{",
"if",
"currentGitHead",
"==",
"\"\"",
"{",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"\".git/HEAD\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"currentGitHead",
"=",
"\"unknown\"",
"\n",
"retur... | // GetVersion returns the current HEAD git commit if .git exists | [
"GetVersion",
"returns",
"the",
"current",
"HEAD",
"git",
"commit",
"if",
".",
"git",
"exists"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/helpers.go#L200-L225 | train |
requilence/integram | data.go | Cache | func (user *User) Cache(key string, res interface{}) (exists bool) {
return user.ctx.getCacheVal("user", key, res)
} | go | func (user *User) Cache(key string, res interface{}) (exists bool) {
return user.ctx.getCacheVal("user", key, res)
} | [
"func",
"(",
"user",
"*",
"User",
")",
"Cache",
"(",
"key",
"string",
",",
"res",
"interface",
"{",
"}",
")",
"(",
"exists",
"bool",
")",
"{",
"return",
"user",
".",
"ctx",
".",
"getCacheVal",
"(",
"\"user\"",
",",
"key",
",",
"res",
")",
"\n",
"... | // Cache returns if User's cache for specific key exists and try to bind it to res | [
"Cache",
"returns",
"if",
"User",
"s",
"cache",
"for",
"specific",
"key",
"exists",
"and",
"try",
"to",
"bind",
"it",
"to",
"res"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L377-L379 | train |
requilence/integram | data.go | Cache | func (chat *Chat) Cache(key string, res interface{}) (exists bool) {
return chat.ctx.getCacheVal("chat", key, res)
} | go | func (chat *Chat) Cache(key string, res interface{}) (exists bool) {
return chat.ctx.getCacheVal("chat", key, res)
} | [
"func",
"(",
"chat",
"*",
"Chat",
")",
"Cache",
"(",
"key",
"string",
",",
"res",
"interface",
"{",
"}",
")",
"(",
"exists",
"bool",
")",
"{",
"return",
"chat",
".",
"ctx",
".",
"getCacheVal",
"(",
"\"chat\"",
",",
"key",
",",
"res",
")",
"\n",
"... | // Cache returns if Chat's cache for specific key exists and try to bind it to res | [
"Cache",
"returns",
"if",
"Chat",
"s",
"cache",
"for",
"specific",
"key",
"exists",
"and",
"try",
"to",
"bind",
"it",
"to",
"res"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L382-L384 | train |
requilence/integram | data.go | ServiceCache | func (c *Context) ServiceCache(key string, res interface{}) (exists bool) {
return c.getCacheVal("service", key, res)
} | go | func (c *Context) ServiceCache(key string, res interface{}) (exists bool) {
return c.getCacheVal("service", key, res)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"ServiceCache",
"(",
"key",
"string",
",",
"res",
"interface",
"{",
"}",
")",
"(",
"exists",
"bool",
")",
"{",
"return",
"c",
".",
"getCacheVal",
"(",
"\"service\"",
",",
"key",
",",
"res",
")",
"\n",
"}"
] | // ServiceCache returns if Services's cache for specific key exists and try to bind it to res | [
"ServiceCache",
"returns",
"if",
"Services",
"s",
"cache",
"for",
"specific",
"key",
"exists",
"and",
"try",
"to",
"bind",
"it",
"to",
"res"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L387-L389 | train |
requilence/integram | data.go | SetCache | func (user *User) SetCache(key string, val interface{}, ttl time.Duration) error {
expiresAt := time.Now().Add(ttl)
serviceID := user.ctx.getServiceID()
key = strings.ToLower(key)
if val == nil {
err := user.ctx.db.C("users_cache").Remove(bson.M{"userid": user.ID, "service": serviceID, "key": key})
return err
}
_, err := user.ctx.db.C("users_cache").Upsert(bson.M{"userid": user.ID, "service": serviceID, "key": key}, bson.M{"$set": bson.M{"val": val, "expiresat": expiresAt}})
if err != nil {
// workaround for WiredTiger bug: https://jira.mongodb.org/browse/SERVER-14322
if mgo.IsDup(err) {
return user.ctx.db.C("users_cache").Update(bson.M{"userid": user.ID, "service": serviceID, "key": key}, bson.M{"$set": bson.M{"val": val, "expiresat": expiresAt}})
}
log.WithError(err).WithField("key", key).Error("Can't set user cache value")
}
return err
} | go | func (user *User) SetCache(key string, val interface{}, ttl time.Duration) error {
expiresAt := time.Now().Add(ttl)
serviceID := user.ctx.getServiceID()
key = strings.ToLower(key)
if val == nil {
err := user.ctx.db.C("users_cache").Remove(bson.M{"userid": user.ID, "service": serviceID, "key": key})
return err
}
_, err := user.ctx.db.C("users_cache").Upsert(bson.M{"userid": user.ID, "service": serviceID, "key": key}, bson.M{"$set": bson.M{"val": val, "expiresat": expiresAt}})
if err != nil {
// workaround for WiredTiger bug: https://jira.mongodb.org/browse/SERVER-14322
if mgo.IsDup(err) {
return user.ctx.db.C("users_cache").Update(bson.M{"userid": user.ID, "service": serviceID, "key": key}, bson.M{"$set": bson.M{"val": val, "expiresat": expiresAt}})
}
log.WithError(err).WithField("key", key).Error("Can't set user cache value")
}
return err
} | [
"func",
"(",
"user",
"*",
"User",
")",
"SetCache",
"(",
"key",
"string",
",",
"val",
"interface",
"{",
"}",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"expiresAt",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"ttl",
")",
"\n"... | // SetCache set the User's cache with specific key and TTL | [
"SetCache",
"set",
"the",
"User",
"s",
"cache",
"with",
"specific",
"key",
"and",
"TTL"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L405-L424 | train |
requilence/integram | data.go | UpdateCache | func (user *User) UpdateCache(key string, update interface{}, res interface{}) error {
exists := user.ctx.updateCacheVal("user", key, update, res)
if !exists {
log.WithField("key", key).Error("Can't update user cache value")
}
return nil
} | go | func (user *User) UpdateCache(key string, update interface{}, res interface{}) error {
exists := user.ctx.updateCacheVal("user", key, update, res)
if !exists {
log.WithField("key", key).Error("Can't update user cache value")
}
return nil
} | [
"func",
"(",
"user",
"*",
"User",
")",
"UpdateCache",
"(",
"key",
"string",
",",
"update",
"interface",
"{",
"}",
",",
"res",
"interface",
"{",
"}",
")",
"error",
"{",
"exists",
":=",
"user",
".",
"ctx",
".",
"updateCacheVal",
"(",
"\"user\"",
",",
"... | // UpdateCache updates the per User cache using MongoDB Update query | [
"UpdateCache",
"updates",
"the",
"per",
"User",
"cache",
"using",
"MongoDB",
"Update",
"query"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L427-L435 | train |
requilence/integram | data.go | SetServiceCache | func (c *Context) SetServiceCache(key string, val interface{}, ttl time.Duration) error {
expiresAt := time.Now().Add(ttl)
serviceID := c.getServiceID()
key = strings.ToLower(key)
if val == nil {
err := c.db.C("services_cache").Remove(bson.M{"service": serviceID, "key": key})
return err
}
_, err := c.db.C("services_cache").Upsert(bson.M{"service": serviceID, "key": key}, bson.M{"$set": bson.M{"val": val, "expiresat": expiresAt}})
if err != nil {
// workaround for WiredTiger bug: https://jira.mongodb.org/browse/SERVER-14322
if mgo.IsDup(err) {
return c.db.C("services_cache").Update(bson.M{"service": serviceID, "key": key}, bson.M{"$set": bson.M{"val": val, "expiresat": expiresAt}})
}
log.WithError(err).WithField("key", key).Error("Can't set sevices cache value")
}
return err
} | go | func (c *Context) SetServiceCache(key string, val interface{}, ttl time.Duration) error {
expiresAt := time.Now().Add(ttl)
serviceID := c.getServiceID()
key = strings.ToLower(key)
if val == nil {
err := c.db.C("services_cache").Remove(bson.M{"service": serviceID, "key": key})
return err
}
_, err := c.db.C("services_cache").Upsert(bson.M{"service": serviceID, "key": key}, bson.M{"$set": bson.M{"val": val, "expiresat": expiresAt}})
if err != nil {
// workaround for WiredTiger bug: https://jira.mongodb.org/browse/SERVER-14322
if mgo.IsDup(err) {
return c.db.C("services_cache").Update(bson.M{"service": serviceID, "key": key}, bson.M{"$set": bson.M{"val": val, "expiresat": expiresAt}})
}
log.WithError(err).WithField("key", key).Error("Can't set sevices cache value")
}
return err
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"SetServiceCache",
"(",
"key",
"string",
",",
"val",
"interface",
"{",
"}",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"expiresAt",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"ttl",
")",... | // SetServiceCache set the Services's cache with specific key and TTL | [
"SetServiceCache",
"set",
"the",
"Services",
"s",
"cache",
"with",
"specific",
"key",
"and",
"TTL"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L470-L489 | train |
requilence/integram | data.go | Settings | func (user *User) Settings(out interface{}) error {
data, err := user.getData()
if err != nil {
return err
}
serviceID := user.ctx.getServiceID()
if _, ok := data.Settings[serviceID]; ok {
// TODO: workaround that creepy bindInterfaceToInterface
err = bindInterfaceToInterface(data.Settings[serviceID], out)
return err
}
// Not a error – just empty settings
return nil
} | go | func (user *User) Settings(out interface{}) error {
data, err := user.getData()
if err != nil {
return err
}
serviceID := user.ctx.getServiceID()
if _, ok := data.Settings[serviceID]; ok {
// TODO: workaround that creepy bindInterfaceToInterface
err = bindInterfaceToInterface(data.Settings[serviceID], out)
return err
}
// Not a error – just empty settings
return nil
} | [
"func",
"(",
"user",
"*",
"User",
")",
"Settings",
"(",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"data",
",",
"err",
":=",
"user",
".",
"getData",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"serviceID... | // Settings bind User's settings for service to the interface | [
"Settings",
"bind",
"User",
"s",
"settings",
"for",
"service",
"to",
"the",
"interface"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L642-L658 | train |
requilence/integram | data.go | Settings | func (chat *Chat) Settings(out interface{}) error {
data, err := chat.getData()
if err != nil {
return err
}
serviceID := chat.ctx.getServiceID()
if _, ok := data.Settings[serviceID]; ok {
// TODO: workaround that creepy bindInterfaceToInterface
err = bindInterfaceToInterface(data.Settings[serviceID], out)
return err
}
// Not a error – just empty settings
return nil
} | go | func (chat *Chat) Settings(out interface{}) error {
data, err := chat.getData()
if err != nil {
return err
}
serviceID := chat.ctx.getServiceID()
if _, ok := data.Settings[serviceID]; ok {
// TODO: workaround that creepy bindInterfaceToInterface
err = bindInterfaceToInterface(data.Settings[serviceID], out)
return err
}
// Not a error – just empty settings
return nil
} | [
"func",
"(",
"chat",
"*",
"Chat",
")",
"Settings",
"(",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"data",
",",
"err",
":=",
"chat",
".",
"getData",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"serviceID... | // Settings bind Chat's settings for service to the interface | [
"Settings",
"bind",
"Chat",
"s",
"settings",
"for",
"service",
"to",
"the",
"interface"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L661-L678 | train |
requilence/integram | data.go | SaveSettings | func (chat *Chat) SaveSettings(allSettings interface{}) error {
serviceID := chat.ctx.getServiceID()
_, err := chat.ctx.db.C("chats").UpsertId(chat.ID, bson.M{"$set": bson.M{"settings." + serviceID: allSettings}, "$setOnInsert": bson.M{"createdat": time.Now()}})
if chat.data == nil {
chat.data = &chatData{}
}
if chat.data.Settings == nil {
chat.data.Settings = make(map[string]interface{})
}
chat.data.Settings[serviceID] = allSettings
return err
} | go | func (chat *Chat) SaveSettings(allSettings interface{}) error {
serviceID := chat.ctx.getServiceID()
_, err := chat.ctx.db.C("chats").UpsertId(chat.ID, bson.M{"$set": bson.M{"settings." + serviceID: allSettings}, "$setOnInsert": bson.M{"createdat": time.Now()}})
if chat.data == nil {
chat.data = &chatData{}
}
if chat.data.Settings == nil {
chat.data.Settings = make(map[string]interface{})
}
chat.data.Settings[serviceID] = allSettings
return err
} | [
"func",
"(",
"chat",
"*",
"Chat",
")",
"SaveSettings",
"(",
"allSettings",
"interface",
"{",
"}",
")",
"error",
"{",
"serviceID",
":=",
"chat",
".",
"ctx",
".",
"getServiceID",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"chat",
".",
"ctx",
".",
"db",
"... | // SaveSettings save Chat's setting for service | [
"SaveSettings",
"save",
"Chat",
"s",
"setting",
"for",
"service"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L713-L730 | train |
requilence/integram | data.go | SaveSettings | func (user *User) SaveSettings(allSettings interface{}) error {
serviceID := user.ctx.getServiceID()
_, err := user.ctx.db.C("users").UpsertId(user.ID, bson.M{"$set": bson.M{"settings." + serviceID: allSettings}, "$setOnInsert": bson.M{"createdat": time.Now()}})
if user.data == nil {
user.data = &userData{}
}
if user.data.Settings == nil {
user.data.Settings = make(map[string]interface{})
}
user.data.Settings[serviceID] = allSettings
return err
} | go | func (user *User) SaveSettings(allSettings interface{}) error {
serviceID := user.ctx.getServiceID()
_, err := user.ctx.db.C("users").UpsertId(user.ID, bson.M{"$set": bson.M{"settings." + serviceID: allSettings}, "$setOnInsert": bson.M{"createdat": time.Now()}})
if user.data == nil {
user.data = &userData{}
}
if user.data.Settings == nil {
user.data.Settings = make(map[string]interface{})
}
user.data.Settings[serviceID] = allSettings
return err
} | [
"func",
"(",
"user",
"*",
"User",
")",
"SaveSettings",
"(",
"allSettings",
"interface",
"{",
"}",
")",
"error",
"{",
"serviceID",
":=",
"user",
".",
"ctx",
".",
"getServiceID",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"user",
".",
"ctx",
".",
"db",
"... | // SaveSettings save User's setting for service | [
"SaveSettings",
"save",
"User",
"s",
"setting",
"for",
"service"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L733-L748 | train |
requilence/integram | data.go | ServiceHookToken | func (chat *Chat) ServiceHookToken() string {
data, _ := chat.getData()
//TODO: test backward compatibility cases
for _, hook := range data.Hooks {
for _, service := range hook.Services {
if service == chat.ctx.ServiceName {
return hook.Token
}
}
}
token := "c" + rndStr.Get(10)
chat.addHook(serviceHook{
Token: token,
Services: []string{chat.ctx.ServiceName},
})
return token
} | go | func (chat *Chat) ServiceHookToken() string {
data, _ := chat.getData()
//TODO: test backward compatibility cases
for _, hook := range data.Hooks {
for _, service := range hook.Services {
if service == chat.ctx.ServiceName {
return hook.Token
}
}
}
token := "c" + rndStr.Get(10)
chat.addHook(serviceHook{
Token: token,
Services: []string{chat.ctx.ServiceName},
})
return token
} | [
"func",
"(",
"chat",
"*",
"Chat",
")",
"ServiceHookToken",
"(",
")",
"string",
"{",
"data",
",",
"_",
":=",
"chat",
".",
"getData",
"(",
")",
"\n",
"for",
"_",
",",
"hook",
":=",
"range",
"data",
".",
"Hooks",
"{",
"for",
"_",
",",
"service",
":=... | // ServiceHookToken returns Chats's hook token to use in webhook handling | [
"ServiceHookToken",
"returns",
"Chats",
"s",
"hook",
"token",
"to",
"use",
"in",
"webhook",
"handling"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L784-L800 | train |
requilence/integram | data.go | ServiceHookURL | func (user *User) ServiceHookURL() string {
return Config.BaseURL + "/" + user.ctx.ServiceName + "/" + user.ServiceHookToken()
} | go | func (user *User) ServiceHookURL() string {
return Config.BaseURL + "/" + user.ctx.ServiceName + "/" + user.ServiceHookToken()
} | [
"func",
"(",
"user",
"*",
"User",
")",
"ServiceHookURL",
"(",
")",
"string",
"{",
"return",
"Config",
".",
"BaseURL",
"+",
"\"/\"",
"+",
"user",
".",
"ctx",
".",
"ServiceName",
"+",
"\"/\"",
"+",
"user",
".",
"ServiceHookToken",
"(",
")",
"\n",
"}"
] | // ServiceHookURL returns User's webhook URL for service to use in webhook handling
// Used in case when incoming webhooks despatching on the user behalf to chats | [
"ServiceHookURL",
"returns",
"User",
"s",
"webhook",
"URL",
"for",
"service",
"to",
"use",
"in",
"webhook",
"handling",
"Used",
"in",
"case",
"when",
"incoming",
"webhooks",
"despatching",
"on",
"the",
"user",
"behalf",
"to",
"chats"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L804-L806 | train |
requilence/integram | data.go | ServiceHookURL | func (chat *Chat) ServiceHookURL() string {
return Config.BaseURL + "/" + chat.ctx.ServiceName + "/" + chat.ServiceHookToken()
} | go | func (chat *Chat) ServiceHookURL() string {
return Config.BaseURL + "/" + chat.ctx.ServiceName + "/" + chat.ServiceHookToken()
} | [
"func",
"(",
"chat",
"*",
"Chat",
")",
"ServiceHookURL",
"(",
")",
"string",
"{",
"return",
"Config",
".",
"BaseURL",
"+",
"\"/\"",
"+",
"chat",
".",
"ctx",
".",
"ServiceName",
"+",
"\"/\"",
"+",
"chat",
".",
"ServiceHookToken",
"(",
")",
"\n",
"}"
] | // ServiceHookURL returns Chats's webhook URL for service to use in webhook handling
// Used in case when user need to put webhook URL to receive notifications to chat | [
"ServiceHookURL",
"returns",
"Chats",
"s",
"webhook",
"URL",
"for",
"service",
"to",
"use",
"in",
"webhook",
"handling",
"Used",
"in",
"case",
"when",
"user",
"need",
"to",
"put",
"webhook",
"URL",
"to",
"receive",
"notifications",
"to",
"chat"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L810-L812 | train |
requilence/integram | data.go | AddChatToHook | func (user *User) AddChatToHook(chatID int64) error {
data, _ := user.getData()
token := user.ServiceHookToken()
for i, hook := range data.Hooks {
if hook.Token == token {
for _, service := range hook.Services {
if service == user.ctx.ServiceName {
for _, existingChatID := range hook.Chats {
if existingChatID == chatID {
return nil
}
}
data.Hooks[i].Chats = append(data.Hooks[i].Chats, chatID)
err := user.ctx.db.C("users").Update(bson.M{"_id": user.ID, "hooks.services": service}, bson.M{"$addToSet": bson.M{"hooks.$.chats": chatID}})
return err
}
}
}
}
err := errors.New("Can't add chat to serviceHook. Can't find a hook.")
user.ctx.Log().Error(err)
return err
} | go | func (user *User) AddChatToHook(chatID int64) error {
data, _ := user.getData()
token := user.ServiceHookToken()
for i, hook := range data.Hooks {
if hook.Token == token {
for _, service := range hook.Services {
if service == user.ctx.ServiceName {
for _, existingChatID := range hook.Chats {
if existingChatID == chatID {
return nil
}
}
data.Hooks[i].Chats = append(data.Hooks[i].Chats, chatID)
err := user.ctx.db.C("users").Update(bson.M{"_id": user.ID, "hooks.services": service}, bson.M{"$addToSet": bson.M{"hooks.$.chats": chatID}})
return err
}
}
}
}
err := errors.New("Can't add chat to serviceHook. Can't find a hook.")
user.ctx.Log().Error(err)
return err
} | [
"func",
"(",
"user",
"*",
"User",
")",
"AddChatToHook",
"(",
"chatID",
"int64",
")",
"error",
"{",
"data",
",",
"_",
":=",
"user",
".",
"getData",
"(",
")",
"\n",
"token",
":=",
"user",
".",
"ServiceHookToken",
"(",
")",
"\n",
"for",
"i",
",",
"hoo... | // AddChatToHook adds the target chat to user's existing hook | [
"AddChatToHook",
"adds",
"the",
"target",
"chat",
"to",
"user",
"s",
"existing",
"hook"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L815-L839 | train |
requilence/integram | data.go | SaveSetting | func (chat *Chat) SaveSetting(key string, value interface{}) error {
key = strings.ToLower(key)
serviceID := chat.ctx.getServiceID()
var cd chatData
_, err := chat.ctx.db.C("chats").FindId(chat.ID).Select(bson.M{"settings." + serviceID: 1}).
Apply(
mgo.Change{
Update: bson.M{
"$set": bson.M{"settings." + serviceID + "." + key: value},
"$setOnInsert": bson.M{"createdat": time.Now()},
},
Upsert: true,
ReturnNew: true,
},
&cd)
if err == nil && chat.data != nil && chat.data.Settings != nil && cd.Settings != nil && cd.Settings[serviceID] != nil {
chat.data.Settings[serviceID] = cd.Settings[serviceID]
}
return err
} | go | func (chat *Chat) SaveSetting(key string, value interface{}) error {
key = strings.ToLower(key)
serviceID := chat.ctx.getServiceID()
var cd chatData
_, err := chat.ctx.db.C("chats").FindId(chat.ID).Select(bson.M{"settings." + serviceID: 1}).
Apply(
mgo.Change{
Update: bson.M{
"$set": bson.M{"settings." + serviceID + "." + key: value},
"$setOnInsert": bson.M{"createdat": time.Now()},
},
Upsert: true,
ReturnNew: true,
},
&cd)
if err == nil && chat.data != nil && chat.data.Settings != nil && cd.Settings != nil && cd.Settings[serviceID] != nil {
chat.data.Settings[serviceID] = cd.Settings[serviceID]
}
return err
} | [
"func",
"(",
"chat",
"*",
"Chat",
")",
"SaveSetting",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"key",
"=",
"strings",
".",
"ToLower",
"(",
"key",
")",
"\n",
"serviceID",
":=",
"chat",
".",
"ctx",
".",
"getServiceI... | // SaveSetting sets Chat's setting for service with specific key | [
"SaveSetting",
"sets",
"Chat",
"s",
"setting",
"for",
"service",
"with",
"specific",
"key"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L895-L917 | train |
requilence/integram | data.go | SaveSetting | func (user *User) SaveSetting(key string, value interface{}) error {
if user.ID == 0 {
return errors.New("SaveSetting: user is empty")
}
key = strings.ToLower(key)
serviceID := user.ctx.getServiceID()
var ud userData
_, err := user.ctx.db.C("users").FindId(user.ID).Select(bson.M{"settings." + serviceID: 1}).
Apply(
mgo.Change{
Update: bson.M{
"$set": bson.M{"settings." + serviceID + "." + key: value},
"$setOnInsert": bson.M{"createdat": time.Now()},
},
Upsert: true,
ReturnNew: true,
},
&ud)
if err == nil && user.data != nil && user.data.Settings != nil && ud.Settings != nil && ud.Settings[serviceID] != nil {
user.data.Settings[serviceID] = ud.Settings[serviceID]
}
return err
} | go | func (user *User) SaveSetting(key string, value interface{}) error {
if user.ID == 0 {
return errors.New("SaveSetting: user is empty")
}
key = strings.ToLower(key)
serviceID := user.ctx.getServiceID()
var ud userData
_, err := user.ctx.db.C("users").FindId(user.ID).Select(bson.M{"settings." + serviceID: 1}).
Apply(
mgo.Change{
Update: bson.M{
"$set": bson.M{"settings." + serviceID + "." + key: value},
"$setOnInsert": bson.M{"createdat": time.Now()},
},
Upsert: true,
ReturnNew: true,
},
&ud)
if err == nil && user.data != nil && user.data.Settings != nil && ud.Settings != nil && ud.Settings[serviceID] != nil {
user.data.Settings[serviceID] = ud.Settings[serviceID]
}
return err
} | [
"func",
"(",
"user",
"*",
"User",
")",
"SaveSetting",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"user",
".",
"ID",
"==",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"SaveSetting: user is empty\"",
")",
"\n... | // SaveSetting sets User's setting for service with specific key | [
"SaveSetting",
"sets",
"User",
"s",
"setting",
"for",
"service",
"with",
"specific",
"key"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L920-L947 | train |
requilence/integram | data.go | AuthTempToken | func (user *User) AuthTempToken() string {
host := user.ctx.ServiceBaseURL.Host
if host == "" {
host = user.ctx.Service().DefaultBaseURL.Host
}
serviceBaseURL := user.ctx.ServiceBaseURL.String()
if serviceBaseURL == "" {
serviceBaseURL = user.ctx.Service().DefaultBaseURL.String()
}
ps, _ := user.protectedSettings()
if ps.AuthTempToken != "" {
fmt.Println("found AuthTempToken:" + ps.AuthTempToken)
oAuthIDCacheFound := oAuthIDCacheVal{}
if exists := user.Cache("auth_"+ps.AuthTempToken, &oAuthIDCacheFound); !exists {
oAuthIDCacheFound = oAuthIDCacheVal{BaseURL: serviceBaseURL}
user.SetCache("auth_"+ps.AuthTempToken, oAuthIDCacheFound, time.Hour*24)
}
u, _ := url.Parse(oAuthIDCacheFound.BaseURL)
if u != nil && u.Host == host {
return ps.AuthTempToken
}
}
rnd := strings.ToLower(rndStr.Get(16))
user.SetCache("auth_"+rnd, oAuthIDCacheVal{BaseURL: serviceBaseURL}, time.Hour*24)
err := user.saveProtectedSetting("AuthTempToken", rnd)
if err != nil {
user.ctx.Log().WithError(err).Error("Error saving AuthTempToken")
}
return rnd
} | go | func (user *User) AuthTempToken() string {
host := user.ctx.ServiceBaseURL.Host
if host == "" {
host = user.ctx.Service().DefaultBaseURL.Host
}
serviceBaseURL := user.ctx.ServiceBaseURL.String()
if serviceBaseURL == "" {
serviceBaseURL = user.ctx.Service().DefaultBaseURL.String()
}
ps, _ := user.protectedSettings()
if ps.AuthTempToken != "" {
fmt.Println("found AuthTempToken:" + ps.AuthTempToken)
oAuthIDCacheFound := oAuthIDCacheVal{}
if exists := user.Cache("auth_"+ps.AuthTempToken, &oAuthIDCacheFound); !exists {
oAuthIDCacheFound = oAuthIDCacheVal{BaseURL: serviceBaseURL}
user.SetCache("auth_"+ps.AuthTempToken, oAuthIDCacheFound, time.Hour*24)
}
u, _ := url.Parse(oAuthIDCacheFound.BaseURL)
if u != nil && u.Host == host {
return ps.AuthTempToken
}
}
rnd := strings.ToLower(rndStr.Get(16))
user.SetCache("auth_"+rnd, oAuthIDCacheVal{BaseURL: serviceBaseURL}, time.Hour*24)
err := user.saveProtectedSetting("AuthTempToken", rnd)
if err != nil {
user.ctx.Log().WithError(err).Error("Error saving AuthTempToken")
}
return rnd
} | [
"func",
"(",
"user",
"*",
"User",
")",
"AuthTempToken",
"(",
")",
"string",
"{",
"host",
":=",
"user",
".",
"ctx",
".",
"ServiceBaseURL",
".",
"Host",
"\n",
"if",
"host",
"==",
"\"\"",
"{",
"host",
"=",
"user",
".",
"ctx",
".",
"Service",
"(",
")",... | // AuthTempToken returns Auth token used in OAuth process to associate TG user with OAuth creditianals | [
"AuthTempToken",
"returns",
"Auth",
"token",
"used",
"in",
"OAuth",
"process",
"to",
"associate",
"TG",
"user",
"with",
"OAuth",
"creditianals"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L950-L988 | train |
requilence/integram | data.go | OauthRedirectURL | func (user *User) OauthRedirectURL() string {
providerID := user.ctx.OAuthProvider().internalID()
if providerID == user.ctx.ServiceName {
return fmt.Sprintf("%s/auth/%s", Config.BaseURL, user.ctx.ServiceName)
}
return fmt.Sprintf("%s/auth/%s/%s", Config.BaseURL, user.ctx.ServiceName, providerID)
} | go | func (user *User) OauthRedirectURL() string {
providerID := user.ctx.OAuthProvider().internalID()
if providerID == user.ctx.ServiceName {
return fmt.Sprintf("%s/auth/%s", Config.BaseURL, user.ctx.ServiceName)
}
return fmt.Sprintf("%s/auth/%s/%s", Config.BaseURL, user.ctx.ServiceName, providerID)
} | [
"func",
"(",
"user",
"*",
"User",
")",
"OauthRedirectURL",
"(",
")",
"string",
"{",
"providerID",
":=",
"user",
".",
"ctx",
".",
"OAuthProvider",
"(",
")",
".",
"internalID",
"(",
")",
"\n",
"if",
"providerID",
"==",
"user",
".",
"ctx",
".",
"ServiceNa... | // OauthRedirectURL used in OAuth process as returning URL | [
"OauthRedirectURL",
"used",
"in",
"OAuth",
"process",
"as",
"returning",
"URL"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L991-L998 | train |
requilence/integram | data.go | OauthInitURL | func (user *User) OauthInitURL() string {
authTempToken := user.AuthTempToken()
s := user.ctx.Service()
if authTempToken == "" {
user.ctx.Log().Error("authTempToken is empty")
return ""
}
if s.DefaultOAuth2 != nil {
provider := user.ctx.OAuthProvider()
return provider.OAuth2Client(user.ctx).AuthCodeURL(authTempToken, oauth2.AccessTypeOffline)
}
if s.DefaultOAuth1 != nil {
return fmt.Sprintf("%s/oauth1/%s/%s", Config.BaseURL, s.Name, authTempToken)
}
return ""
} | go | func (user *User) OauthInitURL() string {
authTempToken := user.AuthTempToken()
s := user.ctx.Service()
if authTempToken == "" {
user.ctx.Log().Error("authTempToken is empty")
return ""
}
if s.DefaultOAuth2 != nil {
provider := user.ctx.OAuthProvider()
return provider.OAuth2Client(user.ctx).AuthCodeURL(authTempToken, oauth2.AccessTypeOffline)
}
if s.DefaultOAuth1 != nil {
return fmt.Sprintf("%s/oauth1/%s/%s", Config.BaseURL, s.Name, authTempToken)
}
return ""
} | [
"func",
"(",
"user",
"*",
"User",
")",
"OauthInitURL",
"(",
")",
"string",
"{",
"authTempToken",
":=",
"user",
".",
"AuthTempToken",
"(",
")",
"\n",
"s",
":=",
"user",
".",
"ctx",
".",
"Service",
"(",
")",
"\n",
"if",
"authTempToken",
"==",
"\"\"",
"... | // OauthInitURL used in OAuth process as returning URL | [
"OauthInitURL",
"used",
"in",
"OAuth",
"process",
"as",
"returning",
"URL"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L1001-L1017 | train |
requilence/integram | data.go | OAuthHTTPClient | func (user *User) OAuthHTTPClient() *http.Client {
ps, _ := user.protectedSettings()
if ps == nil {
return nil
}
if ps.OAuthToken == "" {
return nil
}
if user.ctx.Service().DefaultOAuth2 != nil {
ts := user.ctx.OAuthProvider().OAuth2Client(user.ctx).TokenSource(oauth2.NoContext, &oauth2.Token{AccessToken: ps.OAuthToken, RefreshToken: ps.OAuthRefreshToken, Expiry: *ps.OAuthExpireDate, TokenType: "Bearer"})
if ps.OAuthExpireDate != nil && ps.OAuthExpireDate.Before(time.Now().Add(time.Second*5)) {
token, err := ts.Token()
if err != nil {
if strings.Contains(err.Error(), "revoked") || strings.Contains(err.Error(), "invalid_grant") {
ps.OAuthToken = ""
ps.OAuthExpireDate = nil
user.saveProtectedSettings()
//todo: provide revoked callback
}
user.ctx.Log().WithError(err).Error("OAuth token refresh failed")
return nil
}
if token != nil {
ps.OAuthToken = token.AccessToken
if token.RefreshToken != "" {
ps.OAuthRefreshToken = token.RefreshToken
}
ps.OAuthExpireDate = &token.Expiry
user.saveProtectedSettings()
}
}
return oauth2.NewClient(oauth2.NoContext, ts)
} else if user.ctx.Service().DefaultOAuth1 != nil {
//todo make a correct httpclient
return http.DefaultClient
}
return nil
} | go | func (user *User) OAuthHTTPClient() *http.Client {
ps, _ := user.protectedSettings()
if ps == nil {
return nil
}
if ps.OAuthToken == "" {
return nil
}
if user.ctx.Service().DefaultOAuth2 != nil {
ts := user.ctx.OAuthProvider().OAuth2Client(user.ctx).TokenSource(oauth2.NoContext, &oauth2.Token{AccessToken: ps.OAuthToken, RefreshToken: ps.OAuthRefreshToken, Expiry: *ps.OAuthExpireDate, TokenType: "Bearer"})
if ps.OAuthExpireDate != nil && ps.OAuthExpireDate.Before(time.Now().Add(time.Second*5)) {
token, err := ts.Token()
if err != nil {
if strings.Contains(err.Error(), "revoked") || strings.Contains(err.Error(), "invalid_grant") {
ps.OAuthToken = ""
ps.OAuthExpireDate = nil
user.saveProtectedSettings()
//todo: provide revoked callback
}
user.ctx.Log().WithError(err).Error("OAuth token refresh failed")
return nil
}
if token != nil {
ps.OAuthToken = token.AccessToken
if token.RefreshToken != "" {
ps.OAuthRefreshToken = token.RefreshToken
}
ps.OAuthExpireDate = &token.Expiry
user.saveProtectedSettings()
}
}
return oauth2.NewClient(oauth2.NoContext, ts)
} else if user.ctx.Service().DefaultOAuth1 != nil {
//todo make a correct httpclient
return http.DefaultClient
}
return nil
} | [
"func",
"(",
"user",
"*",
"User",
")",
"OAuthHTTPClient",
"(",
")",
"*",
"http",
".",
"Client",
"{",
"ps",
",",
"_",
":=",
"user",
".",
"protectedSettings",
"(",
")",
"\n",
"if",
"ps",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"ps... | // OAuthHTTPClient returns HTTP client with Bearer authorization headers | [
"OAuthHTTPClient",
"returns",
"HTTP",
"client",
"with",
"Bearer",
"authorization",
"headers"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L1024-L1066 | train |
requilence/integram | data.go | OAuthToken | func (user *User) OAuthToken() string {
// todo: oauthtoken per host?
/*
host := user.ctx.ServiceBaseURL.Host
if host == "" {
host = user.ctx.Service().DefaultBaseURL.Host
}
*/
ps, _ := user.protectedSettings()
if ps != nil {
if ps.OAuthExpireDate != nil && ps.OAuthExpireDate.Before(time.Now().Add(time.Second*5)) {
token, err := user.ctx.OAuthProvider().OAuth2Client(user.ctx).TokenSource(oauth2.NoContext, &oauth2.Token{AccessToken: ps.OAuthToken, Expiry: *ps.OAuthExpireDate, RefreshToken: ps.OAuthRefreshToken}).Token()
if err != nil {
if strings.Contains(err.Error(), "revoked") || strings.Contains(err.Error(), "invalid_grant") {
//remove stored OAuthToken
//todo: provide revoked callback
ps.OAuthToken = ""
ps.OAuthExpireDate = nil
user.saveProtectedSettings()
}
user.ctx.Log().WithError(err).Error("OAuth token refresh failed")
return ""
}
if token != nil {
ps.OAuthToken = token.AccessToken
if token.RefreshToken != "" {
ps.OAuthRefreshToken = token.RefreshToken
}
ps.OAuthExpireDate = &token.Expiry
user.saveProtectedSettings()
}
}
return ps.OAuthToken
}
return ""
} | go | func (user *User) OAuthToken() string {
// todo: oauthtoken per host?
/*
host := user.ctx.ServiceBaseURL.Host
if host == "" {
host = user.ctx.Service().DefaultBaseURL.Host
}
*/
ps, _ := user.protectedSettings()
if ps != nil {
if ps.OAuthExpireDate != nil && ps.OAuthExpireDate.Before(time.Now().Add(time.Second*5)) {
token, err := user.ctx.OAuthProvider().OAuth2Client(user.ctx).TokenSource(oauth2.NoContext, &oauth2.Token{AccessToken: ps.OAuthToken, Expiry: *ps.OAuthExpireDate, RefreshToken: ps.OAuthRefreshToken}).Token()
if err != nil {
if strings.Contains(err.Error(), "revoked") || strings.Contains(err.Error(), "invalid_grant") {
//remove stored OAuthToken
//todo: provide revoked callback
ps.OAuthToken = ""
ps.OAuthExpireDate = nil
user.saveProtectedSettings()
}
user.ctx.Log().WithError(err).Error("OAuth token refresh failed")
return ""
}
if token != nil {
ps.OAuthToken = token.AccessToken
if token.RefreshToken != "" {
ps.OAuthRefreshToken = token.RefreshToken
}
ps.OAuthExpireDate = &token.Expiry
user.saveProtectedSettings()
}
}
return ps.OAuthToken
}
return ""
} | [
"func",
"(",
"user",
"*",
"User",
")",
"OAuthToken",
"(",
")",
"string",
"{",
"ps",
",",
"_",
":=",
"user",
".",
"protectedSettings",
"(",
")",
"\n",
"if",
"ps",
"!=",
"nil",
"{",
"if",
"ps",
".",
"OAuthExpireDate",
"!=",
"nil",
"&&",
"ps",
".",
... | // OAuthToken returns OAuthToken for service | [
"OAuthToken",
"returns",
"OAuthToken",
"for",
"service"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L1083-L1125 | train |
requilence/integram | data.go | ResetOAuthToken | func (user *User) ResetOAuthToken() error {
err := user.saveProtectedSetting("OAuthToken", "")
if err != nil {
user.ctx.Log().WithError(err).Error("ResetOAuthToken error")
}
return err
} | go | func (user *User) ResetOAuthToken() error {
err := user.saveProtectedSetting("OAuthToken", "")
if err != nil {
user.ctx.Log().WithError(err).Error("ResetOAuthToken error")
}
return err
} | [
"func",
"(",
"user",
"*",
"User",
")",
"ResetOAuthToken",
"(",
")",
"error",
"{",
"err",
":=",
"user",
".",
"saveProtectedSetting",
"(",
"\"OAuthToken\"",
",",
"\"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"user",
".",
"ctx",
".",
"Log",
"(",
")"... | // ResetOAuthToken reset OAuthToken for service | [
"ResetOAuthToken",
"reset",
"OAuthToken",
"for",
"service"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L1128-L1134 | train |
requilence/integram | data.go | WebPreview | func (c *Context) WebPreview(title string, headline string, text string, serviceURL string, imageURL string) (WebPreviewURL string) {
token := rndStr.Get(10)
if title == "" {
title = c.Service().NameToPrint
c.Log().WithField("token", token).Warn("webPreview: title is empty")
}
if headline == "" {
c.Log().WithField("token", token).Warn("webPreview: headline is empty")
headline = "-"
}
wp := webPreview{
title,
headline,
text,
serviceURL,
imageURL,
token,
"",
0,
time.Now(),
}
wp.Hash = wp.CalculateHash()
var wpExists webPreview
c.db.C("previews").Find(bson.M{"hash": wp.Hash}).One(&wpExists)
if wpExists.Token != "" {
wp = wpExists
} else {
err := c.db.C("previews").Insert(wp)
if err != nil {
// Wow! So jackpot! Much collision
wp.Token = rndStr.Get(10)
err = c.db.C("previews").Insert(wp)
c.Log().WithError(err).Error("Can't add webpreview")
}
}
return Config.BaseURL + "/a/" + wp.Token
} | go | func (c *Context) WebPreview(title string, headline string, text string, serviceURL string, imageURL string) (WebPreviewURL string) {
token := rndStr.Get(10)
if title == "" {
title = c.Service().NameToPrint
c.Log().WithField("token", token).Warn("webPreview: title is empty")
}
if headline == "" {
c.Log().WithField("token", token).Warn("webPreview: headline is empty")
headline = "-"
}
wp := webPreview{
title,
headline,
text,
serviceURL,
imageURL,
token,
"",
0,
time.Now(),
}
wp.Hash = wp.CalculateHash()
var wpExists webPreview
c.db.C("previews").Find(bson.M{"hash": wp.Hash}).One(&wpExists)
if wpExists.Token != "" {
wp = wpExists
} else {
err := c.db.C("previews").Insert(wp)
if err != nil {
// Wow! So jackpot! Much collision
wp.Token = rndStr.Get(10)
err = c.db.C("previews").Insert(wp)
c.Log().WithError(err).Error("Can't add webpreview")
}
}
return Config.BaseURL + "/a/" + wp.Token
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"WebPreview",
"(",
"title",
"string",
",",
"headline",
"string",
",",
"text",
"string",
",",
"serviceURL",
"string",
",",
"imageURL",
"string",
")",
"(",
"WebPreviewURL",
"string",
")",
"{",
"token",
":=",
"rndStr",
... | // WebPreview generate fake webpreview and store it in DB. Telegram will resolve it as we need | [
"WebPreview",
"generate",
"fake",
"webpreview",
"and",
"store",
"it",
"in",
"DB",
".",
"Telegram",
"will",
"resolve",
"it",
"as",
"we",
"need"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/data.go#L1188-L1233 | train |
requilence/integram | context.go | SetServiceBaseURL | func (c *Context) SetServiceBaseURL(domainOrURL string) {
u, _ := getBaseURL(domainOrURL)
if u != nil && u.Host != "" {
c.ServiceBaseURL = *u
} else if domainOrURL != "" {
c.ServiceBaseURL = url.URL{Scheme: "https", Host: domainOrURL}
} else {
c.Log().Error("Can't use SetServiceHostFromURL with empty arg")
}
} | go | func (c *Context) SetServiceBaseURL(domainOrURL string) {
u, _ := getBaseURL(domainOrURL)
if u != nil && u.Host != "" {
c.ServiceBaseURL = *u
} else if domainOrURL != "" {
c.ServiceBaseURL = url.URL{Scheme: "https", Host: domainOrURL}
} else {
c.Log().Error("Can't use SetServiceHostFromURL with empty arg")
}
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"SetServiceBaseURL",
"(",
"domainOrURL",
"string",
")",
"{",
"u",
",",
"_",
":=",
"getBaseURL",
"(",
"domainOrURL",
")",
"\n",
"if",
"u",
"!=",
"nil",
"&&",
"u",
".",
"Host",
"!=",
"\"\"",
"{",
"c",
".",
"Serv... | // SetServiceBaseURL set the baseURL for the current request. Useful when service can be self-hosted. The actual service URL can be found in the incoming webhook | [
"SetServiceBaseURL",
"set",
"the",
"baseURL",
"for",
"the",
"current",
"request",
".",
"Useful",
"when",
"service",
"can",
"be",
"self",
"-",
"hosted",
".",
"The",
"actual",
"service",
"URL",
"can",
"be",
"found",
"in",
"the",
"incoming",
"webhook"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L68-L78 | train |
requilence/integram | context.go | SaveOAuthProvider | func (c *Context) SaveOAuthProvider(baseURL url.URL, id string, secret string) (*OAuthProvider, error) {
if id == "" || secret == "" {
return nil, errors.New("id and secret must not be empty")
}
baseURL.Host = strings.ToLower(baseURL.Host)
provider := OAuthProvider{BaseURL: baseURL, ID: id, Secret: secret, Service: c.ServiceName}
//TODO: multiply installations on one host are not available
c.db.C("oauth_providers").UpsertId(provider.internalID(), provider.toBson())
return &provider, nil
} | go | func (c *Context) SaveOAuthProvider(baseURL url.URL, id string, secret string) (*OAuthProvider, error) {
if id == "" || secret == "" {
return nil, errors.New("id and secret must not be empty")
}
baseURL.Host = strings.ToLower(baseURL.Host)
provider := OAuthProvider{BaseURL: baseURL, ID: id, Secret: secret, Service: c.ServiceName}
//TODO: multiply installations on one host are not available
c.db.C("oauth_providers").UpsertId(provider.internalID(), provider.toBson())
return &provider, nil
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"SaveOAuthProvider",
"(",
"baseURL",
"url",
".",
"URL",
",",
"id",
"string",
",",
"secret",
"string",
")",
"(",
"*",
"OAuthProvider",
",",
"error",
")",
"{",
"if",
"id",
"==",
"\"\"",
"||",
"secret",
"==",
"\"\"... | // SaveOAuthProvider add the OAuth client to DB. Useful when the new OAuth provider registred for self-hosted services | [
"SaveOAuthProvider",
"add",
"the",
"OAuth",
"client",
"to",
"DB",
".",
"Useful",
"when",
"the",
"new",
"OAuth",
"provider",
"registred",
"for",
"self",
"-",
"hosted",
"services"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L81-L93 | train |
requilence/integram | context.go | OAuthProvider | func (c *Context) OAuthProvider() *OAuthProvider {
service := c.Service()
if c.ServiceBaseURL.Host == "" || c.ServiceBaseURL.Host == service.DefaultBaseURL.Host {
return service.DefaultOAuthProvider()
} else if c.ServiceBaseURL.Host != "" {
p, _ := findOauthProviderByHost(c.db, c.ServiceBaseURL.Host)
if p == nil {
p = &OAuthProvider{BaseURL: c.ServiceBaseURL, Service: c.ServiceName}
}
/*if err != nil {
c.Log().WithError(err).WithField("host", c.ServiceBaseURL.Host).Error("Can't get OAuthProvider")
}*/
return p
}
c.Log().Error("Can't get OAuthProvider – empty ServiceBaseURL")
return nil
} | go | func (c *Context) OAuthProvider() *OAuthProvider {
service := c.Service()
if c.ServiceBaseURL.Host == "" || c.ServiceBaseURL.Host == service.DefaultBaseURL.Host {
return service.DefaultOAuthProvider()
} else if c.ServiceBaseURL.Host != "" {
p, _ := findOauthProviderByHost(c.db, c.ServiceBaseURL.Host)
if p == nil {
p = &OAuthProvider{BaseURL: c.ServiceBaseURL, Service: c.ServiceName}
}
/*if err != nil {
c.Log().WithError(err).WithField("host", c.ServiceBaseURL.Host).Error("Can't get OAuthProvider")
}*/
return p
}
c.Log().Error("Can't get OAuthProvider – empty ServiceBaseURL")
return nil
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"OAuthProvider",
"(",
")",
"*",
"OAuthProvider",
"{",
"service",
":=",
"c",
".",
"Service",
"(",
")",
"\n",
"if",
"c",
".",
"ServiceBaseURL",
".",
"Host",
"==",
"\"\"",
"||",
"c",
".",
"ServiceBaseURL",
".",
"Ho... | // OAuthProvider details. Useful for services that can be installed on your own side | [
"OAuthProvider",
"details",
".",
"Useful",
"for",
"services",
"that",
"can",
"be",
"installed",
"on",
"your",
"own",
"side"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L96-L116 | train |
requilence/integram | context.go | OAuth1Client | func (o *OAuthProvider) OAuth1Client(c *Context) *oauth.Consumer {
if o.ID == "" {
log.Error(errors.New("Can't get OAuth1Client – ID not set"))
return nil
}
service := c.Service()
config := service.DefaultOAuth1
if config.AccessTokenReceiver == nil {
log.Error(errors.New("Can't get OAuth1Client – AccessTokenReceiver not set"))
return nil
}
config.Key = o.ID
config.Secret = o.Secret
config.AccessTokenURL = replaceBaseURL(config.AccessTokenURL, o.BaseURL)
config.AuthorizeTokenURL = replaceBaseURL(config.AuthorizeTokenURL, o.BaseURL)
config.RequestTokenURL = replaceBaseURL(config.RequestTokenURL, o.BaseURL)
consumer := oauth.NewConsumer(
o.ID,
o.Secret,
oauth.ServiceProvider{
RequestTokenUrl: config.RequestTokenURL,
AuthorizeTokenUrl: config.AuthorizeTokenURL,
AccessTokenUrl: config.AccessTokenURL,
},
)
consumer.AdditionalAuthorizationUrlParams = service.DefaultOAuth1.AdditionalAuthorizationURLParams
return consumer
} | go | func (o *OAuthProvider) OAuth1Client(c *Context) *oauth.Consumer {
if o.ID == "" {
log.Error(errors.New("Can't get OAuth1Client – ID not set"))
return nil
}
service := c.Service()
config := service.DefaultOAuth1
if config.AccessTokenReceiver == nil {
log.Error(errors.New("Can't get OAuth1Client – AccessTokenReceiver not set"))
return nil
}
config.Key = o.ID
config.Secret = o.Secret
config.AccessTokenURL = replaceBaseURL(config.AccessTokenURL, o.BaseURL)
config.AuthorizeTokenURL = replaceBaseURL(config.AuthorizeTokenURL, o.BaseURL)
config.RequestTokenURL = replaceBaseURL(config.RequestTokenURL, o.BaseURL)
consumer := oauth.NewConsumer(
o.ID,
o.Secret,
oauth.ServiceProvider{
RequestTokenUrl: config.RequestTokenURL,
AuthorizeTokenUrl: config.AuthorizeTokenURL,
AccessTokenUrl: config.AccessTokenURL,
},
)
consumer.AdditionalAuthorizationUrlParams = service.DefaultOAuth1.AdditionalAuthorizationURLParams
return consumer
} | [
"func",
"(",
"o",
"*",
"OAuthProvider",
")",
"OAuth1Client",
"(",
"c",
"*",
"Context",
")",
"*",
"oauth",
".",
"Consumer",
"{",
"if",
"o",
".",
"ID",
"==",
"\"\"",
"{",
"log",
".",
"Error",
"(",
"errors",
".",
"New",
"(",
"\"Can't get OAuth1Client – ID... | // OAuth1Client returns oauth.Consumer using OAuthProvider details | [
"OAuth1Client",
"returns",
"oauth",
".",
"Consumer",
"using",
"OAuthProvider",
"details"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L134-L167 | train |
requilence/integram | context.go | OAuth2Client | func (o *OAuthProvider) OAuth2Client(c *Context) *oauth2.Config {
if o.ID == "" {
return nil
}
service := c.Service()
if service.DefaultOAuth2 == nil {
return nil
}
config := service.DefaultOAuth2.Config
config.ClientID = o.ID
config.ClientSecret = o.Secret
if c.User.ID != 0 {
config.RedirectURL = c.User.OauthRedirectURL()
}
config.Endpoint = oauth2.Endpoint{
AuthURL: replaceBaseURL(config.Endpoint.AuthURL, o.BaseURL),
TokenURL: replaceBaseURL(config.Endpoint.TokenURL, o.BaseURL),
}
return &config
} | go | func (o *OAuthProvider) OAuth2Client(c *Context) *oauth2.Config {
if o.ID == "" {
return nil
}
service := c.Service()
if service.DefaultOAuth2 == nil {
return nil
}
config := service.DefaultOAuth2.Config
config.ClientID = o.ID
config.ClientSecret = o.Secret
if c.User.ID != 0 {
config.RedirectURL = c.User.OauthRedirectURL()
}
config.Endpoint = oauth2.Endpoint{
AuthURL: replaceBaseURL(config.Endpoint.AuthURL, o.BaseURL),
TokenURL: replaceBaseURL(config.Endpoint.TokenURL, o.BaseURL),
}
return &config
} | [
"func",
"(",
"o",
"*",
"OAuthProvider",
")",
"OAuth2Client",
"(",
"c",
"*",
"Context",
")",
"*",
"oauth2",
".",
"Config",
"{",
"if",
"o",
".",
"ID",
"==",
"\"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"service",
":=",
"c",
".",
"Service",
"(",
"... | // OAuth2Client returns oauth2.Config using OAuthProvider details | [
"OAuth2Client",
"returns",
"oauth2",
".",
"Config",
"using",
"OAuthProvider",
"details"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L170-L196 | train |
requilence/integram | context.go | Param | func (wc *WebhookContext) Param(s string) string {
return wc.gin.Param(s)
} | go | func (wc *WebhookContext) Param(s string) string {
return wc.gin.Param(s)
} | [
"func",
"(",
"wc",
"*",
"WebhookContext",
")",
"Param",
"(",
"s",
"string",
")",
"string",
"{",
"return",
"wc",
".",
"gin",
".",
"Param",
"(",
"s",
")",
"\n",
"}"
] | // Param return param from url | [
"Param",
"return",
"param",
"from",
"url"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L213-L215 | train |
requilence/integram | context.go | Headers | func (wc *WebhookContext) Headers() map[string][]string {
return map[string][]string(wc.gin.Request.Header)
} | go | func (wc *WebhookContext) Headers() map[string][]string {
return map[string][]string(wc.gin.Request.Header)
} | [
"func",
"(",
"wc",
"*",
"WebhookContext",
")",
"Headers",
"(",
")",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"return",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"(",
"wc",
".",
"gin",
".",
"Request",
".",
"Header",
")",
"\n",
"}"
... | // Headers returns the headers of request | [
"Headers",
"returns",
"the",
"headers",
"of",
"request"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L239-L241 | train |
requilence/integram | context.go | Redirect | func (wc *WebhookContext) Redirect(code int, s string) {
wc.gin.Redirect(code, s)
} | go | func (wc *WebhookContext) Redirect(code int, s string) {
wc.gin.Redirect(code, s)
} | [
"func",
"(",
"wc",
"*",
"WebhookContext",
")",
"Redirect",
"(",
"code",
"int",
",",
"s",
"string",
")",
"{",
"wc",
".",
"gin",
".",
"Redirect",
"(",
"code",
",",
"s",
")",
"\n",
"}"
] | // Redirect send the Location header | [
"Redirect",
"send",
"the",
"Location",
"header"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L254-L256 | train |
requilence/integram | context.go | KeyboardAnswer | func (c *Context) KeyboardAnswer() (data string, buttonText string) {
keyboard, err := c.keyboard()
if err != nil || keyboard.ChatID == 0 {
log.WithError(err).Error("Can't get stored keyboard")
return
}
// In group chat keyboard answer always include msg_id of original message that generate this keyboard
if c.Chat.ID < 0 && c.Message.ReplyToMsgID != keyboard.MsgID {
return
}
if c.Message.Text == "" {
return
}
var ok bool
if data, ok = keyboard.Keyboard[checksumString(c.Message.Text)]; ok {
buttonText = c.Message.Text
log.Debugf("button pressed [%v], %v\n", data, c.Message.Text)
}
return
} | go | func (c *Context) KeyboardAnswer() (data string, buttonText string) {
keyboard, err := c.keyboard()
if err != nil || keyboard.ChatID == 0 {
log.WithError(err).Error("Can't get stored keyboard")
return
}
// In group chat keyboard answer always include msg_id of original message that generate this keyboard
if c.Chat.ID < 0 && c.Message.ReplyToMsgID != keyboard.MsgID {
return
}
if c.Message.Text == "" {
return
}
var ok bool
if data, ok = keyboard.Keyboard[checksumString(c.Message.Text)]; ok {
buttonText = c.Message.Text
log.Debugf("button pressed [%v], %v\n", data, c.Message.Text)
}
return
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"KeyboardAnswer",
"(",
")",
"(",
"data",
"string",
",",
"buttonText",
"string",
")",
"{",
"keyboard",
",",
"err",
":=",
"c",
".",
"keyboard",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"keyboard",
".",
"C... | // KeyboardAnswer retrieve the data related to pressed button
// buttonText will be returned only in case this button relates to the one in db for this chat | [
"KeyboardAnswer",
"retrieve",
"the",
"data",
"related",
"to",
"pressed",
"button",
"buttonText",
"will",
"be",
"returned",
"only",
"in",
"case",
"this",
"button",
"relates",
"to",
"the",
"one",
"in",
"db",
"for",
"this",
"chat"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L260-L286 | train |
requilence/integram | context.go | keyboard | func (c *Context) keyboard() (chatKeyboard, error) {
udata, _ := c.User.getData()
chatID := c.Chat.ID
for _, kb := range udata.KeyboardPerChat {
if kb.ChatID == chatID && kb.BotID == c.Bot().ID {
return kb, nil
}
}
cdata, _ := c.Chat.getData()
for _, kb := range cdata.KeyboardPerBot {
if kb.ChatID == chatID && kb.BotID == c.Bot().ID {
return kb, nil
}
}
return chatKeyboard{}, nil
} | go | func (c *Context) keyboard() (chatKeyboard, error) {
udata, _ := c.User.getData()
chatID := c.Chat.ID
for _, kb := range udata.KeyboardPerChat {
if kb.ChatID == chatID && kb.BotID == c.Bot().ID {
return kb, nil
}
}
cdata, _ := c.Chat.getData()
for _, kb := range cdata.KeyboardPerBot {
if kb.ChatID == chatID && kb.BotID == c.Bot().ID {
return kb, nil
}
}
return chatKeyboard{}, nil
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"keyboard",
"(",
")",
"(",
"chatKeyboard",
",",
"error",
")",
"{",
"udata",
",",
"_",
":=",
"c",
".",
"User",
".",
"getData",
"(",
")",
"\n",
"chatID",
":=",
"c",
".",
"Chat",
".",
"ID",
"\n",
"for",
"_",
... | // Keyboard retrieve keyboard for the current chat if set otherwise empty keyboard is returned | [
"Keyboard",
"retrieve",
"keyboard",
"for",
"the",
"current",
"chat",
"if",
"set",
"otherwise",
"empty",
"keyboard",
"is",
"returned"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L351-L372 | train |
requilence/integram | context.go | Log | func (c *Context) Log() *log.Entry {
fields := log.Fields{"service": c.ServiceName}
if Config.Debug {
pc := make([]uintptr, 10)
runtime.Callers(2, pc)
f := runtime.FuncForPC(pc[0])
fields["file"], fields["line"] = f.FileLine(pc[0])
fields["func"] = f.Name()
}
if c.User.ID > 0 {
fields["user"] = c.User.ID
}
if c.Chat.ID != 0 {
fields["chat"] = c.Chat.ID
}
if c.Message != nil {
fields["msg"] = c.Message.GetTextHash()
}
if c.ChosenInlineResult != nil {
fields["chosenresult"] = c.ChosenInlineResult
}
if c.InlineQuery != nil {
fields["inlinequery"] = c.InlineQuery
}
if c.Callback != nil {
fields["callback"] = c.Callback.Data
fields["callback_id"] = c.Callback.ID
if c.Callback.Message.MsgID > 0 {
fields["callback_msgid"] = c.Callback.Message.MsgID
} else {
fields["callback_inlinemsgid"] = c.Callback.Message.InlineMsgID
}
}
if c.gin != nil {
fields["url"] = c.gin.Request.Method + " " + c.gin.Request.URL.String()
fields["ip"] = c.gin.Request.RemoteAddr
}
fields["domain"] = c.ServiceBaseURL.Host
return log.WithFields(fields)
} | go | func (c *Context) Log() *log.Entry {
fields := log.Fields{"service": c.ServiceName}
if Config.Debug {
pc := make([]uintptr, 10)
runtime.Callers(2, pc)
f := runtime.FuncForPC(pc[0])
fields["file"], fields["line"] = f.FileLine(pc[0])
fields["func"] = f.Name()
}
if c.User.ID > 0 {
fields["user"] = c.User.ID
}
if c.Chat.ID != 0 {
fields["chat"] = c.Chat.ID
}
if c.Message != nil {
fields["msg"] = c.Message.GetTextHash()
}
if c.ChosenInlineResult != nil {
fields["chosenresult"] = c.ChosenInlineResult
}
if c.InlineQuery != nil {
fields["inlinequery"] = c.InlineQuery
}
if c.Callback != nil {
fields["callback"] = c.Callback.Data
fields["callback_id"] = c.Callback.ID
if c.Callback.Message.MsgID > 0 {
fields["callback_msgid"] = c.Callback.Message.MsgID
} else {
fields["callback_inlinemsgid"] = c.Callback.Message.InlineMsgID
}
}
if c.gin != nil {
fields["url"] = c.gin.Request.Method + " " + c.gin.Request.URL.String()
fields["ip"] = c.gin.Request.RemoteAddr
}
fields["domain"] = c.ServiceBaseURL.Host
return log.WithFields(fields)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Log",
"(",
")",
"*",
"log",
".",
"Entry",
"{",
"fields",
":=",
"log",
".",
"Fields",
"{",
"\"service\"",
":",
"c",
".",
"ServiceName",
"}",
"\n",
"if",
"Config",
".",
"Debug",
"{",
"pc",
":=",
"make",
"(",
... | // Log creates the logrus entry and attach corresponding info from the context | [
"Log",
"creates",
"the",
"logrus",
"entry",
"and",
"attach",
"corresponding",
"info",
"from",
"the",
"context"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L375-L424 | train |
requilence/integram | context.go | Service | func (c *Context) Service() *Service {
s, _ := serviceByName(c.ServiceName)
return s
} | go | func (c *Context) Service() *Service {
s, _ := serviceByName(c.ServiceName)
return s
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Service",
"(",
")",
"*",
"Service",
"{",
"s",
",",
"_",
":=",
"serviceByName",
"(",
"c",
".",
"ServiceName",
")",
"\n",
"return",
"s",
"\n",
"}"
] | // Service related to the current context | [
"Service",
"related",
"to",
"the",
"current",
"context"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L432-L435 | train |
requilence/integram | context.go | EditPressedMessageText | func (c *Context) EditPressedMessageText(text string) error {
if c.Callback == nil {
return errors.New("EditPressedMessageText: Callback is not presented")
}
return c.EditMessageText(c.Callback.Message, text)
} | go | func (c *Context) EditPressedMessageText(text string) error {
if c.Callback == nil {
return errors.New("EditPressedMessageText: Callback is not presented")
}
return c.EditMessageText(c.Callback.Message, text)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"EditPressedMessageText",
"(",
"text",
"string",
")",
"error",
"{",
"if",
"c",
".",
"Callback",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"EditPressedMessageText: Callback is not presented\"",
")",
"\n",
"}... | // EditPressedMessageText edit the text in the msg where user taped it in case this request is triggered by inlineButton callback | [
"EditPressedMessageText",
"edit",
"the",
"text",
"in",
"the",
"msg",
"where",
"user",
"taped",
"it",
"in",
"case",
"this",
"request",
"is",
"triggered",
"by",
"inlineButton",
"callback"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L443-L449 | train |
requilence/integram | context.go | EditPressedMessageTextAndInlineKeyboard | func (c *Context) EditPressedMessageTextAndInlineKeyboard(text string, kb InlineKeyboard) error {
if c.Callback == nil {
return errors.New("EditPressedMessageTextAndInlineKeyboard: Callback is not presented")
}
return c.EditMessageTextAndInlineKeyboard(c.Callback.Message, c.Callback.Message.InlineKeyboardMarkup.State, text, kb)
} | go | func (c *Context) EditPressedMessageTextAndInlineKeyboard(text string, kb InlineKeyboard) error {
if c.Callback == nil {
return errors.New("EditPressedMessageTextAndInlineKeyboard: Callback is not presented")
}
return c.EditMessageTextAndInlineKeyboard(c.Callback.Message, c.Callback.Message.InlineKeyboardMarkup.State, text, kb)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"EditPressedMessageTextAndInlineKeyboard",
"(",
"text",
"string",
",",
"kb",
"InlineKeyboard",
")",
"error",
"{",
"if",
"c",
".",
"Callback",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"EditPressedMessageTex... | // EditPressedMessageTextAndInlineKeyboard edit the text and inline keyboard in the msg where user taped it in case this request is triggered by inlineButton callback | [
"EditPressedMessageTextAndInlineKeyboard",
"edit",
"the",
"text",
"and",
"inline",
"keyboard",
"in",
"the",
"msg",
"where",
"user",
"taped",
"it",
"in",
"case",
"this",
"request",
"is",
"triggered",
"by",
"inlineButton",
"callback"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L452-L458 | train |
requilence/integram | context.go | EditPressedInlineKeyboard | func (c *Context) EditPressedInlineKeyboard(kb InlineKeyboard) error {
if c.Callback == nil {
return errors.New("EditPressedInlineKeyboard: Callback is not presented")
}
return c.EditInlineKeyboard(c.Callback.Message, c.Callback.Message.InlineKeyboardMarkup.State, kb)
} | go | func (c *Context) EditPressedInlineKeyboard(kb InlineKeyboard) error {
if c.Callback == nil {
return errors.New("EditPressedInlineKeyboard: Callback is not presented")
}
return c.EditInlineKeyboard(c.Callback.Message, c.Callback.Message.InlineKeyboardMarkup.State, kb)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"EditPressedInlineKeyboard",
"(",
"kb",
"InlineKeyboard",
")",
"error",
"{",
"if",
"c",
".",
"Callback",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"EditPressedInlineKeyboard: Callback is not presented\"",
")",
... | // EditPressedInlineKeyboard edit the inline keyboard in the msg where user taped it in case this request is triggered by inlineButton callback | [
"EditPressedInlineKeyboard",
"edit",
"the",
"inline",
"keyboard",
"in",
"the",
"msg",
"where",
"user",
"taped",
"it",
"in",
"case",
"this",
"request",
"is",
"triggered",
"by",
"inlineButton",
"callback"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L461-L467 | train |
requilence/integram | context.go | EditPressedInlineButton | func (c *Context) EditPressedInlineButton(newState int, newText string) error {
log.WithField("newText", newText).WithField("newState", newState).Info("EditPressedInlineButton")
if c.Callback == nil {
return errors.New("EditPressedInlineButton: Callback is not presented")
}
return c.EditInlineStateButton(c.Callback.Message, c.Callback.Message.InlineKeyboardMarkup.State, c.Callback.State, c.Callback.Data, newState, newText)
} | go | func (c *Context) EditPressedInlineButton(newState int, newText string) error {
log.WithField("newText", newText).WithField("newState", newState).Info("EditPressedInlineButton")
if c.Callback == nil {
return errors.New("EditPressedInlineButton: Callback is not presented")
}
return c.EditInlineStateButton(c.Callback.Message, c.Callback.Message.InlineKeyboardMarkup.State, c.Callback.State, c.Callback.Data, newState, newText)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"EditPressedInlineButton",
"(",
"newState",
"int",
",",
"newText",
"string",
")",
"error",
"{",
"log",
".",
"WithField",
"(",
"\"newText\"",
",",
"newText",
")",
".",
"WithField",
"(",
"\"newState\"",
",",
"newState",
... | // EditPressedInlineButton edit the text and state of pressed inline button in case this request is triggered by inlineButton callback | [
"EditPressedInlineButton",
"edit",
"the",
"text",
"and",
"state",
"of",
"pressed",
"inline",
"button",
"in",
"case",
"this",
"request",
"is",
"triggered",
"by",
"inlineButton",
"callback"
] | 7d85c728a299bf2ad121ae1874c0bd39fc48c231 | https://github.com/requilence/integram/blob/7d85c728a299bf2ad121ae1874c0bd39fc48c231/context.go#L470-L477 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.