Implemented volume topology aware scheduling

[ellistarn]

1. Issue, if available:
#622

2. Description of changes:

Tested With:

Dynamic Provisioning

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: ebs-sc
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer
allowedTopologies:
- matchLabelExpressions:
  - key: topology.ebs.csi.aws.com/zone
    values:
    - us-west-2d
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ebs-claim
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: ebs-sc
  resources:
    requests:
      storage: 4Gi
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  nodeSelector:
    karpenter.sh/provisioner-name: default
  containers:
  - name: app
    image: centos
    command: ["/bin/sh"]
    args: ["-c", "while true; do echo $(date -u) >> /data/out.txt; sleep 5; done"]
    volumeMounts:
    - name: persistent-storage
      mountPath: /data
  volumes:
  - name: persistent-storage
    persistentVolumeClaim:
      claimName: ebs-claim

Static Provisioning

apiVersion: v1
kind: PersistentVolume
metadata:
  name: test-pv
spec:
  capacity:
    storage: 50Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteOnce
  storageClassName: ""
  csi:
    driver: ebs.csi.aws.com
    volumeHandle: vol-0755eac953162225d
    fsType: ext4
  nodeAffinity:
    required:
      nodeSelectorTerms:
        - matchExpressions:
            - key: topology.ebs.csi.aws.com/zone
              operator: In
              values:
                - us-west-2d
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ebs-claim
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: ""
  resources:
    requests:
      storage: 50Gi
---
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  nodeSelector:
    karpenter.sh/provisioner-name: "default"
  containers:
    - name: app
      image: centos
      command: ["/bin/sh"]
      args:
        ["-c", "while true; do echo $(date -u) >> /data/out.txt; sleep 5; done"]
      volumeMounts:
        - name: persistent-storage
          mountPath: /data
  volumes:
    - name: persistent-storage
      persistentVolumeClaim:
        claimName: ebs-claim

3. Does this change impact docs?

• Yes, PR includes docs updates
• Yes, issue opened: link to issue
• No

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

[netlify]

✔️ Deploy Preview for karpenter-docs-prod ready!

🔨 Explore the source changes: 3b6c7f7

🔍 Inspect the deploy log: https://app.netlify.com/sites/karpenter-docs-prod/deploys/61d5d1546835410008e61ff9

😎 Browse the preview: https://deploy-preview-1015--karpenter-docs-prod.netlify.app

[wongma7]

good idea

[wongma7]

I think it is necessary for some routine to wait for every PVC provision to succeed/fail after setting this annotation to trigger PVC provision. Step 3 here: https://github.com/kubernetes/design-proposals-archive/blob/main/storage/volume-topology-scheduling.md#bind.

Because if a PVC provision fails then the CSI driver's provisioner controller signals failure by removing the selected-node annotation https://github.com/kubernetes-sigs/sig-storage-lib-external-provisioner/blob/a35bec6eb688ef7a0e31b340ed77bdb84010ace7/controller/controller.go#L1298. And some routine has to notice that + add the annotation again to trigger another PVC provision.

The default scheduler prebind implementation of this wait routine is: https://github.com/kubernetes/kubernetes/blob/39c76ba2edeadb84a115cc3fbd9204a2177f1c28/pkg/scheduler/framework/plugins/volumebinding/binder.go#L462-L465

[ellistarn]

Interesting. I may just implement a PVC scheduler that watches PVCs and pods and makes sure that the annotation is set on the PVC for the node/pod. Thanks for pointing this out.

[geoffcline]

👀👏

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (5)

ebs
persistentvolumeclaims
persistentvolumes
pvc
storageclasses

