10954951954

Committed 20 Sep 2024 07:18AM UTC coverage: 53.452% (-0.008%) from 53.46%

Build # 10954951954

Build Type

push

github

Committed by

web-flow

Commit Message

build(deps): bump github/codeql-action from 3.26.7 to 3.26.8 (#4551)

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 3.26.7 to 3.26.8.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/8214744c5...294a9d929)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Run Details

14120 of 26416 relevant lines covered (53.45%)

42.81 hits per line

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

77.83

/internal/eea/eea.go

// Copyright 2023 Stacklok, Inc.
//
// Licensed 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 rule provides the CLI subcommand for managing rules

// Package eea provides objects and event handlers for the EEA. EEA stands for
// Event Execution Aggregator. The EEA is responsible for aggregating events
// from the webhook and making sure we don't send too many events to the
// executor engine.
package eea

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

        "github.com/ThreeDotsLabs/watermill/message"
        "github.com/google/uuid"
        "github.com/rs/zerolog"

        "github.com/stacklok/minder/internal/artifacts"
        serverconfig "github.com/stacklok/minder/internal/config/server"
        "github.com/stacklok/minder/internal/db"
        "github.com/stacklok/minder/internal/engine/entities"
        "github.com/stacklok/minder/internal/events"
)

// EEA is the Event Execution Aggregator
type EEA struct {
        querier db.Store
        evt     events.Publisher
        cfg     *serverconfig.AggregatorConfig
}

// NewEEA creates a new EEA
func NewEEA(querier db.Store, evt events.Publisher, cfg *serverconfig.AggregatorConfig) *EEA {
        return &EEA{
                querier: querier,
                evt:     evt,
                cfg:     cfg,
        }
}

// Register implements the Consumer interface.
func (e *EEA) Register(r events.Registrar) {
        r.Register(events.TopicQueueEntityFlush, e.FlushMessageHandler)
}

// AggregateMiddleware will pass on the event to the executor engine
// if the event is ready to be executed. Else it'll cache
// the event until it's ready to be executed.
func (e *EEA) AggregateMiddleware(h message.HandlerFunc) message.HandlerFunc {
        return func(msg *message.Message) ([]*message.Message, error) {
                msg, err := e.aggregate(msg)
                if err != nil {
                        return nil, fmt.Errorf("error aggregating event: %w", err)
                }

                if msg == nil {
                        return nil, nil
                }

                return h(msg)
        }
}

