code
stringlengths 12
335k
| docstring
stringlengths 20
20.8k
| func_name
stringlengths 1
105
| language
stringclasses 1
value | repo
stringclasses 498
values | path
stringlengths 5
172
| url
stringlengths 43
235
| license
stringclasses 4
values |
|---|---|---|---|---|---|---|---|
func (v *version) ClusterTriggerBindings() ClusterTriggerBindingInformer {
return &clusterTriggerBindingInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
} | ClusterTriggerBindings returns a ClusterTriggerBindingInformer. | ClusterTriggerBindings | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | Apache-2.0 |
func (v *version) EventListeners() EventListenerInformer {
return &eventListenerInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
} | EventListeners returns a EventListenerInformer. | EventListeners | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | Apache-2.0 |
func (v *version) Interceptors() InterceptorInformer {
return &interceptorInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
} | Interceptors returns a InterceptorInformer. | Interceptors | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | Apache-2.0 |
func (v *version) Triggers() TriggerInformer {
return &triggerInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
} | Triggers returns a TriggerInformer. | Triggers | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | Apache-2.0 |
func (v *version) TriggerBindings() TriggerBindingInformer {
return &triggerBindingInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
} | TriggerBindings returns a TriggerBindingInformer. | TriggerBindings | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | Apache-2.0 |
func (v *version) TriggerTemplates() TriggerTemplateInformer {
return &triggerTemplateInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
} | TriggerTemplates returns a TriggerTemplateInformer. | TriggerTemplates | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/interface.go | Apache-2.0 |
func NewTriggerBindingInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredTriggerBindingInformer(client, namespace, resyncPeriod, indexers, nil)
} | NewTriggerBindingInformer constructs a new informer for TriggerBinding type.
Always prefer using an informer factory to get a shared informer instead of getting an independent
one. This reduces memory footprint and number of connections to the server. | NewTriggerBindingInformer | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/triggerbinding.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/triggerbinding.go | Apache-2.0 |
func NewFilteredTriggerBindingInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TriggersV1alpha1().TriggerBindings(namespace).List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TriggersV1alpha1().TriggerBindings(namespace).Watch(context.TODO(), options)
},
},
&triggersv1alpha1.TriggerBinding{},
resyncPeriod,
indexers,
)
} | NewFilteredTriggerBindingInformer constructs a new informer for TriggerBinding type.
Always prefer using an informer factory to get a shared informer instead of getting an independent
one. This reduces memory footprint and number of connections to the server. | NewFilteredTriggerBindingInformer | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/triggerbinding.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/triggerbinding.go | Apache-2.0 |
func NewEventListenerInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredEventListenerInformer(client, namespace, resyncPeriod, indexers, nil)
} | NewEventListenerInformer constructs a new informer for EventListener type.
Always prefer using an informer factory to get a shared informer instead of getting an independent
one. This reduces memory footprint and number of connections to the server. | NewEventListenerInformer | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/eventlistener.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/eventlistener.go | Apache-2.0 |
func NewFilteredEventListenerInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TriggersV1alpha1().EventListeners(namespace).List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TriggersV1alpha1().EventListeners(namespace).Watch(context.TODO(), options)
},
},
&triggersv1alpha1.EventListener{},
resyncPeriod,
indexers,
)
} | NewFilteredEventListenerInformer constructs a new informer for EventListener type.
Always prefer using an informer factory to get a shared informer instead of getting an independent
one. This reduces memory footprint and number of connections to the server. | NewFilteredEventListenerInformer | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/eventlistener.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/eventlistener.go | Apache-2.0 |
func NewTriggerTemplateInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredTriggerTemplateInformer(client, namespace, resyncPeriod, indexers, nil)
} | NewTriggerTemplateInformer constructs a new informer for TriggerTemplate type.
Always prefer using an informer factory to get a shared informer instead of getting an independent
one. This reduces memory footprint and number of connections to the server. | NewTriggerTemplateInformer | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/triggertemplate.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/triggertemplate.go | Apache-2.0 |
func NewFilteredTriggerTemplateInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TriggersV1alpha1().TriggerTemplates(namespace).List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TriggersV1alpha1().TriggerTemplates(namespace).Watch(context.TODO(), options)
},
},
&triggersv1alpha1.TriggerTemplate{},
resyncPeriod,
indexers,
)
} | NewFilteredTriggerTemplateInformer constructs a new informer for TriggerTemplate type.
Always prefer using an informer factory to get a shared informer instead of getting an independent
one. This reduces memory footprint and number of connections to the server. | NewFilteredTriggerTemplateInformer | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/triggertemplate.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/triggertemplate.go | Apache-2.0 |
func NewTriggerInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredTriggerInformer(client, namespace, resyncPeriod, indexers, nil)
} | NewTriggerInformer constructs a new informer for Trigger type.
Always prefer using an informer factory to get a shared informer instead of getting an independent
one. This reduces memory footprint and number of connections to the server. | NewTriggerInformer | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/trigger.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/trigger.go | Apache-2.0 |
func NewFilteredTriggerInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TriggersV1alpha1().Triggers(namespace).List(context.TODO(), options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TriggersV1alpha1().Triggers(namespace).Watch(context.TODO(), options)
},
},
&triggersv1alpha1.Trigger{},
resyncPeriod,
indexers,
)
} | NewFilteredTriggerInformer constructs a new informer for Trigger type.
Always prefer using an informer factory to get a shared informer instead of getting an independent
one. This reduces memory footprint and number of connections to the server. | NewFilteredTriggerInformer | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/trigger.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1/trigger.go | Apache-2.0 |
func Get(ctx context.Context) v1beta1.TriggerInformer {
untyped := ctx.Value(Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1beta1.TriggerInformer from context.")
}
return untyped.(v1beta1.TriggerInformer)
} | Get extracts the typed informer from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/trigger/trigger.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/trigger/trigger.go | Apache-2.0 |
func Get(ctx context.Context) v1beta1.ClusterTriggerBindingInformer {
untyped := ctx.Value(Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1beta1.ClusterTriggerBindingInformer from context.")
}
return untyped.(v1beta1.ClusterTriggerBindingInformer)
} | Get extracts the typed informer from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/clustertriggerbinding/clustertriggerbinding.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/clustertriggerbinding/clustertriggerbinding.go | Apache-2.0 |
func Get(ctx context.Context) v1beta1.TriggerTemplateInformer {
untyped := ctx.Value(Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1beta1.TriggerTemplateInformer from context.")
}
return untyped.(v1beta1.TriggerTemplateInformer)
} | Get extracts the typed informer from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/triggertemplate/triggertemplate.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/triggertemplate/triggertemplate.go | Apache-2.0 |
func Get(ctx context.Context) v1beta1.EventListenerInformer {
untyped := ctx.Value(Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1beta1.EventListenerInformer from context.")
}
return untyped.(v1beta1.EventListenerInformer)
} | Get extracts the typed informer from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/eventlistener/eventlistener.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/eventlistener/eventlistener.go | Apache-2.0 |
func Get(ctx context.Context) v1beta1.TriggerBindingInformer {
untyped := ctx.Value(Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1beta1.TriggerBindingInformer from context.")
}
return untyped.(v1beta1.TriggerBindingInformer)
} | Get extracts the typed informer from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/triggerbinding/triggerbinding.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1beta1/triggerbinding/triggerbinding.go | Apache-2.0 |
func Get(ctx context.Context) v1alpha1.InterceptorInformer {
untyped := ctx.Value(Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1.InterceptorInformer from context.")
}
return untyped.(v1alpha1.InterceptorInformer)
} | Get extracts the typed informer from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1alpha1/interceptor/interceptor.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1alpha1/interceptor/interceptor.go | Apache-2.0 |
func Get(ctx context.Context) v1alpha1.ClusterInterceptorInformer {
untyped := ctx.Value(Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/informers/externalversions/triggers/v1alpha1.ClusterInterceptorInformer from context.")
}
return untyped.(v1alpha1.ClusterInterceptorInformer)
} | Get extracts the typed informer from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1alpha1/clusterinterceptor/clusterinterceptor.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/triggers/v1alpha1/clusterinterceptor/clusterinterceptor.go | Apache-2.0 |
func Get(ctx context.Context) externalversions.SharedInformerFactory {
untyped := ctx.Value(Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/informers/externalversions.SharedInformerFactory from context.")
}
return untyped.(externalversions.SharedInformerFactory)
} | Get extracts the InformerFactory from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/factory/factory.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/informers/factory/factory.go | Apache-2.0 |
func Get(ctx context.Context) versioned.Interface {
untyped := ctx.Value(Key{})
if untyped == nil {
if injection.GetConfig(ctx) == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/clientset/versioned.Interface from context. This context is not the application context (which is typically given to constructors via sharedmain).")
} else {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/clientset/versioned.Interface from context.")
}
}
return untyped.(versioned.Interface)
} | Get extracts the versioned.Interface client from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/client/client.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/client/client.go | Apache-2.0 |
func Get(ctx context.Context) *fake.Clientset {
untyped := ctx.Value(client.Key{})
if untyped == nil {
logging.FromContext(ctx).Panic(
"Unable to fetch github.com/tektoncd/triggers/pkg/client/clientset/versioned/fake.Clientset from context.")
}
return untyped.(*fake.Clientset)
} | Get extracts the Kubernetes client from the context. | Get | go | tektoncd/cli | vendor/github.com/tektoncd/triggers/pkg/client/injection/client/fake/fake.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/triggers/pkg/client/injection/client/fake/fake.go | Apache-2.0 |
func ExtractOCIImagesFromResults(ctx context.Context, results []objects.Result) []interface{} {
logger := logging.FromContext(ctx)
objs := []interface{}{}
extractor := structuredSignableExtractor{
uriSuffix: OCIImageURLResultName,
digestSuffix: OCIImageDigestResultName,
isValid: hasImageRequirements,
}
for _, s := range extractor.extract(ctx, results) {
dgst, err := name.NewDigest(fmt.Sprintf("%s@%s", s.URI, s.Digest))
if err != nil {
logger.Errorf("error getting digest: %v", err)
continue
}
objs = append(objs, dgst)
}
// look for a comma separated list of images
for _, key := range results {
if key.Name != OCIImagesResultName {
continue
}
imgs := strings.FieldsFunc(key.Value.StringVal, split)
for _, img := range imgs {
trimmed := strings.TrimSpace(img)
if trimmed == "" {
continue
}
dgst, err := name.NewDigest(trimmed)
if err != nil {
logger.Errorf("error getting digest for img %s: %v", trimmed, err)
continue
}
objs = append(objs, dgst)
}
}
return objs
} | ExtractOCIImagesFromResults returns all the results marked as OCIImage type-hint result. | ExtractOCIImagesFromResults | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func ExtractSignableTargetFromResults(ctx context.Context, obj objects.TektonObject) []StructuredSignable {
logger := logging.FromContext(ctx)
extractor := structuredSignableExtractor{
uriSuffix: "ARTIFACT_URI",
digestSuffix: "ARTIFACT_DIGEST",
isValid: func(s StructuredSignable) bool {
if !hasImageRequirements(s) {
return false
}
if _, _, err := ParseDigest(s.Digest); err != nil {
logger.Errorf("error getting digest %s: %v", s.Digest, err)
return false
}
return true
},
}
return extractor.extract(ctx, obj.GetResults())
} | ExtractSignableTargetFromResults extracts signable targets that aim to generate intoto provenance as materials within TaskRun results and store them as StructuredSignable. | ExtractSignableTargetFromResults | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func (s *StructuredSignable) FullRef() string {
return fmt.Sprintf("%s@%s", s.URI, s.Digest)
} | FullRef returns the full reference of the signable artifact in the format of URI@DIGEST | FullRef | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func RetrieveMaterialsFromStructuredResults(ctx context.Context, objResults []objects.Result) []common.ProvenanceMaterial {
logger := logging.FromContext(ctx)
// Retrieve structured provenance for inputs.
mats := []common.ProvenanceMaterial{}
ssts := ExtractStructuredTargetFromResults(ctx, objResults, ArtifactsInputsResultName)
for _, s := range ssts {
alg, digest, err := ParseDigest(s.Digest)
if err != nil {
logger.Debugf("Digest for %s not in the right format: %s, %v", s.URI, s.Digest, err)
continue
}
mats = append(mats, common.ProvenanceMaterial{
URI: s.URI,
Digest: map[string]string{alg: digest},
})
}
return mats
} | RetrieveMaterialsFromStructuredResults retrieves structured results from Object Results, and convert them into materials. | RetrieveMaterialsFromStructuredResults | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func ExtractStructuredTargetFromResults(ctx context.Context, objResults []objects.Result, categoryMarker string) []*StructuredSignable {
logger := logging.FromContext(ctx)
objs := []*StructuredSignable{}
if categoryMarker != ArtifactsInputsResultName && categoryMarker != ArtifactsOutputsResultName {
return objs
}
// TODO(#592): support structured results using Run
for _, res := range objResults {
if strings.HasSuffix(res.Name, categoryMarker) {
valid, err := isStructuredResult(res, categoryMarker)
if err != nil {
logger.Debugf("ExtractStructuredTargetFromResults: %v", err)
}
if valid {
logger.Debugf("Extracted Structured data from Result %s, %s", res.Value.ObjectVal["uri"], res.Value.ObjectVal["digest"])
objs = append(objs, &StructuredSignable{URI: res.Value.ObjectVal["uri"], Digest: res.Value.ObjectVal["digest"]})
}
}
}
return objs
} | ExtractStructuredTargetFromResults extracts structured signable targets aim to generate intoto provenance as materials within TaskRun results and store them as StructuredSignable.
categoryMarker categorizes signable targets into inputs and outputs. | ExtractStructuredTargetFromResults | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func ExtractBuildArtifactsFromResults(ctx context.Context, results []objects.Result) (objs []*StructuredSignable) {
logger := logging.FromContext(ctx)
for _, res := range results {
valid, err := IsBuildArtifact(res)
if err != nil {
logger.Debugf("ExtractBuildArtifactsFromResults failed validatin artifact %v, ignoring artifact, err: %v", res.Name, err)
continue
}
if valid {
logger.Debugf("Extracted Build artifact data from Result %s, %s", res.Value.ObjectVal["uri"], res.Value.ObjectVal["digest"])
objs = append(objs, &StructuredSignable{URI: res.Value.ObjectVal["uri"], Digest: res.Value.ObjectVal["digest"]})
}
}
return
} | ExtractBuildArtifactsFromResults extracts all the structured signable targets from the given results, only processing the ones marked as build artifacts. | ExtractBuildArtifactsFromResults | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func IsBuildArtifact(res objects.Result) (bool, error) {
if !strings.HasSuffix(res.Name, ArtifactsOutputsResultName) {
return false, nil
}
if res.Value.ObjectVal == nil {
return false, fmt.Errorf("%s should be an object: %v", res.Name, res.Value.ObjectVal)
}
if res.Value.ObjectVal[isBuildArtifactField] != "true" {
return false, nil
}
return isValidArtifactOutput(res)
} | IsBuildArtifact indicates if a given result was marked as a Build Artifact. | IsBuildArtifact | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func ParseDigest(dig string) (algo_string string, hex string, err error) {
parts := strings.Split(dig, ":")
if len(parts) != 2 {
return "", "", fmt.Errorf("digest string %s, not in the format of <algorithm>:<digest>", dig)
}
algo_string = strings.ToLower(strings.TrimSpace(parts[0]))
algo := digest.Algorithm(algo_string)
hex = strings.TrimSpace(parts[1])
switch {
case algo.Available():
if err := algo.Validate(hex); err != nil {
return "", "", err
}
case algo_string == "sha1":
// Version 1.0.0, which is the released version, of go_digest does not support SHA1,
// hence this has to be handled differently.
if !Sha1Regexp.MatchString(hex) {
return "", "", fmt.Errorf("sha1 digest %s does not match regexp %s", dig, Sha1Regexp.String())
}
default:
return "", "", fmt.Errorf("unsupported digest algorithm: %s", dig)
}
return algo_string, hex, nil
} | ParseDigest parses the digest string and returns the algorithm and hex section of the digest. | ParseDigest | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func split(r rune) bool {
return r == '\n' || r == ','
} | split allows IMAGES to be separated either by commas (for backwards compatibility)
or by newlines | split | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/artifacts/signable.go | Apache-2.0 |
func GetAnnotationsPatch(newAnnotations map[string]string) ([]byte, error) {
p := patch{
Metadata: metadata{
Annotations: newAnnotations,
},
}
return json.Marshal(p)
} | GetAnnotationsPatch returns patch bytes that can be used with kubectl patch | GetAnnotationsPatch | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/patch/patch.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/patch/patch.go | Apache-2.0 |
func publicKeyOrCert(signer signing.Signer, cert string) ([]byte, error) {
if cert != "" {
return []byte(cert), nil
}
pub, err := signer.PublicKey()
if err != nil {
return nil, errors.Wrap(err, "getting public key")
}
pem, err := cryptoutils.MarshalPublicKeyToPEM(pub)
if err != nil {
return nil, errors.Wrap(err, "key to pem")
}
return pem, nil
} | return the cert if we have it, otherwise return public key | publicKeyOrCert | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/rekor.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/rekor.go | Apache-2.0 |
func (o *ObjectSigner) Sign(ctx context.Context, tektonObj objects.TektonObject) error {
cfg := *config.FromContext(ctx)
logger := logging.FromContext(ctx)
signableTypes, err := getSignableTypes(ctx, tektonObj)
if err != nil {
return err
}
signers := allSigners(ctx, o.SecretPath, cfg)
var merr *multierror.Error
extraAnnotations := map[string]string{}
for _, signableType := range signableTypes {
if !signableType.Enabled(cfg) {
continue
}
payloadFormat := signableType.PayloadFormat(cfg)
// Find the right payload format and format the object
payloader, err := formats.GetPayloader(payloadFormat, cfg)
if err != nil {
logger.Warnf("Format %s configured for %s: %v was not found", payloadFormat, tektonObj.GetGVK(), signableType.Type())
continue
}
// Extract all the "things" to be signed.
// We might have a few of each type (several binaries, or images)
objects := signableType.ExtractObjects(ctx, tektonObj)
// Go through each object one at a time.
for _, obj := range objects {
payload, err := payloader.CreatePayload(ctx, obj)
if err != nil {
logger.Error(err)
continue
}
logger.Infof("Created payload of type %s for %s %s/%s", string(payloadFormat), tektonObj.GetGVK(), tektonObj.GetNamespace(), tektonObj.GetName())
// Sign it!
signerType := signableType.Signer(cfg)
signer, ok := signers[signerType]
if !ok {
logger.Warnf("No signer %s configured for %s", signerType, signableType.Type())
continue
}
if payloader.Wrap() {
wrapped, err := signing.Wrap(signer)
if err != nil {
return err
}
logger.Infof("Using wrapped envelope signer for %s", payloader.Type())
signer = wrapped
}
logger.Infof("Signing object with %s", signerType)
rawPayload, err := getRawPayload(payload)
if err != nil {
logger.Warnf("Unable to marshal payload: %v", signerType, obj)
continue
}
signature, err := signer.SignMessage(bytes.NewReader(rawPayload))
if err != nil {
logger.Error(err)
continue
}
measureMetrics(ctx, SignedMessagesCount, o.Recorder)
// Now store those!
for _, backend := range sets.List[string](signableType.StorageBackend(cfg)) {
b, ok := o.Backends[backend]
if !ok {
backendErr := fmt.Errorf("could not find backend '%s' in configured backends (%v) while trying sign: %s/%s", backend, maps.Keys(o.Backends), tektonObj.GetKindName(), tektonObj.GetName())
logger.Error(backendErr)
merr = multierror.Append(merr, backendErr)
continue
}
storageOpts := config.StorageOpts{
ShortKey: signableType.ShortKey(obj),
FullKey: signableType.FullKey(obj),
Cert: signer.Cert(),
Chain: signer.Chain(),
PayloadFormat: payloadFormat,
}
if err := b.StorePayload(ctx, tektonObj, rawPayload, string(signature), storageOpts); err != nil {
logger.Error(err)
merr = multierror.Append(merr, err)
} else {
measureMetrics(ctx, SignsStoredCount, o.Recorder)
}
}
if shouldUploadTlog(cfg, tektonObj) {
rekorClient, err := getRekor(cfg.Transparency.URL)
if err != nil {
return err
}
entry, err := rekorClient.UploadTlog(ctx, signer, signature, rawPayload, signer.Cert(), string(payloadFormat))
if err != nil {
logger.Warnf("error uploading entry to tlog: %v", err)
merr = multierror.Append(merr, err)
} else {
logger.Infof("Uploaded entry to %s with index %d", cfg.Transparency.URL, *entry.LogIndex)
extraAnnotations[ChainsTransparencyAnnotation] = fmt.Sprintf("%s/api/v1/log/entries?logIndex=%d", cfg.Transparency.URL, *entry.LogIndex)
measureMetrics(ctx, PayloadUploadeCount, o.Recorder)
}
}
}
if merr.ErrorOrNil() != nil {
if err := HandleRetry(ctx, tektonObj, o.Pipelineclientset, extraAnnotations); err != nil {
logger.Warnf("error handling retry: %v", err)
merr = multierror.Append(merr, err)
}
return merr
}
}
// Now mark the TektonObject as signed
if err := MarkSigned(ctx, tektonObj, o.Pipelineclientset, extraAnnotations); err != nil {
return err
}
measureMetrics(ctx, MarkedAsSignedCount, o.Recorder)
return nil
} | Signs TaskRun and PipelineRun objects, as well as generates attesations for each
Follows process of extract payload, sign payload, store payload and signature | Sign | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing.go | Apache-2.0 |
func getRawPayload(payload interface{}) ([]byte, error) {
switch payloadObj := payload.(type) {
case intoto.Statement:
return protojson.Marshal(&payloadObj)
case *intoto.Statement:
if payloadObj == nil {
return json.Marshal(payload)
}
return protojson.Marshal(payloadObj)
default:
return json.Marshal(payload)
} | getRawPayload returns the payload as a json string. If the given payload is a intoto.Statement type, protojson.Marshal
is used to get the proper labels/field names in the resulting json. | getRawPayload | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing.go | Apache-2.0 |
func Reconciled(ctx context.Context, client versioned.Interface, obj objects.TektonObject) bool {
if reconciledFromAnnotations(obj.GetAnnotations()) {
return true
}
logger := logging.FromContext(ctx)
annotations, err := obj.GetLatestAnnotations(ctx, client)
if err != nil {
logger.Warnf("Ignoring error when fetching latest annotations: %s", err)
return false
}
return reconciledFromAnnotations(annotations)
} | Reconciled determines whether a Tekton object has already been reconciled.
It first inspects the state of the given TektonObject. If that indicates it
has not been reconciled, then Reconciled fetches the latest version of the
TektonObject from the cluster and inspects that version as well. This aims
to avoid creating multiple attestations due to a stale cached TektonObject. | Reconciled | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/annotations.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/annotations.go | Apache-2.0 |
func MarkSigned(ctx context.Context, obj objects.TektonObject, ps versioned.Interface, annotations map[string]string) error {
if _, ok := obj.GetAnnotations()[ChainsAnnotation]; ok {
return nil
}
return AddAnnotation(ctx, obj, ps, ChainsAnnotation, "true", annotations)
} | MarkSigned marks a Tekton object as signed. | MarkSigned | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/annotations.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/annotations.go | Apache-2.0 |
func RegisterPayloader(key config.PayloadType, init PayloaderInit) {
payloaderMap[key] = init
} | RegisterPayloader registers the PayloaderInit func for the given type.
This is suitable to be calling during init() to register Payloader types. | RegisterPayloader | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/format.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/format.go | Apache-2.0 |
func GetPayloader(key config.PayloadType, cfg config.Config) (Payloader, error) {
fn, ok := payloaderMap[key]
if !ok {
return nil, fmt.Errorf("payloader %q not found", key)
}
return fn(cfg)
} | GetPayloader returns a new Payloader of the given type.
If no Payloader is registered for the type, an error is returned. | GetPayloader | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/format.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/format.go | Apache-2.0 |
func SubjectDigests(ctx context.Context, obj objects.TektonObject, slsaconfig *slsaconfig.SlsaConfig) []*intoto.ResourceDescriptor {
var subjects []*intoto.ResourceDescriptor
switch obj.GetObject().(type) {
case *v1.PipelineRun:
subjects = subjectsFromPipelineRun(ctx, obj, slsaconfig)
case *v1.TaskRun:
subjects = subjectsFromTektonObject(ctx, obj)
case *v1beta1.PipelineRun:
subjects = extractv1beta1.SubjectsFromPipelineRunV1Beta1(ctx, obj, slsaconfig)
case *v1beta1.TaskRun:
subjects = extractv1beta1.SubjectsFromTektonObjectV1Beta1(ctx, obj)
} | SubjectDigests returns software artifacts produced from the TaskRun/PipelineRun object
in the form of standard subject field of intoto statement.
The type hinting fields expected in results help identify the generated software artifacts.
Valid type hinting fields must:
- have suffix `IMAGE_URL` & `IMAGE_DIGEST` or `ARTIFACT_URI` & `ARTIFACT_DIGEST` pair.
- the `*_DIGEST` field must be in the format of "<algorithm>:<actual-sha>" where the algorithm must be "sha256" and actual sha must be valid per https://github.com/opencontainers/image-spec/blob/main/descriptor.md#sha-256.
- the `*_URL` or `*_URI` fields cannot be empty.
nolint:all | SubjectDigests | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/extract.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/extract.go | Apache-2.0 |
func RetrieveAllArtifactURIs(ctx context.Context, obj objects.TektonObject, deepInspectionEnabled bool) []string {
result := []string{}
subjects := SubjectDigests(ctx, obj, &slsaconfig.SlsaConfig{DeepInspectionEnabled: deepInspectionEnabled})
for _, s := range subjects {
for algo, digest := range s.Digest {
result = append(result, fmt.Sprintf("%s@%s:%s", s.Name, algo, digest))
}
}
return result
} | RetrieveAllArtifactURIs returns all the URIs of the software artifacts produced from the run object.
- It first extracts intoto subjects from run object results and converts the subjects
to a slice of string URIs in the format of "NAME" + "@" + "ALGORITHM" + ":" + "DIGEST".
- If no subjects could be extracted from results, then an empty slice is returned. | RetrieveAllArtifactURIs | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/extract.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/extract.go | Apache-2.0 |
func SubjectsFromBuildArtifact(ctx context.Context, results []objects.Result) []*intoto.ResourceDescriptor {
var subjects []*intoto.ResourceDescriptor
logger := logging.FromContext(ctx)
buildArtifacts := artifacts.ExtractBuildArtifactsFromResults(ctx, results)
for _, ba := range buildArtifacts {
splits := strings.Split(ba.Digest, ":")
if len(splits) != 2 {
logger.Errorf("Error procesing build artifact %v, digest %v malformed. Build artifact skipped", ba.FullRef(), ba.Digest)
continue
}
alg := splits[0]
digest := splits[1]
subjects = artifact.AppendSubjects(subjects, &intoto.ResourceDescriptor{
Name: ba.URI,
Digest: common.DigestSet{
alg: digest,
},
})
}
imgs := artifacts.ExtractOCIImagesFromResults(ctx, results)
for _, i := range imgs {
if d, ok := i.(name.Digest); ok {
subjects = artifact.AppendSubjects(subjects, &intoto.ResourceDescriptor{
Name: d.Repository.Name(),
Digest: common.DigestSet{
"sha256": strings.TrimPrefix(d.DigestStr(), "sha256:"),
},
})
}
}
return subjects
} | SubjectsFromBuildArtifact returns the software artifacts/images produced by the TaskRun/PipelineRun in the form of standard
subject field of intoto statement. The detection is based on type hinting. To be read as a software artifact the
type hintint should:
- use one of the following type-hints:
- Use the *ARTIFACT_OUTPUTS object type-hinting suffix. The value associated with the result should be an object
with the fields `uri`, `digest`, and `isBuildArtifact` set to true.
- Use the IMAGES type-hint
- Use the *IMAGE_URL / *IMAGE_DIGEST type-hint suffix | SubjectsFromBuildArtifact | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/extract.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/extract.go | Apache-2.0 |
func SubjectDigests(ctx context.Context, obj objects.TektonObject, slsaconfig *slsaconfig.SlsaConfig) []*intoto.ResourceDescriptor {
var subjects []*intoto.ResourceDescriptor
switch obj.GetObject().(type) {
case *v1beta1.PipelineRun:
subjects = SubjectsFromPipelineRunV1Beta1(ctx, obj, slsaconfig)
case *v1beta1.TaskRun:
subjects = SubjectsFromTektonObjectV1Beta1(ctx, obj)
} | SubjectDigests returns software artifacts produced from the TaskRun/PipelineRun object
in the form of standard subject field of intoto statement.
The type hinting fields expected in results help identify the generated software artifacts.
Valid type hinting fields must:
- have suffix `IMAGE_URL` & `IMAGE_DIGEST` or `ARTIFACT_URI` & `ARTIFACT_DIGEST` pair.
- the `*_DIGEST` field must be in the format of "<algorithm>:<actual-sha>" where the algorithm must be "sha256" and actual sha must be valid per https://github.com/opencontainers/image-spec/blob/main/descriptor.md#sha-256.
- the `*_URL` or `*_URI` fields cannot be empty.
nolint:all | SubjectDigests | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/v1beta1/extract.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/v1beta1/extract.go | Apache-2.0 |
func SubjectsFromPipelineRunV1Beta1(ctx context.Context, obj objects.TektonObject, slsaconfig *slsaconfig.SlsaConfig) []*intoto.ResourceDescriptor {
prSubjects := SubjectsFromTektonObjectV1Beta1(ctx, obj)
// If deep inspection is not enabled, just return subjects observed on the pipelinerun level
if !slsaconfig.DeepInspectionEnabled {
return prSubjects
}
logger := logging.FromContext(ctx)
// If deep inspection is enabled, collect subjects from child taskruns
var result []*intoto.ResourceDescriptor
pro := obj.(*objects.PipelineRunObjectV1Beta1)
pSpec := pro.Status.PipelineSpec
if pSpec != nil {
pipelineTasks := append(pSpec.Tasks, pSpec.Finally...)
for _, t := range pipelineTasks {
taskRuns := pro.GetTaskRunsFromTask(t.Name)
if len(taskRuns) == 0 {
logger.Infof("no taskruns found for task %s", t.Name)
continue
}
for _, tr := range taskRuns {
// Ignore Tasks that did not execute during the PipelineRun.
if tr == nil || tr.Status.CompletionTime == nil {
logger.Infof("taskrun status not found for task %s", t.Name)
continue
}
trSubjects := SubjectsFromTektonObjectV1Beta1(ctx, tr)
result = artifact.AppendSubjects(result, trSubjects...)
}
}
}
// also add subjects observed from pipelinerun level with duplication removed
result = artifact.AppendSubjects(result, prSubjects...)
return result
} | SubjectsFromPipelineRunV1Beta1 returns software artifacts produced from the PipelineRun object. | SubjectsFromPipelineRunV1Beta1 | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/v1beta1/extract.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/v1beta1/extract.go | Apache-2.0 |
func SubjectsFromTektonObjectV1Beta1(ctx context.Context, obj objects.TektonObject) []*intoto.ResourceDescriptor {
logger := logging.FromContext(ctx)
var subjects []*intoto.ResourceDescriptor
imgs := artifacts.ExtractOCIImagesFromResults(ctx, obj.GetResults())
for _, i := range imgs {
if d, ok := i.(name.Digest); ok {
subjects = artifact.AppendSubjects(subjects, &intoto.ResourceDescriptor{
Name: d.Repository.Name(),
Digest: common.DigestSet{
"sha256": strings.TrimPrefix(d.DigestStr(), "sha256:"),
},
})
}
}
sts := artifacts.ExtractSignableTargetFromResults(ctx, obj)
for _, obj := range sts {
splits := strings.Split(obj.Digest, ":")
if len(splits) != 2 {
logger.Errorf("Digest %s should be in the format of: algorthm:abc", obj.Digest)
continue
}
subjects = artifact.AppendSubjects(subjects, &intoto.ResourceDescriptor{
Name: obj.URI,
Digest: common.DigestSet{
splits[0]: splits[1],
},
})
}
ssts := artifacts.ExtractStructuredTargetFromResults(ctx, obj.GetResults(), artifacts.ArtifactsOutputsResultName)
for _, s := range ssts {
splits := strings.Split(s.Digest, ":")
alg := splits[0]
digest := splits[1]
subjects = artifact.AppendSubjects(subjects, &intoto.ResourceDescriptor{
Name: s.URI,
Digest: common.DigestSet{
alg: digest,
},
})
}
// Check if object is a Taskrun, if so search for images used in PipelineResources
// Otherwise object is a PipelineRun, where Pipelineresources are not relevant.
// PipelineResources have been deprecated so their support has been left out of
// the POC for TEP-84
// More info: https://tekton.dev/docs/pipelines/resources/
tr, ok := obj.GetObject().(*v1beta1.TaskRun) //nolint:staticcheck
if !ok || tr.Spec.Resources == nil { //nolint:staticcheck
return subjects
}
// go through resourcesResult
for _, output := range tr.Spec.Resources.Outputs { //nolint:staticcheck
name := output.Name
if output.PipelineResourceBinding.ResourceSpec == nil {
continue
}
// similarly, we could do this for other pipeline resources or whatever thing replaces them
if output.PipelineResourceBinding.ResourceSpec.Type == backport.PipelineResourceTypeImage {
// get the url and digest, and save as a subject
var url, digest string
for _, s := range tr.Status.ResourcesResult {
if s.ResourceName == name {
if s.Key == "url" {
url = s.Value
}
if s.Key == "digest" {
digest = s.Value
}
}
}
subjects = artifact.AppendSubjects(subjects, &intoto.ResourceDescriptor{
Name: url,
Digest: common.DigestSet{
"sha256": strings.TrimPrefix(digest, "sha256:"),
},
})
}
}
return subjects
} | SubjectsFromTektonObjectV1Beta1 returns software artifacts produced from the Tekton object. | SubjectsFromTektonObjectV1Beta1 | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/v1beta1/extract.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/v1beta1/extract.go | Apache-2.0 |
func RetrieveAllArtifactURIs(ctx context.Context, obj objects.TektonObject, deepInspectionEnabled bool) []string {
result := []string{}
subjects := SubjectDigests(ctx, obj, &slsaconfig.SlsaConfig{DeepInspectionEnabled: deepInspectionEnabled})
for _, s := range subjects {
for algo, digest := range s.Digest {
result = append(result, fmt.Sprintf("%s@%s:%s", s.Name, algo, digest))
}
}
return result
} | RetrieveAllArtifactURIs returns all the URIs of the software artifacts produced from the run object.
- It first extracts intoto subjects from run object results and converts the subjects
to a slice of string URIs in the format of "NAME" + "@" + "ALGORITHM" + ":" + "DIGEST".
- If no subjects could be extracted from results, then an empty slice is returned. | RetrieveAllArtifactURIs | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/v1beta1/extract.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/extract/v1beta1/extract.go | Apache-2.0 |
func AppendSubjects(original []*intoto.ResourceDescriptor, items ...*intoto.ResourceDescriptor) []*intoto.ResourceDescriptor {
var artifacts []artifact
for _, s := range original {
artifacts = append(artifacts, subjectToArtifact(s))
}
for _, s := range items {
artifacts = addArtifact(artifacts, subjectToArtifact(s))
}
var result []*intoto.ResourceDescriptor
for _, a := range artifacts {
result = append(result, artifactToSubject(a))
}
return result
} | AppendSubjects adds new subject(s) to the original slice.
It merges the new item with an existing entry if they are duplicate instead of append. | AppendSubjects | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/internal/artifact/append.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/internal/artifact/append.go | Apache-2.0 |
func AppendMaterials(original []common.ProvenanceMaterial, items ...common.ProvenanceMaterial) []common.ProvenanceMaterial {
var artifacts []artifact
for _, m := range original {
artifacts = append(artifacts, materialToArtifact(m))
}
for _, m := range items {
artifacts = addArtifact(artifacts, materialToArtifact(m))
}
var result []common.ProvenanceMaterial
for _, a := range artifacts {
result = append(result, artifactToMaterial(a))
}
return result
} | AppendMaterials adds new material(s) to the original slice.
It merges the new item with an existing entry if they are duplicate instead of append. | AppendMaterials | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/internal/artifact/append.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/internal/artifact/append.go | Apache-2.0 |
func addArtifact(original []artifact, item artifact) []artifact {
for i, a := range original {
// if there is an equivalent entry in the original slice, merge the
// artifact's DigestSet into the existing entry's DigestSet.
if artifactEqual(a, item) {
mergeMaps(original[i].digestSet, item.digestSet)
return original
}
}
original = append(original, item)
return original
} | AddArtifact adds a new artifact item to the original slice. | addArtifact | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/internal/artifact/append.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/internal/artifact/append.go | Apache-2.0 |
func artifactEqual(x, y artifact) bool {
if x.name != y.name {
return false
}
for algo, hex := range x.digestSet {
if y.digestSet[algo] == hex {
return true
}
}
return false
} | two artifacts are equal if and only if they have same name and have at least
one common algorithm and hex value. | artifactEqual | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/internal/artifact/append.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/slsa/internal/artifact/append.go | Apache-2.0 |
func (i *SimpleSigning) CreatePayload(ctx context.Context, obj interface{}) (interface{}, error) {
switch v := obj.(type) {
case name.Digest:
format := NewSimpleStruct(v)
return format, nil
default:
return nil, fmt.Errorf("unsupported type %s", v)
} | CreatePayload implements the Payloader interface. | CreatePayload | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/formats/simple/simple.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/formats/simple/simple.go | Apache-2.0 |
func InitializeBackends(ctx context.Context, ps versioned.Interface, kc kubernetes.Interface, cfg config.Config) (map[string]Backend, error) {
logger := logging.FromContext(ctx)
// Add an entry here for every configured backend
configuredBackends := []string{}
if cfg.Artifacts.TaskRuns.Enabled() {
configuredBackends = append(configuredBackends, sets.List[string](cfg.Artifacts.TaskRuns.StorageBackend)...)
}
if cfg.Artifacts.OCI.Enabled() {
configuredBackends = append(configuredBackends, sets.List[string](cfg.Artifacts.OCI.StorageBackend)...)
}
if cfg.Artifacts.PipelineRuns.Enabled() {
configuredBackends = append(configuredBackends, sets.List[string](cfg.Artifacts.PipelineRuns.StorageBackend)...)
}
logger.Infof("configured backends from config: %v", configuredBackends)
// Now only initialize and return the configured ones.
backends := map[string]Backend{}
for _, backendType := range configuredBackends {
switch backendType {
case gcs.StorageBackendGCS:
gcsBackend, err := gcs.NewStorageBackend(ctx, cfg)
if err != nil {
return nil, err
}
backends[backendType] = gcsBackend
case tekton.StorageBackendTekton:
backends[backendType] = tekton.NewStorageBackend(ps)
case oci.StorageBackendOCI:
ociBackend := oci.NewStorageBackend(ctx, kc, cfg)
backends[backendType] = ociBackend
case docdb.StorageTypeDocDB:
docdbBackend, err := docdb.NewStorageBackend(ctx, cfg)
if err != nil {
return nil, err
}
backends[backendType] = docdbBackend
case grafeas.StorageBackendGrafeas:
grafeasBackend, err := grafeas.NewStorageBackend(ctx, cfg)
if err != nil {
return nil, err
}
backends[backendType] = grafeasBackend
case pubsub.StorageBackendPubSub:
pubsubBackend, err := pubsub.NewStorageBackend(ctx, cfg)
if err != nil {
return nil, err
}
backends[backendType] = pubsubBackend
}
}
logger.Infof("successfully initialized backends: %v", maps.Keys(backends))
return backends, nil
} | InitializeBackends creates and initializes every configured storage backend. | InitializeBackends | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/storage.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/storage.go | Apache-2.0 |
func WatchBackends(ctx context.Context, watcherStop chan bool, backends map[string]Backend, cfg config.Config) error {
logger := logging.FromContext(ctx)
for backend := range backends {
switch backend {
case docdb.StorageTypeDocDB:
docdbWatcherStop := make(chan bool)
backendChan, err := docdb.WatchBackend(ctx, cfg, docdbWatcherStop)
if err != nil {
if errors.Is(err, docdb.ErrNothingToWatch) {
logger.Info(err)
continue
}
return err
}
go func() {
for {
select {
case newBackend := <-backendChan:
if newBackend == nil {
logger.Errorf("removing backend %s from backends", docdb.StorageTypeDocDB)
delete(backends, docdb.StorageTypeDocDB)
continue
}
logger.Infof("adding to backends: %s", docdb.StorageTypeDocDB)
backends[docdb.StorageTypeDocDB] = newBackend
case <-watcherStop:
// Stop the DocDB watcher first
select {
case docdbWatcherStop <- true:
logger.Info("sent close event to docdb.WatchBackend()...")
default:
logger.Info("could not send close event to docdb.WatchBackend()...")
}
// Now stop this backend
logger.Info("stop watching backends...")
return
}
}
}()
default:
logger.Debugf("no backends to watch...")
}
}
return nil
} | WatchBackends watches backends for any update and keeps them up to date. | WatchBackends | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/storage.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/storage.go | Apache-2.0 |
func WithTargetRepository(repo name.Repository) Option {
return &targetRepoOption{
repo: repo,
}
} | WithTargetRepository configures the target repository where objects will be stored. | WithTargetRepository | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/oci/options.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/oci/options.go | Apache-2.0 |
func NewStorageBackend(ctx context.Context, client kubernetes.Interface, cfg config.Config) *Backend {
return &Backend{
cfg: cfg,
client: client,
getAuthenticator: func(ctx context.Context, obj objects.TektonObject, client kubernetes.Interface) (remote.Option, error) {
kc, err := k8schain.New(ctx, client,
k8schain.Options{
Namespace: obj.GetNamespace(),
ServiceAccountName: obj.GetServiceAccountName(),
ImagePullSecrets: obj.GetPullSecrets(),
UseMountSecrets: true,
})
if err != nil {
return nil, err
}
return remote.WithAuthFromKeychain(kc), nil
},
}
} | NewStorageBackend returns a new OCI StorageBackend that stores signatures in an OCI registry | NewStorageBackend | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/oci/legacy.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/oci/legacy.go | Apache-2.0 |
func (b *Backend) StorePayload(ctx context.Context, obj objects.TektonObject, rawPayload []byte, signature string, storageOpts config.StorageOpts) error {
logger := logging.FromContext(ctx)
auth, err := b.getAuthenticator(ctx, obj, b.client)
if err != nil {
return err
}
logger.Infof("Storing payload on %s/%s/%s", obj.GetGVK(), obj.GetNamespace(), obj.GetName())
if storageOpts.PayloadFormat == formats.PayloadTypeSimpleSigning {
format := simple.SimpleContainerImage{}
if err := json.Unmarshal(rawPayload, &format); err != nil {
return errors.Wrap(err, "unmarshal simplesigning")
}
return b.uploadSignature(ctx, format, rawPayload, signature, storageOpts, auth)
}
if _, ok := formats.IntotoAttestationSet[storageOpts.PayloadFormat]; ok {
attestation := intoto.Statement{}
if err := json.Unmarshal(rawPayload, &attestation); err != nil {
return errors.Wrap(err, "unmarshal attestation")
}
// This can happen if the Task/TaskRun does not adhere to specific naming conventions
// like *IMAGE_URL that would serve as hints. This may be intentional for a Task/TaskRun
// that is not intended to produce an image, e.g. git-clone.
if len(attestation.Subject) == 0 {
logger.Infof(
"No image subject to attest for %s/%s/%s. Skipping upload to registry", obj.GetGVK(), obj.GetNamespace(), obj.GetName())
return nil
}
return b.uploadAttestation(ctx, &attestation, signature, storageOpts, auth)
}
// Fallback in case unsupported payload format is used or the deprecated "tekton" format
logger.Info("Skipping upload to OCI registry, OCI storage backend is only supported for OCI images and in-toto attestations")
return nil
} | StorePayload implements the storage.Backend interface. | StorePayload | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/oci/legacy.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/oci/legacy.go | Apache-2.0 |
func (s *AttestationStorer) Store(ctx context.Context, req *api.StoreRequest[name.Digest, *intoto.Statement]) (*api.StoreResponse, error) {
logger := logging.FromContext(ctx)
repo := req.Artifact.Repository
if s.repo != nil {
repo = *s.repo
}
se, err := ociremote.SignedEntity(req.Artifact, ociremote.WithRemoteOptions(s.remoteOpts...))
if err != nil {
return nil, errors.Wrap(err, "getting signed image")
}
// Create the new attestation for this entity.
attOpts := []static.Option{static.WithLayerMediaType(types.DssePayloadType)}
if req.Bundle.Cert != nil {
attOpts = append(attOpts, static.WithCertChain(req.Bundle.Cert, req.Bundle.Chain))
}
att, err := static.NewAttestation(req.Bundle.Signature, attOpts...)
if err != nil {
return nil, err
}
newImage, err := mutate.AttachAttestationToEntity(se, att)
if err != nil {
return nil, err
}
// Publish the signatures associated with this entity
if err := ociremote.WriteAttestations(repo, newImage, ociremote.WithRemoteOptions(s.remoteOpts...)); err != nil {
return nil, err
}
logger.Infof("Successfully uploaded attestation for %s", req.Artifact.String())
return &api.StoreResponse{}, nil
} | Store saves the given statement. | Store | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/oci/attestation.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/oci/attestation.go | Apache-2.0 |
func NewStorageBackend(ps versioned.Interface) *Backend {
return &Backend{
pipelineclientset: ps,
}
} | NewStorageBackend returns a new Tekton StorageBackend that stores signatures on a TaskRun | NewStorageBackend | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | Apache-2.0 |
func (b *Backend) StorePayload(ctx context.Context, obj objects.TektonObject, rawPayload []byte, signature string, opts config.StorageOpts) error {
logger := logging.FromContext(ctx)
store := &Storer{
client: b.pipelineclientset,
key: opts.ShortKey,
}
if _, err := store.Store(ctx, &api.StoreRequest[objects.TektonObject, *intoto.Statement]{
Object: obj,
Artifact: obj,
// We don't actually use payload - we store the raw bundle values directly.
Payload: nil,
Bundle: &signing.Bundle{
Content: rawPayload,
Signature: []byte(signature),
Cert: []byte(opts.Cert),
Chain: []byte(opts.Chain),
},
}); err != nil {
logger.Errorf("error writing to Tekton object: %w", err)
return err
}
return nil
} | StorePayload implements the Payloader interface. | StorePayload | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | Apache-2.0 |
func (b *Backend) retrieveAnnotationValue(ctx context.Context, obj objects.TektonObject, annotationKey string, decode bool) (string, error) {
logger := logging.FromContext(ctx)
logger.Infof("Retrieving annotation %q on %s/%s/%s", annotationKey, obj.GetGVK(), obj.GetNamespace(), obj.GetName())
var annotationValue string
annotations, err := obj.GetLatestAnnotations(ctx, b.pipelineclientset)
if err != nil {
return "", fmt.Errorf("error retrieving the annotation value for the key %q: %w", annotationKey, err)
}
val, ok := annotations[annotationKey]
// Ensure it exists.
if ok {
// Decode it if needed.
if decode {
decodedAnnotation, err := base64.StdEncoding.DecodeString(val)
if err != nil {
return "", fmt.Errorf("error decoding the annotation value for the key %q: %w", annotationKey, err)
}
annotationValue = string(decodedAnnotation)
} else {
annotationValue = val
}
}
return annotationValue, nil
} | retrieveAnnotationValue retrieve the value of an annotation and base64 decode it if needed. | retrieveAnnotationValue | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | Apache-2.0 |
func (b *Backend) RetrieveSignatures(ctx context.Context, obj objects.TektonObject, opts config.StorageOpts) (map[string][]string, error) {
logger := logging.FromContext(ctx)
logger.Infof("Retrieving signature on %s/%s/%s", obj.GetGVK(), obj.GetNamespace(), obj.GetName())
signatureAnnotation := sigName(opts)
signature, err := b.retrieveAnnotationValue(ctx, obj, signatureAnnotation, true)
if err != nil {
return nil, err
}
m := make(map[string][]string)
m[signatureAnnotation] = []string{signature}
return m, nil
} | RetrieveSignature retrieve the signature stored in the taskrun. | RetrieveSignatures | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | Apache-2.0 |
func (b *Backend) RetrievePayloads(ctx context.Context, obj objects.TektonObject, opts config.StorageOpts) (map[string]string, error) {
logger := logging.FromContext(ctx)
logger.Infof("Retrieving payload on %s/%s/%s", obj.GetGVK(), obj.GetNamespace(), obj.GetName())
payloadAnnotation := payloadName(opts)
payload, err := b.retrieveAnnotationValue(ctx, obj, payloadAnnotation, true)
if err != nil {
return nil, err
}
m := make(map[string]string)
m[payloadAnnotation] = payload
return m, nil
} | RetrievePayload retrieve the payload stored in the taskrun. | RetrievePayloads | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | Apache-2.0 |
func (s *Storer) Store(ctx context.Context, req *api.StoreRequest[objects.TektonObject, *intoto.Statement]) (*api.StoreResponse, error) {
logger := logging.FromContext(ctx)
obj := req.Object
logger.Infof("Storing payload on %s/%s/%s", obj.GetGVK(), obj.GetNamespace(), obj.GetName())
// Use patch instead of update to prevent race conditions.
key := s.key
if key == "" {
key = string(obj.GetUID())
}
patchBytes, err := patch.GetAnnotationsPatch(map[string]string{
// Base64 encode both the signature and the payload
fmt.Sprintf(PayloadAnnotationFormat, key): base64.StdEncoding.EncodeToString(req.Bundle.Content),
fmt.Sprintf(SignatureAnnotationFormat, key): base64.StdEncoding.EncodeToString(req.Bundle.Signature),
fmt.Sprintf(CertAnnotationsFormat, key): base64.StdEncoding.EncodeToString(req.Bundle.Cert),
fmt.Sprintf(ChainAnnotationFormat, key): base64.StdEncoding.EncodeToString(req.Bundle.Chain),
})
if err != nil {
return nil, err
}
patchErr := obj.Patch(ctx, s.client, patchBytes)
if patchErr != nil {
return nil, patchErr
}
return &api.StoreResponse{}, nil
} | Store stores the statement in the TaskRun metadata as an annotation. | Store | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/tekton/tekton.go | Apache-2.0 |
func NewStorageBackend(ctx context.Context, cfg config.Config) (*Backend, error) {
// build connection through grpc
// implicit uses Application Default Credentials to authenticate.
// Requires `gcloud auth application-default login` to work locally
creds, err := oauth.NewApplicationDefault(ctx, "https://www.googleapis.com/auth/cloud-platform")
if err != nil {
return nil, err
}
// TODO: make grafeas server configurable including checking if hostname is trusted
server := "dns:///containeranalysis.googleapis.com"
conn, err := grpc.Dial(server,
grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
grpc.WithDefaultCallOptions(grpc.PerRPCCredentials(creds)),
)
if err != nil {
return nil, err
}
// connection client
client := pb.NewGrafeasClient(conn)
// create backend instance
return &Backend{
client: client,
cfg: cfg,
}, nil
} | NewStorageBackend returns a new Grafeas StorageBackend that stores signatures in a Grafeas server | NewStorageBackend | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | Apache-2.0 |
func (b *Backend) StorePayload(ctx context.Context, obj objects.TektonObject, rawPayload []byte, signature string, opts config.StorageOpts) error {
logger := logging.FromContext(ctx)
// We only support simplesigning for OCI images, and in-toto for taskrun & pipelinerun.
if _, ok := formats.IntotoAttestationSet[opts.PayloadFormat]; !ok && opts.PayloadFormat != formats.PayloadTypeSimpleSigning {
return errors.New("Grafeas storage backend only supports simplesigning and intoto payload format.")
}
// Check if projectID is configured. If not, stop and return an error
if b.cfg.Storage.Grafeas.ProjectID == "" {
return errors.New("Project ID must be configured!")
}
// check if noteID is configured. If not, we give it a name as `tekton-<namespace>`
if b.cfg.Storage.Grafeas.NoteID == "" {
generatedNoteID := fmt.Sprintf("tekton-%s", obj.GetNamespace())
b.cfg.Storage.Grafeas.NoteID = generatedNoteID
}
// step1: create note
// If the note already exists, just move to the next step of creating occurrence.
if _, err := b.createNote(ctx, obj, opts); err != nil && status.Code(err) != codes.AlreadyExists {
return err
}
// step2: create occurrences
occurrences, err := b.createOccurrence(ctx, obj, rawPayload, signature, opts)
if err != nil {
return err
}
occNames := []string{}
for _, occ := range occurrences {
occNames = append(occNames, occ.GetName())
}
if len(occNames) == 0 {
logger.Infof("No occurrences created for payload of type %s for %s %s/%s", string(opts.PayloadFormat), obj.GetGVK(), obj.GetNamespace(), obj.GetName())
} else {
logger.Infof("Successfully created grafeas occurrences %v for %s %s/%s", occNames, obj.GetGVK(), obj.GetNamespace(), obj.GetName())
}
return nil
} | StorePayload implements the storage.Backend interface. | StorePayload | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | Apache-2.0 |
func (b *Backend) RetrievePayloads(ctx context.Context, obj objects.TektonObject, opts config.StorageOpts) (map[string]string, error) {
// initialize an empty map for result
result := make(map[string]string)
// get all occurrences created using this backend
occurrences, err := b.getAllOccurrences(ctx, obj, opts)
if err != nil {
return nil, err
}
for _, occ := range occurrences {
// get payload identifier
name := occ.GetResourceUri()
// get "Payload" field from the occurrence
payload := occ.GetEnvelope().GetPayload()
result[name] = string(payload)
}
return result, nil
} | Retrieve payloads from grafeas server and store it in a map | RetrievePayloads | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | Apache-2.0 |
func (b *Backend) RetrieveSignatures(ctx context.Context, obj objects.TektonObject, opts config.StorageOpts) (map[string][]string, error) {
// initialize an empty map for result
result := make(map[string][]string)
// get all occurrences created using this backend
occurrences, err := b.getAllOccurrences(ctx, obj, opts)
if err != nil {
return nil, err
}
for _, occ := range occurrences {
// get the Signature identifier
name := occ.GetResourceUri()
// get "Signatures" field from the occurrence
signatures := occ.GetEnvelope().GetSignatures()
// signature string
sigStrings := []string{}
for _, sig := range signatures {
sigStrings = append(sigStrings, string(sig.GetSig()))
}
result[name] = sigStrings
}
return result, nil
} | Retrieve signatures from grafeas server and store it in a map | RetrieveSignatures | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | Apache-2.0 |
func (b *Backend) createNote(ctx context.Context, obj objects.TektonObject, opts config.StorageOpts) (*pb.Note, error) {
notePrefix := b.cfg.Storage.Grafeas.NoteID
// for oci image: AttestationNote
if opts.PayloadFormat == formats.PayloadTypeSimpleSigning {
return b.client.CreateNote(ctx,
&pb.CreateNoteRequest{
Parent: b.getProjectPath(),
NoteId: fmt.Sprintf(attestationNoteNameFormat, b.cfg.Storage.Grafeas.NoteID),
Note: &pb.Note{
ShortDescription: "OCI Artifact Attestation Note",
Type: &pb.Note_Attestation{
Attestation: &pb.AttestationNote{
Hint: &pb.AttestationNote_Hint{
HumanReadableName: b.cfg.Storage.Grafeas.NoteHint,
},
},
},
},
},
)
}
return b.createBuildNote(ctx, fmt.Sprintf(buildNoteNameFormat, notePrefix, obj.GetKindName()), obj)
} | ----------------------------- Helper Functions ----------------------------
createNote creates grafeas note that will be linked to grafeas occurrences | createNote | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | Apache-2.0 |
func (b *Backend) createOccurrence(ctx context.Context, obj objects.TektonObject, payload []byte, signature string, opts config.StorageOpts) ([]*pb.Occurrence, error) {
occs := []*pb.Occurrence{}
// create Occurrence_Attestation for OCI
if opts.PayloadFormat == formats.PayloadTypeSimpleSigning {
occ, err := b.createAttestationOccurrence(ctx, payload, signature, opts.FullKey)
if err != nil {
return nil, err
}
occs = append(occs, occ)
return occs, nil
}
// create Occurrence_Build for TaskRun
allURIs := b.getAllArtifactURIs(ctx, opts.PayloadFormat, obj)
for _, uri := range allURIs {
occ, err := b.createBuildOccurrence(ctx, obj, payload, signature, uri)
if err != nil {
return nil, err
}
occs = append(occs, occ)
}
return occs, nil
} | createOccurrence creates grafeas occurrences in the grafeas server that stores the original payload and its signature
for a single oci artifact
- its simplesigning payload and signature will be stored in ATTESTATION occurrence
- the identifier/ResourceUri is IMAGE_URL@IMAGE_DIGEST
for a taskrun/pipelinerun object
- its intoto payload and signature will be stored in a BUILD occurrences for each image artifact generated from the taskrun/pipelinerun
- each BUILD occurrence will have the same data but differ in the ResourceUri field
- the identifier/ResourceUri is IMAGE_URL@IMAGE_DIGEST | createOccurrence | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | Apache-2.0 |
func (b *Backend) getAllOccurrences(ctx context.Context, obj objects.TektonObject, opts config.StorageOpts) ([]*pb.Occurrence, error) {
result := []*pb.Occurrence{}
// step 1: get all resource URIs created under the taskrun
uriFilters := b.getAllArtifactURIs(ctx, opts.PayloadFormat, obj)
// step 2: find all build occurrences
if _, ok := formats.IntotoAttestationSet[opts.PayloadFormat]; ok {
occs, err := b.findOccurrencesForCriteria(ctx, b.getBuildNotePath(obj), uriFilters)
if err != nil {
return nil, err
}
result = append(result, occs...)
}
// step 3: find all attestation occurrences
if opts.PayloadFormat == formats.PayloadTypeSimpleSigning {
occs, err := b.findOccurrencesForCriteria(ctx, b.getAttestationNotePath(), uriFilters)
if err != nil {
return nil, err
}
result = append(result, occs...)
}
return result, nil
} | getAllOccurrences retrieves back all occurrences created for a taskrun | getAllOccurrences | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | Apache-2.0 |
func (b *Backend) findOccurrencesForCriteria(ctx context.Context, noteName string, resourceURIs []string) ([]*pb.Occurrence, error) {
var uriFilters []string
for _, url := range resourceURIs {
uriFilters = append(uriFilters, fmt.Sprintf("resourceUrl=%q", url))
}
occurences, err := b.client.ListNoteOccurrences(ctx,
&pb.ListNoteOccurrencesRequest{
Name: noteName,
Filter: strings.Join(uriFilters, " OR "),
},
)
if err != nil {
return nil, err
}
return occurences.GetOccurrences(), nil
} | findOccurrencesForCriteria lookups a project's occurrences by the resource uri | findOccurrencesForCriteria | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/grafeas/grafeas.go | Apache-2.0 |
func NewStorageBackend(ctx context.Context, cfg config.Config) (*Backend, error) {
client, err := storage.NewClient(ctx)
if err != nil {
return nil, err
}
bucket := cfg.Storage.GCS.Bucket
return &Backend{
writer: &writer{client: client, bucket: bucket},
reader: &reader{client: client, bucket: bucket},
cfg: cfg,
}, nil
} | NewStorageBackend returns a new Tekton StorageBackend that stores signatures on a TaskRun | NewStorageBackend | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/gcs/gcs.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/gcs/gcs.go | Apache-2.0 |
func (b *Backend) StorePayload(ctx context.Context, obj objects.TektonObject, rawPayload []byte, signature string, opts config.StorageOpts) error {
logger := logging.FromContext(ctx)
if tr, isTaskRun := obj.GetObject().(*v1.TaskRun); isTaskRun {
store := &TaskRunStorer{
writer: b.writer,
key: opts.ShortKey,
}
if _, err := store.Store(ctx, &api.StoreRequest[*v1.TaskRun, *in_toto.Statement]{
Object: obj,
Artifact: tr,
// We don't actually use payload - we store the raw bundle values directly.
Payload: nil,
Bundle: &signing.Bundle{
Content: rawPayload,
Signature: []byte(signature),
Cert: []byte(opts.Cert),
Chain: []byte(opts.Chain),
},
}); err != nil {
logger.Errorf("error writing to GCS: %w", err)
return err
}
} else if pr, isPipelineRun := obj.GetObject().(*v1.PipelineRun); isPipelineRun {
store := &PipelineRunStorer{
writer: b.writer,
key: opts.ShortKey,
}
// TODO(https://github.com/tektoncd/chains/issues/665) currently using deprecated v1beta1 APIs until we add full v1 support
if _, err := store.Store(ctx, &api.StoreRequest[*v1.PipelineRun, *in_toto.Statement]{
Object: obj,
Artifact: pr,
// We don't actually use payload - we store the raw bundle values directly.
Payload: nil,
Bundle: &signing.Bundle{
Content: rawPayload,
Signature: []byte(signature),
Cert: []byte(opts.Cert),
Chain: []byte(opts.Chain),
},
}); err != nil {
logger.Errorf("error writing to GCS: %w", err)
return err
}
} else {
return fmt.Errorf("type %T not supported - supported types: [*v1.TaskRun, *v1.PipelineRun]", obj.GetObject())
}
return nil
} | StorePayload implements the storage.Backend interface. As of chains v0.20.0+,
this method has been updated to use Tekton v1 objects (previously v1beta1) and
it's error messages have been updated to reflect this.
nolint:staticcheck | StorePayload | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/gcs/gcs.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/gcs/gcs.go | Apache-2.0 |
func NewStorageBackend(ctx context.Context, cfg config.Config) (*Backend, error) {
return &Backend{
cfg: cfg,
}, nil
} | NewStorageBackend returns a new Tekton StorageBackend that stores signatures on a TaskRun | NewStorageBackend | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/pubsub/pubsub.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/pubsub/pubsub.go | Apache-2.0 |
func NewStorageBackend(ctx context.Context, cfg config.Config) (*Backend, error) {
docdbURL := cfg.Storage.DocDB.URL
u, err := url.Parse(docdbURL)
if err != nil {
return nil, err
}
if u.Scheme == mongodocstore.Scheme {
// MONGO_SERVER_URL can be passed in as an environment variable or via config fields
if err := populateMongoServerURL(ctx, cfg); err != nil {
return nil, err
}
}
coll, err := docstore.OpenCollection(ctx, docdbURL)
if err != nil {
return nil, err
}
return &Backend{
coll: coll,
}, nil
} | NewStorageBackend returns a new Tekton StorageBackend that stores signatures on a TaskRun | NewStorageBackend | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/docdb/docdb.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/docdb/docdb.go | Apache-2.0 |
func WatchBackend(ctx context.Context, cfg config.Config, watcherStop chan bool) (chan *Backend, error) {
logger := logging.FromContext(ctx)
docDBURL := cfg.Storage.DocDB.URL
u, err := url.Parse(docDBURL)
if err != nil {
return nil, err
}
// Set up the watcher only for mongo backends
if u.Scheme != mongodocstore.Scheme {
return nil, ErrNothingToWatch
}
pathsToWatch := getPathsToWatch(ctx, cfg)
if len(pathsToWatch) == 0 {
return nil, ErrNothingToWatch
}
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, err
}
backendChan := make(chan *Backend)
// Start listening for events.
go func() {
for {
select {
case event, ok := <-watcher.Events:
if !ok {
return
}
logger.Infof("received event: %s, path: %s", event.Op.String(), event.Name)
// Only respond to create/write/remove events in the directory
if !(event.Has(fsnotify.Create) || event.Has(fsnotify.Write) || event.Has(fsnotify.Remove)) {
continue
}
if !slices.Contains(pathsToWatch, event.Name) {
continue
}
var updatedEnv string
if cfg.Storage.DocDB.MongoServerURLPath != "" {
updatedEnv, err = getMongoServerURLFromPath(cfg.Storage.DocDB.MongoServerURLPath)
if err != nil {
logger.Error(err)
backendChan <- nil
}
} else if cfg.Storage.DocDB.MongoServerURLDir != "" {
updatedEnv, err = getMongoServerURLFromDir(cfg.Storage.DocDB.MongoServerURLDir)
if err != nil {
logger.Error(err)
backendChan <- nil
}
}
if updatedEnv != os.Getenv("MONGO_SERVER_URL") {
logger.Info("Mongo server url has been updated, reconfiguring backend...")
// Now that MONGO_SERVER_URL has been updated, we should update docdb backend again
newDocDBBackend, err := NewStorageBackend(ctx, cfg)
if err != nil {
logger.Error(err)
backendChan <- nil
} else {
// Storing the backend in the signer so everyone has access to the up-to-date backend
backendChan <- newDocDBBackend
}
} else {
logger.Infof("MONGO_SERVER_URL has not changed in path: %s, backend will not be reconfigured", cfg.Storage.DocDB.MongoServerURLDir)
}
case err, ok := <-watcher.Errors:
if !ok {
return
}
logger.Error(err)
case <-watcherStop:
logger.Info("stopping fsnotify context...")
return
}
}
}()
if cfg.Storage.DocDB.MongoServerURLPath != "" {
dirPath := filepath.Dir(cfg.Storage.DocDB.MongoServerURLPath)
// Add a path.
err = watcher.Add(dirPath)
if err != nil {
return nil, err
}
}
if cfg.Storage.DocDB.MongoServerURLDir != "" {
// Add a path.
err = watcher.Add(cfg.Storage.DocDB.MongoServerURLDir)
if err != nil {
return nil, err
}
}
return backendChan, nil
} | WatchBackend returns a channel that receives a new Backend each time it needs to be updated | WatchBackend | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/docdb/docdb.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/docdb/docdb.go | Apache-2.0 |
func (b *Backend) StorePayload(ctx context.Context, _ objects.TektonObject, rawPayload []byte, signature string, opts config.StorageOpts) error {
var obj interface{}
if err := json.Unmarshal(rawPayload, &obj); err != nil {
return err
}
entry := SignedDocument{
Signed: rawPayload,
Signature: base64.StdEncoding.EncodeToString([]byte(signature)),
Object: obj,
Name: opts.ShortKey,
Cert: opts.Cert,
Chain: opts.Chain,
}
if err := b.coll.Put(ctx, &entry); err != nil {
return err
}
return nil
} | StorePayload implements the Payloader interface. | StorePayload | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/docdb/docdb.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/docdb/docdb.go | Apache-2.0 |
func getMongoServerURLFromPath(path string) (string, error) {
fileData, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("reading file in %q: %w", path, err)
}
// A trailing newline is fairly common in mounted files, so remove it.
fileDataNormalized := strings.TrimSuffix(string(fileData), "\n")
return fileDataNormalized, nil
} | getMongoServerUrlFromPath retreives token from the given mount path | getMongoServerURLFromPath | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/storage/docdb/docdb.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/storage/docdb/docdb.go | Apache-2.0 |
func NewSigner(ctx context.Context, secretPath string, cfg config.Config) (*Signer, error) {
x509PrivateKeyPath := filepath.Join(secretPath, "x509.pem")
cosignPrivateKeypath := filepath.Join(secretPath, "cosign.key")
if cfg.Signers.X509.FulcioEnabled {
return fulcioSigner(ctx, cfg.Signers.X509)
} else if contents, err := os.ReadFile(x509PrivateKeyPath); err == nil {
return x509Signer(ctx, contents)
} else if contents, err := os.ReadFile(cosignPrivateKeypath); err == nil {
return cosignSigner(ctx, secretPath, contents)
}
return nil, errors.New("no valid private key found, looked for: [x509.pem, cosign.key]")
} | NewSigner returns a configured Signer | NewSigner | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/x509.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/x509.go | Apache-2.0 |
func initializeTUF(ctx context.Context, mirror string) error {
logger := logging.FromContext(ctx)
// Get the initial trusted root contents.
root, err := url.JoinPath(mirror, "root.json")
if err != nil {
return err
}
rootFileBytes, err := loadRootFromURL(root)
if err != nil {
return err
}
if err = tuf.Initialize(ctx, mirror, rootFileBytes); err != nil {
return err
}
status, err := tuf.GetRootStatus(ctx)
if err != nil {
return err
}
b, err := json.MarshalIndent(status, "", "\t")
if err != nil {
return err
}
logger.Infof("Root status: %s", string(b))
return nil
} | root: TUF_URL/root.json
mirror: TUF_URL | initializeTUF | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/x509.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/x509.go | Apache-2.0 |
func (s *Signer) Chain() string {
return s.chain
} | there is no cert or chain, return nothing | Chain | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/x509.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/x509.go | Apache-2.0 |
func (ga *filesystemCustomPath) Enabled(ctx context.Context) bool {
// If we can stat the file without error then this is enabled.
_, err := os.Stat(FilesystemTokenPath)
return err == nil
} | Enabled implements providers.Interface | Enabled | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/fsprovider.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/fsprovider.go | Apache-2.0 |
func (ga *filesystemCustomPath) Provide(ctx context.Context, audience string) (string, error) {
b, err := os.ReadFile(FilesystemTokenPath)
if err != nil {
return "", err
}
return string(b), nil
} | Provide implements providers.Interface | Provide | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/fsprovider.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/x509/fsprovider.go | Apache-2.0 |
func NewSigner(ctx context.Context, cfg config.KMSSigner) (*Signer, error) {
kmsOpts := []signature.RPCOption{}
// Checks if the vault address provide by the user is a valid address or not
if cfg.Auth.Address != "" {
vaultAddress, err := url.Parse(cfg.Auth.Address)
if err != nil {
return nil, err
}
var vaultUrl *url.URL
switch {
case vaultAddress.Port() != "":
vaultUrl = vaultAddress
case vaultAddress.Scheme == "http":
vaultUrl = &url.URL{
Scheme: vaultAddress.Scheme,
Host: vaultAddress.Host + ":80",
}
case vaultAddress.Scheme == "https":
vaultUrl = &url.URL{
Scheme: vaultAddress.Scheme,
Host: vaultAddress.Host + ":443",
}
case vaultAddress.Scheme == "":
vaultUrl = &url.URL{
Scheme: "http",
Host: cfg.Auth.Address + ":80",
}
case vaultAddress.Scheme != "" && vaultAddress.Scheme != "http" && vaultAddress.Scheme != "https":
vaultUrl = &url.URL{
Scheme: "http",
Host: cfg.Auth.Address,
}
if vaultUrl.Port() == "" {
vaultUrl.Host = cfg.Auth.Address + ":80"
}
}
if vaultUrl != nil {
conn, err := net.DialTimeout("tcp", vaultUrl.Host, 5*time.Second)
if err != nil {
return nil, err
}
defer conn.Close()
} else {
return nil, fmt.Errorf("Error connecting to URL %s\n", cfg.Auth.Address)
}
}
// pass through configuration options to RPCAuth used by KMS in sigstore
rpcAuth := options.RPCAuth{
Address: cfg.Auth.Address,
OIDC: options.RPCAuthOIDC{
Role: cfg.Auth.OIDC.Role,
Path: cfg.Auth.OIDC.Path,
},
}
// get token from file KMS_AUTH_TOKEN, a mounted secret at signers.kms.auth.token-dir or
// as direct value set from signers.kms.auth.token.
// If both values are set, priority will be given to token-dir.
if cfg.Auth.TokenPath != "" {
rpcAuthToken, err := getKMSAuthToken(cfg.Auth.TokenPath)
if err != nil {
return nil, err
}
rpcAuth.Token = rpcAuthToken
} else {
rpcAuth.Token = cfg.Auth.Token
}
// get token from spire
if cfg.Auth.Spire.Sock != "" {
token, err := newSpireToken(ctx, cfg)
if err != nil {
return nil, err
}
rpcAuth.OIDC.Token = token
}
kmsOpts = append(kmsOpts, options.WithRPCAuthOpts(rpcAuth))
// get the signer/verifier from sigstore
k, err := kms.Get(ctx, cfg.KMSRef, crypto.SHA256, kmsOpts...)
if err != nil {
return nil, err
}
return &Signer{
SignerVerifier: k,
}, nil
} | NewSigner returns a configured Signer | NewSigner | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | Apache-2.0 |
func getKMSAuthToken(path string) (string, error) {
fileData, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("reading file in %q: %w", path, err)
}
// A trailing newline is fairly common in mounted files, so remove it.
fileDataNormalized := strings.TrimSuffix(string(fileData), "\n")
return fileDataNormalized, nil
} | getKMSAuthToken retreives token from the given mount path | getKMSAuthToken | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | Apache-2.0 |
func newSpireToken(ctx context.Context, cfg config.KMSSigner) (string, error) {
jwtSource, err := workloadapi.NewJWTSource(
ctx,
workloadapi.WithClientOptions(workloadapi.WithAddr(cfg.Auth.Spire.Sock)),
)
if err != nil {
return "", err
}
svid, err := jwtSource.FetchJWTSVID(ctx, jwtsvid.Params{Audience: cfg.Auth.Spire.Audience})
if err != nil {
return "", err
}
return svid.Marshal(), nil
} | newSpireToken retrieves an SVID token from Spire | newSpireToken | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | Apache-2.0 |
func (s *Signer) Type() string {
return signing.TypeKMS
} | Type returns the type of the signer | Type | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | Apache-2.0 |
func (s *Signer) Cert() string {
return ""
} | Cert there is no cert, return nothing | Cert | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | Apache-2.0 |
func (s *Signer) Chain() string {
return ""
} | Chain there is no chain, return nothing | Chain | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/signing/kms/kms.go | Apache-2.0 |
func getPodPullSecrets(podTemplate *pod.Template) []string {
imgPullSecrets := []string{}
if podTemplate != nil {
for _, secret := range podTemplate.ImagePullSecrets {
imgPullSecrets = append(imgPullSecrets, secret.Name)
}
}
return imgPullSecrets
} | Get the imgPullSecrets from a pod template, if they exist | getPodPullSecrets | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/chains/objects/objects.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/chains/objects/objects.go | Apache-2.0 |
func FromContext(ctx context.Context) *Config {
return ctx.Value(cfgKey{}).(*Config)
} | FromContext fetch config from context. | FromContext | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/config/store.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/config/store.go | Apache-2.0 |
func ToContext(ctx context.Context, c *Config) context.Context {
return context.WithValue(ctx, cfgKey{}, c)
} | ToContext adds config to given context. | ToContext | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/config/store.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/config/store.go | Apache-2.0 |
func (s *ConfigStore) ToContext(ctx context.Context) context.Context {
return ToContext(ctx, s.Load())
} | ToContext adds Store contents to given context. | ToContext | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/config/store.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/config/store.go | Apache-2.0 |
func (s *ConfigStore) Load() *Config {
return s.UntypedLoad(ChainsConfig).(*Config).DeepCopy()
} | Load fetches config from Store. | Load | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/config/store.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/config/store.go | Apache-2.0 |
func NewConfigStore(logger configmap.Logger, onAfterStore ...func(name string, value interface{})) *ConfigStore {
return &ConfigStore{
UntypedStore: configmap.NewUntypedStore(
"chains",
logger,
configmap.Constructors{
ChainsConfig: NewConfigFromConfigMap,
},
onAfterStore...,
),
}
} | NewConfigStore returns a reconciler.ConfigStore for the chains configuration data. | NewConfigStore | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/config/store.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/config/store.go | Apache-2.0 |
func (in *Artifact) DeepCopyInto(out *Artifact) {
*out = *in
if in.StorageBackend != nil {
in, out := &in.StorageBackend, &out.StorageBackend
*out = make(sets.Set[string], len(*in))
for key, val := range *in {
(*out)[key] = val
}
}
return
} | DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. | DeepCopyInto | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/config/zz_generated.deepcopy.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/config/zz_generated.deepcopy.go | Apache-2.0 |
func (in *Artifact) DeepCopy() *Artifact {
if in == nil {
return nil
}
out := new(Artifact)
in.DeepCopyInto(out)
return out
} | DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Artifact. | DeepCopy | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/config/zz_generated.deepcopy.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/config/zz_generated.deepcopy.go | Apache-2.0 |
func (in *ArtifactConfigs) DeepCopyInto(out *ArtifactConfigs) {
*out = *in
in.TaskRuns.DeepCopyInto(&out.TaskRuns)
in.OCI.DeepCopyInto(&out.OCI)
return
} | DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. | DeepCopyInto | go | tektoncd/cli | vendor/github.com/tektoncd/chains/pkg/config/zz_generated.deepcopy.go | https://github.com/tektoncd/cli/blob/master/vendor/github.com/tektoncd/chains/pkg/config/zz_generated.deepcopy.go | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.