Previously acknowledged words that are now absent

Ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 72 of them
cspell:aws/aws.txt (1485) covers 31 of them
cspell:golang/go.txt (7745) covers 18 of them
cspell:django/django.txt (2342) covers 17 of them
cspell:filetypes/filetypes.txt (337) covers 11 of them
cspell:html/html.txt (542) covers 9 of them
cspell:css/css.txt (993) covers 9 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:fullstack/fullstack.txt (181) covers 7 of them
cspell:python/python.txt (364) covers 6 of them
cspell:lua/lua.txt (391) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:npm/npm.txt (671) covers 5 of them
cspell:csharp/csharp.txt (123) covers 3 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:php/php.txt (9785) covers 1 of them
cspell:dotnet/dotnet.txt (9824) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:aws/aws.txt
          cspell:golang/go.txt
          cspell:django/django.txt
          cspell:filetypes/filetypes.txt
          cspell:html/html.txt
          cspell:css/css.txt
          cspell:java/java.txt
          cspell:fullstack/fullstack.txt
          cspell:python/python.txt
          cspell:lua/lua.txt
          cspell:scala/scala.txt
          cspell:npm/npm.txt
          cspell:csharp/csharp.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:php/php.txt
          cspell:dotnet/dotnet.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1003170365" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (1)

ebs

Previously acknowledged words that are now absent

Ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 72 of them
cspell:aws/aws.txt (1485) covers 31 of them
cspell:golang/go.txt (7745) covers 18 of them
cspell:django/django.txt (2342) covers 17 of them
cspell:filetypes/filetypes.txt (337) covers 11 of them
cspell:html/html.txt (542) covers 9 of them
cspell:css/css.txt (993) covers 9 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:fullstack/fullstack.txt (181) covers 7 of them
cspell:python/python.txt (364) covers 6 of them
cspell:lua/lua.txt (391) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:npm/npm.txt (671) covers 5 of them
cspell:csharp/csharp.txt (123) covers 3 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:php/php.txt (9785) covers 1 of them
cspell:dotnet/dotnet.txt (9824) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:aws/aws.txt
          cspell:golang/go.txt
          cspell:django/django.txt
          cspell:filetypes/filetypes.txt
          cspell:html/html.txt
          cspell:css/css.txt
          cspell:java/java.txt
          cspell:fullstack/fullstack.txt
          cspell:python/python.txt
          cspell:lua/lua.txt
          cspell:scala/scala.txt
          cspell:npm/npm.txt
          cspell:csharp/csharp.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:php/php.txt
          cspell:dotnet/dotnet.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1003178640" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (1)

ebs

Previously acknowledged words that are now absent

Ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 72 of them
cspell:aws/aws.txt (1485) covers 31 of them
cspell:golang/go.txt (7745) covers 18 of them
cspell:django/django.txt (2342) covers 17 of them
cspell:filetypes/filetypes.txt (337) covers 11 of them
cspell:html/html.txt (542) covers 9 of them
cspell:css/css.txt (993) covers 9 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:fullstack/fullstack.txt (181) covers 7 of them
cspell:python/python.txt (364) covers 6 of them
cspell:lua/lua.txt (391) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:npm/npm.txt (671) covers 5 of them
cspell:csharp/csharp.txt (123) covers 3 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:php/php.txt (9785) covers 1 of them
cspell:dotnet/dotnet.txt (9824) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:aws/aws.txt
          cspell:golang/go.txt
          cspell:django/django.txt
          cspell:filetypes/filetypes.txt
          cspell:html/html.txt
          cspell:css/css.txt
          cspell:java/java.txt
          cspell:fullstack/fullstack.txt
          cspell:python/python.txt
          cspell:lua/lua.txt
          cspell:scala/scala.txt
          cspell:npm/npm.txt
          cspell:csharp/csharp.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:php/php.txt
          cspell:dotnet/dotnet.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1003179847" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (1)

ebs

Previously acknowledged words that are now absent

Ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 72 of them
cspell:aws/aws.txt (1485) covers 31 of them
cspell:golang/go.txt (7745) covers 18 of them
cspell:django/django.txt (2342) covers 17 of them
cspell:filetypes/filetypes.txt (337) covers 11 of them
cspell:html/html.txt (542) covers 9 of them
cspell:css/css.txt (993) covers 9 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:fullstack/fullstack.txt (181) covers 7 of them
cspell:python/python.txt (364) covers 6 of them
cspell:lua/lua.txt (391) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:npm/npm.txt (671) covers 5 of them
cspell:csharp/csharp.txt (123) covers 3 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:php/php.txt (9785) covers 1 of them
cspell:dotnet/dotnet.txt (9824) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:aws/aws.txt
          cspell:golang/go.txt
          cspell:django/django.txt
          cspell:filetypes/filetypes.txt
          cspell:html/html.txt
          cspell:css/css.txt
          cspell:java/java.txt
          cspell:fullstack/fullstack.txt
          cspell:python/python.txt
          cspell:lua/lua.txt
          cspell:scala/scala.txt
          cspell:npm/npm.txt
          cspell:csharp/csharp.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:php/php.txt
          cspell:dotnet/dotnet.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1003180761" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (2)

