2017-06-05 14:37:29 +00:00
|
|
|
// Copyright 2017 clair authors
|
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
|
2017-08-16 21:26:53 +00:00
|
|
|
package v3
|
2017-06-05 14:37:29 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
|
|
|
|
"golang.org/x/net/context"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
|
|
"google.golang.org/grpc/status"
|
|
|
|
|
|
|
|
"github.com/coreos/clair"
|
2017-08-16 21:26:53 +00:00
|
|
|
pb "github.com/coreos/clair/api/v3/clairpb"
|
2017-06-05 14:37:29 +00:00
|
|
|
"github.com/coreos/clair/database"
|
|
|
|
"github.com/coreos/clair/pkg/commonerr"
|
2018-09-07 20:12:19 +00:00
|
|
|
"github.com/coreos/clair/pkg/pagination"
|
2017-06-05 14:37:29 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// NotificationServer implements NotificationService interface for serving RPC.
|
|
|
|
type NotificationServer struct {
|
2017-07-12 21:04:05 +00:00
|
|
|
Store database.Datastore
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// AncestryServer implements AncestryService interface for serving RPC.
|
|
|
|
type AncestryServer struct {
|
|
|
|
Store database.Datastore
|
|
|
|
}
|
|
|
|
|
2018-08-30 19:09:24 +00:00
|
|
|
// StatusServer implements StatusService interface for serving RPC.
|
|
|
|
type StatusServer struct {
|
|
|
|
Store database.Datastore
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetStatus implements getting the current status of Clair via the Clair service.
|
|
|
|
func (s *StatusServer) GetStatus(ctx context.Context, req *pb.GetStatusRequest) (*pb.GetStatusResponse, error) {
|
|
|
|
if clairStatus, err := GetClairStatus(s.Store); err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
|
|
|
} else {
|
|
|
|
return &pb.GetStatusResponse{Status: clairStatus}, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-05 14:37:29 +00:00
|
|
|
// PostAncestry implements posting an ancestry via the Clair gRPC service.
|
|
|
|
func (s *AncestryServer) PostAncestry(ctx context.Context, req *pb.PostAncestryRequest) (*pb.PostAncestryResponse, error) {
|
|
|
|
ancestryName := req.GetAncestryName()
|
|
|
|
if ancestryName == "" {
|
2017-07-12 21:04:05 +00:00
|
|
|
return nil, status.Error(codes.InvalidArgument, "ancestry name should not be empty")
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
layers := req.GetLayers()
|
|
|
|
if len(layers) == 0 {
|
2017-07-12 21:04:05 +00:00
|
|
|
return nil, status.Error(codes.InvalidArgument, "ancestry should have at least one layer")
|
|
|
|
}
|
|
|
|
|
|
|
|
ancestryFormat := req.GetFormat()
|
|
|
|
if ancestryFormat == "" {
|
|
|
|
return nil, status.Error(codes.InvalidArgument, "ancestry format should not be empty")
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
ancestryLayers := []clair.LayerRequest{}
|
|
|
|
for _, layer := range layers {
|
2017-06-05 14:37:29 +00:00
|
|
|
if layer == nil {
|
2017-07-12 21:04:05 +00:00
|
|
|
err := status.Error(codes.InvalidArgument, "ancestry layer is invalid")
|
|
|
|
return nil, err
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
if layer.GetHash() == "" {
|
|
|
|
return nil, status.Error(codes.InvalidArgument, "ancestry layer hash should not be empty")
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
if layer.GetPath() == "" {
|
|
|
|
return nil, status.Error(codes.InvalidArgument, "ancestry layer path should not be empty")
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
ancestryLayers = append(ancestryLayers, clair.LayerRequest{
|
|
|
|
Hash: layer.Hash,
|
|
|
|
Headers: layer.Headers,
|
|
|
|
Path: layer.Path,
|
|
|
|
})
|
|
|
|
}
|
2017-06-05 14:37:29 +00:00
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
err := clair.ProcessAncestry(s.Store, ancestryFormat, ancestryName, ancestryLayers)
|
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, "ancestry is failed to be processed: "+err.Error())
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2018-08-30 19:09:24 +00:00
|
|
|
clairStatus, err := GetClairStatus(s.Store)
|
2017-07-12 21:04:05 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
|
|
|
}
|
|
|
|
|
|
|
|
return &pb.PostAncestryResponse{Status: clairStatus}, nil
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
// GetAncestry implements retrieving an ancestry via the Clair gRPC service.
|
|
|
|
func (s *AncestryServer) GetAncestry(ctx context.Context, req *pb.GetAncestryRequest) (*pb.GetAncestryResponse, error) {
|
2018-09-05 15:34:06 +00:00
|
|
|
var (
|
|
|
|
respAncestry *pb.GetAncestryResponse_Ancestry
|
|
|
|
name = req.GetAncestryName()
|
|
|
|
)
|
|
|
|
|
|
|
|
if name == "" {
|
2017-07-12 21:04:05 +00:00
|
|
|
return nil, status.Errorf(codes.InvalidArgument, "ancestry name should not be empty")
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
tx, err := s.Store.Begin()
|
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
2017-07-12 21:04:05 +00:00
|
|
|
defer tx.Rollback()
|
2017-06-05 14:37:29 +00:00
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
if req.GetWithFeatures() || req.GetWithVulnerabilities() {
|
2018-09-05 15:34:06 +00:00
|
|
|
ancestry, ok, err := tx.FindAncestryWithContent(name)
|
2017-06-05 14:37:29 +00:00
|
|
|
if err != nil {
|
2017-07-12 21:04:05 +00:00
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
2017-07-12 21:04:05 +00:00
|
|
|
|
|
|
|
if !ok {
|
|
|
|
return nil, status.Error(codes.NotFound, fmt.Sprintf("requested ancestry '%s' is not found", req.GetAncestryName()))
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2018-09-05 15:34:49 +00:00
|
|
|
respAncestry = &pb.GetAncestryResponse_Ancestry{
|
|
|
|
Name: name,
|
|
|
|
ScannedDetectors: ancestry.ProcessedBy.Detectors,
|
|
|
|
ScannedListers: ancestry.ProcessedBy.Listers,
|
|
|
|
}
|
2018-09-05 15:34:06 +00:00
|
|
|
|
|
|
|
for _, layer := range ancestry.Layers {
|
2018-09-05 15:34:49 +00:00
|
|
|
ancestryLayer := &pb.GetAncestryResponse_AncestryLayer{
|
|
|
|
Layer: &pb.Layer{
|
|
|
|
Hash: layer.Hash,
|
|
|
|
},
|
|
|
|
}
|
2017-07-12 21:04:05 +00:00
|
|
|
|
2018-09-05 15:34:06 +00:00
|
|
|
if req.GetWithVulnerabilities() {
|
|
|
|
featureVulnerabilities, err := tx.FindAffectedNamespacedFeatures(layer.DetectedFeatures)
|
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
2017-07-12 21:04:05 +00:00
|
|
|
}
|
|
|
|
|
2018-09-05 15:34:06 +00:00
|
|
|
for _, fv := range featureVulnerabilities {
|
|
|
|
// Ensure that every feature can be found.
|
|
|
|
if !fv.Valid {
|
|
|
|
return nil, status.Error(codes.Internal, "ancestry feature is not found")
|
2017-07-12 21:04:05 +00:00
|
|
|
}
|
|
|
|
|
2018-09-05 15:34:06 +00:00
|
|
|
feature := pb.NamespacedFeatureFromDatabaseModel(fv.NamespacedFeature)
|
|
|
|
for _, v := range fv.AffectedBy {
|
|
|
|
vuln, err := pb.VulnerabilityWithFixedInFromDatabaseModel(v)
|
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
|
|
|
}
|
|
|
|
feature.Vulnerabilities = append(feature.Vulnerabilities, vuln)
|
|
|
|
}
|
|
|
|
ancestryLayer.DetectedFeatures = append(ancestryLayer.DetectedFeatures, feature)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for _, dbFeature := range layer.DetectedFeatures {
|
|
|
|
ancestryLayer.DetectedFeatures = append(ancestryLayer.DetectedFeatures, pb.NamespacedFeatureFromDatabaseModel(dbFeature))
|
|
|
|
}
|
2017-07-12 21:04:05 +00:00
|
|
|
}
|
2018-09-05 15:34:06 +00:00
|
|
|
|
|
|
|
respAncestry.Layers = append(respAncestry.Layers, ancestryLayer)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
dbAncestry, ok, err := tx.FindAncestry(name)
|
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
|
|
|
} else if !ok {
|
|
|
|
return nil, status.Error(codes.NotFound, fmt.Sprintf("requested ancestry '%s' is not found", req.GetAncestryName()))
|
2017-07-12 21:04:05 +00:00
|
|
|
}
|
2018-09-05 15:34:06 +00:00
|
|
|
respAncestry = pb.AncestryFromDatabaseModel(dbAncestry)
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2018-08-30 19:09:24 +00:00
|
|
|
clairStatus, err := GetClairStatus(s.Store)
|
2017-06-05 14:37:29 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
return &pb.GetAncestryResponse{
|
|
|
|
Status: clairStatus,
|
2018-09-05 15:34:06 +00:00
|
|
|
Ancestry: respAncestry,
|
2017-07-12 21:04:05 +00:00
|
|
|
}, nil
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
// GetNotification implements retrieving a notification via the Clair gRPC
|
2017-06-05 14:37:29 +00:00
|
|
|
// service.
|
2017-07-12 21:04:05 +00:00
|
|
|
func (s *NotificationServer) GetNotification(ctx context.Context, req *pb.GetNotificationRequest) (*pb.GetNotificationResponse, error) {
|
2017-06-05 14:37:29 +00:00
|
|
|
if req.GetName() == "" {
|
2017-07-12 21:04:05 +00:00
|
|
|
return nil, status.Error(codes.InvalidArgument, "notification name should not be empty")
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
if req.GetLimit() <= 0 {
|
|
|
|
return nil, status.Error(codes.InvalidArgument, "notification page limit should not be empty or less than 1")
|
|
|
|
}
|
|
|
|
|
|
|
|
tx, err := s.Store.Begin()
|
|
|
|
if err != nil {
|
2017-06-05 14:37:29 +00:00
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
|
|
|
}
|
2017-07-12 21:04:05 +00:00
|
|
|
defer tx.Rollback()
|
2017-06-05 14:37:29 +00:00
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
dbNotification, ok, err := tx.FindVulnerabilityNotification(
|
|
|
|
req.GetName(),
|
|
|
|
int(req.GetLimit()),
|
2018-09-07 20:12:19 +00:00
|
|
|
pagination.Token(req.GetOldVulnerabilityPage()),
|
|
|
|
pagination.Token(req.GetNewVulnerabilityPage()),
|
2017-07-12 21:04:05 +00:00
|
|
|
)
|
2017-06-05 14:37:29 +00:00
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
if !ok {
|
|
|
|
return nil, status.Error(codes.NotFound, fmt.Sprintf("requested notification '%s' is not found", req.GetName()))
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
notification, err := pb.NotificationFromDatabaseModel(dbNotification)
|
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
return &pb.GetNotificationResponse{Notification: notification}, nil
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
// MarkNotificationAsRead implements deleting a notification via the Clair gRPC
|
|
|
|
// service.
|
2018-04-23 19:36:52 +00:00
|
|
|
func (s *NotificationServer) MarkNotificationAsRead(ctx context.Context, req *pb.MarkNotificationAsReadRequest) (*pb.MarkNotificationAsReadResponse, error) {
|
2017-07-12 21:04:05 +00:00
|
|
|
if req.GetName() == "" {
|
|
|
|
return nil, status.Error(codes.InvalidArgument, "notification name should not be empty")
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
tx, err := s.Store.Begin()
|
|
|
|
if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
defer tx.Rollback()
|
|
|
|
err = tx.DeleteNotification(req.GetName())
|
|
|
|
if err == commonerr.ErrNotFound {
|
|
|
|
return nil, status.Error(codes.NotFound, "requested notification \""+req.GetName()+"\" is not found")
|
|
|
|
} else if err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 21:04:05 +00:00
|
|
|
if err := tx.Commit(); err != nil {
|
|
|
|
return nil, status.Error(codes.Internal, err.Error())
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 19:36:52 +00:00
|
|
|
return &pb.MarkNotificationAsReadResponse{}, nil
|
2017-06-05 14:37:29 +00:00
|
|
|
}
|