mirror of
https://github.com/hanzoai/tasks.git
synced 2026-10-04 02:04:03 +00:00
Alex ShtinandGitHub
8e8f1b0f7c
## What changed?
<!-- Describe what has changed in this PR -->
Remove license header from every file. Because it is really hard to
follow in this PR here is the summary:
1. License header is removed from all `.go` and `.proto` files
:fireworks::fireworks:🎆.
2. `LICENSE` file in the root directory has only Temporal and Uber
copyrights.
3. 5 other `LICENSE` files added to the packages which have copyrights
different from Temporal and Uber: Datadog, Xargin, "Mat Ryer, Tyler
Bunnell and contributors".
4. `license_file` flag is removed from all code generation tools.
5. `copyright_file` flag is removed from `go:generate mockgen`
directive.
6. All copyright related targets are removed from `Makefile`.
7. Updated Temporal copyright year to 2025 everywhere.
## Why?
<!-- Tell your future self why have you made these changes -->
I double checked with legal department that it is not needed to have
license header in every file. One file per repo is enough. I put all
copyrights to the root `LICENSE` file and removed header from all other
files. Also updated tools and `Makefile`.
131 lines
3.4 KiB
Go
131 lines
3.4 KiB
Go
package persistence
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
|
|
"go.temporal.io/api/serviceerror"
|
|
persistencespb "go.temporal.io/server/api/persistence/v1"
|
|
"go.temporal.io/server/common"
|
|
)
|
|
|
|
type (
|
|
historyNodeMetadata struct {
|
|
branchInfo *persistencespb.HistoryBranch
|
|
|
|
nodeID int64
|
|
transactionID int64
|
|
prevTransactionID int64
|
|
}
|
|
)
|
|
|
|
func validateNodeChainAndTrim(
|
|
tailNodeID int64,
|
|
tailTransactionID int64,
|
|
transactionIDToNode map[int64]historyNodeMetadata,
|
|
) ([]historyNodeMetadata, error) {
|
|
|
|
nodeIDToNodes := indexNodeIDToNode(transactionIDToNode)
|
|
|
|
nodeChain, err := reverselyLinkNode(
|
|
tailNodeID,
|
|
tailTransactionID,
|
|
transactionIDToNode,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
nodesToTrim := trimNodes(nodeIDToNodes, nodeChain)
|
|
return nodesToTrim, nil
|
|
}
|
|
|
|
func indexNodeIDToNode(
|
|
transactionIDToNode map[int64]historyNodeMetadata,
|
|
) map[int64][]historyNodeMetadata {
|
|
// indexing node ID -> sorted nodeMetadata by transaction ID from high to low
|
|
nodeIDToNodes := make(map[int64][]historyNodeMetadata)
|
|
for _, node := range transactionIDToNode {
|
|
nodeMetadata := nodeIDToNodes[node.nodeID]
|
|
nodeMetadata = append(nodeMetadata, node)
|
|
nodeIDToNodes[node.nodeID] = nodeMetadata
|
|
}
|
|
for nodeID := range nodeIDToNodes {
|
|
nodes := nodeIDToNodes[nodeID]
|
|
// reverse sort by transaction ID
|
|
sort.Slice(nodes, func(i, j int) bool {
|
|
return nodes[i].transactionID > nodes[j].transactionID
|
|
})
|
|
nodeIDToNodes[nodeID] = nodes
|
|
}
|
|
return nodeIDToNodes
|
|
}
|
|
|
|
func reverselyLinkNode(
|
|
tailNodeID int64,
|
|
tailTransactionID int64,
|
|
transactionIDToNode map[int64]historyNodeMetadata,
|
|
) ([]historyNodeMetadata, error) {
|
|
// from tail node, trace back
|
|
transactionID := tailTransactionID
|
|
node, ok := transactionIDToNode[transactionID]
|
|
// sanity check node ID <-> transaction ID being unique
|
|
if !ok || node.nodeID != tailNodeID {
|
|
return nil, serviceerror.NewInternal(
|
|
fmt.Sprintf("unable to find or verify the tail history node, node ID: %v, transaction ID: %v",
|
|
tailNodeID,
|
|
tailTransactionID,
|
|
),
|
|
)
|
|
}
|
|
|
|
var nodes []historyNodeMetadata
|
|
nodes = append(nodes, node)
|
|
for node.nodeID > common.FirstEventID {
|
|
if prevNode, ok := transactionIDToNode[node.prevTransactionID]; !ok {
|
|
return nil, serviceerror.NewInternal(
|
|
fmt.Sprintf("unable to back trace history node, node ID: %v, transaction ID: %v, prev transaction ID: %v",
|
|
node.nodeID,
|
|
node.transactionID,
|
|
node.prevTransactionID,
|
|
),
|
|
)
|
|
} else {
|
|
node = prevNode
|
|
nodes = append(nodes, node)
|
|
}
|
|
}
|
|
|
|
// now node should be the first node
|
|
// node.nodeID == common.FirstEventID
|
|
// node.prevTransactionID == 0
|
|
if node.nodeID != common.FirstEventID || node.prevTransactionID != 0 {
|
|
return nil, serviceerror.NewInternal(
|
|
fmt.Sprintf("unable to back trace history node, node ID: %v, transaction ID: %v, prev transaction ID: %v",
|
|
node.nodeID,
|
|
node.transactionID,
|
|
node.prevTransactionID,
|
|
),
|
|
)
|
|
}
|
|
|
|
return nodes, nil
|
|
}
|
|
|
|
func trimNodes(
|
|
nodeIDToNodes map[int64][]historyNodeMetadata,
|
|
nodeChain []historyNodeMetadata,
|
|
) []historyNodeMetadata {
|
|
var nodesToTrim []historyNodeMetadata
|
|
// for each node on the chain, validate that the transaction ID being the largest
|
|
for _, validNode := range nodeChain {
|
|
for _, node := range nodeIDToNodes[validNode.nodeID] {
|
|
if node.transactionID <= validNode.transactionID {
|
|
break
|
|
}
|
|
nodesToTrim = append(nodesToTrim, node)
|
|
}
|
|
}
|
|
return nodesToTrim
|
|
}
|