use slightly larger GKE nodes due to Insufficient cpu errors

Error observed during deploying the Pinniped Supervisor was...

Pending: Unschedulable, message: 0/3 nodes are available: 3 Insufficient
cpu. no new claims to deallocate, preemption: 0/3 nodes are available:
3 No preemption victims found for incoming pod.

.gitattributes

@@ -1,2 +0,0 @@
-*.go.tmpl linguist-language=Go
-generated/** linguist-generated

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,42 +0,0 @@
----
-name: Bug report
-about: Explain a problem you are experiencing
-title: ''
-labels: ''
-assignees: ''
-
----
-
-<!--
-
-Hey! Thanks for opening an issue!
-
-IMPORTANT: If you believe this bug is a security issue, please don't use this template and follow our [security guidelines](/doc/security.md).
-
-It is recommended that you include screenshots and logs to help everyone achieve a shared understanding of the bug.
-
--->
-
-**What happened?**
-
-> Please be specific and include screenshots and logs!
-
-**What did you expect to happen?**
-
-> Please be specific and include proposed behavior!
-
-**What is the simplest way to reproduce this behavior?**
-
-**In what environment did you see this bug?**
-- Pinniped server version:
-- Pinniped client version:
-- Pinniped container image (if using a public container image):
-- Pinniped configuration (what IDP(s) are you using? what downstream credential minting mechanisms are you using?):
-- Kubernetes version (use `kubectl version`):
-- Kubernetes installer & version (e.g., `kubeadm version`):
-- Cloud provider or hardware configuration:
-- OS (e.g: `cat /etc/os-release`):
-- Kernel (e.g. `uname -a`):
-- Others:
-
-**What else is there to know about this bug?**

.github/ISSUE_TEMPLATE/feature-proposal.md

@@ -1,35 +0,0 @@
----
-name: Feature proposal
-about: Suggest a way to improve this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-<!--
-
-Hey! Thanks for opening an issue!
-
-It is recommended that you include screenshots and logs to help everyone achieve a shared understanding of the improvement.
-
--->
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Are you considering submitting a PR for this feature?**
-
-- **How will this project improvement be tested?**
-- **How does this change the current architecture?**
-- **How will this change be backwards compatible?**
-- **How will this feature be documented?**
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/codecov.yml

@@ -1,15 +0,0 @@
-codecov:
-  strict_yaml_branch: main
-  require_ci_to_pass: no
-  notify:
-    wait_for_ci: no
-coverage:
-  status:
-    project:
-      default:
-        informational: true
-    patch:
-      default:
-        informational: true
-ignore:
-- cmd/local-user-authenticator/

.github/dependabot.yml

@@ -1,13 +0,0 @@
-# See https://docs.github.com/en/github/administering-a-repository/enabling-and-disabling-version-updates
-
-version: 2
-updates:
-  - package-ecosystem: "gomod"
-    directory: "/"
-    schedule:
-      interval: "daily"
-
-  - package-ecosystem: "docker"
-    directory: "/"
-    schedule:
-      interval: "daily"

.github/pull_request_template.md

@@ -1,41 +0,0 @@
-<!--
-Thank you for submitting a pull request for Pinniped!
-
-Before submitting, please see the guidelines in CONTRIBUTING.md in this repo.
-
-Please note that a project maintainer will need to review and provide an
-initial approval on the PR to cause CI tests to automatically start.
-Also note that if you push additional commits to the PR, those commits
-will need another initial approval before CI will pick them up.
-
-Reminder: Did you remember to run all the linter, unit tests, and integration tests
-described in CONTRIBUTING.md on your branch before submitting this PR?
-
-Below is a template to help you describe your PR.
--->
-
-<!--
-Provide a summary of your change. Feel free to use paragraphs or a bulleted list, for example:
-
-- Improves performance by 10,000%.
-- Fixes all bugs.
-- Boils the oceans.
-
--->
-
-<!--
-Does this PR fix one or more reported issues?
-If yes, use `Fixes #<issue number>` to automatically close the fixed issue(s) when the PR is merged.
--->
-
-**Release note**:
-
-<!--
-Does this PR introduce a user-facing change?
-
-If no, just write "NONE" in the release-note block below.
-If yes, a release note is required. Enter your extended release note in the block below.
--->
-```release-note
-
-```

.gitignore

@@ -1,21 +1,7 @@
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# Dependency directories (remove the comment below to include it)
-# vendor/
-
-# GoLand
 .idea
-
-# MacOS Desktop Services Store
+.terraform
+*.tfstate.*
+*.tfstate
+kubeconfig.yaml
 .DS_Store
+site/

.golangci.yaml

@@ -1,74 +0,0 @@
-# https://github.com/golangci/golangci-lint#config-file
-run:
-  deadline: 1m
-  skip-dirs:
-    - generated
-
-linters:
-  disable-all: true
-  enable:
-  # default linters
-  - deadcode
-  - errcheck
-  - gosimple
-  - govet
-  - ineffassign
-  - staticcheck
-  - structcheck
-  - typecheck
-  - unused
-  - varcheck
-
-  # additional linters for this project (we should disable these if they get annoying).
-  - asciicheck
-  - bodyclose
-  - depguard
-  - dogsled
-  - exhaustive
-  - exportloopref
-  - funlen
-  - gochecknoglobals
-  - gochecknoinits
-  - gocritic
-  - gocyclo
-  - godot
-  - goheader
-  - goimports
-  - golint
-  - goprintffuncname
-  - gosec
-  - misspell
-  - nakedret
-  - nestif
-  - noctx
-  - nolintlint
-  - prealloc
-  - rowserrcheck
-  - scopelint
-  - sqlclosecheck
-  - unconvert
-  - unparam
-  - whitespace
-
-issues:
-  exclude-rules:
-    # exclude tests from some rules for things that are useful in a testing context.
-  - path: _test\.go
-    linters:
-    - funlen
-    - gochecknoglobals
-
-linters-settings:
-  funlen:
-    lines: 150
-    statements: 50
-  goheader:
-    values:
-      regexp:
-        # YYYY or YYYY-YYYY
-        YEARS: \d\d\d\d(-\d\d\d\d)?
-    template: |-
-        Copyright {{YEARS}} the Pinniped contributors. All Rights Reserved.
-        SPDX-License-Identifier: Apache-2.0
-  goimports:
-    local-prefixes: go.pinniped.dev

.pre-commit-config.yaml

@@ -1,25 +1,23 @@
 # This is a configuration for https://pre-commit.com/.
 # On macOS, try `brew install pre-commit` and then run `pre-commit install`.
-exclude: '^(site|generated)/'
 repos:
-- repo: git://github.com/pre-commit/pre-commit-hooks
-  rev: v3.2.0
-  hooks:
-  # TODO: find a version of this to validate ytt templates?
-  # - id: check-yaml
-  #   args: ['--allow-multiple-documents']
-  - id: check-json
-  - id: end-of-file-fixer
-  - id: trailing-whitespace
-  - id: check-merge-conflict
-  - id: check-added-large-files
-  - id: check-byte-order-marker
-  - id: detect-private-key
-    exclude: testdata
-  - id: mixed-line-ending
-- repo: local
-  hooks:
-  - id: validate-copyright-year
-    name: Validate copyright year
-    entry: hack/check-copyright-year.sh
-    language: script
+    - repo: https://github.com/pre-commit/pre-commit-hooks
+      rev: v5.0.0
+      hooks:
+          # TODO: find a version of this to validate ytt templates?
+          # - id: check-yaml
+          #   args: ['--allow-multiple-documents']
+          - id: check-json
+          - id: end-of-file-fixer
+          - id: trailing-whitespace
+          - id: check-merge-conflict
+          - id: check-added-large-files
+          - id: check-byte-order-marker
+          - id: detect-private-key
+          - id: mixed-line-ending
+    - repo: local
+      hooks:
+          - id: validate-copyright-year
+            name: Validate copyright year
+            entry: hack/check-copyright-year.sh
+            language: script

AD-SETUP.md

@@ -0,0 +1,603 @@
+# Creating an Active Directory server on Google Cloud for Pinniped integration tests
+
+This documents the steps that were taken to create our test AD server used by the integration tests.
+The integration tests use LDAPS and StartTLS to connect to the AD server.
+
+## Create a Windows Server VM and configure it as an AD Domain Controller
+
+The steps in this section were mostly inspired by
+https://cloud.google.com/architecture/deploy-an-active-directory-forest-on-compute-engine.
+
+From your Mac, create a VPC, subnet, firewall rules, admin password, reserved static IP, and the VM itself.
+
+On your Mac:
+
+```shell
+# Login as yourself.
+gcloud auth login
+
+# Set some variables.
+project="REDACTED" # Change this to be the actual project name before running these commands.
+region="us-west1"
+zone="us-west1-c"
+vpc_name="ad"
+
+# Create VPC.
+gcloud compute networks create ${vpc_name} \
+  --project ${project} \
+  --description "VPC network to deploy Active Directory" \
+  --subnet-mode custom
+
+# Create subnet.
+# The google tutorial says to "enable Private Google Access so that Windows can activate without internet access."
+gcloud compute networks subnets create domain-controllers \
+  --project ${project} --region ${region} \
+  --network ${vpc_name} \
+  --range "10.0.0.0/28" \
+  --enable-private-ip-google-access
+
+# Create a firewall rule to allow RDP. Find out what your public IP address is by going to https://whatismyipaddress.com.
+# Replace the X.X.X.X placeholder address shown here with your real IPv4 address.
+my_ip=X.X.X.X
+gcloud compute firewall-rules create allow-rdp-ingress-to-addc \
+  --project ${project} \
+  --direction INGRESS \
+  --action allow \
+  --rules tcp:3389 \
+  --source-ranges "${my_ip}/32" \
+  --target-tags ad-domaincontroller \
+  --network ${vpc_name} \
+  --priority 10000
+
+# Allow LDAPS (port 636) from the whole internet.
+gcloud compute firewall-rules create allow-ldaps-ingress-to-addc \
+  --project ${project} \
+  --direction INGRESS \
+  --action allow \
+  --rules tcp:636 \
+  --source-ranges "0.0.0.0/0" \
+  --target-tags ad-domaincontroller \
+  --network ${vpc_name} \
+  --priority 10000
+
+# Allow LDAP (port 389) from the whole internet, to allow the integration tests to use StartTLS.
+gcloud compute firewall-rules create allow-ldap-ingress-to-addc \
+  --project ${project} \
+  --direction INGRESS \
+  --action allow \
+  --rules tcp:389 \
+  --source-ranges "0.0.0.0/0" \
+  --target-tags ad-domaincontroller \
+  --network ${vpc_name} \
+  --priority 10000
+
+# Reserve a static public IP address for the domain controller VM.
+addressOfDc1=$(gcloud compute addresses create ad-domain-controller \
+  --project ${project} --region ${region} \
+  --format="value(address)")
+
+# Create an admin password for the Administrator user on Windows, and save it to secrets manager.
+password="$(openssl rand -hex 8)-$(openssl rand -hex 8)"
+echo -n "$password" > password.tmp
+gcloud secrets create active-directory-dc1-password \
+  --project ${project} \
+  --data-file password.tmp
+rm password.tmp
+
+# This creates a service account called ad-domaincontroller@PROJECT_NAME.iam.gserviceaccount.com
+# (where PROJECT_NAME is the actual GCP project name) and sets the account name to the
+# variable $dcServiceAccount.
+dcServiceAccount=$(gcloud iam service-accounts create ad-domaincontroller \
+  --project ${project} \
+  --display-name "AD Domain Controller VM Service Account" \
+  --format "value(email)")
+
+# Allow the new service account to temporarily read the Windows admin password from secret manager.
+# The following `date` command might only work on MacOS. It prints the time like this: 2024-10-23T19:20:36Z
+one_hour_from_now=$(TZ=UTC date -v "+1H" +"%Y-%m-%dT%H:%M:%SZ")
+gcloud secrets add-iam-policy-binding active-directory-dc1-password \
+  --project ${project} \
+  "--member=serviceAccount:$dcServiceAccount" \
+  --role=roles/secretmanager.secretAccessor \
+  --condition="title=Expires after 1h,expression=request.time < timestamp('$one_hour_from_now')"
+
+# Optional: list all bindings to see the binding that you just created.
+gcloud secrets get-iam-policy active-directory-dc1-password \
+  --project ${project}
+
+# Create a powershell startup script in a local file.
+cat <<"EOF" > dc-startup.ps1
+$ErrorActionPreference = "Stop"
+
+#
+# Only run the script if the VM is not a domain controller already.
+#
+if ((Get-CimInstance -ClassName Win32_OperatingSystem).ProductType -eq 2) {
+    exit
+}
+
+#
+# Read configuration from metadata.
+#
+Import-Module "${Env:ProgramFiles}\Google\Compute Engine\sysprep\gce_base.psm1"
+
+Write-Host "Reading metadata..."
+$ActiveDirectoryDnsDomain     = Get-MetaData -Property "attributes/ActiveDirectoryDnsDomain" -instance_only
+$ActiveDirectoryNetbiosDomain = Get-MetaData -Property "attributes/ActiveDirectoryNetbiosDomain" -instance_only
+$ProjectId                    = Get-MetaData -Property "project-id" -project_only
+$AccessToken                  = (Get-MetaData -Property "service-accounts/default/token" | ConvertFrom-Json).access_token
+
+#
+# Read the DSRM password from secret manager.
+#
+Write-Host "Reading secret from secret manager..."
+$Secret = (Invoke-RestMethod `
+    -Headers @{
+        "Metadata-Flavor" = "Google";
+        "x-goog-user-project" = $ProjectId;
+        "Authorization" = "Bearer $AccessToken"} `
+    -Uri "https://secretmanager.googleapis.com/v1/projects/$ProjectId/secrets/active-directory-dc1-password/versions/latest:access")
+$DsrmPassword = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($Secret.payload.data))
+$DsrmPassword = ConvertTo-SecureString -AsPlainText $DsrmPassword -force
+
+#
+# Promote.
+#
+Write-Host "Setting administrator password..."
+Set-LocalUser -Name Administrator -Password $DsrmPassword
+
+Write-Host "Creating a new forest $ActiveDirectoryDnsDomain ($ActiveDirectoryNetbiosDomain)..."
+Install-ADDSForest `
+    -DomainName $ActiveDirectoryDnsDomain `
+    -DomainNetbiosName $ActiveDirectoryNetbiosDomain `
+    -SafeModeAdministratorPassword $DsrmPassword `
+    -DomainMode Win2008R2 `
+    -ForestMode Win2008R2 `
+    -InstallDns `
+    -CreateDnsDelegation:$False `
+    -NoRebootOnCompletion:$True `
+    -Confirm:$false
+
+#
+# Configure DNS.
+#
+Write-Host "Configuring DNS settings..."
+Get-Netadapter| Disable-NetAdapterBinding -ComponentID ms_tcpip6
+Set-DnsClientServerAddress  `
+    -InterfaceIndex (Get-NetAdapter -Name Ethernet).InterfaceIndex `
+    -ServerAddresses 127.0.0.1
+
+#
+# Enable LSA protection.
+#
+New-ItemProperty `
+    -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" `
+    -Name "RunAsPPL" `
+    -Value 1 `
+    -PropertyType DWord
+
+Write-Host "Restarting to apply all settings..."
+Restart-Computer
+EOF
+
+# Create a domain controller VM.
+# E2 are the cheapest VMs. e2-medium has 2 vCPUs (shared with other customers) and 4 GB of memory.
+# See https://cloud.google.com/compute/docs/general-purpose-machines#e2-shared-core.
+# When we originally set up this VM, we actually started it as n2-standard-2 and after we
+# finished setting up everything as shown in this guide, then we stopped the VM and changed its
+# type to e2-medium and started the VM again. Maybe it would work fine to create it as
+# e2-medium from the beginning, but note that we didn't actually test that.
+gcloud compute instances create active-directory-dc1  \
+  --project ${project} \
+  --zone ${zone} \
+  --image-family windows-2022 \
+  --image-project windows-cloud \
+  --machine-type e2-medium \
+  --tags ad-domaincontroller \
+  --metadata "ActiveDirectoryDnsDomain=activedirectory.test.pinniped.dev,ActiveDirectoryNetbiosDomain=pinniped-ad,sysprep-specialize-script-ps1=Install-WindowsFeature AD-Domain-Services -IncludeManagementTools; Install-WindowsFeature DNS,disable-account-manager=true" \
+  --metadata-from-file windows-startup-script-ps1=dc-startup.ps1 \
+  --address ${addressOfDc1} \
+  --subnet=domain-controllers \
+  --service-account "$dcServiceAccount" \
+  --scopes cloud-platform \
+  --shielded-integrity-monitoring \
+  --shielded-secure-boot \
+  --shielded-vtpm
+
+# Monitor the initialization process of the first domain controller by viewing its serial port output.
+# It should install the sysprep stuff, reboot, run our startup script, and then reboot again.
+gcloud compute instances tail-serial-port-output active-directory-dc1 \
+  --project ${project} \
+  --zone ${zone}
+# Use CTRL-C to cancel tailing the output.
+```
+
+## Update DNS
+
+Update the Cloud DNS entry for `activedirectory.test.pinniped.dev.` to be an "A" record pointing to the
+public static IP of the VM. This is easier to do in the Cloud DNS UI in your browser.
+It would take many gcloud CLI commands to accomplish the same task.
+
+## Configure test users and groups
+
+Make sure you have an RDP client installed. On a Mac, you can install RDP from the App Store.
+It was recently renamed "Windows App".
+
+Note: To copy/paste in the RDP client, you may need to use CTRL-C/CTRL-V if CMD-C/CMD-V don't work.
+
+RDP into the Windows VM. To connect, use `activedirectory.test.pinniped.dev` as the name of the server,
+the username `Administrator`, and the password from the `active-directory-dc1-password` entry in Secrets Manager.
+You can ignore the RDP certificate error.
+
+In your RDP session, open Powershell. Then run the following commands to add some users and groups,
+change the password policy, and grant some permissions.
+
+Before running the commands, replace the redacted passwords as follows:
+- The value for `REDACTED_BIND_USER_PASSWORD` can be found at `aws-ad-bind-account-password` in the `concourse-secrets` secret
+- The value for `REDACTED_PINNY_USER_PASSWORD` can be found at `aws-ad-user-password` in the `concourse-secrets` secret
+- The value for `REDACTED_DEACTIVATED_USER_PASSWORD` can be found at `aws-ad-deactivated-user-password` in the `concourse-secrets` secret
+
+```shell
+New-ADOrganizationalUnit -Name "pinniped-ad" `
+  -ProtectedFromAccidentalDeletion $false
+
+New-ADOrganizationalUnit -Name "Users" `
+  -Path "OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev" `
+  -ProtectedFromAccidentalDeletion $false
+
+New-ADOrganizationalUnit -Name "test-users" `
+  -Path "OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev" `
+  -Description "integration tests will create and delete ephemeral users here" `
+  -ProtectedFromAccidentalDeletion $false
+
+# Print all OUs to validate that they were created.
+Get-ADOrganizationalUnit -Filter *
+
+New-ADUser -Name "Bind User" -SamAccountName "bind-user" -GivenName "Bind" -Surname "User" -DisplayName "Bind User" `
+  -UserPrincipalName "bind-user@activedirectory.test.pinniped.dev" `
+  -Path "OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev" `
+  -AccountPassword (ConvertTo-SecureString "REDACTED_BIND_USER_PASSWORD" -AsPlainText -Force) `
+  -Enabled $true -PasswordNeverExpires $true
+
+# Note that the value of EmailAddress is not a real email address, but that's okay.
+New-ADUser -Name "Pinny Seal" -SamAccountName "pinny" -GivenName "Pinny" -Surname "Seal" -DisplayName "Pinny Seal" `
+  -UserPrincipalName "pinny@activedirectory.test.pinniped.dev" `
+  -Path "OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev" `
+  -EmailAddress "tanzu-user-authentication@groups.vmware.com" `
+  -AccountPassword (ConvertTo-SecureString "REDACTED_PINNY_USER_PASSWORD" -AsPlainText -Force) `
+  -Enabled $true -PasswordNeverExpires $true
+
+New-ADUser -Name "Deactivated User" -SamAccountName "deactivated-user" -GivenName "Deactivated" -Surname "User" -DisplayName "Deactivated User" `
+  -UserPrincipalName "deactivated-user@activedirectory.test.pinniped.dev" `
+  -Path "OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev" `
+  -AccountPassword (ConvertTo-SecureString "REDACTED_DEACTIVATED_USER_PASSWORD" -AsPlainText -Force) `
+  -Enabled $false -PasswordNeverExpires $true
+
+# Take note of the pinny account's ObjectGUID. You will need to edit the concourse-secrets secret later to update this GUID value.
+# This value should look something like "288188dd-ab76-4f61-b6e4-c72e081502c5".
+Get-ADUser pinny -Properties * | Select SamaccountName,ObjectGUID
+
+# Print all users to validate that they were created.
+Get-ADUser -Filter *
+
+New-ADGroup -Name "Marine Mammals" -SamAccountName "Marine Mammals" -DisplayName "Marine Mammals" `
+  -GroupCategory Security -GroupScope Global `
+  -Path "OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev"
+
+Add-ADGroupMember -Identity "Marine Mammals" -Members "pinny"
+
+New-ADGroup -Name "Mammals" -SamAccountName "Mammals" -DisplayName "Mammals" `
+  -GroupCategory Security -GroupScope Global `
+  -Path "OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev"
+
+Add-ADGroupMember -Identity "Mammals" -Members "Marine Mammals"
+
+# Change the default password policy. There are some integration tests that rely on this.
+# This is the equivalent of doing this in the Windows "Active Directory Administrative Center" UI:
+# check "enforce account lockout policy", give it 20 failed attempts and a 15-minute reset, then
+# uncheck "enforce minimum password age" so we can change the password immediately upon creating a user.
+Set-ADDefaultDomainPasswordPolicy -Identity "activedirectory.test.pinniped.dev" `
+  -LockoutThreshold 20 -LockoutDuration "00:15:00" -LockoutObservationWindow "00:15:00" `
+  -MinPasswordAge 0
+
+# Print the policy to validate that it was updated.
+Get-ADDefaultDomainPasswordPolicy
+
+# We need to allow the bind-user to create/delete/edit users and groups within the test-users OU, because several
+# integration tests want to crate/delete/edit ephemeral test users and groups.
+# These access control steps were inspired by https://the-itguy.de/delegate-access-in-active-directory-with-powershell/.
+# This is intended to be the equivalent of using the UI to assign permissions like this: right click on "test-users",
+# select Delegate Control, select "bind-user" as the user, select "create, delete and manage user accounts" and
+# "reset user passwords" as the tasks to delegate.
+function New-ADDGuidMap
+{
+    $rootdse = Get-ADRootDSE
+    $guidmap = @{ }
+    $GuidMapParams = @{
+        SearchBase = ($rootdse.SchemaNamingContext)
+        LDAPFilter = "(schemaidguid=*)"
+        Properties = ("lDAPDisplayName", "schemaIDGUID")
+    }
+    Get-ADObject @GuidMapParams | ForEach-Object { $guidmap[$_.lDAPDisplayName] = [System.GUID]$_.schemaIDGUID }
+    return $guidmap
+}
+$GuidMap = New-ADDGuidMap
+$BindUserSID = New-Object System.Security.Principal.SecurityIdentifier (Get-ADUser "bind-user").SID
+$acl = Get-Acl -Path "AD:OU=test-users,OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev"
+$ace1 = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $BindUserSID, "GenericAll", "Allow", "Descendents", $GuidMap["user"]
+$ace2 = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $BindUserSID, "CreateChild, DeleteChild", "Allow", $GuidMap["user"], "All"
+$ace3 = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $BindUserSID, "GenericAll", "Allow", "Descendents", $GuidMap["group"]
+$ace4 = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $BindUserSID, "CreateChild, DeleteChild", "Allow", $GuidMap["group"], "All"
+$acl.AddAccessRule($ace1)
+$acl.AddAccessRule($ace2)
+$acl.AddAccessRule($ace3)
+$acl.AddAccessRule($ace4)
+Set-Acl -Path "AD:OU=test-users,OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev" -AclObject $acl
+
+# Print the access control rules that were just applied.
+$acl = Get-Acl -Path "AD:OU=test-users,OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev"
+$acl.Access |  Where-Object { $_.IdentityReference -eq "pinniped-ad\bind-user" }
+```
+
+If you would like to see these OUs, users, and groups in the UI, you can open the "Active Directory Users and Computers"
+app in your RDP session.
+
+## Configure a CA and a serving certificate for LDAPS
+
+Now we need to create and configure a TLS serving certificate for LDAPS.
+
+The certificate needs to include two hostnames. One of the hostnames is the name that the AD server
+thinks is its own hostname (`active-directory-dc1.activedirectory.test.pinniped.dev`).
+This is how the AD server will decide to use this cert for the LDAPS port.
+The other hostname is the one that clients will use when making connections from the outside
+(`activedirectory.test.pinniped.dev`) so they can validate the server certificate.
+
+The steps here were inspired by https://gist.github.com/magnetikonline/0ccdabfec58eb1929c997d22e7341e45.
+
+On your mac:
+
+```shell
+# On your Mac: Create a self-signed CA public/private keypair.
+openssl req -x509 -newkey rsa:4096 \
+  -keyout ad-ca.key -out ad-ca.crt \
+  -sha256 -days 36500 -nodes \
+  -subj "/C=US/ST=California/L=San Francisco/O=Pinniped/OU=Pinniped CI/CN=Pinniped AD CA"
+
+# Copy the public key to your clipboard.
+cat ad-ca.crt| pbcopy
+```
+
+In Powershell terminal:
+
+```shell
+# In your Windows RDP session's Powershell terminal, put the content of the clipboard into a file.
+# Note that if you copy/paste this command to your RDP session, then you need to pbcopy the public
+# key again before you hit return for this command.
+Get-Clipboard | Out-File -FilePath "C:\users\administrator\desktop\ca.crt"
+
+# In Powershell terminal, check that the file exists and looks correct.
+type "C:\users\administrator\desktop\ca.crt"
+
+# Import root certificate into trusted store of domain controller in your Powershell terminal:
+Import-Certificate -FilePath "C:\users\administrator\desktop\ca.crt" -CertStoreLocation Cert:\LocalMachine\Root
+```
+
+If you want to validate that this was imported, open the UI tool called "Manage computer certificates"
+and look in the folder called "Trusted Root Certification Authorities\Certificates".
+If the UI was already open, click the refresh button.
+
+Copy the following file contents to your clipboard:
+
+```shell
+[Version]
+Signature="$Windows NT$"
+
+[NewRequest]
+Subject = "CN=activedirectory.test.pinniped.dev"
+KeySpec = 1
+KeyLength = 2048
+Exportable = TRUE
+MachineKeySet = TRUE
+SMIME = FALSE
+PrivateKeyArchive = FALSE
+UserProtected = FALSE
+UseExistingKeySet = FALSE
+ProviderName = "Microsoft RSA SChannel Cryptographic Provider"
+ProviderType = 12
+RequestType = PKCS10
+KeyUsage = 0xa0
+
+[EnhancedKeyUsageExtension]
+OID = 1.3.6.1.5.5.7.3.1 ; Server Authentication
+
+[Extensions]
+2.5.29.17 = "{text}"
+_continue_ = "DNS=activedirectory.test.pinniped.dev"
+_continue_ = "DNS=active-directory-dc1.activedirectory.test.pinniped.dev"
+```
+
+In Powershell terminal:
+
+```shell
+# In your Windows RDP session's Powershell terminal, put the content of the clipboard into a file.
+# Note that if you copy/paste this command to your RDP session, then you need to copy the file contents
+# from above again before you hit return for this command.
+Get-Clipboard | Out-File -FilePath "C:\users\administrator\desktop\request.inf"
+
+# In Powershell terminal, check that the file exists and looks correct.
+type "C:\users\administrator\desktop\request.inf"
+
+# Create a CSR. This command will also generate a private key for the AD server and save it.
+certreq -new "C:\users\administrator\desktop\request.inf" "C:\users\administrator\desktop\client.csr"
+
+# Show the CSR.
+type "C:\users\administrator\desktop\client.csr"
+
+# Copy the content of this file to your clipboard.
+Get-Content "C:\users\administrator\desktop\client.csr" | Set-Clipboard
+```
+
+On your mac:
+
+```shell
+# On your Mac, use the CA to issue a serving cert based on the CSR.
+pbpaste > client.csr
+
+cat <<EOF > v3ext.txt
+keyUsage=digitalSignature,keyEncipherment
+extendedKeyUsage=serverAuth
+subjectKeyIdentifier=hash
+subjectAltName = @alt_names
+[alt_names]
+  DNS.1 = activedirectory.test.pinniped.dev
+  DNS.2 = active-directory-dc1.activedirectory.test.pinniped.dev
+EOF
+
+# Create a cert from the CSR signed by the CA.
+openssl x509 \
+   -req -days 36500 \
+   -in client.csr -CA ad-ca.crt -CAkey ad-ca.key -extfile v3ext.txt \
+   -set_serial 01 -out client.crt
+
+# Inspect the generated certificate.
+# Ensure the following X509v3 extensions are all present:
+#   Key Usage: Digital Signature, Key Encipherment
+#   Extended Key Usage: TLS Web Server Authentication
+#   Subject Key Identifier
+#   Subject Alternative Name with 2 DNS hostnames
+#   Authority Key Identifier
+openssl x509 -in client.crt -text
+
+# Copy the generated cert.
+cat client.crt | pbcopy
+```
+
+In Powershell terminal:
+
+```shell
+# In your Windows RDP session's Powershell terminal, put the content of the clipboard into a file.
+# Note that if you copy/paste this command to your RDP session, then you need to pbcopy the file contents
+# from above again before you hit return for this command.
+Get-Clipboard | Out-File -FilePath "C:\users\administrator\desktop\client.crt"
+
+# In Powershell terminal, check that the file exists and looks correct.
+type "C:\users\administrator\desktop\client.crt"
+
+# Add the serving certificate to Windows. This will also automatically associate it to the private key that you
+# generated with the previous usage of certreq.
+certreq -accept "C:\users\administrator\desktop\client.crt"
+
+# If you want to validate that this was imported, open the UI tool called "Manage computer certificates"
+# and look in the folder called "Personal\Certificates". If the UI was already open, click the refresh button.
+# Double click on the cert. Ensure that it says, "you have a private key that corresponds to this certificate".
+# Next, we need to reboot the VM for the cert to get picked up and used for serving incoming LDAPS connections.
+# After showing you a warning dialog box, this should terminate your RDP session and stop the VM.
+shutdown /s
+```
+
+Wait for the VM to stop, then start the VM again from your Mac:
+
+```shell
+gcloud compute instances start active-directory-dc1 --project ${project} --zone ${zone}
+```
+
+Wait for the VM to finish booting. Then we can confirm that LDAPS is working. On your Mac:
+
+```shell
+# Check that serving cert is being returned on the LDAPS port. This command should show the cert chain.
+# It should also verify the server cert using our CA. The output should include "Verify return code: 0 (ok)".
+openssl s_client -connect activedirectory.test.pinniped.dev:636 -showcerts -CAfile ad-ca.crt < /dev/null
+
+# Unfortunately, the ldapsearch command that comes pre-installed on MacOS does not seem to respect
+# the LDAPTLS_CACERT env variable. So it will not be able to validate the server certificates.
+# As a workaround, we can use docker to run ldapsearch commands in a linux container.
+
+# Test the regular LDAP port by issuing a query on your Mac. The -ZZ option asks it to use StartTLS.
+# This should list all users. Replace REDACTED_BIND_USER_PASSWORD with the real password.
+docker run -v "$(pwd):/certs" -e LDAPTLS_CACERT="/certs/ad-ca.crt" --rm -it bitnami/openldap \
+  ldapsearch -d8 -v -x -ZZ -H 'ldap://activedirectory.test.pinniped.dev' \
+  -D 'CN=Bind User,OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev' \
+  -w 'REDACTED_BIND_USER_PASSWORD' \
+  -b 'OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev' \
+  -s sub \
+  '(objectClass=user)' '*'
+
+# Test the LDAPS port by issuing a query on your Mac. This should list all users.
+# Replace REDACTED_BIND_USER_PASSWORD with the real password.
+docker run -v "$(pwd):/certs" -e LDAPTLS_CACERT="/certs/ad-ca.crt" --rm -it bitnami/openldap \
+  ldapsearch -d8 -v -x -H 'ldaps://activedirectory.test.pinniped.dev' \
+  -D 'CN=Bind User,OU=Users,OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev' \
+  -w 'REDACTED_BIND_USER_PASSWORD' \
+  -b 'OU=pinniped-ad,DC=activedirectory,DC=test,DC=pinniped,DC=dev' \
+  -s sub \
+  '(objectClass=user)' '*'
+```
+
+## Update the `concourse-secrets` secret in GCP Secrets Manager
+
+On your Mac:
+
+```shell
+# Copy the CA's public cert.
+cat ad-ca.crt | base64 | pbcopy
+
+# cd to your local clone of the `ci` branch of the pinniped repo
+cd pinniped-ci-branch
+
+# Edit the secret.
+./hack/edit-gcloud-secret.sh concourse-secret
+# This opens vim to edit the secret.
+# Paste the cert as the value for `aws-ad-ca-data`.
+# Also edit the the value of `aws-ad-user-unique-id-attribute-value`. The value should be the ObjectGUID of the pinny
+# user that you created in the steps above.
+# Save your changes, exit vim, and when prompted say that you want to save this as the new version of concourse-secrets.
+```
+
+## Confirm that Active Directory integration tests can pass
+
+Use these commands run all the Active Directory integration tests on your Mac.
+The `-run` filter is based on the tests as they existed at the time of writing this doc.
+You can find AD tests by searching for `SkipTestWhenActiveDirectoryIsUnavailable`.
+
+On your Mac:
+
+```shell
+# Login so we can read the secrets from GCP Secret Manager.
+gcloud auth login
+
+# cd to your local git clone
+cd pinniped
+
+# Compile and install onto a local kind cluster.
+./hack/prepare-for-integration-tests.sh -c --get-active-directory-vars "../pinniped-ci-branch/hack/get-aws-ad-env-vars.sh"
+
+# Run all the tests that depend on AD.
+source /tmp/integration-test-env && go test -v -race -count 1 -timeout 0 ./test/integration \
+  -run "/TestSupervisorLogin_Browser/active_directory|/TestE2EFullIntegration_Browser/with_Supervisor_ActiveDirectory|/TestActiveDirectoryIDPPhaseAndConditions_Parallel|/TestSupervisorWarnings_Browser/Active_Directory"
+```
+
+## Cleanup
+
+On your Mac:
+
+```shell
+# Remove all bindings for the service account from the secret.
+# The binding was only needed during the first boot of the VM.
+gcloud secrets remove-iam-policy-binding active-directory-dc1-password \
+  --project ${project} \
+  --member "serviceAccount:${dcServiceAccount}" --role roles/secretmanager.secretAccessor \
+  --all
+
+# Remove the firewall rule which allows incoming RDP connections.
+# If you need to RDP to this AD VM in the future, then you will need to create
+# a new firewall rule to allow it.
+gcloud compute firewall-rules delete allow-rdp-ingress-to-addc \
+  --project ${project} \
+  --quiet
+
+# Remove all temp files. It's okay to remove the private key for our CA because we
+# created certs that are good for 100 years, as long as you have already added the
+# public cert to the concourse-secrets secret. If we need to create a new AD VM, we
+# can also create a new CA.
+rm ad-ca.crt ad-ca.key client.crt client.csr v3ext.txt
+```

ADOPTERS.md

@@ -1,34 +0,0 @@
-# Pinniped Adopters
-
-If you're using Pinniped and want to add your organization to this
-list, [follow these directions](#adding-your-organization-to-the-list-of-adopters)!
-
-## Organizations using Pinniped
-
-<a href="https://tanzu.vmware.com/tanzu" border="0" target="_blank"><img alt="vmware-tanzu" src="site/themes/pinniped/static/img/vmware-tanzu.svg" height="50"></a>
-
-<a href="https://kubeapps.com/" border="0" target="_blank"><img alt="kubeapps" src="site/themes/pinniped/static/img/kubeapps.svg" height="50"></a>
-
-<a href="https://www.ok.dk/" border="0" target="_blank"><img alt="ok-amba" src="site/themes/pinniped/static/img/ok-amba.svg" height="50"></a>
-
-## Solutions built with Pinniped
-
-Below is a list of solutions where Pinniped is being used as a component.
-
-**[Kubeapps](https://kubeapps.com/)**
-
-Kubeapps uses Pinniped to [enable SSO authentication](https://github.com/kubeapps/kubeapps/blob/master/docs/user/using-an-OIDC-provider-with-pinniped.md) when running on clusters where SSO cannot be configured for the cluster API server.
-
-**[VMware Tanzu Kubernetes Grid (TKG)](https://tanzu.vmware.com/kubernetes-grid)**
-
-TKG uses Pinniped to provide a seamless SSO experience across management and workload clusters.
-
-**[VMware Tanzu Mission Control (TMC)](https://tanzu.vmware.com/mission-control)**
-
-TMC uses Pinniped to provide a uniform authentication experience across all attached clusters.
-
-## Adding your organization to the list of adopters
-
-If you are using Pinniped and would like to be included in the list of Pinniped Adopters, add an SVG version of your logo that is less than 150 KB to
-the [img directory](https://github.com/vmware-tanzu/pinniped/tree/main/site/themes/pinniped/static/img) in this repo and submit a pull request with your change including 1-2 sentences describing how your organization is using Pinniped. Name the image file something that
-reflects your company (e.g., if your company is called Acme, name the image acme.svg). Please feel free to send us a message in [#pinniped](https://kubernetes.slack.com/archives/C01BW364RJA) with any questions you may have.

CODE_OF_CONDUCT.md

@@ -1,84 +1 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at [oss-coc@vmware.com](mailto:oss-coc@vmware.com). All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
-available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.
+Please see https://github.com/vmware/pinniped/blob/main/CODE_OF_CONDUCT.md

CONTRIBUTING.md

@@ -1,154 +1 @@
-# Contributing to Pinniped
-
-Contributions to Pinniped are welcome. Here are some things to help you get started.
-
-## Code of Conduct
-
-Please see the [Code of Conduct](./CODE_OF_CONDUCT.md).
-
-## Project Scope
-
-See [SCOPE.md](./SCOPE.md) for some guidelines about what we consider in and out of scope for Pinniped.
-
-## Community Meetings
-
-Pinniped is better because of our contributors and maintainers. It is because of you that we can bring great software to the community. Please join us during our online community meetings, occuring every first and third Thursday of the month at 9AM PT / 12PM ET. Use [this Zoom Link](https://vmware.zoom.us/j/93798188973?pwd=T3pIMWxReEQvcWljNm1admRoZTFSZz09) to attend and add any agenda items you wish to discuss to [the notes document](https://hackmd.io/rd_kVJhjQfOvfAWzK8A3tQ?view). Join our [Google Group](https://groups.google.com/u/1/g/project-pinniped) to receive invites to this meeting.
-
-If the meeting day falls on a US holiday, please consider that occurrence of the meeting to be canceled.
-
-## Discussion
-
-Got a question, comment, or idea? Please don't hesitate to reach out via the GitHub [Discussions](https://github.com/vmware-tanzu/pinniped/discussions) tab at the top of this page or reach out in Kubernetes Slack Workspace within the [#pinniped channel](https://kubernetes.slack.com/archives/C01BW364RJA).
-
-## Issues
-
-Need an idea for a project to get started contributing? Take a look at the open
-[issues](https://github.com/vmware-tanzu/pinniped/issues).
-Also check to see if any open issues are labeled with
-["good first issue"](https://github.com/vmware-tanzu/pinniped/labels/good%20first%20issue)
-or ["help wanted"](https://github.com/vmware-tanzu/pinniped/labels/help%20wanted).
-
-### Bugs
-
-To file a bug report, please first open an
-[issue](https://github.com/vmware-tanzu/pinniped/issues/new?template=bug_report.md). The project team
-will work with you on your bug report.
-
-Once the bug has been validated, a [pull request](https://github.com/vmware-tanzu/pinniped/compare)
-can be opened to fix the bug.
-
-For specifics on what to include in your bug report, please follow the
-guidelines in the issue and pull request templates.
-
-### Features
-
-To suggest a feature, please first open an
-[issue](https://github.com/vmware-tanzu/pinniped/issues/new?template=feature-proposal.md)
-and tag it with `proposal`, or create a new [Discussion](https://github.com/vmware-tanzu/pinniped/discussions).
-The project team will work with you on your feature request.
-
-Once the feature request has been validated, a [pull request](https://github.com/vmware-tanzu/pinniped/compare)
-can be opened to implement the feature.
-
-For specifics on what to include in your feature request, please follow the
-guidelines in the issue and pull request templates.
-
-## CLA
-
-We welcome contributions from everyone but we can only accept them if you sign
-our Contributor License Agreement (CLA). If you would like to contribute and you
-have not signed it, our CLA-bot will walk you through the process when you open
-a Pull Request. For questions about the CLA process, see the
-[FAQ](https://cla.vmware.com/faq) or submit a question through the GitHub issue
-tracker.
-
-## Building
-
-The [Dockerfile](Dockerfile) at the root of the repo can be used to build and
-package the code. After making a change to the code, rebuild the docker image with the following command.
-
-```bash
-# From the root directory of the repo...
-docker build .
-```
-
-## Testing
-
-### Running Lint
-
-```bash
-./hack/module.sh lint
-```
-
-### Running Unit Tests
-
-```bash
-./hack/module.sh units
-```
-
-### Running Integration Tests
-
-1. Install dependencies:
-
-   - [`chromedriver`](https://chromedriver.chromium.org/) (and [Chrome](https://www.google.com/chrome/))
-   - [`docker`](https://www.docker.com/)
-   - `htpasswd` (installed by default on MacOS, usually found in `apache2-utils` package for linux)
-   - [`kapp`](https://carvel.dev/#getting-started)
-   - [`kind`](https://kind.sigs.k8s.io/docs/user/quick-start)
-   - [`kubectl`](https://kubernetes.io/docs/tasks/tools/install-kubectl/)
-   - [`ytt`](https://carvel.dev/#getting-started)
-
-   On macOS, these tools can be installed with [Homebrew](https://brew.sh/) (assuming you have Chrome installed already):
-
-   ```bash
-   brew install kind k14s/tap/ytt k14s/tap/kapp kubectl chromedriver && brew cask install docker
-   ```
-
-1. Create a kind cluster, compile, create container images, and install Pinniped and supporting dependencies using:
-
-   ```bash
-   ./hack/prepare-for-integration-tests.sh
-   ```
-
-1. Run the Pinniped integration tests:
-
-   ```bash
-   source /tmp/integration-test-env && go test -v -count 1 -timeout 0 ./test/integration
-   ```
-
-1. After making production code changes, recompile, redeploy, and run tests again by repeating the same
-   commands described above. If there are only test code changes, then simply run the tests again.
-
-To destroy the local Kubernetes cluster, run `./hack/kind-down.sh`.
-
-### Observing Tests on the Continuous Integration Environment
-
-[CI](https://hush-house.pivotal.io/teams/tanzu-user-auth/pipelines/pinniped-pull-requests)
-will not be triggered on a pull request until the pull request is reviewed and
-approved for CI by a project [maintainer](MAINTAINERS.md). Once CI is triggered,
-the progress and results will appear on the Github page for that
-[pull request](https://github.com/vmware-tanzu/pinniped/pulls) as checks. Links
-will appear to view the details of each check.
-
-## Documentation
-
-Any pull request which adds a new feature or changes the behavior of any feature which was previously documented
-should include updates to the documentation. All documentation lives in this repository. This project aspires to
-follow the Kubernetes [documentation style guide](https://kubernetes.io/docs/contribute/style/style-guide).
-
-## Pre-commit Hooks
-
-This project uses [pre-commit](https://pre-commit.com/) to agree on some conventions about whitespace/file encoding.
-
-```bash
-$ brew install pre-commit
-[...]
-$ pre-commit install
-pre-commit installed at .git/hooks/pre-commit
-```
-
-## Becoming a Pinniped Maintainer
-
-Regular contributors who are active in the Pinniped community and who have contributed at least several
-significant pull requests may be considered for promotion to become a maintainer upon request. Please
-contact an existing [maintainer](MAINTAINERS.md) if you would like to be considered.
+Please see https://github.com/vmware/pinniped/blob/main/CONTRIBUTING.md

Dockerfile

@@ -1,47 +0,0 @@
-# syntax = docker/dockerfile:1.0-experimental
-
-# Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-FROM golang:1.16.5 as build-env
-
-WORKDIR /work
-COPY . .
-ARG GOPROXY
-
-# Build the executable binary (CGO_ENABLED=0 means static linking)
-# Pass in GOCACHE (build cache) and GOMODCACHE (module cache) so they
-# can be re-used between image builds.
-RUN \
-  --mount=type=cache,target=/cache/gocache \
-  --mount=type=cache,target=/cache/gomodcache \
-  mkdir out && \
-  GOCACHE=/cache/gocache \
-  GOMODCACHE=/cache/gomodcache \
-  CGO_ENABLED=0 \
-  GOOS=linux \
-  GOARCH=amd64 \
-  go build -v -ldflags "$(hack/get-ldflags.sh)" -o out \
-    ./cmd/pinniped-concierge/... \
-    ./cmd/pinniped-supervisor/... \
-    ./cmd/local-user-authenticator/...
-
-# Use a Debian slim image to grab a reasonable default CA bundle.
-FROM debian:10.9-slim AS get-ca-bundle-env
-RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && rm -rf /var/lib/apt/lists/* /var/cache/debconf/*
-
-# Use a runtime image based on Debian slim.
-FROM debian:10.9-slim
-COPY --from=get-ca-bundle-env /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
-
-# Copy the binaries from the build-env stage.
-COPY --from=build-env /work/out/ /usr/local/bin/
-
-# Document the ports
-EXPOSE 8080 8443
-
-# Run as non-root for security posture
-USER 1001:1001
-
-# Set the entrypoint
-ENTRYPOINT ["/usr/local/bin/pinniped-concierge"]

MAINTAINERS.md

@@ -1,19 +1 @@
-# Pinniped Maintainers
-
-This is the current list of maintainers for the Pinniped project.
-
-| Maintainer | GitHub ID | Affiliation |
-| --------------- | --------- | ----------- |
-| Andrew Keesler | [ankeesler](https://github.com/ankeesler) | [VMware](https://www.github.com/vmware/) |
-| Margo Crawford | [margocrawf](https://github.com/margocrawf) | [VMware](https://www.github.com/vmware/) |
-| Matt Moyer | [mattmoyer](https://github.com/mattmoyer) | [VMware](https://www.github.com/vmware/) |
-| Mo Khan | [enj](https://github.com/enj) | [VMware](https://www.github.com/vmware/) |
-| Pablo Schuhmacher | [pabloschuhmacher](https://github.com/pabloschuhmacher) | [VMware](https://www.github.com/vmware/) |
-| Ryan Richard | [cfryanr](https://github.com/cfryanr) | [VMware](https://www.github.com/vmware/) |
-
-## Pinniped Contributors & Stakeholders
-
-| Feature Area | Lead |
-| ----------------------------- | :---------------------: |
-| Technical Lead | Matt Moyer (mattmoyer) |
-| Product Management | Pablo Schuhmacher (pabloschuhmacher) |
+Please see https://github.com/vmware/pinniped/blob/main/MAINTAINERS.md

README.md

@@ -1,70 +1,219 @@
-<img src="site/content/docs/img/pinniped_logo.svg" alt="Pinniped Logo" width="100%"/>
+# Pinniped's `ci` branch
 
-## Overview
+This `ci` branch contains the CI/CD tooling for [Pinniped](https://github.com/vmware/pinniped).
 
-Pinniped provides identity services to Kubernetes.
+The documentation and code in this branch is mainly intended for the maintainers of Pinniped.
 
-Pinniped allows cluster administrators to easily plug in external identity
-providers (IDPs) into Kubernetes clusters. This is achieved via a uniform
-install procedure across all types and origins of Kubernetes clusters,
-declarative configuration via Kubernetes APIs, enterprise-grade integrations
-with IDPs, and distribution-specific integration strategies.
+This branch is not intended to be merged to the `main` branch.
 
-### Example use cases
+The code in the branch previously lived in a private repository. It was made public by moving
+the code into the `ci` branch of the Pinniped repository in late 2024. The previous git history
+for these files was not copied from the private repository at the time of this migration.
 
-* Your team uses a large enterprise IDP, and has many clusters that they
-  manage. Pinniped provides:
-  * Seamless and robust integration with the IDP
-  * Easy installation across clusters of any type and origin
-  * A simplified login flow across all clusters
-* Your team shares a single cluster. Pinniped provides:
-  * Simple configuration to integrate an IDP
-  * Individual, revocable identities
+## Reporting an issue in this branch
 
-### Architecture
-
-The Pinniped Supervisor component offers identity federation to enable a user to
-access multiple clusters with a single daily login to their external IDP. The
-Pinniped Supervisor supports various external [IDP
-types](https://github.com/vmware-tanzu/pinniped/tree/main/generated/1.20#k8s-api-idp-supervisor-pinniped-dev-v1alpha1).
-
-The Pinniped Concierge component offers credential exchange to enable a user to
-exchange an external credential for a short-lived, cluster-specific
-credential. Pinniped supports various [authentication
-methods](https://github.com/vmware-tanzu/pinniped/tree/main/generated/1.20#authenticationconciergepinnipeddevv1alpha1)
-and implements different integration strategies for various Kubernetes
-distributions to make authentication possible.
-
-The Pinniped Concierge can be configured to hook into the Pinniped Supervisor's
-federated credentials, or it can authenticate users directly via external IDP
-credentials.
-
-To learn more, see [architecture](https://pinniped.dev/docs/background/architecture/).
-
-## Getting started with Pinniped
-
-Care to kick the tires? It's easy to [install and try Pinniped](https://pinniped.dev/docs/).
-
-## Community meetings
-
-Pinniped is better because of our contributors and maintainers. It is because of you that we can bring great software to the community. Please join us during our online community meetings, occurring every first and third Thursday of the month at 9 AM PT / 12 PM PT. Use [this Zoom Link](https://vmware.zoom.us/j/93798188973?pwd=T3pIMWxReEQvcWljNm1admRoZTFSZz09) to attend and add any agenda items you wish to discuss to [the notes document](https://hackmd.io/rd_kVJhjQfOvfAWzK8A3tQ?view). Join our [Google Group](https://groups.google.com/g/project-pinniped) to receive invites to this meeting.
-
-If the meeting day falls on a US holiday, please consider that occurrence of the meeting to be canceled.
-
-## Discussion
-
-Got a question, comment, or idea? Please don't hesitate to reach out via the GitHub [Discussions](https://github.com/vmware-tanzu/pinniped/discussions) tab at the top of this page or reach out in Kubernetes Slack Workspace within the [#pinniped channel](https://kubernetes.slack.com/archives/C01BW364RJA).
-
-## Contributions
-
-Contributions are welcome. Before contributing, please see the [contributing guide](CONTRIBUTING.md).
+Found a bug or would like to make an enhancement request?
+Please report issues in [this repo](https://github.com/vmware/pinniped).
 
 ## Reporting security vulnerabilities
 
-Please follow the procedure described in [SECURITY.md](SECURITY.md).
+Please follow the procedure described in [SECURITY.md](https://github.com/vmware/pinniped/blob/main/SECURITY.md).
+
+## Creating a release
+
+When the team is preparing to ship a release, a maintainer will create a new
+GitHub [Issue](https://github.com/vmware/pinniped/issues/new/choose) in this repo to
+collaboratively track progress on the release checklist. As tasks are completed,
+the team will check them off. When all the tasks are completed, the issue is closed.
+
+The release checklist is committed to this repo as an [issue template](https://github.com/vmware/pinniped/tree/main/.github/ISSUE_TEMPLATE/release_checklist.md).
+
+## Pipelines
+
+Pinniped uses [Concourse](https://concourse-ci.org) for CI/CD.
+We are currently running our Concourse on a network that can only be reached from inside the corporate network at [ci.pinniped.broadcom.net](https://ci.pinniped.broadcom.net).
+
+The following pipelines are implemented in this branch. Not all pipelines are necessarily publicly visible, although our goal is to make them all visible.
+
+- `main`
+
+  This is the main pipeline that runs on merges to `main`. It builds, tests, and (when manually triggered) releases from main.
+
+- `pull-requests`
+
+  This is a pipeline that triggers for each open pull request. It runs a smaller subset of the integration tests and validations as `pinniped`.
+
+- `dockerfile-builders`
+
+  This pipeline builds a bunch of custom utility container images that are used in our CI and testing.
+
+  - `build-gi-cli` (a container image that includes the GitHub CLI)
+  - `build-github-pr-resource` (a [fork](https://github.com/pinniped-ci-bot/github-pr-resource) of the `github-pr-resource` with support for gating PRs for untrusted users)
+  - `build-code-coverage-uploader` (uploading code coverage during unit tests)
+  - `build-eks-deployer-dockerfile` (deploying our app to EKS clusters)
+  - `build-k8s-app-deployer-dockerfile` (deploying our app to clusters)
+  - `build-pool-trigger-resource-dockerfile` (an updated implementation of the [pool-trigger-resource](https://github.com/cfmobile/pool-trigger-resource) for use in our CI)
+  - `build-integration-test-runner-dockerfile` (running our integration tests)
+  - `build-integration-test-runner-beta-dockerfile` (running our integration tests with the latest Chrome beta version)
+  - `build-deployment-yaml-formatter-dockerfile` (templating our deployment YAML during a release)
+  - `build-crane` (copy and tag container images during release)
+  - `build-k8s-code-generator-*` (running our Kubernetes code generation under different Kubernetes dependency versions)
+  - `build-test-dex` (a Dex used during tests)
+  - `build-test-cfssl` (a cfssl used during tests)
+  - `build-test-kubectl` (a kubectl used during tests)
+  - `build-test-forward-proxy` (a Squid forward proxy used during tests)
+  - `build-test-bitnami-ldap` (an OpenLDAP used during tests)
+
+- `cleanup-aws`
+
+  This runs a script that runs [aws-nuke](https://github.com/rebuy-de/aws-nuke) against our test AWS account.
+  This was occasionally needed because [eksctl](https://eksctl.io/) sometimes fails and leaks AWS resources. These resources cost money and use up our AWS quota.
+  However, we seem to have worked around these issues and this pipeline has not been used for some time.
+
+  These jobs are only triggered manually. This is dangerous and should be used with care.
+
+- `concourse-workers`
+
+  Deploys worker replicas on a long-lived GKE cluster that runs the Concourse workers, and can scale them up or down.
+
+- `go-compatibility`
+
+  This pipeline runs nightly jobs that validate the compatibility of our code as a Go module in various contexts. We have jobs that test that our code compiles under older Go versions and that our CLI can be installed using `go install`.
+
+- `security-scan`
+
+  This pipeline has nightly jobs that run security scans on our current main branch and most recently released artifacts.
+
+  The tools we use are:
+  - [sonatype-nexus-community/nancy](https://github.com/sonatype-nexus-community/nancy), which scans Go module versions.
+  - [aquasecurity/trivy](https://github.com/aquasecurity/trivy), which scans container images and Go binaries.
+  - [govulncheck](https://pkg.go.dev/golang.org/x/vuln/cmd/govulncheck), which scans Go code to find calls to known-vulnerable dependencies.
+
+  This pipeline also has a job called `all-golang-deps-updated` which automatically submits PRs to update all
+  direct dependencies in Pinniped's go.mod file, and update the Golang and distroless container images used in
+  Pinniped's Dockerfiles.
+
+- `kind-node-builder`
+
+  A nightly build job which uses the latest version of kind to build the HEAD of master of Kubernetes as a container
+  image that can be used to deploy kind clusters. Other pipelines use this container image to install Pinniped and run
+  integration tests. This gives us insight in any compatibility problems with the upcoming next release of Kubernetes.
+
+## Deploying pipeline changes
+
+After any shared tasks (`./pipelines/shared-tasks`) or helpers (`./pipelines/shared-helpers`) are edited,
+the commits must be pushed to the `ci` branch of this repository to take effect.
+
+After editing any CI secrets or pipeline definitions, a maintainer must run the corresponding
+`./pipelines/$PIPELINE_NAME/update-pipeline.sh` script to apply the changes to Concourse.
+To deploy _all_ pipelines, a maintainer can run `./pipelines/update-all-pipelines.sh`.
+Don't forget to commit and push your changes after applying them!
+
+## Github webhooks for pipelines
+
+Some pipelines use github [webhooks to trigger resource checks](https://concourse-ci.org/resources.html#schema.resource.webhook_token),
+rather than the default of polling every minute, to make these pipelines more responsive and use fewer compute resources
+for running checks. Refer to places where `webhook_token` is configured in various `pipeline.yml` files.
+
+To make these webhooks work, they must be defined on the [GitHub repo's settings](https://github.com/vmware/pinniped/settings/hooks).
+
+## Installing and operating Concourse
+
+See [infra/README.md](./infra/README.md) for details about how Concourse was installed and how it can be operated.
+
+## Acceptance environments
+
+In addition to the many ephemeral Kubernetes clusters we use for testing, we also deploy a long-running acceptance environment.
+
+Google Kubernetes Engine (GKE) in the `gke-acceptance-cluster` cluster in our GCP project in the `us-west1-c` availability zone.
+
+To access this cluster, download the kubeconfig to `gke-acceptance.yaml` by running:
+
+```cmd
+KUBECONFIG=gke-acceptance.yaml gcloud container clusters get-credentials gke-acceptance-cluster --project "$PINNIPED_GCP_PROJECT" --zone us-west1-c
+```
+
+The above command assumes that you have already set `PINNIPED_GCP_PROJECT` to be the name of the GCP project.
+
+## CI secrets
+
+We use [Google Secret Manager](https://cloud.google.com/secret-manager) on GCP to store build/test/release secrets.
+These secrets are only available to the maintainers.
+
+Using the `gcloud secrets list` command or the [web console](https://console.cloud.google.com/security/secret-manager),
+you can list the available secrets. The content of each secret is a YAML file with secret key/value pairs.
+You can also use the `./hack/edit-gcloud-secret.sh <secretName>` script to edit or inspect each secret.
+
+## Configure Azure for CI to test on AKS
+
+There are several CI jobs which test that Pinniped works when installed on Azure's AKS.
+For these jobs to run, they need to be able to create and delete ephemeral AKS clusters.
+This requires the following:
+
+1. An active Azure Subscription. (A "subscription" in Azure is the equivalent of an "account" in AWS or a "project" in GCP.)
+2. An Azure App Registration (basically, a service account) active in the same Directory (aka tenant) as the Subscription.
+   Create the app in "My Organization Only". It does not need a redirect URI or any other optional settings.
+   Create a client secret for this app. If you want the client secret to have a long lifetime, you can use the `az` CLI to create it.
+   In the Subscription's IAM settings, assign this app the role "Azure Kubernetes Service Contributor Role" to allow
+   the app to manage AKS clusters. Also assign this app the role "Reader" to allow it to read all resources
+   (used by the `remove-orphaned-aks-clusters` CI task).
+   Do not grant this app permissions in any other Subscription or use it for any other purpose.
+3. Configure the pipelines with the app's Application (client) ID, Client Secret, and Directory (tenant) ID
+   as the appropriate secret values.
+
+The CI jobs will create and delete AKS clusters in a Resource Group called `pinniped-ci` within the provided Subscription.
+
+## Configure AWS for CI to test on EKS
+
+There are several CI jobs which test that Pinniped works when installed on Amazon's EKS.
+For these jobs to run, they need to be able to create and delete ephemeral EKS clusters.
+There are also some jobs to cleanup any orphaned resources (e.g. IP addresses) in the AWS account.
+These jobs requires the following:
+
+1. An active AWS account, which will only be used for this purpose.
+2. Two IAM users in that account, each with a role that can be assumed.
+   These IAM users which should only be used for Pinniped CI and no other purpose.
+   They should only have permissions to perform AWS actions in the relevant AWS account, and no other account.
+3. The first user and role should have permission to create and delete EKS clusters using `eksctl`.
+   The permissions required can be found in the [eksctl docs](https://eksctl.io/usage/minimum-iam-policies).
+   The user also needs permission to run `aws logs put-retention-policy`, `aws ec2 describe-nat-gateways`,
+   and `aws ec2 delete-nat-gateway`.
+4. The second user and role should have broad permissions to get and delete everything in the account.
+   It will be used to run `aws-nuke` to list and/or clean resources from the AWS account.
+   To use `aws-nuke`, the user also needs to have an AWS account alias
+   (see the [cleanup-aws task](pipelines/shared-tasks/cleanup-aws/task.sh) for details).
+
+## Setting Up Active Directory Test Environment
+
+To test the `ActiveDirectoryIdentityProvider` functionality, we have a long-running Active Directory Domain Controller
+server instance in our GCP account. See [AD-SETUP.md](AD-SETUP.md) for details.
+
+## Running integration tests on your laptop using AD
+
+The relevant environment variables can be pulled from the secret manager via the `hack/get-active-directory-env-vars.sh` script.
+This can be used by maintainers with Pinniped's `/hack/prepare-for-integration-tests.sh` script in the following way:
+
+ ```bash
+ # Must authenticate to glcoud to access the secret manager.
+ gcloud auth login
+ # In the pinniped repo's main branch or in your PR branch:
+ hack/prepare-for-integration-tests.sh --get-active-directory-vars "$HOME/path/to/pinniped-ci-branch/hack/get-active-directory-env-vars.sh"
+ ```
+
+## Running integration tests on your laptop using GitHub
+
+The relevant environment variables can be pulled from the secret manager via the `hack/get-github-env-vars.sh` script.
+This can be used by maintainers with Pinniped's `/hack/prepare-for-integration-tests.sh` script in the following way:
+
+ ```bash
+ # Must authenticate to glcoud to access the secret manager.
+ gcloud auth login
+# In the pinniped repo's main branch or in your PR branch:
+ hack/prepare-for-integration-tests.sh --get-github-vars "$HOME/path/to/pinniped-ci-branch/hack/get-github-env-vars.sh"
+ ```
 
 ## License
 
 Pinniped is open source and licensed under Apache License Version 2.0. See [LICENSE](LICENSE).
 
-Copyright 2020 the Pinniped contributors. All Rights Reserved.
+Copyright 2020-2025 the Pinniped contributors. All Rights Reserved.

ROADMAP.md

@@ -1,50 +0,0 @@
-
-## **Pinniped Project Roadmap**
-
-
-### 
-**About this document**
-
-This document provides a link to the[ Pinniped Project issues](https://github.com/vmware-tanzu/pinniped/issues) list that serves as the up to date description of items that are in the Pinniped release pipeline. Most items are gathered from the community or include a feedback loop with the community. This should serve as a reference point for Pinniped users and contributors to understand where the project is heading, and help determine if a contribution could be conflicting with a longer term plan.
-
-
-### 
-**How to help?**
-
-Discussion on the roadmap can take place in threads under [Issues](https://github.com/vmware-tanzu/pinniped/issues) or in [community meetings](https://github.com/vmware-tanzu/pinniped/blob/main/CONTRIBUTING.md#meeting-with-the-maintainers). Please open and comment on an issue if you want to provide suggestions and feedback to an item in the roadmap. Please review the roadmap to avoid potential duplicated effort.
-
-
-### 
-**Need an idea for a contribution?**
-
-We’ve created an [Opportunity Areas](https://github.com/vmware-tanzu/pinniped/discussions/483) discussion thread that outlines some areas we believe are excellent starting points for the community to get involved. In that discussion we’ve included specific work items that one might consider that also support the high-level items presented in our roadmap. 
-
-
-### 
-**How to add an item to the roadmap?**
-
-Please open an issue to track any initiative on the roadmap of Pinniped (usually driven by new feature requests). We will work with and rely on our community to focus our efforts to improve Pinniped.
-
-
-### 
-**Current Roadmap**
-
-The following table includes the current roadmap for Pinniped. If you have any questions or would like to contribute to Pinniped, please attend a [community meeting](https://github.com/vmware-tanzu/pinniped/blob/main/CONTRIBUTING.md#meeting-with-the-maintainers) to discuss with our team. If you don't know where to start, we are always looking for contributors that will help us reduce technical, automation, and documentation debt. Please take the timelines & dates as proposals and goals. Priorities and requirements change based on community feedback, roadblocks encountered, community contributions, etc. If you depend on a specific item, we encourage you to attend community meetings to get updated status information, or help us deliver that feature by contributing to Pinniped.
-
-
-
-Last Updated: June 2021
-Theme|Description|Timeline|
-|--|--|--|
-|Remote OIDC login support|Add support for logging in from remote hosts without web browsers in the Pinniped CLI and Supervisor|Jun 2021|
-|AD Support|Extends upstream IDP protocols|Jun 2021|
-|Wider Concierge cluster support|Support for more cluster types in the Concierge|Jul 2021|
-|Improved Documentation|Reorganizing and improving Pinniped docs; new how-to guides and tutorials|Exploring/Ongoing|
-|Improving Security Posture|Offer the best security posture for Kubernetes cluster authentication|Exploring/Ongoing|
-|Improve our CI/CD systems|Upgrade tests; make Kind more efficient and reliable for CI ; Windows tests; performance tests; scale tests; soak tests|Exploring/Ongoing|
-|CLI Improvements|Improving CLI UX for setting up Supervisor IDPs|Exploring/Ongoing|
-|Telemetry|Adding some useful phone home metrics as well as some vanity metrics|Exploring/Ongoing|
-|Observability|Expose Pinniped metrics through Prometheus Integration|Exploring/Ongoing|
-|Device Code Flow|Add support for OAuth 2.0 Device Authorization Grant in the Pinniped CLI and Supervisor|Exploring/Ongoing|
-
-   

SCOPE.md

@@ -1,32 +0,0 @@
-# Project Scope
-
-The Pinniped project is guided by the following principles.
-
-- Pinniped lets you plug any external identity providers into Kubernetes.
-  These integrations follow enterprise-grade security principles.
-- Pinniped is easy to install and use on any Kubernetes cluster via distribution-specific integration mechanisms.
-- Pinniped uses a declarative configuration via Kubernetes APIs.
-- Pinniped provides optimal user experience when authenticating to many clusters at one time.
-- Pinniped provides enterprise-grade security posture via secure defaults and revocable or very short-lived credentials.
-- Where possible, Pinniped will contribute ideas and code to upstream Kubernetes.
-
-When contributing to Pinniped, please consider whether your contribution follows
-these guiding principles.
-
-## Out Of Scope
-
-The following items are out of scope for the Pinniped project.
-
-- Authorization.
-- Standalone identity provider for general use.
-- Machine-to-machine (service) identity.
-- Running outside of Kubernetes.
-
-## Roadmap
-
-See our [open milestones][milestones] and the [`priority/backlog` label][backlog] for an idea about what's next on our roadmap.
-
-For more details on proposing features and bugs, check out our [contributing](./CONTRIBUTING.md) doc.
-
-[milestones]: https://github.com/vmware-tanzu/pinniped/milestones
-[backlog]: https://github.com/vmware-tanzu/pinniped/labels/priority%2Fbacklog

SECURITY.md

@@ -1,92 +1 @@
-# Security Release Process
-
-Pinniped provides identity services for Kubernetes clusters. The community has adopted this security disclosure and response policy to ensure we responsibly handle critical issues.
-
-## Supported Versions
-
-As of right now, only the latest version of Pinniped is supported.
-
-## Reporting a Vulnerability - Private Disclosure Process
-
-Security is of the highest importance and all security vulnerabilities or suspected security vulnerabilities should be reported to Pinniped privately, to minimize attacks against current users of Pinniped before they are fixed. Vulnerabilities will be investigated and patched on the next patch (or minor) release as soon as possible. This information could be kept entirely internal to the project.
-
-If you know of a publicly disclosed security vulnerability for Pinniped, please **IMMEDIATELY** contact the VMware Security Team (security@vmware.com). The use of encrypted email is encouraged. The public PGP key can be found at https://kb.vmware.com/kb/1055.
-
-**IMPORTANT: Do not file public issues on GitHub for security vulnerabilities**
-
-To report a vulnerability or a security-related issue, please contact the VMware email address with the details of the vulnerability. The email will be fielded by the VMware Security Team and then shared with the Pinniped maintainers who have committer and release permissions. Emails will be addressed within 3 business days, including a detailed plan to investigate the issue and any potential workarounds to perform in the meantime. Do not report non-security-impacting bugs through this channel. Use [GitHub issues](https://github.com/vmware-tanzu/pinniped/issues/new/choose) instead.
-
-## Proposed Email Content
-
-Provide a descriptive subject line and in the body of the email include the following information:
-
-*   Basic identity information, such as your name and your affiliation or company.
-*   Detailed steps to reproduce the vulnerability  (POC scripts, screenshots, and logs are all helpful to us).
-*   Description of the effects of the vulnerability on Pinniped and the related hardware and software configurations, so that the VMware Security Team can reproduce it.
-*   How the vulnerability affects Pinniped usage and an estimation of the attack surface, if there is one.
-*   List other projects or dependencies that were used in conjunction with Pinniped to produce the vulnerability.
-
-## When to report a vulnerability
-
-*   When you think Pinniped has a potential security vulnerability.
-*   When you suspect a potential vulnerability but you are unsure that it impacts Pinniped.
-*   When you know of or suspect a potential vulnerability on another project that is used by Pinniped.
-
-## Patch, Release, and Disclosure
-
-The VMware Security Team will respond to vulnerability reports as follows:
-
-1. The Security Team will investigate the vulnerability and determine its effects and criticality.
-2. If the issue is not deemed to be a vulnerability, the Security Team will follow up with a detailed reason for rejection.
-3. The Security Team will initiate a conversation with the reporter within 3 business days.
-4. If a vulnerability is acknowledged and the timeline for a fix is determined, the Security Team will work on a plan to communicate with the appropriate community, including identifying mitigating steps that affected users can take to protect themselves until the fix is rolled out.
-5. The Security Team will also create a [CVSS](https://www.first.org/cvss/specification-document) using the [CVSS Calculator](https://www.first.org/cvss/calculator/3.0). The Security Team makes the final call on the calculated CVSS; it is better to move quickly than making the CVSS perfect. Issues may also be reported to [Mitre](https://cve.mitre.org/) using this [scoring calculator](https://nvd.nist.gov/vuln-metrics/cvss/v3-calculator). The CVE will initially be set to private.
-6. The Security Team will work on fixing the vulnerability and perform internal testing before preparing to roll out the fix.
-7. The Security Team will provide early disclosure of the vulnerability by emailing the [Pinniped Distributors](https://groups.google.com/g/project-pinniped-distributors) mailing list. Distributors can initially plan for the vulnerability patch ahead of the fix, and later can test the fix and provide feedback to the Pinniped team. See the section **Early Disclosure to Pinniped Distributors List** for details about how to join this mailing list.
-8. A public disclosure date is negotiated by the VMware SecurityTeam, the bug submitter, and the distributors list. We prefer to fully disclose the bug as soon as possible once a user mitigation or patch is available. It is reasonable to delay disclosure when the bug or the fix is not yet fully understood, the solution is not well-tested, or for distributor coordination. The timeframe for disclosure is from immediate (especially if it’s already publicly known) to a few weeks. For a critical vulnerability with a straightforward mitigation, we expect the report date for the public disclosure date to be on the order of 14 business days. The VMware Security Team holds the final say when setting a public disclosure date.
-9. Once the fix is confirmed, the Security Team will patch the vulnerability in the next patch or minor release, and backport a patch release into all earlier supported releases. Upon release of the patched version of Pinniped, we will follow the **Public Disclosure Process**.
-
-## Public Disclosure Process
-
-The Security Team publishes a [public advisory](https://github.com/vmware-tanzu/pinniped/security/advisories) to the Pinniped community via GitHub. In most cases, additional communication via Slack, Twitter, mailing lists, blog and other channels will assist in educating Pinniped users and rolling out the patched release to affected users.
-
-The Security Team will also publish any mitigating steps users can take until the fix can be applied to their Pinniped instances. Pinniped distributors will handle creating and publishing their own security advisories.
-
-## Mailing lists
-
-*   Use security@vmware.com to report security concerns to the VMware Security Team, who uses the list to privately discuss security issues and fixes prior to disclosure. The use of encrypted email is encouraged. The public PGP key can be found at https://kb.vmware.com/kb/1055.
-*   Join the [Pinniped Distributors](https://groups.google.com/g/project-pinniped-distributors) mailing list for early private information and vulnerability disclosure. Early disclosure may include mitigating steps and additional information on security patch releases. See below for information on how Pinniped distributors or vendors can apply to join this list.
-
-## Early Disclosure to Pinniped Distributors List
-
-The private list is intended to be used primarily to provide actionable information to multiple distributor projects at once. This list is not intended to inform individuals about security issues.
-
-## Membership Criteria
-
-To be eligible to join the [Pinniped Distributors](https://groups.google.com/g/project-pinniped-distributors) mailing list, you should:
-
-1. Be an active distributor of Pinniped.
-2. Have a user base that is not limited to your own organization.
-3. Have a publicly verifiable track record up to the present day of fixing security issues.
-4. Not be a downstream or rebuild of another distributor.
-5. Be a participant and active contributor in the Pinniped community.
-6. Accept the Embargo Policy that is outlined below.
-7. Have someone who is already on the list vouch for the person requesting membership on behalf of your distribution.
-
-**The terms and conditions of the Embargo Policy apply to all members of this mailing list. A request for membership represents your acceptance to the terms and conditions of the Embargo Policy.**
-
-## Embargo Policy
-
-The information that members receive on the Pinniped Distributors mailing list must not be made public, shared, or even hinted at anywhere beyond those who need to know within your specific team, unless you receive explicit approval to do so from the VMware Security Team. This remains true until the public disclosure date/time agreed upon by the list. Members of the list and others cannot use the information for any reason other than to get the issue fixed for your respective distribution's users.
-
-Before you share any information from the list with members of your team who are required to fix the issue, these team members must agree to the same terms, and only be provided with information on a need-to-know basis.
-
-In the unfortunate event that you share information beyond what is permitted by this policy, you must urgently inform the VMware Security Team (security@vmware.com) of exactly what information was leaked and to whom. If you continue to leak information and break the policy outlined here, you will be permanently removed from the list.
-
-## Requesting to Join
-
-Send new membership requests to https://groups.google.com/g/project-pinniped-distributors. In the body of your request please specify how you qualify for membership and fulfill each criterion listed in the Membership Criteria section above.
-
-## Confidentiality, integrity and availability
-
-We consider vulnerabilities leading to the compromise of data confidentiality, elevation of privilege, or integrity to be our highest priority concerns. Availability, in particular in areas relating to DoS and resource exhaustion, is also a serious security concern. The VMware Security Team takes all vulnerabilities, potential vulnerabilities, and suspected vulnerabilities seriously and will investigate them in an urgent and expeditious manner.
+Please see https://github.com/vmware/pinniped/blob/main/SECURITY.md

apis/README.md

@@ -1,5 +0,0 @@
-# API Generation Templates
-
-This directory contains a template for generating our Kubernetes API code across several Kubernetes versions.
-
-See the [`./generated`](../generated) directory for the rendered output.

apis/concierge/authentication/v1alpha1/doc.go.tmpl

@@ -1,10 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// +k8s:openapi-gen=true
-// +k8s:deepcopy-gen=package
-// +k8s:defaulter-gen=TypeMeta
-// +groupName=authentication.concierge.pinniped.dev
-
-// Package v1alpha1 is the v1alpha1 version of the Pinniped concierge authentication API.
-package v1alpha1

apis/concierge/authentication/v1alpha1/register.go.tmpl

@@ -1,45 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const GroupName = "authentication.concierge.pinniped.dev"
-
-// SchemeGroupVersion is group version used to register these objects.
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
-
-var (
-	SchemeBuilder      runtime.SchemeBuilder
-	localSchemeBuilder = &SchemeBuilder
-	AddToScheme        = localSchemeBuilder.AddToScheme
-)
-
-func init() {
-	// We only register manually written functions here. The registration of the
-	// generated functions takes place in the generated files. The separation
-	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addKnownTypes)
-}
-
-// Adds the list of known types to the given scheme.
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&WebhookAuthenticator{},
-		&WebhookAuthenticatorList{},
-		&JWTAuthenticator{},
-		&JWTAuthenticatorList{},
-	)
-	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
-	return nil
-}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource.
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}

apis/concierge/authentication/v1alpha1/types_jwt.go.tmpl

@@ -1,83 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-// Status of a JWT authenticator.
-type JWTAuthenticatorStatus struct {
-	// Represents the observations of the authenticator's current state.
-	// +patchMergeKey=type
-	// +patchStrategy=merge
-	// +listType=map
-	// +listMapKey=type
-	Conditions []Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
-}
-
-// Spec for configuring a JWT authenticator.
-type JWTAuthenticatorSpec struct {
-	// Issuer is the OIDC issuer URL that will be used to discover public signing keys. Issuer is
-	// also used to validate the "iss" JWT claim.
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:Pattern=`^https://`
-	Issuer string `json:"issuer"`
-
-	// Audience is the required value of the "aud" JWT claim.
-	// +kubebuilder:validation:MinLength=1
-	Audience string `json:"audience"`
-
-	// Claims allows customization of the claims that will be mapped to user identity
-	// for Kubernetes access.
-	// +optional
-	Claims JWTTokenClaims `json:"claims"`
-
-	// TLS configuration for communicating with the OIDC provider.
-	// +optional
-	TLS *TLSSpec `json:"tls,omitempty"`
-}
-
-// JWTTokenClaims allows customization of the claims that will be mapped to user identity
-// for Kubernetes access.
-type JWTTokenClaims struct {
-	// Groups is the name of the claim which should be read to extract the user's
-	// group membership from the JWT token. When not specified, it will default to "groups".
-	// +optional
-	Groups string `json:"groups"`
-
-	// Username is the name of the claim which should be read to extract the
-	// username from the JWT token. When not specified, it will default to "username".
-	// +optional
-	Username string `json:"username"`
-}
-
-// JWTAuthenticator describes the configuration of a JWT authenticator.
-//
-// Upon receiving a signed JWT, a JWTAuthenticator will performs some validation on it (e.g., valid
-// signature, existence of claims, etc.) and extract the username and groups from the token.
-//
-// +genclient
-// +genclient:nonNamespaced
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +kubebuilder:resource:categories=pinniped;pinniped-authenticator;pinniped-authenticators,scope=Cluster
-// +kubebuilder:printcolumn:name="Issuer",type=string,JSONPath=`.spec.issuer`
-// +kubebuilder:subresource:status
-type JWTAuthenticator struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	// Spec for configuring the authenticator.
-	Spec JWTAuthenticatorSpec `json:"spec"`
-
-	// Status of the authenticator.
-	Status JWTAuthenticatorStatus `json:"status,omitempty"`
-}
-
-// List of JWTAuthenticator objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type JWTAuthenticatorList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-
-	Items []JWTAuthenticator `json:"items"`
-}

apis/concierge/authentication/v1alpha1/types_meta.go.tmpl

@@ -1,75 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-// ConditionStatus is effectively an enum type for Condition.Status.
-type ConditionStatus string
-
-// These are valid condition statuses. "ConditionTrue" means a resource is in the condition.
-// "ConditionFalse" means a resource is not in the condition. "ConditionUnknown" means kubernetes
-// can't decide if a resource is in the condition or not. In the future, we could add other
-// intermediate conditions, e.g. ConditionDegraded.
-const (
-	ConditionTrue    ConditionStatus = "True"
-	ConditionFalse   ConditionStatus = "False"
-	ConditionUnknown ConditionStatus = "Unknown"
-)
-
-// Condition status of a resource (mirrored from the metav1.Condition type added in Kubernetes 1.19). In a future API
-// version we can switch to using the upstream type.
-// See https://github.com/kubernetes/apimachinery/blob/v0.19.0/pkg/apis/meta/v1/types.go#L1353-L1413.
-type Condition struct {
-	// 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)
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation: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])$`
-	// +kubebuilder:validation:MaxLength=316
-	Type string `json:"type"`
-
-	// status of the condition, one of True, False, Unknown.
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation:Enum=True;False;Unknown
-	Status ConditionStatus `json:"status"`
-
-	// 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.
-	// +optional
-	// +kubebuilder:validation:Minimum=0
-	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
-
-	// 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.
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation:Type=string
-	// +kubebuilder:validation:Format=date-time
-	LastTransitionTime metav1.Time `json:"lastTransitionTime"`
-
-	// 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.
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation:MaxLength=1024
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:Pattern=`^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$`
-	Reason string `json:"reason"`
-
-	// message is a human readable message indicating details about the transition.
-	// This may be an empty string.
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation:MaxLength=32768
-	Message string `json:"message"`
-}

apis/concierge/authentication/v1alpha1/types_tls.go.tmpl

@@ -1,11 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-// Configuration for configuring TLS on various authenticators.
-type TLSSpec struct {
-	// X.509 Certificate Authority (base64-encoded PEM bundle). If omitted, a default set of system roots will be trusted.
-	// +optional
-	CertificateAuthorityData string `json:"certificateAuthorityData,omitempty"`
-}

apis/concierge/authentication/v1alpha1/types_webhook.go.tmpl

@@ -1,55 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-// Status of a webhook authenticator.
-type WebhookAuthenticatorStatus struct {
-	// Represents the observations of the authenticator's current state.
-	// +patchMergeKey=type
-	// +patchStrategy=merge
-	// +listType=map
-	// +listMapKey=type
-	Conditions []Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
-}
-
-// Spec for configuring a webhook authenticator.
-type WebhookAuthenticatorSpec struct {
-	// Webhook server endpoint URL.
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:Pattern=`^https://`
-	Endpoint string `json:"endpoint"`
-
-	// TLS configuration.
-	// +optional
-	TLS *TLSSpec `json:"tls,omitempty"`
-}
-
-// WebhookAuthenticator describes the configuration of a webhook authenticator.
-// +genclient
-// +genclient:nonNamespaced
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +kubebuilder:resource:categories=pinniped;pinniped-authenticator;pinniped-authenticators,scope=Cluster
-// +kubebuilder:printcolumn:name="Endpoint",type=string,JSONPath=`.spec.endpoint`
-// +kubebuilder:subresource:status
-type WebhookAuthenticator struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	// Spec for configuring the authenticator.
-	Spec WebhookAuthenticatorSpec `json:"spec"`
-
-	// Status of the authenticator.
-	Status WebhookAuthenticatorStatus `json:"status,omitempty"`
-}
-
-// List of WebhookAuthenticator objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type WebhookAuthenticatorList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-
-	Items []WebhookAuthenticator `json:"items"`
-}

apis/concierge/config/v1alpha1/doc.go.tmpl

@@ -1,10 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// +k8s:openapi-gen=true
-// +k8s:deepcopy-gen=package
-// +k8s:defaulter-gen=TypeMeta
-// +groupName=config.concierge.pinniped.dev
-
-// Package v1alpha1 is the v1alpha1 version of the Pinniped concierge configuration API.
-package v1alpha1

apis/concierge/config/v1alpha1/register.go.tmpl

@@ -1,43 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const GroupName = "config.concierge.pinniped.dev"
-
-// SchemeGroupVersion is group version used to register these objects.
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
-
-var (
-	SchemeBuilder      runtime.SchemeBuilder
-	localSchemeBuilder = &SchemeBuilder
-	AddToScheme        = localSchemeBuilder.AddToScheme
-)
-
-func init() {
-	// We only register manually written functions here. The registration of the
-	// generated functions takes place in the generated files. The separation
-	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addKnownTypes)
-}
-
-// Adds the list of known types to the given scheme.
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&CredentialIssuer{},
-		&CredentialIssuerList{},
-	)
-	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
-	return nil
-}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource.
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}

apis/concierge/config/v1alpha1/types_credentialissuer.go.tmpl

@@ -1,241 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// StrategyType enumerates a type of "strategy" used to implement credential access on a cluster.
-// +kubebuilder:validation:Enum=KubeClusterSigningCertificate;ImpersonationProxy
-type StrategyType string
-
-// FrontendType enumerates a type of "frontend" used to provide access to users of a cluster.
-// +kubebuilder:validation:Enum=TokenCredentialRequestAPI;ImpersonationProxy
-type FrontendType string
-
-// StrategyStatus enumerates whether a strategy is working on a cluster.
-// +kubebuilder:validation:Enum=Success;Error
-type StrategyStatus string
-
-// StrategyReason enumerates the detailed reason why a strategy is in a particular status.
-// +kubebuilder:validation:Enum=Listening;Pending;Disabled;ErrorDuringSetup;CouldNotFetchKey;CouldNotGetClusterInfo;FetchedKey
-type StrategyReason string
-
-const (
-	KubeClusterSigningCertificateStrategyType = StrategyType("KubeClusterSigningCertificate")
-	ImpersonationProxyStrategyType            = StrategyType("ImpersonationProxy")
-
-	TokenCredentialRequestAPIFrontendType = FrontendType("TokenCredentialRequestAPI")
-	ImpersonationProxyFrontendType        = FrontendType("ImpersonationProxy")
-
-	SuccessStrategyStatus = StrategyStatus("Success")
-	ErrorStrategyStatus   = StrategyStatus("Error")
-
-	ListeningStrategyReason              = StrategyReason("Listening")
-	PendingStrategyReason                = StrategyReason("Pending")
-	DisabledStrategyReason               = StrategyReason("Disabled")
-	ErrorDuringSetupStrategyReason       = StrategyReason("ErrorDuringSetup")
-	CouldNotFetchKeyStrategyReason       = StrategyReason("CouldNotFetchKey")
-	CouldNotGetClusterInfoStrategyReason = StrategyReason("CouldNotGetClusterInfo")
-	FetchedKeyStrategyReason             = StrategyReason("FetchedKey")
-)
-
-// CredentialIssuerSpec describes the intended configuration of the Concierge.
-type CredentialIssuerSpec struct {
-	// ImpersonationProxy describes the intended configuration of the Concierge impersonation proxy.
-	ImpersonationProxy *ImpersonationProxySpec `json:"impersonationProxy"`
-}
-
-// ImpersonationProxyMode enumerates the configuration modes for the impersonation proxy.
-//
-// +kubebuilder:validation:Enum=auto;enabled;disabled
-type ImpersonationProxyMode string
-
-const (
-	// ImpersonationProxyModeDisabled explicitly disables the impersonation proxy.
-	ImpersonationProxyModeDisabled = ImpersonationProxyMode("disabled")
-
-	// ImpersonationProxyModeEnabled explicitly enables the impersonation proxy.
-	ImpersonationProxyModeEnabled = ImpersonationProxyMode("enabled")
-
-	// ImpersonationProxyModeAuto enables or disables the impersonation proxy based upon the cluster in which it is running.
-	ImpersonationProxyModeAuto = ImpersonationProxyMode("auto")
-)
-
-// ImpersonationProxyServiceType enumerates the types of service that can be provisioned for the impersonation proxy.
-//
-// +kubebuilder:validation:Enum=LoadBalancer;ClusterIP;None
-type ImpersonationProxyServiceType string
-
-const (
-	// ImpersonationProxyServiceTypeLoadBalancer provisions a service of type LoadBalancer.
-	ImpersonationProxyServiceTypeLoadBalancer = ImpersonationProxyServiceType("LoadBalancer")
-
-	// ImpersonationProxyServiceTypeClusterIP provisions a service of type ClusterIP.
-	ImpersonationProxyServiceTypeClusterIP = ImpersonationProxyServiceType("ClusterIP")
-
-	// ImpersonationProxyServiceTypeNone does not automatically provision any service.
-	ImpersonationProxyServiceTypeNone = ImpersonationProxyServiceType("None")
-)
-
-// ImpersonationProxySpec describes the intended configuration of the Concierge impersonation proxy.
-type ImpersonationProxySpec struct {
-	// Mode configures whether the impersonation proxy should be started:
-	// - "disabled" explicitly disables the impersonation proxy. This is the default.
-	// - "enabled" explicitly enables the impersonation proxy.
-	// - "auto" enables or disables the impersonation proxy based upon the cluster in which it is running.
-	Mode ImpersonationProxyMode `json:"mode"`
-
-	// Service describes the configuration of the Service provisioned to expose the impersonation proxy to clients.
-	//
-	// +kubebuilder:default:={"type": "LoadBalancer"}
-	Service ImpersonationProxyServiceSpec `json:"service"`
-
-	// ExternalEndpoint describes the HTTPS endpoint where the proxy will be exposed. If not set, the proxy will
-	// be served using the external name of the LoadBalancer service or the cluster service DNS name.
-	//
-	// This field must be non-empty when spec.impersonationProxy.service.mode is "None".
-	//
-	// +optional
-	ExternalEndpoint string `json:"externalEndpoint,omitempty"`
-}
-
-// ImpersonationProxyServiceSpec describes how the Concierge should provision a Service to expose the impersonation proxy.
-type ImpersonationProxyServiceSpec struct {
-	// Type specifies the type of Service to provision for the impersonation proxy.
-	//
-	// If the type is "None", then the "spec.impersonationProxy.externalEndpoint" field must be set to a non-empty
-	// value so that the Concierge can properly advertise the endpoint in the CredentialIssuer's status.
-	//
-	// +kubebuilder:default:="LoadBalancer"
-	Type ImpersonationProxyServiceType `json:"type,omitempty"`
-
-	// LoadBalancerIP specifies the IP address to set in the spec.loadBalancerIP field of the provisioned Service.
-	// This is not supported on all cloud providers.
-	//
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:MaxLength=255
-	// +optional
-	LoadBalancerIP string `json:"loadBalancerIP,omitempty"`
-
-	// Annotations specifies zero or more key/value pairs to set as annotations on the provisioned Service.
-	//
-	// +optional
-	Annotations map[string]string `json:"annotations,omitempty"`
-}
-
-// CredentialIssuerStatus describes the status of the Concierge.
-type CredentialIssuerStatus struct {
-	// List of integration strategies that were attempted by Pinniped.
-	Strategies []CredentialIssuerStrategy `json:"strategies"`
-
-	// Information needed to form a valid Pinniped-based kubeconfig using this credential issuer.
-	// This field is deprecated and will be removed in a future version.
-	// +optional
-	KubeConfigInfo *CredentialIssuerKubeConfigInfo `json:"kubeConfigInfo,omitempty"`
-}
-
-// CredentialIssuerKubeConfigInfo provides the information needed to form a valid Pinniped-based kubeconfig using this credential issuer.
-// This type is deprecated and will be removed in a future version.
-type CredentialIssuerKubeConfigInfo struct {
-	// The K8s API server URL.
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:Pattern=`^https://|^http://`
-	Server string `json:"server"`
-
-	// The K8s API server CA bundle.
-	// +kubebuilder:validation:MinLength=1
-	CertificateAuthorityData string `json:"certificateAuthorityData"`
-}
-
-// CredentialIssuerStrategy describes the status of an integration strategy that was attempted by Pinniped.
-type CredentialIssuerStrategy struct {
-	// Type of integration attempted.
-	Type StrategyType `json:"type"`
-
-	// Status of the attempted integration strategy.
-	Status StrategyStatus `json:"status"`
-
-	// Reason for the current status.
-	Reason StrategyReason `json:"reason"`
-
-	// Human-readable description of the current status.
-	// +kubebuilder:validation:MinLength=1
-	Message string `json:"message"`
-
-	// When the status was last checked.
-	LastUpdateTime metav1.Time `json:"lastUpdateTime"`
-
-	// Frontend describes how clients can connect using this strategy.
-	Frontend *CredentialIssuerFrontend `json:"frontend,omitempty"`
-}
-
-// CredentialIssuerFrontend describes how to connect using a particular integration strategy.
-type CredentialIssuerFrontend struct {
-	// Type describes which frontend mechanism clients can use with a strategy.
-	Type FrontendType `json:"type"`
-
-	// TokenCredentialRequestAPIInfo describes the parameters for the TokenCredentialRequest API on this Concierge.
-	// This field is only set when Type is "TokenCredentialRequestAPI".
-	TokenCredentialRequestAPIInfo *TokenCredentialRequestAPIInfo `json:"tokenCredentialRequestInfo,omitempty"`
-
-	// ImpersonationProxyInfo describes the parameters for the impersonation proxy on this Concierge.
-	// This field is only set when Type is "ImpersonationProxy".
-	ImpersonationProxyInfo *ImpersonationProxyInfo `json:"impersonationProxyInfo,omitempty"`
-}
-
-// TokenCredentialRequestAPIInfo describes the parameters for the TokenCredentialRequest API on this Concierge.
-type TokenCredentialRequestAPIInfo struct {
-	// Server is the Kubernetes API server URL.
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:Pattern=`^https://|^http://`
-	Server string `json:"server"`
-
-	// CertificateAuthorityData is the base64-encoded Kubernetes API server CA bundle.
-	// +kubebuilder:validation:MinLength=1
-	CertificateAuthorityData string `json:"certificateAuthorityData"`
-}
-
-// ImpersonationProxyInfo describes the parameters for the impersonation proxy on this Concierge.
-type ImpersonationProxyInfo struct {
-	// Endpoint is the HTTPS endpoint of the impersonation proxy.
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:Pattern=`^https://`
-	Endpoint string `json:"endpoint"`
-
-	// CertificateAuthorityData is the base64-encoded PEM CA bundle of the impersonation proxy.
-	// +kubebuilder:validation:MinLength=1
-	CertificateAuthorityData string `json:"certificateAuthorityData"`
-}
-
-// CredentialIssuer describes the configuration and status of the Pinniped Concierge credential issuer.
-// +genclient
-// +genclient:nonNamespaced
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +kubebuilder:resource:categories=pinniped,scope=Cluster
-// +kubebuilder:subresource:status
-type CredentialIssuer struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	// Spec describes the intended configuration of the Concierge.
-	//
-	// +optional
-	Spec CredentialIssuerSpec `json:"spec"`
-
-	// CredentialIssuerStatus describes the status of the Concierge.
-	//
-	// +optional
-	Status CredentialIssuerStatus `json:"status"`
-}
-
-// CredentialIssuerList is a list of CredentialIssuer objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type CredentialIssuerList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-
-	Items []CredentialIssuer `json:"items"`
-}

apis/concierge/identity/doc.go.tmpl

@@ -1,8 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// +k8s:deepcopy-gen=package
-// +groupName=identity.concierge.pinniped.dev
-
-// Package identity is the internal version of the Pinniped identity API.
-package identity

apis/concierge/identity/register.go.tmpl

@@ -1,38 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package identity
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const GroupName = "identity.concierge.pinniped.dev"
-
-// SchemeGroupVersion is group version used to register these objects.
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
-
-// Kind takes an unqualified kind and returns back a Group qualified GroupKind.
-func Kind(kind string) schema.GroupKind {
-	return SchemeGroupVersion.WithKind(kind).GroupKind()
-}
-
-// Resource takes an unqualified resource and returns back a Group qualified GroupResource.
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}
-
-var (
-	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
-	AddToScheme   = SchemeBuilder.AddToScheme
-)
-
-// Adds the list of known types to the given scheme.
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&WhoAmIRequest{},
-		&WhoAmIRequestList{},
-	)
-	return nil
-}

apis/concierge/identity/types_userinfo.go.tmpl

@@ -1,37 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package identity
-
-import "fmt"
-
-// KubernetesUserInfo represents the current authenticated user, exactly as Kubernetes understands it.
-// Copied from the Kubernetes token review API.
-type KubernetesUserInfo struct {
-	// User is the UserInfo associated with the current user.
-	User UserInfo
-	// Audiences are audience identifiers chosen by the authenticator.
-	Audiences []string
-}
-
-// UserInfo holds the information about the user needed to implement the
-// user.Info interface.
-type UserInfo struct {
-	// The name that uniquely identifies this user among all active users.
-	Username string
-	// A unique value that identifies this user across time. If this user is
-	// deleted and another user by the same name is added, they will have
-	// different UIDs.
-	UID string
-	// The names of groups this user is a part of.
-	Groups []string
-	// Any additional information provided by the authenticator.
-	Extra map[string]ExtraValue
-}
-
-// ExtraValue masks the value so protobuf can generate
-type ExtraValue []string
-
-func (t ExtraValue) String() string {
-	return fmt.Sprintf("%v", []string(t))
-}

apis/concierge/identity/types_whoami.go.tmpl

@@ -1,40 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package identity
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// WhoAmIRequest submits a request to echo back the current authenticated user.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type WhoAmIRequest struct {
-	metav1.TypeMeta
-	metav1.ObjectMeta
-
-	Spec   WhoAmIRequestSpec
-	Status WhoAmIRequestStatus
-}
-
-type WhoAmIRequestSpec struct {
-	// empty for now but we may add some config here in the future
-	// any such config must be safe in the context of an unauthenticated user
-}
-
-type WhoAmIRequestStatus struct {
-	// The current authenticated user, exactly as Kubernetes understands it.
-	KubernetesUserInfo KubernetesUserInfo
-
-	// We may add concierge specific information here in the future.
-}
-
-// WhoAmIRequestList is a list of WhoAmIRequest objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type WhoAmIRequestList struct {
-	metav1.TypeMeta
-	metav1.ListMeta
-
-	// Items is a list of WhoAmIRequest
-	Items []WhoAmIRequest
-}

apis/concierge/identity/v1alpha1/conversion.go.tmpl

@@ -1,4 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1

apis/concierge/identity/v1alpha1/defaults.go.tmpl

@@ -1,12 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-)
-
-func addDefaultingFuncs(scheme *runtime.Scheme) error {
-	return RegisterDefaults(scheme)
-}

apis/concierge/identity/v1alpha1/doc.go.tmpl

@@ -1,11 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// +k8s:openapi-gen=true
-// +k8s:deepcopy-gen=package
-// +k8s:conversion-gen=go.pinniped.dev/GENERATED_PKG/apis/concierge/identity
-// +k8s:defaulter-gen=TypeMeta
-// +groupName=identity.concierge.pinniped.dev
-
-// Package v1alpha1 is the v1alpha1 version of the Pinniped identity API.
-package v1alpha1

apis/concierge/identity/v1alpha1/register.go.tmpl

@@ -1,43 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const GroupName = "identity.concierge.pinniped.dev"
-
-// SchemeGroupVersion is group version used to register these objects.
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
-
-var (
-	SchemeBuilder      runtime.SchemeBuilder
-	localSchemeBuilder = &SchemeBuilder
-	AddToScheme        = localSchemeBuilder.AddToScheme
-)
-
-func init() {
-	// We only register manually written functions here. The registration of the
-	// generated functions takes place in the generated files. The separation
-	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addKnownTypes, addDefaultingFuncs)
-}
-
-// Adds the list of known types to the given scheme.
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&WhoAmIRequest{},
-		&WhoAmIRequestList{},
-	)
-	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
-	return nil
-}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource.
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}

apis/concierge/identity/v1alpha1/types_userinfo.go.tmpl

@@ -1,41 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import "fmt"
-
-// KubernetesUserInfo represents the current authenticated user, exactly as Kubernetes understands it.
-// Copied from the Kubernetes token review API.
-type KubernetesUserInfo struct {
-	// User is the UserInfo associated with the current user.
-	User UserInfo `json:"user"`
-	// Audiences are audience identifiers chosen by the authenticator.
-	// +optional
-	Audiences []string `json:"audiences,omitempty"`
-}
-
-// UserInfo holds the information about the user needed to implement the
-// user.Info interface.
-type UserInfo struct {
-	// The name that uniquely identifies this user among all active users.
-	Username string `json:"username"`
-	// A unique value that identifies this user across time. If this user is
-	// deleted and another user by the same name is added, they will have
-	// different UIDs.
-	// +optional
-	UID string `json:"uid,omitempty"`
-	// The names of groups this user is a part of.
-	// +optional
-	Groups []string `json:"groups,omitempty"`
-	// Any additional information provided by the authenticator.
-	// +optional
-	Extra map[string]ExtraValue `json:"extra,omitempty"`
-}
-
-// ExtraValue masks the value so protobuf can generate
-type ExtraValue []string
-
-func (t ExtraValue) String() string {
-	return fmt.Sprintf("%v", []string(t))
-}

apis/concierge/identity/v1alpha1/types_whoami.go.tmpl

@@ -1,43 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// WhoAmIRequest submits a request to echo back the current authenticated user.
-// +genclient
-// +genclient:nonNamespaced
-// +genclient:onlyVerbs=create
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type WhoAmIRequest struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   WhoAmIRequestSpec   `json:"spec,omitempty"`
-	Status WhoAmIRequestStatus `json:"status,omitempty"`
-}
-
-type WhoAmIRequestSpec struct {
-	// empty for now but we may add some config here in the future
-	// any such config must be safe in the context of an unauthenticated user
-}
-
-type WhoAmIRequestStatus struct {
-	// The current authenticated user, exactly as Kubernetes understands it.
-	KubernetesUserInfo KubernetesUserInfo `json:"kubernetesUserInfo"`
-
-	// We may add concierge specific information here in the future.
-}
-
-// WhoAmIRequestList is a list of WhoAmIRequest objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type WhoAmIRequestList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-
-	// Items is a list of WhoAmIRequest
-	Items []WhoAmIRequest `json:"items"`
-}

apis/concierge/identity/validation/validation.go.tmpl

@@ -1,14 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package validation
-
-import (
-	"k8s.io/apimachinery/pkg/util/validation/field"
-
-	identityapi "go.pinniped.dev/GENERATED_PKG/apis/concierge/identity"
-)
-
-func ValidateWhoAmIRequest(whoAmIRequest *identityapi.WhoAmIRequest) field.ErrorList {
-	return nil // add validation for spec here if we expand it
-}

apis/concierge/login/doc.go.tmpl

@@ -1,8 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// +k8s:deepcopy-gen=package
-// +groupName=login.concierge.pinniped.dev
-
-// Package login is the internal version of the Pinniped login API.
-package login

apis/concierge/login/register.go.tmpl

@@ -1,38 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package login
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const GroupName = "login.concierge.pinniped.dev"
-
-// SchemeGroupVersion is group version used to register these objects.
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
-
-// Kind takes an unqualified kind and returns back a Group qualified GroupKind.
-func Kind(kind string) schema.GroupKind {
-	return SchemeGroupVersion.WithKind(kind).GroupKind()
-}
-
-// Resource takes an unqualified resource and returns back a Group qualified GroupResource.
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}
-
-var (
-	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
-	AddToScheme   = SchemeBuilder.AddToScheme
-)
-
-// Adds the list of known types to the given scheme.
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&TokenCredentialRequest{},
-		&TokenCredentialRequestList{},
-	)
-	return nil
-}

apis/concierge/login/types_clustercred.go.tmpl

@@ -1,21 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package login
-
-import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-// ClusterCredential is a credential (token or certificate) which is valid on the Kubernetes cluster.
-type ClusterCredential struct {
-	// ExpirationTimestamp indicates a time when the provided credentials expire.
-	ExpirationTimestamp metav1.Time
-
-	// Token is a bearer token used by the client for request authentication.
-	Token string
-
-	// PEM-encoded client TLS certificates (including intermediates, if any).
-	ClientCertificateData string
-
-	// PEM-encoded private key for the above certificate.
-	ClientKeyData string
-}

apis/concierge/login/types_token.go.tmpl

@@ -1,47 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package login
-
-import (
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type TokenCredentialRequestSpec struct {
-	// Bearer token supplied with the credential request.
-	Token string
-
-	// Reference to an authenticator which can validate this credential request.
-	Authenticator corev1.TypedLocalObjectReference
-}
-
-type TokenCredentialRequestStatus struct {
-	// A ClusterCredential will be returned for a successful credential request.
-	// +optional
-	Credential *ClusterCredential
-
-	// An error message will be returned for an unsuccessful credential request.
-	// +optional
-	Message *string
-}
-
-// TokenCredentialRequest submits an IDP-specific credential to Pinniped in exchange for a cluster-specific credential.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type TokenCredentialRequest struct {
-	metav1.TypeMeta
-	metav1.ObjectMeta
-
-	Spec   TokenCredentialRequestSpec
-	Status TokenCredentialRequestStatus
-}
-
-// TokenCredentialRequestList is a list of TokenCredentialRequest objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type TokenCredentialRequestList struct {
-	metav1.TypeMeta
-	metav1.ListMeta
-
-	// Items is a list of TokenCredentialRequest
-	Items []TokenCredentialRequest
-}

apis/concierge/login/v1alpha1/conversion.go.tmpl

@@ -1,4 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1

apis/concierge/login/v1alpha1/defaults.go.tmpl

@@ -1,12 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-)
-
-func addDefaultingFuncs(scheme *runtime.Scheme) error {
-	return RegisterDefaults(scheme)
-}

apis/concierge/login/v1alpha1/doc.go.tmpl

@@ -1,11 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// +k8s:openapi-gen=true
-// +k8s:deepcopy-gen=package
-// +k8s:conversion-gen=go.pinniped.dev/GENERATED_PKG/apis/concierge/login
-// +k8s:defaulter-gen=TypeMeta
-// +groupName=login.concierge.pinniped.dev
-
-// Package v1alpha1 is the v1alpha1 version of the Pinniped login API.
-package v1alpha1

apis/concierge/login/v1alpha1/register.go.tmpl

@@ -1,43 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const GroupName = "login.concierge.pinniped.dev"
-
-// SchemeGroupVersion is group version used to register these objects.
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
-
-var (
-	SchemeBuilder      runtime.SchemeBuilder
-	localSchemeBuilder = &SchemeBuilder
-	AddToScheme        = localSchemeBuilder.AddToScheme
-)
-
-func init() {
-	// We only register manually written functions here. The registration of the
-	// generated functions takes place in the generated files. The separation
-	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addKnownTypes, addDefaultingFuncs)
-}
-
-// Adds the list of known types to the given scheme.
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&TokenCredentialRequest{},
-		&TokenCredentialRequestList{},
-	)
-	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
-	return nil
-}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource.
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}

apis/concierge/login/v1alpha1/types_clustercred.go.tmpl

@@ -1,22 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-// ClusterCredential is the cluster-specific credential returned on a successful credential request. It
-// contains either a valid bearer token or a valid TLS certificate and corresponding private key for the cluster.
-type ClusterCredential struct {
-	// ExpirationTimestamp indicates a time when the provided credentials expire.
-	ExpirationTimestamp metav1.Time `json:"expirationTimestamp,omitempty"`
-
-	// Token is a bearer token used by the client for request authentication.
-	Token string `json:"token,omitempty"`
-
-	// PEM-encoded client TLS certificates (including intermediates, if any).
-	ClientCertificateData string `json:"clientCertificateData,omitempty"`
-
-	// PEM-encoded private key for the above certificate.
-	ClientKeyData string `json:"clientKeyData,omitempty"`
-}

apis/concierge/login/v1alpha1/types_token.go.tmpl

@@ -1,51 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// TokenCredentialRequestSpec is the specification of a TokenCredentialRequest, expected on requests to the Pinniped API.
-type TokenCredentialRequestSpec struct {
-	// Bearer token supplied with the credential request.
-	Token string `json:"token,omitempty"`
-
-	// Reference to an authenticator which can validate this credential request.
-	Authenticator corev1.TypedLocalObjectReference `json:"authenticator"`
-}
-
-// TokenCredentialRequestStatus is the status of a TokenCredentialRequest, returned on responses to the Pinniped API.
-type TokenCredentialRequestStatus struct {
-	// A Credential will be returned for a successful credential request.
-	// +optional
-	Credential *ClusterCredential `json:"credential,omitempty"`
-
-	// An error message will be returned for an unsuccessful credential request.
-	// +optional
-	Message *string `json:"message,omitempty"`
-}
-
-// TokenCredentialRequest submits an IDP-specific credential to Pinniped in exchange for a cluster-specific credential.
-// +genclient
-// +genclient:nonNamespaced
-// +genclient:onlyVerbs=create
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type TokenCredentialRequest struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   TokenCredentialRequestSpec   `json:"spec,omitempty"`
-	Status TokenCredentialRequestStatus `json:"status,omitempty"`
-}
-
-// TokenCredentialRequestList is a list of TokenCredentialRequest objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type TokenCredentialRequestList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-
-	Items []TokenCredentialRequest `json:"items"`
-}

apis/supervisor/config/v1alpha1/doc.go.tmpl

@@ -1,11 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// +k8s:openapi-gen=true
-// +k8s:deepcopy-gen=package
-// +k8s:conversion-gen=go.pinniped.dev/GENERATED_PKG/apis/supervisor/config
-// +k8s:defaulter-gen=TypeMeta
-// +groupName=config.supervisor.pinniped.dev
-
-// Package v1alpha1 is the v1alpha1 version of the Pinniped supervisor configuration API.
-package v1alpha1

apis/supervisor/config/v1alpha1/register.go.tmpl

@@ -1,43 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const GroupName = "config.supervisor.pinniped.dev"
-
-// SchemeGroupVersion is group version used to register these objects.
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
-
-var (
-	SchemeBuilder      runtime.SchemeBuilder
-	localSchemeBuilder = &SchemeBuilder
-	AddToScheme        = localSchemeBuilder.AddToScheme
-)
-
-func init() {
-	// We only register manually written functions here. The registration of the
-	// generated functions takes place in the generated files. The separation
-	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addKnownTypes)
-}
-
-// Adds the list of known types to the given scheme.
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&FederationDomain{},
-		&FederationDomainList{},
-	)
-	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
-	return nil
-}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource.
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}

apis/supervisor/config/v1alpha1/types_federationdomain.go.tmpl

@@ -1,131 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// +kubebuilder:validation:Enum=Success;Duplicate;Invalid;SameIssuerHostMustUseSameSecret
-type FederationDomainStatusCondition string
-
-const (
-	SuccessFederationDomainStatusCondition                         = FederationDomainStatusCondition("Success")
-	DuplicateFederationDomainStatusCondition                       = FederationDomainStatusCondition("Duplicate")
-	SameIssuerHostMustUseSameSecretFederationDomainStatusCondition = FederationDomainStatusCondition("SameIssuerHostMustUseSameSecret")
-	InvalidFederationDomainStatusCondition                         = FederationDomainStatusCondition("Invalid")
-)
-
-// FederationDomainTLSSpec is a struct that describes the TLS configuration for an OIDC Provider.
-type FederationDomainTLSSpec struct {
-	// SecretName is an optional name of a Secret in the same namespace, of type `kubernetes.io/tls`, which contains
-	// the TLS serving certificate for the HTTPS endpoints served by this FederationDomain. When provided, the TLS Secret
-	// named here must contain keys named `tls.crt` and `tls.key` that contain the certificate and private key to use
-	// for TLS.
-	//
-	// Server Name Indication (SNI) is an extension to the Transport Layer Security (TLS) supported by all major browsers.
-	//
-	// SecretName is required if you would like to use different TLS certificates for issuers of different hostnames.
-	// SNI requests do not include port numbers, so all issuers with the same DNS hostname must use the same
-	// SecretName value even if they have different port numbers.
-	//
-	// SecretName is not required when you would like to use only the HTTP endpoints (e.g. when terminating TLS at an
-	// Ingress). It is also not required when you would like all requests to this OIDC Provider's HTTPS endpoints to
-	// use the default TLS certificate, which is configured elsewhere.
-	//
-	// When your Issuer URL's host is an IP address, then this field is ignored. SNI does not work for IP addresses.
-	//
-	// +optional
-	SecretName string `json:"secretName,omitempty"`
-}
-
-// FederationDomainSpec is a struct that describes an OIDC Provider.
-type FederationDomainSpec struct {
-	// Issuer is the OIDC Provider's issuer, per the OIDC Discovery Metadata document, as well as the
-	// identifier that it will use for the iss claim in issued JWTs. This field will also be used as
-	// the base URL for any endpoints used by the OIDC Provider (e.g., if your issuer is
-	// https://example.com/foo, then your authorization endpoint will look like
-	// https://example.com/foo/some/path/to/auth/endpoint).
-	//
-	// See
-	// https://openid.net/specs/openid-connect-discovery-1_0.html#rfc.section.3 for more information.
-	// +kubebuilder:validation:MinLength=1
-	Issuer string `json:"issuer"`
-
-	// TLS configures how this FederationDomain is served over Transport Layer Security (TLS).
-	// +optional
-	TLS *FederationDomainTLSSpec `json:"tls,omitempty"`
-}
-
-// FederationDomainSecrets holds information about this OIDC Provider's secrets.
-type FederationDomainSecrets struct {
-	// JWKS holds the name of the corev1.Secret in which this OIDC Provider's signing/verification keys are
-	// stored. If it is empty, then the signing/verification keys are either unknown or they don't
-	// exist.
-	// +optional
-	JWKS corev1.LocalObjectReference `json:"jwks,omitempty"`
-
-	// TokenSigningKey holds the name of the corev1.Secret in which this OIDC Provider's key for
-	// signing tokens is stored.
-	// +optional
-	TokenSigningKey corev1.LocalObjectReference `json:"tokenSigningKey,omitempty"`
-
-	// StateSigningKey holds the name of the corev1.Secret in which this OIDC Provider's key for
-	// signing state parameters is stored.
-	// +optional
-	StateSigningKey corev1.LocalObjectReference `json:"stateSigningKey,omitempty"`
-
-	// StateSigningKey holds the name of the corev1.Secret in which this OIDC Provider's key for
-	// encrypting state parameters is stored.
-	// +optional
-	StateEncryptionKey corev1.LocalObjectReference `json:"stateEncryptionKey,omitempty"`
-}
-
-// FederationDomainStatus is a struct that describes the actual state of an OIDC Provider.
-type FederationDomainStatus struct {
-	// Status holds an enum that describes the state of this OIDC Provider. Note that this Status can
-	// represent success or failure.
-	// +optional
-	Status FederationDomainStatusCondition `json:"status,omitempty"`
-
-	// Message provides human-readable details about the Status.
-	// +optional
-	Message string `json:"message,omitempty"`
-
-	// LastUpdateTime holds the time at which the Status was last updated. It is a pointer to get
-	// around some undesirable behavior with respect to the empty metav1.Time value (see
-	// https://github.com/kubernetes/kubernetes/issues/86811).
-	// +optional
-	LastUpdateTime *metav1.Time `json:"lastUpdateTime,omitempty"`
-
-	// Secrets contains information about this OIDC Provider's secrets.
-	// +optional
-	Secrets FederationDomainSecrets `json:"secrets,omitempty"`
-}
-
-// FederationDomain describes the configuration of an OIDC provider.
-// +genclient
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +kubebuilder:resource:categories=pinniped
-// +kubebuilder:subresource:status
-type FederationDomain struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	// Spec of the OIDC provider.
-	Spec FederationDomainSpec `json:"spec"`
-
-	// Status of the OIDC provider.
-	Status FederationDomainStatus `json:"status,omitempty"`
-}
-
-// List of FederationDomain objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type FederationDomainList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-
-	Items []FederationDomain `json:"items"`
-}

apis/supervisor/idp/v1alpha1/doc.go.tmpl

@@ -1,11 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// +k8s:openapi-gen=true
-// +k8s:deepcopy-gen=package
-// +k8s:defaulter-gen=TypeMeta
-// +groupName=idp.supervisor.pinniped.dev
-// +groupGoName=IDP
-
-// Package v1alpha1 is the v1alpha1 version of the Pinniped supervisor identity provider (IDP) API.
-package v1alpha1

apis/supervisor/idp/v1alpha1/register.go.tmpl

@@ -1,45 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const GroupName = "idp.supervisor.pinniped.dev"
-
-// SchemeGroupVersion is group version used to register these objects.
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
-
-var (
-	SchemeBuilder      runtime.SchemeBuilder
-	localSchemeBuilder = &SchemeBuilder
-	AddToScheme        = localSchemeBuilder.AddToScheme
-)
-
-func init() {
-	// We only register manually written functions here. The registration of the
-	// generated functions takes place in the generated files. The separation
-	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addKnownTypes)
-}
-
-// Adds the list of known types to the given scheme.
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&OIDCIdentityProvider{},
-		&OIDCIdentityProviderList{},
-		&LDAPIdentityProvider{},
-		&LDAPIdentityProviderList{},
-	)
-	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
-	return nil
-}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource.
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}

apis/supervisor/idp/v1alpha1/types_ldapidentityprovider.go.tmpl

@@ -1,171 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type LDAPIdentityProviderPhase string
-
-const (
-	// LDAPPhasePending is the default phase for newly-created LDAPIdentityProvider resources.
-	LDAPPhasePending LDAPIdentityProviderPhase = "Pending"
-
-	// LDAPPhaseReady is the phase for an LDAPIdentityProvider resource in a healthy state.
-	LDAPPhaseReady LDAPIdentityProviderPhase = "Ready"
-
-	// LDAPPhaseError is the phase for an LDAPIdentityProvider in an unhealthy state.
-	LDAPPhaseError LDAPIdentityProviderPhase = "Error"
-)
-
-// Status of an LDAP identity provider.
-type LDAPIdentityProviderStatus struct {
-	// Phase summarizes the overall status of the LDAPIdentityProvider.
-	// +kubebuilder:default=Pending
-	// +kubebuilder:validation:Enum=Pending;Ready;Error
-	Phase LDAPIdentityProviderPhase `json:"phase,omitempty"`
-
-	// Represents the observations of an identity provider's current state.
-	// +patchMergeKey=type
-	// +patchStrategy=merge
-	// +listType=map
-	// +listMapKey=type
-	Conditions []Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
-}
-
-type LDAPIdentityProviderBind struct {
-	// SecretName contains the name of a namespace-local Secret object that provides the username and
-	// password for an LDAP bind user. This account will be used to perform LDAP searches. The Secret should be
-	// of type "kubernetes.io/basic-auth" which includes "username" and "password" keys. The username value
-	// should be the full dn (distinguished name) of your bind account, e.g. "cn=bind-account,ou=users,dc=example,dc=com".
-	// The password must be non-empty.
-	// +kubebuilder:validation:MinLength=1
-	SecretName string `json:"secretName"`
-}
-
-type LDAPIdentityProviderUserSearchAttributes struct {
-	// Username specifies the name of the attribute in the LDAP entry whose value shall become the username
-	// of the user after a successful authentication. This would typically be the same attribute name used in
-	// the user search filter, although it can be different. E.g. "mail" or "uid" or "userPrincipalName".
-	// The value of this field is case-sensitive and must match the case of the attribute name returned by the LDAP
-	// server in the user's entry. Distinguished names can be used by specifying lower-case "dn". When this field
-	// is set to "dn" then the LDAPIdentityProviderUserSearch's Filter field cannot be blank, since the default
-	// value of "dn={}" would not work.
-	// +kubebuilder:validation:MinLength=1
-	Username string `json:"username,omitempty"`
-
-	// UID specifies the name of the attribute in the LDAP entry which whose value shall be used to uniquely
-	// identify the user within this LDAP provider after a successful authentication. E.g. "uidNumber" or "objectGUID".
-	// The value of this field is case-sensitive and must match the case of the attribute name returned by the LDAP
-	// server in the user's entry. Distinguished names can be used by specifying lower-case "dn".
-	// +kubebuilder:validation:MinLength=1
-	UID string `json:"uid,omitempty"`
-}
-
-type LDAPIdentityProviderGroupSearchAttributes struct {
-	// GroupName specifies the name of the attribute in the LDAP entries whose value shall become a group name
-	// in the user's list of groups after a successful authentication.
-	// The value of this field is case-sensitive and must match the case of the attribute name returned by the LDAP
-	// server in the user's entry. E.g. "cn" for common name. Distinguished names can be used by specifying lower-case "dn".
-	// Optional. When not specified, the default will act as if the GroupName were specified as "dn" (distinguished name).
-	// +optional
-	GroupName string `json:"groupName,omitempty"`
-}
-
-type LDAPIdentityProviderUserSearch struct {
-	// Base is the dn (distinguished name) that should be used as the search base when searching for users.
-	// E.g. "ou=users,dc=example,dc=com".
-	// +kubebuilder:validation:MinLength=1
-	Base string `json:"base,omitempty"`
-
-	// Filter is the LDAP search filter which should be applied when searching for users. The pattern "{}" must occur
-	// in the filter at least once and will be dynamically replaced by the username for which the search is being run.
-	// E.g. "mail={}" or "&(objectClass=person)(uid={})". For more information about LDAP filters, see
-	// https://ldap.com/ldap-filters.
-	// Note that the dn (distinguished name) is not an attribute of an entry, so "dn={}" cannot be used.
-	// Optional. When not specified, the default will act as if the Filter were specified as the value from
-	// Attributes.Username appended by "={}". When the Attributes.Username is set to "dn" then the Filter must be
-	// explicitly specified, since the default value of "dn={}" would not work.
-	// +optional
-	Filter string `json:"filter,omitempty"`
-
-	// Attributes specifies how the user's information should be read from the LDAP entry which was found as
-	// the result of the user search.
-	// +optional
-	Attributes LDAPIdentityProviderUserSearchAttributes `json:"attributes,omitempty"`
-}
-
-type LDAPIdentityProviderGroupSearch struct {
-	// Base is the dn (distinguished name) that should be used as the search base when searching for groups. E.g.
-	// "ou=groups,dc=example,dc=com". When not specified, no group search will be performed and
-	// authenticated users will not belong to any groups from the LDAP provider. Also, when not specified,
-	// the values of Filter and Attributes are ignored.
-	// +optional
-	Base string `json:"base,omitempty"`
-
-	// Filter is the LDAP search filter which should be applied when searching for groups for a user.
-	// The pattern "{}" must occur in the filter at least once and will be dynamically replaced by the
-	// dn (distinguished name) of the user entry found as a result of the user search. E.g. "member={}" or
-	// "&(objectClass=groupOfNames)(member={})". For more information about LDAP filters, see
-	// https://ldap.com/ldap-filters.
-	// Note that the dn (distinguished name) is not an attribute of an entry, so "dn={}" cannot be used.
-	// Optional. When not specified, the default will act as if the Filter were specified as "member={}".
-	// +optional
-	Filter string `json:"filter,omitempty"`
-
-	// Attributes specifies how the group's information should be read from each LDAP entry which was found as
-	// the result of the group search.
-	// +optional
-	Attributes LDAPIdentityProviderGroupSearchAttributes `json:"attributes,omitempty"`
-}
-
-// Spec for configuring an LDAP identity provider.
-type LDAPIdentityProviderSpec struct {
-	// Host is the hostname of this LDAP identity provider, i.e., where to connect. For example: ldap.example.com:636.
-	// +kubebuilder:validation:MinLength=1
-	Host string `json:"host"`
-
-	// TLS contains the connection settings for how to establish the connection to the Host.
-	TLS *TLSSpec `json:"tls,omitempty"`
-
-	// Bind contains the configuration for how to provide access credentials during an initial bind to the LDAP server
-	// to be allowed to perform searches and binds to validate a user's credentials during a user's authentication attempt.
-	Bind LDAPIdentityProviderBind `json:"bind,omitempty"`
-
-	// UserSearch contains the configuration for searching for a user by name in the LDAP provider.
-	UserSearch LDAPIdentityProviderUserSearch `json:"userSearch,omitempty"`
-
-	// GroupSearch contains the configuration for searching for a user's group membership in the LDAP provider.
-	GroupSearch LDAPIdentityProviderGroupSearch `json:"groupSearch,omitempty"`
-}
-
-// LDAPIdentityProvider describes the configuration of an upstream Lightweight Directory Access
-// Protocol (LDAP) identity provider.
-// +genclient
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +kubebuilder:resource:categories=pinniped;pinniped-idp;pinniped-idps
-// +kubebuilder:printcolumn:name="Host",type=string,JSONPath=`.spec.host`
-// +kubebuilder:printcolumn:name="Status",type=string,JSONPath=`.status.phase`
-// +kubebuilder:printcolumn:name="Age",type=date,JSONPath=`.metadata.creationTimestamp`
-// +kubebuilder:subresource:status
-type LDAPIdentityProvider struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	// Spec for configuring the identity provider.
-	Spec LDAPIdentityProviderSpec `json:"spec"`
-
-	// Status of the identity provider.
-	Status LDAPIdentityProviderStatus `json:"status,omitempty"`
-}
-
-// List of LDAPIdentityProvider objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type LDAPIdentityProviderList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-
-	Items []LDAPIdentityProvider `json:"items"`
-}

apis/supervisor/idp/v1alpha1/types_meta.go.tmpl

@@ -1,75 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-// ConditionStatus is effectively an enum type for Condition.Status.
-type ConditionStatus string
-
-// These are valid condition statuses. "ConditionTrue" means a resource is in the condition.
-// "ConditionFalse" means a resource is not in the condition. "ConditionUnknown" means kubernetes
-// can't decide if a resource is in the condition or not. In the future, we could add other
-// intermediate conditions, e.g. ConditionDegraded.
-const (
-	ConditionTrue    ConditionStatus = "True"
-	ConditionFalse   ConditionStatus = "False"
-	ConditionUnknown ConditionStatus = "Unknown"
-)
-
-// Condition status of a resource (mirrored from the metav1.Condition type added in Kubernetes 1.19). In a future API
-// version we can switch to using the upstream type.
-// See https://github.com/kubernetes/apimachinery/blob/v0.19.0/pkg/apis/meta/v1/types.go#L1353-L1413.
-type Condition struct {
-	// 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)
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation: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])$`
-	// +kubebuilder:validation:MaxLength=316
-	Type string `json:"type"`
-
-	// status of the condition, one of True, False, Unknown.
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation:Enum=True;False;Unknown
-	Status ConditionStatus `json:"status"`
-
-	// 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.
-	// +optional
-	// +kubebuilder:validation:Minimum=0
-	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
-
-	// 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.
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation:Type=string
-	// +kubebuilder:validation:Format=date-time
-	LastTransitionTime metav1.Time `json:"lastTransitionTime"`
-
-	// 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.
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation:MaxLength=1024
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:Pattern=`^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$`
-	Reason string `json:"reason"`
-
-	// message is a human readable message indicating details about the transition.
-	// This may be an empty string.
-	// +required
-	// +kubebuilder:validation:Required
-	// +kubebuilder:validation:MaxLength=32768
-	Message string `json:"message"`
-}

apis/supervisor/idp/v1alpha1/types_oidcidentityprovider.go.tmpl

@@ -1,123 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type OIDCIdentityProviderPhase string
-
-const (
-	// PhasePending is the default phase for newly-created OIDCIdentityProvider resources.
-	PhasePending OIDCIdentityProviderPhase = "Pending"
-
-	// PhaseReady is the phase for an OIDCIdentityProvider resource in a healthy state.
-	PhaseReady OIDCIdentityProviderPhase = "Ready"
-
-	// PhaseError is the phase for an OIDCIdentityProvider in an unhealthy state.
-	PhaseError OIDCIdentityProviderPhase = "Error"
-)
-
-// Status of an OIDC identity provider.
-type OIDCIdentityProviderStatus struct {
-	// Phase summarizes the overall status of the OIDCIdentityProvider.
-	// +kubebuilder:default=Pending
-	// +kubebuilder:validation:Enum=Pending;Ready;Error
-	Phase OIDCIdentityProviderPhase `json:"phase,omitempty"`
-
-	// Represents the observations of an identity provider's current state.
-	// +patchMergeKey=type
-	// +patchStrategy=merge
-	// +listType=map
-	// +listMapKey=type
-	Conditions []Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
-}
-
-// OIDCAuthorizationConfig provides information about how to form the OAuth2 authorization
-// request parameters.
-type OIDCAuthorizationConfig struct {
-	// AdditionalScopes are the scopes in addition to "openid" that will be requested as part of the authorization
-	// request flow with an OIDC identity provider. By default only the "openid" scope will be requested.
-	// +optional
-	AdditionalScopes []string `json:"additionalScopes,omitempty"`
-}
-
-// OIDCClaims provides a mapping from upstream claims into identities.
-type OIDCClaims struct {
-	// Groups provides the name of the token claim that will be used to ascertain the groups to which
-	// an identity belongs.
-	// +optional
-	Groups string `json:"groups"`
-
-	// Username provides the name of the token claim that will be used to ascertain an identity's
-	// username.
-	// +optional
-	Username string `json:"username"`
-}
-
-// OIDCClient contains information about an OIDC client (e.g., client ID and client
-// secret).
-type OIDCClient struct {
-	// SecretName contains the name of a namespace-local Secret object that provides the clientID and
-	// clientSecret for an OIDC client. If only the SecretName is specified in an OIDCClient
-	// struct, then it is expected that the Secret is of type "secrets.pinniped.dev/oidc-client" with keys
-	// "clientID" and "clientSecret".
-	SecretName string `json:"secretName"`
-}
-
-// Spec for configuring an OIDC identity provider.
-type OIDCIdentityProviderSpec struct {
-	// Issuer is the issuer URL of this OIDC identity provider, i.e., where to fetch
-	// /.well-known/openid-configuration.
-	// +kubebuilder:validation:MinLength=1
-	// +kubebuilder:validation:Pattern=`^https://`
-	Issuer string `json:"issuer"`
-
-	// TLS configuration for discovery/JWKS requests to the issuer.
-	// +optional
-	TLS *TLSSpec `json:"tls,omitempty"`
-
-	// AuthorizationConfig holds information about how to form the OAuth2 authorization request
-	// parameters to be used with this OIDC identity provider.
-	// +optional
-	AuthorizationConfig OIDCAuthorizationConfig `json:"authorizationConfig,omitempty"`
-
-	// Claims provides the names of token claims that will be used when inspecting an identity from
-	// this OIDC identity provider.
-	// +optional
-	Claims OIDCClaims `json:"claims"`
-
-	// OIDCClient contains OIDC client information to be used used with this OIDC identity
-	// provider.
-	Client OIDCClient `json:"client"`
-}
-
-// OIDCIdentityProvider describes the configuration of an upstream OpenID Connect identity provider.
-// +genclient
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +kubebuilder:resource:categories=pinniped;pinniped-idp;pinniped-idps
-// +kubebuilder:printcolumn:name="Issuer",type=string,JSONPath=`.spec.issuer`
-// +kubebuilder:printcolumn:name="Status",type=string,JSONPath=`.status.phase`
-// +kubebuilder:printcolumn:name="Age",type=date,JSONPath=`.metadata.creationTimestamp`
-// +kubebuilder:subresource:status
-type OIDCIdentityProvider struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	// Spec for configuring the identity provider.
-	Spec OIDCIdentityProviderSpec `json:"spec"`
-
-	// Status of the identity provider.
-	Status OIDCIdentityProviderStatus `json:"status,omitempty"`
-}
-
-// List of OIDCIdentityProvider objects.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type OIDCIdentityProviderList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-
-	Items []OIDCIdentityProvider `json:"items"`
-}

apis/supervisor/idp/v1alpha1/types_tls.go.tmpl

@@ -1,11 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package v1alpha1
-
-// Configuration for TLS parameters related to identity provider integration.
-type TLSSpec struct {
-	// X.509 Certificate Authority (base64-encoded PEM bundle). If omitted, a default set of system roots will be trusted.
-	// +optional
-	CertificateAuthorityData string `json:"certificateAuthorityData,omitempty"`
-}

cmd/local-user-authenticator/main.go

@@ -1,390 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-// Package main provides a authentication webhook program.
-//
-// This webhook is meant to be used in demo settings to play around with
-// Pinniped. As well, it can come in handy in integration tests.
-//
-// This webhook is NOT meant for use in production systems.
-package main
-
-import (
-	"bytes"
-	"context"
-	"crypto/tls"
-	"encoding/csv"
-	"encoding/json"
-	"fmt"
-	"mime"
-	"net"
-	"net/http"
-	"os"
-	"os/signal"
-	"strings"
-	"time"
-
-	"golang.org/x/crypto/bcrypt"
-	authenticationv1beta1 "k8s.io/api/authentication/v1beta1"
-	k8serrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	kubeinformers "k8s.io/client-go/informers"
-	corev1informers "k8s.io/client-go/informers/core/v1"
-	"k8s.io/client-go/kubernetes"
-	"k8s.io/klog/v2"
-
-	"go.pinniped.dev/internal/constable"
-	"go.pinniped.dev/internal/controller/apicerts"
-	"go.pinniped.dev/internal/controllerlib"
-	"go.pinniped.dev/internal/dynamiccert"
-	"go.pinniped.dev/internal/kubeclient"
-	"go.pinniped.dev/internal/plog"
-)
-
-const (
-	// This string must match the name of the Namespace declared in the deployment yaml.
-	namespace = "local-user-authenticator"
-	// This string must match the name of the Service declared in the deployment yaml.
-	serviceName = "local-user-authenticator"
-
-	singletonWorker       = 1
-	defaultResyncInterval = 3 * time.Minute
-
-	invalidRequest = constable.Error("invalid request")
-)
-
-type webhook struct {
-	certProvider   dynamiccert.Private
-	secretInformer corev1informers.SecretInformer
-}
-
-func newWebhook(
-	certProvider dynamiccert.Private,
-	secretInformer corev1informers.SecretInformer,
-) *webhook {
-	return &webhook{
-		certProvider:   certProvider,
-		secretInformer: secretInformer,
-	}
-}
-
-// start runs the webhook in a separate goroutine and returns whether or not the
-// webhook was started successfully.
-func (w *webhook) start(ctx context.Context, l net.Listener) error {
-	server := http.Server{
-		Handler: w,
-		TLSConfig: &tls.Config{
-			MinVersion: tls.VersionTLS13,
-			GetCertificate: func(_ *tls.ClientHelloInfo) (*tls.Certificate, error) {
-				certPEM, keyPEM := w.certProvider.CurrentCertKeyContent()
-				cert, err := tls.X509KeyPair(certPEM, keyPEM)
-				return &cert, err
-			},
-		},
-	}
-
-	errCh := make(chan error)
-	go func() {
-		// Per ListenAndServeTLS doc, the {cert,key}File parameters can be empty
-		// since we want to use the certs from http.Server.TLSConfig.
-		errCh <- server.ServeTLS(l, "", "")
-	}()
-
-	go func() {
-		select {
-		case err := <-errCh:
-			plog.Debug("server exited", "err", err)
-		case <-ctx.Done():
-			plog.Debug("server context cancelled", "err", ctx.Err())
-			if err := server.Shutdown(context.Background()); err != nil {
-				plog.Debug("server shutdown failed", "err", err)
-			}
-		}
-	}()
-
-	return nil
-}
-
-func (w *webhook) ServeHTTP(rsp http.ResponseWriter, req *http.Request) {
-	username, password, err := getUsernameAndPasswordFromRequest(rsp, req)
-	if err != nil {
-		return
-	}
-	defer func() { _ = req.Body.Close() }()
-
-	secret, err := w.secretInformer.Lister().Secrets(namespace).Get(username)
-	notFound := k8serrors.IsNotFound(err)
-	if err != nil && !notFound {
-		plog.Debug("could not get secret", "err", err)
-		rsp.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-
-	if notFound {
-		plog.Debug("user not found")
-		respondWithUnauthenticated(rsp)
-		return
-	}
-
-	passwordMatches := bcrypt.CompareHashAndPassword(
-		secret.Data["passwordHash"],
-		[]byte(password),
-	) == nil
-	if !passwordMatches {
-		plog.Debug("authentication failed: wrong password")
-		respondWithUnauthenticated(rsp)
-		return
-	}
-
-	groups := []string{}
-	groupsBuf := bytes.NewBuffer(secret.Data["groups"])
-	if groupsBuf.Len() > 0 {
-		groupsCSVReader := csv.NewReader(groupsBuf)
-		groups, err = groupsCSVReader.Read()
-		if err != nil {
-			plog.Debug("could not read groups", "err", err)
-			rsp.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-		trimLeadingAndTrailingWhitespace(groups)
-	}
-
-	plog.Debug("successful authentication")
-	respondWithAuthenticated(rsp, secret.ObjectMeta.Name, groups)
-}
-
-func getUsernameAndPasswordFromRequest(rsp http.ResponseWriter, req *http.Request) (string, string, error) {
-	if req.URL.Path != "/authenticate" {
-		plog.Debug("received request path other than /authenticate", "path", req.URL.Path)
-		rsp.WriteHeader(http.StatusNotFound)
-		return "", "", invalidRequest
-	}
-
-	if req.Method != http.MethodPost {
-		plog.Debug("received request method other than post", "method", req.Method)
-		rsp.WriteHeader(http.StatusMethodNotAllowed)
-		return "", "", invalidRequest
-	}
-
-	if !headerContains(req, "Content-Type", "application/json") {
-		plog.Debug("content type is not application/json", "Content-Type", req.Header.Values("Content-Type"))
-		rsp.WriteHeader(http.StatusUnsupportedMediaType)
-		return "", "", invalidRequest
-	}
-
-	if !headerContains(req, "Accept", "application/json") &&
-		!headerContains(req, "Accept", "application/*") &&
-		!headerContains(req, "Accept", "*/*") {
-		plog.Debug("client does not accept application/json", "Accept", req.Header.Values("Accept"))
-		rsp.WriteHeader(http.StatusUnsupportedMediaType)
-		return "", "", invalidRequest
-	}
-
-	if req.Body == nil {
-		plog.Debug("invalid nil body")
-		rsp.WriteHeader(http.StatusBadRequest)
-		return "", "", invalidRequest
-	}
-
-	var body authenticationv1beta1.TokenReview
-	if err := json.NewDecoder(req.Body).Decode(&body); err != nil {
-		plog.Debug("failed to decode body", "err", err)
-		rsp.WriteHeader(http.StatusBadRequest)
-		return "", "", invalidRequest
-	}
-
-	if body.APIVersion != authenticationv1beta1.SchemeGroupVersion.String() {
-		plog.Debug("invalid TokenReview apiVersion", "apiVersion", body.APIVersion)
-		rsp.WriteHeader(http.StatusBadRequest)
-		return "", "", invalidRequest
-	}
-
-	if body.Kind != "TokenReview" {
-		plog.Debug("invalid TokenReview kind", "kind", body.Kind)
-		rsp.WriteHeader(http.StatusBadRequest)
-		return "", "", invalidRequest
-	}
-
-	tokenSegments := strings.SplitN(body.Spec.Token, ":", 2)
-	if len(tokenSegments) != 2 {
-		plog.Debug("bad token format in request")
-		rsp.WriteHeader(http.StatusBadRequest)
-		return "", "", invalidRequest
-	}
-
-	return tokenSegments[0], tokenSegments[1], nil
-}
-
-func headerContains(req *http.Request, headerName, s string) bool {
-	headerValues := req.Header.Values(headerName)
-	for i := range headerValues {
-		mimeTypes := strings.Split(headerValues[i], ",")
-		for _, mimeType := range mimeTypes {
-			mediaType, _, _ := mime.ParseMediaType(mimeType)
-			if mediaType == s {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func trimLeadingAndTrailingWhitespace(ss []string) {
-	for i := range ss {
-		ss[i] = strings.TrimSpace(ss[i])
-	}
-}
-
-func respondWithUnauthenticated(rsp http.ResponseWriter) {
-	rsp.Header().Add("Content-Type", "application/json")
-
-	body := authenticationv1beta1.TokenReview{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "TokenReview",
-			APIVersion: authenticationv1beta1.SchemeGroupVersion.String(),
-		},
-		Status: authenticationv1beta1.TokenReviewStatus{
-			Authenticated: false,
-		},
-	}
-	if err := json.NewEncoder(rsp).Encode(body); err != nil {
-		plog.Debug("could not encode response", "err", err)
-		rsp.WriteHeader(http.StatusInternalServerError)
-	}
-}
-
-func respondWithAuthenticated(
-	rsp http.ResponseWriter,
-	username string,
-	groups []string,
-) {
-	rsp.Header().Add("Content-Type", "application/json")
-	body := authenticationv1beta1.TokenReview{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "TokenReview",
-			APIVersion: authenticationv1beta1.SchemeGroupVersion.String(),
-		},
-		Status: authenticationv1beta1.TokenReviewStatus{
-			Authenticated: true,
-			User: authenticationv1beta1.UserInfo{
-				Username: username,
-				Groups:   groups,
-			},
-		},
-	}
-	if err := json.NewEncoder(rsp).Encode(body); err != nil {
-		plog.Debug("could not encode response", "err", err)
-		rsp.WriteHeader(http.StatusInternalServerError)
-	}
-}
-
-func startControllers(
-	ctx context.Context,
-	dynamicCertProvider dynamiccert.Private,
-	kubeClient kubernetes.Interface,
-	kubeInformers kubeinformers.SharedInformerFactory,
-) {
-	aVeryLongTime := time.Hour * 24 * 365 * 100
-
-	const certsSecretResourceName = "local-user-authenticator-tls-serving-certificate"
-
-	// Create controller manager.
-	controllerManager := controllerlib.
-		NewManager().
-		WithController(
-			apicerts.NewCertsManagerController(
-				namespace,
-				certsSecretResourceName,
-				map[string]string{
-					"app": "local-user-authenticator",
-				},
-				kubeClient,
-				kubeInformers.Core().V1().Secrets(),
-				controllerlib.WithInformer,
-				controllerlib.WithInitialEvent,
-				aVeryLongTime,
-				"local-user-authenticator CA",
-				serviceName,
-			),
-			singletonWorker,
-		).
-		WithController(
-			apicerts.NewCertsObserverController(
-				namespace,
-				certsSecretResourceName,
-				dynamicCertProvider,
-				kubeInformers.Core().V1().Secrets(),
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		)
-
-	kubeInformers.Start(ctx.Done())
-
-	go controllerManager.Start(ctx)
-}
-
-func startWebhook(
-	ctx context.Context,
-	l net.Listener,
-	dynamicCertProvider dynamiccert.Private,
-	secretInformer corev1informers.SecretInformer,
-) error {
-	return newWebhook(dynamicCertProvider, secretInformer).start(ctx, l)
-}
-
-func waitForSignal() os.Signal {
-	signalCh := make(chan os.Signal, 1)
-	signal.Notify(signalCh, os.Interrupt)
-	return <-signalCh
-}
-
-func run() error {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	client, err := kubeclient.New()
-	if err != nil {
-		return fmt.Errorf("cannot create k8s client: %w", err)
-	}
-
-	kubeInformers := kubeinformers.NewSharedInformerFactoryWithOptions(
-		client.Kubernetes,
-		defaultResyncInterval,
-		kubeinformers.WithNamespace(namespace),
-	)
-
-	dynamicCertProvider := dynamiccert.NewServingCert("local-user-authenticator-tls-serving-certificate")
-
-	startControllers(ctx, dynamicCertProvider, client.Kubernetes, kubeInformers)
-	plog.Debug("controllers are ready")
-
-	//nolint: gosec // Intentionally binding to all network interfaces.
-	l, err := net.Listen("tcp", ":8443")
-	if err != nil {
-		return fmt.Errorf("cannot create listener: %w", err)
-	}
-	defer func() { _ = l.Close() }()
-
-	err = startWebhook(ctx, l, dynamicCertProvider, kubeInformers.Core().V1().Secrets())
-	if err != nil {
-		return fmt.Errorf("cannot start webhook: %w", err)
-	}
-	plog.Debug("webhook is ready", "address", l.Addr().String())
-
-	gotSignal := waitForSignal()
-	plog.Debug("webhook exiting", "signal", gotSignal)
-
-	return nil
-}
-
-func main() {
-	// Hardcode the logging level to debug, since this is a test app and it is very helpful to have
-	// verbose logs to debug test failures.
-	if err := plog.ValidateAndSetLogLevelGlobally(plog.LevelDebug); err != nil {
-		klog.Fatal(err)
-	}
-	if err := run(); err != nil {
-		klog.Fatal(err)
-	}
-}

cmd/local-user-authenticator/main_test.go

@@ -1,567 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package main
-
-import (
-	"bytes"
-	"context"
-	"crypto/tls"
-	"crypto/x509"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/url"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-	"golang.org/x/crypto/bcrypt"
-	authenticationv1beta1 "k8s.io/api/authentication/v1beta1"
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	kubeinformers "k8s.io/client-go/informers"
-	corev1informers "k8s.io/client-go/informers/core/v1"
-	"k8s.io/client-go/kubernetes"
-	kubernetesfake "k8s.io/client-go/kubernetes/fake"
-
-	"go.pinniped.dev/internal/certauthority"
-	"go.pinniped.dev/internal/dynamiccert"
-)
-
-func TestWebhook(t *testing.T) {
-	t.Parallel()
-
-	const namespace = "local-user-authenticator"
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	user, otherUser, colonUser, noGroupUser, oneGroupUser, passwordUndefinedUser, emptyPasswordUser, invalidPasswordHashUser, undefinedGroupsUser :=
-		"some-user", "other-user", "colon-user", "no-group-user", "one-group-user", "password-undefined-user", "empty-password-user", "invalid-password-hash-user", "undefined-groups-user"
-	password, otherPassword, colonPassword, noGroupPassword, oneGroupPassword, undefinedGroupsPassword :=
-		"some-password", "other-password", "some-:-password", "no-group-password", "one-group-password", "undefined-groups-password"
-
-	group0, group1 := "some-group-0", "some-group-1"
-	groups := group0 + " , " + group1
-
-	kubeClient := kubernetesfake.NewSimpleClientset()
-	addSecretToFakeClientTracker(t, kubeClient, user, password, groups)
-	addSecretToFakeClientTracker(t, kubeClient, otherUser, otherPassword, groups)
-	addSecretToFakeClientTracker(t, kubeClient, colonUser, colonPassword, groups)
-	addSecretToFakeClientTracker(t, kubeClient, noGroupUser, noGroupPassword, "")
-	addSecretToFakeClientTracker(t, kubeClient, oneGroupUser, oneGroupPassword, group0)
-	addSecretToFakeClientTracker(t, kubeClient, emptyPasswordUser, "", groups)
-
-	require.NoError(t, kubeClient.Tracker().Add(&corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      passwordUndefinedUser,
-			Namespace: namespace,
-		},
-		Data: map[string][]byte{
-			"groups": []byte(groups),
-		},
-	}))
-
-	undefinedGroupsUserPasswordHash, err := bcrypt.GenerateFromPassword([]byte(undefinedGroupsPassword), bcrypt.MinCost)
-	require.NoError(t, err)
-
-	require.NoError(t, kubeClient.Tracker().Add(&corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      undefinedGroupsUser,
-			Namespace: namespace,
-		},
-		Data: map[string][]byte{
-			"passwordHash": undefinedGroupsUserPasswordHash,
-		},
-	}))
-
-	require.NoError(t, kubeClient.Tracker().Add(&corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      invalidPasswordHashUser,
-			Namespace: namespace,
-		},
-		Data: map[string][]byte{
-			"groups":       []byte(groups),
-			"passwordHash": []byte("not a valid password hash"),
-		},
-	}))
-
-	secretInformer := createSecretInformer(ctx, t, kubeClient)
-
-	certProvider, caBundle, serverName := newCertProvider(t)
-	w := newWebhook(certProvider, secretInformer)
-
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	require.NoError(t, err)
-	defer func() { _ = l.Close() }()
-	require.NoError(t, w.start(ctx, l))
-
-	client := newClient(caBundle, serverName)
-
-	goodURL := fmt.Sprintf("https://%s/authenticate", l.Addr().String())
-	goodRequestHeaders := map[string][]string{
-		"Content-Type": {"application/json; charset=UTF-8"},
-		"Accept":       {"application/json, */*"},
-	}
-
-	tests := []struct {
-		name    string
-		url     string
-		method  string
-		headers map[string][]string
-		body    func() (io.ReadCloser, error)
-
-		wantStatus  int
-		wantHeaders map[string][]string
-		wantBody    *authenticationv1beta1.TokenReview
-	}{
-		{
-			name:        "success for a user who belongs to multiple groups",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(user + ":" + password) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    authenticatedResponseJSON(user, []string{group0, group1}),
-		},
-		{
-			name:        "success for a user who belongs to one groups",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(oneGroupUser + ":" + oneGroupPassword) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    authenticatedResponseJSON(oneGroupUser, []string{group0}),
-		},
-		{
-			name:        "success for a user who belongs to no groups",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(noGroupUser + ":" + noGroupPassword) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    authenticatedResponseJSON(noGroupUser, nil),
-		},
-		{
-			name:        "wrong username for password",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(otherUser + ":" + password) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    unauthenticatedResponseJSON(),
-		},
-		{
-			name:        "when a user has no password hash in the secret",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(passwordUndefinedUser + ":foo") },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    unauthenticatedResponseJSON(),
-		},
-		{
-			name:        "when a user has an invalid password hash in the secret",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(invalidPasswordHashUser + ":foo") },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    unauthenticatedResponseJSON(),
-		},
-		{
-			name:    "success for a user has no groups defined in the secret",
-			url:     goodURL,
-			method:  http.MethodPost,
-			headers: goodRequestHeaders,
-			body: func() (io.ReadCloser, error) {
-				return newTokenReviewBody(undefinedGroupsUser + ":" + undefinedGroupsPassword)
-			},
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    authenticatedResponseJSON(undefinedGroupsUser, nil),
-		},
-		{
-			name:        "when a user has empty string as their password",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(passwordUndefinedUser + ":foo") },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    unauthenticatedResponseJSON(),
-		},
-		{
-			name:        "wrong password for username",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(user + ":" + otherPassword) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    unauthenticatedResponseJSON(),
-		},
-		{
-			name:        "non-existent password for username",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(user + ":" + "some-non-existent-password") },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    unauthenticatedResponseJSON(),
-		},
-		{
-			name:        "non-existent username",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody("some-non-existent-user" + ":" + password) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    unauthenticatedResponseJSON(),
-		},
-		{
-			name:       "bad token format (missing colon)",
-			url:        goodURL,
-			method:     http.MethodPost,
-			headers:    goodRequestHeaders,
-			body:       func() (io.ReadCloser, error) { return newTokenReviewBody(user) },
-			wantStatus: http.StatusBadRequest,
-		},
-		{
-			name:        "password contains colon",
-			url:         goodURL,
-			method:      http.MethodPost,
-			headers:     goodRequestHeaders,
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(colonUser + ":" + colonPassword) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    authenticatedResponseJSON(colonUser, []string{group0, group1}),
-		},
-		{
-			name:    "bad TokenReview group",
-			url:     goodURL,
-			method:  http.MethodPost,
-			headers: goodRequestHeaders,
-			body: func() (io.ReadCloser, error) {
-				return newTokenReviewBodyWithGVK(
-					user+":"+password,
-					&schema.GroupVersionKind{
-						Group:   "bad group",
-						Version: authenticationv1beta1.SchemeGroupVersion.Version,
-						Kind:    "TokenReview",
-					},
-				)
-			},
-			wantStatus: http.StatusBadRequest,
-		},
-		{
-			name:    "bad TokenReview version",
-			url:     goodURL,
-			method:  http.MethodPost,
-			headers: goodRequestHeaders,
-			body: func() (io.ReadCloser, error) {
-				return newTokenReviewBodyWithGVK(
-					user+":"+password,
-					&schema.GroupVersionKind{
-						Group:   authenticationv1beta1.SchemeGroupVersion.Group,
-						Version: "bad version",
-						Kind:    "TokenReview",
-					},
-				)
-			},
-			wantStatus: http.StatusBadRequest,
-		},
-		{
-			name:    "bad TokenReview kind",
-			url:     goodURL,
-			method:  http.MethodPost,
-			headers: goodRequestHeaders,
-			body: func() (io.ReadCloser, error) {
-				return newTokenReviewBodyWithGVK(
-					user+":"+password,
-					&schema.GroupVersionKind{
-						Group:   authenticationv1beta1.SchemeGroupVersion.Group,
-						Version: authenticationv1beta1.SchemeGroupVersion.Version,
-						Kind:    "wrong-kind",
-					},
-				)
-			},
-			wantStatus: http.StatusBadRequest,
-		},
-		{
-			name:       "bad path",
-			url:        fmt.Sprintf("https://%s/tuna", l.Addr().String()),
-			method:     http.MethodPost,
-			headers:    goodRequestHeaders,
-			body:       func() (io.ReadCloser, error) { return newTokenReviewBody("some-token") },
-			wantStatus: http.StatusNotFound,
-		},
-		{
-			name:       "bad method",
-			url:        goodURL,
-			method:     http.MethodGet,
-			headers:    goodRequestHeaders,
-			body:       func() (io.ReadCloser, error) { return newTokenReviewBody("some-token") },
-			wantStatus: http.StatusMethodNotAllowed,
-		},
-		{
-			name:   "bad content type",
-			url:    goodURL,
-			method: http.MethodPost,
-			headers: map[string][]string{
-				"Content-Type": {"application/xml"},
-				"Accept":       {"application/json"},
-			},
-			body:       func() (io.ReadCloser, error) { return newTokenReviewBody("some-token") },
-			wantStatus: http.StatusUnsupportedMediaType,
-		},
-		{
-			name:   "bad accept",
-			url:    goodURL,
-			method: http.MethodPost,
-			headers: map[string][]string{
-				"Content-Type": {"application/json"},
-				"Accept":       {"application/xml"},
-			},
-			body:       func() (io.ReadCloser, error) { return newTokenReviewBody("some-token") },
-			wantStatus: http.StatusUnsupportedMediaType,
-		},
-		{
-			name:   "success when there are multiple accepts and one of them is json",
-			url:    goodURL,
-			method: http.MethodPost,
-			headers: map[string][]string{
-				"Content-Type": {"application/json"},
-				"Accept":       {"something/else, application/xml, application/json"},
-			},
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(user + ":" + password) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    authenticatedResponseJSON(user, []string{group0, group1}),
-		},
-		{
-			name:   "success when there are multiple accepts and one of them is */*",
-			url:    goodURL,
-			method: http.MethodPost,
-			headers: map[string][]string{
-				"Content-Type": {"application/json"},
-				"Accept":       {"something/else, */*, application/foo"},
-			},
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(user + ":" + password) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    authenticatedResponseJSON(user, []string{group0, group1}),
-		},
-		{
-			name:   "success when there are multiple accepts and one of them is application/*",
-			url:    goodURL,
-			method: http.MethodPost,
-			headers: map[string][]string{
-				"Content-Type": {"application/json"},
-				"Accept":       {"something/else, application/*, application/foo"},
-			},
-			body:        func() (io.ReadCloser, error) { return newTokenReviewBody(user + ":" + password) },
-			wantStatus:  http.StatusOK,
-			wantHeaders: map[string][]string{"Content-Type": {"application/json"}},
-			wantBody:    authenticatedResponseJSON(user, []string{group0, group1}),
-		},
-		{
-			name:       "bad body",
-			url:        goodURL,
-			method:     http.MethodPost,
-			headers:    goodRequestHeaders,
-			body:       func() (io.ReadCloser, error) { return ioutil.NopCloser(bytes.NewBuffer([]byte("invalid body"))), nil },
-			wantStatus: http.StatusBadRequest,
-		},
-	}
-
-	for _, test := range tests {
-		test := test
-		t.Run(test.name, func(t *testing.T) {
-			parsedURL, err := url.Parse(test.url)
-			require.NoError(t, err)
-
-			body, err := test.body()
-			require.NoError(t, err)
-
-			rsp, err := client.Do(&http.Request{
-				Method: test.method,
-				URL:    parsedURL,
-				Header: test.headers,
-				Body:   body,
-			})
-			require.NoError(t, err)
-			defer func() { _ = rsp.Body.Close() }()
-
-			require.Equal(t, test.wantStatus, rsp.StatusCode)
-
-			if test.wantHeaders != nil {
-				for k, v := range test.wantHeaders {
-					require.Equal(t, v, rsp.Header.Values(k))
-				}
-			}
-
-			responseBody, err := ioutil.ReadAll(rsp.Body)
-			require.NoError(t, err)
-			if test.wantBody != nil {
-				require.NoError(t, err)
-
-				var tr authenticationv1beta1.TokenReview
-				require.NoError(t, json.Unmarshal(responseBody, &tr))
-				require.Equal(t, test.wantBody, &tr)
-			} else {
-				require.Empty(t, responseBody)
-			}
-		})
-	}
-}
-
-func createSecretInformer(ctx context.Context, t *testing.T, kubeClient kubernetes.Interface) corev1informers.SecretInformer {
-	t.Helper()
-
-	kubeInformers := kubeinformers.NewSharedInformerFactory(kubeClient, 0)
-
-	secretInformer := kubeInformers.Core().V1().Secrets()
-
-	// We need to call Informer() on the secretInformer to lazily instantiate the
-	// informer factory before syncing it.
-	secretInformer.Informer()
-
-	kubeInformers.Start(ctx.Done())
-
-	informerTypesSynced := kubeInformers.WaitForCacheSync(ctx.Done())
-	require.True(t, informerTypesSynced[reflect.TypeOf(&corev1.Secret{})])
-
-	return secretInformer
-}
-
-// newClientProvider returns a dynamiccert.Provider configured
-// with valid serving cert, the CA bundle that can be used to verify the serving
-// cert, and the server name that can be used to verify the TLS peer.
-func newCertProvider(t *testing.T) (dynamiccert.Private, []byte, string) {
-	t.Helper()
-
-	serverName := "local-user-authenticator"
-
-	ca, err := certauthority.New(serverName+" CA", time.Hour*24)
-	require.NoError(t, err)
-
-	cert, err := ca.IssueServerCert([]string{serverName}, nil, time.Hour*24)
-	require.NoError(t, err)
-
-	certPEM, keyPEM, err := certauthority.ToPEM(cert)
-	require.NoError(t, err)
-
-	certProvider := dynamiccert.NewServingCert(t.Name())
-	err = certProvider.SetCertKeyContent(certPEM, keyPEM)
-	require.NoError(t, err)
-
-	return certProvider, ca.Bundle(), serverName
-}
-
-// newClient creates an http.Client that can be used to make an HTTPS call to a
-// service whose serving certs can be verified by the provided CA bundle.
-func newClient(caBundle []byte, serverName string) *http.Client {
-	rootCAs := x509.NewCertPool()
-	rootCAs.AppendCertsFromPEM(caBundle)
-	return &http.Client{
-		Transport: &http.Transport{
-			TLSClientConfig: &tls.Config{
-				MinVersion: tls.VersionTLS13,
-				RootCAs:    rootCAs,
-				ServerName: serverName,
-			},
-		},
-	}
-}
-
-// newTokenReviewBody creates an io.ReadCloser that contains a JSON-encodeed
-// TokenReview request with expected APIVersion and Kind fields.
-func newTokenReviewBody(token string) (io.ReadCloser, error) {
-	return newTokenReviewBodyWithGVK(
-		token,
-		&schema.GroupVersionKind{
-			Group:   authenticationv1beta1.SchemeGroupVersion.Group,
-			Version: authenticationv1beta1.SchemeGroupVersion.Version,
-			Kind:    "TokenReview",
-		},
-	)
-}
-
-// newTokenReviewBodyWithGVK creates an io.ReadCloser that contains a
-// JSON-encoded TokenReview request. The TypeMeta fields of the TokenReview are
-// filled in with the provided gvk.
-func newTokenReviewBodyWithGVK(token string, gvk *schema.GroupVersionKind) (io.ReadCloser, error) {
-	buf := bytes.NewBuffer([]byte{})
-	tr := authenticationv1beta1.TokenReview{
-		TypeMeta: metav1.TypeMeta{
-			APIVersion: gvk.GroupVersion().String(),
-			Kind:       gvk.Kind,
-		},
-		Spec: authenticationv1beta1.TokenReviewSpec{
-			Token: token,
-		},
-	}
-	err := json.NewEncoder(buf).Encode(&tr)
-	return ioutil.NopCloser(buf), err
-}
-
-func unauthenticatedResponseJSON() *authenticationv1beta1.TokenReview {
-	return &authenticationv1beta1.TokenReview{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "TokenReview",
-			APIVersion: "authentication.k8s.io/v1beta1",
-		},
-		Status: authenticationv1beta1.TokenReviewStatus{
-			Authenticated: false,
-		},
-	}
-}
-
-func authenticatedResponseJSON(user string, groups []string) *authenticationv1beta1.TokenReview {
-	return &authenticationv1beta1.TokenReview{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "TokenReview",
-			APIVersion: "authentication.k8s.io/v1beta1",
-		},
-		Status: authenticationv1beta1.TokenReviewStatus{
-			Authenticated: true,
-			User: authenticationv1beta1.UserInfo{
-				Username: user,
-				Groups:   groups,
-			},
-		},
-	}
-}
-
-func addSecretToFakeClientTracker(t *testing.T, kubeClient *kubernetesfake.Clientset, username, password, groups string) {
-	passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.MinCost)
-	require.NoError(t, err)
-
-	secret := &corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      username,
-			Namespace: namespace,
-		},
-		Data: map[string][]byte{
-			"passwordHash": passwordHash,
-			"groups":       []byte(groups),
-		},
-	}
-
-	require.NoError(t, kubeClient.Tracker().Add(secret))
-}

cmd/pinniped-concierge/main.go

@@ -1,35 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package main
-
-import (
-	"os"
-	"time"
-
-	genericapiserver "k8s.io/apiserver/pkg/server"
-	"k8s.io/client-go/pkg/version"
-	"k8s.io/client-go/rest"
-	"k8s.io/component-base/logs"
-	"k8s.io/klog/v2"
-
-	"go.pinniped.dev/internal/concierge/server"
-)
-
-func main() {
-	logs.InitLogs()
-	defer logs.FlushLogs()
-
-	// Dump out the time since compile (mostly useful for benchmarking our local development cycle latency).
-	var timeSinceCompile time.Duration
-	if buildDate, err := time.Parse(time.RFC3339, version.Get().BuildDate); err == nil {
-		timeSinceCompile = time.Since(buildDate).Round(time.Second)
-	}
-	klog.Infof("Running %s at %#v (%s since build)", rest.DefaultKubernetesUserAgent(), version.Get(), timeSinceCompile)
-
-	ctx := genericapiserver.SetupSignalContext()
-
-	if err := server.New(ctx, os.Args[1:], os.Stdout, os.Stderr).Run(); err != nil {
-		klog.Fatal(err)
-	}
-}

cmd/pinniped-supervisor/main.go

@@ -1,397 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package main
-
-import (
-	"context"
-	"crypto/rand"
-	"crypto/tls"
-	"fmt"
-	"net"
-	"net/http"
-	"os"
-	"os/signal"
-	"strings"
-	"time"
-
-	appsv1 "k8s.io/api/apps/v1"
-	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/util/clock"
-	kubeinformers "k8s.io/client-go/informers"
-	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/pkg/version"
-	"k8s.io/client-go/rest"
-	"k8s.io/component-base/logs"
-	"k8s.io/klog/v2"
-	"k8s.io/klog/v2/klogr"
-
-	configv1alpha1 "go.pinniped.dev/generated/latest/apis/supervisor/config/v1alpha1"
-	pinnipedclientset "go.pinniped.dev/generated/latest/client/supervisor/clientset/versioned"
-	pinnipedinformers "go.pinniped.dev/generated/latest/client/supervisor/informers/externalversions"
-	"go.pinniped.dev/internal/config/supervisor"
-	"go.pinniped.dev/internal/controller/supervisorconfig"
-	"go.pinniped.dev/internal/controller/supervisorconfig/generator"
-	"go.pinniped.dev/internal/controller/supervisorconfig/ldapupstreamwatcher"
-	"go.pinniped.dev/internal/controller/supervisorconfig/oidcupstreamwatcher"
-	"go.pinniped.dev/internal/controller/supervisorstorage"
-	"go.pinniped.dev/internal/controllerlib"
-	"go.pinniped.dev/internal/deploymentref"
-	"go.pinniped.dev/internal/downward"
-	"go.pinniped.dev/internal/groupsuffix"
-	"go.pinniped.dev/internal/kubeclient"
-	"go.pinniped.dev/internal/oidc/jwks"
-	"go.pinniped.dev/internal/oidc/provider"
-	"go.pinniped.dev/internal/oidc/provider/manager"
-	"go.pinniped.dev/internal/plog"
-	"go.pinniped.dev/internal/secret"
-)
-
-const (
-	singletonWorker       = 1
-	defaultResyncInterval = 3 * time.Minute
-)
-
-func start(ctx context.Context, l net.Listener, handler http.Handler) {
-	server := http.Server{Handler: handler}
-
-	errCh := make(chan error)
-	go func() {
-		errCh <- server.Serve(l)
-	}()
-
-	go func() {
-		select {
-		case err := <-errCh:
-			plog.Debug("server exited", "err", err)
-		case <-ctx.Done():
-			plog.Debug("server context cancelled", "err", ctx.Err())
-			if err := server.Shutdown(context.Background()); err != nil {
-				plog.Debug("server shutdown failed", "err", err)
-			}
-		}
-	}()
-}
-
-func waitForSignal() os.Signal {
-	signalCh := make(chan os.Signal, 1)
-	signal.Notify(signalCh, os.Interrupt)
-	return <-signalCh
-}
-
-//nolint:funlen
-func startControllers(
-	ctx context.Context,
-	cfg *supervisor.Config,
-	issuerManager *manager.Manager,
-	dynamicJWKSProvider jwks.DynamicJWKSProvider,
-	dynamicTLSCertProvider provider.DynamicTLSCertProvider,
-	dynamicUpstreamIDPProvider provider.DynamicUpstreamIDPProvider,
-	secretCache *secret.Cache,
-	supervisorDeployment *appsv1.Deployment,
-	kubeClient kubernetes.Interface,
-	pinnipedClient pinnipedclientset.Interface,
-	kubeInformers kubeinformers.SharedInformerFactory,
-	pinnipedInformers pinnipedinformers.SharedInformerFactory,
-) {
-	federationDomainInformer := pinnipedInformers.Config().V1alpha1().FederationDomains()
-	secretInformer := kubeInformers.Core().V1().Secrets()
-
-	// Create controller manager.
-	controllerManager := controllerlib.
-		NewManager().
-		WithController(
-			supervisorstorage.GarbageCollectorController(
-				clock.RealClock{},
-				kubeClient,
-				secretInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		).
-		WithController(
-			supervisorconfig.NewFederationDomainWatcherController(
-				issuerManager,
-				clock.RealClock{},
-				pinnipedClient,
-				federationDomainInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		).
-		WithController(
-			supervisorconfig.NewJWKSWriterController(
-				cfg.Labels,
-				kubeClient,
-				pinnipedClient,
-				secretInformer,
-				federationDomainInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		).
-		WithController(
-			supervisorconfig.NewJWKSObserverController(
-				dynamicJWKSProvider,
-				secretInformer,
-				federationDomainInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		).
-		WithController(
-			supervisorconfig.NewTLSCertObserverController(
-				dynamicTLSCertProvider,
-				cfg.NamesConfig.DefaultTLSCertificateSecret,
-				secretInformer,
-				federationDomainInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		).
-		WithController(
-			generator.NewSupervisorSecretsController(
-				supervisorDeployment,
-				cfg.Labels,
-				kubeClient,
-				secretInformer,
-				func(secret []byte) {
-					plog.Debug("setting csrf cookie secret")
-					secretCache.SetCSRFCookieEncoderHashKey(secret)
-				},
-				controllerlib.WithInformer,
-				controllerlib.WithInitialEvent,
-			),
-			singletonWorker,
-		).
-		WithController(
-			generator.NewFederationDomainSecretsController(
-				generator.NewSymmetricSecretHelper(
-					"pinniped-oidc-provider-hmac-key-",
-					cfg.Labels,
-					rand.Reader,
-					generator.SecretUsageTokenSigningKey,
-					func(federationDomainIssuer string, symmetricKey []byte) {
-						plog.Debug("setting hmac secret", "issuer", federationDomainIssuer)
-						secretCache.SetTokenHMACKey(federationDomainIssuer, symmetricKey)
-					},
-				),
-				func(fd *configv1alpha1.FederationDomainStatus) *corev1.LocalObjectReference {
-					return &fd.Secrets.TokenSigningKey
-				},
-				kubeClient,
-				pinnipedClient,
-				secretInformer,
-				federationDomainInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		).
-		WithController(
-			generator.NewFederationDomainSecretsController(
-				generator.NewSymmetricSecretHelper(
-					"pinniped-oidc-provider-upstream-state-signature-key-",
-					cfg.Labels,
-					rand.Reader,
-					generator.SecretUsageStateSigningKey,
-					func(federationDomainIssuer string, symmetricKey []byte) {
-						plog.Debug("setting state signature key", "issuer", federationDomainIssuer)
-						secretCache.SetStateEncoderHashKey(federationDomainIssuer, symmetricKey)
-					},
-				),
-				func(fd *configv1alpha1.FederationDomainStatus) *corev1.LocalObjectReference {
-					return &fd.Secrets.StateSigningKey
-				},
-				kubeClient,
-				pinnipedClient,
-				secretInformer,
-				federationDomainInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		).
-		WithController(
-			generator.NewFederationDomainSecretsController(
-				generator.NewSymmetricSecretHelper(
-					"pinniped-oidc-provider-upstream-state-encryption-key-",
-					cfg.Labels,
-					rand.Reader,
-					generator.SecretUsageStateEncryptionKey,
-					func(federationDomainIssuer string, symmetricKey []byte) {
-						plog.Debug("setting state encryption key", "issuer", federationDomainIssuer)
-						secretCache.SetStateEncoderBlockKey(federationDomainIssuer, symmetricKey)
-					},
-				),
-				func(fd *configv1alpha1.FederationDomainStatus) *corev1.LocalObjectReference {
-					return &fd.Secrets.StateEncryptionKey
-				},
-				kubeClient,
-				pinnipedClient,
-				secretInformer,
-				federationDomainInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker,
-		).
-		WithController(
-			oidcupstreamwatcher.New(
-				dynamicUpstreamIDPProvider,
-				pinnipedClient,
-				pinnipedInformers.IDP().V1alpha1().OIDCIdentityProviders(),
-				secretInformer,
-				klogr.New(),
-				controllerlib.WithInformer,
-			),
-			singletonWorker).
-		WithController(
-			ldapupstreamwatcher.New(
-				dynamicUpstreamIDPProvider,
-				pinnipedClient,
-				pinnipedInformers.IDP().V1alpha1().LDAPIdentityProviders(),
-				secretInformer,
-				controllerlib.WithInformer,
-			),
-			singletonWorker)
-
-	kubeInformers.Start(ctx.Done())
-	pinnipedInformers.Start(ctx.Done())
-
-	// Wait until the caches are synced before returning.
-	kubeInformers.WaitForCacheSync(ctx.Done())
-	pinnipedInformers.WaitForCacheSync(ctx.Done())
-
-	go controllerManager.Start(ctx)
-}
-
-func run(podInfo *downward.PodInfo, cfg *supervisor.Config) error {
-	serverInstallationNamespace := podInfo.Namespace
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	dref, supervisorDeployment, err := deploymentref.New(podInfo)
-	if err != nil {
-		return fmt.Errorf("cannot create deployment ref: %w", err)
-	}
-
-	client, err := kubeclient.New(
-		dref,
-		kubeclient.WithMiddleware(groupsuffix.New(*cfg.APIGroupSuffix)),
-	)
-	if err != nil {
-		return fmt.Errorf("cannot create k8s client: %w", err)
-	}
-
-	kubeInformers := kubeinformers.NewSharedInformerFactoryWithOptions(
-		client.Kubernetes,
-		defaultResyncInterval,
-		kubeinformers.WithNamespace(serverInstallationNamespace),
-	)
-
-	pinnipedInformers := pinnipedinformers.NewSharedInformerFactoryWithOptions(
-		client.PinnipedSupervisor,
-		defaultResyncInterval,
-		pinnipedinformers.WithNamespace(serverInstallationNamespace),
-	)
-
-	// Serve the /healthz endpoint and make all other paths result in 404.
-	healthMux := http.NewServeMux()
-	healthMux.Handle("/healthz", http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
-		_, _ = writer.Write([]byte("ok"))
-	}))
-
-	dynamicJWKSProvider := jwks.NewDynamicJWKSProvider()
-	dynamicTLSCertProvider := provider.NewDynamicTLSCertProvider()
-	dynamicUpstreamIDPProvider := provider.NewDynamicUpstreamIDPProvider()
-	secretCache := secret.Cache{}
-
-	// OIDC endpoints will be served by the oidProvidersManager, and any non-OIDC paths will fallback to the healthMux.
-	oidProvidersManager := manager.NewManager(
-		healthMux,
-		dynamicJWKSProvider,
-		dynamicUpstreamIDPProvider,
-		&secretCache,
-		client.Kubernetes.CoreV1().Secrets(serverInstallationNamespace),
-	)
-
-	startControllers(
-		ctx,
-		cfg,
-		oidProvidersManager,
-		dynamicJWKSProvider,
-		dynamicTLSCertProvider,
-		dynamicUpstreamIDPProvider,
-		&secretCache,
-		supervisorDeployment,
-		client.Kubernetes,
-		client.PinnipedSupervisor,
-		kubeInformers,
-		pinnipedInformers,
-	)
-
-	//nolint: gosec // Intentionally binding to all network interfaces.
-	httpListener, err := net.Listen("tcp", ":8080")
-	if err != nil {
-		return fmt.Errorf("cannot create listener: %w", err)
-	}
-	defer func() { _ = httpListener.Close() }()
-	start(ctx, httpListener, oidProvidersManager)
-
-	//nolint: gosec // Intentionally binding to all network interfaces.
-	httpsListener, err := tls.Listen("tcp", ":8443", &tls.Config{
-		MinVersion: tls.VersionTLS12, // Allow v1.2 because clients like the default `curl` on MacOS don't support 1.3 yet.
-		GetCertificate: func(info *tls.ClientHelloInfo) (*tls.Certificate, error) {
-			cert := dynamicTLSCertProvider.GetTLSCert(strings.ToLower(info.ServerName))
-			defaultCert := dynamicTLSCertProvider.GetDefaultTLSCert()
-			plog.Debug("GetCertificate called for port 8443",
-				"info.ServerName", info.ServerName,
-				"foundSNICert", cert != nil,
-				"foundDefaultCert", defaultCert != nil,
-			)
-			if cert == nil {
-				cert = defaultCert
-			}
-			return cert, nil
-		},
-	})
-	if err != nil {
-		return fmt.Errorf("cannot create listener: %w", err)
-	}
-	defer func() { _ = httpsListener.Close() }()
-	start(ctx, httpsListener, oidProvidersManager)
-
-	plog.Debug("supervisor is ready",
-		"httpAddress", httpListener.Addr().String(),
-		"httpsAddress", httpsListener.Addr().String(),
-	)
-
-	gotSignal := waitForSignal()
-	plog.Debug("supervisor exiting", "signal", gotSignal)
-
-	return nil
-}
-
-func main() {
-	logs.InitLogs()
-	defer logs.FlushLogs()
-	plog.RemoveKlogGlobalFlags() // move this whenever the below code gets refactored to use cobra
-
-	klog.Infof("Running %s at %#v", rest.DefaultKubernetesUserAgent(), version.Get())
-	klog.Infof("Command-line arguments were: %s %s %s", os.Args[0], os.Args[1], os.Args[2])
-
-	// Discover in which namespace we are installed.
-	podInfo, err := downward.Load(os.Args[1])
-	if err != nil {
-		klog.Fatal(fmt.Errorf("could not read pod metadata: %w", err))
-	}
-
-	// Read the server config file.
-	cfg, err := supervisor.FromPath(os.Args[2])
-	if err != nil {
-		klog.Fatal(fmt.Errorf("could not load config: %w", err))
-	}
-
-	if err := run(podInfo, cfg); err != nil {
-		klog.Fatal(err)
-	}
-}

cmd/pinniped/cmd/alpha.go

@@ -1,22 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-)
-
-//nolint: gochecknoglobals
-var alphaCmd = &cobra.Command{
-	Use:          "alpha",
-	Short:        "alpha",
-	Long:         "alpha subcommands (syntax or flags are still subject to change)",
-	SilenceUsage: true, // do not print usage message when commands fail
-	Hidden:       true,
-}
-
-//nolint: gochecknoinits
-func init() {
-	rootCmd.AddCommand(alphaCmd)
-}

cmd/pinniped/cmd/cobra_util.go

@@ -1,30 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import "github.com/spf13/cobra"
-
-// mustMarkRequired marks the given flags as required on the provided cobra.Command. If any of the names are wrong, it panics.
-func mustMarkRequired(cmd *cobra.Command, flags ...string) {
-	for _, flag := range flags {
-		if err := cmd.MarkFlagRequired(flag); err != nil {
-			panic(err)
-		}
-	}
-}
-
-// mustMarkHidden marks the given flags as hidden on the provided cobra.Command. If any of the names are wrong, it panics.
-func mustMarkHidden(cmd *cobra.Command, flags ...string) {
-	for _, flag := range flags {
-		if err := cmd.Flags().MarkHidden(flag); err != nil {
-			panic(err)
-		}
-	}
-}
-
-func mustMarkDeprecated(cmd *cobra.Command, flag, usageMessage string) {
-	if err := cmd.Flags().MarkDeprecated(flag, usageMessage); err != nil {
-		panic(err)
-	}
-}

cmd/pinniped/cmd/cobra_util_test.go

@@ -1,21 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/spf13/cobra"
-	"github.com/stretchr/testify/require"
-)
-
-func TestMustMarkRequired(t *testing.T) {
-	require.NotPanics(t, func() { mustMarkRequired(&cobra.Command{}) })
-	require.NotPanics(t, func() {
-		cmd := &cobra.Command{}
-		cmd.Flags().String("known-flag", "", "")
-		mustMarkRequired(cmd, "known-flag")
-	})
-	require.Panics(t, func() { mustMarkRequired(&cobra.Command{}, "unknown-flag") })
-}

cmd/pinniped/cmd/flag_types.go

@@ -1,106 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"bytes"
-	"crypto/x509"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"strings"
-
-	"github.com/spf13/pflag"
-
-	configv1alpha1 "go.pinniped.dev/generated/latest/apis/concierge/config/v1alpha1"
-)
-
-// conciergeModeFlag represents the method by which we should connect to the Concierge on a cluster during login.
-// this is meant to be a valid flag.Value implementation.
-type conciergeModeFlag int
-
-var _ flag.Value = new(conciergeModeFlag)
-
-const (
-	modeUnknown conciergeModeFlag = iota
-	modeTokenCredentialRequestAPI
-	modeImpersonationProxy
-)
-
-func (f *conciergeModeFlag) String() string {
-	switch *f {
-	case modeImpersonationProxy:
-		return "ImpersonationProxy"
-	case modeTokenCredentialRequestAPI:
-		return "TokenCredentialRequestAPI"
-	case modeUnknown:
-		fallthrough
-	default:
-		return "TokenCredentialRequestAPI"
-	}
-}
-
-func (f *conciergeModeFlag) Set(s string) error {
-	if strings.EqualFold(s, "") {
-		*f = modeUnknown
-		return nil
-	}
-	if strings.EqualFold(s, "TokenCredentialRequestAPI") {
-		*f = modeTokenCredentialRequestAPI
-		return nil
-	}
-	if strings.EqualFold(s, "ImpersonationProxy") {
-		*f = modeImpersonationProxy
-		return nil
-	}
-	return fmt.Errorf("invalid mode %q, valid modes are TokenCredentialRequestAPI and ImpersonationProxy", s)
-}
-
-func (f *conciergeModeFlag) Type() string {
-	return "mode"
-}
-
-// MatchesFrontend returns true iff the flag matches the type of the provided frontend.
-func (f *conciergeModeFlag) MatchesFrontend(frontend *configv1alpha1.CredentialIssuerFrontend) bool {
-	switch *f {
-	case modeImpersonationProxy:
-		return frontend.Type == configv1alpha1.ImpersonationProxyFrontendType
-	case modeTokenCredentialRequestAPI:
-		return frontend.Type == configv1alpha1.TokenCredentialRequestAPIFrontendType
-	case modeUnknown:
-		fallthrough
-	default:
-		return true
-	}
-}
-
-// caBundlePathsVar represents a list of CA bundle paths, which load from disk when the flag is populated.
-type caBundleFlag []byte
-
-var _ pflag.Value = new(caBundleFlag)
-
-func (f *caBundleFlag) String() string {
-	return string(*f)
-}
-
-func (f *caBundleFlag) Set(path string) error {
-	pem, err := ioutil.ReadFile(path)
-	if err != nil {
-		return fmt.Errorf("could not read CA bundle path: %w", err)
-	}
-	pool := x509.NewCertPool()
-	if !pool.AppendCertsFromPEM(pem) {
-		return fmt.Errorf("failed to load any CA certificates from %q", path)
-	}
-	if len(*f) == 0 {
-		*f = pem
-		return nil
-	}
-	*f = bytes.Join([][]byte{*f, pem}, []byte("\n"))
-	return nil
-}
-
-func (f *caBundleFlag) Type() string {
-	return "path"
-}

cmd/pinniped/cmd/flag_types_test.go

@@ -1,73 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-
-	configv1alpha1 "go.pinniped.dev/generated/latest/apis/concierge/config/v1alpha1"
-	"go.pinniped.dev/internal/certauthority"
-	"go.pinniped.dev/internal/testutil"
-)
-
-func TestConciergeModeFlag(t *testing.T) {
-	var f conciergeModeFlag
-	require.Equal(t, "mode", f.Type())
-	require.Equal(t, modeUnknown, f)
-	require.NoError(t, f.Set(""))
-	require.Equal(t, modeUnknown, f)
-	require.EqualError(t, f.Set("foo"), `invalid mode "foo", valid modes are TokenCredentialRequestAPI and ImpersonationProxy`)
-	require.True(t, f.MatchesFrontend(&configv1alpha1.CredentialIssuerFrontend{Type: configv1alpha1.TokenCredentialRequestAPIFrontendType}))
-	require.True(t, f.MatchesFrontend(&configv1alpha1.CredentialIssuerFrontend{Type: configv1alpha1.ImpersonationProxyFrontendType}))
-
-	require.NoError(t, f.Set("TokenCredentialRequestAPI"))
-	require.Equal(t, modeTokenCredentialRequestAPI, f)
-	require.Equal(t, "TokenCredentialRequestAPI", f.String())
-	require.True(t, f.MatchesFrontend(&configv1alpha1.CredentialIssuerFrontend{Type: configv1alpha1.TokenCredentialRequestAPIFrontendType}))
-	require.False(t, f.MatchesFrontend(&configv1alpha1.CredentialIssuerFrontend{Type: configv1alpha1.ImpersonationProxyFrontendType}))
-
-	require.NoError(t, f.Set("tokencredentialrequestapi"))
-	require.Equal(t, modeTokenCredentialRequestAPI, f)
-	require.Equal(t, "TokenCredentialRequestAPI", f.String())
-
-	require.NoError(t, f.Set("ImpersonationProxy"))
-	require.Equal(t, modeImpersonationProxy, f)
-	require.Equal(t, "ImpersonationProxy", f.String())
-	require.False(t, f.MatchesFrontend(&configv1alpha1.CredentialIssuerFrontend{Type: configv1alpha1.TokenCredentialRequestAPIFrontendType}))
-	require.True(t, f.MatchesFrontend(&configv1alpha1.CredentialIssuerFrontend{Type: configv1alpha1.ImpersonationProxyFrontendType}))
-
-	require.NoError(t, f.Set("impersonationproxy"))
-	require.Equal(t, modeImpersonationProxy, f)
-	require.Equal(t, "ImpersonationProxy", f.String())
-}
-
-func TestCABundleFlag(t *testing.T) {
-	testCA, err := certauthority.New("Test CA", 1*time.Hour)
-	require.NoError(t, err)
-	tmpdir := testutil.TempDir(t)
-	emptyFilePath := filepath.Join(tmpdir, "empty")
-	require.NoError(t, ioutil.WriteFile(emptyFilePath, []byte{}, 0600))
-
-	testCAPath := filepath.Join(tmpdir, "testca.pem")
-	require.NoError(t, ioutil.WriteFile(testCAPath, testCA.Bundle(), 0600))
-
-	f := caBundleFlag{}
-	require.Equal(t, "path", f.Type())
-	require.Equal(t, "", f.String())
-	require.EqualError(t, f.Set("./does/not/exist"), "could not read CA bundle path: open ./does/not/exist: no such file or directory")
-	require.EqualError(t, f.Set(emptyFilePath), fmt.Sprintf("failed to load any CA certificates from %q", emptyFilePath))
-
-	require.NoError(t, f.Set(testCAPath))
-	require.Equal(t, 1, bytes.Count(f, []byte("BEGIN CERTIFICATE")))
-
-	require.NoError(t, f.Set(testCAPath))
-	require.Equal(t, 2, bytes.Count(f, []byte("BEGIN CERTIFICATE")))
-}

cmd/pinniped/cmd/generate_markdown_help.go

@@ -1,114 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/cobra/doc"
-)
-
-//nolint: gochecknoinits
-func init() {
-	rootCmd.AddCommand(generateMarkdownHelpCommand())
-}
-
-func generateMarkdownHelpCommand() *cobra.Command {
-	return &cobra.Command{
-		Args:         cobra.NoArgs,
-		Use:          "generate-markdown-help",
-		Short:        "Generate markdown help for the current set of non-hidden CLI commands",
-		SilenceUsage: true,
-		Hidden:       true,
-		RunE:         runGenerateMarkdownHelp,
-	}
-}
-
-func runGenerateMarkdownHelp(cmd *cobra.Command, _ []string) error {
-	var generated bytes.Buffer
-	if err := generate(&generated); err != nil {
-		return err
-	}
-	if err := write(cmd.OutOrStdout(), &generated, "###### Auto generated by spf13/cobra"); err != nil {
-		return err
-	}
-	return nil
-}
-
-func generate(w io.Writer) error {
-	if err := generateHeader(w); err != nil {
-		return err
-	}
-	if err := generateCommand(w, rootCmd); err != nil {
-		return err
-	}
-	return nil
-}
-
-func generateHeader(w io.Writer) error {
-	_, err := fmt.Fprintf(w, `---
-title: Command-Line Options Reference
-description: Reference for the `+"`pinniped`"+` command-line tool
-cascade:
-  layout: docs
-menu:
-  docs:
-    name: Command-Line Options
-    weight: 30
-    parent: reference
----
-
-`)
-	return err
-}
-
-func generateCommand(w io.Writer, command *cobra.Command) error {
-	for _, command := range command.Commands() {
-		// if this node is hidden, don't traverse it or its descendents
-		if command.Hidden {
-			continue
-		}
-
-		// generate children
-		if err := generateCommand(w, command); err != nil {
-			return err
-		}
-
-		// generate self, but only if we are a command that people would run to do something interesting
-		if command.Run != nil || command.RunE != nil {
-			if err := doc.GenMarkdownCustom(command, w, func(_ string) string { return "" }); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func write(w io.Writer, r io.Reader, unwantedPrefixes ...string) error {
-	s := bufio.NewScanner(r)
-	for s.Scan() {
-		line := s.Text()
-		if !containsPrefix(line, unwantedPrefixes) {
-			if _, err := fmt.Fprintln(w, line); err != nil {
-				return err
-			}
-		}
-	}
-	return s.Err()
-}
-
-func containsPrefix(s string, prefixes []string) bool {
-	for _, prefix := range prefixes {
-		if strings.HasPrefix(s, prefix) {
-			return true
-		}
-	}
-	return false
-}

cmd/pinniped/cmd/get.go

@@ -1,16 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-)
-
-//nolint: gochecknoglobals
-var getCmd = &cobra.Command{Use: "get", Short: "get"}
-
-//nolint: gochecknoinits
-func init() {
-	rootCmd.AddCommand(getCmd)
-}

cmd/pinniped/cmd/kube_util.go

@@ -1,43 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"k8s.io/client-go/tools/clientcmd"
-
-	conciergeclientset "go.pinniped.dev/generated/latest/client/concierge/clientset/versioned"
-	"go.pinniped.dev/internal/groupsuffix"
-	"go.pinniped.dev/internal/kubeclient"
-)
-
-// getConciergeClientsetFunc is a function that can return a clientset for the Concierge API given a
-// clientConfig and the apiGroupSuffix with which the API is running.
-type getConciergeClientsetFunc func(clientConfig clientcmd.ClientConfig, apiGroupSuffix string) (conciergeclientset.Interface, error)
-
-// getRealConciergeClientset returns a real implementation of a conciergeclientset.Interface.
-func getRealConciergeClientset(clientConfig clientcmd.ClientConfig, apiGroupSuffix string) (conciergeclientset.Interface, error) {
-	restConfig, err := clientConfig.ClientConfig()
-	if err != nil {
-		return nil, err
-	}
-	client, err := kubeclient.New(
-		kubeclient.WithConfig(restConfig),
-		kubeclient.WithMiddleware(groupsuffix.New(apiGroupSuffix)),
-	)
-	if err != nil {
-		return nil, err
-	}
-	return client.PinnipedConcierge, nil
-}
-
-// newClientConfig returns a clientcmd.ClientConfig given an optional kubeconfig path override and
-// an optional context override.
-func newClientConfig(kubeconfigPathOverride string, currentContextName string) clientcmd.ClientConfig {
-	loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
-	loadingRules.ExplicitPath = kubeconfigPathOverride
-	clientConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, &clientcmd.ConfigOverrides{
-		CurrentContext: currentContextName,
-	})
-	return clientConfig
-}

cmd/pinniped/cmd/kubeconfig.go

@@ -1,884 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"context"
-	"crypto/tls"
-	"crypto/x509"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/coreos/go-oidc/v3/oidc"
-	"github.com/go-logr/logr"
-	"github.com/go-logr/stdr"
-	"github.com/spf13/cobra"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	clientauthenticationv1beta1 "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1"
-	_ "k8s.io/client-go/plugin/pkg/client/auth" // Adds handlers for various dynamic auth plugins in client-go
-	"k8s.io/client-go/tools/clientcmd"
-	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
-	"k8s.io/client-go/transport"
-
-	conciergev1alpha1 "go.pinniped.dev/generated/latest/apis/concierge/authentication/v1alpha1"
-	configv1alpha1 "go.pinniped.dev/generated/latest/apis/concierge/config/v1alpha1"
-	conciergeclientset "go.pinniped.dev/generated/latest/client/concierge/clientset/versioned"
-	"go.pinniped.dev/internal/groupsuffix"
-)
-
-type kubeconfigDeps struct {
-	getPathToSelf func() (string, error)
-	getClientset  getConciergeClientsetFunc
-	log           logr.Logger
-}
-
-func kubeconfigRealDeps() kubeconfigDeps {
-	return kubeconfigDeps{
-		getPathToSelf: os.Executable,
-		getClientset:  getRealConciergeClientset,
-		log:           stdr.New(log.New(os.Stderr, "", 0)),
-	}
-}
-
-//nolint: gochecknoinits
-func init() {
-	getCmd.AddCommand(kubeconfigCommand(kubeconfigRealDeps()))
-}
-
-type getKubeconfigOIDCParams struct {
-	issuer            string
-	clientID          string
-	listenPort        uint16
-	scopes            []string
-	skipBrowser       bool
-	sessionCachePath  string
-	debugSessionCache bool
-	caBundle          caBundleFlag
-	requestAudience   string
-	upstreamIDPName   string
-	upstreamIDPType   string
-}
-
-type getKubeconfigConciergeParams struct {
-	disabled          bool
-	credentialIssuer  string
-	authenticatorName string
-	authenticatorType string
-	apiGroupSuffix    string
-	caBundle          caBundleFlag
-	endpoint          string
-	mode              conciergeModeFlag
-	skipWait          bool
-}
-
-type getKubeconfigParams struct {
-	kubeconfigPath            string
-	kubeconfigContextOverride string
-	skipValidate              bool
-	timeout                   time.Duration
-	outputPath                string
-	staticToken               string
-	staticTokenEnvName        string
-	oidc                      getKubeconfigOIDCParams
-	concierge                 getKubeconfigConciergeParams
-	generatedNameSuffix       string
-	credentialCachePath       string
-	credentialCachePathSet    bool
-}
-
-type supervisorOIDCDiscoveryResponseWithV1Alpha1 struct {
-	SupervisorDiscovery SupervisorDiscoveryResponseV1Alpha1 `json:"discovery.supervisor.pinniped.dev/v1alpha1"`
-}
-
-type SupervisorDiscoveryResponseV1Alpha1 struct {
-	PinnipedIDPsEndpoint string `json:"pinniped_identity_providers_endpoint"`
-}
-
-type supervisorIDPsDiscoveryResponseV1Alpha1 struct {
-	PinnipedIDPs []pinnipedIDPResponse `json:"pinniped_identity_providers"`
-}
-
-type pinnipedIDPResponse struct {
-	Name string `json:"name"`
-	Type string `json:"type"`
-}
-
-func kubeconfigCommand(deps kubeconfigDeps) *cobra.Command {
-	var (
-		cmd = &cobra.Command{
-			Args:         cobra.NoArgs,
-			Use:          "kubeconfig",
-			Short:        "Generate a Pinniped-based kubeconfig for a cluster",
-			SilenceUsage: true,
-		}
-		flags     getKubeconfigParams
-		namespace string // unused now
-	)
-
-	f := cmd.Flags()
-	f.StringVar(&flags.staticToken, "static-token", "", "Instead of doing an OIDC-based login, specify a static token")
-	f.StringVar(&flags.staticTokenEnvName, "static-token-env", "", "Instead of doing an OIDC-based login, read a static token from the environment")
-
-	f.BoolVar(&flags.concierge.disabled, "no-concierge", false, "Generate a configuration which does not use the Concierge, but sends the credential to the cluster directly")
-	f.StringVar(&namespace, "concierge-namespace", "pinniped-concierge", "Namespace in which the Concierge was installed")
-	f.StringVar(&flags.concierge.credentialIssuer, "concierge-credential-issuer", "", "Concierge CredentialIssuer object to use for autodiscovery (default: autodiscover)")
-	f.StringVar(&flags.concierge.authenticatorType, "concierge-authenticator-type", "", "Concierge authenticator type (e.g., 'webhook', 'jwt') (default: autodiscover)")
-	f.StringVar(&flags.concierge.authenticatorName, "concierge-authenticator-name", "", "Concierge authenticator name (default: autodiscover)")
-	f.StringVar(&flags.concierge.apiGroupSuffix, "concierge-api-group-suffix", groupsuffix.PinnipedDefaultSuffix, "Concierge API group suffix")
-	f.BoolVar(&flags.concierge.skipWait, "concierge-skip-wait", false, "Skip waiting for any pending Concierge strategies to become ready (default: false)")
-
-	f.Var(&flags.concierge.caBundle, "concierge-ca-bundle", "Path to TLS certificate authority bundle (PEM format, optional, can be repeated) to use when connecting to the Concierge")
-	f.StringVar(&flags.concierge.endpoint, "concierge-endpoint", "", "API base for the Concierge endpoint")
-	f.Var(&flags.concierge.mode, "concierge-mode", "Concierge mode of operation")
-
-	f.StringVar(&flags.oidc.issuer, "oidc-issuer", "", "OpenID Connect issuer URL (default: autodiscover)")
-	f.StringVar(&flags.oidc.clientID, "oidc-client-id", "pinniped-cli", "OpenID Connect client ID (default: autodiscover)")
-	f.Uint16Var(&flags.oidc.listenPort, "oidc-listen-port", 0, "TCP port for localhost listener (authorization code flow only)")
-	f.StringSliceVar(&flags.oidc.scopes, "oidc-scopes", []string{oidc.ScopeOfflineAccess, oidc.ScopeOpenID, "pinniped:request-audience"}, "OpenID Connect scopes to request during login")
-	f.BoolVar(&flags.oidc.skipBrowser, "oidc-skip-browser", false, "During OpenID Connect login, skip opening the browser (just print the URL)")
-	f.StringVar(&flags.oidc.sessionCachePath, "oidc-session-cache", "", "Path to OpenID Connect session cache file")
-	f.Var(&flags.oidc.caBundle, "oidc-ca-bundle", "Path to TLS certificate authority bundle (PEM format, optional, can be repeated)")
-	f.BoolVar(&flags.oidc.debugSessionCache, "oidc-debug-session-cache", false, "Print debug logs related to the OpenID Connect session cache")
-	f.StringVar(&flags.oidc.requestAudience, "oidc-request-audience", "", "Request a token with an alternate audience using RFC8693 token exchange")
-	f.StringVar(&flags.oidc.upstreamIDPName, "upstream-identity-provider-name", "", "The name of the upstream identity provider used during login with a Supervisor")
-	f.StringVar(&flags.oidc.upstreamIDPType, "upstream-identity-provider-type", "", "The type of the upstream identity provider used during login with a Supervisor (e.g. 'oidc', 'ldap')")
-	f.StringVar(&flags.kubeconfigPath, "kubeconfig", os.Getenv("KUBECONFIG"), "Path to kubeconfig file")
-	f.StringVar(&flags.kubeconfigContextOverride, "kubeconfig-context", "", "Kubeconfig context name (default: current active context)")
-	f.BoolVar(&flags.skipValidate, "skip-validation", false, "Skip final validation of the kubeconfig (default: false)")
-	f.DurationVar(&flags.timeout, "timeout", 10*time.Minute, "Timeout for autodiscovery and validation")
-	f.StringVarP(&flags.outputPath, "output", "o", "", "Output file path (default: stdout)")
-	f.StringVar(&flags.generatedNameSuffix, "generated-name-suffix", "-pinniped", "Suffix to append to generated cluster, context, user kubeconfig entries")
-	f.StringVar(&flags.credentialCachePath, "credential-cache", "", "Path to cluster-specific credentials cache")
-	mustMarkHidden(cmd, "oidc-debug-session-cache")
-
-	mustMarkDeprecated(cmd, "concierge-namespace", "not needed anymore")
-	mustMarkHidden(cmd, "concierge-namespace")
-
-	cmd.RunE = func(cmd *cobra.Command, args []string) error {
-		if flags.outputPath != "" {
-			out, err := os.Create(flags.outputPath)
-			if err != nil {
-				return fmt.Errorf("could not open output file: %w", err)
-			}
-			defer func() { _ = out.Close() }()
-			cmd.SetOut(out)
-		}
-		flags.credentialCachePathSet = cmd.Flags().Changed("credential-cache")
-		return runGetKubeconfig(cmd.Context(), cmd.OutOrStdout(), deps, flags)
-	}
-	return cmd
-}
-
-//nolint:funlen
-func runGetKubeconfig(ctx context.Context, out io.Writer, deps kubeconfigDeps, flags getKubeconfigParams) error {
-	ctx, cancel := context.WithTimeout(ctx, flags.timeout)
-	defer cancel()
-
-	// Validate api group suffix and immediately return an error if it is invalid.
-	if err := groupsuffix.Validate(flags.concierge.apiGroupSuffix); err != nil {
-		return fmt.Errorf("invalid API group suffix: %w", err)
-	}
-
-	clientConfig := newClientConfig(flags.kubeconfigPath, flags.kubeconfigContextOverride)
-	currentKubeConfig, err := clientConfig.RawConfig()
-	if err != nil {
-		return fmt.Errorf("could not load --kubeconfig: %w", err)
-	}
-	currentKubeconfigNames, err := getCurrentContext(currentKubeConfig, flags)
-	if err != nil {
-		return fmt.Errorf("could not load --kubeconfig/--kubeconfig-context: %w", err)
-	}
-	cluster := currentKubeConfig.Clusters[currentKubeconfigNames.ClusterName]
-	clientset, err := deps.getClientset(clientConfig, flags.concierge.apiGroupSuffix)
-	if err != nil {
-		return fmt.Errorf("could not configure Kubernetes client: %w", err)
-	}
-
-	// Generate the new context/cluster/user names by appending the --generated-name-suffix to the original values.
-	newKubeconfigNames := &kubeconfigNames{
-		ContextName: currentKubeconfigNames.ContextName + flags.generatedNameSuffix,
-		UserName:    currentKubeconfigNames.UserName + flags.generatedNameSuffix,
-		ClusterName: currentKubeconfigNames.ClusterName + flags.generatedNameSuffix,
-	}
-
-	if !flags.concierge.disabled {
-		credentialIssuer, err := waitForCredentialIssuer(ctx, clientset, flags, deps)
-		if err != nil {
-			return err
-		}
-
-		authenticator, err := lookupAuthenticator(
-			clientset,
-			flags.concierge.authenticatorType,
-			flags.concierge.authenticatorName,
-			deps.log,
-		)
-		if err != nil {
-			return err
-		}
-		if err := discoverConciergeParams(credentialIssuer, &flags, cluster, deps.log); err != nil {
-			return err
-		}
-		if err := discoverAuthenticatorParams(authenticator, &flags, deps.log); err != nil {
-			return err
-		}
-
-		// Point kubectl at the concierge endpoint.
-		cluster.Server = flags.concierge.endpoint
-		cluster.CertificateAuthorityData = flags.concierge.caBundle
-	}
-
-	// If there is an issuer, and if both upstream flags are not already set, then try to discover Supervisor upstream IDP.
-	if len(flags.oidc.issuer) > 0 && (flags.oidc.upstreamIDPType == "" || flags.oidc.upstreamIDPName == "") {
-		if err := discoverSupervisorUpstreamIDP(ctx, &flags); err != nil {
-			return err
-		}
-	}
-
-	execConfig, err := newExecConfig(deps, flags)
-	if err != nil {
-		return err
-	}
-
-	kubeconfig := newExecKubeconfig(cluster, execConfig, newKubeconfigNames)
-	if err := validateKubeconfig(ctx, flags, kubeconfig, deps.log); err != nil {
-		return err
-	}
-
-	return writeConfigAsYAML(out, kubeconfig)
-}
-
-func newExecConfig(deps kubeconfigDeps, flags getKubeconfigParams) (*clientcmdapi.ExecConfig, error) {
-	execConfig := &clientcmdapi.ExecConfig{
-		APIVersion:         clientauthenticationv1beta1.SchemeGroupVersion.String(),
-		Args:               []string{},
-		Env:                []clientcmdapi.ExecEnvVar{},
-		ProvideClusterInfo: true,
-	}
-
-	var err error
-	execConfig.Command, err = deps.getPathToSelf()
-	if err != nil {
-		return nil, fmt.Errorf("could not determine the Pinniped executable path: %w", err)
-	}
-
-	if !flags.concierge.disabled {
-		// Append the flags to configure the Concierge credential exchange at runtime.
-		execConfig.Args = append(execConfig.Args,
-			"--enable-concierge",
-			"--concierge-api-group-suffix="+flags.concierge.apiGroupSuffix,
-			"--concierge-authenticator-name="+flags.concierge.authenticatorName,
-			"--concierge-authenticator-type="+flags.concierge.authenticatorType,
-			"--concierge-endpoint="+flags.concierge.endpoint,
-			"--concierge-ca-bundle-data="+base64.StdEncoding.EncodeToString(flags.concierge.caBundle),
-		)
-	}
-
-	// If --credential-cache is set, pass it through.
-	if flags.credentialCachePathSet {
-		execConfig.Args = append(execConfig.Args, "--credential-cache="+flags.credentialCachePath)
-	}
-
-	// If one of the --static-* flags was passed, output a config that runs `pinniped login static`.
-	if flags.staticToken != "" || flags.staticTokenEnvName != "" {
-		if flags.staticToken != "" && flags.staticTokenEnvName != "" {
-			return nil, fmt.Errorf("only one of --static-token and --static-token-env can be specified")
-		}
-		execConfig.Args = append([]string{"login", "static"}, execConfig.Args...)
-		if flags.staticToken != "" {
-			execConfig.Args = append(execConfig.Args, "--token="+flags.staticToken)
-		}
-		if flags.staticTokenEnvName != "" {
-			execConfig.Args = append(execConfig.Args, "--token-env="+flags.staticTokenEnvName)
-		}
-		return execConfig, nil
-	}
-
-	// Otherwise continue to parse the OIDC-related flags and output a config that runs `pinniped login oidc`.
-	execConfig.Args = append([]string{"login", "oidc"}, execConfig.Args...)
-	if flags.oidc.issuer == "" {
-		return nil, fmt.Errorf("could not autodiscover --oidc-issuer and none was provided")
-	}
-	execConfig.Args = append(execConfig.Args,
-		"--issuer="+flags.oidc.issuer,
-		"--client-id="+flags.oidc.clientID,
-		"--scopes="+strings.Join(flags.oidc.scopes, ","),
-	)
-	if flags.oidc.skipBrowser {
-		execConfig.Args = append(execConfig.Args, "--skip-browser")
-	}
-	if flags.oidc.listenPort != 0 {
-		execConfig.Args = append(execConfig.Args, "--listen-port="+strconv.Itoa(int(flags.oidc.listenPort)))
-	}
-	if len(flags.oidc.caBundle) != 0 {
-		execConfig.Args = append(execConfig.Args, "--ca-bundle-data="+base64.StdEncoding.EncodeToString(flags.oidc.caBundle))
-	}
-	if flags.oidc.sessionCachePath != "" {
-		execConfig.Args = append(execConfig.Args, "--session-cache="+flags.oidc.sessionCachePath)
-	}
-	if flags.oidc.debugSessionCache {
-		execConfig.Args = append(execConfig.Args, "--debug-session-cache")
-	}
-	if flags.oidc.requestAudience != "" {
-		execConfig.Args = append(execConfig.Args, "--request-audience="+flags.oidc.requestAudience)
-	}
-	if flags.oidc.upstreamIDPName != "" {
-		execConfig.Args = append(execConfig.Args, "--upstream-identity-provider-name="+flags.oidc.upstreamIDPName)
-	}
-	if flags.oidc.upstreamIDPType != "" {
-		execConfig.Args = append(execConfig.Args, "--upstream-identity-provider-type="+flags.oidc.upstreamIDPType)
-	}
-
-	return execConfig, nil
-}
-
-type kubeconfigNames struct{ ContextName, UserName, ClusterName string }
-
-func getCurrentContext(currentKubeConfig clientcmdapi.Config, flags getKubeconfigParams) (*kubeconfigNames, error) {
-	contextName := currentKubeConfig.CurrentContext
-	if flags.kubeconfigContextOverride != "" {
-		contextName = flags.kubeconfigContextOverride
-	}
-	ctx := currentKubeConfig.Contexts[contextName]
-	if ctx == nil {
-		return nil, fmt.Errorf("no such context %q", contextName)
-	}
-	if _, exists := currentKubeConfig.Clusters[ctx.Cluster]; !exists {
-		return nil, fmt.Errorf("no such cluster %q", ctx.Cluster)
-	}
-	if _, exists := currentKubeConfig.AuthInfos[ctx.AuthInfo]; !exists {
-		return nil, fmt.Errorf("no such user %q", ctx.AuthInfo)
-	}
-	return &kubeconfigNames{ContextName: contextName, UserName: ctx.AuthInfo, ClusterName: ctx.Cluster}, nil
-}
-
-func waitForCredentialIssuer(ctx context.Context, clientset conciergeclientset.Interface, flags getKubeconfigParams, deps kubeconfigDeps) (*configv1alpha1.CredentialIssuer, error) {
-	credentialIssuer, err := lookupCredentialIssuer(clientset, flags.concierge.credentialIssuer, deps.log)
-	if err != nil {
-		return nil, err
-	}
-
-	if !flags.concierge.skipWait {
-		ticker := time.NewTicker(2 * time.Second)
-		defer ticker.Stop()
-
-		deadline, _ := ctx.Deadline()
-		attempts := 1
-
-		for {
-			if !hasPendingStrategy(credentialIssuer) {
-				break
-			}
-			logStrategies(credentialIssuer, deps.log)
-			deps.log.Info("waiting for CredentialIssuer pending strategies to finish",
-				"attempts", attempts,
-				"remaining", time.Until(deadline).Round(time.Second).String(),
-			)
-			select {
-			case <-ctx.Done():
-				return nil, ctx.Err()
-			case <-ticker.C:
-				credentialIssuer, err = lookupCredentialIssuer(clientset, flags.concierge.credentialIssuer, deps.log)
-				if err != nil {
-					return nil, err
-				}
-			}
-		}
-	}
-	return credentialIssuer, nil
-}
-
-func discoverConciergeParams(credentialIssuer *configv1alpha1.CredentialIssuer, flags *getKubeconfigParams, v1Cluster *clientcmdapi.Cluster, log logr.Logger) error {
-	// Autodiscover the --concierge-mode.
-	frontend, err := getConciergeFrontend(credentialIssuer, flags.concierge.mode)
-	if err != nil {
-		logStrategies(credentialIssuer, log)
-		return err
-	}
-
-	// Auto-set --concierge-mode if it wasn't explicitly set.
-	if flags.concierge.mode == modeUnknown {
-		switch frontend.Type {
-		case configv1alpha1.TokenCredentialRequestAPIFrontendType:
-			log.Info("discovered Concierge operating in TokenCredentialRequest API mode")
-			flags.concierge.mode = modeTokenCredentialRequestAPI
-		case configv1alpha1.ImpersonationProxyFrontendType:
-			log.Info("discovered Concierge operating in impersonation proxy mode")
-			flags.concierge.mode = modeImpersonationProxy
-		}
-	}
-
-	// Auto-set --concierge-endpoint if it wasn't explicitly set.
-	if flags.concierge.endpoint == "" {
-		switch frontend.Type {
-		case configv1alpha1.TokenCredentialRequestAPIFrontendType:
-			flags.concierge.endpoint = v1Cluster.Server
-		case configv1alpha1.ImpersonationProxyFrontendType:
-			flags.concierge.endpoint = frontend.ImpersonationProxyInfo.Endpoint
-		}
-		log.Info("discovered Concierge endpoint", "endpoint", flags.concierge.endpoint)
-	}
-
-	// Auto-set --concierge-ca-bundle if it wasn't explicitly set..
-	if len(flags.concierge.caBundle) == 0 {
-		switch frontend.Type {
-		case configv1alpha1.TokenCredentialRequestAPIFrontendType:
-			flags.concierge.caBundle = v1Cluster.CertificateAuthorityData
-		case configv1alpha1.ImpersonationProxyFrontendType:
-			data, err := base64.StdEncoding.DecodeString(frontend.ImpersonationProxyInfo.CertificateAuthorityData)
-			if err != nil {
-				return fmt.Errorf("autodiscovered Concierge CA bundle is invalid: %w", err)
-			}
-			flags.concierge.caBundle = data
-		}
-		log.Info("discovered Concierge certificate authority bundle", "roots", countCACerts(flags.concierge.caBundle))
-	}
-	return nil
-}
-
-func logStrategies(credentialIssuer *configv1alpha1.CredentialIssuer, log logr.Logger) {
-	for _, strategy := range credentialIssuer.Status.Strategies {
-		log.Info("found CredentialIssuer strategy",
-			"type", strategy.Type,
-			"status", strategy.Status,
-			"reason", strategy.Reason,
-			"message", strategy.Message,
-		)
-	}
-}
-
-func discoverAuthenticatorParams(authenticator metav1.Object, flags *getKubeconfigParams, log logr.Logger) error {
-	switch auth := authenticator.(type) {
-	case *conciergev1alpha1.WebhookAuthenticator:
-		// If the --concierge-authenticator-type/--concierge-authenticator-name flags were not set explicitly, set
-		// them to point at the discovered WebhookAuthenticator.
-		if flags.concierge.authenticatorType == "" && flags.concierge.authenticatorName == "" {
-			log.Info("discovered WebhookAuthenticator", "name", auth.Name)
-			flags.concierge.authenticatorType = "webhook"
-			flags.concierge.authenticatorName = auth.Name
-		}
-	case *conciergev1alpha1.JWTAuthenticator:
-		// If the --concierge-authenticator-type/--concierge-authenticator-name flags were not set explicitly, set
-		// them to point at the discovered JWTAuthenticator.
-		if flags.concierge.authenticatorType == "" && flags.concierge.authenticatorName == "" {
-			log.Info("discovered JWTAuthenticator", "name", auth.Name)
-			flags.concierge.authenticatorType = "jwt"
-			flags.concierge.authenticatorName = auth.Name
-		}
-
-		// If the --oidc-issuer flag was not set explicitly, default it to the spec.issuer field of the JWTAuthenticator.
-		if flags.oidc.issuer == "" {
-			log.Info("discovered OIDC issuer", "issuer", auth.Spec.Issuer)
-			flags.oidc.issuer = auth.Spec.Issuer
-		}
-
-		// If the --oidc-request-audience flag was not set explicitly, default it to the spec.audience field of the JWTAuthenticator.
-		if flags.oidc.requestAudience == "" {
-			log.Info("discovered OIDC audience", "audience", auth.Spec.Audience)
-			flags.oidc.requestAudience = auth.Spec.Audience
-		}
-
-		// If the --oidc-ca-bundle flags was not set explicitly, default it to the
-		// spec.tls.certificateAuthorityData field of the JWTAuthenticator.
-		if len(flags.oidc.caBundle) == 0 && auth.Spec.TLS != nil && auth.Spec.TLS.CertificateAuthorityData != "" {
-			decoded, err := base64.StdEncoding.DecodeString(auth.Spec.TLS.CertificateAuthorityData)
-			if err != nil {
-				return fmt.Errorf("tried to autodiscover --oidc-ca-bundle, but JWTAuthenticator %s has invalid spec.tls.certificateAuthorityData: %w", auth.Name, err)
-			}
-			log.Info("discovered OIDC CA bundle", "roots", countCACerts(decoded))
-			flags.oidc.caBundle = decoded
-		}
-	}
-	return nil
-}
-
-func getConciergeFrontend(credentialIssuer *configv1alpha1.CredentialIssuer, mode conciergeModeFlag) (*configv1alpha1.CredentialIssuerFrontend, error) {
-	for _, strategy := range credentialIssuer.Status.Strategies {
-		// Skip unhealthy strategies.
-		if strategy.Status != configv1alpha1.SuccessStrategyStatus {
-			continue
-		}
-
-		// Backfill the .status.strategies[].frontend field from .status.kubeConfigInfo for backwards compatibility.
-		if strategy.Type == configv1alpha1.KubeClusterSigningCertificateStrategyType && strategy.Frontend == nil && credentialIssuer.Status.KubeConfigInfo != nil {
-			strategy = *strategy.DeepCopy()
-			strategy.Frontend = &configv1alpha1.CredentialIssuerFrontend{
-				Type: configv1alpha1.TokenCredentialRequestAPIFrontendType,
-				TokenCredentialRequestAPIInfo: &configv1alpha1.TokenCredentialRequestAPIInfo{
-					Server:                   credentialIssuer.Status.KubeConfigInfo.Server,
-					CertificateAuthorityData: credentialIssuer.Status.KubeConfigInfo.CertificateAuthorityData,
-				},
-			}
-		}
-
-		// If the strategy frontend is still nil, skip.
-		if strategy.Frontend == nil {
-			continue
-		}
-
-		//	Skip any unknown frontend types.
-		switch strategy.Frontend.Type {
-		case configv1alpha1.TokenCredentialRequestAPIFrontendType, configv1alpha1.ImpersonationProxyFrontendType:
-		default:
-			continue
-		}
-		// Skip strategies that don't match --concierge-mode.
-		if !mode.MatchesFrontend(strategy.Frontend) {
-			continue
-		}
-		return strategy.Frontend, nil
-	}
-
-	if mode == modeUnknown {
-		return nil, fmt.Errorf("could not autodiscover --concierge-mode")
-	}
-	return nil, fmt.Errorf("could not find successful Concierge strategy matching --concierge-mode=%s", mode.String())
-}
-
-func newExecKubeconfig(cluster *clientcmdapi.Cluster, execConfig *clientcmdapi.ExecConfig, newNames *kubeconfigNames) clientcmdapi.Config {
-	return clientcmdapi.Config{
-		Kind:           "Config",
-		APIVersion:     clientcmdapi.SchemeGroupVersion.Version,
-		Clusters:       map[string]*clientcmdapi.Cluster{newNames.ClusterName: cluster},
-		AuthInfos:      map[string]*clientcmdapi.AuthInfo{newNames.UserName: {Exec: execConfig}},
-		Contexts:       map[string]*clientcmdapi.Context{newNames.ContextName: {Cluster: newNames.ClusterName, AuthInfo: newNames.UserName}},
-		CurrentContext: newNames.ContextName,
-	}
-}
-
-func lookupCredentialIssuer(clientset conciergeclientset.Interface, name string, log logr.Logger) (*configv1alpha1.CredentialIssuer, error) {
-	ctx, cancelFunc := context.WithTimeout(context.Background(), time.Second*20)
-	defer cancelFunc()
-
-	// If the name is specified, get that object.
-	if name != "" {
-		return clientset.ConfigV1alpha1().CredentialIssuers().Get(ctx, name, metav1.GetOptions{})
-	}
-
-	// Otherwise list all the available CredentialIssuers and hope there's just a single one
-	results, err := clientset.ConfigV1alpha1().CredentialIssuers().List(ctx, metav1.ListOptions{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to list CredentialIssuer objects for autodiscovery: %w", err)
-	}
-	if len(results.Items) == 0 {
-		return nil, fmt.Errorf("no CredentialIssuers were found")
-	}
-	if len(results.Items) > 1 {
-		return nil, fmt.Errorf("multiple CredentialIssuers were found, so the --concierge-credential-issuer flag must be specified")
-	}
-
-	result := &results.Items[0]
-	log.Info("discovered CredentialIssuer", "name", result.Name)
-	return result, nil
-}
-
-func lookupAuthenticator(clientset conciergeclientset.Interface, authType, authName string, log logr.Logger) (metav1.Object, error) {
-	ctx, cancelFunc := context.WithTimeout(context.Background(), time.Second*20)
-	defer cancelFunc()
-
-	// If one was specified, look it up or error.
-	if authName != "" && authType != "" {
-		switch strings.ToLower(authType) {
-		case "webhook":
-			return clientset.AuthenticationV1alpha1().WebhookAuthenticators().Get(ctx, authName, metav1.GetOptions{})
-		case "jwt":
-			return clientset.AuthenticationV1alpha1().JWTAuthenticators().Get(ctx, authName, metav1.GetOptions{})
-		default:
-			return nil, fmt.Errorf(`invalid authenticator type %q, supported values are "webhook" and "jwt"`, authType)
-		}
-	}
-
-	// Otherwise list all the available authenticators and hope there's just a single one.
-
-	jwtAuths, err := clientset.AuthenticationV1alpha1().JWTAuthenticators().List(ctx, metav1.ListOptions{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to list JWTAuthenticator objects for autodiscovery: %w", err)
-	}
-	webhooks, err := clientset.AuthenticationV1alpha1().WebhookAuthenticators().List(ctx, metav1.ListOptions{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to list WebhookAuthenticator objects for autodiscovery: %w", err)
-	}
-
-	results := make([]metav1.Object, 0, len(jwtAuths.Items)+len(webhooks.Items))
-	for i := range jwtAuths.Items {
-		results = append(results, &jwtAuths.Items[i])
-	}
-	for i := range webhooks.Items {
-		results = append(results, &webhooks.Items[i])
-	}
-	if len(results) == 0 {
-		return nil, fmt.Errorf("no authenticators were found")
-	}
-	if len(results) > 1 {
-		for _, jwtAuth := range jwtAuths.Items {
-			log.Info("found JWTAuthenticator", "name", jwtAuth.Name)
-		}
-		for _, webhook := range webhooks.Items {
-			log.Info("found WebhookAuthenticator", "name", webhook.Name)
-		}
-		return nil, fmt.Errorf("multiple authenticators were found, so the --concierge-authenticator-type/--concierge-authenticator-name flags must be specified")
-	}
-	return results[0], nil
-}
-
-func writeConfigAsYAML(out io.Writer, config clientcmdapi.Config) error {
-	output, err := clientcmd.Write(config)
-	if err != nil {
-		return err
-	}
-	_, err = out.Write(output)
-	if err != nil {
-		return fmt.Errorf("could not write output: %w", err)
-	}
-	return nil
-}
-
-func validateKubeconfig(ctx context.Context, flags getKubeconfigParams, kubeconfig clientcmdapi.Config, log logr.Logger) error {
-	if flags.skipValidate {
-		return nil
-	}
-
-	kubeContext := kubeconfig.Contexts[kubeconfig.CurrentContext]
-	if kubeContext == nil {
-		return fmt.Errorf("invalid kubeconfig (no context)")
-	}
-	cluster := kubeconfig.Clusters[kubeContext.Cluster]
-	if cluster == nil {
-		return fmt.Errorf("invalid kubeconfig (no cluster)")
-	}
-
-	kubeconfigCA := x509.NewCertPool()
-	if !kubeconfigCA.AppendCertsFromPEM(cluster.CertificateAuthorityData) {
-		return fmt.Errorf("invalid kubeconfig (no certificateAuthorityData)")
-	}
-
-	httpClient := &http.Client{
-		Transport: &http.Transport{
-			TLSClientConfig: &tls.Config{
-				MinVersion: tls.VersionTLS12,
-				RootCAs:    kubeconfigCA,
-			},
-			Proxy:               http.ProxyFromEnvironment,
-			TLSHandshakeTimeout: 10 * time.Second,
-		},
-		Timeout: 10 * time.Second,
-	}
-
-	ticker := time.NewTicker(2 * time.Second)
-	defer ticker.Stop()
-
-	pingCluster := func() error {
-		reqCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
-		defer cancel()
-		req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, cluster.Server, nil)
-		if err != nil {
-			return fmt.Errorf("could not form request to validate cluster: %w", err)
-		}
-		resp, err := httpClient.Do(req)
-		if err != nil {
-			return err
-		}
-		_ = resp.Body.Close()
-		if resp.StatusCode >= 500 {
-			return fmt.Errorf("unexpected status code %d", resp.StatusCode)
-		}
-		return nil
-	}
-
-	err := pingCluster()
-	if err == nil {
-		log.Info("validated connection to the cluster")
-		return nil
-	}
-
-	log.Info("could not immediately connect to the cluster but it may be initializing, will retry until timeout")
-	deadline, _ := ctx.Deadline()
-	attempts := 0
-	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case <-ticker.C:
-			attempts++
-			err := pingCluster()
-			if err == nil {
-				log.Info("validated connection to the cluster", "attempts", attempts)
-				return nil
-			}
-			log.Error(err, "could not connect to cluster, retrying...", "attempts", attempts, "remaining", time.Until(deadline).Round(time.Second).String())
-		}
-	}
-}
-
-func countCACerts(pemData []byte) int {
-	pool := x509.NewCertPool()
-	pool.AppendCertsFromPEM(pemData)
-	return len(pool.Subjects())
-}
-
-func hasPendingStrategy(credentialIssuer *configv1alpha1.CredentialIssuer) bool {
-	for _, strategy := range credentialIssuer.Status.Strategies {
-		if strategy.Reason == configv1alpha1.PendingStrategyReason {
-			return true
-		}
-	}
-	return false
-}
-
-func discoverSupervisorUpstreamIDP(ctx context.Context, flags *getKubeconfigParams) error {
-	httpClient, err := newDiscoveryHTTPClient(flags.oidc.caBundle)
-	if err != nil {
-		return err
-	}
-
-	pinnipedIDPsEndpoint, err := discoverIDPsDiscoveryEndpointURL(ctx, flags.oidc.issuer, httpClient)
-	if err != nil {
-		return err
-	}
-	if pinnipedIDPsEndpoint == "" {
-		// The issuer is not advertising itself as a Pinniped Supervisor which supports upstream IDP discovery.
-		return nil
-	}
-
-	upstreamIDPs, err := discoverAllAvailableSupervisorUpstreamIDPs(ctx, pinnipedIDPsEndpoint, httpClient)
-	if err != nil {
-		return err
-	}
-	if len(upstreamIDPs) == 1 {
-		flags.oidc.upstreamIDPName = upstreamIDPs[0].Name
-		flags.oidc.upstreamIDPType = upstreamIDPs[0].Type
-	} else if len(upstreamIDPs) > 1 {
-		idpName, idpType, err := selectUpstreamIDP(upstreamIDPs, flags.oidc.upstreamIDPName, flags.oidc.upstreamIDPType)
-		if err != nil {
-			return err
-		}
-		flags.oidc.upstreamIDPName = idpName
-		flags.oidc.upstreamIDPType = idpType
-	}
-	return nil
-}
-
-func newDiscoveryHTTPClient(caBundleFlag caBundleFlag) (*http.Client, error) {
-	t := &http.Transport{
-		TLSClientConfig: &tls.Config{MinVersion: tls.VersionTLS12},
-		Proxy:           http.ProxyFromEnvironment,
-	}
-	httpClient := &http.Client{Transport: t}
-	if caBundleFlag != nil {
-		rootCAs := x509.NewCertPool()
-		ok := rootCAs.AppendCertsFromPEM(caBundleFlag)
-		if !ok {
-			return nil, fmt.Errorf("unable to fetch OIDC discovery data from issuer: could not parse CA bundle")
-		}
-		t.TLSClientConfig.RootCAs = rootCAs
-	}
-	httpClient.Transport = transport.DebugWrappers(httpClient.Transport)
-	return httpClient, nil
-}
-
-func discoverIDPsDiscoveryEndpointURL(ctx context.Context, issuer string, httpClient *http.Client) (string, error) {
-	discoveredProvider, err := oidc.NewProvider(oidc.ClientContext(ctx, httpClient), issuer)
-	if err != nil {
-		return "", fmt.Errorf("while fetching OIDC discovery data from issuer: %w", err)
-	}
-
-	var body supervisorOIDCDiscoveryResponseWithV1Alpha1
-	err = discoveredProvider.Claims(&body)
-	if err != nil {
-		return "", fmt.Errorf("while fetching OIDC discovery data from issuer: %w", err)
-	}
-
-	return body.SupervisorDiscovery.PinnipedIDPsEndpoint, nil
-}
-
-func discoverAllAvailableSupervisorUpstreamIDPs(ctx context.Context, pinnipedIDPsEndpoint string, httpClient *http.Client) ([]pinnipedIDPResponse, error) {
-	request, err := http.NewRequestWithContext(ctx, http.MethodGet, pinnipedIDPsEndpoint, nil)
-	if err != nil {
-		return nil, fmt.Errorf("while forming request to IDP discovery URL: %w", err)
-	}
-
-	response, err := httpClient.Do(request)
-	if err != nil {
-		return nil, fmt.Errorf("unable to fetch IDP discovery data from issuer: %w", err)
-	}
-	defer func() {
-		_ = response.Body.Close()
-	}()
-	if response.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("unable to fetch IDP discovery data from issuer: unexpected http response status: %s", response.Status)
-	}
-
-	rawBody, err := ioutil.ReadAll(response.Body)
-	if err != nil {
-		return nil, fmt.Errorf("unable to fetch IDP discovery data from issuer: could not read response body: %w", err)
-	}
-
-	var body supervisorIDPsDiscoveryResponseV1Alpha1
-	err = json.Unmarshal(rawBody, &body)
-	if err != nil {
-		return nil, fmt.Errorf("unable to fetch IDP discovery data from issuer: could not parse response JSON: %w", err)
-	}
-
-	return body.PinnipedIDPs, nil
-}
-
-func selectUpstreamIDP(pinnipedIDPs []pinnipedIDPResponse, idpName, idpType string) (string, string, error) {
-	pinnipedIDPsString, _ := json.Marshal(pinnipedIDPs)
-	switch {
-	case idpType != "":
-		discoveredName := ""
-		for _, idp := range pinnipedIDPs {
-			if idp.Type == idpType {
-				if discoveredName != "" {
-					return "", "", fmt.Errorf(
-						"multiple Supervisor upstream identity providers of type \"%s\" were found,"+
-							" so the --upstream-identity-provider-name flag must be specified. "+
-							"Found these upstreams: %s",
-						idpType, pinnipedIDPsString)
-				}
-				discoveredName = idp.Name
-			}
-		}
-		if discoveredName == "" {
-			return "", "", fmt.Errorf(
-				"no Supervisor upstream identity providers of type \"%s\" were found."+
-					" Found these upstreams: %s", idpType, pinnipedIDPsString)
-		}
-		return discoveredName, idpType, nil
-	case idpName != "":
-		discoveredType := ""
-		for _, idp := range pinnipedIDPs {
-			if idp.Name == idpName {
-				if discoveredType != "" {
-					return "", "", fmt.Errorf(
-						"multiple Supervisor upstream identity providers with name \"%s\" were found,"+
-							" so the --upstream-identity-provider-type flag must be specified. Found these upstreams: %s",
-						idpName, pinnipedIDPsString)
-				}
-				discoveredType = idp.Type
-			}
-		}
-		if discoveredType == "" {
-			return "", "", fmt.Errorf(
-				"no Supervisor upstream identity providers with name \"%s\" were found."+
-					" Found these upstreams: %s", idpName, pinnipedIDPsString)
-		}
-		return idpName, discoveredType, nil
-	default:
-		return "", "", fmt.Errorf(
-			"multiple Supervisor upstream identity providers were found,"+
-				" so the --upstream-identity-provider-name/--upstream-identity-provider-type flags must be specified."+
-				" Found these upstreams: %s",
-			pinnipedIDPsString)
-	}
-}

cmd/pinniped/cmd/login.go

@@ -1,36 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-	clientauthv1beta1 "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1"
-	"k8s.io/client-go/tools/auth/exec"
-)
-
-//nolint: gochecknoglobals
-var loginCmd = &cobra.Command{
-	Use:          "login",
-	Short:        "login",
-	Long:         "Login to a Pinniped server",
-	SilenceUsage: true, // Do not print usage message when commands fail.
-	Hidden:       true, // These commands are not really meant to be used directly by users, so it's confusing to have them discoverable.
-}
-
-//nolint: gochecknoinits
-func init() {
-	rootCmd.AddCommand(loginCmd)
-}
-
-func loadClusterInfo() *clientauthv1beta1.Cluster {
-	obj, _, err := exec.LoadExecCredentialFromEnv()
-	if err != nil {
-		return nil
-	}
-	cred, ok := obj.(*clientauthv1beta1.ExecCredential)
-	if !ok {
-		return nil
-	}
-	return cred.Spec.Cluster
-}

cmd/pinniped/cmd/login_oidc.go

@@ -1,321 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"context"
-	"crypto/tls"
-	"crypto/x509"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/coreos/go-oidc/v3/oidc"
-	"github.com/spf13/cobra"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	clientauthv1beta1 "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1"
-	"k8s.io/client-go/transport"
-	"k8s.io/klog/v2/klogr"
-
-	"go.pinniped.dev/internal/execcredcache"
-	"go.pinniped.dev/internal/groupsuffix"
-	"go.pinniped.dev/internal/plog"
-	"go.pinniped.dev/pkg/conciergeclient"
-	"go.pinniped.dev/pkg/oidcclient"
-	"go.pinniped.dev/pkg/oidcclient/filesession"
-	"go.pinniped.dev/pkg/oidcclient/oidctypes"
-)
-
-//nolint: gochecknoinits
-func init() {
-	loginCmd.AddCommand(oidcLoginCommand(oidcLoginCommandRealDeps()))
-}
-
-type oidcLoginCommandDeps struct {
-	lookupEnv     func(string) (string, bool)
-	login         func(string, string, ...oidcclient.Option) (*oidctypes.Token, error)
-	exchangeToken func(context.Context, *conciergeclient.Client, string) (*clientauthv1beta1.ExecCredential, error)
-}
-
-func oidcLoginCommandRealDeps() oidcLoginCommandDeps {
-	return oidcLoginCommandDeps{
-		lookupEnv: os.LookupEnv,
-		login:     oidcclient.Login,
-		exchangeToken: func(ctx context.Context, client *conciergeclient.Client, token string) (*clientauthv1beta1.ExecCredential, error) {
-			return client.ExchangeToken(ctx, token)
-		},
-	}
-}
-
-type oidcLoginFlags struct {
-	issuer                       string
-	clientID                     string
-	listenPort                   uint16
-	scopes                       []string
-	skipBrowser                  bool
-	sessionCachePath             string
-	caBundlePaths                []string
-	caBundleData                 []string
-	debugSessionCache            bool
-	requestAudience              string
-	conciergeEnabled             bool
-	conciergeAuthenticatorType   string
-	conciergeAuthenticatorName   string
-	conciergeEndpoint            string
-	conciergeCABundle            string
-	conciergeAPIGroupSuffix      string
-	credentialCachePath          string
-	upstreamIdentityProviderName string
-	upstreamIdentityProviderType string
-}
-
-func oidcLoginCommand(deps oidcLoginCommandDeps) *cobra.Command {
-	var (
-		cmd = &cobra.Command{
-			Args:         cobra.NoArgs,
-			Use:          "oidc --issuer ISSUER",
-			Short:        "Login using an OpenID Connect provider",
-			SilenceUsage: true,
-		}
-		flags              oidcLoginFlags
-		conciergeNamespace string // unused now
-	)
-	cmd.Flags().StringVar(&flags.issuer, "issuer", "", "OpenID Connect issuer URL")
-	cmd.Flags().StringVar(&flags.clientID, "client-id", "pinniped-cli", "OpenID Connect client ID")
-	cmd.Flags().Uint16Var(&flags.listenPort, "listen-port", 0, "TCP port for localhost listener (authorization code flow only)")
-	cmd.Flags().StringSliceVar(&flags.scopes, "scopes", []string{oidc.ScopeOfflineAccess, oidc.ScopeOpenID, "pinniped:request-audience"}, "OIDC scopes to request during login")
-	cmd.Flags().BoolVar(&flags.skipBrowser, "skip-browser", false, "Skip opening the browser (just print the URL)")
-	cmd.Flags().StringVar(&flags.sessionCachePath, "session-cache", filepath.Join(mustGetConfigDir(), "sessions.yaml"), "Path to session cache file")
-	cmd.Flags().StringSliceVar(&flags.caBundlePaths, "ca-bundle", nil, "Path to TLS certificate authority bundle (PEM format, optional, can be repeated)")
-	cmd.Flags().StringSliceVar(&flags.caBundleData, "ca-bundle-data", nil, "Base64 encoded TLS certificate authority bundle (base64 encoded PEM format, optional, can be repeated)")
-	cmd.Flags().BoolVar(&flags.debugSessionCache, "debug-session-cache", false, "Print debug logs related to the session cache")
-	cmd.Flags().StringVar(&flags.requestAudience, "request-audience", "", "Request a token with an alternate audience using RFC8693 token exchange")
-	cmd.Flags().BoolVar(&flags.conciergeEnabled, "enable-concierge", false, "Use the Concierge to login")
-	cmd.Flags().StringVar(&conciergeNamespace, "concierge-namespace", "pinniped-concierge", "Namespace in which the Concierge was installed")
-	cmd.Flags().StringVar(&flags.conciergeAuthenticatorType, "concierge-authenticator-type", "", "Concierge authenticator type (e.g., 'webhook', 'jwt')")
-	cmd.Flags().StringVar(&flags.conciergeAuthenticatorName, "concierge-authenticator-name", "", "Concierge authenticator name")
-	cmd.Flags().StringVar(&flags.conciergeEndpoint, "concierge-endpoint", "", "API base for the Concierge endpoint")
-	cmd.Flags().StringVar(&flags.conciergeCABundle, "concierge-ca-bundle-data", "", "CA bundle to use when connecting to the Concierge")
-	cmd.Flags().StringVar(&flags.conciergeAPIGroupSuffix, "concierge-api-group-suffix", groupsuffix.PinnipedDefaultSuffix, "Concierge API group suffix")
-	cmd.Flags().StringVar(&flags.credentialCachePath, "credential-cache", filepath.Join(mustGetConfigDir(), "credentials.yaml"), "Path to cluster-specific credentials cache (\"\" disables the cache)")
-	cmd.Flags().StringVar(&flags.upstreamIdentityProviderName, "upstream-identity-provider-name", "", "The name of the upstream identity provider used during login with a Supervisor")
-	cmd.Flags().StringVar(&flags.upstreamIdentityProviderType, "upstream-identity-provider-type", "oidc", "The type of the upstream identity provider used during login with a Supervisor (e.g. 'oidc', 'ldap')")
-
-	mustMarkHidden(cmd, "debug-session-cache")
-	mustMarkRequired(cmd, "issuer")
-	cmd.RunE = func(cmd *cobra.Command, args []string) error { return runOIDCLogin(cmd, deps, flags) }
-
-	mustMarkDeprecated(cmd, "concierge-namespace", "not needed anymore")
-	mustMarkHidden(cmd, "concierge-namespace")
-
-	return cmd
-}
-
-func runOIDCLogin(cmd *cobra.Command, deps oidcLoginCommandDeps, flags oidcLoginFlags) error { //nolint:funlen
-	pLogger, err := SetLogLevel(deps.lookupEnv)
-	if err != nil {
-		plog.WarningErr("Received error while setting log level", err)
-	}
-
-	// Initialize the session cache.
-	var sessionOptions []filesession.Option
-
-	// If the hidden --debug-session-cache option is passed, log all the errors from the session cache with klog.
-	if flags.debugSessionCache {
-		logger := klogr.New().WithName("session")
-		sessionOptions = append(sessionOptions, filesession.WithErrorReporter(func(err error) {
-			logger.Error(err, "error during session cache operation")
-		}))
-	}
-	sessionCache := filesession.New(flags.sessionCachePath, sessionOptions...)
-
-	// Initialize the login handler.
-	opts := []oidcclient.Option{
-		oidcclient.WithContext(cmd.Context()),
-		oidcclient.WithLogger(klogr.New()),
-		oidcclient.WithScopes(flags.scopes),
-		oidcclient.WithSessionCache(sessionCache),
-	}
-
-	if flags.listenPort != 0 {
-		opts = append(opts, oidcclient.WithListenPort(flags.listenPort))
-	}
-
-	if flags.requestAudience != "" {
-		opts = append(opts, oidcclient.WithRequestAudience(flags.requestAudience))
-	}
-
-	if flags.upstreamIdentityProviderName != "" {
-		opts = append(opts, oidcclient.WithUpstreamIdentityProvider(
-			flags.upstreamIdentityProviderName, flags.upstreamIdentityProviderType))
-	}
-
-	switch flags.upstreamIdentityProviderType {
-	case "oidc":
-		// this is the default, so don't need to do anything
-	case "ldap":
-		opts = append(opts, oidcclient.WithCLISendingCredentials())
-	default:
-		// Surprisingly cobra does not support this kind of flag validation. See https://github.com/spf13/pflag/issues/236
-		return fmt.Errorf(
-			"--upstream-identity-provider-type value not recognized: %s (supported values: oidc, ldap)",
-			flags.upstreamIdentityProviderType)
-	}
-
-	var concierge *conciergeclient.Client
-	if flags.conciergeEnabled {
-		var err error
-		concierge, err = conciergeclient.New(
-			conciergeclient.WithEndpoint(flags.conciergeEndpoint),
-			conciergeclient.WithBase64CABundle(flags.conciergeCABundle),
-			conciergeclient.WithAuthenticator(flags.conciergeAuthenticatorType, flags.conciergeAuthenticatorName),
-			conciergeclient.WithAPIGroupSuffix(flags.conciergeAPIGroupSuffix),
-		)
-		if err != nil {
-			return fmt.Errorf("invalid Concierge parameters: %w", err)
-		}
-	}
-
-	// --skip-browser replaces the default "browser open" function with one that prints to stderr.
-	if flags.skipBrowser {
-		opts = append(opts, oidcclient.WithBrowserOpen(func(url string) error {
-			cmd.PrintErr("Please log in: ", url, "\n")
-			return nil
-		}))
-	}
-
-	if len(flags.caBundlePaths) > 0 || len(flags.caBundleData) > 0 {
-		client, err := makeClient(flags.caBundlePaths, flags.caBundleData)
-		if err != nil {
-			return err
-		}
-		opts = append(opts, oidcclient.WithClient(client))
-	}
-	// Look up cached credentials based on a hash of all the CLI arguments and the cluster info.
-	cacheKey := struct {
-		Args        []string                   `json:"args"`
-		ClusterInfo *clientauthv1beta1.Cluster `json:"cluster"`
-	}{
-		Args:        os.Args[1:],
-		ClusterInfo: loadClusterInfo(),
-	}
-	var credCache *execcredcache.Cache
-	if flags.credentialCachePath != "" {
-		credCache = execcredcache.New(flags.credentialCachePath)
-		if cred := credCache.Get(cacheKey); cred != nil {
-			pLogger.Debug("using cached cluster credential.")
-			return json.NewEncoder(cmd.OutOrStdout()).Encode(cred)
-		}
-	}
-
-	pLogger.Debug("Performing OIDC login", "issuer", flags.issuer, "client id", flags.clientID)
-	// Do the basic login to get an OIDC token.
-	token, err := deps.login(flags.issuer, flags.clientID, opts...)
-	if err != nil {
-		return fmt.Errorf("could not complete Pinniped login: %w", err)
-	}
-	cred := tokenCredential(token)
-
-	// If the concierge was configured, exchange the credential for a separate short-lived, cluster-specific credential.
-	if concierge != nil {
-		pLogger.Debug("Exchanging token for cluster credential", "endpoint", flags.conciergeEndpoint, "authenticator type", flags.conciergeAuthenticatorType, "authenticator name", flags.conciergeAuthenticatorName)
-		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-		defer cancel()
-
-		cred, err = deps.exchangeToken(ctx, concierge, token.IDToken.Token)
-		if err != nil {
-			return fmt.Errorf("could not complete Concierge credential exchange: %w", err)
-		}
-		pLogger.Debug("Successfully exchanged token for cluster credential.")
-	} else {
-		pLogger.Debug("No concierge configured, skipping token credential exchange")
-	}
-
-	// If there was a credential cache, save the resulting credential for future use.
-	if credCache != nil {
-		pLogger.Debug("caching cluster credential for future use.")
-		credCache.Put(cacheKey, cred)
-	}
-	return json.NewEncoder(cmd.OutOrStdout()).Encode(cred)
-}
-
-func makeClient(caBundlePaths []string, caBundleData []string) (*http.Client, error) {
-	pool := x509.NewCertPool()
-	for _, p := range caBundlePaths {
-		pem, err := ioutil.ReadFile(p)
-		if err != nil {
-			return nil, fmt.Errorf("could not read --ca-bundle: %w", err)
-		}
-		pool.AppendCertsFromPEM(pem)
-	}
-	for _, d := range caBundleData {
-		pem, err := base64.StdEncoding.DecodeString(d)
-		if err != nil {
-			return nil, fmt.Errorf("could not read --ca-bundle-data: %w", err)
-		}
-		pool.AppendCertsFromPEM(pem)
-	}
-	client := &http.Client{
-		Transport: &http.Transport{
-			Proxy: http.ProxyFromEnvironment,
-			TLSClientConfig: &tls.Config{
-				RootCAs:    pool,
-				MinVersion: tls.VersionTLS12,
-			},
-		},
-	}
-
-	client.Transport = transport.DebugWrappers(client.Transport)
-	return client, nil
-}
-
-func tokenCredential(token *oidctypes.Token) *clientauthv1beta1.ExecCredential {
-	cred := clientauthv1beta1.ExecCredential{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "ExecCredential",
-			APIVersion: "client.authentication.k8s.io/v1beta1",
-		},
-		Status: &clientauthv1beta1.ExecCredentialStatus{
-			Token: token.IDToken.Token,
-		},
-	}
-	if !token.IDToken.Expiry.IsZero() {
-		cred.Status.ExpirationTimestamp = &token.IDToken.Expiry
-	}
-	return &cred
-}
-
-func SetLogLevel(lookupEnv func(string) (string, bool)) (*plog.PLogger, error) {
-	debug, _ := lookupEnv("PINNIPED_DEBUG")
-	if debug == "true" {
-		err := plog.ValidateAndSetLogLevelGlobally(plog.LevelDebug)
-		if err != nil {
-			return nil, err
-		}
-	}
-	logger := plog.New("Pinniped login: ")
-	return &logger, nil
-}
-
-// mustGetConfigDir returns a directory that follows the XDG base directory convention:
-//   $XDG_CONFIG_HOME defines the base directory relative to which user specific configuration files should
-//   be stored. If $XDG_CONFIG_HOME is either not set or empty, a default equal to $HOME/.config should be used.
-// [1] https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
-func mustGetConfigDir() string {
-	const xdgAppName = "pinniped"
-
-	if path := os.Getenv("XDG_CONFIG_HOME"); path != "" {
-		return filepath.Join(path, xdgAppName)
-	}
-	home, err := os.UserHomeDir()
-	if err != nil {
-		panic(err)
-	}
-	return filepath.Join(home, ".config", xdgAppName)
-}

cmd/pinniped/cmd/login_oidc_test.go

@@ -1,317 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"bytes"
-	"context"
-	"encoding/base64"
-	"fmt"
-	"io/ioutil"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	clientauthv1beta1 "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1"
-	"k8s.io/klog/v2"
-
-	"go.pinniped.dev/internal/certauthority"
-	"go.pinniped.dev/internal/here"
-	"go.pinniped.dev/internal/testutil"
-	"go.pinniped.dev/internal/testutil/testlogger"
-	"go.pinniped.dev/pkg/conciergeclient"
-	"go.pinniped.dev/pkg/oidcclient"
-	"go.pinniped.dev/pkg/oidcclient/oidctypes"
-)
-
-func TestLoginOIDCCommand(t *testing.T) {
-	cfgDir := mustGetConfigDir()
-
-	testCA, err := certauthority.New("Test CA", 1*time.Hour)
-	require.NoError(t, err)
-	tmpdir := testutil.TempDir(t)
-	testCABundlePath := filepath.Join(tmpdir, "testca.pem")
-	require.NoError(t, ioutil.WriteFile(testCABundlePath, testCA.Bundle(), 0600))
-
-	time1 := time.Date(3020, 10, 12, 13, 14, 15, 16, time.UTC)
-
-	tests := []struct {
-		name             string
-		args             []string
-		loginErr         error
-		conciergeErr     error
-		env              map[string]string
-		wantError        bool
-		wantStdout       string
-		wantStderr       string
-		wantOptionsCount int
-		wantLogs         []string
-	}{
-		{
-			name: "help flag passed",
-			args: []string{"--help"},
-			wantStdout: here.Doc(`
-				Login using an OpenID Connect provider
-
-				Usage:
-				  oidc --issuer ISSUER [flags]
-
-				Flags:
-				      --ca-bundle strings                        Path to TLS certificate authority bundle (PEM format, optional, can be repeated)
-				      --ca-bundle-data strings                   Base64 encoded TLS certificate authority bundle (base64 encoded PEM format, optional, can be repeated)
-				      --client-id string                         OpenID Connect client ID (default "pinniped-cli")
-				      --concierge-api-group-suffix string        Concierge API group suffix (default "pinniped.dev")
-				      --concierge-authenticator-name string      Concierge authenticator name
-				      --concierge-authenticator-type string      Concierge authenticator type (e.g., 'webhook', 'jwt')
-				      --concierge-ca-bundle-data string          CA bundle to use when connecting to the Concierge
-				      --concierge-endpoint string                API base for the Concierge endpoint
-				      --credential-cache string                  Path to cluster-specific credentials cache ("" disables the cache) (default "` + cfgDir + `/credentials.yaml")
-				      --enable-concierge                         Use the Concierge to login
-				  -h, --help                                     help for oidc
-				      --issuer string                            OpenID Connect issuer URL
-				      --listen-port uint16                       TCP port for localhost listener (authorization code flow only)
-				      --request-audience string                  Request a token with an alternate audience using RFC8693 token exchange
-				      --scopes strings                           OIDC scopes to request during login (default [offline_access,openid,pinniped:request-audience])
-				      --session-cache string                     Path to session cache file (default "` + cfgDir + `/sessions.yaml")
-				      --skip-browser                             Skip opening the browser (just print the URL)
-					  --upstream-identity-provider-name string   The name of the upstream identity provider used during login with a Supervisor
-					  --upstream-identity-provider-type string   The type of the upstream identity provider used during login with a Supervisor (e.g. 'oidc', 'ldap') (default "oidc")
-			`),
-		},
-		{
-			name:      "missing required flags",
-			args:      []string{},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: required flag(s) "issuer" not set
-			`),
-		},
-		{
-			name: "missing concierge flags",
-			args: []string{
-				"--client-id", "test-client-id",
-				"--issuer", "test-issuer",
-				"--enable-concierge",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: invalid Concierge parameters: endpoint must not be empty
-			`),
-		},
-		{
-			name: "invalid CA bundle path",
-			args: []string{
-				"--client-id", "test-client-id",
-				"--issuer", "test-issuer",
-				"--ca-bundle", "./does/not/exist",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: could not read --ca-bundle: open ./does/not/exist: no such file or directory
-			`),
-		},
-		{
-			name: "invalid CA bundle data",
-			args: []string{
-				"--client-id", "test-client-id",
-				"--issuer", "test-issuer",
-				"--ca-bundle-data", "invalid-base64",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: could not read --ca-bundle-data: illegal base64 data at input byte 7
-			`),
-		},
-		{
-			name: "invalid API group suffix",
-			args: []string{
-				"--issuer", "test-issuer",
-				"--enable-concierge",
-				"--concierge-api-group-suffix", ".starts.with.dot",
-				"--concierge-authenticator-type", "jwt",
-				"--concierge-authenticator-name", "test-authenticator",
-				"--concierge-endpoint", "https://127.0.0.1:1234/",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: invalid Concierge parameters: invalid API group suffix: a lowercase RFC 1123 subdomain must consist of lower case alphanumeric characters, '-' or '.', and must start and end with an alphanumeric character (e.g. 'example.com', regex used for validation is '[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*')
-			`),
-		},
-		{
-			name: "invalid upstream type",
-			args: []string{
-				"--issuer", "test-issuer",
-				"--upstream-identity-provider-type", "invalid",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: --upstream-identity-provider-type value not recognized: invalid (supported values: oidc, ldap)
-			`),
-		},
-		{
-			name: "oidc upstream type is allowed",
-			args: []string{
-				"--issuer", "test-issuer",
-				"--client-id", "test-client-id",
-				"--upstream-identity-provider-type", "oidc",
-				"--credential-cache", "", // must specify --credential-cache or else the cache file on disk causes test pollution
-			},
-			wantOptionsCount: 4,
-			wantStdout:       `{"kind":"ExecCredential","apiVersion":"client.authentication.k8s.io/v1beta1","spec":{},"status":{"expirationTimestamp":"3020-10-12T13:14:15Z","token":"test-id-token"}}` + "\n",
-		},
-		{
-			name: "ldap upstream type is allowed",
-			args: []string{
-				"--issuer", "test-issuer",
-				"--client-id", "test-client-id",
-				"--upstream-identity-provider-type", "ldap",
-				"--credential-cache", "", // must specify --credential-cache or else the cache file on disk causes test pollution
-			},
-			wantOptionsCount: 5,
-			wantStdout:       `{"kind":"ExecCredential","apiVersion":"client.authentication.k8s.io/v1beta1","spec":{},"status":{"expirationTimestamp":"3020-10-12T13:14:15Z","token":"test-id-token"}}` + "\n",
-		},
-		{
-			name: "login error",
-			args: []string{
-				"--client-id", "test-client-id",
-				"--issuer", "test-issuer",
-				"--credential-cache", "", // must specify --credential-cache or else the cache file on disk causes test pollution
-			},
-			loginErr:         fmt.Errorf("some login error"),
-			wantOptionsCount: 4,
-			wantError:        true,
-			wantStderr: here.Doc(`
-				Error: could not complete Pinniped login: some login error
-			`),
-		},
-		{
-			name: "concierge token exchange error",
-			args: []string{
-				"--client-id", "test-client-id",
-				"--issuer", "test-issuer",
-				"--enable-concierge",
-				"--concierge-authenticator-type", "jwt",
-				"--concierge-authenticator-name", "test-authenticator",
-				"--concierge-endpoint", "https://127.0.0.1:1234/",
-				"--credential-cache", "", // must specify --credential-cache or else the cache file on disk causes test pollution
-			},
-			conciergeErr:     fmt.Errorf("some concierge error"),
-			wantOptionsCount: 4,
-			wantError:        true,
-			wantStderr: here.Doc(`
-				Error: could not complete Concierge credential exchange: some concierge error
-			`),
-		},
-		{
-			name: "success with minimal options",
-			args: []string{
-				"--client-id", "test-client-id",
-				"--issuer", "test-issuer",
-				"--credential-cache", "", // must specify --credential-cache or else the cache file on disk causes test pollution
-			},
-			env:              map[string]string{"PINNIPED_DEBUG": "true"},
-			wantOptionsCount: 4,
-			wantStdout:       `{"kind":"ExecCredential","apiVersion":"client.authentication.k8s.io/v1beta1","spec":{},"status":{"expirationTimestamp":"3020-10-12T13:14:15Z","token":"test-id-token"}}` + "\n",
-			wantLogs: []string{
-				"\"level\"=0 \"msg\"=\"Pinniped login: Performing OIDC login\"  \"client id\"=\"test-client-id\" \"issuer\"=\"test-issuer\"",
-				"\"level\"=0 \"msg\"=\"Pinniped login: No concierge configured, skipping token credential exchange\"",
-			},
-		},
-		{
-			name: "success with all options",
-			args: []string{
-				"--client-id", "test-client-id",
-				"--issuer", "test-issuer",
-				"--skip-browser",
-				"--listen-port", "1234",
-				"--debug-session-cache",
-				"--request-audience", "cluster-1234",
-				"--ca-bundle-data", base64.StdEncoding.EncodeToString(testCA.Bundle()),
-				"--ca-bundle", testCABundlePath,
-				"--enable-concierge",
-				"--concierge-authenticator-type", "webhook",
-				"--concierge-authenticator-name", "test-authenticator",
-				"--concierge-endpoint", "https://127.0.0.1:1234/",
-				"--concierge-ca-bundle-data", base64.StdEncoding.EncodeToString(testCA.Bundle()),
-				"--concierge-api-group-suffix", "some.suffix.com",
-				"--credential-cache", testutil.TempDir(t) + "/credentials.yaml", // must specify --credential-cache or else the cache file on disk causes test pollution
-				"--upstream-identity-provider-name", "some-upstream-name",
-				"--upstream-identity-provider-type", "ldap",
-			},
-			env:              map[string]string{"PINNIPED_DEBUG": "true"},
-			wantOptionsCount: 10,
-			wantStdout:       `{"kind":"ExecCredential","apiVersion":"client.authentication.k8s.io/v1beta1","spec":{},"status":{"token":"exchanged-token"}}` + "\n",
-			wantLogs: []string{
-				"\"level\"=0 \"msg\"=\"Pinniped login: Performing OIDC login\"  \"client id\"=\"test-client-id\" \"issuer\"=\"test-issuer\"",
-				"\"level\"=0 \"msg\"=\"Pinniped login: Exchanging token for cluster credential\"  \"authenticator name\"=\"test-authenticator\" \"authenticator type\"=\"webhook\" \"endpoint\"=\"https://127.0.0.1:1234/\"",
-				"\"level\"=0 \"msg\"=\"Pinniped login: Successfully exchanged token for cluster credential.\"",
-				"\"level\"=0 \"msg\"=\"Pinniped login: caching cluster credential for future use.\"",
-			},
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			testLogger := testlogger.New(t)
-			klog.SetLogger(testLogger)
-			var (
-				gotOptions []oidcclient.Option
-			)
-			cmd := oidcLoginCommand(oidcLoginCommandDeps{
-				lookupEnv: func(s string) (string, bool) {
-					v, ok := tt.env[s]
-					return v, ok
-				},
-				login: func(issuer string, clientID string, opts ...oidcclient.Option) (*oidctypes.Token, error) {
-					require.Equal(t, "test-issuer", issuer)
-					require.Equal(t, "test-client-id", clientID)
-					gotOptions = opts
-					if tt.loginErr != nil {
-						return nil, tt.loginErr
-					}
-					return &oidctypes.Token{
-						IDToken: &oidctypes.IDToken{
-							Token:  "test-id-token",
-							Expiry: metav1.NewTime(time1),
-						},
-					}, nil
-				},
-				exchangeToken: func(ctx context.Context, client *conciergeclient.Client, token string) (*clientauthv1beta1.ExecCredential, error) {
-					require.Equal(t, token, "test-id-token")
-					if tt.conciergeErr != nil {
-						return nil, tt.conciergeErr
-					}
-					return &clientauthv1beta1.ExecCredential{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "ExecCredential",
-							APIVersion: "client.authentication.k8s.io/v1beta1",
-						},
-						Status: &clientauthv1beta1.ExecCredentialStatus{
-							Token: "exchanged-token",
-						},
-					}, nil
-				},
-			})
-			require.NotNil(t, cmd)
-
-			var stdout, stderr bytes.Buffer
-			cmd.SetOut(&stdout)
-			cmd.SetErr(&stderr)
-			cmd.SetArgs(tt.args)
-			err := cmd.Execute()
-			if tt.wantError {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-			}
-			require.Equal(t, tt.wantStdout, stdout.String(), "unexpected stdout")
-			require.Equal(t, tt.wantStderr, stderr.String(), "unexpected stderr")
-			require.Len(t, gotOptions, tt.wantOptionsCount)
-
-			require.Equal(t, tt.wantLogs, testLogger.Lines())
-		})
-	}
-}

cmd/pinniped/cmd/login_static.go

@@ -1,166 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/spf13/cobra"
-	clientauthv1beta1 "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1"
-
-	"go.pinniped.dev/internal/execcredcache"
-	"go.pinniped.dev/internal/groupsuffix"
-	"go.pinniped.dev/internal/plog"
-	"go.pinniped.dev/pkg/conciergeclient"
-	"go.pinniped.dev/pkg/oidcclient/oidctypes"
-)
-
-//nolint: gochecknoinits
-func init() {
-	loginCmd.AddCommand(staticLoginCommand(staticLoginRealDeps()))
-}
-
-type staticLoginDeps struct {
-	lookupEnv     func(string) (string, bool)
-	exchangeToken func(context.Context, *conciergeclient.Client, string) (*clientauthv1beta1.ExecCredential, error)
-}
-
-func staticLoginRealDeps() staticLoginDeps {
-	return staticLoginDeps{
-		lookupEnv: os.LookupEnv,
-		exchangeToken: func(ctx context.Context, client *conciergeclient.Client, token string) (*clientauthv1beta1.ExecCredential, error) {
-			return client.ExchangeToken(ctx, token)
-		},
-	}
-}
-
-type staticLoginParams struct {
-	staticToken                string
-	staticTokenEnvName         string
-	conciergeEnabled           bool
-	conciergeAuthenticatorType string
-	conciergeAuthenticatorName string
-	conciergeEndpoint          string
-	conciergeCABundle          string
-	conciergeAPIGroupSuffix    string
-	credentialCachePath        string
-}
-
-func staticLoginCommand(deps staticLoginDeps) *cobra.Command {
-	var (
-		cmd = &cobra.Command{
-			Args:         cobra.NoArgs,
-			Use:          "static [--token TOKEN] [--token-env TOKEN_NAME]",
-			Short:        "Login using a static token",
-			SilenceUsage: true,
-		}
-		flags              staticLoginParams
-		conciergeNamespace string // unused now
-	)
-	cmd.Flags().StringVar(&flags.staticToken, "token", "", "Static token to present during login")
-	cmd.Flags().StringVar(&flags.staticTokenEnvName, "token-env", "", "Environment variable containing a static token")
-	cmd.Flags().BoolVar(&flags.conciergeEnabled, "enable-concierge", false, "Use the Concierge to login")
-	cmd.Flags().StringVar(&conciergeNamespace, "concierge-namespace", "pinniped-concierge", "Namespace in which the Concierge was installed")
-	cmd.Flags().StringVar(&flags.conciergeAuthenticatorType, "concierge-authenticator-type", "", "Concierge authenticator type (e.g., 'webhook', 'jwt')")
-	cmd.Flags().StringVar(&flags.conciergeAuthenticatorName, "concierge-authenticator-name", "", "Concierge authenticator name")
-	cmd.Flags().StringVar(&flags.conciergeEndpoint, "concierge-endpoint", "", "API base for the Concierge endpoint")
-	cmd.Flags().StringVar(&flags.conciergeCABundle, "concierge-ca-bundle-data", "", "CA bundle to use when connecting to the Concierge")
-	cmd.Flags().StringVar(&flags.conciergeAPIGroupSuffix, "concierge-api-group-suffix", groupsuffix.PinnipedDefaultSuffix, "Concierge API group suffix")
-	cmd.Flags().StringVar(&flags.credentialCachePath, "credential-cache", filepath.Join(mustGetConfigDir(), "credentials.yaml"), "Path to cluster-specific credentials cache (\"\" disables the cache)")
-
-	cmd.RunE = func(cmd *cobra.Command, args []string) error { return runStaticLogin(cmd.OutOrStdout(), deps, flags) }
-
-	mustMarkDeprecated(cmd, "concierge-namespace", "not needed anymore")
-	mustMarkHidden(cmd, "concierge-namespace")
-
-	return cmd
-}
-
-func runStaticLogin(out io.Writer, deps staticLoginDeps, flags staticLoginParams) error {
-	pLogger, err := SetLogLevel(deps.lookupEnv)
-	if err != nil {
-		plog.WarningErr("Received error while setting log level", err)
-	}
-
-	if flags.staticToken == "" && flags.staticTokenEnvName == "" {
-		return fmt.Errorf("one of --token or --token-env must be set")
-	}
-
-	var concierge *conciergeclient.Client
-	if flags.conciergeEnabled {
-		var err error
-		concierge, err = conciergeclient.New(
-			conciergeclient.WithEndpoint(flags.conciergeEndpoint),
-			conciergeclient.WithBase64CABundle(flags.conciergeCABundle),
-			conciergeclient.WithAuthenticator(flags.conciergeAuthenticatorType, flags.conciergeAuthenticatorName),
-			conciergeclient.WithAPIGroupSuffix(flags.conciergeAPIGroupSuffix),
-		)
-		if err != nil {
-			return fmt.Errorf("invalid Concierge parameters: %w", err)
-		}
-	}
-
-	var token string
-	if flags.staticToken != "" {
-		token = flags.staticToken
-	}
-	if flags.staticTokenEnvName != "" {
-		var ok bool
-		token, ok = deps.lookupEnv(flags.staticTokenEnvName)
-		if !ok {
-			return fmt.Errorf("--token-env variable %q is not set", flags.staticTokenEnvName)
-		}
-		if token == "" {
-			return fmt.Errorf("--token-env variable %q is empty", flags.staticTokenEnvName)
-		}
-	}
-	cred := tokenCredential(&oidctypes.Token{IDToken: &oidctypes.IDToken{Token: token}})
-
-	// Look up cached credentials based on a hash of all the CLI arguments, the current token value, and the cluster info.
-	cacheKey := struct {
-		Args        []string                   `json:"args"`
-		Token       string                     `json:"token"`
-		ClusterInfo *clientauthv1beta1.Cluster `json:"cluster"`
-	}{
-		Args:        os.Args[1:],
-		Token:       token,
-		ClusterInfo: loadClusterInfo(),
-	}
-	var credCache *execcredcache.Cache
-	if flags.credentialCachePath != "" {
-		credCache = execcredcache.New(flags.credentialCachePath)
-		if cred := credCache.Get(cacheKey); cred != nil {
-			pLogger.Debug("using cached cluster credential.")
-			return json.NewEncoder(out).Encode(cred)
-		}
-	}
-
-	// If the concierge was configured, exchange the credential for a separate short-lived, cluster-specific credential.
-	if concierge != nil {
-		pLogger.Debug("exchanging static token for cluster credential", "endpoint", flags.conciergeEndpoint, "authenticator type", flags.conciergeAuthenticatorType, "authenticator name", flags.conciergeAuthenticatorName)
-		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-		defer cancel()
-
-		var err error
-		cred, err = deps.exchangeToken(ctx, concierge, token)
-		if err != nil {
-			return fmt.Errorf("could not complete Concierge credential exchange: %w", err)
-		}
-		pLogger.Debug("exchanged static token for cluster credential")
-	}
-
-	// If there was a credential cache, save the resulting credential for future use. We only save to the cache if
-	// the credential came from the concierge, since that's the only static token case where the cache is useful.
-	if credCache != nil && concierge != nil {
-		credCache.Put(cacheKey, cred)
-	}
-
-	return json.NewEncoder(out).Encode(cred)
-}

cmd/pinniped/cmd/login_static_test.go

@@ -1,209 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io/ioutil"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"k8s.io/klog/v2"
-
-	"go.pinniped.dev/internal/testutil/testlogger"
-
-	"github.com/stretchr/testify/require"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	clientauthv1beta1 "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1"
-
-	"go.pinniped.dev/internal/certauthority"
-	"go.pinniped.dev/internal/here"
-	"go.pinniped.dev/internal/testutil"
-	"go.pinniped.dev/pkg/conciergeclient"
-)
-
-func TestLoginStaticCommand(t *testing.T) {
-	cfgDir := mustGetConfigDir()
-
-	testCA, err := certauthority.New("Test CA", 1*time.Hour)
-	require.NoError(t, err)
-	tmpdir := testutil.TempDir(t)
-	testCABundlePath := filepath.Join(tmpdir, "testca.pem")
-	require.NoError(t, ioutil.WriteFile(testCABundlePath, testCA.Bundle(), 0600))
-
-	tests := []struct {
-		name             string
-		args             []string
-		env              map[string]string
-		loginErr         error
-		conciergeErr     error
-		wantError        bool
-		wantStdout       string
-		wantStderr       string
-		wantOptionsCount int
-		wantLogs         []string
-	}{
-		{
-			name: "help flag passed",
-			args: []string{"--help"},
-			wantStdout: here.Doc(`
-				Login using a static token
-
-				Usage:
-				  static [--token TOKEN] [--token-env TOKEN_NAME] [flags]
-
-				Flags:
-				      --concierge-api-group-suffix string     Concierge API group suffix (default "pinniped.dev")
-				      --concierge-authenticator-name string   Concierge authenticator name
-				      --concierge-authenticator-type string   Concierge authenticator type (e.g., 'webhook', 'jwt')
-				      --concierge-ca-bundle-data string       CA bundle to use when connecting to the Concierge
-				      --concierge-endpoint string             API base for the Concierge endpoint
-				      --credential-cache string               Path to cluster-specific credentials cache ("" disables the cache) (default "` + cfgDir + `/credentials.yaml")
-				      --enable-concierge                      Use the Concierge to login
-				  -h, --help                                  help for static
-				      --token string                          Static token to present during login
-				      --token-env string                      Environment variable containing a static token
-			`),
-		},
-		{
-			name:      "missing required flags",
-			args:      []string{},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: one of --token or --token-env must be set
-			`),
-		},
-		{
-			name: "missing concierge flags",
-			args: []string{
-				"--token", "test-token",
-				"--enable-concierge",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: invalid Concierge parameters: endpoint must not be empty
-			`),
-		},
-		{
-			name: "missing env var",
-			args: []string{
-				"--token-env", "TEST_TOKEN_ENV",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: --token-env variable "TEST_TOKEN_ENV" is not set
-			`),
-		},
-		{
-			name: "empty env var",
-			args: []string{
-				"--token-env", "TEST_TOKEN_ENV",
-			},
-			env: map[string]string{
-				"TEST_TOKEN_ENV": "",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: --token-env variable "TEST_TOKEN_ENV" is empty
-			`),
-		},
-		{
-			name: "env var token success",
-			args: []string{
-				"--token-env", "TEST_TOKEN_ENV",
-			},
-			env: map[string]string{
-				"TEST_TOKEN_ENV": "test-token",
-			},
-			wantStdout: `{"kind":"ExecCredential","apiVersion":"client.authentication.k8s.io/v1beta1","spec":{},"status":{"token":"test-token"}}` + "\n",
-		},
-		{
-			name: "concierge failure",
-			args: []string{
-				"--token", "test-token",
-				"--enable-concierge",
-				"--concierge-endpoint", "https://127.0.0.1/",
-				"--concierge-authenticator-type", "webhook",
-				"--concierge-authenticator-name", "test-authenticator",
-			},
-			conciergeErr: fmt.Errorf("some concierge error"),
-			env:          map[string]string{"PINNIPED_DEBUG": "true"},
-			wantError:    true,
-			wantStderr: here.Doc(`
-				Error: could not complete Concierge credential exchange: some concierge error
-			`),
-			wantLogs: []string{"\"level\"=0 \"msg\"=\"Pinniped login: exchanging static token for cluster credential\"  \"authenticator name\"=\"test-authenticator\" \"authenticator type\"=\"webhook\" \"endpoint\"=\"https://127.0.0.1/\""},
-		},
-		{
-			name: "invalid API group suffix",
-			args: []string{
-				"--token", "test-token",
-				"--enable-concierge",
-				"--concierge-api-group-suffix", ".starts.with.dot",
-				"--concierge-authenticator-type", "jwt",
-				"--concierge-authenticator-name", "test-authenticator",
-				"--concierge-endpoint", "https://127.0.0.1:1234/",
-			},
-			wantError: true,
-			wantStderr: here.Doc(`
-				Error: invalid Concierge parameters: invalid API group suffix: a lowercase RFC 1123 subdomain must consist of lower case alphanumeric characters, '-' or '.', and must start and end with an alphanumeric character (e.g. 'example.com', regex used for validation is '[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*')
-			`),
-		},
-		{
-			name: "static token success",
-			args: []string{
-				"--token", "test-token",
-			},
-			env:        map[string]string{"PINNIPED_DEBUG": "true"},
-			wantStdout: `{"kind":"ExecCredential","apiVersion":"client.authentication.k8s.io/v1beta1","spec":{},"status":{"token":"test-token"}}` + "\n",
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			testLogger := testlogger.New(t)
-			klog.SetLogger(testLogger)
-			cmd := staticLoginCommand(staticLoginDeps{
-				lookupEnv: func(s string) (string, bool) {
-					v, ok := tt.env[s]
-					return v, ok
-				},
-				exchangeToken: func(ctx context.Context, client *conciergeclient.Client, token string) (*clientauthv1beta1.ExecCredential, error) {
-					require.Equal(t, token, "test-token")
-					if tt.conciergeErr != nil {
-						return nil, tt.conciergeErr
-					}
-					return &clientauthv1beta1.ExecCredential{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "ExecCredential",
-							APIVersion: "client.authentication.k8s.io/v1beta1",
-						},
-						Status: &clientauthv1beta1.ExecCredentialStatus{
-							Token: "exchanged-token",
-						},
-					}, nil
-				},
-			})
-			require.NotNil(t, cmd)
-
-			var stdout, stderr bytes.Buffer
-			cmd.SetOut(&stdout)
-			cmd.SetErr(&stderr)
-			cmd.SetArgs(tt.args)
-			err := cmd.Execute()
-			if tt.wantError {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-			}
-			require.Equal(t, tt.wantStdout, stdout.String(), "unexpected stdout")
-			require.Equal(t, tt.wantStderr, stderr.String(), "unexpected stderr")
-
-			require.Equal(t, tt.wantLogs, testLogger.Lines())
-		})
-	}
-}

cmd/pinniped/cmd/root.go

@@ -1,34 +0,0 @@
-// Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"os"
-
-	"github.com/spf13/cobra"
-
-	"go.pinniped.dev/internal/plog"
-)
-
-//nolint: gochecknoglobals
-var rootCmd = &cobra.Command{
-	Use:          "pinniped",
-	Short:        "pinniped",
-	Long:         "pinniped is the client-side binary for use with Pinniped-enabled Kubernetes clusters.",
-	SilenceUsage: true, // do not print usage message when commands fail
-}
-
-//nolint: gochecknoinits
-func init() {
-	// We don't want klog flags showing up in our CLI.
-	plog.RemoveKlogGlobalFlags()
-}
-
-// Execute adds all child commands to the root command and sets flags appropriately.
-// This is called by main.main(). It only needs to happen once to the rootCmd.
-func Execute() {
-	if err := rootCmd.Execute(); err != nil {
-		os.Exit(1)
-	}
-}

cmd/pinniped/cmd/testdata/kubeconfig.yaml

@@ -1,39 +0,0 @@
-apiVersion: v1
-clusters:
-  - cluster:
-      certificate-authority-data: ZmFrZS1jZXJ0aWZpY2F0ZS1hdXRob3JpdHktZGF0YS12YWx1ZQ== # fake-certificate-authority-data-value
-      server: https://fake-server-url-value
-    name: kind-cluster
-  - cluster:
-      certificate-authority-data: c29tZS1vdGhlci1mYWtlLWNlcnRpZmljYXRlLWF1dGhvcml0eS1kYXRhLXZhbHVl # some-other-fake-certificate-authority-data-value
-      server: https://some-other-fake-server-url-value
-    name: some-other-cluster
-contexts:
-  - context:
-      cluster: kind-cluster
-      user: kind-user
-    name: kind-context
-  - context:
-      cluster: some-other-cluster
-      user: some-other-user
-    name: some-other-context
-  - context:
-      cluster: invalid-cluster
-      user: some-other-user
-    name: invalid-context-no-such-cluster
-  - context:
-      cluster: some-other-cluster
-      user: invalid-user
-    name: invalid-context-no-such-user
-current-context: kind-context
-kind: Config
-preferences: {}
-users:
-  - name: kind-user
-    user:
-      client-certificate-data: ZmFrZS1jbGllbnQtY2VydGlmaWNhdGUtZGF0YS12YWx1ZQ== # fake-client-certificate-data-value
-      client-key-data: ZmFrZS1jbGllbnQta2V5LWRhdGEtdmFsdWU= # fake-client-key-data-value
-  - name: some-other-user
-    user:
-      client-certificate-data: c29tZS1vdGhlci1mYWtlLWNsaWVudC1jZXJ0aWZpY2F0ZS1kYXRhLXZhbHVl # some-other-fake-client-certificate-data-value
-      client-key-data: c29tZS1vdGhlci1mYWtlLWNsaWVudC1rZXktZGF0YS12YWx1ZQ== # some-other-fake-client-key-data-value

cmd/pinniped/cmd/version.go

@@ -1,28 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-	"k8s.io/component-base/version"
-)
-
-//nolint: gochecknoinits
-func init() {
-	rootCmd.AddCommand(newVersionCommand())
-}
-
-func newVersionCommand() *cobra.Command {
-	return &cobra.Command{
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			fmt.Fprintf(cmd.OutOrStdout(), "%#v\n", version.Get())
-			return nil
-		},
-		Args:  cobra.NoArgs, // do not accept positional arguments for this command
-		Use:   "version",
-		Short: "Print the version of this Pinniped CLI",
-	}
-}

cmd/pinniped/cmd/version_test.go

@@ -1,85 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"go.pinniped.dev/internal/here"
-)
-
-var (
-	knownGoodUsageRegexpForVersion = here.Doc(`
-		Usage:
-		  version \[flags\]
-
-		Flags:
-		  -h, --help   help for version
-
-		`)
-
-	knownGoodHelpRegexpForVersion = here.Doc(`
-		Print the version of this Pinniped CLI
-
-		Usage:
-		  version \[flags\]
-
-		Flags:
-		  -h, --help   help for version
-		`)
-
-	emptyVersionRegexp = `version.Info{Major:"", Minor:"", GitVersion:".*", GitCommit:".*", GitTreeState:"", BuildDate:".*", GoVersion:".*", Compiler:".*", Platform:".*/.*"}`
-)
-
-func TestNewVersionCmd(t *testing.T) {
-	tests := []struct {
-		name             string
-		args             []string
-		wantError        bool
-		wantStdoutRegexp string
-		wantStderrRegexp string
-	}{
-		{
-			name:             "no flags",
-			args:             []string{},
-			wantStdoutRegexp: emptyVersionRegexp + "\n",
-		},
-		{
-			name:             "help flag passed",
-			args:             []string{"--help"},
-			wantStdoutRegexp: knownGoodHelpRegexpForVersion,
-		},
-		{
-			name:             "arg passed",
-			args:             []string{"tuna"},
-			wantError:        true,
-			wantStderrRegexp: `Error: unknown command "tuna" for "version"`,
-			wantStdoutRegexp: knownGoodUsageRegexpForVersion,
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			cmd := newVersionCommand()
-			require.NotNil(t, cmd)
-
-			var stdout, stderr bytes.Buffer
-			cmd.SetOut(&stdout)
-			cmd.SetErr(&stderr)
-			cmd.SetArgs(tt.args)
-			err := cmd.Execute()
-			if tt.wantError {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-			}
-			assert.Regexp(t, tt.wantStdoutRegexp, stdout.String(), "unexpected stdout")
-			assert.Regexp(t, tt.wantStderrRegexp, stderr.String(), "unexpected stderr")
-		})
-	}
-}

cmd/pinniped/cmd/whoami.go

@@ -1,191 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/spf13/cobra"
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/client-go/tools/clientcmd"
-
-	identityv1alpha1 "go.pinniped.dev/generated/latest/apis/concierge/identity/v1alpha1"
-	conciergescheme "go.pinniped.dev/internal/concierge/scheme"
-	"go.pinniped.dev/internal/groupsuffix"
-	"go.pinniped.dev/internal/here"
-)
-
-//nolint: gochecknoinits
-func init() {
-	rootCmd.AddCommand(newWhoamiCommand(getRealConciergeClientset))
-}
-
-type whoamiFlags struct {
-	outputFormat string // e.g., yaml, json, text
-
-	kubeconfigPath            string
-	kubeconfigContextOverride string
-
-	apiGroupSuffix string
-}
-
-type clusterInfo struct {
-	name string
-	url  string
-}
-
-func newWhoamiCommand(getClientset getConciergeClientsetFunc) *cobra.Command {
-	cmd := &cobra.Command{
-		Args:         cobra.NoArgs, // do not accept positional arguments for this command
-		Use:          "whoami",
-		Short:        "Print information about the current user",
-		SilenceUsage: true,
-	}
-	flags := &whoamiFlags{}
-
-	// flags
-	f := cmd.Flags()
-	f.StringVarP(&flags.outputFormat, "output", "o", "text", "Output format (e.g., 'yaml', 'json', 'text')")
-	f.StringVar(&flags.kubeconfigPath, "kubeconfig", os.Getenv("KUBECONFIG"), "Path to kubeconfig file")
-	f.StringVar(&flags.kubeconfigContextOverride, "kubeconfig-context", "", "Kubeconfig context name (default: current active context)")
-	f.StringVar(&flags.apiGroupSuffix, "api-group-suffix", groupsuffix.PinnipedDefaultSuffix, "Concierge API group suffix")
-
-	cmd.RunE = func(cmd *cobra.Command, _ []string) error {
-		return runWhoami(cmd.OutOrStdout(), getClientset, flags)
-	}
-
-	return cmd
-}
-
-func runWhoami(output io.Writer, getClientset getConciergeClientsetFunc, flags *whoamiFlags) error {
-	clientConfig := newClientConfig(flags.kubeconfigPath, flags.kubeconfigContextOverride)
-	clientset, err := getClientset(clientConfig, flags.apiGroupSuffix)
-	if err != nil {
-		return fmt.Errorf("could not configure Kubernetes client: %w", err)
-	}
-
-	clusterInfo, err := getCurrentCluster(clientConfig, flags.kubeconfigContextOverride)
-	if err != nil {
-		return fmt.Errorf("could not get current cluster info: %w", err)
-	}
-
-	ctx, cancelFunc := context.WithTimeout(context.Background(), time.Second*20)
-	defer cancelFunc()
-	whoAmI, err := clientset.IdentityV1alpha1().WhoAmIRequests().Create(ctx, &identityv1alpha1.WhoAmIRequest{}, metav1.CreateOptions{})
-	if err != nil {
-		hint := ""
-		if errors.IsNotFound(err) {
-			hint = " (is the Pinniped WhoAmI API running and healthy?)"
-		}
-		return fmt.Errorf("could not complete WhoAmIRequest%s: %w", hint, err)
-	}
-
-	if err := writeWhoamiOutput(output, flags, clusterInfo, whoAmI); err != nil {
-		return fmt.Errorf("could not write output: %w", err)
-	}
-
-	return nil
-}
-
-func getCurrentCluster(clientConfig clientcmd.ClientConfig, currentContextNameOverride string) (*clusterInfo, error) {
-	currentKubeConfig, err := clientConfig.RawConfig()
-	if err != nil {
-		return nil, err
-	}
-
-	contextName := currentKubeConfig.CurrentContext
-	if len(currentContextNameOverride) > 0 {
-		contextName = currentContextNameOverride
-	}
-
-	unknownClusterInfo := &clusterInfo{name: "???", url: "???"}
-	ctx, ok := currentKubeConfig.Contexts[contextName]
-	if !ok {
-		return unknownClusterInfo, nil
-	}
-
-	cluster, ok := currentKubeConfig.Clusters[ctx.Cluster]
-	if !ok {
-		return unknownClusterInfo, nil
-	}
-
-	return &clusterInfo{name: ctx.Cluster, url: cluster.Server}, nil
-}
-
-func writeWhoamiOutput(output io.Writer, flags *whoamiFlags, cInfo *clusterInfo, whoAmI *identityv1alpha1.WhoAmIRequest) error {
-	switch flags.outputFormat {
-	case "text":
-		return writeWhoamiOutputText(output, cInfo, whoAmI)
-	case "json":
-		return writeWhoamiOutputJSON(output, flags.apiGroupSuffix, whoAmI)
-	case "yaml":
-		return writeWhoamiOutputYAML(output, flags.apiGroupSuffix, whoAmI)
-	default:
-		return fmt.Errorf("unknown output format: %q", flags.outputFormat)
-	}
-}
-
-func writeWhoamiOutputText(output io.Writer, clusterInfo *clusterInfo, whoAmI *identityv1alpha1.WhoAmIRequest) error {
-	fmt.Fprint(output, here.Docf(`
-		Current cluster info:
-
-		Name: %s
-		URL: %s
-
-		Current user info:
-
-		Username: %s
-		Groups: %s
-`, clusterInfo.name, clusterInfo.url, whoAmI.Status.KubernetesUserInfo.User.Username, prettyStrings(whoAmI.Status.KubernetesUserInfo.User.Groups)))
-	return nil
-}
-
-func writeWhoamiOutputJSON(output io.Writer, apiGroupSuffix string, whoAmI *identityv1alpha1.WhoAmIRequest) error {
-	return serialize(output, apiGroupSuffix, whoAmI, runtime.ContentTypeJSON)
-}
-
-func writeWhoamiOutputYAML(output io.Writer, apiGroupSuffix string, whoAmI *identityv1alpha1.WhoAmIRequest) error {
-	return serialize(output, apiGroupSuffix, whoAmI, runtime.ContentTypeYAML)
-}
-
-func serialize(output io.Writer, apiGroupSuffix string, whoAmI *identityv1alpha1.WhoAmIRequest, contentType string) error {
-	scheme, _, identityGV := conciergescheme.New(apiGroupSuffix)
-	codecs := serializer.NewCodecFactory(scheme)
-	respInfo, ok := runtime.SerializerInfoForMediaType(codecs.SupportedMediaTypes(), contentType)
-	if !ok {
-		return fmt.Errorf("unknown content type: %q", contentType)
-	}
-
-	// I have seen the pretty serializer be nil before, so this will hopefully protect against that
-	// corner.
-	serializer := respInfo.PrettySerializer
-	if serializer == nil {
-		serializer = respInfo.Serializer
-	}
-
-	// Ensure that these fields are set so that the JSON/YAML output tells the full story.
-	whoAmI.APIVersion = identityGV.String()
-	whoAmI.Kind = "WhoAmIRequest"
-
-	return serializer.Encode(whoAmI, output)
-}
-
-func prettyStrings(ss []string) string {
-	b := &strings.Builder{}
-	for i, s := range ss {
-		if i != 0 {
-			b.WriteString(", ")
-		}
-		b.WriteString(s)
-	}
-	return b.String()
-}

cmd/pinniped/cmd/whoami_test.go

@@ -1,327 +0,0 @@
-// Copyright 2021 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package cmd
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/runtime"
-	kubetesting "k8s.io/client-go/testing"
-	"k8s.io/client-go/tools/clientcmd"
-
-	identityv1alpha1 "go.pinniped.dev/generated/latest/apis/concierge/identity/v1alpha1"
-	conciergeclientset "go.pinniped.dev/generated/latest/client/concierge/clientset/versioned"
-	fakeconciergeclientset "go.pinniped.dev/generated/latest/client/concierge/clientset/versioned/fake"
-	"go.pinniped.dev/internal/constable"
-	"go.pinniped.dev/internal/here"
-)
-
-func TestWhoami(t *testing.T) {
-	tests := []struct {
-		name                   string
-		args                   []string
-		groupsOverride         []string
-		gettingClientsetErr    error
-		callingAPIErr          error
-		wantError              bool
-		wantStdout, wantStderr string
-	}{
-		{
-			name: "help flag",
-			args: []string{"--help"},
-			wantStdout: here.Doc(`
-				Print information about the current user
-
-				Usage:
-				  whoami [flags]
-
-				Flags:
-				      --api-group-suffix string     Concierge API group suffix (default "pinniped.dev")
-				  -h, --help                        help for whoami
-				      --kubeconfig string           Path to kubeconfig file
-				      --kubeconfig-context string   Kubeconfig context name (default: current active context)
-				  -o, --output string               Output format (e.g., 'yaml', 'json', 'text') (default "text")
-			`),
-		},
-		{
-			name: "text output",
-			args: []string{"--kubeconfig", "testdata/kubeconfig.yaml"},
-			wantStdout: here.Doc(`
-				Current cluster info:
-
-				Name: kind-cluster
-				URL: https://fake-server-url-value
-
-				Current user info:
-
-				Username: some-username
-				Groups: some-group-0, some-group-1
-			`),
-		},
-		{
-			name: "text output with long output flag",
-			args: []string{"--kubeconfig", "testdata/kubeconfig.yaml", "--output", "text"},
-			wantStdout: here.Doc(`
-				Current cluster info:
-
-				Name: kind-cluster
-				URL: https://fake-server-url-value
-
-				Current user info:
-
-				Username: some-username
-				Groups: some-group-0, some-group-1
-			`),
-		},
-		{
-			name:           "text output with 1 group",
-			args:           []string{"--kubeconfig", "testdata/kubeconfig.yaml", "--output", "text"},
-			groupsOverride: []string{"some-group-0"},
-			wantStdout: here.Doc(`
-				Current cluster info:
-
-				Name: kind-cluster
-				URL: https://fake-server-url-value
-
-				Current user info:
-
-				Username: some-username
-				Groups: some-group-0
-			`),
-		},
-		{
-			name:           "text output with no groups",
-			args:           []string{"--kubeconfig", "testdata/kubeconfig.yaml", "--output", "text"},
-			groupsOverride: []string{},
-			wantStdout: here.Doc(`
-				Current cluster info:
-
-				Name: kind-cluster
-				URL: https://fake-server-url-value
-
-				Current user info:
-
-				Username: some-username
-				Groups: 
-			`),
-		},
-		{
-			name: "json output",
-			args: []string{"--kubeconfig", "testdata/kubeconfig.yaml", "-o", "json"},
-			wantStdout: here.Doc(`
-				{
-				  "kind": "WhoAmIRequest",
-				  "apiVersion": "identity.concierge.pinniped.dev/v1alpha1",
-				  "metadata": {
-				    "creationTimestamp": null
-				  },
-				  "spec": {},
-				  "status": {
-				    "kubernetesUserInfo": {
-				      "user": {
-				        "username": "some-username",
-				        "groups": [
-				          "some-group-0",
-				          "some-group-1"
-				        ]
-				      }
-				    }
-				  }
-				}`),
-		},
-		{
-			name: "json output with api group suffix flag",
-			args: []string{"--kubeconfig", "testdata/kubeconfig.yaml", "-o", "json", "--api-group-suffix", "tuna.io"},
-			wantStdout: here.Doc(`
-				{
-				  "kind": "WhoAmIRequest",
-				  "apiVersion": "identity.concierge.tuna.io/v1alpha1",
-				  "metadata": {
-				    "creationTimestamp": null
-				  },
-				  "spec": {},
-				  "status": {
-				    "kubernetesUserInfo": {
-				      "user": {
-				        "username": "some-username",
-				        "groups": [
-				          "some-group-0",
-				          "some-group-1"
-				        ]
-				      }
-				    }
-				  }
-				}`),
-		},
-		{
-			name: "yaml output",
-			args: []string{"--kubeconfig", "testdata/kubeconfig.yaml", "-o", "yaml"},
-			wantStdout: here.Doc(`
-				apiVersion: identity.concierge.pinniped.dev/v1alpha1
-				kind: WhoAmIRequest
-				metadata:
-				  creationTimestamp: null
-				spec: {}
-				status:
-				  kubernetesUserInfo:
-				    user:
-				      groups:
-				      - some-group-0
-				      - some-group-1
-				      username: some-username
-			`),
-		},
-		{
-			name: "yaml output with api group suffix",
-			args: []string{"--kubeconfig", "testdata/kubeconfig.yaml", "-o", "yaml", "--api-group-suffix", "tuna.io"},
-			wantStdout: here.Doc(`
-				apiVersion: identity.concierge.tuna.io/v1alpha1
-				kind: WhoAmIRequest
-				metadata:
-				  creationTimestamp: null
-				spec: {}
-				status:
-				  kubernetesUserInfo:
-				    user:
-				      groups:
-				      - some-group-0
-				      - some-group-1
-				      username: some-username
-			`),
-		},
-		{
-			name:       "extra args",
-			args:       []string{"extra-arg"},
-			wantError:  true,
-			wantStderr: "Error: unknown command \"extra-arg\" for \"whoami\"\n",
-		},
-		{
-			name:       "cannot get cluster info",
-			args:       []string{"--kubeconfig", "this-file-does-not-exist"},
-			wantError:  true,
-			wantStderr: "Error: could not get current cluster info: stat this-file-does-not-exist: no such file or directory\n",
-		},
-		{
-			name: "different kubeconfig context, but same as current",
-			args: []string{
-				"--kubeconfig", "./testdata/kubeconfig.yaml",
-				"--kubeconfig-context", "kind-context",
-			},
-			wantStdout: here.Doc(`
-				Current cluster info:
-
-				Name: kind-cluster
-				URL: https://fake-server-url-value
-
-				Current user info:
-
-				Username: some-username
-				Groups: some-group-0, some-group-1
-			`),
-		},
-		{
-			name: "different kubeconfig context, not current",
-			args: []string{
-				"--kubeconfig", "./testdata/kubeconfig.yaml",
-				"--kubeconfig-context", "some-other-context",
-			},
-			wantStdout: here.Doc(`
-				Current cluster info:
-
-				Name: some-other-cluster
-				URL: https://some-other-fake-server-url-value
-
-				Current user info:
-
-				Username: some-username
-				Groups: some-group-0, some-group-1
-			`),
-		},
-		{
-			name: "invalid kubeconfig context prints ???",
-			args: []string{
-				"--kubeconfig", "./testdata/kubeconfig.yaml",
-				"--kubeconfig-context", "invalid",
-			},
-			wantStdout: here.Doc(`
-				Current cluster info:
-
-				Name: ???
-				URL: ???
-
-				Current user info:
-
-				Username: some-username
-				Groups: some-group-0, some-group-1
-			`),
-		},
-		{
-			name:                "getting clientset fails",
-			gettingClientsetErr: constable.Error("some get clientset error"),
-			wantError:           true,
-			wantStderr:          "Error: could not configure Kubernetes client: some get clientset error\n",
-		},
-		{
-			name:          "calling API fails",
-			callingAPIErr: constable.Error("some API error"),
-			wantError:     true,
-			wantStderr:    "Error: could not complete WhoAmIRequest: some API error\n",
-		},
-		{
-			name:          "calling API fails because WhoAmI API is not installed",
-			callingAPIErr: errors.NewNotFound(identityv1alpha1.SchemeGroupVersion.WithResource("whoamirequests").GroupResource(), "whatever"),
-			wantError:     true,
-			wantStderr:    "Error: could not complete WhoAmIRequest (is the Pinniped WhoAmI API running and healthy?): whoamirequests.identity.concierge.pinniped.dev \"whatever\" not found\n",
-		},
-	}
-	for _, test := range tests {
-		test := test
-		t.Run(test.name, func(t *testing.T) {
-			getClientset := func(clientConfig clientcmd.ClientConfig, apiGroupSuffix string) (conciergeclientset.Interface, error) {
-				if test.gettingClientsetErr != nil {
-					return nil, test.gettingClientsetErr
-				}
-				clientset := fakeconciergeclientset.NewSimpleClientset()
-				clientset.PrependReactor("create", "whoamirequests", func(_ kubetesting.Action) (bool, runtime.Object, error) {
-					if test.callingAPIErr != nil {
-						return true, nil, test.callingAPIErr
-					}
-					groups := []string{"some-group-0", "some-group-1"}
-					if test.groupsOverride != nil {
-						groups = test.groupsOverride
-					}
-					return true, &identityv1alpha1.WhoAmIRequest{
-						Status: identityv1alpha1.WhoAmIRequestStatus{
-							KubernetesUserInfo: identityv1alpha1.KubernetesUserInfo{
-								User: identityv1alpha1.UserInfo{
-									Username: "some-username",
-									Groups:   groups,
-								},
-							},
-						},
-					}, nil
-				})
-				return clientset, nil
-			}
-			cmd := newWhoamiCommand(getClientset)
-
-			stdout, stderr := bytes.NewBuffer([]byte{}), bytes.NewBuffer([]byte{})
-			cmd.SetOut(stdout)
-			cmd.SetErr(stderr)
-			cmd.SetArgs(test.args)
-
-			err := cmd.Execute()
-			if test.wantError {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-			}
-			require.Equal(t, test.wantStdout, stdout.String())
-			require.Equal(t, test.wantStderr, stderr.String())
-		})
-	}
-}

cmd/pinniped/main.go

@@ -1,10 +0,0 @@
-// Copyright 2020 the Pinniped contributors. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package main
-
-import "go.pinniped.dev/cmd/pinniped/cmd"
-
-func main() {
-	cmd.Execute()
-}

deploy/concierge/README.md

@@ -1,3 +0,0 @@
-# Pinniped Concierge Deployment
-
-See [the how-to guide for details](https://pinniped.dev/docs/howto/install-concierge/).

deploy/concierge/authentication.concierge.pinniped.dev_jwtauthenticators.yaml

@@ -1,171 +0,0 @@
-
----
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  annotations:
-    controller-gen.kubebuilder.io/version: v0.4.0
-  creationTimestamp: null
-  name: jwtauthenticators.authentication.concierge.pinniped.dev
-spec:
-  group: authentication.concierge.pinniped.dev
-  names:
-    categories:
-    - pinniped
-    - pinniped-authenticator
-    - pinniped-authenticators
-    kind: JWTAuthenticator
-    listKind: JWTAuthenticatorList
-    plural: jwtauthenticators
-    singular: jwtauthenticator
-  scope: Cluster
-  versions:
-  - additionalPrinterColumns:
-    - jsonPath: .spec.issuer
-      name: Issuer
-      type: string
-    name: v1alpha1
-    schema:
-      openAPIV3Schema:
-        description: "JWTAuthenticator describes the configuration of a JWT authenticator.
-          \n Upon receiving a signed JWT, a JWTAuthenticator will performs some validation
-          on it (e.g., valid signature, existence of claims, etc.) and extract the
-          username and groups from the token."
-        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: Spec for configuring the authenticator.
-            properties:
-              audience:
-                description: Audience is the required value of the "aud" JWT claim.
-                minLength: 1
-                type: string
-              claims:
-                description: Claims allows customization of the claims that will be
-                  mapped to user identity for Kubernetes access.
-                properties:
-                  groups:
-                    description: Groups is the name of the claim which should be read
-                      to extract the user's group membership from the JWT token. When
-                      not specified, it will default to "groups".
-                    type: string
-                  username:
-                    description: Username is the name of the claim which should be
-                      read to extract the username from the JWT token. When not specified,
-                      it will default to "username".
-                    type: string
-                type: object
-              issuer:
-                description: Issuer is the OIDC issuer URL that will be used to discover
-                  public signing keys. Issuer is also used to validate the "iss" JWT
-                  claim.
-                minLength: 1
-                pattern: ^https://
-                type: string
-              tls:
-                description: TLS configuration for communicating with the OIDC provider.
-                properties:
-                  certificateAuthorityData:
-                    description: X.509 Certificate Authority (base64-encoded PEM bundle).
-                      If omitted, a default set of system roots will be trusted.
-                    type: string
-                type: object
-            required:
-            - audience
-            - issuer
-            type: object
-          status:
-            description: Status of the authenticator.
-            properties:
-              conditions:
-                description: Represents the observations of the authenticator's current
-                  state.
-                items:
-                  description: Condition status of a resource (mirrored from the metav1.Condition
-                    type added in Kubernetes 1.19). In a future API version we can
-                    switch to using the upstream type. See https://github.com/kubernetes/apimachinery/blob/v0.19.0/pkg/apis/meta/v1/types.go#L1353-L1413.
-                  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
-                x-kubernetes-list-map-keys:
-                - type
-                x-kubernetes-list-type: map
-            type: object
-        required:
-        - spec
-        type: object
-    served: true
-    storage: true
-    subresources:
-      status: {}
-status:
-  acceptedNames:
-    kind: ""
-    plural: ""
-  conditions: []
-  storedVersions: []

deploy/concierge/authentication.concierge.pinniped.dev_webhookauthenticators.yaml

@@ -1,147 +0,0 @@
-
----
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  annotations:
-    controller-gen.kubebuilder.io/version: v0.4.0
-  creationTimestamp: null
-  name: webhookauthenticators.authentication.concierge.pinniped.dev
-spec:
-  group: authentication.concierge.pinniped.dev
-  names:
-    categories:
-    - pinniped
-    - pinniped-authenticator
-    - pinniped-authenticators
-    kind: WebhookAuthenticator
-    listKind: WebhookAuthenticatorList
-    plural: webhookauthenticators
-    singular: webhookauthenticator
-  scope: Cluster
-  versions:
-  - additionalPrinterColumns:
-    - jsonPath: .spec.endpoint
-      name: Endpoint
-      type: string
-    name: v1alpha1
-    schema:
-      openAPIV3Schema:
-        description: WebhookAuthenticator describes the configuration of a webhook
-          authenticator.
-        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: Spec for configuring the authenticator.
-            properties:
-              endpoint:
-                description: Webhook server endpoint URL.
-                minLength: 1
-                pattern: ^https://
-                type: string
-              tls:
-                description: TLS configuration.
-                properties:
-                  certificateAuthorityData:
-                    description: X.509 Certificate Authority (base64-encoded PEM bundle).
-                      If omitted, a default set of system roots will be trusted.
-                    type: string
-                type: object
-            required:
-            - endpoint
-            type: object
-          status:
-            description: Status of the authenticator.
-            properties:
-              conditions:
-                description: Represents the observations of the authenticator's current
-                  state.
-                items:
-                  description: Condition status of a resource (mirrored from the metav1.Condition
-                    type added in Kubernetes 1.19). In a future API version we can
-                    switch to using the upstream type. See https://github.com/kubernetes/apimachinery/blob/v0.19.0/pkg/apis/meta/v1/types.go#L1353-L1413.
-                  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
-                x-kubernetes-list-map-keys:
-                - type
-                x-kubernetes-list-type: map
-            type: object
-        required:
-        - spec
-        type: object
-    served: true
-    storage: true
-    subresources:
-      status: {}
-status:
-  acceptedNames:
-    kind: ""
-    plural: ""
-  conditions: []
-  storedVersions: []

deploy/concierge/config.concierge.pinniped.dev_credentialissuers.yaml

@@ -1,237 +0,0 @@
-
----
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  annotations:
-    controller-gen.kubebuilder.io/version: v0.4.0
-  creationTimestamp: null
-  name: credentialissuers.config.concierge.pinniped.dev
-spec:
-  group: config.concierge.pinniped.dev
-  names:
-    categories:
-    - pinniped
-    kind: CredentialIssuer
-    listKind: CredentialIssuerList
-    plural: credentialissuers
-    singular: credentialissuer
-  scope: Cluster
-  versions:
-  - name: v1alpha1
-    schema:
-      openAPIV3Schema:
-        description: CredentialIssuer describes the configuration and status of the
-          Pinniped Concierge credential issuer.
-        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: Spec describes the intended configuration of the Concierge.
-            properties:
-              impersonationProxy:
-                description: ImpersonationProxy describes the intended configuration
-                  of the Concierge impersonation proxy.
-                properties:
-                  externalEndpoint:
-                    description: "ExternalEndpoint describes the HTTPS endpoint where
-                      the proxy will be exposed. If not set, the proxy will be served
-                      using the external name of the LoadBalancer service or the cluster
-                      service DNS name. \n This field must be non-empty when spec.impersonationProxy.service.mode
-                      is \"None\"."
-                    type: string
-                  mode:
-                    description: 'Mode configures whether the impersonation proxy
-                      should be started: - "disabled" explicitly disables the impersonation
-                      proxy. This is the default. - "enabled" explicitly enables the
-                      impersonation proxy. - "auto" enables or disables the impersonation
-                      proxy based upon the cluster in which it is running.'
-                    enum:
-                    - auto
-                    - enabled
-                    - disabled
-                    type: string
-                  service:
-                    default:
-                      type: LoadBalancer
-                    description: Service describes the configuration of the Service
-                      provisioned to expose the impersonation proxy to clients.
-                    properties:
-                      annotations:
-                        additionalProperties:
-                          type: string
-                        description: Annotations specifies zero or more key/value
-                          pairs to set as annotations on the provisioned Service.
-                        type: object
-                      loadBalancerIP:
-                        description: LoadBalancerIP specifies the IP address to set
-                          in the spec.loadBalancerIP field of the provisioned Service.
-                          This is not supported on all cloud providers.
-                        maxLength: 255
-                        minLength: 1
-                        type: string
-                      type:
-                        default: LoadBalancer
-                        description: "Type specifies the type of Service to provision
-                          for the impersonation proxy. \n If the type is \"None\",
-                          then the \"spec.impersonationProxy.externalEndpoint\" field
-                          must be set to a non-empty value so that the Concierge can
-                          properly advertise the endpoint in the CredentialIssuer's
-                          status."
-                        enum:
-                        - LoadBalancer
-                        - ClusterIP
-                        - None
-                        type: string
-                    type: object
-                required:
-                - mode
-                - service
-                type: object
-            required:
-            - impersonationProxy
-            type: object
-          status:
-            description: CredentialIssuerStatus describes the status of the Concierge.
-            properties:
-              kubeConfigInfo:
-                description: Information needed to form a valid Pinniped-based kubeconfig
-                  using this credential issuer. This field is deprecated and will
-                  be removed in a future version.
-                properties:
-                  certificateAuthorityData:
-                    description: The K8s API server CA bundle.
-                    minLength: 1
-                    type: string
-                  server:
-                    description: The K8s API server URL.
-                    minLength: 1
-                    pattern: ^https://|^http://
-                    type: string
-                required:
-                - certificateAuthorityData
-                - server
-                type: object
-              strategies:
-                description: List of integration strategies that were attempted by
-                  Pinniped.
-                items:
-                  description: CredentialIssuerStrategy describes the status of an
-                    integration strategy that was attempted by Pinniped.
-                  properties:
-                    frontend:
-                      description: Frontend describes how clients can connect using
-                        this strategy.
-                      properties:
-                        impersonationProxyInfo:
-                          description: ImpersonationProxyInfo describes the parameters
-                            for the impersonation proxy on this Concierge. This field
-                            is only set when Type is "ImpersonationProxy".
-                          properties:
-                            certificateAuthorityData:
-                              description: CertificateAuthorityData is the base64-encoded
-                                PEM CA bundle of the impersonation proxy.
-                              minLength: 1
-                              type: string
-                            endpoint:
-                              description: Endpoint is the HTTPS endpoint of the impersonation
-                                proxy.
-                              minLength: 1
-                              pattern: ^https://
-                              type: string
-                          required:
-                          - certificateAuthorityData
-                          - endpoint
-                          type: object
-                        tokenCredentialRequestInfo:
-                          description: TokenCredentialRequestAPIInfo describes the
-                            parameters for the TokenCredentialRequest API on this
-                            Concierge. This field is only set when Type is "TokenCredentialRequestAPI".
-                          properties:
-                            certificateAuthorityData:
-                              description: CertificateAuthorityData is the base64-encoded
-                                Kubernetes API server CA bundle.
-                              minLength: 1
-                              type: string
-                            server:
-                              description: Server is the Kubernetes API server URL.
-                              minLength: 1
-                              pattern: ^https://|^http://
-                              type: string
-                          required:
-                          - certificateAuthorityData
-                          - server
-                          type: object
-                        type:
-                          description: Type describes which frontend mechanism clients
-                            can use with a strategy.
-                          enum:
-                          - TokenCredentialRequestAPI
-                          - ImpersonationProxy
-                          type: string
-                      required:
-                      - type
-                      type: object
-                    lastUpdateTime:
-                      description: When the status was last checked.
-                      format: date-time
-                      type: string
-                    message:
-                      description: Human-readable description of the current status.
-                      minLength: 1
-                      type: string
-                    reason:
-                      description: Reason for the current status.
-                      enum:
-                      - Listening
-                      - Pending
-                      - Disabled
-                      - ErrorDuringSetup
-                      - CouldNotFetchKey
-                      - CouldNotGetClusterInfo
-                      - FetchedKey
-                      type: string
-                    status:
-                      description: Status of the attempted integration strategy.
-                      enum:
-                      - Success
-                      - Error
-                      type: string
-                    type:
-                      description: Type of integration attempted.
-                      enum:
-                      - KubeClusterSigningCertificate
-                      - ImpersonationProxy
-                      type: string
-                  required:
-                  - lastUpdateTime
-                  - message
-                  - reason
-                  - status
-                  - type
-                  type: object
-                type: array
-            required:
-            - strategies
-            type: object
-        type: object
-    served: true
-    storage: true
-    subresources:
-      status: {}
-status:
-  acceptedNames:
-    kind: ""
-    plural: ""
-  conditions: []
-  storedVersions: []

deploy/concierge/deployment.yaml

@@ -1,300 +0,0 @@
-#! Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-#! SPDX-License-Identifier: Apache-2.0
-
-#@ load("@ytt:data", "data")
-#@ load("@ytt:json", "json")
-#@ load("helpers.lib.yaml", "defaultLabel", "labels", "namespace", "defaultResourceName", "defaultResourceNameWithSuffix", "getAndValidateLogLevel", "pinnipedDevAPIGroupWithPrefix")
-
-#@ if not data.values.into_namespace:
----
-apiVersion: v1
-kind: Namespace
-metadata:
-  name: #@ data.values.namespace
-  labels: #@ labels()
-#@ end
----
-apiVersion: v1
-kind: ServiceAccount
-metadata:
-  name: #@ defaultResourceName()
-  namespace: #@ namespace()
-  labels: #@ labels()
----
-apiVersion: v1
-kind: ServiceAccount
-metadata:
-  name: #@ defaultResourceNameWithSuffix("kube-cert-agent")
-  namespace: #@ namespace()
-  labels: #@ labels()
----
-apiVersion: v1
-kind: ServiceAccount
-metadata:
-  name: #@ defaultResourceNameWithSuffix("impersonation-proxy")
-  namespace: #@ namespace()
-  labels: #@ labels()
-  annotations:
-    #! we need to create this service account before we create the secret
-    kapp.k14s.io/change-group: "impersonation-proxy.concierge.pinniped.dev/serviceaccount"
-secrets: #! make sure the token controller does not create any other secrets
-- name: #@ defaultResourceNameWithSuffix("impersonation-proxy")
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: #@ defaultResourceNameWithSuffix("config")
-  namespace: #@ namespace()
-  labels: #@ labels()
-data:
-  #! If names.apiService is changed in this ConfigMap, must also change name of the ClusterIP Service resource below.
-  #@yaml/text-templated-strings
-  pinniped.yaml: |
-    discovery:
-      url: (@= data.values.discovery_url or "null" @)
-    api:
-      servingCertificate:
-        durationSeconds: (@= str(data.values.api_serving_certificate_duration_seconds) @)
-        renewBeforeSeconds: (@= str(data.values.api_serving_certificate_renew_before_seconds) @)
-    apiGroupSuffix: (@= data.values.api_group_suffix @)
-    names:
-      servingCertificateSecret: (@= defaultResourceNameWithSuffix("api-tls-serving-certificate") @)
-      credentialIssuer: (@= defaultResourceNameWithSuffix("config") @)
-      apiService: (@= defaultResourceNameWithSuffix("api") @)
-      impersonationLoadBalancerService: (@= defaultResourceNameWithSuffix("impersonation-proxy-load-balancer") @)
-      impersonationClusterIPService: (@= defaultResourceNameWithSuffix("impersonation-proxy-cluster-ip") @)
-      impersonationTLSCertificateSecret: (@= defaultResourceNameWithSuffix("impersonation-proxy-tls-serving-certificate") @)
-      impersonationCACertificateSecret: (@= defaultResourceNameWithSuffix("impersonation-proxy-ca-certificate") @)
-      impersonationSignerSecret: (@= defaultResourceNameWithSuffix("impersonation-proxy-signer-ca-certificate") @)
-      agentServiceAccount: (@= defaultResourceNameWithSuffix("kube-cert-agent") @)
-    labels: (@= json.encode(labels()).rstrip() @)
-    kubeCertAgent:
-      namePrefix: (@= defaultResourceNameWithSuffix("kube-cert-agent-") @)
-      (@ if data.values.kube_cert_agent_image: @)
-      image: (@= data.values.kube_cert_agent_image @)
-      (@ else: @)
-      (@ if data.values.image_digest: @)
-      image: (@= data.values.image_repo + "@" + data.values.image_digest @)
-      (@ else: @)
-      image: (@= data.values.image_repo + ":" + data.values.image_tag @)
-      (@ end @)
-      (@ end @)
-      (@ if data.values.image_pull_dockerconfigjson: @)
-      imagePullSecrets:
-        - image-pull-secret
-      (@ end @)
-    (@ if data.values.log_level: @)
-    logLevel: (@= getAndValidateLogLevel() @)
-    (@ end @)
----
-#@ if data.values.image_pull_dockerconfigjson and data.values.image_pull_dockerconfigjson != "":
-apiVersion: v1
-kind: Secret
-metadata:
-  name: image-pull-secret
-  namespace: #@ namespace()
-  labels: #@ labels()
-type: kubernetes.io/dockerconfigjson
-data:
-  .dockerconfigjson: #@ data.values.image_pull_dockerconfigjson
-#@ end
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: #@ defaultResourceName()
-  namespace: #@ namespace()
-  labels: #@ labels()
-spec:
-  replicas: #@ data.values.replicas
-  selector:
-    matchLabels: #@ defaultLabel()
-  template:
-    metadata:
-      labels: #@ defaultLabel()
-      annotations:
-        scheduler.alpha.kubernetes.io/critical-pod: ""
-    spec:
-      securityContext:
-        runAsUser: #@ data.values.run_as_user
-        runAsGroup: #@ data.values.run_as_group
-      serviceAccountName: #@ defaultResourceName()
-      #@ if data.values.image_pull_dockerconfigjson and data.values.image_pull_dockerconfigjson != "":
-      imagePullSecrets:
-        - name: image-pull-secret
-      #@ end
-      containers:
-        - name: #@ defaultResourceName()
-          #@ if data.values.image_digest:
-          image:  #@ data.values.image_repo + "@" + data.values.image_digest
-          #@ else:
-          image: #@ data.values.image_repo + ":" + data.values.image_tag
-          #@ end
-          imagePullPolicy: IfNotPresent
-          resources:
-            requests:
-              cpu: "100m"
-              memory: "128Mi"
-            limits:
-              cpu: "100m"
-              memory: "128Mi"
-          args:
-            - --config=/etc/config/pinniped.yaml
-            - --downward-api-path=/etc/podinfo
-          volumeMounts:
-            - name: config-volume
-              mountPath: /etc/config
-            - name: podinfo
-              mountPath: /etc/podinfo
-            - name: impersonation-proxy
-              mountPath: /var/run/secrets/impersonation-proxy.concierge.pinniped.dev/serviceaccount
-          livenessProbe:
-            httpGet:
-              path: /healthz
-              port: 8443
-              scheme: HTTPS
-            initialDelaySeconds: 2
-            timeoutSeconds: 15
-            periodSeconds: 10
-            failureThreshold: 5
-          readinessProbe:
-            httpGet:
-              path: /healthz
-              port: 8443
-              scheme: HTTPS
-            initialDelaySeconds: 2
-            timeoutSeconds: 3
-            periodSeconds: 10
-            failureThreshold: 3
-      volumes:
-        - name: config-volume
-          configMap:
-            name: #@ defaultResourceNameWithSuffix("config")
-        - name: impersonation-proxy
-          secret:
-            secretName: #@ defaultResourceNameWithSuffix("impersonation-proxy")
-            items: #! make sure our pod does not start until the token controller has a chance to populate the secret
-              - key: token
-                path: token
-        - name: podinfo
-          downwardAPI:
-            items:
-              - path: "labels"
-                fieldRef:
-                  fieldPath: metadata.labels
-              - path: "name"
-                fieldRef:
-                  fieldPath: metadata.name
-              - path: "namespace"
-                fieldRef:
-                  fieldPath: metadata.namespace
-      tolerations:
-        - key: CriticalAddonsOnly
-          operator: Exists
-        - key: node-role.kubernetes.io/master #! Allow running on master nodes too
-          effect: NoSchedule
-      #! "system-cluster-critical" cannot be used outside the kube-system namespace until Kubernetes >= 1.17,
-      #! so we skip setting this for now (see https://github.com/kubernetes/kubernetes/issues/60596).
-      #!priorityClassName: system-cluster-critical
-      #! This will help make sure our multiple pods run on different nodes, making
-      #! our deployment "more" "HA".
-      affinity:
-        podAntiAffinity:
-          preferredDuringSchedulingIgnoredDuringExecution:
-            - weight: 50
-              podAffinityTerm:
-                labelSelector:
-                  matchLabels: #@ defaultLabel()
-                topologyKey: kubernetes.io/hostname
----
-apiVersion: v1
-kind: Service
-metadata:
-  #! If name is changed, must also change names.apiService in the ConfigMap above and spec.service.name in the APIService below.
-  name: #@ defaultResourceNameWithSuffix("api")
-  namespace: #@ namespace()
-  labels: #@ labels()
-spec:
-  type: ClusterIP
-  selector: #@ defaultLabel()
-  ports:
-    - protocol: TCP
-      port: 443
-      targetPort: 8443
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: #@ defaultResourceNameWithSuffix("proxy")
-  namespace: #@ namespace()
-  labels: #@ labels()
-spec:
-  type: ClusterIP
-  selector: #@ defaultLabel()
-  ports:
-    - protocol: TCP
-      port: 443
-      targetPort: 8444
----
-apiVersion: apiregistration.k8s.io/v1
-kind: APIService
-metadata:
-  name: #@ pinnipedDevAPIGroupWithPrefix("v1alpha1.login.concierge")
-  labels: #@ labels()
-spec:
-  version: v1alpha1
-  group: #@ pinnipedDevAPIGroupWithPrefix("login.concierge")
-  groupPriorityMinimum: 9900
-  versionPriority: 15
-  #! caBundle: Do not include this key here. Starts out null, will be updated/owned by the golang code.
-  service:
-    name: #@ defaultResourceNameWithSuffix("api")
-    namespace: #@ namespace()
-    port: 443
----
-apiVersion: apiregistration.k8s.io/v1
-kind: APIService
-metadata:
-  name: #@ pinnipedDevAPIGroupWithPrefix("v1alpha1.identity.concierge")
-  labels: #@ labels()
-spec:
-  version: v1alpha1
-  group: #@ pinnipedDevAPIGroupWithPrefix("identity.concierge")
-  groupPriorityMinimum: 9900
-  versionPriority: 15
-  #! caBundle: Do not include this key here. Starts out null, will be updated/owned by the golang code.
-  service:
-    name: #@ defaultResourceNameWithSuffix("api")
-    namespace: #@ namespace()
-    port: 443
----
-apiVersion: #@ pinnipedDevAPIGroupWithPrefix("config.concierge") + "/v1alpha1"
-kind: CredentialIssuer
-metadata:
-  name: #@ defaultResourceNameWithSuffix("config")
-  labels: #@ labels()
-spec:
-  impersonationProxy:
-    mode: #@ data.values.impersonation_proxy_spec.mode
-    #@ if data.values.impersonation_proxy_spec.external_endpoint:
-    externalEndpoint: #@ data.values.impersonation_proxy_spec.external_endpoint
-    #@ end
-    service:
-      type: #@ data.values.impersonation_proxy_spec.service.type
-      #@ if data.values.impersonation_proxy_spec.service.load_balancer_ip:
-      loadBalancerIP: #@ data.values.impersonation_proxy_spec.service.load_balancer_ip
-      #@ end
-      annotations: #@ data.values.impersonation_proxy_spec.service.annotations
----
-apiVersion: v1
-kind: Secret
-metadata:
-  name: #@ defaultResourceNameWithSuffix("impersonation-proxy")
-  namespace: #@ namespace()
-  labels: #@ labels()
-  annotations:
-    #! wait until the SA exists to create this secret so that the token controller does not delete it
-    #! we have this secret at the end so that kubectl will create the service account first
-    kapp.k14s.io/change-rule: "upsert after upserting impersonation-proxy.concierge.pinniped.dev/serviceaccount"
-    kubernetes.io/service-account.name: #@ defaultResourceNameWithSuffix("impersonation-proxy")
-type: kubernetes.io/service-account-token

deploy/concierge/helpers.lib.yaml

@@ -1,42 +0,0 @@
-#! Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-#! SPDX-License-Identifier: Apache-2.0
-
-#@ load("@ytt:data", "data")
-#@ load("@ytt:template", "template")
-
-#@ def defaultResourceName():
-#@   return data.values.app_name
-#@ end
-
-#@ def defaultResourceNameWithSuffix(suffix):
-#@   return data.values.app_name + "-" + suffix
-#@ end
-
-#@ def pinnipedDevAPIGroupWithPrefix(prefix):
-#@   return prefix + "." + data.values.api_group_suffix
-#@ end
-
-#@ def namespace():
-#@   if data.values.into_namespace:
-#@     return data.values.into_namespace
-#@   else:
-#@     return data.values.namespace
-#@   end
-#@ end
-
-#@ def defaultLabel():
-app: #@ data.values.app_name
-#@ end
-
-#@ def labels():
-_: #@ template.replace(defaultLabel())
-_: #@ template.replace(data.values.custom_labels)
-#@ end
-
-#@ def getAndValidateLogLevel():
-#@   log_level = data.values.log_level
-#@   if log_level != "info" and log_level != "debug" and log_level != "trace" and log_level != "all":
-#@     fail("log_level '" + log_level + "' is invalid")
-#@   end
-#@   return log_level
-#@ end

deploy/concierge/rbac.yaml

@@ -1,293 +0,0 @@
-#! Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-#! SPDX-License-Identifier: Apache-2.0
-
-#@ load("@ytt:data", "data")
-#@ load("helpers.lib.yaml", "labels", "namespace", "defaultResourceName", "defaultResourceNameWithSuffix", "pinnipedDevAPIGroupWithPrefix")
-
-#! Give permission to various cluster-scoped objects
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: ClusterRole
-metadata:
-  name: #@ defaultResourceNameWithSuffix("aggregated-api-server")
-  labels: #@ labels()
-rules:
-  - apiGroups: [ "" ]
-    resources: [ namespaces ]
-    verbs: [ get, list, watch ]
-  - apiGroups: [ apiregistration.k8s.io ]
-    resources: [ apiservices ]
-    verbs: [ get, list, patch, update, watch ]
-  - apiGroups: [ admissionregistration.k8s.io ]
-    resources: [ validatingwebhookconfigurations, mutatingwebhookconfigurations ]
-    verbs: [ get, list, watch ]
-  - apiGroups: [ flowcontrol.apiserver.k8s.io ]
-    resources: [ flowschemas, prioritylevelconfigurations ]
-    verbs: [ get, list, watch ]
-  - apiGroups: [ security.openshift.io ]
-    resources: [ securitycontextconstraints ]
-    verbs: [ use ]
-    resourceNames: [ nonroot ]
-  - apiGroups: [ "" ]
-    resources: [ nodes ]
-    verbs: [ list ]
-  - apiGroups:
-      - #@ pinnipedDevAPIGroupWithPrefix("config.concierge")
-    resources: [ credentialissuers ]
-    verbs: [ get, list, watch, create ]
-  - apiGroups:
-      - #@ pinnipedDevAPIGroupWithPrefix("config.concierge")
-    resources: [ credentialissuers/status ]
-    verbs: [ get, patch, update ]
-  - apiGroups:
-      - #@ pinnipedDevAPIGroupWithPrefix("authentication.concierge")
-    resources: [ jwtauthenticators, webhookauthenticators ]
-    verbs: [ get, list, watch ]
----
-kind: ClusterRoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("aggregated-api-server")
-  labels: #@ labels()
-subjects:
-  - kind: ServiceAccount
-    name: #@ defaultResourceName()
-    namespace: #@ namespace()
-roleRef:
-  kind: ClusterRole
-  name: #@ defaultResourceNameWithSuffix("aggregated-api-server")
-  apiGroup: rbac.authorization.k8s.io
-
-#! Give minimal permissions to impersonation proxy service account
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: ClusterRole
-metadata:
-  name: #@ defaultResourceNameWithSuffix("impersonation-proxy")
-  labels: #@ labels()
-rules:
-  - apiGroups: [ "" ]
-    resources: [ "users", "groups", "serviceaccounts" ]
-    verbs: [ "impersonate" ]
-  - apiGroups: [ "authentication.k8s.io" ]
-    resources: [ "*" ]  #! What we really want is userextras/* but the RBAC authorizer only supports */subresource, not resource/*
-    verbs: [ "impersonate" ]
----
-kind: ClusterRoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("impersonation-proxy")
-  labels: #@ labels()
-subjects:
-  - kind: ServiceAccount
-    name: #@ defaultResourceNameWithSuffix("impersonation-proxy")
-    namespace: #@ namespace()
-roleRef:
-  kind: ClusterRole
-  name: #@ defaultResourceNameWithSuffix("impersonation-proxy")
-  apiGroup: rbac.authorization.k8s.io
-
-#! Give permission to the kube-cert-agent Pod to run privileged.
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: Role
-metadata:
-  name: #@ defaultResourceNameWithSuffix("kube-cert-agent")
-  namespace: #@ namespace()
-  labels: #@ labels()
-rules:
-  - apiGroups: [ policy ]
-    resources: [ podsecuritypolicies ]
-    verbs: [ use ]
----
-kind: RoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("kube-cert-agent")
-  namespace: #@ namespace()
-  labels: #@ labels()
-subjects:
-  - kind: ServiceAccount
-    name: #@ defaultResourceNameWithSuffix("kube-cert-agent")
-    namespace: #@ namespace()
-roleRef:
-  kind: Role
-  name: #@ defaultResourceNameWithSuffix("kube-cert-agent")
-  apiGroup: rbac.authorization.k8s.io
-
-#! Give permission to various objects within the app's own namespace
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: Role
-metadata:
-  name: #@ defaultResourceNameWithSuffix("aggregated-api-server")
-  namespace: #@ namespace()
-  labels: #@ labels()
-rules:
-  - apiGroups: [ "" ]
-    resources: [ services ]
-    verbs: [ create, get, list, patch, update, watch, delete ]
-  - apiGroups: [ "" ]
-    resources: [ secrets ]
-    verbs: [ create, get, list, patch, update, watch, delete ]
-  #! We need to be able to watch pods in our namespace so we can find the kube-cert-agent pods.
-  - apiGroups: [ "" ]
-    resources: [ pods ]
-    verbs: [ get, list, watch ]
-  #! We need to be able to exec into pods in our namespace so we can grab the API server's private key
-  - apiGroups: [ "" ]
-    resources: [ pods/exec ]
-    verbs: [ create ]
-  #! We need to be able to delete pods in our namespace so we can clean up legacy kube-cert-agent pods.
-  - apiGroups: [ "" ]
-    resources: [ pods ]
-    verbs: [ delete ]
-  #! We need to be able to create and update deployments in our namespace so we can manage the kube-cert-agent Deployment.
-  - apiGroups: [ apps ]
-    resources: [ deployments ]
-    verbs: [ create, get, list, patch, update, watch ]
-  #! We need to be able to get replicasets so we can form the correct owner references on our generated objects.
-  - apiGroups: [ apps ]
-    resources: [ replicasets ]
-    verbs: [ get ]
-  - apiGroups: [ "" ]
-    resources: [ configmaps ]
-    verbs: [ list, get, watch ]
----
-kind: RoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("aggregated-api-server")
-  namespace: #@ namespace()
-  labels: #@ labels()
-subjects:
-  - kind: ServiceAccount
-    name: #@ defaultResourceName()
-    namespace: #@ namespace()
-roleRef:
-  kind: Role
-  name: #@ defaultResourceNameWithSuffix("aggregated-api-server")
-  apiGroup: rbac.authorization.k8s.io
-
-#! Give permission to read pods in the kube-system namespace so we can find the API server's private key
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: Role
-metadata:
-  name: #@ defaultResourceNameWithSuffix("kube-system-pod-read")
-  namespace: kube-system
-  labels: #@ labels()
-rules:
-  - apiGroups: [ "" ]
-    resources: [ pods ]
-    verbs: [ get, list, watch ]
----
-kind: RoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("kube-system-pod-read")
-  namespace: kube-system
-  labels: #@ labels()
-subjects:
-  - kind: ServiceAccount
-    name: #@ defaultResourceName()
-    namespace: #@ namespace()
-roleRef:
-  kind: Role
-  name: #@ defaultResourceNameWithSuffix("kube-system-pod-read")
-  apiGroup: rbac.authorization.k8s.io
-
-#! Allow both authenticated and unauthenticated TokenCredentialRequests (i.e. allow all requests)
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: ClusterRole
-metadata:
-  name: #@ defaultResourceNameWithSuffix("pre-authn-apis")
-  labels: #@ labels()
-rules:
-  - apiGroups:
-      - #@ pinnipedDevAPIGroupWithPrefix("login.concierge")
-    resources: [ tokencredentialrequests ]
-    verbs: [ create, list ]
-  - apiGroups:
-      - #@ pinnipedDevAPIGroupWithPrefix("identity.concierge")
-    resources: [ whoamirequests ]
-    verbs: [ create, list ]
----
-kind: ClusterRoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("pre-authn-apis")
-  labels: #@ labels()
-subjects:
-  - kind: Group
-    name: system:authenticated
-    apiGroup: rbac.authorization.k8s.io
-  - kind: Group
-    name: system:unauthenticated
-    apiGroup: rbac.authorization.k8s.io
-roleRef:
-  kind: ClusterRole
-  name: #@ defaultResourceNameWithSuffix("pre-authn-apis")
-  apiGroup: rbac.authorization.k8s.io
-
-#! Give permissions for subjectaccessreviews, tokenreview that is needed by aggregated api servers
----
-kind: ClusterRoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceName()
-  labels: #@ labels()
-subjects:
-  - kind: ServiceAccount
-    name: #@ defaultResourceName()
-    namespace: #@ namespace()
-roleRef:
-  kind: ClusterRole
-  name: system:auth-delegator
-  apiGroup: rbac.authorization.k8s.io
-
-#! Give permissions for a special configmap of CA bundles that is needed by aggregated api servers
----
-kind: RoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("extension-apiserver-authentication-reader")
-  namespace: kube-system
-  labels: #@ labels()
-subjects:
-  - kind: ServiceAccount
-    name: #@ defaultResourceName()
-    namespace: #@ namespace()
-roleRef:
-  kind: Role
-  name: extension-apiserver-authentication-reader
-  apiGroup: rbac.authorization.k8s.io
-
-#! Give permission to list and watch ConfigMaps in kube-public
----
-kind: Role
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("cluster-info-lister-watcher")
-  namespace: kube-public
-  labels: #@ labels()
-rules:
-  - apiGroups: [ "" ]
-    resources: [ configmaps ]
-    verbs: [ list, watch ]
----
-kind: RoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: #@ defaultResourceNameWithSuffix("cluster-info-lister-watcher")
-  namespace: kube-public
-  labels: #@ labels()
-subjects:
-  - kind: ServiceAccount
-    name: #@ defaultResourceName()
-    namespace: #@ namespace()
-roleRef:
-  kind: Role
-  name: #@ defaultResourceNameWithSuffix("cluster-info-lister-watcher")
-  apiGroup: rbac.authorization.k8s.io

deploy/concierge/values.yaml

@@ -1,95 +0,0 @@
-#! Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-#! SPDX-License-Identifier: Apache-2.0
-
-#@data/values
----
-
-app_name: pinniped-concierge
-
-#! Creates a new namespace statically in yaml with the given name and installs the app into that namespace.
-namespace: pinniped-concierge
-#! If specified, assumes that a namespace of the given name already exists and installs the app into that namespace.
-#! If both `namespace` and `into_namespace` are specified, then only `into_namespace` is used.
-into_namespace: #! e.g. my-preexisting-namespace
-
-#! All resources created statically by yaml at install-time and all resources created dynamically
-#! by controllers at runtime will be labelled with `app: $app_name` and also with the labels
-#! specified here. The value of `custom_labels` must be a map of string keys to string values.
-#! The app can be uninstalled either by:
-#! 1. Deleting the static install-time yaml resources including the static namespace, which will cascade and also delete
-#!    resources that were dynamically created by controllers at runtime
-#! 2. Or, deleting all resources by label, which does not assume that there was a static install-time yaml namespace.
-custom_labels: {} #! e.g. {myCustomLabelName: myCustomLabelValue, otherCustomLabelName: otherCustomLabelValue}
-
-#! Specify how many replicas of the Pinniped server to run.
-replicas: 2
-
-#! Specify either an image_digest or an image_tag. If both are given, only image_digest will be used.
-image_repo: projects.registry.vmware.com/pinniped/pinniped-server
-image_digest: #! e.g. sha256:f3c4fdfd3ef865d4b97a1fd295d94acc3f0c654c46b6f27ffad5cf80216903c8
-image_tag: latest
-
-#! Optionally specify a different image for the "kube-cert-agent" pod which is scheduled
-#! on the control plane. This image needs only to include `sleep` and `cat` binaries.
-#! By default, the same image specified for image_repo/image_digest/image_tag will be re-used.
-kube_cert_agent_image:
-
-#! Specifies a secret to be used when pulling the above `image_repo` container image.
-#! Can be used when the above image_repo is a private registry.
-#! Typically the value would be the output of: kubectl create secret docker-registry x --docker-server=https://example.io --docker-username="USERNAME" --docker-password="PASSWORD" --dry-run=client -o json | jq -r '.data[".dockerconfigjson"]'
-#! Optional.
-image_pull_dockerconfigjson: #! e.g. {"auths":{"https://registry.example.com":{"username":"USERNAME","password":"PASSWORD","auth":"BASE64_ENCODED_USERNAME_COLON_PASSWORD"}}}
-
-#! Pinniped will try to guess the right K8s API URL for sharing that information with potential clients.
-#! This settings allows the guess to be overridden.
-#! Optional.
-discovery_url: #! e.g., https://example.com
-
-#! Specify the duration and renewal interval for the API serving certificate.
-#! The defaults are set to expire the cert about every 30 days, and to rotate it
-#! about every 25 days.
-api_serving_certificate_duration_seconds: 2592000
-api_serving_certificate_renew_before_seconds: 2160000
-
-#! Specify the verbosity of logging: info ("nice to know" information), debug (developer
-#! information), trace (timing information), all (kitchen sink).
-log_level: #! By default, when this value is left unset, only warnings and errors are printed. There is no way to suppress warning and error logs.
-
-run_as_user: 1001 #! run_as_user specifies the user ID that will own the process
-run_as_group: 1001 #! run_as_group specifies the group ID that will own the process
-
-#! Specify the API group suffix for all Pinniped API groups. By default, this is set to
-#! pinniped.dev, so Pinniped API groups will look like foo.pinniped.dev,
-#! authentication.concierge.pinniped.dev, etc. As an example, if this is set to tuna.io, then
-#! Pinniped API groups will look like foo.tuna.io. authentication.concierge.tuna.io, etc.
-api_group_suffix: pinniped.dev
-
-#! Customize CredentialIssuer.spec.impersonationProxy to change how the concierge
-#! handles impersonation.
-impersonation_proxy_spec:
-  #! options are "auto", "disabled" or "enabled".
-  #! If auto, the impersonation proxy will run only if the cluster signing key is not available
-  #! and the other strategy does not work.
-  #! If disabled, the impersonation proxy will never run, which could mean that the concierge
-  #! doesn't work at all.
-  #! If enabled, the impersonation proxy will always run regardless of other strategies available.
-  mode: auto
-  #! The endpoint which the client should use to connect to the impersonation proxy.
-  #! If left unset, the client will default to connecting based on the ClusterIP or LoadBalancer
-  #! endpoint.
-  external_endpoint:
-  service:
-    #! Options are "LoadBalancer", "ClusterIP" and "None".
-    #! LoadBalancer automatically provisions a Service of type LoadBalancer pointing at
-    #! the impersonation proxy. Some cloud providers will allocate
-    #! a public IP address by default even on private clusters.
-    #! ClusterIP automatically provisions a Service of type ClusterIP pointing at the
-    #! impersonation proxy.
-    #! None does not provision either and assumes that you have set the external_endpoint
-    #! and set up your own ingress to connect to the impersonation proxy.
-    type: LoadBalancer
-    #! The annotations that should be set on the ClusterIP or LoadBalancer Service.
-    annotations:
-      {service.beta.kubernetes.io/aws-load-balancer-connection-idle-timeout: "4000"}
-    #! When mode LoadBalancer is set, this will set the LoadBalancer Service's Spec.LoadBalancerIP.
-    load_balancer_ip:

deploy/concierge/z0_crd_overlay.yaml

@@ -1,33 +0,0 @@
-#! Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-#! SPDX-License-Identifier: Apache-2.0
-
-#@ load("@ytt:overlay", "overlay")
-#@ load("helpers.lib.yaml", "labels", "pinnipedDevAPIGroupWithPrefix")
-#@ load("@ytt:data", "data")
-
-#@overlay/match by=overlay.subset({"kind": "CustomResourceDefinition", "metadata":{"name":"credentialissuers.config.concierge.pinniped.dev"}}), expects=1
----
-metadata:
-  #@overlay/match missing_ok=True
-  labels: #@ labels()
-  name: #@ pinnipedDevAPIGroupWithPrefix("credentialissuers.config.concierge")
-spec:
-  group: #@ pinnipedDevAPIGroupWithPrefix("config.concierge")
-
-#@overlay/match by=overlay.subset({"kind": "CustomResourceDefinition", "metadata":{"name":"webhookauthenticators.authentication.concierge.pinniped.dev"}}), expects=1
----
-metadata:
-  #@overlay/match missing_ok=True
-  labels: #@ labels()
-  name: #@ pinnipedDevAPIGroupWithPrefix("webhookauthenticators.authentication.concierge")
-spec:
-  group: #@ pinnipedDevAPIGroupWithPrefix("authentication.concierge")
-
-#@overlay/match by=overlay.subset({"kind": "CustomResourceDefinition", "metadata":{"name":"jwtauthenticators.authentication.concierge.pinniped.dev"}}), expects=1
----
-metadata:
-  #@overlay/match missing_ok=True
-  labels: #@ labels()
-  name: #@ pinnipedDevAPIGroupWithPrefix("jwtauthenticators.authentication.concierge")
-spec:
-  group: #@ pinnipedDevAPIGroupWithPrefix("authentication.concierge")

deploy/local-user-authenticator/README.md

@@ -1,163 +0,0 @@
-# Deploying local-user-authenticator
-
-## What is local-user-authenticator?
-
-The local-user-authenticator app is an identity provider used for integration testing and demos.
-If you would like to demo Pinniped, but you don't have a compatible identity provider handy,
-you can use Pinniped's local-user-authenticator identity provider. Note that this is not recommended for
-production use.
-
-The local-user-authenticator is a Kubernetes Deployment which runs a webhook server that implements the Kubernetes
-[Webhook Token Authentication interface](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#webhook-token-authentication).
-
-User accounts can be created and edited dynamically using `kubectl` commands (see below).
-
-## Installing the Latest Version with Default Options
-
-```bash
-kubectl apply -f https://get.pinniped.dev/latest/install-local-user-authenticator.yaml
-```
-
-## Installing a Specific Version with Default Options
-
-Choose your preferred [release](https://github.com/vmware-tanzu/pinniped/releases) version number
-and use it to replace the version number in the URL below.
-
-```bash
-# Replace v0.4.1 with your preferred version in the URL below
-kubectl apply -f https://get.pinniped.dev/v0.4.1/install-local-user-authenticator.yaml
-```
-
-## Installing with Custom Options
-
-Creating your own deployment YAML file requires `ytt` from [Carvel](https://carvel.dev/) to template the YAML files
-in the `deploy/local-user-authenticator` directory.
-Either [install `ytt`](https://get-ytt.io/) or use the [container image from Dockerhub](https://hub.docker.com/r/k14s/image/tags).
-
-1. `git clone` this repo and `git checkout` the release version tag of the release that you would like to deploy.
-1. The configuration options are in [deploy/local-user-authenticator/values.yml](values.yaml).
-   Fill in the values in that file, or override those values using additional `ytt` command-line options in
-   the command below. Use the release version tag as the `image_tag` value.
-2. In a terminal, cd to this `deploy/local-user-authenticator` directory
-3. To generate the final YAML files, run `ytt --file .`
-4. Deploy the generated YAML using your preferred deployment tool, such as `kubectl` or [`kapp`](https://get-kapp.io/).
-   For example: `ytt --file . | kapp deploy --yes --app local-user-authenticator --diff-changes --file -`
-
-## Configuring After Installing
-
-### Create Users
-
-Use `kubectl` to create, edit, and delete user accounts by creating a `Secret` for each user account in the same
-namespace where local-user-authenticator is deployed.  The name of the `Secret` resource is the username.
-Store the user's group membership and `bcrypt` encrypted password as the contents of the `Secret`.
-For example, to create a user named `pinny-the-seal` with the password `password123`
-who belongs to the groups `group1` and `group2`, use:
-
-```bash
-kubectl create secret generic pinny-the-seal \
-  --namespace local-user-authenticator \
-  --from-literal=groups=group1,group2 \
-  --from-literal=passwordHash=$(htpasswd -nbBC 10 x password123 | sed -e "s/^x://")
-```
-
-Note that the above command requires a tool capable of generating a `bcrypt` hash. It uses `htpasswd`,
-which is installed on most macOS systems, and can be
-installed on some Linux systems via the `apache2-utils` package (e.g., `apt-get install apache2-utils`).
-
-### Get the local-user-authenticator App's Auto-Generated Certificate Authority Bundle
-
-Fetch the auto-generated CA bundle for the local-user-authenticator's HTTP TLS endpoint.
-
-```bash
-kubectl get secret local-user-authenticator-tls-serving-certificate --namespace local-user-authenticator \
-  -o jsonpath={.data.caCertificate} \
-  | base64 -d \
-  | tee /tmp/local-user-authenticator-ca
-```
-
-### Configuring Pinniped to Use local-user-authenticator as an Identity Provider
-
-When installing Pinniped on the same cluster, configure local-user-authenticator as an Identity Provider for Pinniped
-using the webhook URL `https://local-user-authenticator.local-user-authenticator.svc/authenticate`
-along with the CA bundle fetched by the above command. See [demo](https://pinniped.dev/docs/demo/) for an example.
-
-## Optional: Manually Testing the Webhook Endpoint After Installing
-
-The following steps demonstrate the API of the local-user-authenticator app. Typically, a user would not need to
-interact with this API directly. Pinniped will automatically integrate with this API if the local-user-authenticator
-is configured as an identity provider for Pinniped.
-
-  1. Start a pod from which you can curl the endpoint from inside the cluster.
-
-      ```bash
-      kubectl run curlpod --image=curlimages/curl --command -- /bin/sh -c "while true; do echo hi; sleep 120; done"
-      ```
-
-  1. Copy the CA bundle that was fetched above onto the new pod.
-
-      ```bash
-      kubectl cp /tmp/local-user-authenticator-ca curlpod:/tmp/local-user-authenticator-ca
-      ```
-
-  1. Run a `curl` command to try to authenticate as the user created above.
-
-      ```bash
-      kubectl -it exec curlpod -- curl https://local-user-authenticator.local-user-authenticator.svc/authenticate \
-        --cacert /tmp/local-user-authenticator-ca \
-        -H 'Content-Type: application/json' -H 'Accept: application/json' -d '
-      {
-        "apiVersion": "authentication.k8s.io/v1beta1",
-        "kind": "TokenReview",
-        "spec": {
-          "token": "pinny-the-seal:password123"
-        }
-      }'
-      ```
-
-      When authentication is successful the above command should return some JSON similar to the following.
-      Note that the value of `authenticated` is `true` to indicate a successful authentication.
-
-      ```json
-      {
-        "kind": "TokenReview",
-        "apiVersion": "authentication.k8s.io/v1beta1",
-        "metadata": {
-          "creationTimestamp": null
-        },
-        "spec": {},
-        "status": {
-          "authenticated": true,
-          "user": {
-            "username": "pinny-the-seal",
-            "uid": "19c433ec-8f58-44ca-9ef0-2d1081ccb876",
-            "groups": [
-              "group1",
-              "group2"
-            ]
-          }
-        }
-      }
-      ```
-
-      Trying the above `curl` command again with the wrong username or password in the body of the request
-      should result in a JSON response which indicates that the authentication failed.
-
-      ```json
-      {
-        "kind": "TokenReview",
-        "apiVersion": "authentication.k8s.io/v1beta1",
-        "metadata": {
-          "creationTimestamp": null
-        },
-        "spec": {},
-        "status": {
-          "user": {}
-        }
-      }
-      ```
-
-  1. Remove the curl pod.
-
-      ```bash
-      kubectl delete pod curlpod
-      ```

deploy/local-user-authenticator/deployment.yaml

@@ -1,83 +0,0 @@
-#! Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-#! SPDX-License-Identifier: Apache-2.0
-
-#@ load("@ytt:data", "data")
-
----
-apiVersion: v1
-kind: Namespace
-metadata:
-  name: local-user-authenticator
-  labels:
-    name: local-user-authenticator
----
-apiVersion: v1
-kind: ServiceAccount
-metadata:
-  name: local-user-authenticator
-  namespace: local-user-authenticator
----
-#@ if data.values.image_pull_dockerconfigjson and data.values.image_pull_dockerconfigjson != "":
-apiVersion: v1
-kind: Secret
-metadata:
-  name: image-pull-secret
-  namespace: local-user-authenticator
-  labels:
-    app: local-user-authenticator
-type: kubernetes.io/dockerconfigjson
-data:
-  .dockerconfigjson: #@ data.values.image_pull_dockerconfigjson
-#@ end
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: local-user-authenticator
-  namespace: local-user-authenticator
-  labels:
-    app: local-user-authenticator
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: local-user-authenticator
-  template:
-    metadata:
-      labels:
-        app: local-user-authenticator
-    spec:
-      securityContext:
-        runAsUser: #@ data.values.run_as_user
-        runAsGroup: #@ data.values.run_as_group
-      serviceAccountName: local-user-authenticator
-      #@ if data.values.image_pull_dockerconfigjson and data.values.image_pull_dockerconfigjson != "":
-      imagePullSecrets:
-        - name: image-pull-secret
-      #@ end
-      containers:
-        - name: local-user-authenticator
-          #@ if data.values.image_digest:
-          image:  #@ data.values.image_repo + "@" + data.values.image_digest
-          #@ else:
-          image: #@ data.values.image_repo + ":" + data.values.image_tag
-          #@ end
-          imagePullPolicy: IfNotPresent
-          command: #! override the default entrypoint
-            - /usr/local/bin/local-user-authenticator
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: local-user-authenticator
-  namespace: local-user-authenticator
-  labels:
-    app: local-user-authenticator
-spec:
-  type: ClusterIP
-  selector:
-    app: local-user-authenticator
-  ports:
-    - protocol: TCP
-      port: 443
-      targetPort: 8443

deploy/local-user-authenticator/rbac.yaml

@@ -1,30 +0,0 @@
-#! Copyright 2020 the Pinniped contributors. All Rights Reserved.
-#! SPDX-License-Identifier: Apache-2.0
-
-#@ load("@ytt:data", "data")
-
-#! Give permission to various objects within the app's own namespace
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: Role
-metadata:
-  name: local-user-authenticator
-  namespace: local-user-authenticator
-rules:
-  - apiGroups: [""]
-    resources: [secrets]
-    verbs: [create, get, list, patch, update, watch]
----
-kind: RoleBinding
-apiVersion: rbac.authorization.k8s.io/v1
-metadata:
-  name: local-user-authenticator
-  namespace: local-user-authenticator
-subjects:
-  - kind: ServiceAccount
-    name: local-user-authenticator
-    namespace: local-user-authenticator
-roleRef:
-  kind: Role
-  name: local-user-authenticator
-  apiGroup: rbac.authorization.k8s.io

deploy/local-user-authenticator/values.yaml

@@ -1,19 +0,0 @@
-#! Copyright 2020-2021 the Pinniped contributors. All Rights Reserved.
-#! SPDX-License-Identifier: Apache-2.0
-
-#@data/values
----
-
-#! Specify either an image_digest or an image_tag. If both are given, only image_digest will be used.
-image_repo: projects.registry.vmware.com/pinniped/pinniped-server
-image_digest: #! e.g. sha256:f3c4fdfd3ef865d4b97a1fd295d94acc3f0c654c46b6f27ffad5cf80216903c8
-image_tag: latest
-
-#! Specifies a secret to be used when pulling the above `image_repo` container image.
-#! Can be used when the above image_repo is a private registry.
-#! Typically the value would be the output of: kubectl create secret docker-registry x --docker-server=https://example.io --docker-username="USERNAME" --docker-password="PASSWORD" --dry-run=client -o json | jq -r '.data[".dockerconfigjson"]'
-#! Optional.
-image_pull_dockerconfigjson: #! e.g. {"auths":{"https://registry.example.com":{"username":"USERNAME","password":"PASSWORD","auth":"BASE64_ENCODED_USERNAME_COLON_PASSWORD"}}}
-
-run_as_user: 1001 #! run_as_user specifies the user ID that will own the process
-run_as_group: 1001 #! run_as_group specifies the group ID that will own the process

deploy/supervisor/README.md

@@ -1,3 +0,0 @@
-# Pinniped Supervisor Deployment
-
-See [the how-to guide for details](https://pinniped.dev/docs/howto/install-supervisor/).

deploy/supervisor/config.supervisor.pinniped.dev_federationdomains.yaml

@@ -1,160 +0,0 @@
-
----
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  annotations:
-    controller-gen.kubebuilder.io/version: v0.4.0
-  creationTimestamp: null
-  name: federationdomains.config.supervisor.pinniped.dev
-spec:
-  group: config.supervisor.pinniped.dev
-  names:
-    categories:
-    - pinniped
-    kind: FederationDomain
-    listKind: FederationDomainList
-    plural: federationdomains
-    singular: federationdomain
-  scope: Namespaced
-  versions:
-  - name: v1alpha1
-    schema:
-      openAPIV3Schema:
-        description: FederationDomain describes the configuration of an OIDC provider.
-        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: Spec of the OIDC provider.
-            properties:
-              issuer:
-                description: "Issuer is the OIDC Provider's issuer, per the OIDC Discovery
-                  Metadata document, as well as the identifier that it will use for
-                  the iss claim in issued JWTs. This field will also be used as the
-                  base URL for any endpoints used by the OIDC Provider (e.g., if your
-                  issuer is https://example.com/foo, then your authorization endpoint
-                  will look like https://example.com/foo/some/path/to/auth/endpoint).
-                  \n See https://openid.net/specs/openid-connect-discovery-1_0.html#rfc.section.3
-                  for more information."
-                minLength: 1
-                type: string
-              tls:
-                description: TLS configures how this FederationDomain is served over
-                  Transport Layer Security (TLS).
-                properties:
-                  secretName:
-                    description: "SecretName is an optional name of a Secret in the
-                      same namespace, of type `kubernetes.io/tls`, which contains
-                      the TLS serving certificate for the HTTPS endpoints served by
-                      this FederationDomain. When provided, the TLS Secret named here
-                      must contain keys named `tls.crt` and `tls.key` that contain
-                      the certificate and private key to use for TLS. \n Server Name
-                      Indication (SNI) is an extension to the Transport Layer Security
-                      (TLS) supported by all major browsers. \n SecretName is required
-                      if you would like to use different TLS certificates for issuers
-                      of different hostnames. SNI requests do not include port numbers,
-                      so all issuers with the same DNS hostname must use the same
-                      SecretName value even if they have different port numbers. \n
-                      SecretName is not required when you would like to use only the
-                      HTTP endpoints (e.g. when terminating TLS at an Ingress). It
-                      is also not required when you would like all requests to this
-                      OIDC Provider's HTTPS endpoints to use the default TLS certificate,
-                      which is configured elsewhere. \n When your Issuer URL's host
-                      is an IP address, then this field is ignored. SNI does not work
-                      for IP addresses."
-                    type: string
-                type: object
-            required:
-            - issuer
-            type: object
-          status:
-            description: Status of the OIDC provider.
-            properties:
-              lastUpdateTime:
-                description: LastUpdateTime holds the time at which the Status was
-                  last updated. It is a pointer to get around some undesirable behavior
-                  with respect to the empty metav1.Time value (see https://github.com/kubernetes/kubernetes/issues/86811).
-                format: date-time
-                type: string
-              message:
-                description: Message provides human-readable details about the Status.
-                type: string
-              secrets:
-                description: Secrets contains information about this OIDC Provider's
-                  secrets.
-                properties:
-                  jwks:
-                    description: JWKS holds the name of the corev1.Secret in which
-                      this OIDC Provider's signing/verification keys are stored. If
-                      it is empty, then the signing/verification keys are either unknown
-                      or they don't exist.
-                    properties:
-                      name:
-                        description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
-                          TODO: Add other useful fields. apiVersion, kind, uid?'
-                        type: string
-                    type: object
-                  stateEncryptionKey:
-                    description: StateSigningKey holds the name of the corev1.Secret
-                      in which this OIDC Provider's key for encrypting state parameters
-                      is stored.
-                    properties:
-                      name:
-                        description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
-                          TODO: Add other useful fields. apiVersion, kind, uid?'
-                        type: string
-                    type: object
-                  stateSigningKey:
-                    description: StateSigningKey holds the name of the corev1.Secret
-                      in which this OIDC Provider's key for signing state parameters
-                      is stored.
-                    properties:
-                      name:
-                        description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
-                          TODO: Add other useful fields. apiVersion, kind, uid?'
-                        type: string
-                    type: object
-                  tokenSigningKey:
-                    description: TokenSigningKey holds the name of the corev1.Secret
-                      in which this OIDC Provider's key for signing tokens is stored.
-                    properties:
-                      name:
-                        description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
-                          TODO: Add other useful fields. apiVersion, kind, uid?'
-                        type: string
-                    type: object
-                type: object
-              status:
-                description: Status holds an enum that describes the state of this
-                  OIDC Provider. Note that this Status can represent success or failure.
-                enum:
-                - Success
-                - Duplicate
-                - Invalid
-                - SameIssuerHostMustUseSameSecret
-                type: string
-            type: object
-        required:
-        - spec
-        type: object
-    served: true
-    storage: true
-    subresources:
-      status: {}
-status:
-  acceptedNames:
-    kind: ""
-    plural: ""
-  conditions: []
-  storedVersions: []