func()

in pkg/berglas/list.go [211:290]

• 62 lines of code
• 12 McCabe index (conditional complexity)

func (c *Client) storageList(ctx context.Context, i *StorageListRequest) (*ListResponse, error) {
	bucket := i.Bucket
	if bucket == "" {
		return nil, fmt.Errorf("missing bucket name")
	}

	prefix := i.Prefix
	generations := i.Generations

	logger := logging.FromContext(ctx).With(
		"bucket", bucket,
		"prefix", prefix,
		"generations", generations,
	)

	logger.DebugContext(ctx, "list.start")
	defer logger.DebugContext(ctx, "list.finish")

	allObjects := map[string][]*storage.ObjectAttrs{}

	query := &storage.Query{
		Prefix:   prefix,
		Versions: generations,
	}

	// List all objects
	it := c.storageClient.
		Bucket(bucket).
		Objects(ctx, query)
	for {
		obj, err := it.Next()
		if err == iterator.Done {
			logger.DebugContext(ctx, "out of objects")
			break
		}
		if err != nil {
			return nil, fmt.Errorf("failed to list secrets: %w", err)
		}

		// Check that it has metadata
		if obj.Metadata == nil || obj.Metadata[MetadataIDKey] != "1" {
			logger.DebugContext(ctx, "found object without metadata",
				"object", obj.Name,
				"metadata", obj.Metadata)
			continue
		}

		logger.DebugContext(ctx, "adding object to list",
			"object", obj.Name)
		allObjects[obj.Name] = append(allObjects[obj.Name], obj)
	}

	var result secretList

	// list objects returns all generations even if the live object is gone.
	// filter on names which have not been deleted
	logger.DebugContext(ctx, "filtering objects with no live versions")

	for _, objects := range allObjects {
		foundLiveObject := false
		for _, obj := range objects {
			if obj.Deleted.IsZero() {
				foundLiveObject = true
				break
			}
		}

		if foundLiveObject {
			for _, obj := range objects {
				result = append(result, secretFromAttrs(bucket, obj, nil))
			}
		}
	}

	sort.Sort(result)

	return &ListResponse{
		Secrets: result,
	}, nil
}