PR(ADHERE): Code review - remove code duplication & init

Author: shahzadlone

acp/aac/aac.go

@@ -12,240 +12,28 @@ package aac
 
 import (
 	"context"
-	"os"
-
-	protoTypes "github.com/cosmos/gogoproto/types"
-	"github.com/sourcenetwork/acp_core/pkg/auth"
-	acpErrors "github.com/sourcenetwork/acp_core/pkg/errors"
-	"github.com/sourcenetwork/acp_core/pkg/runtime"
-	"github.com/sourcenetwork/acp_core/pkg/services"
-	"github.com/sourcenetwork/acp_core/pkg/types"
-	"github.com/sourcenetwork/immutable"
 
 	"github.com/sourcenetwork/defradb/acp"
-	"github.com/sourcenetwork/defradb/acp/identity"
+	"github.com/sourcenetwork/defradb/acp/local"
 	acpTypes "github.com/sourcenetwork/defradb/acp/types"
-	"github.com/sourcenetwork/defradb/errors"
 )
 
-const adminACPStoreName = "admin_acp"
-
-// AdminACP represents a admin acp (local to the node) implementation that makes no remote calls.
-type AdminACP struct {
-	pathToStore immutable.Option[string]
-	engine      types.ACPEngineServer
-	manager     runtime.RuntimeManager
-	closed      bool
-}
-
-func NewAdminACP() AdminACP {
-	return AdminACP{}
-}
+const localStoreName = "local_admin_acp"
 
 var _ acp.ACPSystemClient = (*AdminACP)(nil)
 
