14831306943

Committed 05 May 2025 07:29AM UTC coverage: 56.912% (+0.006%) from 56.906%

Build # 14831306943

Build Type

Pull #5621

github

Committed by

web-flow

Commit Message

Merge 9a09bd468 into 416b6047a

Pull Request Pull Request #5621: build(deps): bump github.com/open-policy-agent/opa from 1.2.0 to 1.4.2

Run Details

18369 of 32276 relevant lines covered (56.91%)

36.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/internal/controlplane/handlers_entity_instances.go

// SPDX-FileCopyrightText: Copyright 2024 The Minder Authors
// SPDX-License-Identifier: Apache-2.0

package controlplane

import (
        "context"
        "database/sql"
        "errors"
        "fmt"

        "github.com/google/uuid"
        "google.golang.org/grpc/codes"

        "github.com/mindersec/minder/internal/engine/engcontext"
        "github.com/mindersec/minder/internal/logger"
        "github.com/mindersec/minder/internal/util"
        pb "github.com/mindersec/minder/pkg/api/protobuf/go/minder/v1"
)

// ListEntities returns a list of entity instances for a given project and provider
func (s *Server) ListEntities(
        ctx context.Context,
        in *pb.ListEntitiesRequest,
) (*pb.ListEntitiesResponse, error) {
        entityCtx := engcontext.EntityFromContext(ctx)
        projectID := entityCtx.Project.ID
        providerName := entityCtx.Provider.Name

        logger.BusinessRecord(ctx).Provider = providerName
        logger.BusinessRecord(ctx).Project = projectID

        // Get provider ID from name
        provider, err := s.providerStore.GetByName(ctx, projectID, providerName)
        if err != nil {
                if errors.Is(err, sql.ErrNoRows) {
                        return nil, util.UserVisibleError(codes.NotFound, "provider not found")
                }
                return nil, fmt.Errorf("error getting provider: %w", err)
        }

        // Get entity type from request
        entityType := in.GetEntityType()
        if entityType == pb.Entity_ENTITY_UNSPECIFIED {
                return nil, util.UserVisibleError(codes.InvalidArgument, "entity type must be specified")
        }

        // Get limit from request
        limit := in.GetCursor().GetSize()
        if limit == 0 {
                limit = 20 // Default limit
        }

        // Get cursor from request
        cursor := in.GetCursor().GetCursor()

        // Call service to get entities
        outentities, nextCursor, err := s.entityService.ListEntities(
                ctx,
                projectID,
                provider.ID,
                entityType,
                cursor,
                int64(limit),
        )
        if err != nil {
                return nil, err
        }

        // Create response
        resp := &pb.ListEntitiesResponse{
                Results: outentities,
                Page: &pb.CursorPage{
                        Next: &pb.Cursor{
                                Cursor: nextCursor,
                                Size:   limit,
                        },
                },
        }

        return resp, nil
}

// GetEntityById returns an entity instance for a given entity ID
func (s *Server) GetEntityById(
        ctx context.Context,
        in *pb.GetEntityByIdRequest,
) (*pb.GetEntityByIdResponse, error) {
        // Parse entity ID
        entityID, err := uuid.Parse(in.GetId())
        if err != nil {
                return nil, util.UserVisibleError(codes.InvalidArgument, "invalid entity ID")
        }

        projectID := GetProjectID(ctx)

        // Call service to get entity
        entity, err := s.entityService.GetEntityByID(ctx, entityID, projectID)
        if err != nil {
                return nil, err
        }

        // Telemetry logging
        logger.BusinessRecord(ctx).Project = projectID
        logger.BusinessRecord(ctx).Entity = entityID

        return &pb.GetEntityByIdResponse{
                Entity: entity,
        }, nil
}

