MF-1676 - Make Bootstrap fetch Certs data on demand

bootstrap/service.go

@@ -28,6 +28,8 @@ var (
 
 	// ErrBootstrap indicates error in getting bootstrap configuration.
 	ErrBootstrap = errors.New("failed to read bootstrap configuration")
+	// ErrUpdateCert indicates error in updating the certificates
+	ErrUpdateCert = errors.New("failed to update cert")
 
 	errAddBootstrap       = errors.New("failed to add bootstrap configuration")
 	errUpdateConnections  = errors.New("failed to update connections")
@@ -40,7 +42,6 @@ var (
 	errDisconnectThing    = errors.New("failed to disconnect thing")
 	errCheckChannels      = errors.New("failed to check if channels exists")
 	errConnectionChannels = errors.New("failed to check channels connections")
-	errUpdateCert         = errors.New("failed to update cert")
 )
 
 var _ Service = (*bootstrapService)(nil)
@@ -191,7 +192,7 @@ func (bs bootstrapService) UpdateCert(ctx context.Context, token, thingID, clien
 		return err
 	}
 	if err := bs.configs.UpdateCert(owner, thingID, clientCert, clientKey, caCert); err != nil {
-		return errors.Wrap(errUpdateCert, err)
+		return errors.Wrap(ErrUpdateCert, err)
 	}
 	return nil
 }

certs/api/endpoint.go

@@ -16,30 +16,23 @@ func issueCert(svc certs.Service) endpoint.Endpoint {
 		if err := req.validate(); err != nil {
 			return nil, err
 		}
-		res, err := svc.IssueCert(ctx, req.token, req.ThingID, req.TTL)
+		res, err := svc.IssueCert(ctx, req.token, req.ThingID, req.Name, req.TTL)
 		if err != nil {
 			return certsRes{}, err
 		}
 
-		return certsRes{
-			CertSerial: res.Serial,
-			ThingID:    res.ThingID,
-			ClientCert: res.ClientCert,
-			ClientKey:  res.ClientKey,
-			Expiration: res.Expire,
-			created:    true,
-		}, nil
+		return CertToCertResponse(res, true), nil
 	}
 }
 
-func listSerials(svc certs.Service) endpoint.Endpoint {
+func listCerts(svc certs.Service) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
 		req := request.(listReq)
 		if err := req.validate(); err != nil {
 			return nil, err
 		}
 
-		page, err := svc.ListSerials(ctx, req.token, req.thingID, req.offset, req.limit)
+		page, err := svc.ListCerts(ctx, req.token, req.certID, req.thingID, req.serial, req.name, req.certStatus, req.offset, req.limit)
 		if err != nil {
 			return certsPageRes{}, err
 		}
@@ -53,9 +46,7 @@ func listSerials(svc certs.Service) endpoint.Endpoint {
 		}
 
 		for _, cert := range page.Certs {
-			cr := certsRes{
-				CertSerial: cert.Serial,
-			}
+			cr := CertToCertResponse(cert, true)
 			res.Certs = append(res.Certs, cr)
 		}
 		return res, nil
@@ -64,39 +55,99 @@ func listSerials(svc certs.Service) endpoint.Endpoint {
 
 func viewCert(svc certs.Service) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewReq)
+		req := request.(viewRevokeRenewRemoveReq)
 		if err := req.validate(); err != nil {
 			return nil, err
 		}
 
-		cert, err := svc.ViewCert(ctx, req.token, req.serialID)
+		cert, err := svc.ViewCert(ctx, req.token, req.certID)
 		if err != nil {
 			return certsPageRes{}, err
 		}
 
-		certRes := certsRes{
-			CertSerial: cert.Serial,
-			ThingID:    cert.ThingID,
-			ClientCert: cert.ClientCert,
-			Expiration: cert.Expire,
+		return CertToCertResponse(cert, false), nil
+	}
+}
+
+func revokeCert(svc certs.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(viewRevokeRenewRemoveReq)
+		if err := req.validate(); err != nil {
+			return nil, err
 		}
+		return emptyCertRes{}, svc.RevokeCert(ctx, req.token, req.certID)
+	}
+}
 
