github stephrobert/feint v0.8.0

latest releases: v0.16.0, v0.15.0, v0.14.0...
3 months ago

Fixed

  • A destroy assertion told two failures apart (found while lifting a
    reserve on #152). The Outscale Terraform suite asked whether the emulator held
    no Net at all, which is true only when it is the sole creator against a
    fresh emulator. Run against a bench another run had touched, it announced "the
    destroyed Net still answers" while the destroy had worked perfectly: the
    message blamed the subject for the state of the bench.

    It now asks whether this run's Net is gone, names it when it is not, and says
    plainly when somebody else's resources are still around. Falsified: make the
    emulator keep a Net through its own delete and the suite fails naming the
    identifier.

  • The status table is generated from the workflow that proves it (reported
    by a reader comparing the README with CI). It said Outscale was proven by
    oapi-cli and Terraform. Both were true of the repository and only one was
    true of CI: the Outscale Terraform fixture exists, applies twenty-one
    resources, plans empty and destroys clean — and no workflow ran it, so a
    regression in it would have reached a release without one red check.

    The suite is in CI now, on both engines, and the table is no longer
    hand-written: its proven by column is read from
    .github/workflows/conformance.yml, so a client appears when a workflow drives
    it and goes when it stops. A suite CI runs that nobody mapped is refused by
    name rather than dropped in silence — understating what is proven is the same
    defect wearing the other face.

  • Six defects an audit of the 0.8 train found, and the false verdict that
    found a seventh.
    The delivery was audited twice before tagging; everything
    below was reproduced before being fixed.

    • A block volume restored smaller than its snapshot answered 201. The guard
      lived on updateBlockVolume while its comment stated a property of the
      volume — "a volume grows and does not shrink" — held on one of two paths. A
      10 GB snapshot restored into a 1 GB volume, available. Neither the barrage
      nor the invariant sweep could see it: one drives no block route, the other
      asks about identity, not about whether a size makes sense.
    • Releasing an IPAM address took no lock, while booking one held the
      allocator from rebuild to store. allocatorFor rebuilds occupancy from the
      IPAM resources alone, so deleting one is exactly what frees an address. Both
      release paths now hold it and re-read under it, and the writes go through
      Commit rather than Put, which re-inserts a resource the client released.
    • A falsification claim was false. "Neutralise any of the three locks and
      the barrage goes red on the first attempt" — thirty green runs with the
      private-NIC lock removed. Every worker takes its own subnet, so no contention
      defect can surface there whatever it drives. The claim now says which two it
      holds and names the test that holds the third.
    • The evidence artefact was fourteen operations behind at a release
      candidate, and nothing was red: docs/routes.md printed "—" for them, which
      reads exactly like an operation nothing has proven. A test now requires every
      mounted operation to have a row.
    • A conformance assertion produced a false verdict. feint clean gained a
      line reporting stale runtime records, printed before its tally; the Outscale
      suite prefix-matched the whole output and announced "the delete left a machine
      behind" while the tally said zero. It reads the count now, and refuses to
      decide when there is no count to read.
    • The documentation claimed no workflow starts a machine runtime, in five
      places across two languages, contradicted by the nightly job shipped in the
      same release train. It was frozen in the generator, so feint docs --check
      reconducted it at every release: the gate compares the page with its
      generator and proves the form, never the claim. The true distinction — no
      pull-request gate starts one — is what they say now.

Changed

  • The verify recipe names the release workflow, not the repository (#129).
    docs/install.md published --certificate-identity-regexp 'https://github.com/stephrobert/feint/.*', which accepts any workflow of
    this repository that ever gets id-token: write — a claim about who owns the
    repository rather than about what built the file. It is now anchored on
    .github/workflows/release.yml@refs/tags/v, and the gh recipe gains
    --signer-workflow.

    Both halves were run against the published 0.7.3: the new identity verifies it,
    and pointed at another workflow of the same repository it refuses, naming what
    it expected and what it got. The old one accepted that other workflow — the
    width being closed.

    tools/release/preflight.sh now extracts the identity from the page and
    runs it against the previous release, then checks it can still refuse. The
    recipe a reader copies and what the workflow signs cannot drift apart in
    silence, which is what happened here.

  • A barrage of concurrent traffic, and one invariant sweep over the store
    (#134). Each pack now drives its own served routes from ten workers at once —
    Terraform's default parallelism — and the store is then swept by a
    provider-neutral check in internal/core/store/storetest: no identifier issued
    twice, no address held by two resources of one kind, no runtime object claimed
    by two resources. A snapshot restore racing live traffic has its own test.

    It found a real defect on its first run against Exoscale: elastic IP
    allocation was a read-modify-write with no lock, so three addresses out of
    sixteen creates went to two resources each. The Scaleway pack fixed that shape
    for its own pools long ago and this one never received it — written twice,
    fixed once, alive in the other copy.

    The sweep lives in the core and knows no provider, so a fourth pack inherits it
    by calling one function; it finds addresses by shape rather than by attribute
    name, because a sweep keyed on each pack's spelling is a sweep a new pack
    escapes.

  • A snapshot is understood or refused, and says which version it is (#133).
    feint snapshot save, GET /_feint/state and --state now write
    {"format": "feint-snapshot", "version": 1, "resources": [...]} instead of a
    bare array, and Restore refuses anything it cannot account for: a version it
    does not read, a format that is not ours, an unknown field on a resource.

    This is a breaking change to the snapshot and state formats. A file written
    by 0.7.x is refused with a message saying how to convert it, and a PUT /_feint/state carrying a bare array is refused too. Taking a fresh snapshot
    from the instance that holds the state is the way through.

    The reason it is worth breaking: the old format lost data in silence. A
    snapshot carrying a field this build does not declare restored successfully,
    encoding/json dropped the field, and the next save wrote the file back
    without it. The store was coherent, wrong, and green — measured before the
    change, not feared. snapshot.go documents the format as made to outlive its
    instance and be loaded into another one, which is exactly when this bites.

    Attrs stays open, because its keys are data a pack chose rather than schema:
    a new attribute is not a format change, and refusing one would make every pack
    addition breaking.

    Two documents disagreed about whether any of this was a promise —
    store.go called the format an implementation detail with no compatibility
    promise, RELEASING.md listed it among the surfaces whose change is breaking.
    They now say the same thing, and the stricter one won.

Added

  • A container image, control plane only, published with the release. The
    release workflow pushes ghcr.io/stephrobert/feint:<tag> for linux/amd64 and
    linux/arm64 — the exact binaries the release signs, wrapped in scratch,
    16.6 MB, nothing else inside. It runs feint serve with --vm off and says
    so: real machines stay a property of the binary on an Incus host, and an
    image claiming otherwise would be the half-truth this project refuses. The
    proof is not "it starts": the conformance workflow's image job drives the
    emulator inside the container with the official scw CLI and the contract
    probe on every pull request, through the published port, the way a
    services: block reaches it. The image is signed (keyless, by digest) and
    carries provenance and SBOM attestations under the same
    release.yml@refs/tags/v identity as the binaries; the verification recipe
    in docs/install.md is executed by the release workflow against the image it
    has just pushed, and by the preflight against the previous release. One tag
    per release, nothing mutable: no latest. A release now refuses to push an
    image whose own feint version is not the tag being released.

  • Scaleway serves Block Storage, and a server's root volume can finally be
    written
    (#8). block/v1 and block/v1alpha1 mount 22 routes: volumes,
    snapshots and the volume-type catalogue. root_volume { volume_type = "sbs_volume" } is honoured, the disk is created in Block, and the Terraform
    provider reads it back through the fallback it always used —
    instance.GetVolume first, then block.GetVolume on a typed 404.

    Before this, root_volume had no usable value at all: the provider refuses
    b_ssd outright from 2.79 on, and sbs_volume planned for ever. Measured and
    reported by @vde-dis, who tried honouring it, watched the apply die on
    "waiting for Volume failed: http error 404 Not Found", and threw the change
    away rather than guess. The conformance fixture omitted the block, so the
    suite was green while never asking the question — a test that avoids the one
    input that breaks. It declares the block now.

    Two things only the real clients could have said, both found on the first run
    of the suite. scw 2.56.3 calls /block/v1alpha1 for every block command
    while the Terraform provider calls /block/v1: two official clients of one
    cloud, each pinned to a different spelling, so both are served from the same
    handlers rather than one being declined on a reason the CLI falsifies. And
    scw block volume create refuses a raw byte count where the instance command
    takes one, wanting 10G.

    The volume shape comes from a recording of a real account rather than from the
    SDK, which is why kms_key_id and last_detached_at are present and null and
    why references is computed from the attachment rather than stored beside it.
    A reference identifier is derived from the pair it joins, so it reads back the
    same on every plan.

    Refusals a client can observe: a volume created from neither or both of
    from_empty and from_snapshot, a volume that would shrink, a kms_key_id
    naming a Key Manager this emulator does not serve, a volume deleted under its
    server, and a snapshot deleted under a volume restored from it. The two Object
    Storage transfers stay declined, for the reason instance/v1.ExportSnapshot
    carries.

    Conformance: 158 of 206 routes proven by a real client, up from 146 of 184.

  • Scaleway serves snapshots and images the client creates (#7). The
    golden-image sequence — snapshot a volume, cut an image from that snapshot,
    list and delete both in the order the API imposes — is a control-plane path
    answerable at every step, and Outscale has answered it since 0.6.0 while this
    pack declined it. Nine operations move from Declined() to served:
    Create/Get/List/Update/DeleteSnapshot, Create/Update/DeleteImage and
    ListImages, which now carries the client's images beside the fixed
    catalogue.

    The refusals they replace read "a snapshot copies the bytes of a volume" and
    "the catalogue is a table nothing can add to". Both sentences were true and
    neither was a reason: the bytes are the one part an emulator cannot provide,
    and that limit is named where it bites rather than at the door — an image cut
    here boots nothing and says so (#115), instead of substituting a distribution
    nobody asked for. ExportSnapshot stays declined, since it writes those bytes
    into Object Storage.

    Two refusals a client can observe: a snapshot of a volume that does not exist
    is a 404 rather than a record of nothing, and a snapshot an image is cut from
    refuses to delete until the image is gone — the order Terraform walks when one
    plan removes both. GET /images/{id} reads the client's image before the
    catalogue, without which a create and its following read described different
    objects.

    scw instance snapshot create, image create, image list and the deletion
    order are driven end to end by the conformance suite: 146 of 184 routes are
    now proven by a real client, up from 140.

Fixed

  • feint --help names every command it dispatches (reported by @vde-dis).
    shapes answered, was documented in the guide, and was missing from the help,
    so anyone exploring the CLI the way people do could not find it. The line is
    added, and a test now reads the dispatch from the source and requires each
    verb to appear: adding the missing entry fixes today, comparing the two lists
    is what stops the twenty-first verb from shipping invisible.

Don't miss a new feint release

NewReleases is sending notifications on new releases.