Git-Mirrors/constellation
1
0
Fork 0
mirror of https://github.com/edgelesssys/constellation.git synced 2025-04-21 23:59:09 -04:00
Code Issues Packages Projects Releases Wiki Activity

more logical log formatting with flags and similair

Browse Source 
added forgotten flag print

forgotten flag print in info.go
This commit is contained in:
miampf 2024-03-25 13:08:39 +01:00
parent 9e92581d66
commit 5535ee4f43
No known key found for this signature in database
GPG Key ID: EF039364B5B6886C
15 changed files with 18 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
cli/internal/cmd/configfetchmeasurements.go
View File

@ -105,12 +105,7 @@ func runConfigFetchMeasurements(cmd *cobra.Command, _ []string) error {
if err := cfm.flags.parse(cmd.Flags()); err != nil {
return fmt.Errorf("parsing flags: %w", err)
}
cfm.log.Debug(fmt.Sprintf(
`Using flags:
insecure: %t
measurements-url: %q
signature-url: %q
`, cfm.flags.insecure, cfm.flags.measurementsURL, cfm.flags.signatureURL))
cfm.log.Debug("Using flags", "insecure", cfm.flags.insecure, "measurementsURL", cfm.flags.measurementsURL, "signatureURL", cfm.flags.signatureURL)
fetcher := attestationconfigapi.NewFetcherWithClient(http.DefaultClient, constants.CDNRepositoryURL)
return cfm.configFetchMeasurements(cmd, fileHandler, fetcher)

6
cli/internal/cmd/configgenerate.go
View File

@ -85,11 +85,7 @@ func runConfigGenerate(cmd *cobra.Command, args []string) error {
if err := cg.flags.parse(cmd.Flags()); err != nil {
return fmt.Errorf("parsing flags: %w", err)
}
log.Debug(fmt.Sprintf(
`Parsed flags:
kubernetes: %q
attestation: %q
`, cg.flags.k8sVersion, cg.flags.attestationVariant))
log.Debug("Using flags", "k8sVersion", cg.flags.k8sVersion, "attestationVariant", cg.flags.attestationVariant)
return cg.configGenerate(cmd, fileHandler, provider, args[0])
}

7
cli/internal/cmd/recover.go
View File

@ -84,12 +84,7 @@ func runRecover(cmd *cobra.Command, _ []string) error {
if err := r.flags.parse(cmd.Flags()); err != nil {
return err
}
r.log.Debug(fmt.Sprintf(
`Using flags:
debug: %t
endpoint: %q
force: %t`,
r.flags.debug, r.flags.endpoint, r.flags.force))
r.log.Debug("Using flags", "debug", r.flags.debug, "endpoint", r.flags.endpoint, "force", r.flags.force)
return r.recover(cmd, fileHandler, 5*time.Second, &recoverDoer{log: r.log}, newDialer)
}

7
cli/internal/cmd/verify.go
View File

@ -128,12 +128,7 @@ func runVerify(cmd *cobra.Command, _ []string) error {
if err := v.flags.parse(cmd.Flags()); err != nil {
return err
}
v.log.Debug(fmt.Sprintf(
`Using flags:
cluster-id: %q
node-endpoint: %q
owner-id: %q`,
v.flags.clusterID, v.flags.endpoint, v.flags.ownerID))
v.log.Debug("Using flags", "clusterID", v.flags.clusterID, "endpoint", v.flags.endpoint, "ownerID", v.flags.ownerID)
fetcher := attestationconfigapi.NewFetcher()
return v.verify(cmd, verifyClient, formatterFactory, fetcher)
}

6
e2e/malicious-join/malicious-join.go
View File

@ -172,11 +172,7 @@ func (j *maliciousJoiner) join(ctx context.Context) (*joinproto.IssueJoinTicketR
IsControlPlane: false,
}
res, err := protoClient.IssueJoinTicket(ctx, req)
j.logger.Debug(fmt.Sprintf(
`Got join ticket response:
ApiServerEndpoint: %q
KubernetesVersion: %q
`, res.ApiServerEndpoint, res.KubernetesVersion))
j.logger.Debug("Got join ticket response", "apiServerEndpoint", res.ApiServerEndpoint, "kubernetesVersion", res.KubernetesVersion)
if err != nil {
return nil, fmt.Errorf("issuing join ticket: %w", err)
}

6
hack/bazel-deps-mirror/upgrade.go
View File

@ -40,11 +40,7 @@ func runUpgrade(cmd *cobra.Command, _ []string) error {
return err
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
unauthenticated: %t
dry-run: %t
`, flags.unauthenticated, flags.dryRun))
log.Debug("Using flags", "unauthenticated", flags.unauthenticated, "dryRun", flags.dryRun)
fileHelper, err := bazelfiles.New()
if err != nil {

8
hack/oci-pin/codegen.go
View File

@ -45,13 +45,7 @@ func runCodegen(cmd *cobra.Command, _ []string) error {
return err
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
identifier: %q
repoimage-tag-file: %q
oci-path: %q
package: %q`,
flags.identifier, flags.imageRepoTag, flags.ociPath, flags.pkg))
log.Debug("Using flags", "identifier", flags.identifier, "imageRepoTag", flags.imageRepoTag, "ociPath", flags.ociPath, "pkg", flags.pkg)
registry, prefix, name, tag, err := splitRepoTag(flags.imageRepoTag)
if err != nil {

7
hack/oci-pin/merge.go
View File

@ -36,12 +36,7 @@ func runMerge(cmd *cobra.Command, _ []string) error {
return err
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
input: %v
output: %q
verbose: %q
`, flags.inputs, flags.output, flags.logLevel))
log.Debug("Using flags", "inputs", flags.inputs, "output", flags.output, "logLevel", flags.logLevel)
log.Debug(fmt.Sprintf("Merging sum file from %q into %q.", flags.inputs, flags.output))

7
image/upload/internal/cmd/info.go
View File

@ -50,12 +50,7 @@ func runInfo(cmd *cobra.Command, args []string) error {
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
region: %q
bucket: %q
distribution-id: %q
`, flags.region, flags.bucket, flags.distributionID))
log.Debug("Using flags", "region", flags.region, "bucket", flags.bucket, "distributionID", flags.distributionID)
info, err := readInfoArgs(args)
if err != nil {
return err

8
image/upload/internal/cmd/measurementsenvelope.go
View File

@ -54,13 +54,7 @@ func runEnvelopeMeasurements(cmd *cobra.Command, _ []string) error {
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
version: %q
csp: %q
attestation-variant: %q
in: %q
`, flags.version.Version(), flags.csp, flags.attestationVariant, flags.in))
log.Debug("Using flags", "version", flags.version.Version(), "csp", flags.csp, "attestationVariant", flags.attestationVariant, "in", flags.in)
f, err := os.Open(flags.in)
if err != nil {

5
image/upload/internal/cmd/measurementsmerge.go
View File

@ -45,10 +45,7 @@ func runMergeMeasurements(cmd *cobra.Command, args []string) error {
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
out: %q
verbose: %q`, flags.out, flags.logLevel))
log.Debug("Using flags", "out", flags.out, "logLevel", flags.logLevel)
mergedMeasurements, err := readMeasurementsArgs(args)
if err != nil {

10
image/upload/internal/cmd/measurementsupload.go
View File

@ -53,15 +53,7 @@ func runMeasurementsUpload(cmd *cobra.Command, _ []string) error {
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
measurements: %q
signature: %q
region: %q
bucket: %q
distribution-id: %q
`, flags.measurementsPath, flags.signaturePath, flags.region,
flags.bucket, flags.distributionID))
log.Debug("Using flags", "measurementsPath", flags.measurementsPath, "signaturePath", flags.signaturePath, "region", flags.region, "bucket", flags.bucket, "distributionID", flags.distributionID)
uploadC, uploadCClose, err := measurementsuploader.New(cmd.Context(), flags.region, flags.bucket, flags.distributionID, log)
if err != nil {

14
image/upload/internal/cmd/uplosi.go
View File

@ -59,18 +59,8 @@ func runUplosi(cmd *cobra.Command, _ []string) error {
return err
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
raw-image: %q
attestation-variant: %q
csp: %q
version: %q
region: %q
bucket: %q
distribution-id: %q
`, flags.rawImage, flags.attestationVariant, flags.provider, flags.version.Version(), flags.region,
flags.bucket, flags.distributionID))
log.Debug("Using flags", "raw-image", flags.rawImage, "attestation-variant", flags.attestationVariant, "csp", flags.provider, "ref", flags.version.Ref(), "stream", flags.version.Stream(),
"version", flags.version.Version(), "region", flags.region, "bucket", flags.bucket, "distribution-id", flags.distributionID, "out", flags.out, "uplosi-path", flags.uplosiPath)
archiveC, archiveCClose, err := archive.New(cmd.Context(), flags.region, flags.bucket, flags.distributionID, log)
if err != nil {
return err

21
internal/api/versionsapi/cli/rm.go
View File

@ -75,24 +75,9 @@ func runRemove(cmd *cobra.Command, _ []string) (retErr error) {
return err
}
log := logger.NewTextLogger(flags.logLevel)
log.Debug(fmt.Sprintf(
`Parsed flags:
all: %t
az-location: %q
az-resource-group: %q
az-subscription: %q
bucket: %q
distribution-id: %q
dryrun: %t
gcp-project: %q
ref: %q
region: %q
stream: %q
version: %q
version-path: %q`,
flags.all, flags.azLocation, flags.azResourceGroup, flags.azSubscription,
flags.bucket, flags.distributionID, flags.dryrun, flags.gcpProject,
flags.ref, flags.region, flags.stream, flags.version, flags.versionPath))
log.Debug("Using flags", "all", flags.all, "azLocation", flags.azLocation, "azResourceGroup", flags.azResourceGroup, "azSubscription", flags.azSubscription,
"bucket", flags.bucket, "distributionID", flags.distributionID, "dryrun", flags.dryrun, "gcpProject", flags.gcpProject, "ref", flags.ref,
"region", flags.region, "stream", flags.stream, "version", flags.version, "versionPath", flags.versionPath)
log.Debug("Validating flags")
if err := flags.validate(); err != nil {

7
internal/constellation/applyinit.go
View File

@ -90,12 +90,7 @@ func (a *Applier) Init(
}
// Perform the RPC
a.log.Debug(fmt.Sprintf(
`Making initialization call, doer has the following parameters:
endpoint: %q
req.KmsUri: %q
req.StorageUri: %q
`, doer.endpoint, doer.req.KmsUri, doer.req.StorageUri))
a.log.Debug("Initialization call", "endpoint", doer.endpoint, "kmsURI", doer.req.KmsUri, "storageURI", doer.req.StorageUri)
a.spinner.Start("Connecting ", false)
retrier := retry.NewIntervalRetrier(doer, 30*time.Second, serviceIsUnavailable)
if err := retrier.Do(ctx); err != nil {