// GetEntityByName returns an entity instance for a given entity name
func (s *Server) GetEntityByName(
        ctx context.Context,
        in *pb.GetEntityByNameRequest,
) (*pb.GetEntityByNameResponse, error) {
        entityCtx := engcontext.EntityFromContext(ctx)
        projectID := entityCtx.Project.ID
        providerName := entityCtx.Provider.Name

        // Get provider ID from name
        provider, err := s.providerStore.GetByName(ctx, projectID, providerName)
        if err != nil {
                if errors.Is(err, sql.ErrNoRows) {
                        return nil, util.UserVisibleError(codes.NotFound, "provider not found")
                }
                return nil, fmt.Errorf("error getting provider: %w", err)
        }

        // Get entity type from request
        entityType := in.GetEntityType()
        if entityType == pb.Entity_ENTITY_UNSPECIFIED {
                return nil, util.UserVisibleError(codes.InvalidArgument, "entity type must be specified")
        }

        // Call service to get entity
        entity, err := s.entityService.GetEntityByName(
                ctx,
                in.GetName(),
                projectID,
                provider.ID,
                entityType,
        )
        if err != nil {
                return nil, err
        }

        // Telemetry logging
        logger.BusinessRecord(ctx).Provider = providerName
        logger.BusinessRecord(ctx).Project = projectID

        return &pb.GetEntityByNameResponse{
                Entity: entity,
        }, nil
}

// DeleteEntityById deletes an entity instance for a given entity ID
func (s *Server) DeleteEntityById(
        ctx context.Context,
        in *pb.DeleteEntityByIdRequest,
) (*pb.DeleteEntityByIdResponse, error) {
        // Parse entity ID
        entityID, err := uuid.Parse(in.GetId())
        if err != nil {
                return nil, util.UserVisibleError(codes.InvalidArgument, "invalid entity ID")
        }

        projectID := GetProjectID(ctx)

        // Call service to delete entity
        err = s.entityService.DeleteEntityByID(ctx, entityID, projectID)
        if err != nil {
                return nil, err
        }

        // Telemetry logging
        logger.BusinessRecord(ctx).Project = projectID
        logger.BusinessRecord(ctx).Entity = entityID

        return &pb.DeleteEntityByIdResponse{
                Id: in.GetId(),
        }, nil
}