// nolint:gocyclo // TODO: hacking in the TODO about foreign keys pushed this over the limit.
func (e *EEA) aggregate(msg *message.Message) (*message.Message, error) {
        ctx := msg.Context()
        inf, err := entities.ParseEntityEvent(msg)
        if err != nil {
                return nil, fmt.Errorf("error unmarshalling payload: %w", err)
        }

        projectID := inf.ProjectID

        logger := zerolog.Ctx(ctx).With().
                Str("component", "EEA").
                // This is added for consistency with how watermill
                // tracks message UUID when logging.
                Str("message_uuid", msg.UUID).
                Str("entity", inf.Type.ToString()).
                Logger()

        entityID, err := inf.GetID()
        if err != nil {
                logger.Debug().AnErr("error getting entity ID", err).Msgf("Entity ID was not set for event %s", inf.Type)
                // Nothing we can do after this.
                return nil, nil
        }

        logger = logger.With().Str("entity_id", entityID.String()).Logger()

        tx, err := e.querier.BeginTransaction()
        if err != nil {
                return nil, fmt.Errorf("error beginning transaction: %w", err)
        }
        qtx := e.querier.GetQuerierWithTransaction(tx)

        // We'll only attempt to lock if the entity exists.
        _, err = qtx.GetEntityByID(ctx, entityID)
        if err != nil {
                // explicit rollback if entity had an issue.
                _ = e.querier.Rollback(tx)
                if errors.Is(err, sql.ErrNoRows) {
                        logger.Debug().Msg("entity not found")
                        return nil, nil
                }
                return nil, fmt.Errorf("error getting entity: %w", err)
        }

        res, err := qtx.LockIfThresholdNotExceeded(ctx, db.LockIfThresholdNotExceededParams{
                Entity:           entities.EntityTypeToDB(inf.Type),
                EntityInstanceID: entityID,
                ProjectID:        projectID,
                Interval:         fmt.Sprintf("%d", e.cfg.LockInterval),
        })
        if err == nil {
                if err := tx.Commit(); err != nil {
                        return nil, fmt.Errorf("error committing transaction: %w", err)
                }
        } else {
                _ = e.querier.Rollback(tx)
        }

        // if nothing was retrieved from the database, then we can assume
        // that the event is not ready to be executed.
        if err != nil && errors.Is(err, sql.ErrNoRows) {
                logger.Info().Msg("executor not ready to process event. Queuing in flush cache.")

                _, err := e.querier.EnqueueFlush(ctx, db.EnqueueFlushParams{
                        Entity:           entities.EntityTypeToDB(inf.Type),
                        EntityInstanceID: entityID,
                        ProjectID:        projectID,
                })
                if err != nil {
                        // We already have this item in the queue.
                        if errors.Is(err, sql.ErrNoRows) {
                                return nil, nil
                        }
                        return nil, fmt.Errorf("error enqueuing flush: %w", err)
                }

                return nil, nil
        } else if err != nil {
                logger.Err(err).Msg("error locking event")
                return nil, fmt.Errorf("error locking: %w", err)
        }

        logger.Info().Str("execution_id", res.LockedBy.String()).Msg("event ready to be executed")
        msg.Metadata.Set(entities.ExecutionIDKey, res.LockedBy.String())

        return msg, nil
}

// FlushMessageHandler will flush the cache of events to the executor engine
// if the event is ready to be executed.
func (e *EEA) FlushMessageHandler(msg *message.Message) error {
        ctx := msg.Context()

        inf, err := entities.ParseEntityEvent(msg)
        if err != nil {
                return fmt.Errorf("error unmarshalling payload: %w", err)
        }

        eID, err := inf.GetID()
        if err != nil {
                return fmt.Errorf("error getting entity ID: %w", err)
        }

        logger := zerolog.Ctx(ctx).With().
                Str("component", "EEA").
                Str("function", "FlushMessageHandler").
                // This is added for consistency with how watermill
                // tracks message UUID when logging.
                Str("message_uuid", msg.UUID).
                Str("entity", inf.Type.ToString()).Logger()

        logger.Debug().Msg("flushing event")

        _, err = e.querier.FlushCache(ctx, eID)
        // Nothing to do here. If we can't flush the cache, it means
        // that the event has already been executed.
        if err != nil && errors.Is(err, sql.ErrNoRows) {
                zerolog.Ctx(ctx).Debug().Msg("no flushing needed")
                return nil
        } else if err != nil {
                return fmt.Errorf("error flushing cache: %w", err)
        }

        logger.Debug().Msg("re-publishing event because of flush")

        // Now that we've flushed the event, let's try to publish it again
        // which means, go through the locking process again.
        if err := inf.Publish(e.evt); err != nil {
                return fmt.Errorf("error publishing execute event: %w", err)
        }

        return nil
}

// FlushAll will flush all events in the cache to the executor engine
func (e *EEA) FlushAll(ctx context.Context) error {
        caches, err := e.querier.ListFlushCache(ctx)
        if err != nil {
                return fmt.Errorf("error listing flush cache: %w", err)
        }

        for _, cache := range caches {
                cache := cache

                eiw, err := e.buildEntityWrapper(ctx, cache.Entity,
                        cache.ProjectID, cache.EntityInstanceID)
                if err != nil && errors.Is(err, sql.ErrNoRows) {
                        continue
                } else if err != nil {
                        return fmt.Errorf("error building entity wrapper: %w", err)
                }

                msg, err := eiw.BuildMessage()
                if err != nil {
                        return fmt.Errorf("error building message: %w", err)
                }

                msg.SetContext(ctx)

                if err := e.FlushMessageHandler(msg); err != nil {
                        return fmt.Errorf("error flushing messages: %w", err)
                }
        }

        return nil
}

