From 031721dc5d857e69d9ee849747f944a34fa004a7 Mon Sep 17 00:00:00 2001 From: Guilhem Lettron Date: Wed, 13 Oct 2021 19:59:09 +0200 Subject: [PATCH 1/2] feat: Add an omaha source Signed-off-by: Guilhem Lettron --- Makefile | 13 +- PROJECT | 3 + api/v1beta1/omaha_types.go | 161 +++++++ api/v1beta1/zz_generated.deepcopy.go | 104 +++++ .../source.toolkit.fluxcd.io_omahas.yaml | 150 +++++++ config/crd/kustomization.yaml | 1 + config/crd/kustomizeconfig.yaml | 17 + config/crd/patches/cainjection_in_omahas.yaml | 8 + config/crd/patches/webhook_in_omahas.yaml | 17 + config/manager/kustomization.yaml | 5 + config/rbac/omaha_editor_role.yaml | 24 ++ config/rbac/omaha_viewer_role.yaml | 20 + config/rbac/role.yaml | 20 + config/samples/source_v1beta1_omaha.yaml | 10 + controllers/omaha_controller.go | 398 ++++++++++++++++++ controllers/omaha_controller_test.go | 152 +++++++ controllers/suite_test.go | 13 +- go.mod | 3 + go.sum | 10 +- main.go | 13 + 20 files changed, 1123 insertions(+), 19 deletions(-) create mode 100644 api/v1beta1/omaha_types.go create mode 100644 config/crd/bases/source.toolkit.fluxcd.io_omahas.yaml create mode 100644 config/crd/kustomizeconfig.yaml create mode 100644 config/crd/patches/cainjection_in_omahas.yaml create mode 100644 config/crd/patches/webhook_in_omahas.yaml create mode 100644 config/rbac/omaha_editor_role.yaml create mode 100644 config/rbac/omaha_viewer_role.yaml create mode 100644 config/samples/source_v1beta1_omaha.yaml create mode 100644 controllers/omaha_controller.go create mode 100644 controllers/omaha_controller_test.go diff --git a/Makefile b/Makefile index 3053b281e..0a05278a5 100644 --- a/Makefile +++ b/Makefile @@ -163,19 +163,8 @@ docker-push: ## Push Docker image docker push $(IMG):$(TAG) controller-gen: ## Find or download controller-gen -ifeq (, $(shell which controller-gen)) - @{ \ - set -e; \ - CONTROLLER_GEN_TMP_DIR=$$(mktemp -d); \ - cd $$CONTROLLER_GEN_TMP_DIR; \ - go mod init tmp; \ - go get sigs.k8s.io/controller-tools/cmd/controller-gen@$(CONTROLLER_GEN_VERSION); \ - rm -rf $$CONTROLLER_GEN_TMP_DIR; \ - } + go install sigs.k8s.io/controller-tools/cmd/controller-gen@$(CONTROLLER_GEN_VERSION) CONTROLLER_GEN=$(GOBIN)/controller-gen -else -CONTROLLER_GEN=$(shell which controller-gen) -endif gen-crd-api-reference-docs: ## Find or download gen-crd-api-reference-docs ifeq (, $(shell which gen-crd-api-reference-docs)) diff --git a/PROJECT b/PROJECT index a807390b9..76acc1a2c 100644 --- a/PROJECT +++ b/PROJECT @@ -13,4 +13,7 @@ resources: - group: source kind: Bucket version: v1beta1 +- group: source + kind: Omaha + version: v1beta1 version: "2" diff --git a/api/v1beta1/omaha_types.go b/api/v1beta1/omaha_types.go new file mode 100644 index 000000000..5465f52cb --- /dev/null +++ b/api/v1beta1/omaha_types.go @@ -0,0 +1,161 @@ +/* +Copyright 2020 The Flux authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +import ( + "github.com/fluxcd/pkg/apis/meta" + apimeta "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// OmahaSpec defines the desired state of Omaha +type OmahaSpec struct { + // The Omaha server URL, a valid URL contains at least a protocol and host. + // +required + URL string `json:"url"` + + // +required + AppID string `json:"appid"` + + // +required + Track string `json:"track"` + + // +optional + Arch string `json:"arch"` + + // The interval at which to check for omaha updates. + // +required + Interval metav1.Duration `json:"interval"` + + // This flag tells the controller to suspend the reconciliation of this source. + // +optional + Suspend bool `json:"suspend,omitempty"` +} + +// OmahaStatus defines the observed state of Omaha +type OmahaStatus struct { + // ObservedGeneration is the last observed generation. + // +optional + ObservedGeneration int64 `json:"observedGeneration,omitempty"` + + // Conditions holds the conditions for Ohama. + // +optional + Conditions []metav1.Condition `json:"conditions,omitempty"` + + // URL is the download link for the artifact output of the last Ohama sync. + // +optional + URL string `json:"url,omitempty"` + + // TODO + AppVersion string `json:"appVersion,omitempty"` + + // Artifact represents the output of the last successful Omaha sync. + // +optional + Artifact *Artifact `json:"artifact,omitempty"` + + meta.ReconcileRequestStatus `json:",inline"` +} + +const ( + // OmahaOperationSucceedReason represents the fact that the omaha listing and + // download operations succeeded. + OmahaOperationSucceedReason string = "OmahaOperationSucceed" + + // OmahaOperationFailedReason represents the fact that the omaha listing or + // download operations failed. + OmahaOperationFailedReason string = "OmahaOperationFailed" +) + +// OmahaProgressing resets the conditions of the Omaha to metav1.Condition of +// type meta.ReadyCondition with status 'Unknown' and meta.ProgressingReason +// reason and message. It returns the modified Omaha. +func OmahaProgressing(omaha Omaha) Omaha { + omaha.Status.ObservedGeneration = omaha.Generation + omaha.Status.URL = "" + omaha.Status.Conditions = []metav1.Condition{} + meta.SetResourceCondition(&omaha, meta.ReadyCondition, metav1.ConditionUnknown, meta.ProgressingReason, "reconciliation in progress") + return omaha +} + +// OmahaReady sets the given Artifact and URL on the Omaha and sets the +// meta.ReadyCondition to 'True', with the given reason and message. It returns +// the modified Omaha. +func OmahaReady(omaha Omaha, artifact *Artifact, url, reason, message string) Omaha { + omaha.Status.Artifact = artifact + omaha.Status.URL = url + meta.SetResourceCondition(&omaha, meta.ReadyCondition, metav1.ConditionTrue, reason, message) + return omaha +} + +// OmahaNotReady sets the meta.ReadyCondition on the Omaha to 'False', with +// the given reason and message. It returns the modified Omaha. +func OmahaNotReady(omaha Omaha, reason, message string) Omaha { + meta.SetResourceCondition(&omaha, meta.ReadyCondition, metav1.ConditionFalse, reason, message) + return omaha +} + +// OmahaReadyMessage returns the message of the metav1.Condition of type +// meta.ReadyCondition with status 'True' if present, or an empty string. +func OmahaReadyMessage(omaha Omaha) string { + if c := apimeta.FindStatusCondition(omaha.Status.Conditions, meta.ReadyCondition); c != nil { + if c.Status == metav1.ConditionTrue { + return c.Message + } + } + return "" +} + +// GetArtifact returns the latest artifact from the source if present in the +// status sub-resource. +func (in *Omaha) GetArtifact() *Artifact { + return in.Status.Artifact +} + +// GetStatusConditions returns a pointer to the Status.Conditions slice +func (in *Omaha) GetStatusConditions() *[]metav1.Condition { + return &in.Status.Conditions +} + +// GetInterval returns the interval at which the source is updated. +func (in *Omaha) GetInterval() metav1.Duration { + return in.Spec.Interval +} + +//+kubebuilder:object:root=true +//+kubebuilder:subresource:status + +// Omaha is the Schema for the omahas API +type Omaha struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + Spec OmahaSpec `json:"spec,omitempty"` + Status OmahaStatus `json:"status,omitempty"` +} + +//+kubebuilder:object:root=true + +// OmahaList contains a list of Omaha +type OmahaList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []Omaha `json:"items"` +} + +func init() { + SchemeBuilder.Register(&Omaha{}, &OmahaList{}) +} diff --git a/api/v1beta1/zz_generated.deepcopy.go b/api/v1beta1/zz_generated.deepcopy.go index 443f17a31..6bde2ad07 100644 --- a/api/v1beta1/zz_generated.deepcopy.go +++ b/api/v1beta1/zz_generated.deepcopy.go @@ -1,3 +1,4 @@ +//go:build !ignore_autogenerated // +build !ignore_autogenerated /* @@ -608,3 +609,106 @@ func (in *LocalHelmChartSourceReference) DeepCopy() *LocalHelmChartSourceReferen in.DeepCopyInto(out) return out } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Omaha) DeepCopyInto(out *Omaha) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + out.Spec = in.Spec + in.Status.DeepCopyInto(&out.Status) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Omaha. +func (in *Omaha) DeepCopy() *Omaha { + if in == nil { + return nil + } + out := new(Omaha) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Omaha) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OmahaList) DeepCopyInto(out *OmahaList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]Omaha, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OmahaList. +func (in *OmahaList) DeepCopy() *OmahaList { + if in == nil { + return nil + } + out := new(OmahaList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *OmahaList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OmahaSpec) DeepCopyInto(out *OmahaSpec) { + *out = *in + out.Interval = in.Interval +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OmahaSpec. +func (in *OmahaSpec) DeepCopy() *OmahaSpec { + if in == nil { + return nil + } + out := new(OmahaSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OmahaStatus) DeepCopyInto(out *OmahaStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]v1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Artifact != nil { + in, out := &in.Artifact, &out.Artifact + *out = new(Artifact) + (*in).DeepCopyInto(*out) + } + out.ReconcileRequestStatus = in.ReconcileRequestStatus +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OmahaStatus. +func (in *OmahaStatus) DeepCopy() *OmahaStatus { + if in == nil { + return nil + } + out := new(OmahaStatus) + in.DeepCopyInto(out) + return out +} diff --git a/config/crd/bases/source.toolkit.fluxcd.io_omahas.yaml b/config/crd/bases/source.toolkit.fluxcd.io_omahas.yaml new file mode 100644 index 000000000..a4b70f1f0 --- /dev/null +++ b/config/crd/bases/source.toolkit.fluxcd.io_omahas.yaml @@ -0,0 +1,150 @@ + +--- +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.5.0 + creationTimestamp: null + name: omahas.source.toolkit.fluxcd.io +spec: + group: source.toolkit.fluxcd.io + names: + kind: Omaha + listKind: OmahaList + plural: omahas + singular: omaha + scope: Namespaced + versions: + - name: v1beta1 + schema: + openAPIV3Schema: + description: Omaha is the Schema for the omahas API + properties: + apiVersion: + description: 'APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources' + type: string + kind: + description: 'Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds' + type: string + metadata: + type: object + spec: + description: OmahaSpec defines the desired state of Omaha + properties: + appid: + type: string + arch: + type: string + interval: + description: The interval at which to check for omaha updates. + type: string + suspend: + description: This flag tells the controller to suspend the reconciliation of this source. + type: boolean + track: + type: string + url: + description: The Omaha server URL, a valid URL contains at least a protocol and host. + type: string + required: + - appid + - interval + - track + - url + type: object + status: + description: OmahaStatus defines the observed state of Omaha + properties: + appVersion: + description: TODO + type: string + artifact: + description: Artifact represents the output of the last successful Omaha sync. + properties: + checksum: + description: Checksum is the SHA1 checksum of the artifact. + type: string + lastUpdateTime: + description: LastUpdateTime is the timestamp corresponding to the last update of this artifact. + format: date-time + type: string + path: + description: Path is the relative file path of this artifact. + type: string + revision: + description: Revision is a human readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm index timestamp, a Helm chart version, etc. + type: string + url: + description: URL is the HTTP address of this artifact. + type: string + required: + - path + - url + type: object + conditions: + description: Conditions holds the conditions for Ohama. + items: + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + properties: + lastTransitionTime: + description: lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + format: date-time + type: string + message: + description: message is a human readable message indicating details about the transition. This may be an empty string. + maxLength: 32768 + type: string + observedGeneration: + description: observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. + format: int64 + minimum: 0 + type: integer + reason: + description: reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty. + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ + type: string + status: + description: status of the condition, one of True, False, Unknown. + enum: + - "True" + - "False" + - Unknown + type: string + type: + description: type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt) + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ + type: string + required: + - lastTransitionTime + - message + - reason + - status + - type + type: object + type: array + lastHandledReconcileAt: + description: LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change can be detected. + type: string + observedGeneration: + description: ObservedGeneration is the last observed generation. + format: int64 + type: integer + url: + description: URL is the download link for the artifact output of the last Ohama sync. + type: string + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: [] + storedVersions: [] diff --git a/config/crd/kustomization.yaml b/config/crd/kustomization.yaml index a666a9259..47aba692e 100644 --- a/config/crd/kustomization.yaml +++ b/config/crd/kustomization.yaml @@ -5,4 +5,5 @@ resources: - bases/source.toolkit.fluxcd.io_helmrepositories.yaml - bases/source.toolkit.fluxcd.io_helmcharts.yaml - bases/source.toolkit.fluxcd.io_buckets.yaml +- bases/source.toolkit.fluxcd.io_omahas.yaml # +kubebuilder:scaffold:crdkustomizeresource diff --git a/config/crd/kustomizeconfig.yaml b/config/crd/kustomizeconfig.yaml new file mode 100644 index 000000000..6f83d9a94 --- /dev/null +++ b/config/crd/kustomizeconfig.yaml @@ -0,0 +1,17 @@ +# This file is for teaching kustomize how to substitute name and namespace reference in CRD +nameReference: +- kind: Service + version: v1 + fieldSpecs: + - kind: CustomResourceDefinition + group: apiextensions.k8s.io + path: spec/conversion/webhookClientConfig/service/name + +namespace: +- kind: CustomResourceDefinition + group: apiextensions.k8s.io + path: spec/conversion/webhookClientConfig/service/namespace + create: false + +varReference: +- path: metadata/annotations diff --git a/config/crd/patches/cainjection_in_omahas.yaml b/config/crd/patches/cainjection_in_omahas.yaml new file mode 100644 index 000000000..e407c1721 --- /dev/null +++ b/config/crd/patches/cainjection_in_omahas.yaml @@ -0,0 +1,8 @@ +# The following patch adds a directive for certmanager to inject CA into the CRD +# CRD conversion requires k8s 1.13 or later. +apiVersion: apiextensions.k8s.io/v1beta1 +kind: CustomResourceDefinition +metadata: + annotations: + cert-manager.io/inject-ca-from: $(CERTIFICATE_NAMESPACE)/$(CERTIFICATE_NAME) + name: omahas.source.toolkit.fluxcd.io diff --git a/config/crd/patches/webhook_in_omahas.yaml b/config/crd/patches/webhook_in_omahas.yaml new file mode 100644 index 000000000..38b3a6d62 --- /dev/null +++ b/config/crd/patches/webhook_in_omahas.yaml @@ -0,0 +1,17 @@ +# The following patch enables conversion webhook for CRD +# CRD conversion requires k8s 1.13 or later. +apiVersion: apiextensions.k8s.io/v1beta1 +kind: CustomResourceDefinition +metadata: + name: omahas.source.toolkit.fluxcd.io +spec: + conversion: + strategy: Webhook + webhookClientConfig: + # this is "\n" used as a placeholder, otherwise it will be rejected by the apiserver for being blank, + # but we're going to set it later using the cert-manager (or potentially a patch if not using cert-manager) + caBundle: Cg== + service: + namespace: system + name: webhook-service + path: /convert diff --git a/config/manager/kustomization.yaml b/config/manager/kustomization.yaml index 3206171eb..216e53049 100644 --- a/config/manager/kustomization.yaml +++ b/config/manager/kustomization.yaml @@ -5,5 +5,10 @@ resources: - deployment.yaml images: - name: fluxcd/source-controller +<<<<<<< HEAD newName: fluxcd/source-controller newTag: v0.19.2 +======= + newName: docker.io/guilhem/source-controller + newTag: omaha +>>>>>>> c11d601 (feat: Add an omaha source) diff --git a/config/rbac/omaha_editor_role.yaml b/config/rbac/omaha_editor_role.yaml new file mode 100644 index 000000000..8e8c48eee --- /dev/null +++ b/config/rbac/omaha_editor_role.yaml @@ -0,0 +1,24 @@ +# permissions for end users to edit omahas. +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: omaha-editor-role +rules: +- apiGroups: + - source.toolkit.fluxcd.io + resources: + - omahas + verbs: + - create + - delete + - get + - list + - patch + - update + - watch +- apiGroups: + - source.toolkit.fluxcd.io + resources: + - omahas/status + verbs: + - get diff --git a/config/rbac/omaha_viewer_role.yaml b/config/rbac/omaha_viewer_role.yaml new file mode 100644 index 000000000..55f1f5bf7 --- /dev/null +++ b/config/rbac/omaha_viewer_role.yaml @@ -0,0 +1,20 @@ +# permissions for end users to view omahas. +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: omaha-viewer-role +rules: +- apiGroups: + - source.toolkit.fluxcd.io + resources: + - omahas + verbs: + - get + - list + - watch +- apiGroups: + - source.toolkit.fluxcd.io + resources: + - omahas/status + verbs: + - get diff --git a/config/rbac/role.yaml b/config/rbac/role.yaml index 8cf5c66a0..effc59c7c 100644 --- a/config/rbac/role.yaml +++ b/config/rbac/role.yaml @@ -141,3 +141,23 @@ rules: - get - patch - update +- apiGroups: + - source.toolkit.fluxcd.io + resources: + - omahas + verbs: + - create + - delete + - get + - list + - patch + - update + - watch +- apiGroups: + - source.toolkit.fluxcd.io + resources: + - omahas/status + verbs: + - get + - patch + - update diff --git a/config/samples/source_v1beta1_omaha.yaml b/config/samples/source_v1beta1_omaha.yaml new file mode 100644 index 000000000..2f32b5a63 --- /dev/null +++ b/config/samples/source_v1beta1_omaha.yaml @@ -0,0 +1,10 @@ +apiVersion: source.toolkit.fluxcd.io/v1beta1 +kind: Omaha +metadata: + name: omaha-sample +spec: + url: http://10.152.183.78 + appid: 4246ed1e-5137-412b-8e0f-28964bd70ab8 + track: stable + arch: all + interval: 30m diff --git a/controllers/omaha_controller.go b/controllers/omaha_controller.go new file mode 100644 index 000000000..a07aea4a0 --- /dev/null +++ b/controllers/omaha_controller.go @@ -0,0 +1,398 @@ +/* +Copyright 2020 The Flux authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controllers + +import ( + "context" + "errors" + "fmt" + "net/http" + "path" + "time" + + "github.com/go-logr/logr" + apimeta "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + kuberecorder "k8s.io/client-go/tools/record" + "k8s.io/client-go/tools/reference" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller" + "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" + "sigs.k8s.io/controller-runtime/pkg/predicate" + + "github.com/fluxcd/pkg/apis/meta" + "github.com/fluxcd/pkg/runtime/events" + "github.com/fluxcd/pkg/runtime/metrics" + "github.com/fluxcd/pkg/runtime/predicates" + sourcev1 "github.com/fluxcd/source-controller/api/v1beta1" + sourcev1beta1 "github.com/fluxcd/source-controller/api/v1beta1" + goomaha "github.com/kinvolk/go-omaha/omaha" + oclient "github.com/kinvolk/go-omaha/omaha/client" +) + +//+kubebuilder:rbac:groups=source.toolkit.fluxcd.io,resources=omahas,verbs=get;list;watch;create;update;patch;delete +//+kubebuilder:rbac:groups=source.toolkit.fluxcd.io,resources=omahas/status,verbs=get;update;patch + +// OmahaReconciler reconciles a Omaha object +type OmahaReconciler struct { + client.Client + Scheme *runtime.Scheme + Storage *Storage + EventRecorder kuberecorder.EventRecorder + ExternalEventRecorder *events.Recorder + MetricsRecorder *metrics.Recorder +} + +type OmahaReconcilerOptions struct { + MaxConcurrentReconciles int +} + +func (r *OmahaReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { + start := time.Now() + log := logr.FromContext(ctx) + + var omaha sourcev1beta1.Omaha + if err := r.Get(ctx, req.NamespacedName, &omaha); err != nil { + log.Error(err, "can't get Omaha", "Object", req.NamespacedName) + return ctrl.Result{}, client.IgnoreNotFound(err) + } + + // Record suspended status metric + defer r.recordSuspension(ctx, omaha) + + // Add our finalizer if it does not exist + if !controllerutil.ContainsFinalizer(&omaha, sourcev1beta1.SourceFinalizer) { + controllerutil.AddFinalizer(&omaha, sourcev1beta1.SourceFinalizer) + if err := r.Update(ctx, &omaha); err != nil { + log.Error(err, "unable to register finalizer") + return ctrl.Result{}, err + } + } + + // Examine if the object is under deletion + if !omaha.ObjectMeta.DeletionTimestamp.IsZero() { + return r.reconcileDelete(ctx, omaha) + } + + // Return early if the object is suspended. + if omaha.Spec.Suspend { + log.Info("Reconciliation is suspended for this object") + return ctrl.Result{}, nil + } + + if r.MetricsRecorder != nil { + objRef, err := reference.GetReference(r.Scheme, &omaha) + if err != nil { + return ctrl.Result{}, err + } + defer r.MetricsRecorder.RecordDuration(*objRef, start) + } + + // set initial status + if resetOmaha, ok := r.resetStatus(omaha); ok { + log.Info("status reset") + omaha = resetOmaha + if err := r.updateStatus(ctx, req, omaha.Status); err != nil { + log.Error(err, "unable to update status") + return ctrl.Result{Requeue: true}, err + } + r.recordReadiness(ctx, omaha) + } + + // record the value of the reconciliation request, if any + // TODO(hidde): would be better to defer this in combination with + // always patching the status sub-resource after a reconciliation. + if v, ok := meta.ReconcileAnnotationValue(omaha.GetAnnotations()); ok { + omaha.Status.SetLastHandledReconcileRequest(v) + } + + // purge old artifacts from storage + if err := r.gc(omaha); err != nil { + log.Error(err, "unable to purge old artifacts") + } + + // reconcile omaha by downloading its content + reconciledOmaha, reconcileErr := r.reconcile(ctx, *omaha.DeepCopy()) + + // update status with the reconciliation result + if err := r.updateStatus(ctx, req, reconciledOmaha.Status); err != nil { + log.Error(err, "unable to update status") + return ctrl.Result{Requeue: true}, err + } + + // if reconciliation failed, record the failure and requeue immediately + if reconcileErr != nil { + r.event(ctx, reconciledOmaha, events.EventSeverityError, reconcileErr.Error()) + r.recordReadiness(ctx, reconciledOmaha) + return ctrl.Result{Requeue: true}, reconcileErr + } + + // emit revision change event + if omaha.Status.Artifact == nil || reconciledOmaha.Status.Artifact.Revision != omaha.Status.Artifact.Revision { + log.Info("event") + r.event(ctx, reconciledOmaha, events.EventSeverityInfo, sourcev1beta1.OmahaReadyMessage(reconciledOmaha)) + } + r.recordReadiness(ctx, reconciledOmaha) + + log.Info(fmt.Sprintf("Reconciliation finished in %s, next run in %s", + time.Now().Sub(start).String(), + omaha.GetInterval().Duration.String(), + )) + + return ctrl.Result{RequeueAfter: omaha.GetInterval().Duration}, nil +} + +func (r *OmahaReconciler) reconcile(ctx context.Context, omaha sourcev1beta1.Omaha) (sourcev1beta1.Omaha, error) { + log := logr.FromContext(ctx) + + // oc, err := oclient.New(omaha.Spec.URL, string(omaha.UID)) + // if err != nil { + // return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.URLInvalidReason, err.Error()), err + // } + + version := omaha.Status.AppVersion + if version == "" { + version = "0.0.0" + } + + appc, err := oclient.NewAppClient(omaha.Spec.URL, string(omaha.UID), omaha.Spec.AppID, version) + if err != nil { + return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.URLInvalidReason, err.Error()), err + } + + if omaha.Spec.Arch == "" { + appc.SetArch("all") + } else { + appc.SetArch(omaha.Spec.Arch) + } + + appc.SetMachine(false) + + if err := appc.SetTrack(omaha.Spec.Track); err != nil { + return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.OmahaOperationFailedReason, err.Error()), err + } + + upd, err := appc.UpdateCheck() + if err != nil { + log.Error(err, "updatecheck fail", "url", omaha.Spec.URL, "appID", omaha.Spec.AppID, "version", version) + return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.OmahaOperationFailedReason, err.Error()), err + } + + switch upd.Status { + case goomaha.NoUpdate: + log.Info("no update") + return omaha, nil + case goomaha.UpdateOK: + break + default: + err := fmt.Errorf("omaha status '%s': %w", upd.Status, err) + return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.OmahaOperationFailedReason, err.Error()), err + } + + var url string + + switch l := len(upd.URLs); { + case l == 0: + err := errors.New("can't find URL") + return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.OmahaOperationFailedReason, err.Error()), err + case l > 1: + log.Info("answer with more than 1 url, keep only one") + fallthrough + case l == 1: + url = upd.URLs[0].CodeBase + } + + // for _, url := range upd.URLs { + resp, err := http.Get(url) + if err != nil { + log.Error(err, "can't download file", "url", url) + return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.StorageOperationFailedReason, err.Error()), err + } + defer resp.Body.Close() + + newVersion := upd.Manifest.Version + + artifact := r.Storage.NewArtifactFor(omaha.Kind, + omaha.GetObjectMeta(), + newVersion, + fmt.Sprintf("%s-%s", newVersion, path.Base(url))) + + // create artifact dir + + if err := r.Storage.MkdirAll(artifact); err != nil { + err = fmt.Errorf("unable to create repository index directory: %w", err) + return sourcev1.OmahaNotReady(omaha, sourcev1.StorageOperationFailedReason, err.Error()), err + } + + // acquire lock + unlock, err := r.Storage.Lock(artifact) + if err != nil { + err = fmt.Errorf("unable to acquire lock: %w", err) + return sourcev1.OmahaNotReady(omaha, sourcev1.StorageOperationFailedReason, err.Error()), err + } + defer unlock() + + if err := r.Storage.AtomicWriteFile(&artifact, resp.Body, 0644); err != nil { + err := fmt.Errorf("can't store file: %w", err) + return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.StorageOperationFailedReason, err.Error()), err + } + + storageURL, err := r.Storage.Symlink(artifact, "latest.tar.gz") + if err != nil { + err = fmt.Errorf("storage symlink error: %w", err) + return sourcev1beta1.OmahaNotReady(omaha, sourcev1beta1.StorageOperationFailedReason, err.Error()), err + } + + message := fmt.Sprintf("Fetched revision: %s", artifact.Revision) + return sourcev1beta1.OmahaReady(omaha, &artifact, storageURL, sourcev1beta1.OmahaOperationSucceedReason, message), nil +} + +func (r *OmahaReconciler) reconcileDelete(ctx context.Context, omaha sourcev1beta1.Omaha) (ctrl.Result, error) { + if err := r.gc(omaha); err != nil { + r.event(ctx, omaha, events.EventSeverityError, + fmt.Sprintf("garbage collection for deleted resource failed: %s", err.Error())) + // Return the error so we retry the failed garbage collection + return ctrl.Result{}, err + } + + // Record deleted status + r.recordReadiness(ctx, omaha) + + // Remove our finalizer from the list and update it + controllerutil.RemoveFinalizer(&omaha, sourcev1.SourceFinalizer) + if err := r.Update(ctx, &omaha); err != nil { + return ctrl.Result{}, err + } + + // Stop reconciliation as the object is being deleted + return ctrl.Result{}, nil +} + +// resetStatus returns a modified v1beta1.Omaha and a boolean indicating +// if the status field has been reset. +func (r *OmahaReconciler) resetStatus(omaha sourcev1beta1.Omaha) (sourcev1beta1.Omaha, bool) { + // We do not have an artifact, or it does no longer exist + if omaha.GetArtifact() == nil || !r.Storage.ArtifactExist(*omaha.GetArtifact()) { + omaha = sourcev1beta1.OmahaProgressing(omaha) + omaha.Status.Artifact = nil + return omaha, true + } + if omaha.Generation != omaha.Status.ObservedGeneration { + return sourcev1beta1.OmahaProgressing(omaha), true + } + return omaha, false +} + +// gc performs a garbage collection for the given v1beta1.Omaha. +// It removes all but the current artifact except for when the +// deletion timestamp is set, which will result in the removal of +// all artifacts for the resource. +func (r *OmahaReconciler) gc(omaha sourcev1beta1.Omaha) error { + if !omaha.DeletionTimestamp.IsZero() { + return r.Storage.RemoveAll(r.Storage.NewArtifactFor(omaha.Kind, omaha.GetObjectMeta(), "", "*")) + } + if omaha.GetArtifact() != nil { + return r.Storage.RemoveAllButCurrent(*omaha.GetArtifact()) + } + return nil +} + +// event emits a Kubernetes event and forwards the event to notification controller if configured +func (r *OmahaReconciler) event(ctx context.Context, omaha sourcev1beta1.Omaha, severity, msg string) { + log := logr.FromContext(ctx) + if r.EventRecorder != nil { + r.EventRecorder.Eventf(&omaha, "Normal", severity, msg) + } + if r.ExternalEventRecorder != nil { + objRef, err := reference.GetReference(r.Scheme, &omaha) + if err != nil { + log.Error(err, "unable to send event") + return + } + + if err := r.ExternalEventRecorder.Eventf(*objRef, nil, severity, severity, msg); err != nil { + log.Error(err, "unable to send event") + return + } + } +} + +func (r *OmahaReconciler) recordReadiness(ctx context.Context, omaha sourcev1beta1.Omaha) { + log := logr.FromContext(ctx) + if r.MetricsRecorder == nil { + return + } + objRef, err := reference.GetReference(r.Scheme, &omaha) + if err != nil { + log.Error(err, "unable to record readiness metric") + return + } + if rc := apimeta.FindStatusCondition(omaha.Status.Conditions, meta.ReadyCondition); rc != nil { + r.MetricsRecorder.RecordCondition(*objRef, *rc, !omaha.DeletionTimestamp.IsZero()) + } else { + r.MetricsRecorder.RecordCondition(*objRef, metav1.Condition{ + Type: meta.ReadyCondition, + Status: metav1.ConditionUnknown, + }, !omaha.DeletionTimestamp.IsZero()) + } +} + +func (r *OmahaReconciler) recordSuspension(ctx context.Context, omaha sourcev1beta1.Omaha) { + if r.MetricsRecorder == nil { + return + } + log := logr.FromContext(ctx) + + objRef, err := reference.GetReference(r.Scheme, &omaha) + if err != nil { + log.Error(err, "unable to record suspended metric") + return + } + + if !omaha.DeletionTimestamp.IsZero() { + r.MetricsRecorder.RecordSuspend(*objRef, false) + } else { + r.MetricsRecorder.RecordSuspend(*objRef, omaha.Spec.Suspend) + } +} + +func (r *OmahaReconciler) updateStatus(ctx context.Context, req ctrl.Request, newStatus sourcev1beta1.OmahaStatus) error { + var omaha sourcev1beta1.Omaha + if err := r.Get(ctx, req.NamespacedName, &omaha); err != nil { + return err + } + + patch := client.MergeFrom(omaha.DeepCopy()) + omaha.Status = newStatus + + return r.Status().Patch(ctx, &omaha, patch) +} + +// SetupWithManager sets up the controller with the Manager. +func (r *OmahaReconciler) SetupWithManager(mgr ctrl.Manager) error { + return r.SetupWithManagerAndOptions(mgr, OmahaReconcilerOptions{}) +} + +func (r *OmahaReconciler) SetupWithManagerAndOptions(mgr ctrl.Manager, opts OmahaReconcilerOptions) error { + return ctrl.NewControllerManagedBy(mgr). + For(&sourcev1beta1.Omaha{}). + WithEventFilter(predicate.Or(predicate.GenerationChangedPredicate{}, predicates.ReconcileRequestedPredicate{})). + WithOptions(controller.Options{MaxConcurrentReconciles: opts.MaxConcurrentReconciles}). + Complete(r) +} diff --git a/controllers/omaha_controller_test.go b/controllers/omaha_controller_test.go new file mode 100644 index 000000000..6b6937778 --- /dev/null +++ b/controllers/omaha_controller_test.go @@ -0,0 +1,152 @@ +/* +Copyright 2020 The Flux authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package controllers + +import ( + "context" + "fmt" + "os" + "path" + "time" + + sourcev1 "github.com/fluxcd/source-controller/api/v1beta1" + "github.com/kinvolk/go-omaha/omaha" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" +) + +var _ = Describe("OmahaReconciler", func() { + + const ( + timeout = time.Second * 30 + interval = time.Second * 1 + indexInterval = time.Second * 2 + repositoryTimeout = time.Second * 5 + ) + + Context("Omaha", func() { + var ( + namespace *corev1.Namespace + omahaServer *omaha.TrivialServer + err error + ) + + BeforeEach(func() { + namespace = &corev1.Namespace{ + ObjectMeta: metav1.ObjectMeta{Name: "omaha-repository-" + randStringRunes(5)}, + } + err = k8sClient.Create(context.Background(), namespace) + Expect(err).NotTo(HaveOccurred(), "failed to create test namespace") + + omahaServer, err = omaha.NewTrivialServer("127.0.0.1:0") + Expect(err).To(Succeed()) + }) + + AfterEach(func() { + Expect(omahaServer.Destroy()).Should(Succeed()) + // os.RemoveAll(omahaServer.Root()) + + Eventually(func() error { + return k8sClient.Delete(context.Background(), namespace) + }, timeout, interval).Should(Succeed(), "failed to delete test namespace") + }) + + It("Creates artifacts for", func() { + omahaServer.SetVersion("1.2.3") + Expect(omahaServer.AddPackage(path.Join("testdata/charts/helmchart-0.1.0.tgz"), "app")).Should(Succeed()) + + go omahaServer.Serve() + + key := types.NamespacedName{ + Name: "omaha-sample-" + randStringRunes(5), + Namespace: namespace.Name, + } + created := &sourcev1.Omaha{ + ObjectMeta: metav1.ObjectMeta{ + Name: key.Name, + Namespace: key.Namespace, + }, + Spec: sourcev1.OmahaSpec{ + URL: fmt.Sprintf("http://%s", omahaServer.Addr().String()), + Interval: metav1.Duration{Duration: indexInterval}, + AppID: "app", + // Timeout: &metav1.Duration{Duration: repositoryTimeout}, + }, + } + Expect(k8sClient.Create(context.Background(), created)).Should(Succeed()) + + By("Expecting artifact") + got := &sourcev1.Omaha{} + Eventually(func() bool { + _ = k8sClient.Get(context.Background(), key, got) + return got.Status.Artifact != nil && storage.ArtifactExist(*got.Status.Artifact) + }, timeout, interval).Should(BeTrue()) + + By("Expecting revision change and GC") + omahaServer.SetVersion("1.2.4") + + Eventually(func() bool { + now := &sourcev1.Omaha{} + _ = k8sClient.Get(context.Background(), key, now) + // Test revision change and garbage collection + return now.Status.Artifact != nil && now.Status.Artifact.Revision != got.Status.Artifact.Revision && + !storage.ArtifactExist(*got.Status.Artifact) + }, timeout, interval).Should(BeTrue()) + + updated := &sourcev1.Omaha{} + Expect(k8sClient.Get(context.Background(), key, updated)).Should(Succeed()) + updated.Spec.URL = "invalid#url?" + Expect(k8sClient.Update(context.Background(), updated)).Should(Succeed()) + Eventually(func() bool { + _ = k8sClient.Get(context.Background(), key, updated) + for _, c := range updated.Status.Conditions { + if c.Reason == sourcev1.URLInvalidReason { + return true + } + } + return false + }, timeout, interval).Should(BeTrue()) + Expect(updated.Status.Artifact).ToNot(BeNil()) + + By("Expecting to delete successfully") + got = &sourcev1.Omaha{} + Eventually(func() error { + _ = k8sClient.Get(context.Background(), key, got) + return k8sClient.Delete(context.Background(), got) + }, timeout, interval).Should(Succeed()) + + By("Expecting delete to finish") + Eventually(func() error { + r := &sourcev1.Omaha{} + return k8sClient.Get(context.Background(), key, r) + }, timeout, interval).ShouldNot(Succeed()) + + exists := func(path string) bool { + // wait for tmp sync on macOS + time.Sleep(time.Second) + _, err := os.Stat(path) + return err == nil + } + + By("Expecting GC after delete") + Eventually(exists(got.Status.Artifact.Path), timeout, interval).ShouldNot(BeTrue()) + }) + }) +}) diff --git a/controllers/suite_test.go b/controllers/suite_test.go index 5f5341155..394a9704a 100644 --- a/controllers/suite_test.go +++ b/controllers/suite_test.go @@ -86,12 +86,6 @@ var _ = BeforeSuite(func(done Done) { err = sourcev1.AddToScheme(scheme.Scheme) Expect(err).NotTo(HaveOccurred()) - err = sourcev1.AddToScheme(scheme.Scheme) - Expect(err).NotTo(HaveOccurred()) - - err = sourcev1.AddToScheme(scheme.Scheme) - Expect(err).NotTo(HaveOccurred()) - // +kubebuilder:scaffold:scheme Expect(loadExampleKeys()).To(Succeed()) @@ -140,6 +134,13 @@ var _ = BeforeSuite(func(done Done) { }).SetupWithManager(k8sManager) Expect(err).ToNot(HaveOccurred(), "failed to setup HelmChartReconciler") + err = (&OmahaReconciler{ + Client: k8sManager.GetClient(), + Scheme: scheme.Scheme, + Storage: storage, + }).SetupWithManager(k8sManager) + Expect(err).ToNot(HaveOccurred(), "failed to setup OmahaReconciler") + go func() { err = k8sManager.Start(ctrl.SetupSignalHandler()) Expect(err).ToNot(HaveOccurred()) diff --git a/go.mod b/go.mod index f781aa473..75ed57d9c 100644 --- a/go.mod +++ b/go.mod @@ -33,6 +33,7 @@ require ( github.com/googleapis/gax-go/v2 v2.1.0 // indirect github.com/gorilla/handlers v1.5.1 // indirect github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 // indirect + github.com/kinvolk/go-omaha v0.0.1 github.com/libgit2/git2go/v31 v31.6.1 github.com/minio/minio-go/v7 v7.0.15 github.com/onsi/ginkgo v1.16.4 @@ -78,3 +79,5 @@ replace github.com/opencontainers/runc => github.com/opencontainers/runc v1.0.3 // Fix CVE-2021-41190 replace github.com/opencontainers/image-spec => github.com/opencontainers/image-spec v1.0.2 + +replace github.com/kinvolk/go-omaha => github.com/guilhem/go-omaha v0.0.2-0.20211019232651-3b6535cd26d0 diff --git a/go.sum b/go.sum index 0acdc7568..310d34ab1 100644 --- a/go.sum +++ b/go.sum @@ -136,7 +136,10 @@ github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6r github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84= +github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= +github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= +github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= github.com/bshuster-repo/logrus-logstash-hook v1.0.0/go.mod h1:zsTqEiSzDgAa/8GZR7E1qaXrhYNDKBYy5/dWPTIflbk= github.com/bshuster-repo/logrus-logstash-hook v1.0.2 h1:JYRWo+QGnQdedgshosug9hxpPYTB9oJ1ZZD3fY31alU= github.com/bshuster-repo/logrus-logstash-hook v1.0.2/go.mod h1:HgYntJprnHSPaF9VPPPLP1L5S1vMWxRfa1J+vzDrDTw= @@ -498,8 +501,9 @@ github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaU github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/googleapis/gax-go/v2 v2.1.0 h1:6DWmvNpomjL1+3liNSZbVns3zsYzzCjm6pRBO1tLeso= @@ -530,6 +534,8 @@ github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgf github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/guilhem/go-omaha v0.0.2-0.20211019232651-3b6535cd26d0 h1:hUpYU5t+f+1NsPiwkwz7mK4yHUOxveJtZUZ/UWk8dcE= +github.com/guilhem/go-omaha v0.0.2-0.20211019232651-3b6535cd26d0/go.mod h1:SAEkKv9dpmCAVA3KxGdlHMoO4VaCAfIZuui57PqGQbg= github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE= github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= @@ -624,6 +630,8 @@ github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 h1:SOEGU9fKiNWd/HOJuq6+3iTQz8KNCLtVX6idSoTLdUw= github.com/lann/builder v0.0.0-20180802200727-47ae307949d0/go.mod h1:dXGbAdH5GtBTC4WfIxhKZfyBF/HBFgRZSWwZ9g/He9o= github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 h1:P6pPBnrTSX3DEVR4fDembhRWSsG5rVo6hYhAB/ADZrk= diff --git a/main.go b/main.go index 67f00a920..003e02fff 100644 --- a/main.go +++ b/main.go @@ -223,6 +223,19 @@ func main() { setupLog.Error(err, "unable to create controller", "controller", "Bucket") os.Exit(1) } + if err = (&controllers.OmahaReconciler{ + Client: mgr.GetClient(), + Scheme: mgr.GetScheme(), + Storage: storage, + EventRecorder: mgr.GetEventRecorderFor(controllerName), + ExternalEventRecorder: eventRecorder, + MetricsRecorder: metricsRecorder, + }).SetupWithManagerAndOptions(mgr, controllers.OmahaReconcilerOptions{ + MaxConcurrentReconciles: concurrent, + }); err != nil { + setupLog.Error(err, "unable to create controller", "controller", "Omaha") + os.Exit(1) + } // +kubebuilder:scaffold:builder go func() { From cbebb291663974d62354d8258b94cb338afbb704 Mon Sep 17 00:00:00 2001 From: Guilhem Lettron Date: Wed, 20 Oct 2021 17:53:57 +0200 Subject: [PATCH 2/2] doc: update overview made with draw.io png include schema to be updated easily Signed-off-by: Guilhem Lettron --- docs/diagrams/source-controller-overview.png | Bin 45175 -> 92924 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/docs/diagrams/source-controller-overview.png b/docs/diagrams/source-controller-overview.png index 554c005403e01d12cee25bc10f5db17107e50aad..3620ca96025efad8b8c65e70dfc5c3de4e1d87db 100644 GIT binary patch literal 92924 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 G=>GwiRb*WN literal 45175 zcmce7Wk6J2v^Ew9D#{=rf=bLFLrV=H-81yi-5^LvgQSAM&t@N?5zLP>&v;A8ZibJJVE-`8A_a*_lU{j_VqA8M+K8Zt*mN53^>*u2K7tE;W7 ztbk#Oh@GpetMl_S9{c5u&7JhLG&bMt`Ptdv;NbecgTaA;h!>3h#XF-5e>y&Q%E-tt zFfe$RcWq`QR=V0HD@cs#(WMd)&=J6;B{V#zHfQzK^S)9B3_jt`zDey$2D!Rwcv?DQ zJ{zv^KH#;8qQI29%0RgB<_vg`kf4g-xBoQ)Is^fMH1Yqxp8)1-czyrRPe4aS*?K{7 z^fUgoEI~g5J~z!U5P=CtCOr~EWUS_V-YDQ_5DttWHHY~f9iQ!~73RE3X+9_G^&eAG zqrI`TNHwkmK@bEG`~9F28;%WOxD?~FNu3w^K?WhHnq@v^M%Pz-t62XN1L>e3%DG8U zU+54m$8Y(>Qbny{X^+|ZGLTm7Ispy2J))SU7llblW|hDYe5$8CmQVSphJ4bXX64H) zhacfBexeV~)Ez1q!5bKp`P_y(v@5C%aO>@*qNBPXsv$W+0r1cc3`drDD@rt94GHDD zN0~eT?6?*ZzWA~n-CebW9#Qs>Vnh&_kgIXOYT;{k`zHLd5-@9QCzr;VtzPsi+U&0d ze#!RJ)7BQZl(^LJNNvEt8TI2yhbOZfFP7|W@zXbUjpp5hsj&@a-#*}VCyIhy8}dQ7dC3&#N~L}EDbEO)zId=74ZJ? zcnjAME8W4_aGG(K5&#Nh8N!5}W8B-M^3#A9kmIAts+MO~&uZZ9;~2Zqxjv#x__`k&CoDKLlFZL!Gca|=mZdw!_hci1>V#)wwTD@SX zk}BQD=^c;Qd=(B+wdk)Pz|1>;4#UuoxP~X%Xt(yqm0vDb<43#07IZ~bGBp`O zUMy6cR+k|kXHWv-6NH& z68Ep0E5H4fN9uql_n^phk6hf5SA6%^z|>qO3c&pO+;5jG?Hroio*qlM(igke`2csr zM=pX-n@TL!Tb5;jKn|5_@5zKz|ywip%JZ>{?3v~3ip2zvccURrWd;2NB0w1sE1Ky4f zyuDuWm?kSo>>?6h5)=;h7~58lgx|Q@qr+KHUput--8|s2EWo2u?G+v9yY(H+R z1V8m*>KC0p<75Y(xCNs7J-&-Yq757LM}o^{ff{*Iqc)Vy$Kio+C!fRT{I5zFT=*3_ z@t8Ec!s{PKQ<_J=E{3dK(4|V_<7@v7xit^CnZy~`hbwA9H0Q(r5vs58%pj8&YoG~g z+i}I?$n{LD-#c?sy3iNBqi<-g8ZX^3oEP2k0SJcX%O;D{6LW0eh1|oi-t_x&FA?1fgr-HrkGB{(8q}qnxH55ol@GV`hXorCnY=j zhFmYxX+&(7x8omjhn9L7yr_pLL6>Iofe)+nAXmG|_W`wt55GV}K*ghO+R)QM8fLzUHGHk7c@s z8-+U`Dnh*R%(k;dqJ34J+tr;7X?+t67YDyP;@$K?I$Mg-A(WXQXQUm|?Z-Lc09X{I zsSES|JTh2^6y_IzQn%7|hKsYEU(2PA3}<^v190s2slNiA6sMkf?4mBX)p`BO6$g&L zWpLj=|h zO$-KXU+IM_O%Pnm_18ZX=6Pv+#+Q0;vR>5JSf4<=Lznv=YR8vc9n#ScZ7N11l{#M> z5D*-uLl)0~WUG z&t)47CM}*eaG*debc9nz;Wd6jGkwBnANR8+QUu{|gYyd-wHovjh&U0#?XB7+7He#pf~!{FF= z+*4m~7@`0L_4_r=x-*KDASx!)8uavtz*tJ$tF5x-~Ynqec2f_&H-)9KrhG)7t z@a}Lp3fP(mR^Mr?FD*ia2G+}Pmou@I2p9B;I^v&8dsWR|v^gg~=yZzFm1lk^dyrb? zzb8{J_e)cW#!?RDoaTQZwsWPad?|HiF8P=s1O%J&Q|nfLaO|hjc8s)A4p1)&2yqL| z=f8vm0dq;CqkUDaXG(uAmzT=GV1yqZ{2K?b2N0O7%#}HCOftC5=|U>4A;+-hjFOo} zAu%$$oQ@ax*eSK?&$8u$Ud#NIIJgR1@``W0mk3fa%NcM18bpFu>s#x~X0+r?j2)K? z2QIj1M?y$tDwsj5XEk>i?~0x?Ldn!RYz@?HdU2W>z(i*A68y~96~E7mOC78;?GBx7 zmvC~I;Fygv)3nSyYFcHufMg`7(tlT)`aTY=t+~H);wJRuYUDKk)zDU%H?tj#hbc2h z8y4=d^N^OO^L8=1FEt1l%&I;a?dvq2$8cWA-X~LogajPV-07p_RQd+P_d8i7L8E<3 zpeGl~pBbzJ&A&y$gOuKW##_XfU+&OeIq2mmcCc&k<86FeSb5m;aa$~k^AQ1oMh>|) zY+kITXp}`T-m@ch!x+uK1pzu90u7!@2iLzUj#`jHq<+r#tnPv~1EBr}Ak5JbqkS#R zWMsX?ZIx(s_s|)?7`SJk3I1W2PyhPzM}+hjT`W{kI>Y~Ki~udL>kt%iKgSvXk)>P< zkKh_B#pT^m@NL5zM-kCfn!3c2?h!B*=jnxneEH|Ai5y9p!?GGGTC^1Ry1)XzO*=h7mDG|J?6oHP<>ZNwHTE|%V%xqVq{+%4BNQ!~i?ieQks~niKvXyY`2lv9 zl>HLAnrW(jA0X^s%e1txE5rK)U$;X#OH+TT!S`b2*4ZJtl^M)y^$JY+MZj(n@8!1m z&0kOC@oab*6$0a`Fu^_W=>`GGUcA;u|F@HS;a`m=gwMoe`k3eufAeqU0!zmIS+#U# z*{(Vp8U}8KFTYHdbphq%y+*4M6Ku-n11xaSpRVOF+rdys6X$}uif$78>D2aRL5k}C z3N`zpR^Vyj9!Cc8jYbI1-z1oL_qH^3VCLjG)me$b5*|QKC?LXqHwdPk`m|to zZ1Rh!DXB9HR2TOeGzRVh1evyJY}Q>p;~5E?RYL1SD^%kiK-%Pp2X5Z@q;*B&(A0d| z{z`uXnJT5R@z7Br9S6s_D&coERq(LL@KAJruJoP~K>+)Y(p062 zY)wafrLW2Fl_W8TO87IuhkIHu&Qj@-EwXHF6# z9L^x;KzGeWg>9Y&PH2E&{mHj(HC+7XcG_z8@r=G}<1!e)@_=8DlQ8?=HO5w9a`2J z+VbV-^5V)a(nT*61f|M43rt~ z1rWwNH?ge+o2PQ>_+wX9@yzs;)tYxUaNo8-|e7J_jOzG z@!cwFw?N+Sp&l0oew0wt+&8Mde`E}f9irPG4KZj3##nc)*)OJg?v7nlgLjgr3%cGHNCmU3A zcT4#gBptvut{$(gF!KDcx*ay+eiy*pu;JMXho?p%f5r;uj2Q;R>UUmmQDxJy~q6 zOVmYqi}6rzRo6^ze^&|xDe>}7{JMF019(d#KKXqi1R!6<)UxxIQ83d!_H?gba4o^3 zUQiC@p--smiU~!f8f+Y7U&-S^7$Pcn@GHSNpZ@vIv4UjyE-gK$D2Lk$aeoNOc!|(U z+j{)A>IHzrE#Hy#Wh~#7_uWcI$!__bv`K7ul<|DTjM|WyFS$-B-isEn-^}{*_)qDp z^LKt}`L5KEn_U?WEC9c=9v%bzz+5%g{$k`p0-9gtmI|<-78hR~>?ozJ#_g;CPi0Q- zWD3QLX`=NzUtcEAwcuj>@>6;uI2u41B&!7j`uhbaBr*37nJ5eK%h^O=_&T^Wl_OW0 zB^d)w%*s}He`^fi51uAUYQe5@nUmuzk}-E_iD>K=WVH!i1r|CqN1{(k8YAR?tZi6u z=t?Hu^q&WEp(tv!@9H@sp)FGM$$kH;OA%U?L@|g$Vn466n;g z6A*~q*Mm{TqN|3j%E6?=JgE4s1hub zfO|dKEm8lU>K8?B=6n3-PSDeO-$feOg*k*+Z%9fZ26~MkATvM@c5g2Dej+*#{F;c& zEEl!d3Hb@K0P4}NazGC?a=*%#e4#v57oBiq#;Tu#i~W0t8xjM!7trmI{pPmPX66YbL(F3Q?j!==3wUk(JV9aQ}%`(Bot%PnZE z1Np8)Yu#)yMu0urmN@U9y`F-vW_{3@%?3xN@>kC`8*MDFUOgubjQ@uSCsBFoYk5@K z;lUt>$$>ngsO1I}&`3aFbhpj{JQob8G;~Y4L_gCHIq%W!mq%5 zGU9{beIclKPB$HtnsD3C zi?uida+ezc*G>QDm>=|>9_$%2#Cush7X9i`fi{y2d~Dw2X(iKC?e6!gK;%##1Lzz5 z+?}#IwnVfLEI7E;!ZYOs?-)O4!hcw!06+PlHY=$8kMZVa@zTvNn7Df#I zT%_b%Qz|T(;fUHY0&aCzL&M8?<|rTeUJ>Zzgzuro`m7OHqcf|&tT1C;ub@_`lR$fe zUaMxXKDoDGL>L4I)+JpsDaxyj!K%qR-nMln9aXi?w;4m`)P$6jZm@{R9e*qsa%-5F zSKpZ8Kefux(@xi$k&>aAE;^5@4e$$IL-P5?8Zciy#s|fd>eZ})A_B*-Vynoh`PyJZ z_7BJOdY*J+^8OE9Y;7=m)b`6qEY#uaH=E=Vxgqo-l6$d|h-C*-uREVLecnlYP^kYg zv`$C1ml2b&1eSdP-)NS!Z3^&v@VYQF{<+P**h@J)TjuTpn6g4%F2u+oeCC7Uwqsu( z(a|sM8vp%^O3T=xA~%WtfY6w%Fb!w_e1^<1KkF&D=r$+MvxsQ;@^h2R5#qi?&bK46 zY;&x{0hw(zQI$ZXP24@&6q+rr+WOc*Di2`ibMR5q#c0vKF$MFGXIUz<$HFb9h`lHC zj)5J00i3DVtYWksGm^qWuIG`D;WcNr;q7Oe5i&O0b9gb!lcz_lDMDzthKX9*&M0{* z1?`5z3ui42iENT78@I%Tn2db{t?HS5na2K$(~VjOQC)=l6l|F13kJ0K7KYVuhLXw7 zjXz%sz5IGoJ5fFvi*Cy*eUkG-k>SOZa2hh71a*(p%v_?|<|bU8JNt7bbHmMEH^qCu zS6q-esk`?EJRJX32y1}7xALWz1;+)nG7<{6IxJ`<5J66-z#25RPm7Q9 zENE#Lg$ug-;}dp~nzl`ito+Gx@?jC}!i!2@-*z$QflGsnOrA=GC4wW@DW`+~$sXtN zMQV6biE1P2+f02QXRdW^gs{ENWb3YFX+^5(+e8N;ip?4jY$~CtCfXZ0Ie-pj(-9+v+XM$U7SP87jX5C&N!05*y1UNQUrcBI;lU z-KJv)W@0$8SNLwOLK3d_eQ53iYt4r&jE=6|9Uvc@7ir+2Z)>hX3ch~fQUXe}LGEk#mZ5K7>8 zJhe5Q6$OhR7(%Z;q}#hIj<6dZtnA-^WcEZm2WffhuC^SO^JEH@$*{3d<*tC(KR6Zg zx7X3qZ*C1G={2<7 zQ>AAH`5%AZjrCdPS(JX3R7WU6AujvzdENH?PK!(GQ9-ipe^%lujHEgxyk@KFAf7X5 z&{it9#`+swO%H><2Mwg!dr|Zg2qDkthdl*T@CMs?4JVK4$PcM%@$u*$YYPggf7{w+ zQ}9^dQhpw-AUaR_Boemm_4}wh^a<3d!Pg(0NfrC<^>#ap`@BHS&%W(lWrniMUSb+D@?8c^G{k5H6xD}1%*2Rz@q6dH{3KlyrwZnEWj#M)r}CgT1W~x( z)I#19y-Lka*?b=`G0@2WGd*O07wD@X5dHiJ%{=L(QTsOH8_S8>9a@DaSgB`|-^TRD zN0*=Kk52Y_J8H_oU@jEq`ybYh)>|=y8pCL1%X!t;?FOKpZ#^=zu5xv->Z8q=|F%ux zSF_>>t-?K2)t$yxm2XELjvtt(f!chRSK|54A@kb~O~k`|hIry;TDkkRShY7@ps07s65-gvf>bygpK*0&wY_xWnN6 zGAGumUL|F6v$w(h?M|%u7B#~@S(qZ_(Uty%e@svg9P6XVw`lR@Q9$Li@paaoTJS!H zw0p&o61snk%i#a5XoOb4PM70Gk;vKp9U@sgeflpGsmp2P;ZR8D2^1{JZrz|9{kD+l zG)?=;WFI}!o{hlDA+Qr^ZTIl`ArK+Cv7Cae9&B%_v?@FmRetyY#uG^mW8dnR4y#S@ zcK2geA9AWNKK<+dh^Sn7J{a!}?T1TxIlvvX`+RM_QKO5U;^W!%s1=uY<8R743K`E5 zLhf`JBK)BL>gI11CL^BKd)gTEmLP;i<~~dOiO%b1;S3d)C0Gh-qn-fnaEp4{$WOf9DbIeco@ zaJu|bve?XS+m9Hv?mf)vd|?!YA|4ZIc3X4 zb6d=~wl6jRzwY<89xMiJ2sKR=N#-2vxvoIV>pwr?L5}?B__wjr5k+6p{ zP&B^|`G*7J&*pcSnP){^zO0)FB-#Qzh1JSju~*JH=@eUMhoa1Xr!Lrj_*Ys<@l%B{ zAm{s5-L_Sw+yz_S+HbSE{wjXgISZuM-d3R3w0>>PV2D9qO}wPq?$%_EsHTiSGJmZe zIlH=A;~T8+k?UI&H>)`|*h#V3sEy0oOxqDB&CDz~b=!{{;Did+J`>Ss0KEkc5Kkpt z12Ji{hrhdhDkt44r^>8q#6C{evX^VW7_i~2vu&6^TqG?@r=~`i|+Y$oS1oC5>TOp>z=?TOpL#Mo;1^A1_&LM7t<$Gpf&e6bbJb zeh0k8n7SoD3v>=`mPXu*7QgeGw_l*Ki+x63R#y#_%sBVtpW$8 zq#8xMSLeI>J}wUK7i3X=z3Gy0nsoy|r7!6Qh7GDiu@o+6mfGiD=MUL0t z2yJq3pWT6Z|z4u#QJphJREBh#(;OD({{IM>>CwJ6W!uJksW`*e-wfEJ3Kk!}Vg)%E*{P&lXOMpZFxyAqGu`96FCI z$&A;qcfMe83lc>-%SW?7>c(yk10K8~2F!8}Spf~s?KG(9!-sKtqj0|+C~@(r+nnE} zsS5EKfd5GETXWu!Yfx$q$cokYiZ7(4`5r`W|7bn+{B&{-+F0|qK=1d}{G^_R|) zsNd&wvy5*(?)sXuzqk1hP8WiG+BaB|eSvxF_|OPHrEM$FU_J4Gdo-tPKf5T$!(KFk4i7hq+8~tf}I#Z4b@_yMI+?Bg!vIaz&S(bcO zfb<5^Ini&g53caIKKe@CC2P8TaLTQ%qBt(?AZglr{)7|ibdSE*|B7YqG#D@a&wl(W zA(Si@{Q;zM7W2qus+mu;g?=8AnY}Oo2S`l-K)K(oHyXak$tN}6MxXiDV?Cq|4O+Cl zOuJAf0#45Uk8)`8aFq%ulI3ac&M&0kJ=<92O?m8Zp5PKO2oSNVzr zIM)av_P^G7z>5kkQb2e$Dbx!!M+LxUGK$Y1k*bsH_%P=`e-6mK3Dw0j?Nb;WPs(SZ zj(AQpNAUNM15@Sy@xet!5&z8if1lk3WWLAz1ZYro6VDX-+z%)JJVnNV29@Atch-FR zQhmCL!Ar$q4aL3;U7$`N8Z%9GIcG&3IcEF*U#O=h*a`82#Qoyg_%e zQ4SA7BpxU34<1JCleLaPZ=D6&UOhvPm1og*2;>QN)%>;=`*nxnb}|60&h!l2RoyIQ zTx>MfSZ%$<7CmfW+HV3y5waEs?3{j+#(zhTi9kui_J_|0<(=QubJD}~xV77CSC8xF zz?f_SemNEZJC;y~AmXM-J3Cc(Iu?s*S;3>gw9ky61~sa)5L?R+Hp7(lDft))Q z>3qH-6vF?I9do$DE(tiYRJo3Fz%3tc+LP7CrzrIJBt9U1^DP+mu_2xgxC^xKU{;<5 zb!;k5k$06yxZ@I8!@KO=xR{3$!gR@~e1Pfzg~#+jPcmfBol_esjn|_|-yF+ucg-PvlcNL&r!fxyI4F?Ma|9}8K#j3H65D0NJC#FqEDbZ0 ztG1C~H)cGQOtkY%fACwL7(8xQOI%gec+bot25{~8bpqgX{(M!xXZmGPd^2WRANO>P34ItNpDZSNn< ze*KNy`?MU4BS&5bPV48lLLG2bUz$q!zifvDVt_dWeDux9lW>e8-!14rX-^ypD|v!i z4m|puKleQnoD}kUA%Os1gaz0>mYW@KXxj1AsJ@en z|FqXm`mWd=D1ZmSx=GuMlrFj@aLH=({8Rr(bOXRVAP=@v-l>X^_Sflx?RxxH*>5qJ^to>rL3TygV_eRjN5sSptGoT@!d>rz_+2f}}k1 zMbW3#BDg?wx7sMFj4NXi4hFlWm76%qoXoHDyn&DiaDY&Wh-rUWxXU$0W10OT^%b|d z8UKqxb9Zw{bF3TMzy}86+Z@()u;c>D%wc7RY$0gp`$3GCidb}~1-UY}^;&<>=L5pQ zNV@uvxX`oEw|_p!v63O)#DMaG?u?8#%4%{{cXjboOWE>pZVP~j;!C!hWL7@kC*pcb!yr_+!%KUeUn$qT1T z+wWjIbPe-i4d`~ML$~pDQFvt)S-;!NVe=zAg7gpO*escJ90SN1j+$j|3B;}z?6ZFI zw%#~I6**;U`TYga0%Y?d)kH(;nk(FEK>EMl_|ckrM%%qXNWvvE;>C08rEtkXC9P5AU?hM}+OhnB$_x?fBNvPLG0xLv6JdQ0ietV;&nzFuS_7VqnbW9cbf+p(@VP{lw?YdQY za#qFqXfo7Z_L)^2Xv3^_`{dFyO~Xsk$1|>s->Vpz!?x3*&@4K-p}1}-m+dl-7_ue) zg8rRH#QHhZ;ae-g(^mm#7gETuEq62~s32wiAq~-OH_qloO}PnD<1JkoguLS`7F|gN z6pq=oB34ps00D1^CNaQ$4tSdOWB}&9hQb@}mXj zS%~+bk~lr?J9sW!j(vTx?YDW*w6L#im1chT6Q!g?^I|jXCy@uG@~9U`S?3B#=Zrhx zQ-9I+*eP?rV|n=0=;wzD1rgFYsggKreN2RELcQw#Wk$RY6Q0)Rbh32Iu{eo_Ho%aiMAfZI; zzoPMKWG@9y1guq;R)}JYD$J|x5nZ2t>MFspaCvM4ir3?@pthpCldPl)Hi#Rmf1lr* zqxEgO_N|;$Y7z*dIv;m2OQF-vldr*jf}&?K3b&-LhK(t7!;IU&S2Z3SdQmyzkCthl zn3*#^9mHMCyDl-we`1|@p})Dg4Yp+(rr$jsH`Z+JGIOQ9mH>{#1r}PQ5;jRNz32yh zLZ|bPNy5A=I}d*a=#^vM)Us4(vF4*^H)u8)wWZ&DrINsc(G%>Z-Dr|3-0DEw`$F8$ zMB7xw>yw{f1|MO>SD7|+x+CL-7(RA|+T;i2h*0I)|B{MYncoZojRXLn)>a$FUtON; zMrI^ubUg65TZQxVxi1VMVt}PuqMyAQYH(Bh9({XO;}a0gxRp|a%o|f*K@OQMQ=oJIdpEct17U3LaWF6>|)X| zaG@T`sB7_d$taN^2T?8NHLBVN=B`VhZ7c15e``fz=Z@~R2al@~H;G|_Zon=}jNfV6 zG{g{Qpws7>C_UmL6hUGn{pfgl5y*pPtgxQ*%xFm#E-}{gj}jLoY4wi2E5q6fh?yRu zgAo1Bw_E(1ChmstHj(F`%2$CR$fOmKCn8U=n(Nlfo|EhG0Xo&fJxd{yt4zn;#;nVa z3&}O8=jCbWNI?RF@;!4K0fJcvQ8DSBvM{E~?L?^0nt2-d;--`P<(tpyXav*g zXEgj#VDkYH6$?pr>Sk_{jmAA)8A8K4HwRiZGvVKy<(LQWACSB?F}`j8(DM39otx7& zjPUKls*YDHO-?6PC77Q2B@?sT3$!SJDY!Dl99oDEG~kBP-vqgP*{L&uX|`WNj5-eJ zBCmt`jg|uh{@79^CcTHu&>F0T*Ek=VT&qi`dNRYu@`|+Om=ss9%B_je*M_IL8B=k* z)2%iQC-;!j5@U&#nJ?_pxCiook%; zru~-{>p`7Q;tT^GOtGy_#AFJMSc=OF%MjkjxRI1AMP{;T%*Tb!;F=>+T!yUnYsW7F zl-bcUn6UMOo{D>!SNmIHo(TSLV9#>V$1nu;Z!yJNp(tY{EQ zRPKk1nUv`2$ul-t!{JTU>P!}lw4}7I;0MSj2;A^S=EL@6mV9=c&OXVgJ=_(gV+aXFis4`d&Q2 zOK|TQA>`d-n>)-P_r&vdDlUmsf!h$MCi;a>?p!SSINz4(HHG#;b%w&slUk~pCpR%= zGCQnUARr}MC*0LkWzmVY!}{ci1+;?1NJ#rF=^Ak#a>6zHJ8RZgGKj)$1rFL`ta z8cm~1^i>|n(#4B|uWAeP&L$H`?JmDic_SXbW8kBh)md^Ry3Rw^BNXR32&(1C%Nk=x zbapEJxt*!2Oz8%46=NPu=Km;ahsYvgJ7rQqMU2>gy>6x7kJh+8d_x#gC=6kY|Mi8C zh~Kp)gEB4meM)K6;lQ5S{S45f1Bv>FP~9hE&5vb3qg0Izs*>1i>RY|Rjw5H{;rAe) z^!F_@KzqqNX}1v;7^0$^|D-MI7z8%vVv4SQD{NqDC7&lhrKpkn1${>^mr8($DSx>? z9asJ*PW5nET)41&x+4Vi0leWmK^J-eR5mBdX=JmT)QN2Moga~n*9kJvz!%+B?h)$5 zQcXn8?YP39J|bqf)7O|}Nf^qD=H`aiOkeIjvX}8?-5c?&El=$<`Z>~H8acqL6f5%d zW(N9)`P}g`U0l@`f9xJ^{DlfC^L_5K;TtlBa=X-ML>MJEE?Pn{G! zx^>TKi)Df9L$c?FQ^`)`Alzu$0z}^BmG9d86uO@B5Wxf{9@*%ozot3GXnN4pQ7G-R z`2QeJ*lKfs5kyh=6WLpA9_-N6k=4ddvS0j$ zD)KdR>}hv?0nH71+xG%CBKBj&w=>XX<}*X#E-09Tw3RuuR#jqr(e-^;%DL%@?6iJh z0~1?PR$-vP8xZuI)?tZ zQQ^xj#SPaTCwGy?piz=~9O)UV%@6%Z$nk+|z zD6w~3K3a6EZ?{Sksa}sgf0zNP8$NLOsI>dV0d!E2_P)YWiLLlmAu&aFbrz;JZc*A_ z?8^q3*JRdJkVM<{AKg19=o>j7$PiP8Y^D`&V}~6Hwp2)zZ$aV}ulL+Z&iZJsQv#{F zHan@lpbh;U&%Pbz7NM;C>_Wz61f-v0F;;Rvt>PCHz6gEsf|gd{ZWIed*AjGE5LT!@ zsM(~!uEs1*ua=+Z1eY#<4AQmjg(Iyi{H|x9qu-+m=pMu?)g*F6kU?Z_)%{Qf-Jkc| zzo5Zr_&}fEaL@AgMu0IU+R);sDG0922yl>sXtBUbckPX_Z5=g^a_5hPxkO0_pj39M zSA!FhkOu-YHGi*vD*H~XNLU`FxP*B7fr>0&`br>!^h+&+X`|~1SxVDiVo$^+0pjOV zF4ak1@8mp5jU2_Z=kd$r64;X!v`pqA2ot(WDvnJTfq?kV(Pe0a;Bj=yjtj5}z;AFuku8LtdF{kfW_~&+tw~Ft3K~{~lq|4bc49XLLq}t% zg#?u#zo4f&*%k@pK6FjT5M*c^7u<>&*Qcw+C0=dIPDSRgOhai@-=h$NK9lOQddD%@8Y&ais9*OV$3jLds52ym-g z+Vy!9L|}nsFYGDh$5wA{F-~UQ{+G`DQ0PLjR#?X#MkDhY#BYtaY-Y|Dt#k=0_IFi> z@TETx&G_R^bBA7J7Xv=TBt0S}O;Ght^`Vk>ke_dX$#JU}ctB!^1!$S+qmX94U>D}S zBycGb2zwc$gvj{fzN}lbU8++bx=a;xZ(e%CYr&zFI#y=rb~IHVD0MVn6+L#9pB;3! zD<;&<-4jvKs5@x_^{PY;t$An(Mh=!CbH@CVJt;Oh*{0?RFhJ)KUnqTFC3?eEP1~nU zambrDJ7xYyLZcD8Iw|HSEI+8#G=wYpfd^27D$G4Zw80u=8j~s3ue2_ocy(9}w3FZ3 z-(=mEc{w+{ol;?wWnl$%q98L=^aJTx-C9j2*L7enzKOY;e=axvG7p;#o( zUO792YGQBZIUz#wi^(+v9XfMD-7F2_DFJQjSK0^OHrbZ5E*Eh#AFh^H=(j^5`(U&9 zcr7N7dWh>=fG>5JO%Cq)cHB=mPiScfH#%zdJ54o3l-JuiDxw#@QD2_8c(uHYsA>7> z!_92U|765Yis@j1{!UR6!{YrmW)q{yZ@3dZW~V!M^V^Q$HzE2v;w8}m=w8N=vvKeZ zu}zME(quO7^u5(idGaLkBQAkww9wuVsW+4CnF9l_ZyAR+Y-~zz{kl87To-+j59GKs z+nO1IxLuy#)sWn$iutGA1g@EES+cgDhf#W!BM9Zeg$i1J{%J7L=eU>q64uo!lPTSp_? zBptORe@l}K<#PWCe>|H6Tz^EpKm7AG$uItA&00+Yc@2f0IR*ObF|~Cf_py)cjA1oF zDSPoLQ%CuAGQ*zZs$Tk%s7b*d@&Xv^e3H*gjNY@j`pPg}V@Nucljz#x9Xec!mqPkFO_o$t)J)sGCy@eo8_B*W#C~&T)sUagpK_x4^Lj(WQ^*oruylcdG(ykE4Rr9{i$YYjzk|iIf`z|N)k;` zN0CiTuTfXp?VB)GD38mMcSzSZD58b~j7H0WyG5-~sc;?{`O_U!56)K{FK} zG;bxo3H}2kY1pkA4)KL?B=2ueVC(-_th2VVm)837ROAIxZi@Dw>-7rD7o<9U8LRfb z#c;Yys)|k=5I_1+?*3kWct+^3F08r2$x+VLO*>3bSCK_6`;l`zJjFu;QK0iiVO?^I zlh+J@gwoJ+>5XMDrx3gOK*K`wJ*cB8h)V2Me%_S+hl2}6pk->uriVSj=#JcCE;emSQ&kj9==3>e zau#?K?w}JfYMw2Ci<{}p zQ0^>#jlc@UwJ!aMl==PD>`92`ZMLrh3((|P9FH*5^S21v_!(ObAc~3b2VD85=Q@Wi zC<)4^XjTdPAHFpIcNbvfz!LXU_I}YRNaZS>Lj{|RBwis-pmq4sA_Z-lcMLpZbQdSq zF(e+GiM~{{hp4aLKnEFL#BO*B;=#{L_aW2DU*_ECFS(dkMjL!P~p-ky2m>aUF79rLC3O~Mx~pO+nj=Qz{!^O%_me`iE&ILF;%s_p0zti-5yBw|2h z;~!%>_CNcQEIU4(70=!WJxfmNNCU-On#hGI#vh#Aq-5P-(Zu?4{zbpPLH!V&g48)j zE)n(`sSwj)Lmn;`J-=;CsPN;e`wLZKA&xx{c%Ryq_0~Jk(#};E z3&yjOsF&9&>6yl-ho;65)C?(A;A0Ysgf3#t&&V4dg8MNy3f&E}9X+BK53KXPDY`vW z7|X`BOq_i6`RTjrtZso$S+)J3I-WC3Aq*joV-tsSF{{|iHqmAWwY>hljF5(4iODdk z3OW5o>|wcHRnN{3f&W6`ji5#QgsFCBB4>omu^+&IUy*s}00{k0H|yFKZNwX0!(cQs z%1;4$`T}m(9lalb9BQX4%!5B+aI-WZBo&W9{iyJI{cyjuA0(gX^}zkHA$fafc92)b zPbfyQJXmZ3&9hNdY_g_kA~j|6z2+q8z|DB4)sWY+XQn8ozy!pXH(XRircz3iH7v_54$VIo+ED^WXj$!Dj3@XMGlH%W zfs8wOA?DOsB-r*;ky~y~beLaihZq3`cn3McsuOj2Ab_E@_j9?9NeX^%I1^O)(JhmU zoKHkLA**c=XE!+%p|4dw_&-d2cOX^&|34DhxstsdE{Twpk&xVLU3-&F_9iPMTq~|? zWsk_-D zK9Xt>@OV8MIY7Zwe>C$ld#7#ucHi0@@3yxi+@qkx`{Z-Aau=z)Zbe}f`d{#> z$38-E06{{jRw6i@Isu4s-}XBjj-t}*{D-eXE&CxsSFa|6=QV!%WIcBrCCMicSeOsY z6ZLaXRlkZS@Wh9rl8zB*&Lvl;&o?v=4 z4cjqmP-d~$-3MCTrRW72y~qsz`7G``p3((NPtpZv<9&wJb}^9m#DVQ0dcrDVm02YY zoi_+p;0Gne*?U3#zW%5c077LwvH2Dhf7^#P1jIFu`X##Fx%E|&A%^!mSm^UoIta1? zOBZ8J%W{5Vew#Uc-c=yk_MW_8){^FLeX{pITx&Nc#4)IV>^*~QCvOL3WeI9wa+6Dn zOc`wA^TO%~EO|c!(@M?3 zS$#0;L&|7r2)QamcK7y}iV1j)nJ@i^tdH@>AxKtmx1mlvy6d%kmm3i-*E;hY_PKQ+ zz2&oZQf_EsK}@Cmx^iZB&cg=AM+V`^ekA_0E3og>Fc?va0SsdEDU9GKQ9*_2UN9?# zIAyr(I+4WEG`LD>Ko@O3L#B}D$gA`=C87ucTIvl{Asx&_3}C4Db@76tyOyQhoYjQ~ z6haEcIo7hda%;SjPe%~)^h|vp6xt)ucT7lB|3qtk`WYrAxG+6WB!UB|4X?WG8*)bJ zf7@w9eMI7{RA57UsHyp_)(?r;zSphRPr1=PFgaFc{n$$TYVxs*Ffl4j4>tNW0;W2x z&e;z%+-`xNsXRAIinMPaP8Dl31tm)CTJ8^ z;(>?(-@NVT9_yrAzEG1pb)d+;ZQu1?U2{K0Y2t0t32D`kZvF^ED5x%4P)T;J(Q+3I z8wypk9vf)Y!^Pg=H!;Bv09C(Gl4y_8Lcc}bfOeN45^&c}k81&sW?C1FM#}J!$R;!G znPv{5(u!Bf6~YAQt;{^djp4*#UKhCb8-&y!D+eqUBbo1DX?QNqGL!OWYZihLNu235 zwcSxNF{Hv<&DUA6qe*;k!H2gjmgVAnMF0j(P;vSy2Pu!d>&3)70@idU<7miAB@BEgzX6tZQT(qIU;pW?*8tZh%6u)t-!2#5KGG^<4)ob^-NqUq1rks3Qldji43--RFaRHCD|8Fy;ks z0R@`Zk*NXL(2zAu5-^w_F4`fZMZCV@oy6I5BZa?-6NB*58gv8QhK08E9!slAni!Lw!>^Gyh0B&#uy{{H%>rB7c z;n1Hh$=b)g_X71;V{cq0WsQ^4Zfa#Vs&?zK9vi3ilC_bLmHMDUe(mj0tCW%)|5c7y zc89H6Nan9_$Mjs}*V;WZvexbas42wFlSFmu;eDl*KVkK5MW1u zujm31`CABkIOS?nx91eT8QUGF!z~82F=Al^F9n-x7!30ID^)?>0h$K;B(P|v;xXZL^Eh3v7UM?;>iQ+(r zSTLJq=2DQc%;O^mPiiOLC#>F3KQlLH_h8am{!!l`Rjm7OVGC2X)YzHW;))J~)9DDk z%;3PEUwV7N4t%fU2-!M%mmXILC8U^|zfN`UiI4bjd;vwd!mSM^dVbQ$`3AzIEP9%$ zpltVfFEmuI*3K(hRry>5St!j-gT`N;$Vx&Cc)XyI=Ji5Eipv;;y%vOTp2+NOcJOoSC-Roq~!r6cDGa`W$@Qs4=&+-nJ?LmQo7W3LrbUN_Yl!~4DjFetuw2K z*k#JUo2a0b`AZ!dEpHGa8MZq}pR-&3tFT=~OypMqf#|qlwLo_Tp5|ts#Y~y6=8e!u zeU}w2JfJ3Vt-zMu*+I++FBoxFuw?ro*LQ}bsYr90odQZfK>X83@T6-sAQ3$T)u9cNh9pV$2Z1@vOhNNy z!{kLTE)O`w0Dm)J2Pqe1V~)`g&X)FrYeaby|I!MKN=K;GJX3A@?&~7QVN8$g;d!11 z*>gW4`a}jTRN6vxdTJ%jJn`-3Z6br*V)-^eO@3#)*dY{A6%X=Cq;agIyTkE4?c4d3 zmbe8IOL}egNgZJeybBdneea6j2;N|uzv@c0g+0Q|8lsV52n#nauk7n`!BjF9km!8(Rtn?PTe&~6S_u|<1pL_W8Mzz3K{%$7TF{KCkXh#>0$38*4G>UHvFo&X6wpvj~Ls? zIY{bP9zy$fvaB+HfXasXBMZYg1>nqWK?=SS-(-;+FAn@Uuen_r)=fW-Z%!}z0TDz+ z+Jg^Hh7{J|Qg_|^{$50mC~mPqn}vbQ4Vuj^(R;+~TZIKMCw?JPZ`(DPlv)3-wrkpf zNDEONT-yP@Dy+xKN*k=r+&S7wPdee&>pQNNdEL!PHmhOS+7I^YQR6B~*H9!4+4 z`O{r5QdF&SBw)`?#t?2Eel=5bzz`h2bpEa@BI(2`ugIlb^L2UbvN|{(Tm;d7r9z(J z!@UIc!&k=hz|m?S*1&xwpsoG#fu}gsu&074vIOV0*3}qpFa_!>t^ArQb^J8ZH0uU) zx%@y@$2dsuEb^J=(>@=zOL{O~=-^sW<>me7Ezf6nP9(ld2py|{owpBO$vKH2zrF+7 z=06?DI^=%Hs)#$#7p@oz&jZf|9R86Ef8boDS#+X`1y3}3B3i0kfqU>Ns9*$gKU`>( zBV{OTlLNBA5zGIqr1jfNc!nBtYlk_0KKEkG@MEIXQB#M^+ye{UW0)%SQ!<=5?yr&~ zRLJ_DF;i`9nYrgs0^qxvGl0xY8}oW<$~&5Y4^$+b2*=A&CP(9Aj3^&;t*wE#SDAOOypXOcnH&cR9H+EaT{=$p5v*uf+y`JH=92;& zpXL)8ewo)YxlUvG%q7M^h5Y^B9$%2`SQ#PZG?}c#RD4x3=M%5a()Kg9*UHaYjKPqW zTTDmN@WT1xdZ}03Ke4@dy|7?zrSwrPj{~CSJw73vl~AJU*)GdOmSB|*NjR}vwQ|Bs zgf(mrCu^QiNcir6s@})R+Y^5CMUid23W!Qg`BJN9FQ(LqKIhOp#7P)! zuJT(T(Ken4Xh39isbxREE3S_B_#)g`NcP1^{tI3mEwJXe){wii6}eIlcx(98MN9C2 z*sYhK0IX2ocw$0(1LA0^oO_aZVRr?q7~y?mD9Z(972LB$1!g@j^W5`j3Kaoc$}M^q zGVeh;7_);&EU}SzpmK2TMUffKo6F?K7S9Uy=+>g>dx!YW1T8r4U=^ zfpkQ0Is%Wo-r{ar_TwSu3K75nw?QVV8~p(iX@45~UV?~t@+I}%N}-O-+@pX_4E*$G z5Ip9$@<)+h8)DGV`OS>|2jXgA21=%Ep)j)`dpoDk{s8Ed3VHEWlTQWiXNWGNXdkAgi6I4jJs8CzvM{@nRNr(K0T zAELSk#|4zm7>5hnEMQo3sr8oSjiqW{pKILTEk$g19vvBec~o^I*n(5y=S_ypv{IBk z!@>?r$~<|I`$x9Xgy&Os+;DBFMC(hUPsU{dxZQ`U+~1pSaXiI>R+q3U0kXVg-xRqi z_%Zi!U&FQcJ6NDX!%8dxrhVA$J^$qa;!D zPGKxa=3r29mqdX;y=5-35gOnw4}r*ihjo_ncN0puvxV`D7D=p869@N|;iV79V+#r2 zkV>;xJQ*_gU=;4_Fu?Eu^TtoJ3G3>6Eq*Vxo>=u46uh&_P4h5>@{($P9IHz`8R85) zjm?)?uOz2zTV-BmO1wh`cdt9GC~b>Sb=!9wco?Z`*CZd#J^sd&7mT@>NDZ#6WfHxH6 z1ub7M`DyTIw95%Tz~NN3klE25pzREM&}w{wCf3FY8~BULKcac3{Yx1JZqAk*)s2VXPhj3Ct6=m1vMa zCbj#GP!J`e7b+_UBJA2uK=JBhs8@&SyF)Gh@m`Fh6>7__C;BMmpBz7j=U;_xJC$jg z(*MD-X#GJ*wjygMf)4~0HGp$AFh02}Zudm&DpKj!_n&1`Aqh+CCe^*sb4p8o)B|qG z6m993c)F^PQ+6NvC-Y^uSps*`V9a`sA6FeBXR@F0wC#<$p774&?=>7{VPk@sn%_7l ztM4v~0e#nwC2dvkezCy&TI4!*(caLdg6DR{=TkB?vjc4V#xrc2UlW4z5aR|)_js%A z$HtQUe%e9telR8@t1+NoQcUd-ed&lf2*CSNG8X(el;-oAzYP7*9b$ip&-uP(rzRtU zvah>U5#>HP1Es{mob+_`qBCyuF5C*vo$~9?Tt4KcJpd?ih|mCCsO6}RAAZfzD)Z6I z81qH4KEJ1#G6YK*ayyq8dm)yM8xLp4Z63P=vyc^Ext;BaH~Tk*L_E@ z*}r_1^Eei}-M%=X@4~pvfSQx3aIdUp@n|Wa($2hZ?hUNTXY6C57Zkq1%yr<{a(^I8 z#_P0Ckgt*l{V+4$7Mg4}NP{JkF8+aNHS%z1jjWbEB@@X6!25)zG%L#=8cuQ=Suudc zQhs3}A3wCk^p`HC1%uygyGHa-!V8S9x0EI(UsKr0Xpcr1)fN_BBfp|9nt;`Z<4=*RC zc(eRADL(7Ir~wRh0b~9Hm9NWeOg0m-)cLLc6-z4&#v#IzccSG5g>ik?sDAm-|WqKFO9e*_9f; z5G)3{L!0}S%37~&+#kcj_o+Y5Z^-xiMgHu&0|e)I69rAP5?gp)S}b@|0TpjH-MC^6 z$zDo%UE+hEjcSxfL5^z_OrD$?NyB$zI+2K?*Ma_d`5me#_X;ldhTn!F`DXdrqt?B5 z9>?kc-C|}__L15MkuFGMvcV0SMe?9a zF5@89WQxpu^s9__SE*A&Pxq1PtJEKheOv+&?xgXK+aXXtePxt+<&rDjTusBlMrDeT z|F0bqpFkEK0#)6km(m-jQARH3%V)~`)f{x5zqn5>)6X@8($>wb!!0&a^AyNo&U}r{ zhDZt4qteMMao@$3=Dd`^GNn0%(DnW_1yoC9zC-N>N33O;tfk# zO8x9Yg!Y5=EHl}Y71u|{-!xBJ&J~rPC=^IZ-z{zC!$nn~@vB=-`}BW{DYJLmR6n z6yyo@8#cv`x@yFVYyZ%?)Dl;>bS}z>Dvq^!5(zAST>4hha=9~N=%if94Rwz?8d^du+yVp5GL{fi%2vV#KW}ZNX1eTMRg&P{hjyJ!x3DPL772M13{| z*+&ga2>t{~mS zwU8IC?36LPSiRDG?4{Q^IX4)Nez2b8M<%HZDwl*e@A~HG9U^-!{PvXhSY4ev)exg< zyMzjU4r`*Oc!r2C!UELtlA-wc!bii|{$>Ox4f#XjuiJmN%QgNO9<6qJ1}QP~-;~Zi zm@sGQ?55Z?*yuAqmuOU!My4;C_K%JSh8{XWB$5RNBixN(33W3trxo_3@C{qu=uwo-Y z7C-3u#n5|<@;PsGeBZMZqvUZLxN3fqc+mKxK7T0?+I4Tg9+~!UEx_!a5s^Y*KI^;u zr33|Hiu?fO7LU7Pz)vcJNPt5P;Gy~Wur1uBN=uC*ZnMOP|8};a8xMEX#}Ar~-*=<> z#RG50aWQI&0l%=mc#3RyDhgY2onXk0cW^`k4QhZ58SM%xc78h=>@WY62)0`)8Z#h; zD(2UID#$Id`{p^hGO8E%Sj3?1sGV`u70)e2<65kUDnRP?ijCn1)NkBCx%OnOVV5`c)> zltkwT`0X~bcql$8R_ao}4L7cMV9kUJlEei^cE_a91Ygmf#Z#t}n`=eh>J|Dn@k&Uq z`58QnTp5DRB|`uCq!ZDOOFVJlgl`HV=1g{jX$4kDjf=`FU9E4vCy0H6c(^HvFAe#z zj8S5s>@5b6y4ug52E>_pjs9lKiKxi+EM)y);T%z8)9ZASWfZ$M$cfd2>pMog-1}Tq*#{W`Nz}CYTG1|Yk{Dbd=l63tg+?nshkcWnA>Rxy z=#??k&fr2&1uHpHIF7H8^q|ac_Zi-DifYYNWjaW^x^QY%!XujvlPYDM4Vw=j_)z_+ zMd2kEBy+a#yPcE?CY;OLG>#P7RNLRd^-IaX7aF`@x`*BxtR$@T@|DNS?#3oSd^woI@|UIG_MPo$OgOwF%1>zL)C9FJ^n^K@cLuaIXf#hTWSO zg+)8j-fhw498keZ5HELV+T#3lFPm9?Q;H>Z{SgJL*3%YEmc|#b%VsqLt@a^5Mh|_iKL34`7H--)-MjKh z$wU7w*|#~%5|k`cB_5bcmg;tD^_aMsO)Lo%hyH-;&fB_ti^?s(R*{K&M2!Q+*d;P#@iC8JoE0%OJD0P{xeJe*E@z6Z4ZwVddN5?iL+>wfI zZIFhE9fKS*=vV)r#X9d_ea}#DfKR3td7R%u(l&?ific1O1q1l!g31yVDKUvIE@=!- zwz=eST;?t-t}IhXM{3PG6`R4H7;e15&Z&OmeGK1(5sFa?}oO#zpT* z6=`R*NWDf1`EE|3L1XwH%WD%3tx!e`&MtxLTU=Z%VVG$wWkVP0D< zqb6K%u0PX(pV$)eqK<<~z6aG93Z(paJ$|e!_g)erslMd*2pf5CddidwPBU11@bj24 zOC(lj9Z~<33U0hGZ4Ux;<2auwOqpm0Rc1;Oii?z(OS7+aINhDGRHZ&@hKaC^F{ShPF0s zkQ0MwEDu%!WwGsTkQZp$Dw4fl>ZlpkYe@NsR~ z&1vpPKxJ`SM2necj247ci0vkxa4q2Oy1ip(bR)a<+8T@64k0R%Tki%SJxIod=?xip znqTa-c>DyFNT4FaYBYPG)5yBGhQkzmZP$zJj`uspQL!=C)@hc9p(CaU44OAEX#)yz z7(hpzcu$)Bk0ko>u>bth^e90l4`d^)gxlA)p)|&74niw=c)6jJ_$G}$q2jMwL$LSux6gn+5b7-Gx?si^lJ6Jw4}hLD-NH0TBVJ0)=T zIud|?t(|>cHw?)RdHS9q?|3-OL5wSyGW2<(QY3(S{6SPo_w$og_7qzt2@Et6{+{cc zK%aw~y>{5*)f#OXOcoaXX4~uA_&-&vbt3^hhTmVuKgDxcJOA=0Up+OXd-t6Xw&1O{ z?QI~0qi>1ZtkE>y{A7-DfhGdeg!Z?#k|`HN7U({hRjx^8fh$mvy2a9|Bs$D6BCGR$ z>E_fBMsSwJ^Aw$FJ}mqQn)B2Sb2?^2DE&(BjyYyZS;VRTj6s^?Ge@I_5~@d9(~L~X zIbc7J;cs_!RrDN3qc5pJ3KO)YH2`jNkQ_x->?cMg;5E=JMJ=hLmAp= z@Q61drdOx8O8g$FfkhLQZkPiXPMA}@)&Zsb8^lX5f#M8C8R`P1o5Rxrc&2zT5ICm> zmtGZ+$695%jumC-A0QHtgk+}PrXN*-Og_JL9a|IH=EO${7=ZCT`DM16st&R_ZNj^Y zjxBB4SV-(g@Za+xxzsB;cW;jJUCV25rdzdF^)?{diR#4QCH8n2QGpFk&cAQf18e2& z5W0V>1HB7I))dlbiUBqJ{JDMUy`kUb{eb^$aX?S@BvD+Rohpc|x*~K&{k^>IS_S?k zN8}QCuKMO!=nx+fe;ES?Y)M??Q*Wo?^>yBV!2fI)xct>uaXSQ{&*%&9*DIyR8ihKtCVK z;e-jxl=V`}-($E1+Z}=}qzDwQ#derNvaA;7Ihd#z7w&!rU+WUS^dO3+pdT9|RfEmd zswQS*@ z4gb?(io=HMry2(IlU101bzSLeNO(_}fCC)iy}{!NJ@#X{wn4<03ln-M30Vbnwx;j6 zyc^E|e~rc`Ob0d3{q=z1H3|)Pzng%p@hg4L(*G3j-i;ARQ1?M^q2hOs zvA^RvHmhr^4y8?)e1!)K%n!bfX0`J577q1U5%ZTN%%o9N5-%Ne9n=v+^Xq%h1fNvHc2l1$k@P#?MXEdHb9!%?qrdy1Fqjs$ zP5&Yl3#j$3iei;|Fg^3V3*>|>%59EP*YY+RpH02sjJt8Z_+N}v`HnTm&TdDnwbcXG zy-89I+Qx5V*(Fh13C%>%(NBXr*SKIN_W!Fk5ja^J+C?5)uF%X=t#E(%ojq4{5Q5EV z*Avu20NtH__&4HV!spM8xf-4zZDWIKkgma5QKO&Z%}x&6Ukj-03rV=T5+Wbh>1hqa z;9K+Oq~IHroQeR~-WSZwr4;P-D50IvfaL0#GPkoVM*wYd-{T^~h>MV{afZ>SH2?FZ zG^IQ@5t!@t*CMeG6SUc=PGH1*@n5AsbOZ#O62+U- zrI_iEFqo&VI*EiLZ0qYH$AtAYbVj8h2|urKEJJ%)c%A-5zw~jNho|H;tR_Cic6sU1 zA@9_wNjR&I&XOrc|9(ImgfPPb5*{Ja)zy_5%*ohXd-0Hy3Cg1__5RI!LtWPybB8pv zg)tu=JJAkbSqoNLOoRWR((icUqCHTN9c(B48Mb7zN29 z^4zxDLi(iBI>uEt#1ygMxed2d#d!XOP>)i+6d$13N;ypao&ef1X;iX2H_xh1TK_RcJGcq(c%aAlyZjY!mZETGzsFz>6N@4Z=E0X5&QH%iH_ur45`# z514_pyXs zTO%${(K?3=MSz7R$tEU7SFInGc~>AVR~oTw+4!NcQxJTzP_w zUrSTt7+<)r#rGBwY$%&I^v7LAkr2ct9x_+M!S!IT<+JL|2qX$t=rDjLJ|~~*zl{wL zZo4;lOhg-3ulLnf4KCKCTKNW1c!YFaLuhDxSAn)nvKpl?h2Gfi6duRAqE=6gEUt6- z?K}>rN+`HZ0Z0C{y!yf#t(m>xng45PGv&8Tb1rUpwUL~vvf(_>^b=@Ko88R5BEbUh zbtRJO`1zvnx`%LWFGx_zrgqnS&f0bzO;q0pnfLR;_{yclC=D+36~{eK?~o&5PYO<> zO0BKt)usK}3BHm2GvZzsdcOxsH>lH|W5fkam0ETm`ol3=k7w>oZnIa*rD^Qj;J09% zS|z=$6wR}|E8K#*rf(K)d+#329b_ukP#5%YIgDDB`({;L@u3cGS$1#4b}nKD*k95 zbzDGYlVViJdg5RwQDZEPMgJYeHxCEWe^#YdilKND^f930P$~j>_;5rb72W-QdP3t5$?zLp5p^m!TRML3rH|=ph{XC>%X#vJuJtxKd z75#&TvmW8cRDZk^axGRtkN;CVs)nf zSfZlrDCeb1=grio>QRCZFS58K*(e``%d(|Gz}O05_8IHalDR)XGd&srx#|0}TsBOtgz-!m-U zU!uhKx}G8nwP(E+=A**nK3Q+DGANywEIeCwTy@;(*?V(?Y+{P*w1rep#d(Eg2Yt04 zIrlaH%~o%s3_V&e(VEGUb)hL5jBk7&#Upr9p#LwZn(=7Al0a)mel}aU*T6>GOng;}#tSY~v%j=Wu4@0C z%$VR%L5hCL7n)n~9q7&6O9)&rgxxpeZ%Ux2TqFdhD350-wb$A(2opsK^~7lM=3|jK z$mkmyIxE*y-nWR~&VpN$U-J|GO*20mq07T9z#cn4=~ycJV`2I!diaX($o^WZIB~x&cn05Dy3a ziQ=yVTjT+>1T4U%s%YHgHnb~o=y8LripWD>+h-6@B<+Fcibwamca&W~T zime=knqsLz0n79)K(RrCL&S!S@}}I#nd5aKT1Ws<#IP}E@qS@N}_52fWr=6#@?}2}Zaw(5xpke8?yCZG>L z`u^S(Zqgo~viWRjPT|VXfaywmKJM;!8!fz4H7S0KOyUfjKp;&XlKWyUvMgS7{fWN+ zgkK`)>Vl&+@z1viG=KJA*~`g6KziTyrfMav@YUFZZypF2eY5ja?+eprd3d8+cF~#3 zA7O1i;PEYtjdDG%Rz&m%R{N8cVt}9L=qf=R);D6+*KEi?1mXV0JD1^WdIg0iI~ku} zG%mzB^dN`Pi*SRXcezg3b8}U?_C#3Q9VI@wov#P@WO%ud&#@gB6u<=+mEZ)Fl^5o628ATAu+8_nyL*<&J&1lJ?ARCibH zTs7u^n^B0+_Cg^?eL{V^ky?u%ea8O8D&P%Ze3br(+lr=FywQej7+d}m62Y$BypDY{ zHZyu`5aYGiHttdfyoC6xw(X+Xu-{{1xE-hVw}J-DC82Nr8)}kHxjdJj!}tVEd_92i z=82EyodiZe^1t9b#%e{B<_0g*{O7K1I6AIz$lz9HLNllp4#wA?V^Zb0EdS@`S9cOz zSpgnmqmOS0t}j7vK2o~NwJrW36;HZ4;ku9-cTK;UeUbl0ReL z(=@GDq{#K4G@-`k@9G@9reCPTGgb@hTSl&<{27;^{n7hbf6{D;JQfmCuZ;KDEg6vj z&zzMV;S|gjW^!{Kjx3?_U9MP^Tp<6G`xF)rV=rbMb}j2;Z>Ls92ywg`yokESIa11l zmdnXlr*cHem3bl1Fv0ndlI(*#Jo!D_28@_r_a<_9>KUydym8%}I;Qc{4VE}^qhUq= z_uX{R0Z8iopO>=N_D*H?y+k2ccJw}Ua9JaJQ=Bz*VrXRdv%YrGbpI#pvGluEkVCsB zi---RT+o#fuqbZ>DZ#^vBH<^@za8|s(D(zpl(X*d`^|Zbnn|ui+U}|D@?8XO^-wEW zv}GdvpVqfHRiK^F*58WYp8bej6tS)PP`~o<*P7F#Y^*(mzBK4VM~R%5i~phtrrVtl z>nz%pxq1d|_gF8b(`vG!6N)c6r#|;Qf}0FY=6wvYoi@`F8Qk!fueE7 z)?=`O7cvoELxuZ3y68MrW`0kUu(tQT``Ak3+@X&m$pSl>))e0Rl zL6`E5t+V?p^##c7=rsxfP4aS3ZmwnZ`jXewbvfHkj`AsMb(ak=K3Ih%+RFHpqVfSKgc+dUMH%QuRBpf82%^Bz?udCi(~!$ zoB!_ey@b`9mM?W}N(uhKPuP!@@A1QoL6lZ_TbBGS0WH0Lt%z4ScMF;YDA9L0%?rg` z<9)M3sTFa+$#lE2Tn_L2EnVxi1;$VJiCaMvGVhmqq0X<-450k!144gKyePz#@2?BR zk}seW-oZ^U+vh_Y2GQCQ3ka~lkfgheP$y1MPy#vUOEG(3%w4RV=D z4xbYp)IQtjR$_jRDA^suRnkP*-A23mHLPue=(^xcCc}8Nvx{F@uMQZgH$w%?NCci~Tu)Gk2Nq`ZISp*6&vk{w-fpG&{cjtxgRy9!XWXlqHa=zg_5zTDWT=|NPw3yhE_cKDpB&3swOgiWH*!rCqsw_zM{O=# z@cxEJ4M~_FY%@Te7PGk++ZbZ%V%z!*`sUg>QVG^wk0$vDeof8NAvY0D+$R+M|JDM0 zK6vXB&Hpt9goYL@G{!Prg;N{x`qg{%;$@v3-Cld6W~rM&=oOM*qQ3qC^54qEPTEA@ zMpLR@$Ct@0#rhszf|Z)84C~mFXlW?MUu~q(b>T-zO+eKMGdY?|_%Cp`V2s+86C*4K zLvGJ+29>SEmDkh_MUqo;7^5j)hY7E1KXm*hJT@|p&7xFW7M$M$wJ$KfTzD%2`?IRh$99f-g3c zxEns!@yl){vV7|0aaeKb-uy2OYox8X^@f_;os1t(B_m)B}+i*KIWzv~(vyIHSDEf)_DS ztYFAjw)B-6&3r9+jfkwCa#rbbRzEpj8k7ww8xN!$RAqiebmJF%Yt;Bl$oUS->Ad_Cjd8s`KS+Rz+Q4_0T zp~a#5hjfaQTY1L|CHC{38nL)*{_Vfz#bF#r{>OoFsj~--BN2OYi45~QFY-Ef!Qh(# zvx^B6z%)WB+xeWTyRY|Shc@@z?LJX(U|!EF?wIS4bMYQAbb1^ts>(x^B=|I#i%8I9 zyZ=E{NAtFPwsMk3H#81Jak80qfcuf@#(3fNR>T_F3ZPCEpBl(2mOyd?rxFA$7q7(W zS~ayMVxCo3uaSEr{6-V}dZvfkh+W#|g$KfQ?>HKYIP8~o(5%RR@%1qvvVA^64t}2u znx5hQBrg&oNUQNL3{O~Z%iE{VoW9fsMVmJ*xr&AKjOm*f{Vx*4Pnfh3YZwuU9~U|5 z5^3M{<|{$aywrb_Q$j*eyHe_wOhS|C0MT`j(2J&msPxRrYM!)dB zW698!(~S<(1|B_1NR7 z6Ca|lPrd^>irY*5&j;^((Q_PzSkQ@AgUsM~xhLwvs~hk?UGMapTI8pKKlN#HpV9%0 z6+fb>!T*Bh8+x)%;{Gw$uEm!kG$KjgQeBJJ(ws!A?2N&Cb$p49ICw-Ui&IS%K6;Df z^s43YOK;mRKfd1CUQQj@wBPcKQ&_2T`|+v<)E$qF)}a%lhsg(LFA8`tG~=2AHSAnk zVf$sUaJqK(Gp#wMdNLkBJPZwt1-<0OU<^estBnHS8d3hH9h9YZEdIVM^6{~?s~xWy z41JfN&ge={;nTO-pK@>6lk)556*{b*XqI^MdfY+I3>Q zp=}c(q?YGYA%|LgV5M=|3ciNMUzHd?cY$m!SE6)`?AKgpa5F}g&~PlL#1IKq&Y9K* zDY#wL<$9G)K!7uOxMGsZt_J~$D%KYhjHSC0VV0&4<4Y*e?o}E=!&Z6qThTeA2yF3* z89<+xB>pKw9|goWBtqXWi*0RhVJZUas;W;Cn*xH67!jCg0sJR6T)adRIB}~nUS26m zS{aWAHAJoGIWX_vLfe+_Y{Ruvg49Q^W!+ezNj@c^xT058MT3^_vE?bRcV81CQpN9Y-v=V!hi>G=2X4Ta4&6 zBba&fI|UShaCul zuw8DCSbO&;zqs)$T-);XJyX@ndbInRdj%*YlK1#Q*2zS&a$SZ|6SMH`q0}17?B#5!_yllU^eu2UEH z44CF#^y$v=zN5TY92=NR8R|P0j4}E?%^4(ut}Xw`l(Y5akLxXI+0RQ&S*Om4Jm(?V z3DX>R%a$td`w?&WRL82=lzG;8H5suwc{)039e}HOvRxs5ZTYuTp--K+k z|H-xAfPbTUbKG5LIaGBVmpari#X@@OCk>ifUz-q(tVASK^#~%{oqu9a0}r#i5>(-6 zIQ%lG|0mz(nos}lH51y9Da;?j70b+r?(=N2JX$AfnowPX2D&?bPx{I?c8eSC+{p3M zgPJ{O>Hfl+&P;0f+9*SHbc+H0&fvYgx&nvS1rgJY8R%UQIE9zC*reIMz*e%y9vg7CuuhM{Lpkj%k!XsLl4T@Cu%^C3*da0=nauamt^n6@f)n zgri2rm5mh2>G`97p=wrA6)l^5xSo-`PJ48~n`hAI0pFNDMpuWwsb?hPn5CZTvF;JL zFJaoAo!HTRK4FYr!Tx^+P#uj2x#bu6rj0%E!gVC9i#X}(?hiHNApMtnw`a*eK>+>( zqGax*eFhF5t+~mi_Aed{5G}$R95$)&6Y82=HVi2KW>|OuaYwFA;KL zGpC!^&pN)&2oX$deVFYM5*ilx&KvVzA=$R5LAZ&s@||1iyRpnU`dhrDlURubbxNWO z@ZUsfYKbp?LVeEHq#?_|$@9YROlbF@ro$$$q4sHnJpCHFsr^k=k~jp%|Lg55!=n1W zaHSLsVh|B2ff>3)kWfGgVP@!%l#-BcX;FzGq=unOTDrTNp+f9IX#B;%vt>BOdd)Wriwm` zZa63}>eGuH70VZ;wCZ{}%CkPxEtd)YkAIdK;G7gmutFF^TnzH$-C(zHGM>!eI&RkHB&+WSmCZ?DMZd{H(Zoq-_K0^KILWDVln1 znES7w(Ja8~HCdv1%ba%IiVU=29@t-ksBb7)_lJ-eS5LQIsN!s6U^I;AnhLJICcAmX z(s7#->qoa^pJkIQ4@u@sV;h)uJv~7v`D23moveBGAeuo8EyY&vzek5||@?ecQUlk%hQ1=QrT^>>@ zWMp0XI>YgyYa2xia8Aub$Tm?X=q98%CQ5f9O}=|XvbO78+QB_KbvSTKDNEEme|1$S zXNlo1F8UX0fE6@~o%OaOq1kFU8LtUE~j!1sewNp(6jCy=1XYplWPRP(B4fwxs z`A-sbNVj0-(&i30?E)C41_%^&zq?#mE|DSh$Ua}i&^5&KiOp1rN9-`^@RsyY5h z877R5-4#*W#oHW ztGOT>n$`-UW}>C8SKs`yK4yrMFy?t~H-oTma#T04^D1&;=2(N(ev;=t+s6X6tb4t; z+&T$TpM+{gNIDSS$^>cE+VWVYSO&#uW(PooB z)RokYdKviT_yhWzr}rwr#(;7ac6+fi&EkF)_Q3dI^D*lO^$665cU-&_MdMFZc^fQh zgF%NvV@(V z(Wkif>eLh|Bu_nh9xO}rwm(T@6_2n5B;X)RjILQryrsa4zw>}6(2EHw^0DkJ>Y7kiba6irj-cjO=M48H$1XV)T-|CjL}1?EejJ^UJVjU# zz|U@!K(CTDCgV>+LM;Q_EEGe8?Yd1HSu6k#S}{gEn0MS&w9$pivT?W8bo~<_LcVY$ zJpP%`;0bsz|9pg{(blYkED>EHVr%$K7y{Jdi2!jz#3U&j`p};-HoSw$F+Z`Ka4 zn;mjZF1yslTRBid6!{aX+el4KbnmO?R4<9Y4)k4fP{GXw8GxxgTk}h+BwFKwr9#I7 zd67UM-?;J2?i@H}3+7M^Y6IacLCQ;$qBYcsw6c1cAjJa0`S@l9*DIII;lOZ3IQo-n z#$n@X(E>SJsX_^Z`WK`3JSp+m0b3PI5WuE+64i0{?C?I429#D4e+Ir9=Q?Kms@&#) zWE_pU{#tdRN{MbbLRV3$DF)R5>pqUn7eAg-E)*b2^Vrv=NmpjnxsB2tK$&hN+O!C|jTx23@lJ5pv-ET1uIi!KZMo0N6|KIR${6{RVYjIWAY z*+V6{eLpKkN6oZRG#C(MmwiIgg^Dscxnq6umL^fJ%>$(g?0VFnTW z!9poE9-TeEn#BrprMsH!X3qwI?@@UDxMY|1e!((4FPyg1)Qn5)v1iT=dRI}7#ZW7J z`#ZepKAQ=5qSb%~iH+KV$(f!Uk!Fh*Yni7L;qPr(EvViENF!`2V4>q|o$Uh~4sduh z=9aoxjTXU1z1Qi1&P;l=tp@QBfWxXN>{10?o0>H9p)XF=<_ zps5t~W*|j*W>}FPyvpd=-A~~%AX@De(xG_`P|CJn3zVS4txZuZm z?PBLeUX}5a!_Poa>#;6mFsed5ad{NUp6i7cBVDoDK#*2r;6zM24kPK6F@FMU5 zpVB1Xeq9JvjCQABCs9`i|5%X;aA>}Hq9qnrvzYLW2Dt7-c&BwqWlSqDZcq-DZ~DaJ z-2V~8Actm6>-_+2u4LiCIvxOoSFoMz`-KlXzuQLB^`86W@fKzYt*E7!>nDow^!FzW zM0*F_h$nWqEIwU&y0o2*hmo_Z5+a+gX z?Se(FL)~9W`PMv=pjoc!RwS}2PWo48<5v#2QpbbC^udE#H?!~u)~gH5uz58Uq>W)r zcSQD5C7&ZcuzmC~5blkcw-96);XJ3z7F0M+_gv!_NAXb9pE(i6d}lC#&ACoYBZ9t% z83yS*xZpsmaC4-`OxgDLJKtSNee?s4urr~>&B7-}Ompfl&9BBT=}RV(MSngcOyjvT z;PW-jOzzzXgRb_aEj)I!Fs*a0;0w`*oK#7=0X*tS0ovMcB(m`@H8k5q^Rx-%xbZME zaKjoP4ACmMM0X;iUd%Ykm-f^08r7UzeMME%@I)ZL zNqHgHDw9Cgb(Jn6rcgq7Az!be8aKj+n#y&YVTcV!j);b=?nJ4#Zd~WU7Ab_;yKovl z8~GsBt6Px_ya*~;U401<(cutnTWJ}2`&N-JL|>%W8y_r^pUi75AGll4Rz*Zto34r* z3lj2mcsA`9R1@oKiXI=>y@3NAv3d|aPOqHod^CnMepDtY0=W#-oMm(qnAyAyWQ9KL z+fBhm&iH4Q7DT#!pAUerwM1W`S`SIlI`4HbA2lS>KorGdn(oND_XMX6l@YUW5>@&t z5CLt>+p}-CuKzH)RmH+A1rv4yoU|P@NYx~gSOT5^U70$ITJ($-r;BWV6C6z%o#+}Z zP8(jn6ebeLLfcpZ-r=BnAA6-qaB6V3D+b;>!VlrZW@(*!J|AIlp3^`C|Ie19?%*!V zB-nl)$}9#)zAw}|Fa3~F#*?Z~%U$_DYj)3i>BFGF5k%2hkNT0LgS+B{vhPObS)w!W zSB5WRy`D~kC_6fKaUsq*z2>lm^Q?7}HMbfUJnFjCo^(;xL1S?D{0OtNCEl$i}k1 z-6~?)WM@|2UIlb^G`>JIiAyBj#@VB!k?LJ`Q5|4ESx zmYwRH+KRERAdx?$fAiGYv@4rpH*t|>w7DaHSZ^eObl@u7Iu5`F>{nWe0C}gG$f*FB z!lPan>hSti-uy;&?#c~Relgf8Q1VJhS(sY{^7w~LqB49GX)1tP22NTa@q1J#E1#*VErFVjWx*tw7hkENq@Qq z-}}AHEv1IRU9TJ9EhpAAv3Yh{o43$HEBJ5JwJiL4wl3*xV-ZfYKNPxuuWaaartDPo zG5|MCc9jm~11rZ6tnsPLDdfIs4HYZbL+=tRVFG1Ln$i|n&C~3oU zocBK6trT%GgmPQLg_MCdaysWQNcQMnv@s-14EjP&u5_H!yXr$mptS$13|38qfNtJx(L=Q6aMb9k{YxGq3Hiem`kE~; z5c+Izw}Als=T*kZvZyp>-ySPMTU!Rv;Eb|M!&9nmHU9iy3}r`h4yU@aR~JtD5W%lZ z+i_#6H&EXSm!?%L7NJCs(930>8aRRK?0f}nyg?Eram1>eSM+XnvzuX~x&tqbsL&0B zRwiMd63V{HVjLCuCg0-BL7S!dx1P%8QdLJNNM;Mxj*Vb^Hw%CE?+V_Ly_d;|)~3z1 zv!rD<_lI23ONc;B1Y$iekU&4H>nb@HVusZr028Z_U5Myf!}&fE;{cT+DNH8<2?Kk% zdy0~(L*u}WsP09^9Ff(K1!Oi*1yYz2fE1VRuCyKh3Ft$R`qxV zo!N|JlNjY*@`pioQTMb(qMrWBlEtUNkR z>zt)-f`*ZzQqHwu66*KhoBGHoEAntoxHK|-P074W8v%V-O3MWeANR+eISz^sW`Wt?msCH* z4594YE;-rin4OV&8%_sBKS|hH`AEVxI3%9E6(!fdYleqh%wnt*K@CT8X?>N9$ZT^F zuLLJpYthPQy7HVwwCc=KHkC`N{^RRx67mTrbg@viw4bQyLDR3cvL>-QHmW#G6F&GC zOgi70HMz1wE33`jXtWA~&gY^67Hr$*<<;0>k}5CVjdIumLk(d66}d}x23LJn|EM7K zw9jhx$>2yvxl3GHy?-zF4a!c`V>+f_xck;EiPx_ePrAxu8drHudKB;JXRbA91@VOY zST!6yImXtZW-|shGP#*TzL%Z;`mp4i6VO1+!I35I&>jXt4@GCBXdy$apqe6P(_woS z>J+Q2YOi3`?iy+#8tPA~(koB3>C$fmaY1xXon_UV6tJZQ76_xPtEu>whZAg-Jol>) zsH8uzte)WPk>U%izHPDUc8tr`tn{Cjre(|a(HFHRtGU;|tp0p8{cKK^2E3_Af(>Af zv$cH(>*ifh$*|FcbT-?=L9~Qxwo`(N^zx1Vz459{#%F z08<_DDz=9-`0Q1)1=im1+-;f>$PiiGSs#2|o&~mOG(UIUZ&GYUc5yaQhWjqBUq;A; zzZmjZf8XNiNZg>JHgdmG>icf(;jx0BR2s~4Gz+{c`s&_+g=!M8jn9(Se}=Oa(C-Fa z4;<`8-#H%tp@g2fKFk(Ali5dXZXh=KP|DQR^@5P^aOZKvv60F+p4`6hvIqr;!e;B2uv*dY2~mE?^8U43sy=yQO^j+t4Qn=-{snPR z{-Gg_pC%u=Zd8D2RI~INw9*hd`hyc|zp1h`6aZ#*5*SiRpkxfD%)zQ#i>aC4uJkL! zd#tMZ=>y2=ULZeKP98mThGV!Tf1fpiJ3j5>Vs^wqKv8WFYT|vm`vaKOxs11u)J10x zfd%NSs2F*;!)DfV|z*Vx&%I6-)YZDRZy$3wX6+{(j!g z8#Kyh_IMD<|IB3$bL>oS1*ggRJ#-K+P}P|$j(RxFlUaaY1CdZ0RYFb_e-=A<-P06N z)j}Il`?cX5&ySQNxlFZr5!jgiSV=4!Sxhby)pih`A!H<-B9QazPD)lb6C^C9{AMcH zp|}7#jzA9eeM3F`f}bSKhc%E#Q-6^{2Z{op0S*HtXjynxV{z|UvLsrn$W$li>VB8@isnM zHgm*WhVpdvlRZPjDnI1Mf7}UKV8y&gQ_-%aJLToAcfY8^7B}@ zTF8}<7kl7VoPumkGT3#neD6O(EGeI^gt0q(M=Dl9_NkRqi zfUU5k=I@d_V2h55#h+QvAUH~vo`YBJF&rU*UxZ8pptOOT4X0G7y?!})B3#&zISOoB z#O9WG>W3lC$-ONY)`Jp1^J5GVNmmtDS+IclE2SB6xC_PW-hx=LM(;UMYe^$rB$>zh z%4(Iky(36Y-Ymx)*%8B+Ji?{INFM#j?z}%3hLRgYIlY0^LI|ckcA>|n2BsD;Ql(D{ z;JBu$tR?%si!--rV!qxWBgf*5&7=`^%7R*b4GVdMo1|;kWZB9(Xj1IR)I8Bjm`}xMg6d`^Pm4E zW%xB|$krR-{46QpoZQ10>`LN>2ew^t$eYQz#vG%JSb2Z{B}~QEP5+R(o;b-A*eiC% zj~wxasnt%d)+UNWY|rcdVT5rG38evgSau<-bmw)&*Q^ZU#dkYgu}!Kq?|7_B+=FVa zn#Zww=FTd)i_TqXQ)xoTs&viSi*JSFbvYew6=Ko-_z_N;JZWygGodT&66`SpDL$Yr znwtN@aM5tHl~& zTJ4FD1orb2e8^$@>dtwiCbxGd!Xc8xta!-)yz;x+Y~1udTaFA9WbFC0zt4n_!u_tS z$*7H6|Mdy>z><=}lW|mc-z#MKtxwi)yOO~|14EI!51O`~)6TqONU08?tj#r?&G{XK zC-2))IF*0^iPCe0F#TL#c>ygP&vEufP(aUvF}oxO^KeZS)XC|*eG^~B3M0$=45^yp z0Yn67Sia_wsDK5ZcD}x)94GIJ-u*|91t5g1FIehs=L&v9IS~|A<`30RHXiA$4^hwz zIDGBb7q>lz&&qshw;kUbJ9KV|fhZXzJh86rE_%8*qgy3MN58q+_Fc1-5_tr_`Ajjx zFhlBoB=IszYCvp7QD}S6zL3xTvFSf*W-f96ah{*jP^hd#E^QSN218-$`;#Bh%O3*k zP8+C9MiPH#Er99Fi4@iiZai+!TQ$fc+oeKH@Ll`k_LPq6ezGY~xT$*3g+WfZZnn0IxlmX3>}9eikC@0$NlgI>(qTmZbM`~?{v zq;%S2(Fgi!Ph5eUp1$$x`ijb&)g7cR75uNoY9y@%Y;WE5HFRNr%(ZRw+q*`_KRr4> zAE5LH95wc_kBfKqc}8*GYw zbNfrwWD3-{TW$tOmK8$?`#LcQIl^q z4+OsQL;ov(kG@ztpW~b*`;HO)Yq_Oy31D74Z+GkET<(0ElTmH)6|iASKVT4ue?_+; zDsbeuC9IT`-TjtzMo`R=BkY-J$wu2f>7H9WbS?e~p4Hdjo_*K;3XiXzyUPbM-bpCk znY5`_eO()N@T(_b8)lkITI5a@-aEV8W}>O`34EEj-)j^y=sW>P>F>(beIt6>m~Oph zPb=Z#Lg||0ZGH#rPtS?mwWFjCP&ht4;}?7{tcg;CXV8j`0rdiFnSPjPkIFHoz(x*j zJEp_zY0u6O(=?1=*5>ujuWykMKg~R~mCQK~$_9CRRIzxV5*K^=m&FO~N)aU;q9#r=*Xlbp+lbjQ~ ze{TaSz`%u1zH;M7-D&9i0?xw5h%nuAIqzxDA-_``p?ne`z*9k5wj%yYFKTR}ixw9?aa3;O-zt2$bN6H6=5f+!sk=>xM*|ZI^XxHoRz_6V&c4;U)cZP}ufUU`VtbTX?T`6$w}LhrcXL zgz5ETVzk(%-x-MdH(J-FHb?26Q+wV2J;NRJuLRuA4sv@WxaLRetk*$en*d_leM52W zPiL3?c*wlMP)v%NmP)Ht<|7C20_QR5{G}t_(g_Y&3udS-5j~dL0lRg;(0YmJ!oL!; zOMe%%d7V2jIkMNgiG=K`CCQvtLf?Jh;N8_FsySuy3b<0;^e}>%xh2Doe5@N(5g8D!_4Ma=OD%^(Ob3n%II zq3D3fk5HAxZtnvgaLMG3nA8=Orh?K%la(1jg`aG<|AJ#_y3J0!maZ;Mq0ol7lp*YA zoyXaC?I25vJtDnSmg)vQrVAZQs=G#inXZTBbKC)p>=L200#0@$;WNFZ|s=ie~7PxkR$Y>JygxBva)i0=#SA6AHR`yV#3_RB!M zEkQmlAi1b=v1PmMqjXo=k3;Hi2gxt-G1Hr!_{SypgnUL#t5z2Cc%JbK?rsbblR=8p zG288DEr+yeuFrp_(lWvfdi$okZqGJ_ZHYQQEtixcdN%R8zisp|cV?~KR&SHT#ozy_R&m#gmcsc4cnV(-M9w)L8TR>3MC9a{U7+R?!Ev3