_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q26700 | lookupOrCreateChannel | train | func (s *StanServer) lookupOrCreateChannel(name string) (*channel, error) {
cs := s.channels
cs.RLock()
c := cs.channels[name]
if c != nil {
if c.activity != nil && c.activity.deleteInProgress {
cs.RUnlock()
return nil, ErrChanDelInProgress
}
cs.RUnlock()
return c, nil
}
cs.RUnlock()
return cs.crea... | go | {
"resource": ""
} |
q26701 | createSubStore | train | func (s *StanServer) createSubStore() *subStore {
subs := &subStore{
psubs: make([]*subState, 0, 4),
qsubs: make(map[string]*queueState),
durables: make(map[string]*subState),
acks: make(map[string]*subState),
stan: s,
}
return subs
} | go | {
"resource": ""
} |
q26702 | Store | train | func (ss *subStore) Store(sub *subState) error {
if sub == nil {
return nil
}
// Adds to storage.
// Use sub lock to avoid race with waitForAcks in some tests
sub.Lock()
err := sub.store.CreateSub(&sub.SubState)
sub.Unlock()
if err == nil {
err = sub.store.Flush()
}
if err != nil {
ss.stan.log.Errorf("... | go | {
"resource": ""
} |
q26703 | hasActiveSubs | train | func (ss *subStore) hasActiveSubs() bool {
ss.RLock()
defer ss.RUnlock()
if len(ss.psubs) > 0 {
return true
}
for _, qsub := range ss.qsubs {
// For a durable queue group, when the group is offline,
// qsub.shadow is not nil, but the qsub.subs array should be
// empty.
if len(qsub.subs) > 0 {
return t... | go | {
"resource": ""
} |
q26704 | LookupByDurable | train | func (ss *subStore) LookupByDurable(durableName string) *subState {
ss.RLock()
sub := ss.durables[durableName]
ss.RUnlock()
return sub
} | go | {
"resource": ""
} |
q26705 | LookupByAckInbox | train | func (ss *subStore) LookupByAckInbox(ackInbox string) *subState {
ss.RLock()
sub := ss.acks[ackInbox]
ss.RUnlock()
return sub
} | go | {
"resource": ""
} |
q26706 | Clone | train | func (o *Options) Clone() *Options {
// A simple copy covers pretty much everything
clone := *o
// But we have the problem of the PerChannel map that needs
// to be copied.
clone.PerChannel = (&o.StoreLimits).ClonePerChannelMap()
// Make a copy of the clustering peers
if len(o.Clustering.Peers) > 0 {
clone.Clu... | go | {
"resource": ""
} |
q26707 | GetDefaultOptions | train | func GetDefaultOptions() (o *Options) {
opts := defaultOptions
opts.StoreLimits = stores.DefaultStoreLimits
return &opts
} | go | {
"resource": ""
} |
q26708 | RunServer | train | func RunServer(ID string) (*StanServer, error) {
sOpts := GetDefaultOptions()
sOpts.ID = ID
nOpts := DefaultNatsServerOptions
return RunServerWithOpts(sOpts, &nOpts)
} | go | {
"resource": ""
} |
q26709 | startRaftNode | train | func (s *StanServer) startRaftNode(hasStreamingState bool) error {
if err := s.createServerRaftNode(hasStreamingState); err != nil {
return err
}
node := s.raft
leaderWait := make(chan struct{}, 1)
leaderReady := func() {
select {
case leaderWait <- struct{}{}:
default:
}
}
if node.State() != raft.Lea... | go | {
"resource": ""
} |
q26710 | leadershipAcquired | train | func (s *StanServer) leadershipAcquired() error {
s.log.Noticef("server became leader, performing leader promotion actions")
defer s.log.Noticef("finished leader promotion actions")
// If we were not the leader, there should be nothing in the ioChannel
// (processing of client publishes). However, since a node cou... | go | {
"resource": ""
} |
q26711 | leadershipLost | train | func (s *StanServer) leadershipLost() {
s.log.Noticef("server lost leadership, performing leader stepdown actions")
defer s.log.Noticef("finished leader stepdown actions")
// Cancel outstanding client heartbeats. We aren't concerned about races
// where new clients might be connecting because at this point, the se... | go | {
"resource": ""
} |
q26712 | ensureRunningStandAlone | train | func (s *StanServer) ensureRunningStandAlone() error {
clusterID := s.info.ClusterID
hbInbox := nats.NewInbox()
timeout := time.Millisecond * 250
// We cannot use the client's API here as it will create a dependency
// cycle in the streaming client, so build our request and see if we
// get a response.
req := &... | go | {
"resource": ""
} |
q26713 | processRecoveredClients | train | func (s *StanServer) processRecoveredClients(clients []*stores.Client) {
if !s.isClustered {
s.clients.recoverClients(clients)
}
} | go | {
"resource": ""
} |
q26714 | processRecoveredChannels | train | func (s *StanServer) processRecoveredChannels(channels map[string]*stores.RecoveredChannel) ([]*subState, error) {
allSubs := make([]*subState, 0, 16)
for channelName, recoveredChannel := range channels {
channel, err := s.channels.create(s, channelName, recoveredChannel.Channel)
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q26715 | performRedeliveryOnStartup | train | func (s *StanServer) performRedeliveryOnStartup(recoveredSubs []*subState) {
queues := make(map[*queueState]*channel)
for _, sub := range recoveredSubs {
// Ignore subs that did not have any ack pendings on startup.
sub.Lock()
// Consider this subscription ready to receive messages
sub.initialized = true
/... | go | {
"resource": ""
} |
q26716 | initSubscriptions | train | func (s *StanServer) initSubscriptions() error {
// Do not create internal subscriptions in clustered mode,
// the leader will when it gets elected.
if !s.isClustered {
createSubOnClientPublish := true
if s.partitions != nil {
// Receive published messages from clients, but only on the list
// of static ... | go | {
"resource": ""
} |
q26717 | connectCB | train | func (s *StanServer) connectCB(m *nats.Msg) {
req := &pb.ConnectRequest{}
err := req.Unmarshal(m.Data)
if err != nil || req.HeartbeatInbox == "" {
s.log.Errorf("[Client:?] Invalid conn request: ClientID=%s, Inbox=%s, err=%v",
req.ClientID, req.HeartbeatInbox, err)
s.sendConnectErr(m.Reply, ErrInvalidConnReq.E... | go | {
"resource": ""
} |
q26718 | isDuplicateConnect | train | func (s *StanServer) isDuplicateConnect(client *client) bool {
client.RLock()
hbInbox := client.info.HbInbox
client.RUnlock()
// This is the HbInbox from the "old" client. See if it is up and
// running by sending a ping to that inbox.
_, err := s.nc.Request(hbInbox, nil, s.dupCIDTimeout)
// If err is nil, the... | go | {
"resource": ""
} |
q26719 | replicateDeleteChannel | train | func (s *StanServer) replicateDeleteChannel(channel string) {
op := &spb.RaftOperation{
OpType: spb.RaftOperation_DeleteChannel,
Channel: channel,
}
data, err := op.Marshal()
if err != nil {
panic(err)
}
// Wait on result of replication.
if err = s.raft.Apply(data, 0).Error(); err != nil {
// If we have... | go | {
"resource": ""
} |
q26720 | handleChannelDelete | train | func (s *StanServer) handleChannelDelete(c *channel) {
delete := false
cs := s.channels
cs.Lock()
a := c.activity
if a.preventDelete || a.deleteInProgress || c.ss.hasActiveSubs() {
if s.debug {
s.log.Debugf("Channel %q cannot be deleted: preventDelete=%v inProgress=%v hasActiveSubs=%v",
c.name, a.preventD... | go | {
"resource": ""
} |
q26721 | processDeleteChannel | train | func (s *StanServer) processDeleteChannel(channel string) {
cs := s.channels
cs.Lock()
defer cs.Unlock()
c := cs.channels[channel]
if c == nil {
s.log.Errorf("Error deleting channel %q: not found", channel)
return
}
if c.activity != nil && c.activity.preventDelete {
s.log.Errorf("The channel %q cannot be d... | go | {
"resource": ""
} |
q26722 | checkClientHealth | train | func (s *StanServer) checkClientHealth(clientID string) {
client := s.clients.lookup(clientID)
if client == nil {
return
}
// If clustered and we lost leadership, we should stop
// heartbeating as the new leader will take over.
if s.isClustered && !s.isLeader() {
// Do not remove client HB here. We do that i... | go | {
"resource": ""
} |
q26723 | closeClient | train | func (s *StanServer) closeClient(clientID string) error {
s.closeMu.Lock()
defer s.closeMu.Unlock()
// Lookup client first, will unregister only after removing its subscriptions
client := s.clients.lookup(clientID)
if client == nil {
s.log.Errorf("Unknown client %q in close request", clientID)
return ErrUnknow... | go | {
"resource": ""
} |
q26724 | processCloseRequest | train | func (s *StanServer) processCloseRequest(m *nats.Msg) {
req := &pb.CloseRequest{}
err := req.Unmarshal(m.Data)
if err != nil {
s.log.Errorf("Received invalid close request, subject=%s", m.Subject)
s.sendCloseResponse(m.Reply, ErrInvalidCloseReq)
return
}
s.barrier(func() {
var err error
// If clustered,... | go | {
"resource": ""
} |
q26725 | processClientPublish | train | func (s *StanServer) processClientPublish(m *nats.Msg) {
iopm := &ioPendingMsg{m: m}
pm := &iopm.pm
if pm.Unmarshal(m.Data) != nil {
if s.processCtrlMsg(m) {
return
}
// else we will report an error below...
}
// Make sure we have a guid and valid channel name.
if pm.Guid == "" || !util.IsChannelNameVal... | go | {
"resource": ""
} |
q26726 | processClientPings | train | func (s *StanServer) processClientPings(m *nats.Msg) {
if len(m.Data) == 0 {
return
}
ping := &pb.Ping{}
if err := ping.Unmarshal(m.Data); err != nil {
return
}
var reply []byte
client := s.clients.lookupByConnID(ping.ConnID)
if client != nil {
// If the client has failed heartbeats and since the
// ser... | go | {
"resource": ""
} |
q26727 | sendMsgToQueueGroup | train | func (s *StanServer) sendMsgToQueueGroup(qs *queueState, m *pb.MsgProto, force bool) (*subState, bool, bool) {
sub := findBestQueueSub(qs.subs)
if sub == nil {
return nil, false, false
}
sub.Lock()
wasStalled := sub.stalled
didSend, sendMore := s.sendMsgToSub(sub, m, force)
// If this is not a redelivery and t... | go | {
"resource": ""
} |
q26728 | processMsg | train | func (s *StanServer) processMsg(c *channel) {
ss := c.ss
// Since we iterate through them all.
ss.RLock()
// Walk the plain subscribers and deliver to each one
for _, sub := range ss.psubs {
s.sendAvailableMessages(c, sub)
}
// Check the queue subscribers
for _, qs := range ss.qsubs {
s.sendAvailableMessa... | go | {
"resource": ""
} |
q26729 | makeSortedSequences | train | func makeSortedSequences(sequences map[uint64]int64) []uint64 {
results := make([]uint64, 0, len(sequences))
for seq := range sequences {
results = append(results, seq)
}
sort.Sort(bySeq(results))
return results
} | go | {
"resource": ""
} |
q26730 | performDurableRedelivery | train | func (s *StanServer) performDurableRedelivery(c *channel, sub *subState) {
// Sort our messages outstanding from acksPending, grab some state and unlock.
sub.RLock()
sortedSeqs := makeSortedSequences(sub.acksPending)
clientID := sub.ClientID
newOnHold := sub.newOnHold
subID := sub.ID
sub.RUnlock()
if s.debug &... | go | {
"resource": ""
} |
q26731 | collectSentOrAck | train | func (s *StanServer) collectSentOrAck(sub *subState, sent bool, sequence uint64) {
sr := s.ssarepl
if sub.replicate == nil {
sub.replicate = &subSentAndAck{
sent: make([]uint64, 0, 100),
ack: make([]uint64, 0, 100),
}
}
r := sub.replicate
if sent {
r.sent = append(r.sent, sequence)
} else {
r.ack =... | go | {
"resource": ""
} |
q26732 | replicateSubSentAndAck | train | func (s *StanServer) replicateSubSentAndAck(sub *subState) {
var data []byte
sr := s.ssarepl
sub.Lock()
r := sub.replicate
if r != nil && len(r.sent)+len(r.ack) > 0 {
data = createSubSentAndAckProto(sub, r)
r.sent = r.sent[:0]
r.ack = r.ack[:0]
r.applying = true
}
sub.Unlock()
if data != nil {
if te... | go | {
"resource": ""
} |
q26733 | createSubSentAndAckProto | train | func createSubSentAndAckProto(sub *subState, r *subSentAndAck) []byte {
op := &spb.RaftOperation{
OpType: spb.RaftOperation_SendAndAck,
SubSentAck: &spb.SubSentAndAck{
Channel: sub.subject,
AckInbox: sub.AckInbox,
Sent: r.sent,
Ack: r.ack,
},
}
data, err := op.Marshal()
if err != nil {
... | go | {
"resource": ""
} |
q26734 | clearSentAndAck | train | func (s *StanServer) clearSentAndAck(sub *subState) {
sr := s.ssarepl
sr.waiting.Delete(sub)
sr.ready.Delete(sub)
sub.replicate = nil
} | go | {
"resource": ""
} |
q26735 | sendMsgToSub | train | func (s *StanServer) sendMsgToSub(sub *subState, m *pb.MsgProto, force bool) (bool, bool) {
if sub == nil || m == nil || !sub.initialized || (sub.newOnHold && !m.Redelivered) {
return false, false
}
// Don't send if we have too many outstanding already, unless forced to send.
ap := int32(len(sub.acksPending))
i... | go | {
"resource": ""
} |
q26736 | setupAckTimer | train | func (s *StanServer) setupAckTimer(sub *subState, d time.Duration) {
sub.ackTimer = time.AfterFunc(d, func() {
s.performAckExpirationRedelivery(sub, false)
})
} | go | {
"resource": ""
} |
q26737 | sendDeleteChannelRequest | train | func (s *StanServer) sendDeleteChannelRequest(c *channel) {
iopm := &ioPendingMsg{c: c, dc: true}
s.ioChannel <- iopm
} | go | {
"resource": ""
} |
q26738 | ackPublisher | train | func (s *StanServer) ackPublisher(iopm *ioPendingMsg) {
msgAck := &iopm.pa
msgAck.Guid = iopm.pm.Guid
needed := msgAck.Size()
s.tmpBuf = util.EnsureBufBigEnough(s.tmpBuf, needed)
n, _ := msgAck.MarshalTo(s.tmpBuf)
if s.trace {
pm := &iopm.pm
s.log.Tracef("[Client:%s] Acking Publisher subj=%s guid=%s", pm.Clie... | go | {
"resource": ""
} |
q26739 | deleteFromList | train | func (sub *subState) deleteFromList(sl []*subState) ([]*subState, bool) {
for i := 0; i < len(sl); i++ {
if sl[i] == sub {
sl[i] = sl[len(sl)-1]
sl[len(sl)-1] = nil
sl = sl[:len(sl)-1]
return shrinkSubListIfNeeded(sl), true
}
}
return sl, false
} | go | {
"resource": ""
} |
q26740 | shrinkSubListIfNeeded | train | func shrinkSubListIfNeeded(sl []*subState) []*subState {
lsl := len(sl)
csl := cap(sl)
// Don't bother if list not too big
if csl <= 8 {
return sl
}
pFree := float32(csl-lsl) / float32(csl)
if pFree > 0.50 {
return append([]*subState(nil), sl...)
}
return sl
} | go | {
"resource": ""
} |
q26741 | removeAllNonDurableSubscribers | train | func (s *StanServer) removeAllNonDurableSubscribers(client *client) {
// client has been unregistered and no other routine can add/remove
// subscriptions, so it is safe to use the original.
client.RLock()
subs := client.subs
clientID := client.info.ID
client.RUnlock()
var (
storesToFlush = map[string]stores.S... | go | {
"resource": ""
} |
q26742 | processUnsubscribeRequest | train | func (s *StanServer) processUnsubscribeRequest(m *nats.Msg) {
req := &pb.UnsubscribeRequest{}
err := req.Unmarshal(m.Data)
if err != nil {
s.log.Errorf("Invalid unsub request from %s", m.Subject)
s.sendSubscriptionResponseErr(m.Reply, ErrInvalidUnsubReq)
return
}
s.performmUnsubOrCloseSubscription(m, req, fa... | go | {
"resource": ""
} |
q26743 | performmUnsubOrCloseSubscription | train | func (s *StanServer) performmUnsubOrCloseSubscription(m *nats.Msg, req *pb.UnsubscribeRequest, isSubClose bool) {
// With partitioning, first verify that this server is handling this
// channel. If not, do not return an error, since another server will
// handle it. If no other server is, the client will get a timeo... | go | {
"resource": ""
} |
q26744 | clearAckTimer | train | func (sub *subState) clearAckTimer() {
if sub.ackTimer != nil {
sub.ackTimer.Stop()
sub.ackTimer = nil
}
} | go | {
"resource": ""
} |
q26745 | adjustAckTimer | train | func (sub *subState) adjustAckTimer(nextExpirationTime int64) {
sub.Lock()
defer sub.Unlock()
// Possible that the subscriber has been destroyed, and timer cleared
if sub.ackTimer == nil {
return
}
// Check if there are still pending acks
if len(sub.acksPending) > 0 {
// Capture time
now := time.Now().Un... | go | {
"resource": ""
} |
q26746 | startAckSub | train | func (sub *subState) startAckSub(nc *nats.Conn, cb nats.MsgHandler) error {
ackSub, err := nc.Subscribe(sub.AckInbox, cb)
if err != nil {
return err
}
sub.Lock()
// Should not occur, but if it was already set,
// unsubscribe old and replace.
sub.stopAckSub()
sub.ackSub = ackSub
sub.ackSub.SetPendingLimits(-1... | go | {
"resource": ""
} |
q26747 | stopAckSub | train | func (sub *subState) stopAckSub() {
if sub.ackSub != nil {
sub.ackSub.Unsubscribe()
sub.ackSub = nil
}
} | go | {
"resource": ""
} |
q26748 | isShadowQueueDurable | train | func (sub *subState) isShadowQueueDurable() bool {
return sub.IsDurable && sub.QGroup != "" && sub.ClientID == ""
} | go | {
"resource": ""
} |
q26749 | replicateSub | train | func (s *StanServer) replicateSub(sr *pb.SubscriptionRequest, ackInbox string, subID uint64) (*subState, error) {
op := &spb.RaftOperation{
OpType: spb.RaftOperation_Subscribe,
Sub: &spb.AddSubscription{
Request: sr,
AckInbox: ackInbox,
ID: subID,
},
}
data, err := op.Marshal()
if err != nil {... | go | {
"resource": ""
} |
q26750 | addSubscription | train | func (s *StanServer) addSubscription(ss *subStore, sub *subState) error {
// Store in client
if !s.clients.addSub(sub.ClientID, sub) {
return fmt.Errorf("can't find clientID: %v", sub.ClientID)
}
// Store this subscription in subStore
if err := ss.Store(sub); err != nil {
s.clients.removeSub(sub.ClientID, sub)... | go | {
"resource": ""
} |
q26751 | updateDurable | train | func (s *StanServer) updateDurable(ss *subStore, sub *subState) error {
// Reset the hasFailedHB boolean since it may have been set
// if the client previously crashed and server set this
// flag to its subs.
sub.hasFailedHB = false
// Store in the client
if !s.clients.addSub(sub.ClientID, sub) {
return fmt.Err... | go | {
"resource": ""
} |
q26752 | processAckMsg | train | func (s *StanServer) processAckMsg(m *nats.Msg) {
ack := &pb.Ack{}
if ack.Unmarshal(m.Data) != nil {
if s.processCtrlMsg(m) {
return
}
}
c := s.channels.get(ack.Subject)
if c == nil {
s.log.Errorf("Unable to process ack seq=%d, channel %s not found", ack.Sequence, ack.Subject)
return
}
sub := c.ss.Loo... | go | {
"resource": ""
} |
q26753 | processAck | train | func (s *StanServer) processAck(c *channel, sub *subState, sequence uint64, fromUser bool) {
var stalled bool
// This is immutable, so can grab outside of sub's lock.
// If we have a queue group, we want to grab queue's lock before
// sub's lock.
qs := sub.qstate
if qs != nil {
qs.Lock()
}
sub.Lock()
pers... | go | {
"resource": ""
} |
q26754 | sendAvailableMessagesToQueue | train | func (s *StanServer) sendAvailableMessagesToQueue(c *channel, qs *queueState) {
if c == nil || qs == nil {
return
}
qs.Lock()
// Short circuit if no active members
if len(qs.subs) == 0 {
qs.Unlock()
return
}
// If redelivery at startup in progress, don't attempt to deliver new messages
if qs.newOnHold {
... | go | {
"resource": ""
} |
q26755 | sendAvailableMessages | train | func (s *StanServer) sendAvailableMessages(c *channel, sub *subState) {
sub.Lock()
for nextSeq := sub.LastSent + 1; !sub.stalled; nextSeq++ {
nextMsg := s.getNextMsg(c, &nextSeq, &sub.LastSent)
if nextMsg == nil {
break
}
if sent, sendMore := s.sendMsgToSub(sub, nextMsg, honorMaxInFlight); !sent || !sendMo... | go | {
"resource": ""
} |
q26756 | setSubStartSequence | train | func (s *StanServer) setSubStartSequence(c *channel, sr *pb.SubscriptionRequest) (string, uint64, error) {
lastSent := uint64(0)
debugTrace := ""
// In all start position cases, if there is no message, ensure
// lastSent stays at 0.
switch sr.StartPosition {
case pb.StartPosition_NewOnly:
var err error
last... | go | {
"resource": ""
} |
q26757 | startGoRoutine | train | func (s *StanServer) startGoRoutine(f func()) {
s.mu.Lock()
if !s.shutdown {
s.wg.Add(1)
go f()
}
s.mu.Unlock()
} | go | {
"resource": ""
} |
q26758 | ClusterID | train | func (s *StanServer) ClusterID() string {
s.mu.RLock()
defer s.mu.RUnlock()
return s.info.ClusterID
} | go | {
"resource": ""
} |
q26759 | State | train | func (s *StanServer) State() State {
s.mu.RLock()
defer s.mu.RUnlock()
return s.state
} | go | {
"resource": ""
} |
q26760 | setLastError | train | func (s *StanServer) setLastError(err error) {
s.mu.Lock()
s.lastError = err
s.state = Failed
s.mu.Unlock()
s.log.Fatalf("%v", err)
} | go | {
"resource": ""
} |
q26761 | LastError | train | func (s *StanServer) LastError() error {
s.mu.RLock()
defer s.mu.RUnlock()
return s.lastError
} | go | {
"resource": ""
} |
q26762 | Shutdown | train | func (s *StanServer) Shutdown() {
s.log.Noticef("Shutting down.")
s.mu.Lock()
if s.shutdown {
s.mu.Unlock()
return
}
close(s.shutdownCh)
// Allows Shutdown() to be idempotent
s.shutdown = true
// Change the state too
s.state = Shutdown
// We need to make sure that the storeIOLoop returns before
// cl... | go | {
"resource": ""
} |
q26763 | SetLogger | train | func (s *StanLogger) SetLogger(log Logger, logtime, debug, trace bool, logfile string) {
s.mu.Lock()
s.log = log
s.ltime = logtime
s.debug = debug
s.trace = trace
s.lfile = logfile
s.mu.Unlock()
} | go | {
"resource": ""
} |
q26764 | GetLogger | train | func (s *StanLogger) GetLogger() Logger {
s.mu.RLock()
l := s.log
s.mu.RUnlock()
return l
} | go | {
"resource": ""
} |
q26765 | ReopenLogFile | train | func (s *StanLogger) ReopenLogFile() {
s.mu.Lock()
if s.lfile == "" {
s.mu.Unlock()
s.Noticef("File log re-open ignored, not a file logger")
return
}
if l, ok := s.log.(io.Closer); ok {
if err := l.Close(); err != nil {
s.mu.Unlock()
s.Errorf("Unable to close logger: %v", err)
return
}
}
fileLo... | go | {
"resource": ""
} |
q26766 | Close | train | func (s *StanLogger) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
if l, ok := s.log.(io.Closer); ok {
return l.Close()
}
return nil
} | go | {
"resource": ""
} |
q26767 | Errorf | train | func (s *StanLogger) Errorf(format string, v ...interface{}) {
s.executeLogCall(func(log Logger, format string, v ...interface{}) {
log.Errorf(format, v...)
}, format, v...)
} | go | {
"resource": ""
} |
q26768 | Warnf | train | func (s *StanLogger) Warnf(format string, v ...interface{}) {
s.executeLogCall(func(logger Logger, format string, v ...interface{}) {
logger.Warnf(format, v...)
}, format, v...)
} | go | {
"resource": ""
} |
q26769 | BufferSize | train | func BufferSize(size int) FileStoreOption {
return func(o *FileStoreOptions) error {
if size < 0 {
return fmt.Errorf("buffer size value must be a positive number")
}
o.BufferSize = size
return nil
}
} | go | {
"resource": ""
} |
q26770 | CompactEnabled | train | func CompactEnabled(enabled bool) FileStoreOption {
return func(o *FileStoreOptions) error {
o.CompactEnabled = enabled
return nil
}
} | go | {
"resource": ""
} |
q26771 | CompactInterval | train | func CompactInterval(seconds int) FileStoreOption {
return func(o *FileStoreOptions) error {
if seconds <= 0 {
return fmt.Errorf("compact interval value must at least be 1 seconds")
}
o.CompactInterval = seconds
return nil
}
} | go | {
"resource": ""
} |
q26772 | CompactFragmentation | train | func CompactFragmentation(fragmentation int) FileStoreOption {
return func(o *FileStoreOptions) error {
if fragmentation <= 0 {
return fmt.Errorf("compact fragmentation value must at least be 1")
}
o.CompactFragmentation = fragmentation
return nil
}
} | go | {
"resource": ""
} |
q26773 | CompactMinFileSize | train | func CompactMinFileSize(fileSize int64) FileStoreOption {
return func(o *FileStoreOptions) error {
if fileSize < 0 {
return fmt.Errorf("compact minimum file size value must be a positive number")
}
o.CompactMinFileSize = fileSize
return nil
}
} | go | {
"resource": ""
} |
q26774 | DoCRC | train | func DoCRC(enableCRC bool) FileStoreOption {
return func(o *FileStoreOptions) error {
o.DoCRC = enableCRC
return nil
}
} | go | {
"resource": ""
} |
q26775 | SliceConfig | train | func SliceConfig(maxMsgs int, maxBytes int64, maxAge time.Duration, script string) FileStoreOption {
return func(o *FileStoreOptions) error {
if maxMsgs < 0 || maxBytes < 0 || maxAge < 0 {
return fmt.Errorf("slice max values must be positive numbers")
}
o.SliceMaxMsgs = maxMsgs
o.SliceMaxBytes = maxBytes
... | go | {
"resource": ""
} |
q26776 | FileDescriptorsLimit | train | func FileDescriptorsLimit(limit int64) FileStoreOption {
return func(o *FileStoreOptions) error {
if limit < 0 {
return fmt.Errorf("file descriptor limit must be a positive number")
}
o.FileDescriptorsLimit = limit
return nil
}
} | go | {
"resource": ""
} |
q26777 | ParallelRecovery | train | func ParallelRecovery(count int) FileStoreOption {
return func(o *FileStoreOptions) error {
if count <= 0 {
return fmt.Errorf("parallel recovery value must be at least 1")
}
o.ParallelRecovery = count
return nil
}
} | go | {
"resource": ""
} |
q26778 | AllOptions | train | func AllOptions(opts *FileStoreOptions) FileStoreOption {
return func(o *FileStoreOptions) error {
if err := BufferSize(opts.BufferSize)(o); err != nil {
return err
}
if err := CompactInterval(opts.CompactInterval)(o); err != nil {
return err
}
if err := CompactFragmentation(opts.CompactFragmentation)(... | go | {
"resource": ""
} |
q26779 | checkFileVersion | train | func checkFileVersion(r io.Reader) error {
fv, err := util.ReadInt(r)
if err != nil {
return fmt.Errorf("unable to verify file version: %v", err)
}
if fv == 0 || fv > fileVersion {
return fmt.Errorf("unsupported file version: %v (supports [1..%v])", fv, fileVersion)
}
return nil
} | go | {
"resource": ""
} |
q26780 | createNewWriter | train | func (w *bufferedWriter) createNewWriter(file *os.File) io.Writer {
w.buf = bufio.NewWriterSize(file, w.bufSize)
return w.buf
} | go | {
"resource": ""
} |
q26781 | tryShrinkBuffer | train | func (w *bufferedWriter) tryShrinkBuffer(file *os.File) (io.Writer, error) {
// Nothing to do if we are already at the lowest
// or file not set/opened.
if w.bufSize == w.minShrinkSize || file == nil {
return w.buf, nil
}
if !w.shrinkReq {
percentFilled := w.buf.Buffered() * 100 / w.bufSize
if percentFilled... | go | {
"resource": ""
} |
q26782 | checkShrinkRequest | train | func (w *bufferedWriter) checkShrinkRequest() {
percentFilled := w.buf.Buffered() * 100 / w.bufSize
// If above the threshold, cancel the request.
if percentFilled > bufShrinkThreshold {
w.shrinkReq = false
}
} | go | {
"resource": ""
} |
q26783 | openFile | train | func (fm *filesManager) openFile(file *file) error {
fm.Lock()
if fm.isClosed {
fm.Unlock()
return fmt.Errorf("unable to open file %q, store is being closed", file.name)
}
curState := atomic.LoadInt32(&file.state)
if curState == fileRemoved {
fm.Unlock()
return fmt.Errorf("unable to open file %q, it has be... | go | {
"resource": ""
} |
q26784 | closeLockedFile | train | func (fm *filesManager) closeLockedFile(file *file) error {
if !atomic.CompareAndSwapInt32(&file.state, fileInUse, fileClosing) {
panic(fmt.Errorf("file %q is requested to be closed but was not locked by caller", file.name))
}
fm.Lock()
err := fm.doClose(file)
fm.Unlock()
return err
} | go | {
"resource": ""
} |
q26785 | closeFileIfOpened | train | func (fm *filesManager) closeFileIfOpened(file *file) error {
if !atomic.CompareAndSwapInt32(&file.state, fileOpened, fileClosing) {
return nil
}
fm.Lock()
err := fm.doClose(file)
fm.Unlock()
return err
} | go | {
"resource": ""
} |
q26786 | doClose | train | func (fm *filesManager) doClose(file *file) error {
var err error
if file.beforeClose != nil {
err = file.beforeClose()
}
util.CloseFile(err, file.handle)
// Regardless of error, we need to change the state to closed.
file.handle = nil
atomic.StoreInt32(&file.state, fileClosed)
fm.openedFDs--
return err
} | go | {
"resource": ""
} |
q26787 | lockFile | train | func (fm *filesManager) lockFile(file *file) (bool, error) {
if atomic.CompareAndSwapInt32(&file.state, fileOpened, fileInUse) {
return true, nil
}
return false, fm.openFile(file)
} | go | {
"resource": ""
} |
q26788 | unlockFile | train | func (fm *filesManager) unlockFile(file *file) {
if !atomic.CompareAndSwapInt32(&file.state, fileInUse, fileOpened) {
panic(fmt.Errorf("failed to switch state from fileInUse to fileOpened for file %q, state=%v",
file.name, file.state))
}
} | go | {
"resource": ""
} |
q26789 | trySwitchState | train | func (fm *filesManager) trySwitchState(file *file, newState int32) (bool, error) {
wasOpened := false
wasClosed := false
for i := 0; i < 10000; i++ {
if atomic.CompareAndSwapInt32(&file.state, fileOpened, newState) {
wasOpened = true
break
}
if atomic.CompareAndSwapInt32(&file.state, fileClosed, newState... | go | {
"resource": ""
} |
q26790 | close | train | func (fm *filesManager) close() error {
fm.Lock()
if fm.isClosed {
fm.Unlock()
return nil
}
fm.isClosed = true
files := make([]*file, 0, len(fm.files))
for _, file := range fm.files {
files = append(files, file)
}
fm.files = nil
fm.Unlock()
var err error
for _, file := range files {
wasOpened, sser... | go | {
"resource": ""
} |
q26791 | Init | train | func (fs *FileStore) Init(info *spb.ServerInfo) error {
fs.Lock()
defer fs.Unlock()
if fs.serverFile == nil {
var err error
// Open/Create the server file (note that this file must not be opened,
// in APPEND mode to allow truncate to work).
fs.serverFile, err = fs.fm.createFile(serverFileName, os.O_RDWR|os... | go | {
"resource": ""
} |
q26792 | recoverClients | train | func (fs *FileStore) recoverClients() ([]*Client, error) {
var err error
var recType recordType
var recSize int
_buf := [256]byte{}
buf := _buf[:]
offset := int64(4)
// Create a buffered reader to speed-up recovery
br := bufio.NewReaderSize(fs.clientsFile.handle, defaultBufSize)
for {
buf, recSize, recTyp... | go | {
"resource": ""
} |
q26793 | recoverServerInfo | train | func (fs *FileStore) recoverServerInfo() (*spb.ServerInfo, error) {
info := &spb.ServerInfo{}
buf, size, _, err := readRecord(fs.serverFile.handle, nil, false, fs.crcTable, fs.opts.DoCRC)
if err != nil {
if err == io.EOF {
// We are done, no state recovered
return nil, nil
}
fs.log.Errorf("Server file %q... | go | {
"resource": ""
} |
q26794 | shouldCompactClientFile | train | func (fs *FileStore) shouldCompactClientFile() bool {
// Global switch
if !fs.opts.CompactEnabled {
return false
}
// Check that if minimum file size is set, the client file
// is at least at the minimum.
if fs.opts.CompactMinFileSize > 0 && fs.cliFileSize < fs.opts.CompactMinFileSize {
return false
}
// Ch... | go | {
"resource": ""
} |
q26795 | compactClientFile | train | func (fs *FileStore) compactClientFile(orgFileName string) error {
// Open a temporary file
tmpFile, err := getTempFile(fs.fm.rootDir, clientsFileName)
if err != nil {
return err
}
defer func() {
if tmpFile != nil {
tmpFile.Close()
os.Remove(tmpFile.Name())
}
}()
bw := bufio.NewWriterSize(tmpFile, de... | go | {
"resource": ""
} |
q26796 | Close | train | func (fs *FileStore) Close() error {
fs.Lock()
if fs.closed {
fs.Unlock()
return nil
}
fs.closed = true
err := fs.genericStore.close()
fm := fs.fm
lockFile := fs.lockFile
fs.Unlock()
if fm != nil {
if fmerr := fm.close(); fmerr != nil && err == nil {
err = fmerr
}
}
if lockFile != nil {
err =... | go | {
"resource": ""
} |
q26797 | beforeDataFileCloseCb | train | func (ms *FileMsgStore) beforeDataFileCloseCb(fslice *fileSlice) beforeFileClose {
return func() error {
if fslice != ms.writeSlice {
return nil
}
if ms.bw != nil && ms.bw.buf != nil && ms.bw.buf.Buffered() > 0 {
if err := ms.bw.buf.Flush(); err != nil {
return err
}
}
if ms.fstore.opts.DoSync {... | go | {
"resource": ""
} |
q26798 | beforeIndexFileCloseCb | train | func (ms *FileMsgStore) beforeIndexFileCloseCb(fslice *fileSlice) beforeFileClose {
return func() error {
if fslice != ms.writeSlice {
return nil
}
if len(ms.bufferedMsgs) > 0 {
if err := ms.processBufferedMsgs(fslice); err != nil {
return err
}
}
if ms.fstore.opts.DoSync {
if err := fslice.i... | go | {
"resource": ""
} |
q26799 | setFile | train | func (ms *FileMsgStore) setFile(fslice *fileSlice, offset int64) error {
var err error
file := fslice.file.handle
ms.writer = file
if file != nil && ms.bw != nil {
ms.writer = ms.bw.createNewWriter(file)
}
if offset == -1 {
ms.wOffset, err = file.Seek(0, io.SeekEnd)
} else {
ms.wOffset = offset
}
return ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.