func (e *EEA) buildEntityWrapper(
        ctx context.Context,
        entity db.Entities,
        projID uuid.UUID,
        entityID uuid.UUID,
) (*entities.EntityInfoWrapper, error) {
        switch entity {
        case db.EntitiesRepository:
                return e.buildRepositoryInfoWrapper(ctx, entityID, projID)
        case db.EntitiesArtifact:
                return e.buildArtifactInfoWrapper(ctx, entityID, projID)
        case db.EntitiesPullRequest:
                return e.buildPullRequestInfoWrapper(ctx, entityID, projID)
        case db.EntitiesBuildEnvironment, db.EntitiesRelease,
                db.EntitiesPipelineRun, db.EntitiesTaskRun, db.EntitiesBuild:
                return nil, fmt.Errorf("entity type %q not yet supported", entity)
        default:
                return nil, fmt.Errorf("unknown entity type: %q", entity)
        }
}

func (e *EEA) buildRepositoryInfoWrapper(
        ctx context.Context,
        repoID uuid.UUID,
        projID uuid.UUID,
) (*entities.EntityInfoWrapper, error) {
        providerID, r, err := getRepository(ctx, e.querier, projID, repoID)
        if err != nil {
                return nil, fmt.Errorf("error getting repository: %w", err)
        }

        return entities.NewEntityInfoWrapper().
                WithRepository(r).
                WithRepositoryID(repoID).
                WithProjectID(projID).
                WithProviderID(providerID), nil
}

func (e *EEA) buildArtifactInfoWrapper(
        ctx context.Context,
        artID uuid.UUID,
        projID uuid.UUID,
) (*entities.EntityInfoWrapper, error) {
        providerID, a, err := artifacts.GetArtifact(ctx, e.querier, projID, artID)
        if err != nil {
                return nil, fmt.Errorf("error getting artifact with versions: %w", err)
        }

        eiw := entities.NewEntityInfoWrapper().
                WithProjectID(projID).
                WithArtifact(a).
                WithArtifactID(artID).
                WithProviderID(providerID)
        return eiw, nil
}

func (e *EEA) buildPullRequestInfoWrapper(
        ctx context.Context,
        prID uuid.UUID,
        projID uuid.UUID,
) (*entities.EntityInfoWrapper, error) {
        providerID, repoID, pr, err := getPullRequest(ctx, e.querier, projID, prID)
        if err != nil {
                return nil, fmt.Errorf("error getting pull request: %w", err)
        }

        return entities.NewEntityInfoWrapper().
                WithRepositoryID(repoID).
                WithProjectID(projID).
                WithPullRequest(pr).
                WithPullRequestID(prID).
                WithProviderID(providerID), nil
}