ebs
persistentvolumeclaim

Previously acknowledged words that are now absent

Ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 72 of them
cspell:aws/aws.txt (1485) covers 31 of them
cspell:golang/go.txt (7745) covers 18 of them
cspell:django/django.txt (2342) covers 17 of them
cspell:filetypes/filetypes.txt (337) covers 11 of them
cspell:html/html.txt (542) covers 9 of them
cspell:css/css.txt (993) covers 9 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:fullstack/fullstack.txt (181) covers 7 of them
cspell:python/python.txt (364) covers 6 of them
cspell:lua/lua.txt (391) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:npm/npm.txt (671) covers 5 of them
cspell:csharp/csharp.txt (123) covers 3 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:php/php.txt (9785) covers 1 of them
cspell:dotnet/dotnet.txt (9824) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:aws/aws.txt
          cspell:golang/go.txt
          cspell:django/django.txt
          cspell:filetypes/filetypes.txt
          cspell:html/html.txt
          cspell:css/css.txt
          cspell:java/java.txt
          cspell:fullstack/fullstack.txt
          cspell:python/python.txt
          cspell:lua/lua.txt
          cspell:scala/scala.txt
          cspell:npm/npm.txt
          cspell:csharp/csharp.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:php/php.txt
          cspell:dotnet/dotnet.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1003234717" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (2)

ebs
persistentvolumeclaim

Previously acknowledged words that are now absent

Ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 72 of them
cspell:aws/aws.txt (1485) covers 31 of them
cspell:golang/go.txt (7745) covers 18 of them
cspell:django/django.txt (2342) covers 17 of them
cspell:filetypes/filetypes.txt (337) covers 11 of them
cspell:html/html.txt (542) covers 9 of them
cspell:css/css.txt (993) covers 9 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:fullstack/fullstack.txt (181) covers 7 of them
cspell:python/python.txt (364) covers 6 of them
cspell:lua/lua.txt (391) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:npm/npm.txt (671) covers 5 of them
cspell:csharp/csharp.txt (123) covers 3 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:php/php.txt (9785) covers 1 of them
cspell:dotnet/dotnet.txt (9824) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:aws/aws.txt
          cspell:golang/go.txt
          cspell:django/django.txt
          cspell:filetypes/filetypes.txt
          cspell:html/html.txt
          cspell:css/css.txt
          cspell:java/java.txt
          cspell:fullstack/fullstack.txt
          cspell:python/python.txt
          cspell:lua/lua.txt
          cspell:scala/scala.txt
          cspell:npm/npm.txt
          cspell:csharp/csharp.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:php/php.txt
          cspell:dotnet/dotnet.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1003235177" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (3)

ebs
persistentvolumeclaim
storageclass

Previously acknowledged words that are now absent

Ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 72 of them
cspell:aws/aws.txt (1485) covers 31 of them
cspell:golang/go.txt (7745) covers 18 of them
cspell:django/django.txt (2342) covers 17 of them
cspell:filetypes/filetypes.txt (337) covers 11 of them
cspell:html/html.txt (542) covers 9 of them
cspell:css/css.txt (993) covers 9 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:fullstack/fullstack.txt (181) covers 7 of them
cspell:python/python.txt (364) covers 6 of them
cspell:lua/lua.txt (391) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:npm/npm.txt (671) covers 5 of them
cspell:csharp/csharp.txt (123) covers 3 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:php/php.txt (9785) covers 1 of them
cspell:dotnet/dotnet.txt (9824) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:aws/aws.txt
          cspell:golang/go.txt
          cspell:django/django.txt
          cspell:filetypes/filetypes.txt
          cspell:html/html.txt
          cspell:css/css.txt
          cspell:java/java.txt
          cspell:fullstack/fullstack.txt
          cspell:python/python.txt
          cspell:lua/lua.txt
          cspell:scala/scala.txt
          cspell:npm/npm.txt
          cspell:csharp/csharp.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:php/php.txt
          cspell:dotnet/dotnet.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1003242757" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (2)

