id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c26700 | return nil, ErrChanDelInProgress
}
cs.RUnlock()
return c, nil
}
cs.RUnlock()
return cs.createChannel(s, name)
} | |
c26701 | durables: make(map[string]*subState),
acks: make(map[string]*subState),
stan: s,
}
return subs
} | |
c26702 | != nil {
ss.stan.log.Errorf("Unable to store subscription [%v:%v] on [%s]: %v", sub.ClientID, sub.Inbox, sub.subject, err)
return err
}
ss.Lock()
ss.updateState(sub)
ss.Unlock()
return nil
} | |
c26703 | is not nil, but the qsub.subs array should be
// empty.
if len(qsub.subs) > 0 {
return true
}
}
return false
} | |
c26704 | sub := ss.durables[durableName]
ss.RUnlock()
return sub
} | |
c26705 | *subState {
ss.RLock()
sub := ss.acks[ackInbox]
ss.RUnlock()
return sub
} | |
c26706 | clone.Clustering.Peers = make([]string, 0, len(o.Clustering.Peers))
clone.Clustering.Peers = append(clone.Clustering.Peers, o.Clustering.Peers...)
}
return &clone
} | |
c26707 |
opts.StoreLimits = stores.DefaultStoreLimits
return &opts
} | |
c26708 |
sOpts.ID = ID
nOpts := DefaultNatsServerOptions
return RunServerWithOpts(sOpts, &nOpts)
} | |
c26709 | err == raft.ErrLeadershipLost:
case err == raft.ErrNotLeader:
// Node lost leadership, continue loop.
continue
default:
// TODO: probably step down as leader?
panic(err)
}
}
} else {
s.leadershipLost()
}
case <-s.shutdownCh:
// Signal channel here ... | |
c26710 | {
client.RUnlock()
return err
}
}
client.RUnlock()
s.clients.setClientHB(cID, s.opts.ClientHBInterval, func() {
s.checkClientHealth(cID)
})
}
// Start the internal subscriptions so we receive protocols from clients.
if err := s.initInternalSubs(true); err != nil {
return err
}
var allSub... | |
c26711 |
for _, client := range s.clients.getClients() {
s.clients.removeClientHB(client)
// Ensure subs ackTimer is stopped
subs := client.getSubsCopy()
for _, sub := range subs {
sub.Lock()
sub.stopAckSub()
sub.clearAckTimer()
s.clearSentAndAck(sub)
sub.Unlock()
}
}
// Unsubscribe to the snapshot... | |
c26712 | the long run, so better fail
// the startup early.
return fmt.Errorf("unmarshall error while detecting another server instance: %v", err)
}
// Another streaming server was found, cleanup then return error.
clreq := &pb.CloseRequest{ClientID: clusterID}
b, _ = clreq.Marshal()
s.nc.Request(cr.CloseRequests, b, ... | |
c26713 | {
s.clients.recoverClients(clients)
}
} | |
c26714 | allSubs = append(allSubs, sub)
}
}
// Now that we have recovered possible subscriptions for this channel,
// check if we should start the delete timer.
if channel.activity != nil {
s.channels.maybeStartChannelDeleteTimer(channelName, channel)
}
}
}
return allSubs, nil
} | |
c26715 | // Unlock in order to call function below
sub.Unlock()
// Send old messages (lock is acquired in that function)
s.performAckExpirationRedelivery(sub, true)
// Regrab lock
sub.Lock()
// Allow new messages to be delivered
sub.newOnHold = false
subject := sub.subject
qs := sub.qstate
sub.Unlock()
c... | |
c26716 | s.partitions != nil {
s.log.Debugf("Publish subjects root: %s", s.info.Publish)
} else {
s.log.Debugf("Publish subject: %s.>", s.info.Publish)
}
s.log.Debugf("Subscribe subject: %s", s.info.Subscribe)
s.log.Debugf("Subscription Close subject: %s", s.info.SubClose)
s.log.Debugf("Unsubs... | |
c26717 | if _, exists := s.cliDipCIDsMap[req.ClientID]; exists {
s.cliDupCIDsMu.Unlock()
s.log.Debugf("[Client:%s] Connect failed; already connected", req.ClientID)
s.sendConnectErr(m.Reply, ErrInvalidClient.Error())
return
}
s.cliDipCIDsMap[req.ClientID] = struct{}{}
s.cliDupCIDsMu.Unlock()
s.startGoRout... | |
c26718 | _, err := s.nc.Request(hbInbox, nil, s.dupCIDTimeout)
// If err is nil, the currently registered client responded, so this is a
// duplicate.
return err == nil
} | |
c26719 | {
// If we have lost leadership, clear the deleteInProgress flag.
cs := s.channels
cs.Lock()
c := cs.channels[channel]
if c != nil && c.activity != nil {
c.activity.deleteInProgress = false
}
cs.Unlock()
}
} | |
c26720 | time.Duration
if elapsed < 0 {
next = a.maxInactivity
} else {
// elapsed < a.maxInactivity
next = a.maxInactivity - elapsed
}
if s.debug {
s.log.Debugf("Channel %q cannot be deleted now, reset timer to fire in %v",
c.name, next)
}
c.resetDeleteTimer(next)
}
}
cs.Unlock()
if... | |
c26721 | s.log.Errorf("Error deleting channel %q: %v", channel, err)
if c.activity != nil {
c.activity.deleteInProgress = false
c.startDeleteTimer()
}
return
}
delete(s.channels.channels, channel)
s.log.Noticef("Channel %q has been deleted", channel)
} | |
c26722 | }
})
} else {
s.closeClient(clientID)
}
return
}
} else {
// We got the reply, reset the number of failed heartbeats.
client.fhb = 0
}
// Reset the timer to fire again.
client.hbt.Reset(s.opts.ClientHBInterval)
var (
subs []*subState
hasFailedHB = client.fhb > 0
)
if (hadFail... | |
c26723 | return ErrUnknownClient
}
// Remove all non-durable subscribers.
s.removeAllNonDurableSubscribers(client)
// Remove from our clientStore.
if _, err := s.clients.unregister(clientID); err != nil {
s.log.Errorf("Error unregistering client %q: %v", clientID, err)
}
if s.debug {
client.RLock()
hbInbox := c... | |
c26724 | } else {
err = s.closeClient(req.ClientID)
}
// If there was an error, it has been already logged.
// Send response, if err is nil, will be a success response.
s.sendCloseResponse(m.Reply, err)
})
} | |
c26725 | wait
// for conn request to be processed first. Check clientCheckTimeout
// doc for details.
valid = s.clients.isValidWithTimeout(pm.ClientID, pm.ConnID, clientCheckTimeout)
} else {
valid = s.clients.isValid(pm.ClientID, pm.ConnID)
}
if !valid {
s.log.Errorf("Received invalid client publish message %v", ... | |
c26726 | client.Unlock()
}
if s.pingResponseOKBytes == nil {
s.pingResponseOKBytes, _ = (&pb.PingResponse{}).Marshal()
}
reply = s.pingResponseOKBytes
} else {
if s.pingResponseInvalidClientBytes == nil {
pingError := &pb.PingResponse{
Error: "client has been replaced or is no longer registered",
}
... | |
c26727 | s.sendMsgToSub(sub, m, force)
// If this is not a redelivery and the sub was not stalled, but now is,
// bump the number of stalled members.
if !force && !wasStalled && sub.stalled {
qs.stalledSubCount++
}
if didSend && sub.LastSent > qs.lastSent {
qs.lastSent = sub.LastSent
}
sub.Unlock()
return sub, didS... | |
c26728 |
// Check the queue subscribers
for _, qs := range ss.qsubs {
s.sendAvailableMessagesToQueue(c, qs)
}
ss.RUnlock()
} | |
c26729 |
results = append(results, seq)
}
sort.Sort(bySeq(results))
return results
} | |
c26730 | s.trace {
s.log.Tracef("[Client:%s] Redelivering to subid=%d, seq=%d", clientID, subID, m.Sequence)
}
// Flag as redelivered.
m.Redelivered = true
sub.Lock()
// Force delivery
s.sendMsgToSub(sub, m, forceDelivery)
sub.Unlock()
}
}
// Release newOnHold if needed.
if newOnHold {
sub.Loc... | |
c26731 | to given map. This
// avoid the need for booleans to not add more than once.
l := len(r.sent) + len(r.ack)
if l == 1 {
sr.waiting.Store(sub, struct{}{})
} else if l == 100 {
sr.waiting.Delete(sub)
sr.ready.Store(sub, struct{}{})
signalCh(sr.notifyCh)
}
} | |
c26732 | // in which case we don't do anything, or the sub/conn is being
// closed and endSubSentAndAckReplication() is waiting on a
// channel stored in "gates" map. If we find it, signal.
if r == nil {
if c, ok := sr.gates.Load(sub); ok {
sr.gates.Delete(sub)
signalCh(c.(chan struct{}))
}
} else {
r.... | |
c26733 | r.sent,
Ack: r.ack,
},
}
data, err := op.Marshal()
if err != nil {
panic(err)
}
return data
} | |
c26734 |
sr.ready.Delete(sub)
sub.replicate = nil
} | |
c26735 | of the sent event.
if s.isClustered {
s.collectSentOrAck(sub, replicateSent, m.Sequence)
}
// Store in storage
if err := sub.store.AddSeqPending(sub.ID, m.Sequence); err != nil {
s.log.Errorf("[Client:%s] Unable to add pending message to subid=%d, subject=%s, seq=%d, err=%v",
sub.ClientID, sub.ID, sub.subj... | |
c26736 | s.performAckExpirationRedelivery(sub, false)
})
} | |
c26737 | &ioPendingMsg{c: c, dc: true}
s.ioChannel <- iopm
} | |
c26738 |
n, _ := msgAck.MarshalTo(s.tmpBuf)
if s.trace {
pm := &iopm.pm
s.log.Tracef("[Client:%s] Acking Publisher subj=%s guid=%s", pm.ClientID, pm.Subject, pm.Guid)
}
s.ncs.Publish(iopm.m.Reply, s.tmpBuf[:n])
} | |
c26739 |
sl = sl[:len(sl)-1]
return shrinkSubListIfNeeded(sl), true
}
}
return sl, false
} | |
c26740 | float32(csl-lsl) / float32(csl)
if pFree > 0.50 {
return append([]*subState(nil), sl...)
}
return sl
} | |
c26741 | if isDurable && subStore != nil {
storesToFlush[subject] = subStore
}
channels[subject] = struct{}{}
}
if len(storesToFlush) > 0 {
for subject, subStore := range storesToFlush {
if err := subStore.Flush(); err != nil {
s.log.Errorf("[Client:%s] Error flushing store while removing subscriptions: subj... | |
c26742 | %s", m.Subject)
s.sendSubscriptionResponseErr(m.Reply, ErrInvalidUnsubReq)
return
}
s.performmUnsubOrCloseSubscription(m, req, false)
} | |
c26743 | has been already logged.
if err == nil {
// This will check if the channel has MaxInactivity defined,
// if so and there is no active subscription, it will start the
// delete timer.
s.channels.maybeStartChannelDeleteTimer(req.Subject, nil)
}
// If err is nil, it will be a non-error response
s.se... | |
c26744 | sub.ackTimer.Stop()
sub.ackTimer = nil
}
} | |
c26745 | } else {
// Compute the time the ackTimer should fire, based
// on the given next expiration time and now.
fireIn := (nextExpirationTime - now)
sub.ackTimer.Reset(time.Duration(fireIn))
}
} else {
// No more pending acks, clear the timer.
sub.clearAckTimer()
}
} | |
c26746 | // unsubscribe old and replace.
sub.stopAckSub()
sub.ackSub = ackSub
sub.ackSub.SetPendingLimits(-1, -1)
sub.Unlock()
return nil
} | |
c26747 | sub.ackSub.Unsubscribe()
sub.ackSub = nil
}
} | |
c26748 | && sub.QGroup != "" && sub.ClientID == ""
} | |
c26749 | panic(err)
}
// Replicate operation and wait on result.
future := s.raft.Apply(data, 0)
if err := future.Error(); err != nil {
return nil, err
}
rs := future.Response().(*replicatedSub)
return rs.sub, rs.err
} | |
c26750 | find clientID: %v", sub.ClientID)
}
// Store this subscription in subStore
if err := ss.Store(sub); err != nil {
s.clients.removeSub(sub.ClientID, sub)
return err
}
return nil
} | |
c26751 | only for durable subscribers (not durable queue subscribers).
if sub.isDurableSubscriber() {
// Add back into plain subscribers
ss.psubs = append(ss.psubs, sub)
}
// And in ackInbox lookup map.
ss.acks[sub.AckInbox] = sub
ss.Unlock()
return nil
} | |
c26752 | ack.Subject)
return
}
sub := c.ss.LookupByAckInbox(m.Subject)
if sub == nil {
return
}
s.processAck(c, sub, ack.Sequence, true)
} | |
c26753 | server sends more messages if needed.
}
if sub.stalled && int32(len(sub.acksPending)) < sub.MaxInFlight {
// For queue, we must not check the queue stalled count here. The queue
// as a whole may not be stalled, yet, if this sub was stalled, it is
// not now since the pending acks is below MaxInflight. The ser... | |
c26754 | to deliver new messages
if qs.newOnHold {
qs.Unlock()
return
}
for nextSeq := qs.lastSent + 1; qs.stalledSubCount < len(qs.subs); nextSeq++ {
nextMsg := s.getNextMsg(c, &nextSeq, &qs.lastSent)
if nextMsg == nil {
break
}
if _, sent, sendMore := s.sendMsgToQueueGroup(qs, nextMsg, honorMaxInFlight); !s... | |
c26755 |
}
if sent, sendMore := s.sendMsgToSub(sub, nextMsg, honorMaxInFlight); !sent || !sendMore {
break
}
}
sub.Unlock()
} | |
c26756 | lower than 0.
if sr.StartSequence < firstSeq {
// That translates to sending the first message available.
lastSent = firstSeq - 1
} else if sr.StartSequence > lastSeq {
// That translates to "new only"
lastSent = lastSeq
} else if sr.StartSequence > 0 {
// That translates to sending the message wi... | |
c26757 | s.mu.Lock()
if !s.shutdown {
s.wg.Add(1)
go f()
}
s.mu.Unlock()
} | |
c26758 | s.mu.RUnlock()
return s.info.ClusterID
} | |
c26759 | s.mu.RUnlock()
return s.state
} | |
c26760 |
s.lastError = err
s.state = Failed
s.mu.Unlock()
s.log.Fatalf("%v", err)
} | |
c26761 | s.mu.RUnlock()
return s.lastError
} | |
c26762 | s.partitions.shutdown()
}
s.mu.Unlock()
// Make sure the StoreIOLoop returns before closing the Store
if waitForIOStoreLoop {
s.ioChannelWG.Wait()
}
// Close Raft group before closing store.
if s.raft != nil {
if err := s.raft.shutdown(); err != nil {
s.log.Errorf("Failed to stop Raft node: %v", err)
... | |
c26763 | = logtime
s.debug = debug
s.trace = trace
s.lfile = logfile
s.mu.Unlock()
} | |
c26764 | l := s.log
s.mu.RUnlock()
return l
} | |
c26765 | := natsdLogger.NewFileLogger(s.lfile, s.ltime, s.debug, s.trace, true)
s.log = fileLog
s.mu.Unlock()
s.Noticef("File log re-opened")
} | |
c26766 | := s.log.(io.Closer); ok {
return l.Close()
}
return nil
} | |
c26767 | ...interface{}) {
log.Errorf(format, v...)
}, format, v...)
} | |
c26768 | ...interface{}) {
logger.Warnf(format, v...)
}, format, v...)
} | |
c26769 | if size < 0 {
return fmt.Errorf("buffer size value must be a positive number")
}
o.BufferSize = size
return nil
}
} | |
c26770 |
o.CompactEnabled = enabled
return nil
}
} | |
c26771 | fmt.Errorf("compact interval value must at least be 1 seconds")
}
o.CompactInterval = seconds
return nil
}
} | |
c26772 | return fmt.Errorf("compact fragmentation value must at least be 1")
}
o.CompactFragmentation = fragmentation
return nil
}
} | |
c26773 | minimum file size value must be a positive number")
}
o.CompactMinFileSize = fileSize
return nil
}
} | |
c26774 |
o.DoCRC = enableCRC
return nil
}
} | |
c26775 | be positive numbers")
}
o.SliceMaxMsgs = maxMsgs
o.SliceMaxBytes = maxBytes
o.SliceMaxAge = maxAge
o.SliceArchiveScript = script
return nil
}
} | |
c26776 | positive number")
}
o.FileDescriptorsLimit = limit
return nil
}
} | |
c26777 | return fmt.Errorf("parallel recovery value must be at least 1")
}
o.ParallelRecovery = count
return nil
}
} | |
c26778 | opts.SliceMaxBytes, opts.SliceMaxAge, opts.SliceArchiveScript)(o); err != nil {
return err
}
if err := FileDescriptorsLimit(opts.FileDescriptorsLimit)(o); err != nil {
return err
}
if err := ParallelRecovery(opts.ParallelRecovery)(o); err != nil {
return err
}
o.CompactEnabled = opts.CompactEnable... | |
c26779 | return fmt.Errorf("unsupported file version: %v (supports [1..%v])", fv, fileVersion)
}
return nil
} | |
c26780 | = bufio.NewWriterSize(file, w.bufSize)
return w.buf
} | |
c26781 | w.shrinkReq = true
}
// Wait for next tick to see if we can shrink
return w.buf, nil
}
if err := w.buf.Flush(); err != nil {
return w.buf, err
}
// Reduce size, but ensure it does not go below the limit
w.bufSize /= 2
if w.bufSize < w.minShrinkSize {
w.bufSize = w.minShrinkSize
}
w.buf = bufio.NewWri... | |
c26782 | the request.
if percentFilled > bufShrinkThreshold {
w.shrinkReq = false
}
} | |
c26783 | var err error
if fm.limit > 0 && fm.openedFDs >= fm.limit {
fm.closeUnusedFiles(file.id)
}
file.handle, err = openFileWithFlags(file.name, file.flags)
if err == nil {
atomic.StoreInt32(&file.state, fileInUse)
fm.openedFDs++
}
fm.Unlock()
return err
} | |
c26784 | closed but was not locked by caller", file.name))
}
fm.Lock()
err := fm.doClose(file)
fm.Unlock()
return err
} | |
c26785 | fileOpened, fileClosing) {
return nil
}
fm.Lock()
err := fm.doClose(file)
fm.Unlock()
return err
} | |
c26786 | 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
} | |
c26787 | return true, nil
}
return false, fm.openFile(file)
} | |
c26788 | fileInUse to fileOpened for file %q, state=%v",
file.name, file.state))
}
} | |
c26789 | if i%1000 == 1 {
time.Sleep(time.Millisecond)
}
}
if !wasOpened && !wasClosed {
return false, fmt.Errorf("file %q is still probably locked", file.name)
}
return wasOpened, nil
} | |
c26790 | err == nil {
err = sserr
}
} else if wasOpened {
fm.Lock()
if cerr := fm.doClose(file); cerr != nil && err == nil {
err = cerr
}
fm.Unlock()
}
}
return err
} | |
c26791 | is the size of the fileVersion record)
if err := f.Truncate(4); err != nil {
return err
}
// Move offset to 4 (truncate does not do that)
if _, err := f.Seek(4, io.SeekStart); err != nil {
return err
}
// ServerInfo record is not typed. We also don't pass a reusable buffer.
if _, _, err := writeRecord(f, ni... | |
c26792 | {
return nil, err
}
// Add to the map. Note that if one already exists, which should
// not, just replace with this most recent one.
fs.clients[c.ID] = c
case delClient:
c := spb.ClientDelete{}
if err := c.Unmarshal(buf[:recSize]); err != nil {
return nil, err
}
delete(fs.clients, c.I... | |
c26793 | return nil, err
}
// Check that the size of the file is consistent with the size
// of the record we are supposed to recover. Account for the
// 12 bytes (4 + recordHeaderSize) corresponding to the fileVersion and
// record header.
fstat, err := fs.serverFile.handle.Stat()
if err != nil {
return nil, err
}
... | |
c26794 | frag := fs.cliDeleteRecs * 100 / (fs.cliDeleteRecs + len(fs.clients))
if frag < fs.opts.CompactFragmentation {
return false
}
// Check that we don't do too often
if time.Since(fs.cliCompactTS) < fs.compactItvl {
return false
}
return true
} | |
c26795 | temporary file.
if err := tmpFile.Close(); err != nil {
return err
}
// Rename the tmp file to original file name
if err := os.Rename(tmpFile.Name(), orgFileName); err != nil {
return err
}
// Avoid unnecessary attempt to cleanup
tmpFile = nil
fs.cliDeleteRecs = 0
fs.cliFileSize = fileSize
fs.cliCompact... | |
c26796 | if fmerr := fm.close(); fmerr != nil && err == nil {
err = fmerr
}
}
if lockFile != nil {
err = util.CloseFile(err, lockFile)
}
return err
} | |
c26797 | nil && ms.bw.buf.Buffered() > 0 {
if err := ms.bw.buf.Flush(); err != nil {
return err
}
}
if ms.fstore.opts.DoSync {
if err := fslice.file.handle.Sync(); err != nil {
return err
}
}
ms.writer = nil
return nil
}
} | |
c26798 | 0 {
if err := ms.processBufferedMsgs(fslice); err != nil {
return err
}
}
if ms.fstore.opts.DoSync {
if err := fslice.idxFile.handle.Sync(); err != nil {
return err
}
}
return nil
}
} | |
c26799 | if offset == -1 {
ms.wOffset, err = file.Seek(0, io.SeekEnd)
} else {
ms.wOffset = offset
}
return err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.