1	// Copyright 2023 Stacklok, Inc.
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14	// Package rule provides the CLI subcommand for managing rules
15
16	// Package eea provides objects and event handlers for the EEA. EEA stands for
17	// Event Execution Aggregator. The EEA is responsible for aggregating events
18	// from the webhook and making sure we don't send too many events to the
19	// executor engine.
20	package eea
21
22	import (
23	"context"
24	"database/sql"
25	"errors"
26	"fmt"
27
28	"github.com/ThreeDotsLabs/watermill/message"
29	"github.com/google/uuid"
30	"github.com/rs/zerolog"
31
32	"github.com/stacklok/minder/internal/artifacts"
33	serverconfig "github.com/stacklok/minder/internal/config/server"
34	"github.com/stacklok/minder/internal/db"
35	"github.com/stacklok/minder/internal/engine/entities"
36	"github.com/stacklok/minder/internal/events"
37	)
38
39	// EEA is the Event Execution Aggregator
40	type EEA struct {
41	querier db.Store
42	evt events.Publisher
43	cfg *serverconfig.AggregatorConfig
44	}
45
46	// NewEEA creates a new EEA
47	func NewEEA(querier db.Store, evt events.Publisher, cfg serverconfig.AggregatorConfig) EEA {	9✔
48	return &EEA{	9✔
49	querier: querier,	9✔
50	evt: evt,	9✔
51	cfg: cfg,	9✔
52	}	9✔
53	}	9✔
54
55	// Register implements the Consumer interface.
56	func (e *EEA) Register(r events.Registrar) {	1✔
57	r.Register(events.TopicQueueEntityFlush, e.FlushMessageHandler)	1✔
58	}	1✔
59
60	// AggregateMiddleware will pass on the event to the executor engine
61	// if the event is ready to be executed. Else it'll cache
62	// the event until it's ready to be executed.
63	func (e *EEA) AggregateMiddleware(h message.HandlerFunc) message.HandlerFunc {	2✔
64	return func(msg message.Message) ([]message.Message, error) {	103✔
65	msg, err := e.aggregate(msg)	101✔
66	if err != nil {	101✔
67	return nil, fmt.Errorf("error aggregating event: %w", err)	×
68	}	×
69
70	if msg == nil {	200✔
71	return nil, nil	99✔
72	}	99✔
73
74	return h(msg)	2✔
75	}
76	}
77
78	// nolint:gocyclo // TODO: hacking in the TODO about foreign keys pushed this over the limit.
79	func (e EEA) aggregate(msg message.Message) (*message.Message, error) {	101✔
80	ctx := msg.Context()	101✔
81	inf, err := entities.ParseEntityEvent(msg)	101✔
82	if err != nil {	101✔
83	return nil, fmt.Errorf("error unmarshalling payload: %w", err)	×
84	}	×
85
86	projectID := inf.ProjectID	101✔
87		101✔
88	logger := zerolog.Ctx(ctx).With().	101✔
89	Str("component", "EEA").	101✔
90	// This is added for consistency with how watermill	101✔
91	// tracks message UUID when logging.	101✔
92	Str("message_uuid", msg.UUID).	101✔
93	Str("entity", inf.Type.ToString()).	101✔
94	Logger()	101✔
95		101✔
96	entityID, err := inf.GetID()	101✔
97	if err != nil {	101✔
98	logger.Debug().AnErr("error getting entity ID", err).Msgf("Entity ID was not set for event %s", inf.Type)	×
99	// Nothing we can do after this.	×
100	return nil, nil	×
101	}	×
102
103	logger = logger.With().Str("entity_id", entityID.String()).Logger()	101✔
104		101✔
105	tx, err := e.querier.BeginTransaction()	101✔
106	if err != nil {	101✔
107	return nil, fmt.Errorf("error beginning transaction: %w", err)	×
108	}	×
109	qtx := e.querier.GetQuerierWithTransaction(tx)	101✔
110		101✔
111	// We'll only attempt to lock if the entity exists.	101✔
112	_, err = qtx.GetEntityByID(ctx, entityID)	101✔
113	if err != nil {	101✔
114	// explicit rollback if entity had an issue.	×
115	_ = e.querier.Rollback(tx)	×
116	if errors.Is(err, sql.ErrNoRows) {	×
117	logger.Debug().Msg("entity not found")	×
118	return nil, nil	×
119	}	×
120	return nil, fmt.Errorf("error getting entity: %w", err)	×
121	}
122
123	res, err := qtx.LockIfThresholdNotExceeded(ctx, db.LockIfThresholdNotExceededParams{	101✔
124	Entity: entities.EntityTypeToDB(inf.Type),	101✔
125	EntityInstanceID: entityID,	101✔
126	ProjectID: projectID,	101✔
127	Interval: fmt.Sprintf("%d", e.cfg.LockInterval),	101✔
128	})	101✔
129	if err == nil {	103✔
130	if err := tx.Commit(); err != nil {	2✔
131	return nil, fmt.Errorf("error committing transaction: %w", err)	×
132	}	×
133	} else {	99✔
134	_ = e.querier.Rollback(tx)	99✔
135	}	99✔
136
137	// if nothing was retrieved from the database, then we can assume
138	// that the event is not ready to be executed.
139	if err != nil && errors.Is(err, sql.ErrNoRows) {	200✔
140	logger.Info().Msg("executor not ready to process event. Queuing in flush cache.")	99✔
141		99✔
142	_, err := e.querier.EnqueueFlush(ctx, db.EnqueueFlushParams{	99✔
143	Entity: entities.EntityTypeToDB(inf.Type),	99✔
144	EntityInstanceID: entityID,	99✔
145	ProjectID: projectID,	99✔
146	})	99✔
147	if err != nil {	197✔
148	// We already have this item in the queue.	98✔
149	if errors.Is(err, sql.ErrNoRows) {	196✔
150	return nil, nil	98✔
151	}	98✔
152	return nil, fmt.Errorf("error enqueuing flush: %w", err)	×
153	}
154
155	return nil, nil	1✔
156	} else if err != nil {	2✔
157	logger.Err(err).Msg("error locking event")	×
158	return nil, fmt.Errorf("error locking: %w", err)	×
159	}	×
160
161	logger.Info().Str("execution_id", res.LockedBy.String()).Msg("event ready to be executed")	2✔
162	msg.Metadata.Set(entities.ExecutionIDKey, res.LockedBy.String())	2✔
163		2✔
164	return msg, nil	2✔
165	}
166
167	// FlushMessageHandler will flush the cache of events to the executor engine
168	// if the event is ready to be executed.
169	func (e EEA) FlushMessageHandler(msg message.Message) error {	61✔
170	ctx := msg.Context()	61✔
171		61✔
172	inf, err := entities.ParseEntityEvent(msg)	61✔
173	if err != nil {	61✔
174	return fmt.Errorf("error unmarshalling payload: %w", err)	×
175	}	×
176
177	eID, err := inf.GetID()	61✔
178	if err != nil {	61✔
179	return fmt.Errorf("error getting entity ID: %w", err)	×
180	}	×
181
182	logger := zerolog.Ctx(ctx).With().	61✔
183	Str("component", "EEA").	61✔
184	Str("function", "FlushMessageHandler").	61✔
185	// This is added for consistency with how watermill	61✔
186	// tracks message UUID when logging.	61✔
187	Str("message_uuid", msg.UUID).	61✔
188	Str("entity", inf.Type.ToString()).Logger()	61✔
189		61✔
190	logger.Debug().Msg("flushing event")	61✔
191		61✔
192	_, err = e.querier.FlushCache(ctx, eID)	61✔
193	// Nothing to do here. If we can't flush the cache, it means	61✔
194	// that the event has already been executed.	61✔
195	if err != nil && errors.Is(err, sql.ErrNoRows) {	61✔
196	zerolog.Ctx(ctx).Debug().Msg("no flushing needed")	×
197	return nil	×
198	} else if err != nil {	116✔
199	return fmt.Errorf("error flushing cache: %w", err)	55✔
200	}	55✔
201
202	logger.Debug().Msg("re-publishing event because of flush")	6✔
203		6✔
204	// Now that we've flushed the event, let's try to publish it again	6✔
205	// which means, go through the locking process again.	6✔
206	if err := inf.Publish(e.evt); err != nil {	6✔
207	return fmt.Errorf("error publishing execute event: %w", err)	×
208	}	×
209
210	return nil	6✔
211	}
212
213	// FlushAll will flush all events in the cache to the executor engine
214	func (e *EEA) FlushAll(ctx context.Context) error {	8✔
215	caches, err := e.querier.ListFlushCache(ctx)	8✔
216	if err != nil {	9✔
217	return fmt.Errorf("error listing flush cache: %w", err)	1✔
218	}	1✔
219
220	for _, cache := range caches {	13✔
221	cache := cache	6✔
222		6✔
223	eiw, err := e.buildEntityWrapper(ctx, cache.Entity,	6✔
224	cache.ProjectID, cache.EntityInstanceID)	6✔
225	if err != nil && errors.Is(err, sql.ErrNoRows) {	7✔
226	continue	1✔
227	} else if err != nil {	5✔
228	return fmt.Errorf("error building entity wrapper: %w", err)	×
229	}	×
230
231	msg, err := eiw.BuildMessage()	5✔
232	if err != nil {	5✔
233	return fmt.Errorf("error building message: %w", err)	×
234	}	×
235
236	msg.SetContext(ctx)	5✔
237		5✔
238	if err := e.FlushMessageHandler(msg); err != nil {	5✔
239	return fmt.Errorf("error flushing messages: %w", err)	×
240	}	×
241	}
242
243	return nil	7✔
244	}
245
246	func (e *EEA) buildEntityWrapper(
247	ctx context.Context,
248	entity db.Entities,
249	projID uuid.UUID,
250	entityID uuid.UUID,
251	) (*entities.EntityInfoWrapper, error) {	6✔
252	switch entity {	6✔
253	case db.EntitiesRepository:	2✔
254	return e.buildRepositoryInfoWrapper(ctx, entityID, projID)	2✔
255	case db.EntitiesArtifact:	3✔
256	return e.buildArtifactInfoWrapper(ctx, entityID, projID)	3✔
257	case db.EntitiesPullRequest:	1✔
258	return e.buildPullRequestInfoWrapper(ctx, entityID, projID)	1✔
259	case db.EntitiesBuildEnvironment, db.EntitiesRelease,
260	db.EntitiesPipelineRun, db.EntitiesTaskRun, db.EntitiesBuild:	×
261	return nil, fmt.Errorf("entity type %q not yet supported", entity)	×
262	default:	×
263	return nil, fmt.Errorf("unknown entity type: %q", entity)	×
264	}
265	}
266
267	func (e *EEA) buildRepositoryInfoWrapper(
268	ctx context.Context,
269	repoID uuid.UUID,
270	projID uuid.UUID,
271	) (*entities.EntityInfoWrapper, error) {	2✔
272	providerID, r, err := getRepository(ctx, e.querier, projID, repoID)	2✔
273	if err != nil {	3✔
274	return nil, fmt.Errorf("error getting repository: %w", err)	1✔
275	}	1✔
276
277	return entities.NewEntityInfoWrapper().	1✔
278	WithRepository(r).	1✔
279	WithRepositoryID(repoID).	1✔
280	WithProjectID(projID).	1✔
281	WithProviderID(providerID), nil	1✔
282	}
283
284	func (e *EEA) buildArtifactInfoWrapper(
285	ctx context.Context,
286	artID uuid.UUID,
287	projID uuid.UUID,
288	) (*entities.EntityInfoWrapper, error) {	3✔
289	providerID, a, err := artifacts.GetArtifact(ctx, e.querier, projID, artID)	3✔
290	if err != nil {	3✔
291	return nil, fmt.Errorf("error getting artifact with versions: %w", err)	×
292	}	×
293
294	eiw := entities.NewEntityInfoWrapper().	3✔
295	WithProjectID(projID).	3✔
296	WithArtifact(a).	3✔
297	WithArtifactID(artID).	3✔
298	WithProviderID(providerID)	3✔
299	return eiw, nil	3✔
300	}
301
302	func (e *EEA) buildPullRequestInfoWrapper(
303	ctx context.Context,
304	prID uuid.UUID,
305	projID uuid.UUID,
306	) (*entities.EntityInfoWrapper, error) {	1✔
307	providerID, repoID, pr, err := getPullRequest(ctx, e.querier, projID, prID)	1✔
308	if err != nil {	1✔
309	return nil, fmt.Errorf("error getting pull request: %w", err)	×
310	}	×
311
312	return entities.NewEntityInfoWrapper().	1✔
313	WithRepositoryID(repoID).	1✔
314	WithProjectID(projID).	1✔
315	WithPullRequest(pr).	1✔
316	WithPullRequestID(prID).	1✔
317	WithProviderID(providerID), nil	1✔
318	}

stacklok / minder / 10954951954

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