amazonvpc
persistentvolumeclaim

Previously acknowledged words that are now absent

ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 55 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:django/django.txt (2342) covers 8 of them
cspell:html/html.txt (542) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:python/python.txt (364) covers 5 of them
cspell:fullstack/fullstack.txt (181) covers 5 of them
cspell:filetypes/filetypes.txt (337) covers 5 of them
cspell:css/css.txt (993) covers 5 of them
cspell:lua/lua.txt (391) covers 4 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:npm/npm.txt (671) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:csharp/csharp.txt (123) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:java/java.txt
          cspell:django/django.txt
          cspell:html/html.txt
          cspell:scala/scala.txt
          cspell:python/python.txt
          cspell:fullstack/fullstack.txt
          cspell:filetypes/filetypes.txt
          cspell:css/css.txt
          cspell:lua/lua.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:npm/npm.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:csharp/csharp.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1004422135" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (2)

amazonvpc
persistentvolumeclaim

Previously acknowledged words that are now absent

ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 55 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:django/django.txt (2342) covers 8 of them
cspell:html/html.txt (542) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:python/python.txt (364) covers 5 of them
cspell:fullstack/fullstack.txt (181) covers 5 of them
cspell:filetypes/filetypes.txt (337) covers 5 of them
cspell:css/css.txt (993) covers 5 of them
cspell:lua/lua.txt (391) covers 4 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:npm/npm.txt (671) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:csharp/csharp.txt (123) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:java/java.txt
          cspell:django/django.txt
          cspell:html/html.txt
          cspell:scala/scala.txt
          cspell:python/python.txt
          cspell:fullstack/fullstack.txt
          cspell:filetypes/filetypes.txt
          cspell:css/css.txt
          cspell:lua/lua.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:npm/npm.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:csharp/csharp.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1004436396" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (2)

amazonvpc
persistentvolumeclaim

Previously acknowledged words that are now absent

ebs

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 55 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:django/django.txt (2342) covers 8 of them
cspell:html/html.txt (542) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:python/python.txt (364) covers 5 of them
cspell:fullstack/fullstack.txt (181) covers 5 of them
cspell:filetypes/filetypes.txt (337) covers 5 of them
cspell:css/css.txt (993) covers 5 of them
cspell:lua/lua.txt (391) covers 4 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:npm/npm.txt (671) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:csharp/csharp.txt (123) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:java/java.txt
          cspell:django/django.txt
          cspell:html/html.txt
          cspell:scala/scala.txt
          cspell:python/python.txt
          cspell:fullstack/fullstack.txt
          cspell:filetypes/filetypes.txt
          cspell:css/css.txt
          cspell:lua/lua.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:npm/npm.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:csharp/csharp.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1004472391" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[github-actions]

@check-spelling-bot Report

🔴 Please review

See the files view or the action log for details.

Unrecognized words (5)

amazonvpc
persistentvolumeclaim
persistentvolumes
pvc
storageclasses

Available dictionaries could cover words not in the dictionary

cspell:cpp/cpp.txt (104293) covers 55 of them
cspell:java/java.txt (33524) covers 8 of them
cspell:django/django.txt (2342) covers 8 of them
cspell:html/html.txt (542) covers 6 of them
cspell:scala/scala.txt (2752) covers 5 of them
cspell:python/python.txt (364) covers 5 of them
cspell:fullstack/fullstack.txt (181) covers 5 of them
cspell:filetypes/filetypes.txt (337) covers 5 of them
cspell:css/css.txt (993) covers 5 of them
cspell:lua/lua.txt (391) covers 4 of them
cspell:rust/rust.txt (112) covers 2 of them
cspell:ruby/ruby.txt (354) covers 2 of them
cspell:npm/npm.txt (671) covers 2 of them
cspell:node/node.txt (9611) covers 2 of them
cspell:bash/bash-words.txt (22) covers 2 of them
cspell:csharp/csharp.txt (123) covers 1 of them
cspell:ada/ada.txt (72) covers 1 of them