-		return certRes, nil
+func renewCert(svc certs.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(viewRevokeRenewRemoveReq)
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+		cert, err := svc.RenewCert(ctx, req.token, req.certID)
+		if err != nil {
+			return certsPageRes{}, err
+		}
+		return CertToCertResponse(cert, false), nil
 	}
 }
 
-func revokeCert(svc certs.Service) endpoint.Endpoint {
+func removeCert(svc certs.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(viewRevokeRenewRemoveReq)
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+		if err := svc.RemoveCert(ctx, req.token, req.certID); err != nil {
+			return nil, err
+		}
+		return emptyCertRes{}, nil
+
+	}
+}
+
+func revokeThingCerts(svc certs.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(revokeRenewRemoveThingIDReq)
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+		c, err := svc.RevokeThingCerts(ctx, req.token, req.thingID, req.limit)
+		if err != nil {
+			return nil, err
+		}
+		rc := map[string]interface{}{"remaining": c}
+		return rc, nil
+	}
+}
+
+func renewThingCerts(svc certs.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(revokeRenewRemoveThingIDReq)
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+		c, err := svc.RenewThingCerts(ctx, req.token, req.thingID, req.limit)
+		if err != nil {
+			return nil, err
+		}
+		rc := map[string]interface{}{"remaining": c}
+		return rc, nil
+	}
+}
+
+func removeThingCerts(svc certs.Service) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(revokeReq)
+		req := request.(revokeRenewRemoveThingIDReq)
 		if err := req.validate(); err != nil {
 			return nil, err
 		}
-		res, err := svc.RevokeCert(ctx, req.token, req.certID)
+		c, err := svc.RemoveThingCerts(ctx, req.token, req.thingID, req.limit)
 		if err != nil {
 			return nil, err
 		}
-		return revokeCertsRes{
-			RevocationTime: res.RevocationTime,
-		}, nil
+		rc := map[string]interface{}{"remaining": c}
+		return rc, nil
 	}
 }

certs/api/logging.go

@@ -26,7 +26,7 @@ func NewLoggingMiddleware(svc certs.Service, logger log.Logger) certs.Service {
 	return &loggingMiddleware{logger, svc}
 }
 
