pi: Cache proposal statuses.

politeiad/backendv2/tstorebe/plugins/pi/cmds.go

@@ -244,63 +244,19 @@ func (p *piPlugin) cmdBillingStatusChanges(token []byte) (string, error) {
 
 // cmdSummary returns the pi summary of a proposal.
 func (p *piPlugin) cmdSummary(token []byte) (string, error) {
-	// Get an abridged version of the record. We only
-	// need the record metadata and the vote metadata.
-	r, err := p.record(backend.RecordRequest{
-		Token:     token,
-		Filenames: []string{ticketvote.FileNameVoteMetadata},
-	})
-	if err != nil {
-		return "", err
-	}
-	var (
-		mdState    = r.RecordMetadata.State
-		mdStatus   = r.RecordMetadata.Status
-		voteStatus = ticketvote.VoteStatusInvalid
-
-		voteMD *ticketvote.VoteMetadata
-		bscs   []pi.BillingStatusChange
-	)
-
-	// Pull the vote metadata out of the record files.
-	voteMD, err = voteMetadataDecode(r.Files)
-	if err != nil {
-		return "", err
-	}
-
-	// Fetch vote status & billing status change if they are needed in order
-	// to determine the proposal status.
-	if mdState == backend.StateVetted {
-		// If proposal status is public fetch vote status.
-		if mdStatus == backend.StatusPublic {
-			vs, err := p.voteSummary(token)
-			if err != nil {
-				return "", err
-			}
-			voteStatus = vs.Status
-			// If vote status is approved fetch billing status change.
-			if voteStatus == ticketvote.VoteStatusApproved {
-				bscs, err = p.billingStatusChanges(token)
-				if err != nil {
-					return "", err
-				}
-			}
-		}
-	}
-
-	// Determine the proposal status
-	proposalStatus, err := proposalStatus(mdState, mdStatus,
-		voteStatus, voteMD, bscs)
+	// Get the proposal status
+	propStatus, err := p.getProposalStatus(token)
 	if err != nil {
 		return "", err
 	}
 
-	// Prepare reply
+	// Prepare the reply
 	sr := pi.SummaryReply{
 		Summary: pi.ProposalSummary{
-			Status: proposalStatus,
+			Status: propStatus,
 		},
 	}
+
 	reply, err := json.Marshal(sr)
 	if err != nil {
 		return "", err

politeiad/backendv2/tstorebe/plugins/pi/cmds_test.go

@@ -241,6 +241,75 @@ func TestCmdBillingStatus(t *testing.T) {
 	}
 }
 
+func TestCmdSummary(t *testing.T) {
+	// Setup pi plugin
+	p, cleanup := newTestPiPlugin(t)
+	defer cleanup()
+
+	// Setup test data
+	var tokens = [6]string{"45154fb45664714b", "45154fb45664714a",
+		"45154fb45664714c", "45154fb45664714d", "45154fb45664714e",
+		"45154fb45664714f"}
+	// List of all final proposal statuses
+	var statuses = [6]pi.PropStatusT{pi.PropStatusUnvettedAbandoned,
+		pi.PropStatusUnvettedCensored, pi.PropStatusAbandoned,
+		pi.PropStatusCensored, pi.PropStatusApproved, pi.PropStatusRejected}
+
+	// Setup tests and pre-load final statuses in cache
+	type test struct {
+		name       string // Test name
+		token      []byte
+		propStatus pi.PropStatusT // expected proposal status
+	}
+	var tests [6]test
+
+	for i, token := range tokens {
+		// Decode string token
+		b, err := hex.DecodeString(token)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// Cache final status
+		p.statuses.set(token, statusEntry{
+			propStatus: statuses[i],
+		})
+
+		// Add test
+		tests[i] = test{
+			name:       string(statuses[i]),
+			token:      b,
+			propStatus: statuses[i],
+		}
+	}
+
+	// Run tests
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			// Run test
+			r, err := p.cmdSummary(tc.token)
+			if err != nil {
+				// Unexpected error
+				t.Fatal(err)
+			}
+
+			// Unmarshal command reply
+			var sr pi.SummaryReply
+			err = json.Unmarshal([]byte(r), &sr)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// Check if received proposal status euqal to the expected.
+			if sr.Summary.Status != tc.propStatus {
+				t.Errorf("want proposal status %v, got '%v'", tc.propStatus,
+					sr.Summary.Status)
+			}
+		})
+	}
+
+}
+
 func TestProposalStatus(t *testing.T) {
 	// Setup tests
 	var tests = []struct {

politeiad/backendv2/tstorebe/plugins/pi/pi.go

@@ -5,6 +5,7 @@
 package pi
 
 import (
+	"container/list"
 	"encoding/json"
 	"os"
 	"path/filepath"
@@ -32,6 +33,10 @@ type piPlugin struct {
 	backend backend.Backend
 	tstore  plugins.TstoreClient
 
+	// statuses holds proposal statuses in memory to avoid extra expensive
+	// tlog tree reads in runtime.
+	statuses proposalStatuses
+
 	// dataDir is the pi plugin data directory. The only data that is
 	// stored here is cached data that can be re-created at any time
 	// by walking the trillian trees.
@@ -339,5 +344,10 @@ func New(backend backend.Backend, tstore plugins.TstoreClient, settings []backen
 		proposalDomainsEncoded:  domainsString,
 		proposalDomains:         domainsMap,
 		billingStatusChangesMax: billingStatusChangesMax,
+		statuses: proposalStatuses{
+			data:    make(map[string]*statusEntry, defaultCacheLimit),
+			entries: list.New(),
+			limit:   defaultCacheLimit,
+		},
 	}, nil
 }

politeiad/backendv2/tstorebe/plugins/pi/proposalstatus.go

@@ -0,0 +1,189 @@
+// Copyright (c) 2021 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package pi
+
+import (
+	"encoding/hex"
+
+	backend "github.com/decred/politeia/politeiad/backendv2"
+	"github.com/decred/politeia/politeiad/plugins/pi"
+	"github.com/decred/politeia/politeiad/plugins/ticketvote"
+)
+
+// getProposalStatus determines the proposal status in runtime, it uses the
+// in-memory cache to avoid retrieving the record, it's vote summary or
+// it's billing status changes when possible.
+func (p *piPlugin) getProposalStatus(token []byte) (pi.PropStatusT, error) {
+	var (
+		propStatus pi.PropStatusT
+		err        error
+		tokenStr   = hex.EncodeToString(token)
+
+		// The following fields are required to determine the proposal status and
+		// MUST be populated.
+		recordState  backend.StateT
+		recordStatus backend.StatusT
+		voteStatus   ticketvote.VoteStatusT
+
+		// The following fields are required to determine the proposal status and
+		// will only be populated for certain types of proposals or during certain
+		// stages of the proposal lifecycle.
+		voteMetadata    *ticketvote.VoteMetadata
+		billingStatuses []pi.BillingStatusChange
+	)
+
+	// Check if the proposal status has been cached
+	e := p.statuses.get(tokenStr)
+	if e != nil {
+		propStatus = e.propStatus
+		recordState = e.recordState
+		recordStatus = e.recordStatus
+		voteStatus = e.voteStatus
+		voteMetadata = e.voteMetadata
+	}
+
+	// Check if we need to get any additional data
+	if statusIsFinal(propStatus) {
+		// The status is final and cannot be changed.
+		// No need to get any additional data.
+		return propStatus, nil
+	}
+
+	// Get the record if required
+	if statusRequiresRecord(propStatus) {
+		r, err := p.record(backend.RecordRequest{
+			Token:     token,
+			Filenames: []string{ticketvote.FileNameVoteMetadata},
+		})
+		if err != nil {
+			return "", err
+		}
+
+		// Update the record data fields required to
+		// determine the proposal status.
+		recordState = r.RecordMetadata.State
+		recordStatus = r.RecordMetadata.Status
+		voteStatus = ticketvote.VoteStatusInvalid
+
+		// Pull the vote metadata out of the record files
+		voteMetadata, err = voteMetadataDecode(r.Files)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	// Get the vote summary if required
+	if statusRequiresVoteSummary(propStatus) {
+		vs, err := p.voteSummary(token)
+		if err != nil {
+			return "", err
+		}
+		voteStatus = vs.Status
+	}
+
+	// Get the billing statuses if required
+	if statusRequiresBillingStatuses(voteStatus, voteMetadata) {
+		billingStatuses, err = p.billingStatusChanges(token)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	// Determine the proposal status
+	propStatus, err = proposalStatus(recordState, recordStatus, voteStatus,
+		voteMetadata, billingStatuses)
+	if err != nil {
+		return "", nil
+	}
+
+	// Cache the results
+	p.statuses.set(tokenStr, statusEntry{
+		propStatus:   propStatus,
+		recordState:  recordState,
+		recordStatus: recordStatus,
+		voteStatus:   voteStatus,
+		voteMetadata: voteMetadata,
+	})
+
+	return propStatus, nil
+}
+
+// statusIsFinal returns whether the proposal status is a final status and
+// cannot be changed any further.
+func statusIsFinal(s pi.PropStatusT) bool {
+	switch s {
+	case pi.PropStatusUnvettedAbandoned, pi.PropStatusUnvettedCensored,
+		pi.PropStatusAbandoned, pi.PropStatusCensored, pi.PropStatusApproved,
+		pi.PropStatusRejected:
+		return true
+	default:
+		return false
+	}
+}
+
+// statusRequiresRecord returns whether the proposal status requires the record
+// to be retrieved from the backend. This is necessary when the proposal is in
+// a part of the proposal lifecycle that still allows changes to the underlying
+// record data. For example, an unvetted proposal may still have it's record
+// metadata or vote metadata altered, but a proposal with the status of active
+// cannot.
+func statusRequiresRecord(s pi.PropStatusT) bool {
+	if statusIsFinal(s) {
+		// The status is final and cannot be changed
+		// any further, which means the record data
+		// is not required.
+		return false
+	}
+
+	switch s {
+	case pi.PropStatusVoteStarted, pi.PropStatusActive,
+		pi.PropStatusCompleted, pi.PropStatusClosed:
+		// The record cannot be changed any further for
+		// these statuses.
+		return false
+
+	case pi.PropStatusUnvetted, pi.PropStatusUnderReview,
+		pi.PropStatusVoteAuthorized:
+		// The record can still change for these statuses.
+		return true
+
+	default:
+		// Defaulting to true is the conservative default
+		// since it will force the record to be retrieved
+		// for unhandled cases.
+		return true
+	}
+}
+
+// statusRequiresVoteSummary returns whether the proposal status requires the
+// vote summary to be retrieved. This is necessary when the proposal is in
+// a stage where the vote status can still change.
+func statusRequiresVoteSummary(s pi.PropStatusT) bool {
+	if statusIsFinal(s) {
+		// The status is final and cannot be changed
+		// any further, which means the vote summary
+		// is not required.
+		return false
+	}
+
+	switch s {
+	case pi.PropStatusActive, pi.PropStatusClosed, pi.PropStatusCompleted:
+		// The vote result is known no need to fetch
+		return false
+
+	default:
+		// If proposal status is unknown, not final or vote was not finished yet,
+		// we need to fetch the vote summary.
+		return true
+	}
+}
+
+// statusRequiresBillingStatuses returns whether the proposal status requires
+// the billing status changes to be retrieved. The billing status
+// changes are required only if the proposal is not a RFP and it's vote was
+// approved, otherwise they are not relevant.
+func statusRequiresBillingStatuses(vs ticketvote.VoteStatusT, vm *ticketvote.VoteMetadata) bool {
+	return !isRFP(vm) && vs == ticketvote.VoteStatusApproved
+}