Consider adding them using:

      with:
        extra_dictionaries:
          cspell:cpp/cpp.txt
          cspell:java/java.txt
          cspell:django/django.txt
          cspell:html/html.txt
          cspell:scala/scala.txt
          cspell:python/python.txt
          cspell:fullstack/fullstack.txt
          cspell:filetypes/filetypes.txt
          cspell:css/css.txt
          cspell:lua/lua.txt
          cspell:rust/rust.txt
          cspell:ruby/ruby.txt
          cspell:npm/npm.txt
          cspell:node/node.txt
          cspell:bash/bash-words.txt
          cspell:csharp/csharp.txt
          cspell:ada/ada.txt

To stop checking additional dictionaries, add:

      with:
        check_extra_dictionaries: ''

To accept these unrecognized words as correct, run the following commands

... in a clone of the [email protected]:ellistarn/karpenter.git repository
on the i622 branch:

update_files() {
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
-H "Content-Type: application/json" \
"https://api.github.com/repos/aws/karpenter/issues/comments/1004473023" > "$comment_json"
comment_body=$(mktemp)
jq -r ".body // empty" "$comment_json" > $comment_body
rm $comment_json

patch_add=$(perl -e '$/=undef; $_=<>; if (m{Unrecognized words[^<]*</summary>\n*```\n*([^<]*)```\n*</details>$}m) { print "$1" } elsif (m{Unrecognized words[^<]*\n\n((?:\w.*\n)+)\n}m) { print "$1" };' < "$comment_body")

update_files
rm $comment_body
git add -u

If the flagged items do not appear to be text

If items relate to a ...

• well-formed pattern.

  If you can write a pattern that would match it,
  try adding it to the patterns.txt file.

  Patterns are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your lines.

  Note that patterns can't match multiline strings.

• binary file.

  Please add a file path to the excludes.txt file matching the containing file.

  File paths are Perl 5 Regular Expressions - you can test yours before committing to verify it will match your files.

  ^ refers to the file's path from the root of the repository, so ^README\.md$ would exclude README.md (on whichever branch you're using).

[suket22]

If a pod has no PVCs at all, is there a way to short-circuit the reconcile? with eventFilters?

[suket22]

I get that we inlined since binding was used just once, but it did make this line tougher for me to parse IMO :)

[suket22]

I think I'm missing something obvious but why is this necessary? Once we bind the pod with the PVC volume to that node, won't this happen anyway?

[ellistarn]

No! I thought that the PVC controller should be responsible for this, but it turns out that it's a prebind implementation within the kube scheduler. Any scheduler implementation (i.e. karpenter) is responsible for also doing volume binding.

This is unintuitive to me, and I feel like the kvc or pvc controller (or kubescheduler, for that matter) should be responsible for this. This was brought up by @wongma7 in a previous comment.

[suket22]

TIL!

[suket22]

Should we wrap VolumeTopology into Preferences and not expose it to the Controller?

[ellistarn]

I think these are fully separate concepts. Preferences is all about relaxing preferred node affinities. Volume topology is a fully separate scheduling plugin.

[ellistarn]

That said, as we continue to build out scheduling features, I'm always game for a reimagining of the implementation to something more streamlined -- there just wasn't anything obvious to me as I've built it piece by piece. Along these lines, I'd love to figure out how to get all the scheduling logic up into the selection controller.

[suket22]

Preferences is all about relaxing preferred node affinities.

Aaah okay, that makes sense - on first reading I thought Preferences was the way we're getting all the scheduling logic into the controller. I suppose it was just the first.

Agreed though, it might be nice to have some kind of uniform contract for all our scheduler plugins to implement and unifying all of them into a different wrapper maybe?

[suket22]

This was a nice refactor 💯