135 lines
4.5 KiB
Go
135 lines
4.5 KiB
Go
// Licensed to the Apache Software Foundation (ASF) under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The ASF licenses this file
|
|
// to you under the Apache License, Version 2.0 (the
|
|
// "License"); you may not use this file except in compliance
|
|
// with the License. You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing,
|
|
// software distributed under the License is distributed on an
|
|
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations
|
|
// under the License.
|
|
|
|
package casbin
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"github.com/casbin/casbin/v3/model"
|
|
"github.com/casbin/casbin/v3/persist"
|
|
)
|
|
|
|
// TransactionBuffer holds all policy changes made within a transaction.
|
|
// It maintains a list of operations and a snapshot of the model state
|
|
// at the beginning of the transaction.
|
|
type TransactionBuffer struct {
|
|
operations []persist.PolicyOperation // Buffered operations
|
|
modelSnapshot model.Model // Model state at transaction start
|
|
mutex sync.RWMutex // Protects concurrent access
|
|
}
|
|
|
|
// NewTransactionBuffer creates a new transaction buffer with a model snapshot.
|
|
// The snapshot represents the state of the model at the beginning of the transaction.
|
|
func NewTransactionBuffer(baseModel model.Model) *TransactionBuffer {
|
|
return &TransactionBuffer{
|
|
operations: make([]persist.PolicyOperation, 0),
|
|
modelSnapshot: baseModel.Copy(),
|
|
}
|
|
}
|
|
|
|
// AddOperation adds a policy operation to the buffer.
|
|
// This operation will be applied when the transaction is committed.
|
|
func (tb *TransactionBuffer) AddOperation(op persist.PolicyOperation) {
|
|
tb.mutex.Lock()
|
|
defer tb.mutex.Unlock()
|
|
tb.operations = append(tb.operations, op)
|
|
}
|
|
|
|
// GetOperations returns all buffered operations.
|
|
// Returns a copy to prevent external modifications.
|
|
func (tb *TransactionBuffer) GetOperations() []persist.PolicyOperation {
|
|
tb.mutex.RLock()
|
|
defer tb.mutex.RUnlock()
|
|
|
|
// Return a copy to prevent external modifications.
|
|
result := make([]persist.PolicyOperation, len(tb.operations))
|
|
copy(result, tb.operations)
|
|
return result
|
|
}
|
|
|
|
// Clear removes all buffered operations.
|
|
// This is typically called after a successful commit or rollback.
|
|
func (tb *TransactionBuffer) Clear() {
|
|
tb.mutex.Lock()
|
|
defer tb.mutex.Unlock()
|
|
tb.operations = tb.operations[:0]
|
|
}
|
|
|
|
// GetModelSnapshot returns the model snapshot taken at transaction start.
|
|
// This represents the original state before any transaction operations.
|
|
func (tb *TransactionBuffer) GetModelSnapshot() model.Model {
|
|
tb.mutex.RLock()
|
|
defer tb.mutex.RUnlock()
|
|
return tb.modelSnapshot.Copy()
|
|
}
|
|
|
|
// ApplyOperationsToModel applies all buffered operations to a model and returns the result.
|
|
// This simulates what the model would look like after all operations are applied.
|
|
// It's used for validation and preview purposes within the transaction.
|
|
func (tb *TransactionBuffer) ApplyOperationsToModel(baseModel model.Model) (model.Model, error) {
|
|
tb.mutex.RLock()
|
|
defer tb.mutex.RUnlock()
|
|
|
|
resultModel := baseModel.Copy()
|
|
|
|
for _, op := range tb.operations {
|
|
switch op.Type {
|
|
case persist.OperationAdd:
|
|
for _, rule := range op.Rules {
|
|
if err := resultModel.AddPolicy(op.Section, op.PolicyType, rule); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
case persist.OperationRemove:
|
|
for _, rule := range op.Rules {
|
|
if _, err := resultModel.RemovePolicy(op.Section, op.PolicyType, rule); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
case persist.OperationUpdate:
|
|
// For update operations, remove old rules and add new ones.
|
|
for i, oldRule := range op.OldRules {
|
|
if i < len(op.Rules) {
|
|
if _, err := resultModel.RemovePolicy(op.Section, op.PolicyType, oldRule); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := resultModel.AddPolicy(op.Section, op.PolicyType, op.Rules[i]); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return resultModel, nil
|
|
}
|
|
|
|
// HasOperations returns true if there are any buffered operations.
|
|
func (tb *TransactionBuffer) HasOperations() bool {
|
|
tb.mutex.RLock()
|
|
defer tb.mutex.RUnlock()
|
|
return len(tb.operations) > 0
|
|
}
|
|
|
|
// OperationCount returns the number of buffered operations.
|
|
func (tb *TransactionBuffer) OperationCount() int {
|
|
tb.mutex.RLock()
|
|
defer tb.mutex.RUnlock()
|
|
return len(tb.operations)
|
|
}
|