1	// SPDX-FileCopyrightText: Copyright 2024 The Minder Authors
2	// SPDX-License-Identifier: Apache-2.0
3
4	package controlplane
5
6	import (
7	"context"
8	"database/sql"
9	"errors"
10	"fmt"
11
12	"github.com/google/uuid"
13	"google.golang.org/grpc/codes"
14
15	"github.com/mindersec/minder/internal/engine/engcontext"
16	"github.com/mindersec/minder/internal/logger"
17	"github.com/mindersec/minder/internal/util"
18	pb "github.com/mindersec/minder/pkg/api/protobuf/go/minder/v1"
19	)
20
21	// ListEntities returns a list of entity instances for a given project and provider
22	func (s *Server) ListEntities(
23	ctx context.Context,
24	in *pb.ListEntitiesRequest,
25	) (*pb.ListEntitiesResponse, error) {	×
26	entityCtx := engcontext.EntityFromContext(ctx)	×
27	projectID := entityCtx.Project.ID	×
28	providerName := entityCtx.Provider.Name	×
29		×
30	logger.BusinessRecord(ctx).Provider = providerName	×
31	logger.BusinessRecord(ctx).Project = projectID	×
32		×
33	// Get provider ID from name	×
34	provider, err := s.providerStore.GetByName(ctx, projectID, providerName)	×
35	if err != nil {	×
36	if errors.Is(err, sql.ErrNoRows) {	×
37	return nil, util.UserVisibleError(codes.NotFound, "provider not found")	×
38	}	×
39	return nil, fmt.Errorf("error getting provider: %w", err)	×
40	}
41
42	// Get entity type from request
43	entityType := in.GetEntityType()	×
44	if entityType == pb.Entity_ENTITY_UNSPECIFIED {	×
45	return nil, util.UserVisibleError(codes.InvalidArgument, "entity type must be specified")	×
46	}	×
47
48	// Get limit from request
49	limit := in.GetCursor().GetSize()	×
50	if limit == 0 {	×
51	limit = 20 // Default limit	×
52	}	×
53
54	// Get cursor from request
55	cursor := in.GetCursor().GetCursor()	×
56		×
57	// Call service to get entities	×
58	outentities, nextCursor, err := s.entityService.ListEntities(	×
59	ctx,	×
60	projectID,	×
61	provider.ID,	×
62	entityType,	×
63	cursor,	×
64	int64(limit),	×
65	)	×
66	if err != nil {	×
67	return nil, err	×
68	}	×
69
70	// Create response
71	resp := &pb.ListEntitiesResponse{	×
72	Results: outentities,	×
73	Page: &pb.CursorPage{	×
74	Next: &pb.Cursor{	×
75	Cursor: nextCursor,	×
76	Size: limit,	×
77	},	×
78	},	×
79	}	×
80		×
81	return resp, nil	×
82	}
83
84	// GetEntityById returns an entity instance for a given entity ID
85	func (s *Server) GetEntityById(
86	ctx context.Context,
87	in *pb.GetEntityByIdRequest,
88	) (*pb.GetEntityByIdResponse, error) {	×
89	// Parse entity ID	×
90	entityID, err := uuid.Parse(in.GetId())	×
91	if err != nil {	×
92	return nil, util.UserVisibleError(codes.InvalidArgument, "invalid entity ID")	×
93	}	×
94
95	projectID := GetProjectID(ctx)	×
96		×
97	// Call service to get entity	×
98	entity, err := s.entityService.GetEntityByID(ctx, entityID, projectID)	×
99	if err != nil {	×
100	return nil, err	×
101	}	×
102
103	// Telemetry logging
104	logger.BusinessRecord(ctx).Project = projectID	×
105	logger.BusinessRecord(ctx).Entity = entityID	×
106		×
107	return &pb.GetEntityByIdResponse{	×
108	Entity: entity,	×
109	}, nil	×
110	}
111
112	// GetEntityByName returns an entity instance for a given entity name
113	func (s *Server) GetEntityByName(
114	ctx context.Context,
115	in *pb.GetEntityByNameRequest,
116	) (*pb.GetEntityByNameResponse, error) {	×
117	entityCtx := engcontext.EntityFromContext(ctx)	×
118	projectID := entityCtx.Project.ID	×
119	providerName := entityCtx.Provider.Name	×
120		×
121	// Get provider ID from name	×
122	provider, err := s.providerStore.GetByName(ctx, projectID, providerName)	×
123	if err != nil {	×
124	if errors.Is(err, sql.ErrNoRows) {	×
125	return nil, util.UserVisibleError(codes.NotFound, "provider not found")	×
126	}	×
127	return nil, fmt.Errorf("error getting provider: %w", err)	×
128	}
129
130	// Get entity type from request
131	entityType := in.GetEntityType()	×
132	if entityType == pb.Entity_ENTITY_UNSPECIFIED {	×
133	return nil, util.UserVisibleError(codes.InvalidArgument, "entity type must be specified")	×
134	}	×
135
136	// Call service to get entity
137	entity, err := s.entityService.GetEntityByName(	×
138	ctx,	×
139	in.GetName(),	×
140	projectID,	×
141	provider.ID,	×
142	entityType,	×
143	)	×
144	if err != nil {	×
145	return nil, err	×
146	}	×
147
148	// Telemetry logging
149	logger.BusinessRecord(ctx).Provider = providerName	×
150	logger.BusinessRecord(ctx).Project = projectID	×
151		×
152	return &pb.GetEntityByNameResponse{	×
153	Entity: entity,	×
154	}, nil	×
155	}
156
157	// DeleteEntityById deletes an entity instance for a given entity ID
158	func (s *Server) DeleteEntityById(
159	ctx context.Context,
160	in *pb.DeleteEntityByIdRequest,
161	) (*pb.DeleteEntityByIdResponse, error) {	×
162	// Parse entity ID	×
163	entityID, err := uuid.Parse(in.GetId())	×
164	if err != nil {	×
165	return nil, util.UserVisibleError(codes.InvalidArgument, "invalid entity ID")	×
166	}	×
167
168	projectID := GetProjectID(ctx)	×
169		×
170	// Call service to delete entity	×
171	err = s.entityService.DeleteEntityByID(ctx, entityID, projectID)	×
172	if err != nil {	×
173	return nil, err	×
174	}	×
175
176	// Telemetry logging
177	logger.BusinessRecord(ctx).Project = projectID	×
178	logger.BusinessRecord(ctx).Entity = entityID	×
179		×
180	return &pb.DeleteEntityByIdResponse{	×
181	Id: in.GetId(),	×
182	}, nil	×
183	}

mindersec / minder / 14831306943

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous