Rebased on main and squashed

Co-authored-by: Louis DeJardin <dejardin@google.com>

* Fix Makefile Formatting

* Remove dependency on kptlib
* Tidy modules
* Delete kptlib
* Remove kptlib replace Clause

* Fix Porch Build

Location of ClonerUsingGitExec changed in the OCI branch.

* Add Porch Workflow

LICENSE file is supposed to be an exact copy of
https://www.apache.org/licenses/LICENSE-2.0.txt.

* Update VSCode Workspace
* Add launch.json
* Move Clone Logic Into Own File
* Implement Git pacakge fetch

Initial version of the function interfaces.

* Tidy Porch Modules
* Ignore Modules In .build Directory

We can have a git tag that looks like `packageDir/version`, this
allows for independent versioning of packages that share a git repo.

We need to try both ref forms when resolving git packages.

In particular, some of the methods such as GetResources are ambiguous
until we finish the draft (do we want the in-progress resources or the
upstream resources?)

In general, we should always return the error, unless we actually want
to mask it e.g. for security reasons (and in that case, we would
normally expect to log the underlying error instead of wrapping).

* Remove init and deinit (no longer useful)
* Fix module discovery
* Clean up directory references

* Render and Eval via Simple Memory FS
  For now the filesystem is inserted at lower level; In future changes
  the mutation Apply will accept the filesystem abstraction to avoid
  back-and-forth between filesystem and PackageResources.
* Clean up Function Evaluation to use new interface
* Remove unnecessary kpt module

First steps (with lots of hard-coding and hacks) towards applying from
a repository to a cluster.

aggregated-apiservers seem to query these resources, and spam the logs
(at least) if they don't have permission.

We start to expose the status of the sync operation.

Remove kpt directory from Docker build.

* Fix Go Modules

* Run Tidy in Porch Workflow

* Expose Renderer api with FileSystem abstraction

* Merge Fs methods in pkg.go

* Update name

* Merge ReadKptfile and address changes

* Update porch go.sum

* Update results write

* Suggested changes

* Create fix-all and verify-fix-all

We run all the formatters / header makers etc.

In CI, we run them and make sure that the git checkout is still clean.

Ideally we would also run generate, but it is very slow, and it also
requires GOPATH to be set.  We can do that in CI later.

* Add missing headers

* Add install-protoc.sh script
* Define a FunctionEvaluator interface
* Create an empty server implementation

* Integrate porch with renderer interview

* Suggested changes

* Add implementation

Replacing our very primitive apply logic with something better using
server-side apply.

We create a simple git server, and we try round-tripping a package.

Some hacks/todos uncovered that we need to tackle.

Our package logic requires a Kptfile, so adding one (for now).

And make names more consistent.

Several functions are built into the server Docker image and are exec'd
with input.
Added simple client which can be used (in ./func directory):

```
go run ./client \
  --address=192.168.8.202:9445 \
  --package=./config/ \
  --image=gcr.io/kpt-fn/set-namespace:v0.2.0 \
  -- \
  namespace=foo
```

This avoids dependency on docker in unit tests.
The price is that the simple functions don't support full semantics,
but they also run much faster.

…2712)

* git: create ApprovePackageRevision method, remove draft hack

Now that we can approve a package (in our tests at least), we can now
fetch the package on the non-draft ref.

* Update go-git to HEAD

We want to pick up go-git/go-git#325

* Building block for parsing arg location

- location.ParseReference to be used by CLI where string arg is taken
- may be used by callers that needs similar arg parsing/muxing
- callers which have strongly-typed data  initialize
  types like location.Git{...} and location.Oci{...}

* Adding test coverage for parsing "-" arg

- using WithStdin and WithStdout option must be added by the caller

- if they are both present on all calls to ParseReference, then the
location returned for "-" would be ambiguous. it depends on which
switch or argument is being parsed.

* Fixing PR errors related to best practices

* Another update for PR coding standard

* Adding details needed by kpg pkg get

- location.Reference gets Type() and Validate()
- kptfileutils has method to make kptfilev1 types from ref and reflock

* Selection of parsers is now controlled by options

- for kpt CLI it enables parse to be used for many different args
- for external code, enables custom and standard parsing together

* Adding comments and returning bool from trivial func

* Adding headers

* Using lock instead of string for argument name

* Using filepath.Clean before creating location.Dir{}

* Changing parsers to clarify semantics

- Parser and Option split into two concepts
- Single WithParsers option now takes ordered parsers
- StdioParser adjusted so WithStdin and WithStdout options
are not sensitive to parser order
- the parser result struct documented to clarify what to return and
how they combine

Co-authored-by: Louis DeJardin <dejardin@google.com>

* Add capability to override function runner during fnrender
* Use Lower-Level Function Runner Interface
  The function framework operates at the level of IO streams so we need to
  use that in order to benefit from comment healing and other features.
* Fix tests to rely on files-on-disk.

Co-authored-by: droot <sunilarora@google.com>

Just noticed kyaml comes with in-memory filesystem implementation.
Use it instead of custom one.

Remove direct dependency on deprecated kustomize/api package

…ev#2742)

* Fix test flake from timestamp sanitization

When timestamps "overlap", sanitization did not work correctly.

For example:

in 1s ... in 2.1s

The first substitution would replace 1s => 0s

in 0s ... in 2.0s

The second substitution is predetermined, and replaces 2.1s => 0s, but
2.1s is no longer in the string.

* Use new sanitization function in tests, remove old function

Co-authored-by: Justin Santa Barbara <justinsb@google.com>

* Use kpt Renderer in Porch
* Accept gRPC function runner endpoint

Stop hard-coding and use the image the user specifies!

This lets us switch from client-side-applied to server-side-applied.

It's now causing problems; we shouldn't need it and we should fix it
later in the logic anyway (with a default namespace).

Also a few tweaks to make the porch image build faster.

…uster (kptdev#2694)

This lets us start to run these on the server, instead of just locally.

This is a small refactor so that we can reuse this logic in future.

* missing file.Close() call (filesys' memory filesystem doesn't support
  files opened multiple times)
* pass filesystem into newFnConfig (it reads fn config from file)

* Move eval mutation into own file
* Pass Function Config to Eval
* Remove unused field (runner.fn)
* Move ConfigMap construction back to engine
* Eval preserves comments

If gRPC call fails, res is nill :(

After changes to git cloning we return PackageResources with configs
at the "root directory". Therefore we don't need to rewrite config paths
anymore.

The client was using packagerevisionresourceses (extra "es"), which
doesn't match the server name.

* Upgrade dependencies
* Upgrade go to 1.17

* Use the same naming pattern
* Enable nested Makefiles to inherit values from parent
* Enable explicit image tagging (i.e. using
  `IMAGE_TAG=$(git rev-parse --short HEAD) make build-images`
* Enable `make build-images` and `make push-images`

`go run` doesn't support setting working directory; use `go build`
instead.

* Add subpkgs test for porch

* Add runtime

* Basic e2e Test
* Simple harness to reduce some boilerplate
* Add a simple git repo test

* Start background processing in Run function
* Shut down when stopCh is closed

Occasionally `make tidy` fails complaining about 1.16 vs. 1.17 golang;
this should keep our mods 1.17 compatible with fewer `make tidy`
failures.

Create options for the common engine configuration options.

* Add CredentialResolver interface
* Add WithCredentialResolver engine option
* Use lazy credential resolution when interacting with Git

Turns out k8s apiserver supports both and we can get the core context to
listen on instead of just getting the close channel.

Git branch and directory can be optional (defaulting to `main` and `/` respectively,
while `SecretRef.Name` is required since nameless secret reference is unhelpful.

* Create `deployment-config` and `push-and-deploy` make targets
* Use kpt function to set images on the deployment config

* Set workload identity service accounts via set-annotations
* Simplify instructions
* Build at Git tag
* Combine Deployment Config in Same Directory
* Rename config files, assign 0 to CRDs.
* `kubectl apply` recursively just in case we add more config later

Use consistent version of controller-gen (v0.8.0)
crd:preserveUnknownFields marker has been removed (`false` was the
required value for v1 CRDs).

Otherwise we crash when trying to render a package.

We weren't checking errors when building a CaDEngine.

When creating an empty package, we get an error otherwise (as kpt
render doesn't work if it doesn't have a package).

Enable e2e tests to use git server

Simple test that creates a package by cloning from upstream repository.

Some blueprints we encounter in tests use the older version of the function.

Newly created Git package returned package resources at its old commit
SHA where no package contents existed, thus returning empty resources.
As package changes, advance the reference to return up-to-date package
revision contents.

* Make Git Server hostable in cluster
* Add makefile targets to build and push its images

* Add PackageRevision .../approval subresource
* Generate client

* Add Clone Package Test
* Fix issues with git server's reporting of symbolic references

Preparing for merge of porch branch back into main,

* Revert "Kpt location parsing (kptdev#2688)"
* Revert "oci-support feature branch (kptdev#2666)"

* Tidy go modules
* Fix year in license header
* Fixed few more issues that crept in during merges from main and preparing for merge back to main.