-func (lm *loggingMiddleware) IssueCert(ctx context.Context, token, thingID, ttl string) (c certs.Cert, err error) {
+func (lm *loggingMiddleware) IssueCert(ctx context.Context, token, thingID, name, ttl string) (c certs.Cert, err error) {
 	defer func(begin time.Time) {
 		message := fmt.Sprintf("Method issue_cert for token: %s and thing: %s took %s to complete", token, thingID, time.Since(begin))
 		if err != nil {
@@ -36,57 +36,109 @@ func (lm *loggingMiddleware) IssueCert(ctx context.Context, token, thingID, ttl
 		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
 	}(time.Now())
 
-	return lm.svc.IssueCert(ctx, token, thingID, ttl)
+	return lm.svc.IssueCert(ctx, token, thingID, name, ttl)
 }
 
-func (lm *loggingMiddleware) ListCerts(ctx context.Context, token, thingID string, offset, limit uint64) (cp certs.Page, err error) {
+func (lm *loggingMiddleware) ListCerts(ctx context.Context, token, certID, thingID, serial, name string, status certs.Status, offset, limit uint64) (cp certs.Page, err error) {
 	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method list_certs for token: %s and thing id: %s took %s to complete", token, thingID, time.Since(begin))
+		message := fmt.Sprintf("Method list_certs for token: %s, cert ID: %s  thing id: %s serial: %s name: %s took %s to complete", token, certID, thingID, serial, name, time.Since(begin))
 		if err != nil {
 			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
 			return
 		}
 		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
 	}(time.Now())
 
-	return lm.svc.ListCerts(ctx, token, thingID, offset, limit)
+	return lm.svc.ListCerts(ctx, token, certID, thingID, serial, name, status, offset, limit)
 }
 
-func (lm *loggingMiddleware) ListSerials(ctx context.Context, token, thingID string, offset, limit uint64) (cp certs.Page, err error) {
+func (lm *loggingMiddleware) ViewCert(ctx context.Context, token, certID string) (c certs.Cert, err error) {
 	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method list_serials for token: %s and thing id: %s took %s to complete", token, thingID, time.Since(begin))
+		message := fmt.Sprintf("Method view_cert for token: %s and certificate id: %s took %s to complete", token, certID, time.Since(begin))
 		if err != nil {
 			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
 			return
 		}
 		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
 	}(time.Now())
 
-	return lm.svc.ListSerials(ctx, token, thingID, offset, limit)
+	return lm.svc.ViewCert(ctx, token, certID)
 }
 
-func (lm *loggingMiddleware) ViewCert(ctx context.Context, token, serialID string) (c certs.Cert, err error) {
+func (lm *loggingMiddleware) RevokeCert(ctx context.Context, token, certID string) (err error) {
 	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method view_cert for token: %s and serial id %s took %s to complete", token, serialID, time.Since(begin))
+		message := fmt.Sprintf("Method revoke_cert for token: %s and certificate id: %s took %s to complete", token, certID, time.Since(begin))
 		if err != nil {
 			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
 			return
 		}
 		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
 	}(time.Now())
 
-	return lm.svc.ViewCert(ctx, token, serialID)
+	return lm.svc.RevokeCert(ctx, token, certID)
 }
 
-func (lm *loggingMiddleware) RevokeCert(ctx context.Context, token, thingID string) (c certs.Revoke, err error) {
+func (lm *loggingMiddleware) RenewCert(ctx context.Context, token, certID string) (c certs.Cert, err error) {
 	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method revoke_cert for token: %s and thing: %s took %s to complete", token, thingID, time.Since(begin))
+		message := fmt.Sprintf("Method renew_certs for token: %s and certificate id: %s took %s to complete", token, certID, time.Since(begin))
+		if err != nil {
+			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
+			return
+		}
+		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
+	}(time.Now())
+
+	return lm.svc.RenewCert(ctx, token, certID)
+}
+
+func (lm *loggingMiddleware) RemoveCert(ctx context.Context, token, certID string) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method renew_certs for token: %s and certificate id: %s took %s to complete", token, certID, time.Since(begin))
 		if err != nil {
 			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
 			return
 		}
 		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
 	}(time.Now())
 
-	return lm.svc.RevokeCert(ctx, token, thingID)
+	return lm.svc.RemoveCert(ctx, token, certID)
+}
+
+func (lm *loggingMiddleware) RevokeThingCerts(ctx context.Context, token, thingID string, limit int64) (c uint64, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method revoke_cert for token: %s and thing: %s took %s to complete", token, thingID, time.Since(begin))
+		if err != nil {
+			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
+			return
+		}
+		lm.logger.Info(fmt.Sprintf("%s without errors. %d remaining certificates to revoke ", message, c))
+	}(time.Now())
+
+	return lm.svc.RevokeThingCerts(ctx, token, thingID, limit)
+}
+
+func (lm *loggingMiddleware) RenewThingCerts(ctx context.Context, token, thingID string, limit int64) (c uint64, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method renew_certs token: %s and thing: %s took %s to complete", token, thingID, time.Since(begin))
+		if err != nil {
+			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
+			return
+		}
+		lm.logger.Info(fmt.Sprintf("%s without errors. %d remaining certificates to renew ", message, c))
+	}(time.Now())
+
+	return lm.svc.RenewThingCerts(ctx, token, thingID, limit)
+}
+
+func (lm *loggingMiddleware) RemoveThingCerts(ctx context.Context, token, thingID string, limit int64) (c uint64, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method remove_certs for token: %s and thing: %s took %s to complete", token, thingID, time.Since(begin))
+		if err != nil {
+			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
+			return
+		}
+		lm.logger.Info(fmt.Sprintf("%s without errors. %d remaining certificates to remove ", message, c))
+	}(time.Now())
+
+	return lm.svc.RemoveThingCerts(ctx, token, thingID, limit)
 }