-func (a *AdminACP) Init(ctx context.Context, path string) {
-	if path == "" {
-		a.pathToStore = immutable.None[string]()
-	} else {
-		a.pathToStore = immutable.Some(path)
-	}
-}
-
-func (a *AdminACP) Start(ctx context.Context) error {
-	var manager runtime.RuntimeManager
-	var err error
-	var opts []runtime.Opt
-	var storeLocation string
-
-	a.closed = false
-	if !a.pathToStore.HasValue() { // Use a non-persistent, i.e. in memory store.
-		storeLocation = "in-memory"
-		opts = append(opts, runtime.WithMemKV())
-	} else { // Use peristent storage.
-		storeLocation = a.pathToStore.Value()
-		acpStorePath := storeLocation + "/" + adminACPStoreName
-		opts = append(opts, runtime.WithPersistentKV(acpStorePath))
-	}
-
-	manager, err = runtime.NewRuntimeManager(opts...)
-	if err != nil {
-		return acp.NewErrInitializationOfACPFailed(err, "Admin", storeLocation)
-	}
-
-	a.manager = manager
-	a.engine = services.NewACPEngine(manager)
-	return nil
-}
-
-func (a *AdminACP) Close() error {
-	if !a.closed {
-		if a.manager != nil {
-			err := a.manager.Terminate()
-			if err != nil {
-				return err
-			}
-		}
-		a.closed = true
-	}
-	return nil
-}
-
-func (a *AdminACP) ResetState(ctx context.Context) error {
-	err := a.Close()
-	if err != nil {
-		return err
-	}
-
-	// delete state (applicable to persistent store)
-	if a.pathToStore.HasValue() {
-		storeLocation := a.pathToStore.Value()
-		path := storeLocation + "/" + adminACPStoreName
-		info, err := os.Stat(path)
-		if os.IsNotExist(err) {
-			return errors.Join(acp.ErrACPResetState, err)
-		} else if err != nil {
-			return errors.Join(acp.ErrACPResetState, err)
-		}
-
-		if info.IsDir() {
-			// remove dir
-			if err := os.RemoveAll(path); err != nil {
-				return errors.Join(acp.ErrACPResetState, err)
-			}
-		} else {
-			// remove file
-			if err := os.Remove(path); err != nil {
-				return errors.Join(acp.ErrACPResetState, err)
-			}
-		}
-	}
-
-	// Start again
-	return a.Start(ctx)
-}
-
-func (a *AdminACP) AddPolicy(
-	ctx context.Context,
-	creator identity.Identity,
-	policy string,
-	marshalType acpTypes.PolicyMarshalType,
-	creationTime *protoTypes.Timestamp,
-) (string, error) {
-	principal, err := types.NewDIDPrincipal(creator.DID())
-	if err != nil {
-		return "", acp.NewErrInvalidActorID(err, creator.DID())
-	}
-	ctx = auth.InjectPrincipal(ctx, principal)
-
-	createPolicy := types.CreatePolicyRequest{
-		Policy:      policy,
-		MarshalType: types.PolicyMarshalingType(marshalType),
-	}
-
-	response, err := a.engine.CreatePolicy(ctx, &createPolicy)
-	if err != nil {
-		return "", err
-	}
-
-	return response.Record.Policy.Id, nil
-}
-
-func (a *AdminACP) Policy(
-	ctx context.Context,
-	policyID string,
-) (immutable.Option[acpTypes.Policy], error) {
-	none := immutable.None[acpTypes.Policy]()
-
-	request := types.GetPolicyRequest{Id: policyID}
-	response, err := a.engine.GetPolicy(ctx, &request)
-	if err != nil {
-		if errors.Is(err, acpErrors.ErrorType_NOT_FOUND) {
-			return none, nil
-		}
-		return none, err
-	}
-
-	policy := acpTypes.MapACPCorePolicy(response.Record.Policy)
-	return immutable.Some(policy), nil
-}
-
-func (a *AdminACP) RegisterObject(
-	ctx context.Context,
-	identity identity.Identity,
-	policyID string,
-	resourceName string,
-	objectID string,
-	creationTime *protoTypes.Timestamp,
-) error {
-	principal, err := types.NewDIDPrincipal(identity.DID())
-	if err != nil {
-		return acp.NewErrInvalidActorID(err, identity.DID())
-	}
-
-	ctx = auth.InjectPrincipal(ctx, principal)
-	req := types.RegisterObjectRequest{
-		PolicyId: policyID,
-		Object:   types.NewObject(resourceName, objectID),
-	}
-
-	_, err = a.engine.RegisterObject(ctx, &req)
-	return err
-}
-
-func (a *AdminACP) ObjectOwner(
-	ctx context.Context,
-	policyID string,
-	resourceName string,
-	objectID string,
-) (immutable.Option[string], error) {
-	none := immutable.None[string]()
-
-	req := types.GetObjectRegistrationRequest{
-		PolicyId: policyID,
-		Object:   types.NewObject(resourceName, objectID),
-	}
-	result, err := a.engine.GetObjectRegistration(ctx, &req)
-	if err != nil {
-		return none, err
-	}
-
-	if result.IsRegistered {
-		return immutable.Some(result.OwnerId), nil
-	}
-
-	return none, nil
+// AdminACP represents a admin acp (local to the node) implementation that makes no remote calls.
+type AdminACP struct {
+	*local.LocalACP
 }
 
-func (a *AdminACP) VerifyAccessRequest(
-	ctx context.Context,
-	permission acpTypes.ResourceInterfacePermission,
-	actorID string,
-	policyID string,
-	resourceName string,
-	objectID string,
-) (bool, error) {
-	req := types.VerifyAccessRequestRequest{
-		PolicyId: policyID,
-		AccessRequest: &types.AccessRequest{
-			Operations: []*types.Operation{
-				{
-					Object:     types.NewObject(resourceName, objectID),
-					Permission: permission.String(),
-				},
-			},
-			Actor: &types.Actor{
-				Id: actorID,
-			},
-		},
-	}
-	resp, err := a.engine.VerifyAccessRequest(ctx, &req)
-
+func NewAdminACP(pathToStore string) (AdminACP, error) {
+	localACP, err := local.NewLocalACP(pathToStore, localStoreName)
 	if err != nil {
-		return false, err
+		return AdminACP{}, err
 	}
 
-	return resp.Valid, nil
+	return AdminACP{LocalACP: localACP}, nil
 }
 
 func (a *AdminACP) ValidateResourceInterface(
@@ -261,95 +49,3 @@ func (a *AdminACP) ValidateResourceInterface(
 		a,
 	)
 }
-
-func (a *AdminACP) AddActorRelationship(
-	ctx context.Context,
-	policyID string,
-	resourceName string,
-	objectID string,
-	relation string,
-	requester identity.Identity,
-	targetActor string,
-	creationTime *protoTypes.Timestamp,
-) (bool, error) {
-	principal, err := types.NewDIDPrincipal(requester.DID())
-	if err != nil {
-		return false, acp.NewErrInvalidActorID(err, requester.DID())
-	}
-
-	ctx = auth.InjectPrincipal(ctx, principal)
-
-	var newActorRelationship *types.Relationship
-	if targetActor == "*" {
-		newActorRelationship = types.NewAllActorsRelationship(
-			resourceName,
-			objectID,
-			relation,
-		)
-	} else {
-		newActorRelationship = types.NewActorRelationship(
-			resourceName,
-			objectID,
-			relation,
-			targetActor,
-		)
-	}
-
-	setRelationshipRequest := types.SetRelationshipRequest{
-		PolicyId:     policyID,
-		Relationship: newActorRelationship,
-	}
-
-	setRelationshipResponse, err := a.engine.SetRelationship(ctx, &setRelationshipRequest)
-	if err != nil {
-		return false, err
-	}
-
-	return setRelationshipResponse.GetRecordExisted(), nil
-}
-
-func (a *AdminACP) DeleteActorRelationship(
-	ctx context.Context,
-	policyID string,
-	resourceName string,
-	objectID string,
-	relation string,
-	requester identity.Identity,
-	targetActor string,
-	creationTime *protoTypes.Timestamp,
-) (bool, error) {
-	principal, err := types.NewDIDPrincipal(requester.DID())
-	if err != nil {
-		return false, acp.NewErrInvalidActorID(err, requester.DID())
-	}
-
-	ctx = auth.InjectPrincipal(ctx, principal)
-
-	var newActorRelationship *types.Relationship
-	if targetActor == "*" {
-		newActorRelationship = types.NewAllActorsRelationship(
-			resourceName,
-			objectID,
-			relation,
-		)
-	} else {
-		newActorRelationship = types.NewActorRelationship(
-			resourceName,
-			objectID,
-			relation,
-			targetActor,
-		)
-	}
-
-	deleteRelationshipRequest := types.DeleteRelationshipRequest{
-		PolicyId:     policyID,
-		Relationship: newActorRelationship,
-	}
-
-	deleteRelationshipResponse, err := a.engine.DeleteRelationship(ctx, &deleteRelationshipRequest)
-	if err != nil {
-		return false, err
-	}
-
-	return deleteRelationshipResponse.GetRecordFound(), nil
-}

acp/acp.go

@@ -23,14 +23,8 @@ import (
 
 // ACPSystemClient is an abstraction to allow multiple types of ACP systems to share DefraDB specific logic.
 type ACPSystemClient interface {
-	// Init initializes the acp, with an absolute path. The provided path indicates where the
-	// persistent data will be stored for that ACP system.
-	//
-	// If the path is empty then acp will run in memory.
-	Init(ctx context.Context, path string)
-
-	// Start starts the acp, using the initialized path. Will recover acp state
-	// from a previous run if under the same path.
+	// Start starts the acp, using the configured path. Will recover acp state
+	// from a previous run if under the same persistent path.
 	//
 	// If the path is empty then acp will run in memory.
 	Start(ctx context.Context) error

acp/dac/bridge.go

@@ -34,10 +34,6 @@ type bridgeDocumentACP struct {
 	clientACP acp.ACPSystemClient
 }
 
-func (a *bridgeDocumentACP) Init(ctx context.Context, path string) {
-	a.clientACP.Init(ctx, path)
-}
-
 func (a *bridgeDocumentACP) Start(ctx context.Context) error {
 	return a.clientACP.Start(ctx)
 }

acp/dac/dac.go

@@ -29,12 +29,6 @@ var (
 
 // DocumentACP is the interface to all types of document access control that might exist.
 type DocumentACP interface {
-	// Init initializes the acp, with an absolute path. The provided path indicates where the
-	// persistent data will be stored for acp.
-	//
-	// If the path is empty then acp will run in memory.
-	Init(ctx context.Context, path string)
-
 	// Start starts the acp, using the initialized path. Will recover acp state
 	// from a previous run if under the same path.
 	//