Troubleshooting
1119 refusals, each in the words migkit prints it.
Every refusal migkit can stop with, read from where the code raises it: search this page for the words you saw. The parts filled in at run time are shown as <...>. Each message says what to do.
Addresses, migkit init and the hop's configuration
- REFUSALthe <...> address <...> names no engine migkit knows by <...> (it knows <...>) - did you mean <...>:// | <...>
- REFUSALthe <...> address <...> holds a password, and migkit keeps none in its configuration. Take it out of the address and either let
migkit initkeep it in this machine's keychain, or put it in an environment variable and write the variable in its place: <...>://<...>:env:NAME@... - REFUSAL<...>: the port is not a number
- REFUSALthe <...> address <...> names no program
- REFUSALthe <...> address <...> names no catalog
- REFUSALthe <...> address <...> names no file
- REFUSALthe <...> address names <...> servers, and a <...> side is one server
- REFUSAL<...>: its DNS records could not be read (<...>: <...>)
- REFUSALsslmode=<...>: one of <...>
- REFUSALthe <...> address's <...>=<...>: a <...> side has no option <...> - did you mean <...>? | <...> It reads: <...> | It reads none from an address
- REFUSALssl-mode=<...>: one of DISABLED, PREFERRED, REQUIRED, VERIFY_CA, VERIFY_IDENTITY
- REFUSALthe <...> address asks for no TLS (ssl-mode=<...>), and a MySQL connection migkit opens takes TLS wherever the server offers it - leave ssl-mode out
- REFUSALssl-mode=<...> checks the server's certificate against an authority: say which with ssl-ca=<its certificate file> (a managed service publishes its bundle)
- REFUSAL<...> is not a change a tail carries - insert, update or delete
- REFUSALobjects: <...> is not a kind of object - <...>
- REFUSAL<...>: a list of names, or databases each with all, a list of tables, or its schemas
- REFUSAL<...>: <...> - all, a table, a list of tables, or its schemas
- REFUSALnothing is kept in this machine's keychain as <...>/<...> -
migkit initkeeps it there, or write another reference - REFUSALpip install boto3 for AWS sign-in and secrets
- REFUSAL<...>: <...> | <...>
- REFUSAL<...> <...> may be changed by every user of this machine; make it writable by its owner alone (chmod o-w)
- REFUSAL<...> <...> is in a directory every user of this machine may write, where any of them may put another file in its place; keep it in one only its owner writes
- REFUSAL<...> <...> belongs to another user of this machine (uid <...>), who may change it; it is taken only from this user or root
- REFUSALpip install google-cloud-secret-manager for gcp-sm: secrets
- REFUSALpip install azure-identity azure-keyvault-secrets for azure-kv: secrets
- REFUSAL<...> has <...> problem<...>, and nothing was run: <...>
- REFUSALno hop configuration yet (<...> does not exist). create one: migkit init or point at an existing file: MIGKIT_CONF=/path/to/hops.yaml
- REFUSAL<...> is not YAML migkit can read, and nothing was run: <...>
- REFUSALauth: <...> - password (the default), or the cloud's own sign-in: <...>
- REFUSAL<...>: the source address names <...> and databases says <...> - say it once
- REFUSAL<...>: the target address names <...>, and the source <...> databases | none - name as many on each, in the same order, and each moves into the one in its place
- REFUSAL<...>: <...> goes to <...> by the target address and to <...> by db_map
- REFUSALunknown hop <...> - did you mean <...>? | <...>, have: <...>
- REFUSAL<...>: mapping.names.<...>.<...> cannot be turned round for the way back - not every name it writes says what it was. Name those tables in mapping.tables, which is turned round exactly
- REFUSAL<...> already has a hop <...> going somewhere else (MIGKIT_HOP=<another name> adds this one beside it)
- REFUSALMIGKIT_GOAL=<...>: one of <...>
- REFUSALthis machine has no keychain migkit can use; keep the passwords in environment variables instead (MIGKIT_SECRETS=env)
- REFUSALno <...> address: set <...> or run
migkit initin a terminal - REFUSAL<...> holds <...>, which migkit reads nothing from beside
hopsand <...> - add the hop by hand, or use --force to write a new file (which leaves nothing of the old one) - REFUSAL<...> is not YAML migkit can read; use --force to write a new one
- REFUSALthe hop could not be added to <...> as it is written (<...>); nothing was changed - use --force to write a new file
- REFUSAL<...>: <...> - <...>
- REFUSALtopology: <...> - one_way or two_way
- REFUSALreverse: <...> - at_cutover
- REFUSALorigin_table: <...> - keep, or drop
- REFUSAL<...>: goal <...> - <...> - so <...> is not run. Change the hop's goal to copy or cutover to move data.
- REFUSALengine: <...>, and the <...> address is a <...> one - leave engine out and the two addresses say what the pair is
- REFUSAL<...>_engine: <...>, and the <...> address is a <...> one
- REFUSAL<...>: not a file migkit reads a hop from - a replication task's JSON, a connector's configuration, or a LOAD DATABASE command file
- REFUSAL<...>: JSON, but neither a replication task (it has no TableMappings), a DTS job (no MigrateOption, Objects, ObjectItems or DbObject), a DRS job (no base_info or object_info), a migration job or stream (no sourceDatabase or sourceConfig), an Azure migration (no taskType or sourceDatabaseName) or a connector's configuration (no connector.class)
- REFUSALthe file holds <...> replication tasks; give it one (a hop is one task)
- REFUSALthe endpoint <...> is a <...> one, which migkit has no engine for
- REFUSALa row filter on a <...> source: migkit has no engine to write it in
- REFUSALfilter operator <...>: not one migkit reads
- REFUSAL<...>: a list of migration jobs says no objects; save the job's own detail - tccli dts DescribeMigrationDetail --JobId <...>
- REFUSALthe file holds <...> jobs (<...>); give it one (a hop is one job)
- REFUSALthe job's <...> is a <...> one, which migkit has no engine for - it reads a job between <...>; where the <...> speaks one of them under a name of the service's own, write the hop with
migkit initand give that engine's address - REFUSALthe job sends database <...> to both <...> and <...>
- REFUSALthe file holds <...> DTS jobs (<...>); give it one (a hop is one job)
- REFUSALthe job's <...> is a <...> one, which migkit has no engine for
- REFUSALthe file holds <...> DRS jobs (<...>); give it one (a hop is one job)
- REFUSAL<...>: its detail says no objects; save the objects it takes beside it, under db_object - GET /v5/{project_id}/jobs/<...>/db-objects
- REFUSALthe job's <...> names no engine migkit has
- REFUSALthe file holds <...> <...>s (<...>); give it one (a hop is one <...>)
- REFUSALthe job's <...> (<...>) names no engine migkit has
- REFUSALthe stream reads <...>, which migkit has no engine for
- REFUSALthe file holds <...> migrations (<...>); give it one (a hop is one migration)
- REFUSAL<...>: a <...> of the migration service, not a migration - save the migration task, or the database migration
- REFUSAL<...>: a task that does not migrate a database - save the project's migration task (its taskType begins Migrate.)
- REFUSALthe file's connector.class reads no database migkit has an engine for
- REFUSALconnection.url <...>: not an address migkit reads
- REFUSALLOAD <...> loads files into a table; a hop moves a database - only LOAD DATABASE is read
- REFUSALLOAD DATABASE without FROM and INTO addresses
The commands
- REFUSALshare_tables needs the s3 state backend (options.state.backend: s3): the machines sharing a move find each other's tables there
- REFUSAL<...> masks columns on the way, and this engine's change stream would carry their real values into the target: a hop that masks is copied here (--mode full), not followed. Nothing has been started
- REFUSAL<...> masks columns on the way, and a repair of rows on this engine writes the source's values as they are, unmasked: --kind sequences or --kind schema repairs the rest. Nothing has been started
- REFUSAL<...>: <...> not configured yet fill host/user/password in conf/hops.yaml, then: migkit doctor
- REFUSAL<...> already exists (use --force to overwrite)
- REFUSALa position belongs to one database: name it with --db (<...>)
- REFUSAL<...>: no stream of this hop reads a position, so there is nothing to drain to. Its cutover proves the drain by a mark
- REFUSAL--convert is for hetero hops, same-engine hops use migkit schema HOP
- REFUSAL--migration supports postgres and mysql hops
- REFUSALgenerating migration DDL needs a component that is not installed on this machine: migkit doctor --install puts it in place
- REFUSAL<...>: <...>
- REFUSAL--drill needs --db and --table (schema.table)
- REFUSAL--drill supports postgres and mysql hops
- REFUSALthe row-by-row drilldown needs a component that is not installed here: migkit doctor --install puts it in place
- REFUSAL[BLOCKED] <...>
- REFUSAL--only <...>: not a check of this hop's engine; its checks are <...>
- REFUSAL<...>: <...>. Nothing has been compared
- REFUSALon_conflict: <...> - source-wins or keep-target
- REFUSALrun migkit check first, then sync uses its diffs
- REFUSAL<...>: <...> is writing to this target, and a row repair beside it would race it - the row that survives is whichever lands last. Nothing was applied. Stop it, repair, and start it again, or let it catch up and check again.
- REFUSAL<...>: <...> did not pause within <...>s (hop option repair_window); no repair was applied and it was asked to resume. Confirm its current state, inspect why the pause failed and resolve the coordination, then rerun the repair plan
- REFUSAL--kind picks what a repair of the last check's differences puts right; --mode <...> runs a whole flow and repairs whatever it finds
- REFUSAL--tag names the restore point --go takes; without --go nothing is saved to name
- REFUSAL--interval is the time between the cycles of --serve
- REFUSAL--serve keeps verifying a stream: --mode stream or --mode migrate
- REFUSAL--apply repairs; --go repairs with a restore point taken first - one or the other
- REFUSAL<...> is a copy for testing (goal subset): it is taken afresh by migkit move <...> --mode full --go, and proved by migkit check <...>; sync makes a target equal to the whole source. Nothing was written
- REFUSAL<...>'s goal is <...>: its target holds rows this source does not, and sync makes a target equal to the source. It is carried by migkit move <...> --mode full --go and proved by migkit check <...>. Nothing was written
- REFUSALgoal <...>: one of <...>
- REFUSAL<...>'s goal is <...>: migrate runs <...>
- REFUSAL<...> reported success and <...> is still empty on the target: <...> ... | <...>. Nothing has been marked as moved - look at the copy's output above, and at the target server's log
- REFUSALthe bulk copy finished and <...> of <...>'s tables do not hold what the source does: <...> ... | <...>. Nothing has been marked as moved. A source written to while it was copied differs by what changed - move with --mode full+cdc for that; otherwise
migkit syncputs the rows right - REFUSALthe hop maps or masks columns or renames tables (mapping.columns, mask_on_write, mapping.tables), and the server's own replication carries whole rows under the source's names, as the source holds them. Nothing was set up.
migkit move --mode cdcfollows this hop with migkit's own change tail, which applies the mapping. - REFUSAL<...>. Nothing was set up.
migkit move --mode cdcfollows this hop with migkit's own change tail, which reads the hop's scope and mapping for every change. - REFUSAL<...>. Nothing was set up.
migkit move --mode cdcfollows this hop with migkit's own change tail, which stops on a schema change instead of carrying half of it. |migkit move --mode fullcopies what the hop covers, andmigkit syncbrings the target level again before cutover. - REFUSAL<...>: the tail is still running; stop it first, then take its marks away
- REFUSALthe streaming pipeline did not come up (its stack is written under <...>); migkit doctor says what this machine is missing
- REFUSAL--drop tears the stream down: migkit move <...> --mode cdc --drop
- REFUSAL--table narrows a copy; a stream follows the whole database (--mode full or full+cdc)
- REFUSAL--chunk sizes the ranges of a copy; --mode cdc copies nothing
- REFUSALa topology is moved and proved one database at a time: migkit move <...> --db <name> --go
- REFUSALthe topology's move stopped at <...>: <...>. migkit check <...> says what differs; the same command goes on from the hops that finished.
- REFUSAL<...> <...> | <...>Nothing past the last finished table is marked as moved. The commands that ran are in the run's commands.log.
- REFUSALthe move stopped: no space left on this machine for <...>. Free space there and move again; the checkpoint is as it was before the write that did not fit, and the next run goes on from it.
- REFUSALthe copy stopped: <...> <...> | <...>Nothing past the last finished table is marked as moved. The commands that ran are in the run's commands.log.
- REFUSAL<...>: a seed from a copy of the source's pages cannot be held to the number of the machine that holds the hop, so it is not run with standby on. Seed it from one machine with standby off, then turn standby on for the change stream (--mode cdc). Nothing was written
- REFUSALmoving and then following a <...> source is not set up on this machine; migkit doctor says what is missing
- REFUSALan earlier move is still writing to <...> (process <...>); a move beside it would empty the tables under it. Do not start another move. Inspect the saved run log and have the owner finish or safely stop that process, confirm it has stopped, then rerun the original move command
- REFUSALthe programs installed here do not take options the move passes them - migkit doctor --install puts builds that do in place
- REFUSALno way to follow a <...> source is set up on this machine - <...> | ; migkit doctor says what is missing
- REFUSAL<...>: a group's changes are followed whole - leave out --table
- REFUSAL<...>: the follow of a group runs one database a process - --db one of <...>
- REFUSAL<...>: cutover stopped because the change tail did not end. Do not advance the cutover or release an existing write freeze. Inspect this hop's tail status and its saved run log, resolve the stop failure, then rerun the cutover plan before approving another attempt
- REFUSAL<...>: cutover stopped because the change tail did not pause. Keep the cutover blocked. Inspect the tail's progress and its saved run log, resolve the pause failure, then rerun the cutover plan
- REFUSAL--only names the checks --verify runs each cycle
- REFUSAL--teardown drops what --delta keeps; --verify alone keeps nothing to drop
- REFUSAL--serve and --metrics are for every hop; --refresh, --open and a hop name are for one hop's report
- REFUSAL--port is where --serve listens
- REFUSALwhich hop? reports exist for: <...>
- REFUSALno state matching '<...>', have: <...>
- REFUSALthe masking key was not replaced
- REFUSALthe move's checkpoint <...> kept changing while it was written; nothing past the last save is lost. Check which machines still own this move and reconcile their state; the checkpoint is kept, and once the contention is resolved the original move command goes on from it
- REFUSALthe move's checkpoint kept changing under migkit while it saved it. Check which machines still own this move and reconcile their state before retrying; once the contention is resolved, rerun the original move command
- REFUSALthe keys and constraints of <...> were not all put on; migkit migrate runs this phase again
Planning: the ways, the machine and the limits
- REFUSAL<...>: <...> failed (<...>), and what it began could not be undone (<...>) - no other way is tried over it
- REFUSALlimits: <...> <...> is not between 0 and 100%
- REFUSALlimits: <...> <...> is not a share (0.3 or 30%)
- REFUSALlimits: <...> <...> is below zero
- REFUSALlimits: <...> <...> is not a number
- REFUSALlimits: <...> <...> is not a size (8GB)
- REFUSALdeadline: <...> is neither a duration (6h, 90m, 2d) nor a moment (2026-10-01T02:00)
Moving the data
- REFUSAL<...> was restored with no change tracking version, so nothing says where its changes go on from
- REFUSALthe Aurora copy did not say the LSN its storage starts from
- REFUSALthe copy holds less than the oldest binlog the source still keeps (<...>): the changes between were purged, and nothing can carry them
- REFUSALthe copy is <...> at <...>:<...>, and the hop's target is <...>:<...>. Point the hop's target there and move again: it goes on from the copy, which is kept
- REFUSALthe restored server does not say which binlog position it holds, and GTIDs are off on the source: the position is never guessed. Turn GTIDs on, or copy with the logical copy
- REFUSALthe copy's position is not exact: <...>
- REFUSAL<...> is <...>
- REFUSAL<...> is <...> after its upgrade
- REFUSAL<...> runs <...> version after its upgrade to <...>
- REFUSALthe clone failed: <...>
- REFUSAL<...> runs <...> after its upgrade to <...>
- REFUSALthe upgrade failed: <...>
- REFUSALa <...> copy is not upgraded through its API by migkit; the logical copy carries an upgrade
- REFUSALMIGKIT_TABLE_COPY=<...> is not one of <...>
- REFUSALthis way needs a component this machine does not have - migkit doctor --install puts it in place
- REFUSAL<...> ... | <...> have a key and REPLICA IDENTITY NOTHING: in a publication the source would refuse its application's updates and deletes on them while the copy runs. Nothing has been made; move without server_to_server, or give them an identity
- REFUSALthis bulk path needs a component this machine does not have - migkit doctor --install puts it in place
- REFUSAL<...>. Nothing has been copied
- REFUSAL<...> has fewer partitions on the target than on the source: a key's messages would land in another partition, out of the order its consumers read them
- REFUSALMIGKIT_MOVER=<...> is not one of <...>
- REFUSALMIGKIT_MOVER=<...> does not apply to a <...> hop
- REFUSALthe hop maps row filters onto <...>, and nothing on this <...> path can apply one: neither its bulk copy nor its table copier takes a row predicate. Moving anyway would copy every row and leave
checkcomparing a filtered source against a full target for good. Drop the filters, or narrow the source with a view the hop points at instead. - REFUSALthe hop masks <...> on the way, and this engine's copy writes what it reads, as it reads it - no way of it takes the hop's transforms. Nothing has been copied. Drop the masking rule to copy the values as they are
- REFUSALthe hop masks <...> on the way, and this path carries whole tables as they are and cannot leave a masked one to the table copier, which masks it. Nothing has been copied. Move by another way, or drop the masking rule
- REFUSAL<...>: the hop asks to mask <...>. Nothing has been copied: fix the rule, or drop it to copy the values as they are
- REFUSAL<...>.<...>: the hop's transform cannot run: <...>. Nothing has been copied: fix the rule, or drop it to copy the values as they are
- REFUSAL<...> would be emptied anyway: the table references one of the tables this move replaces, and emptying a table empties everything pointing at it. the hop excludes it, which says its rows are written here and not carried, so they cannot be put back afterwards. either it is not target-owned after all - take it out of the hop's exclude list and let the move carry it - or the reference has to go before the move can run. | <...> the hop carries only the rows its filter selects into it, and the rows outside the filter are the target's own, so they cannot be put back afterwards. Either the filter goes, or the reference has to go before the move can run. | <...> the source has no such table, so the move does not carry it and its rows are the target's own, which cannot be put back afterwards. Either the reference goes before the move can run, or the hop leaves out the table it points at. | <...>
- REFUSAL<...> ... | <...>: the hop carries only some of their changes (mapping.ops), so the rows the target holds of them are kept as they are - a row the source deleted, or changed, stays as it was there - and emptying them for the load would take those rows. Nothing has been emptied. Move them while the target holds none of their rows, or follow only their changes (
migkit move --mode cdc) - REFUSAL<...>: <...> ... | <...> have triggers on the target - foreign keys among them - and <...> can neither turn them off for the load nor load as a replica. Loading anyway would either be refused row by row or let the triggers rewrite what arrives. Nothing has been written. Grant it with
GRANT SET ON PARAMETER session_replication_role TO <...>(PostgreSQL 15 and later), or move as the managed service's admin user. - REFUSALthe installed bulk copy program accepts none of <...>, which this move needs -
migkit doctor --installputs a version in place that does - REFUSAL<...>: the bulk copy stopped on <...> (<...>: <...>: <...>); nothing it loaded is taken as done and no other way is tried over it. Next: <...>, then run the move of <...> again - the table copier replaces each range by key;
migrate --whykeeps the evidence - REFUSAL<...>: the hop asks to mask <...>. Nothing has been written: fix the rule, or drop it to copy the values as they are
- REFUSAL<...>: <...>
- REFUSAL<...>: the copy's own checksum of <...> tables differs from the source's: <...> ... | <...>. Nothing has been marked as moved; the load reported <...> warnings, the likely cause | <...>. A source written to while it was copied differs by what changed - move with --mode full+cdc for that; otherwise
migkit syncputs the rows right - REFUSAL<...>: the tables masked on the way are not what the hop's transforms make them: <...>
- REFUSALno free port could be found on this machine
- REFUSAL<...>: the online sync carried collections the hop leaves out: <...> ... | <...>. They are on the target now; nothing has been marked as moved - drop them there, or move this hop by the dump
- REFUSALMIGKIT_CDC=<...> is not one of native, follow. native = the database's own replication, which needs the target to dial the source; follow = a leg driven from where migkit runs, which connects out to both sides instead
- REFUSALthis CDC path needs a component that is not installed on this machine: it runs for the length of the catch-up and keeps its state in <...>. migkit doctor --install puts it in place, or use MIGKIT_CDC=native, which needs no component here but does need the target to reach the source
- REFUSALthe CDC leg exited <...> before it finished catching up; its log is <...>
- REFUSALthe CDC leg did not reach its end position in <...>s, and was stopped there; its log is <...>. Nothing has been marked as caught up - raise MIGKIT_FOLLOW_TIMEOUT if the backlog is simply larger than that
- REFUSALthe CDC leg never became ready to be told to apply; its log is <...>
- REFUSALthe CDC leg exited before it was told to apply anything, so nothing reached the target; its log is <...>
- REFUSALcould not set the <...> on the CDC leg: <...>
- REFUSAL<...>: the columns the hop keeps could not be matched against the source's, so the stream cannot be told which to take. Nothing has been started
- REFUSAL<...>: a name holding a comma cannot be put on <...>'s lists, which a comma divides. Nothing has been started
- REFUSALthe hop moves <...> databases (<...>), and <...> writes into the one database its sink is given: every database's tables would land in the first's. Nothing has been started - follow one database a hop, or with migkit's own change tail
- REFUSALthe source's tables in <...> could not be listed, so what the hop maps cannot be matched against them. Nothing has been started
- REFUSALthe change stream's configuration was refused before it started: <...>. Nothing has been registered
- REFUSALno bulk path named <...>
- REFUSALthis bulk path needs programs this machine does not have - migkit doctor --install puts them in place
- REFUSALthis bulk path needs a component that is not available on this machine - migkit doctor says what is missing and migkit doctor --install puts it in place
- REFUSALthe <...> an earlier move of <...> started is still running (process <...>, since <...>): the run that started it was stopped without stopping it, and it is still writing. A move started beside it would empty the tables under it. Wait for it to finish, or stop it (
kill <...>), then run the move again. Nothing has been written by this run - REFUSALthe installed <...> does not take options the move passes it: <...>. Nothing has been written. migkit doctor --install puts a build that does in place
- REFUSAL<...>: <...> ... | <...> would fire for every row the load writes, and could rewrite them; <...> cannot create them again as their definer after taking them off. Nothing has been loaded. Load as an account allowed to set a definer (SET_USER_ID), or take them off and put them back yourself.
- REFUSAL<...>: the target's triggers could not be saved before taking them off for the load, so nothing was loaded
- REFUSAL<...>: <...> triggers were not put back: <...>. Their definitions are in <...>
- REFUSALphysical: source is <...>; it names the source as host:port, as the target's host reaches it
- REFUSALthe hop's <...> command failed (exit <...>): <...>
- REFUSALthe hop's <...> command failed: <...>
- REFUSALa slot named <...> exists on the source with the <...> plugin; it is not this hop's - drop it or rename the hop
- REFUSALthe copy of the source's pages failed, and the target's server is left stopped with its data directory as the copy left it - nothing was written to the source but the slots, which are dropped. What it said: <...>
- REFUSAL<...> did not accept a connection within <...>s after the copy: <...>. The copy carries the source's users - the hop signs in to the target as one of them, with the source's password
- REFUSALthe target does not say where its recovery ended: it was restarted after the copy, or it was not started from one. The position the changes go on from is never guessed - move again, which copies again
- REFUSALthe target's system identifier is <...> and the source's <...>: the target is not a copy of this source
- REFUSALthe target's recovery ended at <...>, before the copy's own end at <...>: it is not consistent, and nothing goes on from it
- REFUSALthe target's last checkpoint (<...>) is before the end of its recovery (<...>): the two do not describe one recovery
- REFUSAL<...> was copied from the source's pages on <...> for the servers' own replication to go on from: its slot is read through a publication the change leg run from here does not read. Its changes go on by that replication (MIGKIT_CDC=native), or move again with --mode full+cdc and MIGKIT_CDC=follow, which makes the slot for this leg
- REFUSAL<...> was copied from the source's pages on <...>, and no slot was made before that copy, so nothing holds the changes after its position <...>: a change leg started now would carry only what changes from now on. Move again with --mode full+cdc, which makes the slot first and goes on from the copy's own position
- REFUSALthe clone is complete and the target must be restarted to open it, and nothing restarts it by itself. The hop says how (physical: {restart: ...}); restart it and move again, which goes on from the clone
- REFUSALthe clone did not complete: <...> <...> <...>
- REFUSALthe target holds <...> and the clone recorded <...>: they do not describe one copy
- REFUSALthe clone's position is not exact: <...>
- REFUSALdb<...>: no way to read the source here - <...>
- REFUSALdb<...>: <...>. Nothing has been copied
- REFUSALdb<...>: the hop checks the servers' certificates, and this way of copying cannot. Nothing has been copied
- REFUSALthis bulk path needs a program this machine does not have - migkit doctor --install puts it in place
Following changes, and two ways at once
- REFUSALa message of TiCDC's open protocol ends inside a frame: the topic holds something else
- REFUSALan Avro type migkit does not read: <...>
- REFUSALformat: <...> - migkit reads <...>
- REFUSALthe TiCDC changefeed's messages carry no commit timestamp, and without it no change can be put in the order it was committed: create the changefeed's sink with enable-tidb-extension=true
- REFUSALthe changefeed's messages carry no commit timestamp: make it WITH updated, resolved
- REFUSALthe Couchbase topic's messages are not the connector's default envelope (no mutation/deletion event): set the connector's source handler to its default, which carries each change's vBucket and sequence number
- REFUSALa DSQL change to <...> came in pieces that do not add up to what it says it holds (CRC32C): nothing of it is applied
- REFUSALa delete from <...> names no key: DSQL sends a deleted row's key only for a table with a primary key, and without one the row cannot be found on the target
- REFUSALa message of TiCDC's open protocol names no version 1 in its key
- REFUSALTiCDC's Avro names its schemas by the registry's ids: say where the registry is in the source's changes (registry: http://host:8081)
- REFUSALan Avro message of TiCDC's is not in the schema registry's framing
- REFUSALthe TiCDC changefeed's Avro carries no commit timestamp, and without it no change can be put in the order it was committed: create the changefeed's sink with enable-tidb-extension=true
- REFUSALthe topic's first message is in no protocol of TiCDC's migkit reads: canal-json with the TiDB extension, simple, open protocol or Avro
- REFUSALchanges: name the Kafka cluster the changes are published to (servers: host:9092)
- REFUSALchanges: name the topic the changes are published to (topic:, or topics: [...])
- REFUSALthe change topic <...> is not on the cluster the hop names
- REFUSALchanges: name the Kinesis stream the changes are published to (stream: name or ARN)
- REFUSALthe shards of <...> name each other as parents
- REFUSALa change to <...> cannot be carried as the feed wrote it, and its source cannot be read back
- REFUSAL<...> changes are held and the feed has not said for <...> minutes that anything older is past (nothing from <...>) | <...>: without its marks a change cannot be put in commit order. <...>
- REFUSAL<...>: drain to what? Name a position, or write
<...>for where the source stands this moment - REFUSAL<...> is not a WAL location - write it as 0/16B3748 (the form pg_current_wal_lsn shows)
- REFUSAL<...> is not a set of transaction ids - write it as uuid:1-500 (several, comma-separated)
- REFUSAL<...>: the source gives no position this stream can be held to, so there is nothing to stop at. A cutover of this hop proves its drain by a mark instead
- REFUSAL<...>: no change tail runs for this database, so nothing applies the changes up to a position. Start it (
migkit move <...> --mode cdc --go) and drain again - REFUSAL<...>: the tail did not reach <...> within <...>s - no stream of this hop's reads the source | (<...>s waited)<...>. Nothing was stopped; the tail goes on. Give it longer (a larger wait), or name an earlier position
- REFUSALtwo_way: this tail numbers its batches on the target by <...>, and the target no longer allows it: <...>. Which batch it last committed is kept there, so put that right and start the tail again
- REFUSALtwo_way: no way of marking migkit's own writes proved itself on <...>, so what it applies would come back to where it began. <...>
- REFUSALformat: protobuf is not written: <...>
- REFUSALformat: <...> is not one of <...>
- REFUSALformat: <...> is written through a schema registry, which a Kafka target has and this stream does not - one of <...>
- REFUSALfollow_until: <...> is not one of <...> - run until asked to stop, or until caught up with the source
- REFUSALcdc tail needs --db
- REFUSALthe saved position in <...> cannot be read, and a follow started from anywhere else either skips changes or cannot say it did not. Remove the file and move again with --mode full+cdc
- REFUSAL<...> was written by a newer migkit (envelope version <...>); this one reads version <...>. Run the newer migkit, or remove the file and move again with --mode full+cdc
- REFUSAL<...>: <...>. Nothing was applied. Move again with --mode full+cdc.
- REFUSAL<...>: the saved change position belongs to another source (<...>); the source is now <...>. A failover or a rebuilt server gives the same address a log of its own, and resuming in it skips what the old one held. Nothing was applied. Move again with --mode full+cdc, or remove <...> once the target is known to be level with the new source.
- REFUSAL<...>: offset disagreement detected: <...>
- REFUSAL<...>: <...> is not one of <...> - stop the tail, park the table the DDL touched, or apply what can be carried
- REFUSALddl.skip: <...> is not one of <...> - an ALTER or a rename left out would have every change after it written where the target has no column or table for it
- REFUSALspool_limit: the bytes a parked table's changes may take on this machine, a whole number
- REFUSAL<...>, so it could not be read back once set aside. Nothing of this batch was kept and its position stays where it was; the table's changes need a reader that hands its values over as plain kinds
- REFUSAL<...> was written by a newer migkit (layout <...>); this one reads layout <...>. Run the newer migkit
- REFUSAL<...> cannot be read (<...>). It holds the change tail's tables' states and what it set aside, and going on without it would be a guess, so migkit stops here; removing it and the tail's position beside it starts the tail over with --mode full+cdc
- REFUSAL<...> stands at batch <...> and the tail's position beside it at <...>: the two were not saved together, and which tables were set aside, and what for, cannot be known. Nothing was applied. Put back the two files as they were saved together, or remove both and move again with --mode full+cdc
- REFUSAL<...>: <...> was replaced on the source - its name names another table now (renamed, or two renames swapped one in under it) - at <...> or after, and nothing after that position was applied. The hop's
ddlis stop: setddl: applyorddl: parkto have it copied again, and run the tail again; it resumes from there - REFUSAL<...>: <...> was <...> on the source at <...> or after, and nothing after that position was applied. The hop's
ddlis stop: setddl: applyto carry what can be carried at its place, orddl: parkto set only that table aside, and run the tail again; it resumes from there - REFUSAL<...>: <...> is not one of <...><...>
- REFUSAL<...>: <...> compares no column, so it names none
- REFUSAL<...>: one rule - a name, or {newest|max|min: the column it compares}
- REFUSAL<...>: newest compares a column each row carries its last change's time in - name it as {newest: column}, or the table's or the hop's
column - REFUSALtwo_way.on_conflict: last_update_wins compares a column each row carries its last change's time in - name it as two_way.column
- REFUSALtwo_way: the <...> (<...>) cannot mark what migkit applies or leave it out when read, so every change would come back to where it began. Two ways run through migkit between PostgreSQL and MySQL (or MariaDB) sides
- REFUSALtwo_way: the target committed batch <...> of this tail, and this machine has no record of where in the source's log that batch ended - its position was saved elsewhere, or lost. Applying it again would add its counters twice, and going on from an older position would too; nothing was applied. Give this tail back the position file it saved, or move again with --mode full+cdc
- REFUSALtwo_way.delta: <...>.<...> is <...>, not a number - a counter is added to on both sides, so it has to be one
- REFUSALtwo_way: <...> on <...> compares <...>, which <...> does not have
- REFUSALtwo_way: union keeps both sides' members, and <...>.<...> is <...> - a set, an array or a JSON array holds members
- REFUSALtwo_way: <...> on <...> <...>: <...>, and the rule for <...> is error. Both versions are in conflicts.jsonl; decide the row on both sides, then run the tail again
- REFUSAL<...> keys were written on both sites that the hop's rule (<...>) does not settle: <...> and <...> more | <...>; nothing was written on either site. State two_way.on_conflict: newest (the later write by the server's clock) or delta/union (counters summed, sets merged), or settle the keys by hand
- REFUSALtwo_way.tables: a mapping of each table's rules by its name
- REFUSALtwo_way.on_conflict: source_priority keeps the row of the side ranked higher - give both as two_way.source_rank and two_way.target_rank, apart
- REFUSAL<...>: a mapping of <...>
- REFUSAL<...>.columns: a mapping of a column (or columns settled together, "a, b") to its rule
- REFUSAL<...>.<...>: not a key of a table's rules - <...><...>
- REFUSAL<...>: <...> settles one column - give each its own line
- REFUSAL<...>: columns settled together are settled by one column's value - name it as {<...>: column}
- REFUSAL<...>: <...> already has a rule | names no column
Checking and proving
- REFUSAL<...> was written by a newer migkit (layout <...>); this one reads layout <...>. Run the newer migkit
- REFUSAL<...>: a table copied again whole is not replayed from its record - run the repair again, which copies it from the source as it is now
- REFUSAL<...>: the rows it held before it was copied again were kept in <...>, which is gone - nothing was put back
- REFUSAL<...>: put back from its snapshot, it reads as <...> rows (digest <...>) and held <...> (digest <...>) before it was copied again - the snapshot did not bring it back exactly
- REFUSAL<...>: a table copied again whole is put back from its snapshot, never removed
- REFUSALno summary at <...>, run migkit check first
- REFUSAL<...>: no step <...> in the change sheet; export it from the plan first
- REFUSALno second reading is set up for <...> hops
Values kept at rest
- REFUSALthis file is encrypted for the hop's recipients, and no key to read it is at <...>: set MIGKIT_IDENTITY to the private SSH key or age identity it was encrypted to
- REFUSALthis file is encrypted to the hop's recipients, and the key in MIGKIT_IDENTITY is not one of them
- REFUSALa line of an encrypted file cannot be opened (<...>)
- REFUSALat_rest.scratch is <...>: an absolute path to a directory on an encrypted or memory-backed volume
- REFUSALat_rest.scratch <...> cannot be used for the files a program writes (<...>)
- REFUSAL<...> holds values the hop keeps encrypted (at_rest), and a file opened '<...>' cannot be kept so
The cutover, and what guards a write
- REFUSALapprovals.steps: a list of steps - <...>
- REFUSALapprovals.steps: <...> - not a step migkit holds; the steps are <...>
- REFUSAL<...> needs approval, and the hop's
approvals.signers- the list of who may approve - is not there, and no one approves it in the web view either (the hop'saccessnames no approver) - REFUSAL<...> is not offered for approval yet: <...>. Nothing was asked of the approvers. Then: <...>.
- REFUSALcutover: is
trueor the path's settings (<...>), not <...> - REFUSALcutover: <...> - not a setting of the cutover; it has <...>
- REFUSALcutover: budget is the seconds the write outage may last, more than 0
- REFUSALcutover: freeze <...> - one of <...>
- REFUSALcutover: jobs is move or leave
- REFUSALcutover: no_return is later (its own run of the command, once the flip is done) or at_flip
- REFUSALcutover: restore_points lists the sides a restore point is taken of through their provider's API before the clock: <...>
- REFUSALcutover: budget and start_below are seconds
- REFUSALcutover: pooler is {kind: pgbouncer, pgcat, proxysql or envoy, host, port, user, password, databases}
- REFUSALcutover: keys <...> - exact, or apart:<a whole number above 0>
- REFUSALthe interrupted cutover was undone: the source is writable and has what it had. Nothing was cut over; run
migkit move <...> --mode cdc --drop --goagain to cut over. - REFUSALthe cutover did not start, nothing was written: <...><...> | . To tear the stream down anyway, as an abandoned migration rather than a cutover: MIGKIT_CUTOVER=unproven
- REFUSALthe cutover did not start, nothing was written: <...>
- REFUSALthe stream was left up: <...> is still being written - <...>. Stop the application's writes (step 2) and run this again
- REFUSALthe stream was left up: it has not carried everything the source has (<...> at <...>). Tearing it down now would lose that; run this again once it has caught up
- REFUSAL<...> has no cutover past its flip to take past the point of no return
- REFUSALthe point of no return was undone (<...>): the old source is frozen as the cutover left it, and going back is still possible
- REFUSALthe point of no return stopped at the stream back's drop (<...>): <...> dropped already; the old source is frozen again.
migkit move <...> --mode cdc --drop --gogoes on from there - REFUSALthe cutover could not be fully undone: <...>. What is left is recorded;
migkit move <...> --mode cdc --drop --gotries it again - REFUSAL<...> is past the point of no return (approved by <...>): the stream back is dropped and the old source takes its own writes, so nothing the target took since is on it. Nothing was done
- REFUSAL<...> of the application's sessions could not be ended - migkit's account may not end them
- REFUSALthe <...> is not held by migkit here: <...>
- REFUSAL<...>: protect_target is set, and <...> - nothing has been copied. Remove the option to move without it.
- REFUSALthe provider made read_only 1, and the server still reads it off
- REFUSALread_only could not be given back through the provider; it is recorded, and the next run takes it off
- REFUSALa <...> side is not held by migkit
- REFUSAL<...>: nothing was written - <...>.
- REFUSAL<...>: nothing was written - the target is not the server the plan showed. Then: <...>; now: <...>. A DNS switch, a failover, a restart or an edited hop sends the write somewhere nobody looked at. Show the plan again (the same command without --go or --apply) to see this target; writing is then held to that one.
- REFUSALtarget_rows: <...> - <...>
- REFUSAL<...>: <...>. Nothing was written. Use target_rows: replace, or empty them
- REFUSAL<...>: <...> was not done - it <...> and cannot be taken back, and no plan showed it | the plan that showed it was for another target. Show the plan first (the same command without --go), then run it with --go against the target it names.
- REFUSALthe hop's lease kept changing under migkit while it tried to write it; another machine is taking it over and back - stop the other runs
- REFUSAL<...>: nothing was written - <...> thing<...> known now would stop this before its end: <...>.
migkit assess <...>lists everything the goal needs; MIGKIT_PREFLIGHT=warn goes on regardless - REFUSALa change an earlier run made on the source could not be taken off; nothing more is changed there until it is
Goals: upgrade, subset and rehearsal
- REFUSALsubset: most is a number of rows, not <...>
- REFUSALsubset: <...>: no rule - a condition, a share like 10% or a number of rows
- REFUSALsubset: <...>: <...> rows - more than 0
- REFUSALsubset: <...>: <...> - a share is more than 0% and no more than 100%
- REFUSAL<...>: the subset would hold more than <...> rows (<...> alone <...>), and the hop allows <...> (subset: most). Choose fewer rows to start from, or raise the bound; nothing was written
- REFUSAL<...>: its goal is not subset
- REFUSAL<...>: the subset cannot be taken, nothing was written: <...>
- REFUSAL<...>: <...> refers to <...> through <...>, which cannot be read on the source; nothing was written
- REFUSAL<...>: nothing was written - <...>
- REFUSAL<...>: a copy for testing is taken once (--mode full) and not followed - its rows are masked and chosen, and a change of the source's would carry neither. Nothing has been started
- REFUSAL<...>: a subset is taken whole - its tables refer to each other, and one of them alone would not be complete. Leave out --table
- REFUSAL<...>: <...> has no table on the target to write into; nothing was written
- REFUSAL<...>: the copy is not what it was to hold - <...>
- REFUSALthe copy of the pages is at the source's version and the hop does not say how to upgrade it: physical: {upgrade: {...}} needs <...> - the new version's programs, the old one's, the new data directory and how its server starts
- REFUSALthe new version's own upgrade refuses this copy, and nothing was changed on the source; the target's old server is left stopped with the copy as it was: <...>
- REFUSALthe new version's own upgrade failed on the target, and the source is as it was; the target's old server is left stopped with the copy as it was. What it said: <...>
- REFUSALthe target's server answers <...> after the upgrade, and the new version is <...>
- REFUSALthe clone is at the source's version and the hop does not say how to upgrade it: physical: {upgrade: {...}} needs <...> - how the old server stops and how the new version's server starts on the same data
- REFUSALthe cloud's copy is at the source's version and the hop does not name the version to upgrade it to: physical: {upgrade: {version: ...}}
Stored code carried to another engine
- REFUSALno code-conversion.json found for <...>
- REFUSALno draft fix for <...>
- REFUSALno proposed draft fix for <...>
- REFUSALproposed draft fix for <...> did not pass proof: <...>
Users and grants
- REFUSALusers: engine <...> not supported
- REFUSALusers: the target still differs from the source after create - <...>
- REFUSALusers: <...> step(s) failed, each named above and in <...>
- REFUSALusers: accounts are carried into <...> only from another <...>: its own accounts are read in a shape no other engine's meet
- REFUSALusers: <...>
- REFUSALusers: <...> could not be created
- REFUSALusers: <...> statement(s) failed
- REFUSALusers: <...> authority(ies) not granted
- REFUSALusers: a Teradata hop names its databases
- REFUSALusers: the <...>'s security configuration cannot be read (<...>): the account needs the security plugin's REST API
- REFUSALusers: one side is Elasticsearch and the other OpenSearch, which keep roles, users and mappings in shapes of their own - make them on the target by hand, from what compare lists
- REFUSALusers: the target answers no security API, so nothing can be carried to it
- REFUSALusers: <...> statement(s) failed, each named above and in <...>
- REFUSALsetpw: mongodb only (other engines can copy the hash)
Schedules, the run's state and tunnels
- REFUSAL<...>=<...>: one of 1, true, yes, on - or 0, false, no, off
- REFUSALschedule.timezone: <...> is not a time zone
- REFUSALstate: backend <...> is not one of <...>
- REFUSALthis restore point is encrypted: set MIGKIT_STATE_KEY to the passphrase it was written with
- REFUSALMIGKIT_STATE_KEY is not the passphrase this restore point was written with
- REFUSALs3 state backend needs 'bucket' in hops.yaml
- REFUSALpip install boto3 for the s3 state backend
- REFUSALthe <...> (<...>:<...>) cannot be reached: <...>. Next: install the client of the forwarder it names, or name a way it can be reached from here
- REFUSALno cloud forwarder <...>
- REFUSALthe <...>'s forwarder is not opened: <...>. Next: let calls to the cloud provider's own API out, or reach the side another way
- REFUSAL<...>: a tunnel says
sshorcommand; this one says neither (<...>) - REFUSALthe tunnel to the <...> (<...>:<...>) did not come up: <...>
Help from a model
- REFUSALMIGKIT_AI=<...> is not one of <...>
- REFUSALMIGKIT_AI=<...> needs MIGKIT_AI_MODEL: migkit does not choose a model for this provider
- REFUSALthe model provider <...> is not one of <...>
The web view and the API
- REFUSAL<...> describes no identity provider (no IDPSSODescriptor)
- REFUSAL<...>: the identity provider offers no sign-in by redirect
- REFUSAL<...>: no signing certificate - an answer could not be proved
- REFUSAL<...>: <...>: <...>
- REFUSALMIGKIT_WEB_URL=<...> is not an address people open: https://host[:port], no path
- REFUSALMIGKIT_WEB_TLS_CERT and MIGKIT_WEB_TLS_KEY go together: the certificate and its private key
- REFUSALsigning in through an identity provider needs the view at an https:// address (MIGKIT_WEB_URL) - a code or an assertion would cross the network in the clear otherwise
- REFUSALMIGKIT_WEB_SAML_METADATA=<...> is not a file: the identity provider's metadata, as it publishes it
- REFUSALMIGKIT_WEB_SCIM_TOKEN is shorter than 24 characters - anyone who guesses it provisions people; draw a long random one
- REFUSALMIGKIT_METRICS_TOKEN is shorter than 24 characters; draw a long random one
- REFUSAL<...> is not a file this machine can read
- REFUSALthe view would listen on <...> without TLS: give it a certificate (MIGKIT_WEB_TLS_CERT, MIGKIT_WEB_TLS_KEY), or serve it behind a reverse proxy that does TLS - MIGKIT_WEB_URL=https://... and MIGKIT_WEB_PROXIES naming the proxy's address, the only one then answered; or, in a container published on the host's loopback only, MIGKIT_WEB_PLAIN=on
- REFUSALMIGKIT_WEB_OIDC_ISSUER needs MIGKIT_WEB_OIDC_CLIENT_ID and MIGKIT_WEB_OIDC_CLIENT_SECRET - the client the provider registered for this view
- REFUSALthe identity provider <...> is not an https:// address
PostgreSQL
- REFUSALthe <...>: <...>. The connection was refused before it ran anything.
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSALtwo_way: the replication origin <...> stayed held by another session for 30s - is another tail of this hop applying?
- REFUSALtwo_way: <...> keeps no batch here
- REFUSALthe slot <...> is gone from the source, and the tail had read up to <...> from it. The changes after that were kept by the slot and nowhere else, so starting again from now would skip them without a trace. Move again with --mode full+cdc, which makes the slot before it copies
- REFUSALthe slot <...> was made with the <...> plugin and migkit reads <...>. Reading one plugin's output as another's does not fail, it mis-parses - drop the slot and let migkit make it, or point this hop at another name
- REFUSALwal_level is <...> on this server and a logical slot needs 'logical'. Nothing migkit does client-side can make the WAL carry row images it was not told to carry. alter system set wal_level = 'logical'; -- then restart rds.logical_replication = 1 -- parameter group, then reboot <...>
- REFUSAL<...> transactions committed are still out of sight of any read after <...>s (transaction ids <...>) - a synchronous standby that does not answer holds a commit this way. A table added to the tail is not copied around them; make the standby answer
- REFUSAL<...> transactions committed before the change position are still out of sight of any read after <...>s (transaction ids <...>) - a synchronous standby that does not answer holds a commit this way. A copy read now would miss them and the change tail starts after them, so nothing was copied. Make the standby answer, or take it out of synchronous_standby_names, and move again.
- REFUSAL<...>: no way to follow the source's changes - <...>
- REFUSAL<...>: the source's WAL from <...> was not read (<...>), and whether it is still kept could not be asked (<...>): grant pg_monitor to the account, then follow again
- REFUSAL<...>: the source's WAL files from <...> were not read: <...>
- REFUSAL<...>: <...> has no primary key, and a change its WAL records name by place cannot be written to the target by key - give it one (<...>) | <...>
- REFUSAL<...>: the WAL names relation file <...>, which no table holds now - it was dropped, emptied or rewritten after the change, and its rows cannot be read again by their place. Compare the database again, then follow from there
- REFUSAL<...>: rows were taken out of <...> (block <...>) before <...>, where this follow began holding its keys, and the WAL does not say which: compare the table again, then follow
- REFUSAL<...>: <...> was made after this follow began holding its tables' keys, so a row taken out of it could not be named: move it, then follow
- REFUSALtwo_way: a tail applies into <...> under a replication origin of migkit's (<...>), and <...> applies into it too. Leaving out what migkit applied there would leave out what the other applies, and those changes would never reach the other side. Tear the two-way tail into this side down (move --mode cdc --drop), or the other; its next start chooses another way to mark what it applies
- REFUSALno primary key on <...> - a change to a keyless table cannot be addressed on the target, and applying it by matching every column would hit every duplicate. The change is still in the slot and every call will stop here again, because peeking never throws anything away. Give the table a key or a unique REPLICA IDENTITY, or step past it with: select pg_replication_slot_advance(<...>, pg_current_wal_lsn()); -- skips everything pending, including this
- REFUSAL<...>: the schema fix would make or drop trigger <...> on <...>, which the hop's objects leave out, in a statement that is not one line - nothing is applied; make the target's schema by hand or carry the trigger
- REFUSAL<...>: the key column <...> has no text both sides render, so the repair could not be recorded row by row. Nothing was repaired on this table.
- REFUSAL<...>: newer_wins names <...>, and it is not on both sides, so which row is newer cannot be told. Nothing was repaired on this table.
- REFUSAL<...>: the target holds <...> rows where <...> were copied, or the same number holding different values. The target changes what it is given, or another writer is writing this table
- REFUSAL<...>: copied twice, and the target reads back <...> rows where <...> were copied, or the same number holding different values. The target changes what it is given, or another writer is writing these rows. The copy stopped here; the ranges before it read back equal
- REFUSALMIGKIT_SUBSCRIBE_TIMEOUT=<...> is not a whole number of seconds greater than zero
- REFUSALthe source publishes a table of the hop's that the target does not have (<...>): the change stream carries no DDL, so the table is made on the target first - migkit check names it, migkit sync --kind schema --apply makes it - and this run again
MySQL
- REFUSALpip install 'migkit[mysql]' for mysql support
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...>: the binlog has more columns than information_schema does, which means the table was altered after this event was written - replaying it would put values in the wrong columns
- REFUSALtwo_way: the target stopped logging each statement's text with its rows (binlog_rows_query_log_events), which is how this tail's writes were told apart there. Nothing of the batch was applied; start the tail again and it chooses another way
- REFUSALthe source's binary log carries a statement that changes rows (<...>), and the rows it changed cannot be read from its text: it writes through a routine, a join, a trigger or a cascading key. Set binlog_format = 'ROW' on the source (set global binlog_format = 'ROW'), so the log carries the rows
- REFUSALtwo_way: <...> keeps no batch here
- REFUSALbinlog_row_image is <...> on this server, and the tail reads FULL, MINIMAL or NOBLOB only
- REFUSALno primary key on <...> - a change to a keyless table cannot be addressed on the target, and applying it by matching every column would hit every duplicate. Add a key, or exclude the table
- REFUSAL<...> is <...> on this server, and the tail needs FULL: <...>. set global <...> = 'FULL'; -- self-managed <...>=FULL -- parameter group
- REFUSALthe source no longer has the binlog this tail had read up to (<...>, position <...>): <...>. The changes after it went with it, so starting again from now would skip them without a trace. Move again with --mode full+cdc, and keep the binlog longer than the tail may be stopped for (binlog_expire_logs_seconds, or
binlog retention hourson RDS) - REFUSAL<...>: the binlog's before image did not carry <...>, so migkit cannot say which row it meant
- REFUSAL<...>: the binlog's row image did not carry <...>, so migkit cannot say which row it meant
- REFUSALthe binlog reader's server_id cannot be used: <...>. Two readers under one id end each other; name a free id, or leave server_id out and one is chosen
- REFUSALthe binlog reader was ended twice for another reader attached under its id (server_id <...>, then <...>): another reader of this source chooses ids as this one does - name a free server_id for one of the hops
- REFUSALthe binlog reader was ended for another reader attached under the server_id the hop names (<...>): name a free one, or leave server_id out and one is chosen
- REFUSALthe binlog is off on this server, so there is no change log to read - turn on log_bin, or move without CDC
- REFUSALthe source's account cannot see the other sessions (PROCESS), so which commits are under way when the copy starts cannot be read, and a commit written to the binary log before the copy's position but not yet visible would be in neither the copy nor the tail. Grant it -
grant process on *.* to <the account>;- or use a MariaDB server, whose snapshot says its binary log position. Nothing was copied - REFUSAL<...> commits on the source have not finished after <...>s (threads <...>). A copy read now could miss one the change tail starts after, so nothing was copied - move again once they are through.
- REFUSALthe MySQL client is not installed on this machine: migkit doctor --install
- REFUSAL<...> is not in the form this migkit reads (<...>). Re-run
migkit check --only datato write it again before syncing - REFUSAL<...>: newer_wins names <...>, and it is not on both sides, so which row is newer cannot be told. Nothing was repaired on this table.
- REFUSAL<...>: the key column <...> has no text both sides render, so the repair could not be recorded row by row. Nothing was repaired on this table.
- REFUSAL<...>: copied twice, and the target reads back <...> rows where <...> were copied, or the same number holding different values. The target changes what it is given, or another writer is writing these rows. The copy stopped here; the ranges before it read back equal
MongoDB
- REFUSALpip install 'migkit[mongo]' for mongodb support
- REFUSALa row filter is SQL, and MongoDB takes none; narrow this collection another way
- REFUSAL<...>.<...>: the hop masks columns of this collection (mask_on_write), and a MongoDB copy carries each document as stored, so the masked values would arrive unmasked. Nothing was copied; leave the collection out of this hop, or move it by a way that masks
- REFUSAL<...>: migkit will not write documents without _id - there would be no way to write the same row twice without duplicating it
- REFUSALthe server opened a change stream without saying where it stands, so there is no position to start the tail from before the copy
- REFUSALthis server is a standalone, and a change stream needs a replica set - the oplog a stream reads does not exist otherwise. A single node is enough: mongod --replSet rs0 mongosh --eval 'rs.initiate()'
- REFUSAL<...>.<...>: the source no longer has it, and the hop's ddl stops at a collection dropped there. Nothing was copied or dropped; drop it on the target, or set the hop's ddl to apply it
- REFUSAL<...>: the saved position is no point in the source's oplog. Nothing was applied. Move again with --mode full+cdc
- REFUSAL<...>: <...>. Nothing past it was applied. Move again with --mode full+cdc
- REFUSAL<...>: the source no longer says up to where a majority of its members hold its writes
- REFUSAL<...>: no way to follow the source - <...>
- REFUSAL<...>: the target's TTL indexes could not be saved before holding them for the load, so nothing was loaded
- REFUSAL<...>: <...> TTL indexes were not put back: <...>. Their values are in <...>
SQL Server
- REFUSALmssql cannot apply a <...> action
- REFUSALChange Tracking is off for <...>, and no way to follow it holds (<...>) - <...>. Then each table: alter table ... enable change_tracking
- REFUSALChange Tracking does not follow <...> and <...> more | <...>, so their changes would be carried by nothing - <...>
- REFUSAL<...> captures changes and nothing has been captured yet: the capture job has not run - start the server's Agent
- REFUSALChange Data Capture does not capture <...>, so their changes would be carried by nothing - exec sys.sp_cdc_enable_table for each
- REFUSAL<...>: the triggers the load would switch off on the target could not be recorded first, so none was switched off and nothing was loaded
- REFUSAL<...>: <...> triggers were not switched on again: <...>. What to run is in <...>
- REFUSAL<...>: the source's log can be followed no way here - <...>
- REFUSALthe server migkit owns would not restore the log backup in standby: <...>
- REFUSAL<...>: the log backups are restored onto the server migkit owns, which is not reachable
- REFUSAL<...>.<...>: a delete in the source's log names a row whose key cannot be read from it: run check on the table
- REFUSAL<...>.<...>: a row the source's log changed is no longer where the log put it, and no delete of it follows: run check on the table, then start the tail again
Redis
- REFUSALpip install 'migkit[redis]' for redis support
- REFUSALthe hop asks for <...>, which this engine does not read: its keys are taken or left by name (
include,exclude) and carried as they are. Nothing was read or written; take the rule out of the hop - REFUSAL<...>: the source would not hand over a key: <...>
- REFUSAL<...>: the target refused a key it was handed: <...>. A payload version error means it runs an older Redis than the source, whose values do not load into an older version
- REFUSALRESTORE of <...> was refused by the target: <...>. <...> keys were copied before this one and nothing has been deleted. A payload version error means the target runs an older Redis than the source: its payloads do not load into an older version, so these keys need re-writing value by value, which migkit does not do yet (backlog item 0e)
- REFUSALthe <...> refused <...>: <...><...>. What ran before it stays as it is.
- REFUSALdb<...>: no live way holds - <...>
- REFUSALthe shard from slot <...> can no longer be followed as a replica (<...>); the tail stops with each shard's offset saved, and its next start sweeps the cluster whole
- REFUSALdb<...>: the stream fails again at offset <...> - <...>; the tail stops there, its offset saved
- REFUSALdb<...>: the target refused a key of the snapshot: <...>
- REFUSALthe side's monitor did not open
Kafka
- REFUSALAmazon MSK's IAM sign-in has no provider credentials on this machine. Next: give the machine an identity, or sign in with SCRAM
- REFUSALAmazon MSK's IAM sign-in is not minted: <...>. Next: let calls to the cloud provider's own API out (MIGKIT_EGRESS=provider, or
providerin the hop's egress allow), or sign in with SCRAM - REFUSALsecurity_protocol: <...> is not one of <...>
- REFUSALsasl_mechanism: <...> is not one of <...>
- REFUSALsasl_mechanism: AWS_MSK_IAM signs in over SASL_SSL only
- REFUSALthe <...> cluster refused the sign-in: <...>. Check the endpoint's user and password, and its sasl_mechanism
- REFUSALpip install 'migkit[kafka]' for kafka support
- REFUSAL<...>[<...>]: the target refused the message at offset <...> (<...>); nothing past the last saved position is counted as copied. A message larger than the target's topic takes needs its max.message.bytes raised to the source topic's
- REFUSALformat: <...> needs the target's
schema_registry- the URL of the registry its consumers read schemas from - REFUSAL<...>: the schema registry refused the table's new schema - its compatibility rule says the consumers of the topic could not read it: <...>
- REFUSAL<...>: not written as <...>: <...>
- REFUSAL<...>: schema <...> refers to other schemas in the source's registry, which a copy does not carry over - the message is not copied, nor skipped
- REFUSAL<...>: a message names schema <...>, which the source's registry does not hold: <...>
- REFUSAL<...>: the target's registry refused schema <...> (<...>) - its compatibility rule says the topic's consumers could not read it: <...>
- REFUSAL<...>: its settings could not be read on the source, and a topic made without them (compaction, retention) would mean something else on the target. Nothing was made
- REFUSAL<...> is not a topic on the source
- REFUSAL<...> has fewer partitions on the target than on the source: a key's messages would land in another partition, out of the order its consumers read them
- REFUSALoffsets: <...> is not one of <...>
- REFUSALthe offset map on the target could not be read to its end: no position is placed from part of it
- REFUSALthe offset map holds a record of version <...>, which this migkit does not read: nothing is placed from it
- REFUSALthe offset map disagrees with itself at <...>[<...>] source offset <...>: it is in two committed batches; nothing is placed from it
- REFUSAL<...>[<...>]: the target's end is <...> where the copy has reached source offset <...> (the source ends at <...>): identical offsets cannot be vouched for. Nothing more is copied
- REFUSAL<...>[<...>]: the target's message at <...> is not the source's: the copy stops, and no offset is claimed identical
- REFUSAL<...>[<...>]: the target's log is at <...>-<...>, past the source's first offset <...>, and the copy has not begun: someone else wrote to it. Nothing is copied, and no offset is claimed identical
- REFUSAL<...>[<...>]: after the padding the target's end is <...>, not <...>: someone else wrote to it. The padding stays until it is cut; nothing is copied
- REFUSAL<...>[<...>]: the target's first offset is <...> after DeleteRecords up to <...>: the offsets are not identical, and nothing is copied
- REFUSAL<...>[<...>]: source offset <...> landed at <...> on the target - another writer is on the partition. Identical offsets hold below <...> and are not claimed past it; nothing more is copied
- REFUSAL<...>[<...>]: the saved position was <...> but the offset map on the target knows messages only before <...>: the map is missing what was copied. No offset is placed from it; nothing more is copied
- REFUSALthe target refused offsets for <...>: <...>. Offsets committed before this one stand; nothing was deleted
SQLite
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSALno target database file is configured
- REFUSAL<...>: the directory <...> does not exist, so migkit will not create the target file - make the directory first if this is really where the data should land
- REFUSALsqlite cannot apply a <...> action
Parquet files
- REFUSALa <...> column has no Parquet counterpart migkit writes; leave the column out with mapping.columns
- REFUSALthe <...> has no url or path for its Parquet files
- REFUSAL<...> moves under a row filter, which is SQL, and Parquet files take none
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...> on the target is a Delta or Iceberg table, which migkit reads and does not write
- REFUSAL<...> is not described on the target yet
- REFUSAL<...>: a row filter is SQL, and Parquet files take none
- REFUSAL<...>: a Delta or Iceberg table is read through its log, not copied file by file; exclude it from this hop or move it into a database
ClickHouse
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...>: a row is deleted by its key, and none was given
- REFUSAL<...>: partition <...> <...>
- REFUSAL<...>: <...> and <...> more | <...> - a follow by partitions copies a changed partition again whole, under its own name, with every row and every kind of change in it, so it cannot hold the table to what the hop asks. Nothing was followed: leave these tables out of the hop, or carry them another way
- REFUSALmaterialized views taken off for the load could not be attached again: <...>.
ATTACH TABLEeach, or run the move again
DynamoDB
- REFUSAL<...> moves under a row filter, which is SQL, and DynamoDB takes none
- REFUSAL<...>: a row filter is SQL, and DynamoDB takes none
- REFUSALa <...> column (<...>) has no DynamoDB counterpart migkit writes; leave it out with mapping.columns
- REFUSAL<...> is keyed by <...> columns, and a DynamoDB table is keyed by one, or by one and a sort key: give the table such a key, or leave it out of this hop
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...> has too many columns to describe in a DynamoDB table's tags
- REFUSAL<...> has no stream on, and its stream is the change log migkit reads: turn it on for the table (NEW_IMAGE or NEW_AND_OLD_IMAGES) - migkit does not change the source
- REFUSALthe shards of <...> name each other as parents; the stream cannot be read in order
- REFUSALthe stream no longer holds the records after <...> of <...>: its 24 hours passed, and what was written then is carried by nothing. Move again with --mode full+cdc
Oracle Database
- REFUSALthe change reader cannot see the open transactions (select on v$transaction), and without them it cannot tell where a transaction still open began - so it cannot mine without losing that transaction's first changes: <...>. Grant the account SELECT_CATALOG_ROLE, or select on v_$transaction
- REFUSAL<...>: the redo cannot be read back as the changes it holds - <...>: <...>
- REFUSAL<...>.<...>: a change at SCN <...> does not carry its row's key in the redo: alter table ... add supplemental log data (primary key) columns
- REFUSAL<...>.<...>: a row's key could not be read from the redo at SCN <...>
- REFUSALmine_standby names a database that is not a physical standby (it is <...>): mine on the source instead, by leaving mine_standby out
- REFUSALthe standby mine_standby names is not open read-only (<...>): LogMiner reads the dictionary through an open database, which on a standby is Active Data Guard
- REFUSALthe standby mine_standby names is the standby of another database (DBID <...>, the source's is <...>)
- REFUSAL<...>: the source's redo can be mined nowhere - <...>
- REFUSAL<...>: a change to it came through, and it has no primary key, so the change cannot be placed on the target. Give it a key, or leave it out of the hop
- REFUSAL<...>: no dictionary the source wrote into its archived redo is at or before SCN <...>, where the read stands, so the mining database cannot read its tables there: run once on the source begin dbms_logmnr_d.build(options => dbms_logmnr_d.store_in_redo_logs); end; - then copy the tables again from a point after it
- REFUSAL<...>.<...>: the redo holds a change LogMiner cannot read back as a row (a type or a storage it does not support), at SCN <...>. Nothing after it was handed on; leave the table out of the hop, or move it again after
- REFUSAL<...>.<...>: a large value written at SCN <...> does not name its row by key in the redo: alter table ... add supplemental log data (primary key) columns
- REFUSAL<...>.<...>: a change at SCN <...> could not be read back (<...>). Nothing after it was handed on
- REFUSAL<...>: the target's Data Pump stopped (<...>): <...>
- REFUSAL<...>: the target's Data Pump said it finished, and <...> hold other than the source held at SCN <...> - it said: <...> | <...>
- REFUSAL<...>: no reader of the source's redo keeps up here - <...>
- REFUSALMIGKIT_ORACLE_READER=<...> is not one of <...>, <...>
- REFUSALthe redo-file reader started here did not come up; what it said is in <...>
- REFUSALthe redo-file reader never began streaming
- REFUSALthe redo-file reader at <...> reads another database than <...>
- REFUSALthe redo-file reader would not stream from SCN <...> (answer <...>): the redo it needs may be gone, or the account lacks its grants
Db2 (Linux, UNIX, Windows)
- REFUSALthe <...> needs
database, the Db2 database to connect to; the hop's databases are its schemas - REFUSALthe <...> is <...> (<...>), and this hop names it <...>: name its engine <...>
- REFUSAL<...>: the server's load read <...> rows and loaded <...> (<...> skipped or rejected). The table is not taken as moved: its messages are on the target; move it with the table copier
- REFUSAL<...>.<...>: a row the source's log changed is no longer where the log put it, and no delete of it follows: run check on the table, then start the tail again
- REFUSAL<...>.<...>: a delete in the source's log names a row whose key cannot be read from it: run check on the table
- REFUSALthe source's log could not be read (SQL code <...>)
Db2 for i
- REFUSALa journal entry's <...> is not a number: <...>
- REFUSALthe <...> IBM i is reached through IBM's ODBC driver, which is not installed on this machine (migkit doctor --install puts it in place once IBM's terms are accepted), or through the Mapepire server on the system, which did not answer at <...>:<...> (<...>)
- REFUSAL<...> are not journaled, so their changes are recorded nowhere migkit can read: STRJRNPF FILE(<...>/<...> ...) JRN(<library>/<journal>) IMAGES(*BOTH) for each
- REFUSAL<...> are journaled with after images only, so an update's old key is not recorded: CHGJRNOBJ OBJ((<...>/<...> *FILE)) ATR(*IMAGES) IMAGES(*BOTH) for each
- REFUSAL<...> have no primary key, so a change to one cannot be applied to the row it changed: give each a primary key, or leave them out of the hop
- REFUSALthe journal <...> keeps minimized entries, which hold only the changed bytes of a row: CHGJRN JRN(<...>) MINENTDTA(*NONE)
- REFUSALthe hop's tables are now journaled to <...>, which this tail was not following when it began: start the tail again from a new copy
- REFUSALthe journal <...> holds a minimized entry (<...>) for <...>: CHGJRN JRN(<...>) MINENTDTA(*NONE), then start the tail again from a new copy
- REFUSAL<...>: a key column cannot be read from its journal entries
- REFUSAL<...>: the target names no file for it
- REFUSAL<...>: the source holds <...> rows and the copy left <...>. The table is not taken as moved; move it with the table copier
Db2 for z/OS
- REFUSAL<...>: the subsystem's utility ended with return code <...>; its output is in the subsystem's utility messages
- REFUSAL<...>: the source holds <...> rows and the utility loaded <...>. The table is not taken as moved; move it with the table copier
SAP ASE
- REFUSALFreeTDS's ODBC driver is not on this machine, and SAP ASE is reached through it: brew install freetds, or apt-get install tdsodbc - or say where it is with odbc_driver in the endpoint's options
- REFUSALODBC is not usable on this machine (<...>): brew install unixodbc freetds, or apt-get install unixodbc tdsodbc
- REFUSAL<...>: the server inserted <...> rows of <...>. The table is not taken as moved; move it with the table copier
Teradata
- REFUSAL<...> holds months, which a Teradata <...> has no room for
- REFUSAL<...> holds a fraction of a second, which a Teradata <...> has no room for
- REFUSAL<...> is finer than a Teradata <...> holds
- REFUSAL<...> holds days or time, which a Teradata <...> has no room for
- REFUSAL<...> is not whole years, which a Teradata <...> holds
- REFUSAL<...>: the statements that enable the target's triggers again could not be saved, so none was disabled - and <...> would fire for every row the load writes. Nothing has been loaded.
- REFUSAL<...>: the target's triggers could not be read (<...>), and a trigger that fires for every row the load writes could rewrite them. Nothing has been loaded.
- REFUSALthe <...> is Teradata, which is reached through Teradata's own driver, and it is not installed on this machine: migkit doctor --install puts it in place once its terms are accepted
OpenSearch
- REFUSAL<...>: the target refused <...> documents: <...>: <...>
- REFUSAL<...> moves under a row filter, which is SQL, and OpenSearch takes none
- REFUSAL<...> has no key, and a document's id is its row's key: without one a row written again would be a second document. Give the table a key, or leave it out of this hop
- REFUSAL<...> is a field of type <...>, which is not copied row by row; the move's own path carries <...> whole
- REFUSALa <...> column (<...>) has no mapping migkit writes; leave it out with mapping.columns
- REFUSAL<...> already exists on the target - migkit will not alter or replace an index that is already there
- REFUSAL<...>: a row filter is SQL, and OpenSearch takes none
- REFUSAL<...>: <...> documents deleted on the target in the last minute refuse the source's version of them for a minute more - move again after it
- REFUSAL<...>: the load's record could not be written under <...>, so its replicas and refresh are not taken away - a load that died inside the window could not give them back
- REFUSAL<...> on the source was made again since the saved position (another index id): what the position counted is not in it. Move it again with --mode full+cdc
Cassandra
- REFUSALthe keyspace <...> is not on the target, and how many copies it keeps is not migkit's to choose: create it, or give the target endpoint
replication - REFUSAL<...> moves under a row filter, which is SQL, and Cassandra takes none
- REFUSAL<...>: a row filter is SQL, and Cassandra takes none
- REFUSAL<...> has no key, and a Cassandra table is found by its key: give the table one, or leave it out of this hop
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...>: the target refused <...> rows: <...>
- REFUSAL<...>: <...> indexes or triggers were not made on the target; they are kept in <...> and the next move makes them
- REFUSAL<...>: renamed, or with columns the hop maps, which the copy that keeps each cell's times does not read - move them with --via builtin, the table copier through the pair
- REFUSAL<...> holds counters, which are added to and never written: it is not copied by this path
- REFUSAL<...>: Cassandra keeps its changes in the commit log's change files on each node, which only a program running on every node reads - there is nothing a client can follow. Stop writes on the source and move it, then prove it with migkit check
- REFUSAL<...> keeps its data in tablets, whose change log streams split and merge with them, and migkit follows only a log it has proved it reads whole. Stop writes on the source and move it
- REFUSAL<...>.<...> holds counters, which are only ever added to: a change carried twice would count twice, and no copy writes one. Stop writes on the source, then compare it with migkit check, which holds counters to their values
- REFUSAL<...>.<...> has no change log on, and turning it on is a change to the source's table, which migkit does not make: ALTER TABLE <...>.<...> WITH cdc = {'enabled': true}, then move again with --mode full+cdc
- REFUSAL<...>.<...>: a range of rows was deleted on the source, which a change carried to another engine cannot name by key. Move the table again
- REFUSAL<...>: the target's triggers could not be saved before taking them off for the load, so nothing was loaded
- REFUSAL<...>: <...> triggers were not put back: <...>. Their definitions are in <...>
Amazon Redshift, Snowflake and BigQuery
- REFUSALthe <...> needs
database, the database to connect to; the hop's databases are its schemas - REFUSAL<...>: a counter's change adds to the value where it stands, which only a two-way hop does
- REFUSAL<...>: the provider's zero-ETL integration carries the feed (<...>), so this tail stops here - run
migkit checkon the hop to verify the warehouse's rows - REFUSAL<...>: <...> on the target and in the change are not of one kind, so which version is newer cannot be told; give the column one type on both sides
- REFUSAL<...>: no writer can be held here: <...>
- REFUSAL<...> has no key on the target, and a change is applied by its key
- REFUSALthe <...> needs
account, the Snowflake account identifier - REFUSALthe Snowflake driver is not installed: run migkit doctor --install
- REFUSALthe staged file did not load: <...>
- REFUSAL<...>: <...> of <...> staged rows loaded
- REFUSALthe BigQuery driver is not installed: run migkit doctor --install
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSALa rule must only read; this one is <...>
- REFUSALa <...> column has no Parquet counterpart migkit loads; leave the column out with mapping.columns
- REFUSAL<...>: a new write stream already held rows at its first offset
- REFUSAL<...>: a column of this name is not written through the Storage Write API
- REFUSALthe write stream refused a batch: <...>
- REFUSAL<...>: the batch's changes could not be written to its journal
- REFUSALa <...> column is not written through the Storage Write API
Kinesis Data Streams
- REFUSALno stream <...> on the target, and a stream costs money for as long as it exists: create it, or say create_streams: true in the hop's options
Google Pub/Sub
- REFUSALthe target names no project: say project: in its options
- REFUSALtopic <...> has no subscription, and Pub/Sub keeps a message only for the subscriptions a topic has when it is published - these changes would be dropped. Create the subscription that will read them first
- REFUSALno topic <...> in project <...>: create it, and the subscription that will read it
- REFUSALPub/Sub did not take a change for topic <...>: <...>. Started again, the tail goes on from the position it last saved
DuckDB
- REFUSALthe <...> needs
path, the DuckDB database file
Files described by COBOL copybooks
- REFUSALa row filter is SQL, and files described by a copybook take none
- REFUSAL<...>: recfm <...> is not one of <...>
- REFUSAL<...>: lrecl <...> is shorter than its copybook's <...> bytes
- REFUSAL<...>: its copybook cannot be read - <...>
- REFUSAL<...>: its segment field <...> is not a field at a fixed place in the record
- REFUSAL<...> has no column <...>
- REFUSAL<...>: <...>
- REFUSALthe <...> needs
path, a directory on this machine holding the files and their copybooks - REFUSAL<...> is not described on the <...>: no copybook for it
- REFUSAL<...>: its copybook <...> cannot be read
- REFUSAL<...>: its key names <...>, which is not a field of the record
- REFUSAL<...>: the target's copybook has no field for <...>
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...>: a row cannot be written into its record - <...>
- REFUSAL<...>: a range of a file is not emptied on its own
- REFUSAL<...>: the target describes it differently from the source, so its file cannot be copied as it is
Iceberg tables and Delta tables
- REFUSALa <...> column has no Iceberg counterpart migkit makes
- REFUSAL<...>.<...>: a <...> column has no <...> counterpart migkit makes; leave the column out with mapping.columns
- REFUSAL<...>: a counter's change adds to the value where it stands, which only a two-way hop does
- REFUSALthe <...> needs
catalog, the Iceberg catalog's URI - REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...> has no key on the target, and a change is applied by its key
- REFUSALthe <...> has no url or path for its Delta tables
- REFUSALname the hop's databases: an S3 root is not listed for them
TiDB
- REFUSALthe <...> is not TiDB (<...>): name its engine mysql
- REFUSALTiDB keeps no binlog: its changes are read from the Kafka topic TiCDC publishes them to. Say where in the source's options - changes: {servers: host:9092, topic: <topic>, format: canal-json} - with a changefeed made with enable-tidb-extension=true
- REFUSALformat: unsupported - this stream format carries no watermarks: use canal-json, simple, open-protocol or avro
- REFUSALformat: <...> - TiCDC's changes are read as canal-json, simple, open-protocol or avro
- REFUSAL<...>: <...> <...> no primary key, and a change TiCDC publishes for such a table names its hidden row id, which no other server holds: give each a primary key, or leave it out of the hop and move it with a copy
- REFUSAL<...>.<...>: TiCDC says the row keyed <...> was <...> by <...>, and TiDB as it stood then <...> it: the key as the feed names it is not the key here. Nothing of this batch was applied
- REFUSAL<...>: TiCDC names its changes by <...>, and its primary key is <...>: the changefeed's table is not the table here
CockroachDB
- REFUSAL<...>: no table in scope to follow
- REFUSALthe cluster has rangefeeds off, and a changefeed reads through them: SET CLUSTER SETTING kv.rangefeed.enabled = true (migkit does not change a cluster's settings)
- REFUSALthe changefeed's position is lost; move again with --mode full+cdc
- REFUSALchanges: via <...> - a CockroachDB source is followed by a changefeed streamed to migkit (changefeed) or one publishing to Kafka (kafka)
- REFUSAL<...>: the changefeed keys its rows by <...> values, and its primary key has <...> columns - the feed's table is not the table here
- REFUSAL<...>.<...>: the changefeed says the row keyed <...> was <...> by <...>, and the cluster as it stood then <...> it: the key as the feed names it is not the key here. Nothing of this batch was applied
- REFUSALthe <...> is not CockroachDB (<...>)
CockroachDB and Aurora DSQL
- REFUSAL<...>: <...> <...> no primary key, and <...>: give each a primary key, or leave it out of the hop and move it with a copy
Aurora DSQL
- REFUSAL<...>: say the DSQL cluster's region (region: in the side's options)
- REFUSALDSQL keeps no log a client reads: its changes are read from the Kinesis stream its CDC stream publishes to. Say which in the source's options - changes: {stream: <name or ARN>, region: <region>, cdc_stream: <the CDC stream's id>}
Couchbase
- REFUSALa Couchbase data node answered in a protocol migkit does not read
- REFUSALthe data node refused the sign-in (<...>)
- REFUSALthe data node has no bucket <...> this user may read
- REFUSALthe data node offers no sign-in migkit makes (<...>)
- REFUSALthe data node would not give its <...> statistics (<...>)
- REFUSALthe data node refused the sign-in
- REFUSAL<...> moves under a row filter, which is SQL, and a collection is read by its keys
- REFUSAL<...>: a row filter is SQL, and a collection takes none
- REFUSAL<...> has no key, and a document is kept by its key: a table without one has no collection to go to
- REFUSAL<...> already exists on the target - migkit will not alter or replace a collection that is already there
- REFUSAL<...>: the document <...> is <...> bytes, and Couchbase holds a document of <...> at most; nothing of this write was sent. Leave the row out of the hop, or keep the value elsewhere and the document a reference to it
- REFUSAL<...>: the document <...> was not written (<...>)
- REFUSALCouchbase hands its changes out through its Kafka connector: say which topic it publishes to in the source's options - changes: {servers: host:9092, topic: <topic>} - with the connector's default source handler
Cosmos DB for NoSQL
- REFUSAL<...> is partitioned by <...>, a field inside an object, which no other side has a column for
- REFUSAL<...> moves under a row filter, which is SQL, and a container is read whole
- REFUSAL<...>: a row filter is SQL, and a container takes none
- REFUSAL<...> has no key, and an item is kept by its id: a table without one has no container to go to
- REFUSAL<...> has a column named id outside its key, and a Cosmos DB item's id is made from its key: rename the column with mapping.columns
- REFUSAL<...> already exists on the target - migkit will not alter or replace a container that is already there
- REFUSAL<...>: the item <...> is <...> bytes, and Cosmos DB holds an item of <...> at most; nothing of this write was sent. Leave the row out of the hop, or keep the value elsewhere and the item a reference to it
- REFUSALthe account does not serve the all-versions-and-deletes change feed (<...>), and the latest-version one carries no delete: turn on continuous backup and the all-versions-and-deletes feature, or say change_feed: latest in the source's options - every delete is then found by check instead of followed
Google Cloud Spanner
- REFUSALa Spanner side names its instance: options: {instance: ...}, or spanner://project/instance/database
- REFUSAL<...> has no key, and Spanner keeps every row by its primary key: give the table one, or leave it out of this hop
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...>: no change stream watches every table in scope, and Spanner hands its changes out only through one. Have the DBA make one (
create change stream migkit_<...> for all options (retention_period = '1d')), or name one in the source's options (change_stream: <name>) - REFUSAL<...>: the change stream names its changes by <...>, and its primary key is <...>: the stream's table is not the table here
- REFUSAL<...>.<...>: the change stream says the row keyed <...> was <...> by <...>, and Spanner as it stood then <...> it: the key as the stream names it is not the key here. Nothing of this batch was applied
Google Cloud Bigtable
- REFUSAL<...>: a row filter is SQL, and a Bigtable table takes none
- REFUSAL<...> is read by its row key alone
- REFUSAL<...> has no key, and a Bigtable row is filed under its key: give the table one, or leave it out of this hop
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...>: the target refused <...> rows: <...>
- REFUSAL<...>: a row is not written - <...>. Nothing of it was sent
- REFUSAL<...>: a value written in pieces read back other than it was sent; the row is written again from its delete next run
- REFUSAL<...>: <...> were made by migkit from another engine's rows, and are followed from that engine, not from here
Firestore (native mode) and Firestore in Datastore mode
- REFUSAL<...> has no key, and a document is kept by its name: a table without one has nowhere to go
- REFUSAL<...>: a row filter is SQL, and a collection takes none
- REFUSAL<...>: the target refused <...> documents: <...>
- REFUSAL<...>: the target refused <...> deletes
- REFUSAL<...>: <...> were made by migkit from another engine's rows, and are followed from that engine, not from here
- REFUSAL<...>: a Firestore listener cannot be resumed by another process, and the documents the target holds that the source no longer does can be found only on a Firestore target. Move the group again (full and follow) in one run
- REFUSAL<...>: the listener sent no first snapshot in two minutes
GaussDB (openGauss)
- REFUSALthe <...> is not GaussDB (<...>): name its engine postgres
- REFUSAL<...> was emptied on the source, which its log carries as no row: move the table again
OceanBase (MySQL mode) and OceanBase (Oracle mode)
- REFUSALOceanBase answers no binlog position here (<...>): its binlog is written by its binlog service and served through OBProxy. Reach the tenant through a proxy that names the service (binlog_service_ip), with the binlog service running for the tenant, to follow its changes
- REFUSALthe <...> is not an OceanBase Oracle-mode tenant (<...>)
PolarDB-X and TDSQL (distributed)
- REFUSALthe <...> is not <...> (<...>, <...>): name its engine mysql
- REFUSALPolarDB-X answers no binlog position (<...>): its global binlog is written by its CDC component, which the instance must have running (and the account REPLICATION SLAVE and REPLICATION CLIENT) before its changes can be followed
- REFUSAL<...> has no key to shard by: give it one, or say shardkey: none for it on the target
- REFUSALTDSQL's proxy keeps no binlog: each set keeps its own. Name every set's primary in the source's options - sets: [host:port, ...] - with an account that may read its binlog (REPLICATION SLAVE, REPLICATION CLIENT)
Amazon Keyspaces
- REFUSALthe <...> <...> did not become ACTIVE in ten minutes
- REFUSAL<...>: a row filter is SQL, and Keyspaces takes none
- REFUSAL<...>.<...> has no CDC stream, and turning one on is a change to the source's table, which migkit does not make: alter table ... with cdc = true (a view of new images, or of new and old), then move again with --mode full+cdc
- REFUSALthe shards of <...>'s stream name each other as parents
Amazon Neptune
- REFUSALa stream statement of <...> terms: <...>
- REFUSALa stream statement migkit cannot read: <...>
- REFUSAL<...>: a Neptune side's databases are graph (its property graph) and rdf (its RDF store)
- REFUSALgraph_api: <...> - gremlin or opencypher
- REFUSAL<...>: a row filter is SQL, and a graph takes none
- REFUSAL<...>: a graph holds vertices and edges, an RDF store quads - another engine's table has no place in either
- REFUSALedges go from or to vertices the target does not hold (<...>): copy the vertices first
- REFUSALa property graph is written through Gremlin: give the target graph_api: gremlin
- REFUSAL<...>: the target's load <...> ended <...>: <...> records, <...> that could not be read
- REFUSALNeptune Streams no longer holds the saved position: its retention (neptune_streams_expiry_days) passed, and what changed then is carried by nothing
Amazon Timestream
- REFUSAL<...> has no timestamp column named time, which a Timestream record is kept at
- REFUSAL<...>: <...> holds values Timestream keeps no measure of
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...>: a row without its time
- REFUSAL<...>: a single-measure record holds <...> values
- REFUSAL<...>: the target refused <...> records: <...>
- REFUSAL<...>: Timestream deletes no record
- REFUSAL<...>: Timestream deletes no record, so a part of a table cannot be emptied
- REFUSAL<...>: the batch load <...> ended <...>: <...> (its report: s3://<...>/<...>/report)
Lindorm
- REFUSAL<...> has no key, and a Lindorm wide table keeps every row by its primary key: give the table one, or leave it out of this hop
GeminiDB (Cassandra API), GeminiDB (Redis API) and GeminiDB (MongoDB API)
- REFUSAL<...>: GeminiDB's Cassandra API keeps no change log a client can read, so its changes cannot be followed. Stop writes on the source and move it, then prove it with migkit check
Qdrant
- REFUSAL<...>: a row filter is SQL, and a collection takes none
- REFUSAL<...>: a collection is made from the source's vectors, and the source has no collection of that name
Neo4j
- REFUSAL<...> <...>: the server answered <...> <...>
- REFUSAL<...>: a row filter is SQL, and a graph takes none: name labels or types instead
- REFUSAL<...>: a graph holds nodes and relationships - another engine's table has no place in it
- REFUSAL<...> <...> relationships wait on nodes the target never received, first: <...>
- REFUSAL<...>: its changes cannot be followed - <...>
- REFUSAL<...>: the change log no longer holds <...>: <...>
AnalyticDB for MySQL and AnalyticDB for PostgreSQL
- REFUSAL<...>: no way to follow <...> holds: <...>
Azure Synapse (dedicated SQL pool)
- REFUSAL<...>: no way to follow <...> holds: <...>
YugabyteDB
- REFUSAL<...>: no way to follow <...> holds: <...>
SingleStore
- REFUSAL<...>: no way to follow <...> holds: <...>
Netezza, SAP HANA, Informix, Progress OpenEdge, Vertica, Exasol and Databricks SQL
- REFUSAL<...> already exists on the target - migkit will not alter or replace a table that is already there
- REFUSAL<...> needs its Python driver,
<...>, and it is not installed: pip install <...>. Nothing was read - REFUSALcannot open the <...> <...> address: <...>
- REFUSAL<...>: a repair of rows on <...> is not written yet: the rows that differ are reported, and nothing was changed
- REFUSALcannot read <...> on the source: <...>
- REFUSALthe bulk load failed: <...>
- REFUSAL<...>: the bulk load left <...> rows on the target for <...> on the source; the table is not marked done and the next run reconciles it by key
SAP application data (ODP)
- REFUSALsap_licence: <...> - full-use or runtime
- REFUSAL<...>: nothing was read - <...>
- REFUSALthe <...> service <...> refused its metadata (<...>): the SAP user needs the service (S_SERVICE) and ODP extraction of its data sources
- REFUSAL<...> is not an entity set of the service <...>
- REFUSALan SAP side names its OData services as the hop's databases: sapodp://user@host/SERVICE_SRV
- REFUSAL<...> has no <...>
- REFUSAL<...>: the extractor's delta initialisation ended with no delta token, and its delta links list none - the service does not track changes of it (a simple transformation on the entity set turns tokens off, SAP Note 1574568)
- REFUSALa row filter is SQL, and an SAP service takes none
- REFUSAL<...> track no changes - the service lists no delta links for them - so a follow cannot carry theirs: leave them out of the hop (exclude), or copy them without a follow
- REFUSAL<...>: no delta initialisation of it happened after this follow's point, so there is no position to follow it from - the copy that starts it has not run. Copy it and follow it together (migkit move --mode full+cdc)
SaaS applications, read by a connector program
- REFUSALthe <...>'s program <...> is not on this machine: install it, or name what installs it with
installin the side's options (a pip requirement), which migkit installs into an environment of its own - REFUSAL<...> installed no program called <...>
- REFUSALthe program <...> did not install from <...>: <...>
- REFUSALthe tap wrote its records as <...>, which migkit does not read yet
- REFUSALa dlt source is named module:function, not <...>
- REFUSALa program source's kind is one of <...>, not <...>
- REFUSALthe <...>'s config <...> could not be read (<...>)
- REFUSALthe tap's catalogue is not JSON
- REFUSALthe <...> is a connector run under terms not accepted: <...>
- REFUSALthe connector is an image, and docker is not on this machine: migkit doctor --install says what is short
- REFUSALthe connector gave no catalogue
- REFUSALthe program has no stream <...>
- REFUSAL<...> is not a stream of the <...>'s program
- REFUSALa row filter is SQL, and a program source takes none
- REFUSALSalesforce refused the sign-in (<...>): the config's connected app and its user
- REFUSALname the Salesforce objects to read with
streamsin the side's options - REFUSAL<...>: the follow's position is past the 72 hours Salesforce keeps change events - copy the object and follow it again
- REFUSAL<...>: its copy began more than 72 hours ago, and Salesforce keeps change events no longer - copy it and follow it again
Any pair of two engines
- REFUSAL<...> cannot be 'hetero'
- REFUSALhetero <...>-><...>: <...> is still written for mysql->postgres only.
checkworks on this pair; this does not. - REFUSAL<...>: values on the source would not arrive on <...> as they are, so nothing was copied: <...> ... | <...> Decide what each of these should be - on the source, or in a view the hop reads - or give the target a column that holds them, and move again. Where a change is what is wanted, the hop's
accept_changesnames the columns (table.column) that may arrive as the target keeps them. - REFUSALthis pair cannot repair rows: <...> -> <...> does not implement both halves of the read/write contract, so there is nothing to carry the rows with.
migkit assesslists what the pair can do - REFUSAL<...> is no longer on both sides, so the rows the last check listed cannot be placed
- REFUSAL<...>: copied twice in one pass each (it has no key), and the target holds <...> rows where <...> were copied, or the same number holding different values. The target changes what it is given, or another writer is writing this table
- REFUSAL<...>: copied twice <...> (it has no key), and the target holds <...> rows that do not add up to what was copied. The target changes what it is given, or another writer is writing this table
- REFUSAL<...>: written twice, <...> rows of a batch are not on the target and <...> read back different from the source - the first by key <...>, in <...> | <...>. The target changes what <...> is given, or cannot hold it as it is. The copy stopped here; the batches before it were read back equal
- REFUSAL<...> is not on the target and migkit cannot build it: no neutral class for <...>. Create the table yourself and run this again - guessing a column type is how a migration arrives complete and wrong
- REFUSAL<...> is not on the target and migkit cannot build it: <...> has no column that holds these as they are - <...>. Create the table yourself with the columns you want them in (a value a column changes is then counted and refused, or let through by the hop's
accept_changes), and run this again - REFUSAL<...> moves under a row filter, which is SQL, and <...> takes none. Drop the filter, or exclude the table from this hop
- REFUSALthe row filter on <...> (<...>) has no translation into <...>'s SQL (<...>), so the target cannot be read through it. Write it so both engines accept it
- REFUSAL<...>-><...>: one of these engines has no type mapping in migkit, so there is no honest DDL to write for it
- REFUSAL<...> keeps no restore point migkit can take before a repair; use migkit sync --apply, which repairs without one
- REFUSAL<...>: <...> appear under the same name more than once, so migkit cannot tell which target table each goes to. Rename them in the hop's mapping, or exclude the ones not moving.
- REFUSAL<...> has no change log migkit can read, so there is nothing to tail. Re-run
migkit movefor a fresh full load instead, and verify it withmigkit check - REFUSAL<...> cannot apply changes yet - it has no statement for writing one row by its key
- REFUSAL<...>: mapping.columns leaves out part of its key, so a change cannot be placed on the target by it. Keep the key's columns.
- REFUSAL<...>: another table of the source has its name, and the target has no table of its whole name, so its changes would land in a table of the other's. Nothing of the batch was applied: make the target's table of that whole name, or rename one of them with mapping.tables, and run the tail again
- REFUSAL<...>: the source's schema changed under the tail - <...> ... | <...>. The target does not have <...> yet, so nothing after <...> was applied. Bring the target's schema level with the source's, then run the tail again; it resumes from there.
- REFUSAL<...>: the target committed batch <...> of this tail, and the tail's own state was not set down for it. Nothing more was applied; start the tail again, which holds the two together before it reads
- REFUSAL<...>.<...>: the tail read <...> changes and took back <...> set aside | <...> and accounts for <...> - <...> to apply, <...> left out. Nothing of the batch was applied, and the position stays at <...>: the batch is read again when the tail starts
Any other SQL engine
- REFUSALgeneric engine needs <...>.url in hops.yaml
- REFUSALthe hop names no tables in options.tables and the source's catalogue listed none (<...>): name them in options.tables: [t1, t2]
- REFUSALevery table the hop lists is also in its exclude list, so there is nothing to compare
- REFUSALthis engine needs a comparison component that is not installed on this machine: migkit doctor --install puts it in place, and migkit doctor says what is missing
- REFUSALcannot count the NULLs of <...>: <...>
- REFUSALcannot read the key of <...>: <...>
- REFUSALcannot read <...> on the <...>: <...>
- REFUSALthe columns of <...> could not be read on the source
- REFUSALcannot open the <...> url to write: <...>
- REFUSALcannot read the columns of <...>: <...>
- REFUSALmigkit will not repair by <...>: it is <...>, and a key of that type has no one text form to turn back into a value. Key the hop on a column that is a number, a string or a boolean, or repair those rows with the tool that owns that database
- REFUSAL<...> cannot be repaired by <...>: the column is not on both sides, so a row listed by the check cannot be addressed on the target
- REFUSAL<...>: newer_wins names <...>, and it is not on both sides, so which row is newer cannot be told. Nothing was repaired on this table.
- REFUSAL<...> has columns the writer would not quote: <...>. An update naming them would be read by the server as some other column, so migkit will not send it - the rows it had already inserted are listed in the report and the check will name the rest again
- REFUSAL<...>: this engine's repairs are recorded statement by statement with each row as it was, and cannot be put back by migkit: the record is the undo file named beside it, to apply by hand
- REFUSAL<...>.<...> holds binary, and the writer this engine borrows renders bytes as the characters they happen to spell - measured, b'\x00\x01' goes in as a two-character string. Nothing has been written. Move those rows with the tool that owns the target, or leave <...> out of the hop's column list
- REFUSAL<...>.<...> is <...>, which the borrowed writer will not put in an update. Nothing has been written.
migkit movecan re-copy the table, or repair those rows with the tool that owns the target - REFUSALa numeric column holds <...>, which is not a number that can be written literally. Nothing has been written; repair that row with the tool that owns the target
- REFUSALthe <...>'s driver declares no placeholder style a statement can be written in (<...>); nothing was written
- REFUSALthe <...>'s driver keeps no connection that runs statements
- REFUSAL<...>: the source's catalogue gave no columns; nothing was copied
- REFUSAL<...>: <...> not on the target, so a row copied would lose them. Nothing was copied: add them to the target, or leave the table out of the hop
- REFUSAL<...>: <...>
- REFUSAL<...>: the target already holds <...> rows this copy did not write, and copying on top would leave them or write some twice. Nothing was copied: empty the table on the target, or repair it with sync
- REFUSAL<...>. Nothing is followed: a table is followed by its key and a column of when its rows changed. Name the column with newer_wins, or move with writes stopped and prove it with check
Every engine
- REFUSALunsupported engine <...>
- REFUSAL<...> cannot apply a <...> action
- REFUSAL<...> has no key among the compared columns, so a row cannot be addressed on both sides
- REFUSAL<...> rows of <...> have NULL in the key (<...> ... | <...>) - a row with no key cannot be found on the other side, so repairing it would report success and change nothing. Give those rows a key, or key the hop on a column that is always filled
- REFUSAL<...> cannot be repaired row by row: <...> could not be rendered, and a row written without those columns would be a row the source does not have. Nothing has been written.
migkit movecan re-copy the table, which carries every column whether migkit can compare it or not - REFUSAL<...>: newer_wins names <...>, and it is not on both sides, so which row is newer cannot be told. Nothing was repaired on this table.
- REFUSAL<...>: newer_wins names <...>, and its values cannot be read alike on both sides, so which row is newer cannot be told. Nothing was repaired on this table.
- REFUSALa repair record of form <...> cannot be put back by <...>
- REFUSALmigkit does not <...> on a source
- REFUSALtwo_way: <...> cannot mark what migkit applies
- REFUSALtwo_way.delta: <...> cannot add to a value where it stands
- REFUSAL<...> cannot be followed: <...>; and <...> more | <...>
- REFUSAL<...>: <...>
- REFUSAL<...> has no declared key: it cannot be followed
- REFUSAL<...>: the target holds <...> rows and the source <...>: migkit will not replace a table that is already there
- REFUSAL<...>: the copy job was refused: <...>
Elsewhere in migkit
- REFUSALanchor: a mapping naming the bucket - bucket, prefix, retention, required
- REFUSALanchor: needs
bucket, the object-locked bucket the checkpoints go to - REFUSALanchor: retention is {mode: GOVERNANCE or COMPLIANCE, days: a whole number}
- REFUSALanchor: retention mode <...> is not one of <...>
- REFUSALanchor: retention days is a whole number of at least 1
- REFUSALanchor: <...> is not kept in the hop - the bucket is reached with the credentials the machine already has (environment, profile or role)
- REFUSALarchive: is a mapping - remove, restore, batch
- REFUSALarchive: remove and restore both - one of the two
- REFUSALarchive: batch: <...> is not a number of rows
- REFUSALremoving rows from a <...> source is not a way migkit has: the archive is carried and proved, and the rows stay
- REFUSAL<...>: an archive is carried by its rule (--mode full), run again to take the rows the rule picks since. Nothing has been started
- REFUSAL<...>: nothing was written - <...>
- REFUSAL<...>: the archive is not what it was to hold, nothing was removed - <...>
- REFUSAL<...>: <...> - the archive would not hold every column of a row it proves, and a row removed from the source would lose them. Nothing was written
- REFUSAL<...>: the archive holds <...> of the rows the rule picks otherwise than the source has them (<...>) - an archived row is never overwritten: find which is right, then move again. Nothing was removed
- REFUSAL<...>: <...> rows written to the archive read back otherwise (<...>); nothing was removed
- REFUSAL<...>: <...> rows are still on the source after their removal (<...>); the ledger has the batch
- REFUSAL<...>: the archive holds <...> of the <...> rows to put back
- REFUSALgoal <...>: one of <...>
- REFUSALno step <...>
- REFUSALship: <...> names no container - write it as https://<account host>/<container>/<prefix>
- REFUSALship: model <...> is not one of <...>'s (<...>) - name one, or give its capacity (capacity: 80TB)
- REFUSALship: carrier <...> - one of <...>
- REFUSALship: no carrier the hop names can be written here - <...>
- REFUSAL<...> is not in <...>
- REFUSALcharset: <...> - a character set, or {to, collation, repair}}
- REFUSALcharset: repair: <...> - double-encoded or none
- REFUSALcharset: says neither a character set (to) nor a collation
- REFUSALcharset: <...> is not a character set or collation name
- REFUSAL<...> was not ready within <...>s
- REFUSAL<...> is <...>
- REFUSAL<...>'s zero-ETL integration needs <...> named in the target's options
- REFUSALmigkit asks no API of <...>; it asks <...>
- REFUSAL<...>; let them out (MIGKIT_EGRESS, or the hop's options.egress) to make this call
- REFUSAL<...>'s API is asked here for <...>; <...> is not one of them
- REFUSAL<...> has no restore point ready to copy from: make one first
- REFUSALthe AWS CLI has no profile <...>
- REFUSALno AWS credentials: looked in the environment (AWS_ACCESS_KEY_ID), the CLI's credentials and config files (profile <...>), its single sign-on login, a web identity token, the container's role and the instance's role
- REFUSAL<...>: point-in-time recovery is off on <...> - a table without it has no time to be restored to; turn it on (ALTER TABLE ... WITH custom_properties = {'point_in_time_recovery': {'status': 'enabled'}})
- REFUSALa restore onto a new instance class needs the target's class (spec) named
- REFUSALthe restored instance <...> runs on <...>, not <...>
- REFUSAL<...> has no parameter <...> in its parameter groups
- REFUSAL<...> cannot be changed on <...>
- REFUSAL<...> runs with the provider's default parameter group <...>, which is never changed: give it a group of its own first
- REFUSALthe zero-ETL integration <...> is <...>: <...> | <...> - see its errors in the provider's console, then run again
- REFUSALno Google Cloud credentials: looked at the key file GOOGLE_APPLICATION_CREDENTIALS names, gcloud's application default login and the instance's service account
- REFUSALno Google Cloud project: name it (project) or set gcloud's default project
- REFUSAL<...> failed: <...>
- REFUSAL<...>: <...>
- REFUSAL<...> is <...>: <...> | <...>
- REFUSAL<...> has no primary instance
- REFUSALa Spanner side's id is <instance>/<database>; <...> is not
- REFUSAL<...>: point-in-time recovery is off, so its versions are kept an hour only - turn it on (seven days) for a restore point that outlasts the cutover
- REFUSAL<...> was made, and the provider does not list it
- REFUSALthe copy <...> failed: <...>
- REFUSAL<...> is no flag the provider lets <...> set
- REFUSALAzure's API assumes no role: it acts as the identity signed in - name another with AZURE_CLIENT_ID or the az CLI's login
- REFUSALno Azure credentials: looked in the environment (AZURE_CLIENT_ID with a secret or a certificate), a workload identity, the instance's managed identity, the shared token cache, the az CLI's login, the PowerShell module's login and the developer CLI's login
- REFUSALno Azure subscription: name it (subscription), set AZURE_SUBSCRIPTION_ID or the az CLI's default
- REFUSALthe Azure resource group is not named (resource_group)
- REFUSALthe SQL Database's server is not named (server)
- REFUSAL<...> is not restorable in <...>
- REFUSALthe CLI's profile <...> holds no Tencent Cloud credentials
- REFUSALno Tencent Cloud credentials: looked in the environment (TENCENTCLOUD_SECRET_ID and TENCENTCLOUD_SECRET_KEY), the CLI's profile <...>, the SDK's own credentials file and the instance's role
- REFUSALno Tencent Cloud region: name it (region), set TENCENTCLOUD_REGION or the CLI profile's region
- REFUSALTencent Cloud's API refused <...> for <...>: <...> (<...>)
- REFUSALTencent Cloud's API lists no <...> <...> in <...>
- REFUSAL<...> has no parameter <...>
- REFUSALTencent Cloud's API did not change <...> on <...>
- REFUSALTencent Cloud's API did not change <...> on <...> (code <...>)
- REFUSALthe CLI's profile <...> holds no Alibaba Cloud credentials
- REFUSALno Alibaba Cloud credentials: looked in the environment (ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET), an OIDC token, the CLI's profile, the SDK's own credentials file, the instance's RAM role and a credentials address
- REFUSALno Alibaba Cloud region: name it (region) or set the CLI profile's region
- REFUSALAlibaba Cloud's API refused <...> for <...>: <...> (<...>)
- REFUSALAlibaba Cloud's API lists no <...> <...> in <...>
- REFUSALHuawei Cloud's API is driven from an environment of its own, which is not installed on this machine: migkit doctor --install
- REFUSALHuawei Cloud's API refused <...> for <...>: <...>
- REFUSALthe CLI's profile <...> holds no Huawei Cloud keys
- REFUSALno Huawei Cloud credentials: looked in the environment (HUAWEICLOUD_SDK_AK and HUAWEICLOUD_SDK_SK), the CLI's profile, the SDK's own credentials file and the instance's agency
- REFUSALno Huawei Cloud region: name it (region) or set the CLI profile's region
- REFUSALHuawei Cloud's API lists no <...> <...> in <...>
- REFUSALOracle Cloud's API assumes no role: its policies grant a user or an instance directly
- REFUSALthe CLI's config file holds no usable profile <...>
- REFUSALno Oracle Cloud credentials: looked in the CLI's config file (profile <...>) and the instance's principal
- REFUSALthe Oracle Cloud compartment is not named (compartment)
- REFUSAL<...> is no variable Oracle Cloud's API sets on a DB system
- REFUSALa trusted profile is assumed with an API key, and the CLI's login is a token: set IBMCLOUD_API_KEY
- REFUSALno IBM Cloud credentials: looked in the environment (IBMCLOUD_API_KEY or IC_API_KEY), the CLI's login and the instance's identity
- REFUSALno IBM Cloud region: name it (region) or log the CLI in to one
- REFUSALIBM Cloud's API refused <...> <...> for <...>: <...> (<...>)
- REFUSALthe IBM Cloud resource group is not named (resource_group)
- REFUSAL<...> is no setting IBM Cloud's API changes on <...>
- REFUSALconsolidate: is a mapping - column, value or values, keys, offsets, with
- REFUSALconsolidate: keys: <...> - one of <...>
- REFUSALconsolidate: offsets: <...>: <...> is not a whole number
- REFUSAL<...>: the consolidation does not hold together - <...>
- REFUSALconsolidate: offsets names no offset for <...> (<...>)
- REFUSAL<...> refers to <...> by <...>: only a one-column reference to a shifted key is shifted with it
- REFUSAL<...>: a consolidation's rows are carried here once (--mode full); its changes are followed by its group, every source in one loop (
reshard.follow, --mode cdc or full+cdc). Nothing has been started - REFUSAL<...>: a consolidation is carried whole - its keys are shifted and proved across every table. Leave out --table
- REFUSAL<...>: the consolidation is not what it was to hold - <...>
- REFUSAL<...>: its changes cannot be followed - <...>
- REFUSAL<...>: <...> keys of <...> arrived since the move that another source holds on the target (<...>) - its keys are kept as they are, and these two rows would be one. The follow stops before them, its position kept: consolidate: {keys: tenant, offset or remap}, and the consolidation carried again
- REFUSAL<...>: a key of <...> arrived since the move (<...>, shifted to <...>) past its range (<...> up to <...>) - it would land among another source's keys. The follow stops before it, its position kept: offsets further apart, and the consolidation carried again
- REFUSAL<...>: <...> is not something migkit sends; one of <...>, or none
- REFUSAL<...> names no server
- REFUSALnothing answers at <...> on any engine's own port: write the port, host:port
- REFUSAL<...> is no engine migkit knows
- REFUSAL<...>. Write it as the address's scheme: <...>://<...><...>:<...><...>
- REFUSALname an address, a network (10.0.0.0/24) or an account (--account aws:rds:us-east-1)
- REFUSALthe tail keeps <...>, which the machines' store cannot hold; keep the hop's run state in a bucket or a directory every machine sees
- REFUSALthe machines' store kept changing under migkit while it wrote <...>; too many machines write one record at once
- REFUSAL<...>: another machine kept raising the target's number past this one's; stop the other runs
- REFUSAL<...>: standby needs a target that refuses a write from a machine that lost the hop, and <...>'s does not prove it can - <...>. Nothing was written; run one machine, without standby
- REFUSAL<...>: <...> holds its number on the target through another store (<...>; this machine's is <...>) - every machine of a hop must name the same one. Nothing was written
- REFUSALno stream client can write the target here (<...>): migkit doctor --install puts it in place
- REFUSAL<...>: the target refused <...> for a message and took one sent after it; sending it again would put it out of order. Nothing past the last saved position is counted as copied
- REFUSALthe target refused <...>: <...>
- REFUSALa setting an earlier run changed on the target could not be put back; nothing more is changed there until it is - migkit leftovers says which
- REFUSAL<...> is not a managed service migkit knows; it knows <...> and more (
migkit/data/managed.yaml) - REFUSALthe <...> is named <...> (<...>), and it runs <...> - name the service it is (managed: {service: ...})
- REFUSALthe <...>: <...>
- REFUSALthe <...>: <...>:<...> is no instance the provider's API lists for these credentials - name it under the side's managed option (id)
- REFUSALthe masking key was not replaced: <...> cannot be written (<...>)
- REFUSAL<...>: <...>; the row is not written cut or in part
- REFUSALreshard: is a mapping - with, by, key, shared, ranges, values, lookup, default
- REFUSALreshard: by: <...> - one of <...>
- REFUSALreshard: key is {table: column or [columns]}
- REFUSALreshard: <...>
- REFUSAL<...>: the split does not hold together - <...>
- REFUSAL<...>: the reshard does not hold together - <...>
- REFUSAL<...>: <...> holds other columns of it than <...> - the targets of a reshard hold one schema. Nothing more was written
- REFUSAL<...>: the shard key <...> is not carried, so a row cannot be placed by it. Nothing more was written
- REFUSAL<...>: a row no target takes arrived since the rows were counted (<...>, by its shard key <...>) - name a target for its value, or reshard: {default: <hop>}. The tables written so far are kept, and the next run goes on
- REFUSAL<...>: target_rows: keep leaves <...> as they are, and a reshard places and proves every row of every table - target_rows: replace, or empty them. Nothing was written
- REFUSAL<...>: the reshard is not what its function places - <...>
- REFUSAL<...>.<...>: nothing was written - no way places its rows: <...>
- REFUSAL<...>: a reshard is carried whole - every row is placed and proved across every target. Leave out --table
- REFUSAL<...>: the follow of a group runs one database a process - --db one of <...>
- REFUSAL<...>.<...>: no way places its rows - <...>
- REFUSAL<...>: <...> on every source - a change the group's follow does not make on its targets: it stops before it, every position kept. Make it on every target, then move again (--mode full+cdc)
- REFUSAL<...>: every source changed it, and <...> cannot take the change at its place in the log (<...>) - the follow stops before it, every position kept: make it on every target, then move again (--mode cdc)
- REFUSAL<...>: the group's follow already runs - one follow a group
- REFUSAL<...>: the group's follow did not pause
- REFUSAL<...>: the group's follow did not end
- REFUSAL<...>: a group is cut over one database at a time - --db one of <...>
- REFUSAL<...>: a group has no stream back - its targets hold other rows than each of its sources
- REFUSAL<...>: its group is cut over as one, and <...> say cutover: otherwise than <...> - say it alike on every hop of the group. Nothing was written
- REFUSAL<...> is not a time zone - an offset (+07:00) or a zone name (Asia/Bangkok)
- REFUSALthe row filter <...> is not SQL the source reads: <...>
- REFUSALthe row filter <...> has no translation into the target's SQL: <...>
- REFUSAL<...> never happens in <...> (its clock goes forward over it): write the time with its offset
- REFUSAL<...> happens twice in <...> (its clock goes back over it): write the time with its offset
- REFUSAL<...> is compared with a column holding a point in time, and is not a time
- REFUSAL<...> holds a point in time, and the filter reads it through <...>, which each server reads in its own session's zone: compare the column itself with a time
- REFUSAL<...> holds a point in time, and this engine's SQL has no way migkit writes one exactly: write the times with their offset, or drop tz
- REFUSAL<...> holds a time whose meaning on this engine is not measured, so a time read in <...> has no exact match: write it with its offset, or drop tz
- REFUSAL<...> holds a time whose meaning on this engine is not measured
- REFUSAL<...> is not a column - a document store is asked of its fields only
- REFUSAL<...> is not a value a document store's query can hold - write it out as a literal
- REFUSAL<...>: no document query says it - filter on comparisons, IN, BETWEEN, LIKE and IS NULL
- REFUSAL<...>: IS takes NULL only here
- REFUSALIN over a subquery has no document query
- REFUSAL<...>: the reference does not read it
- REFUSALrules: a mapping of each rule's name to its question
- REFUSALrules.<...>: asks <...> nothing - a rule is one question both sides answer, or a question for each (source: ..., target: ...)
- REFUSALnodes: is a mapping - spaces, conflict, route, marks
- REFUSALnodes: conflict: <...> - one of <...>
- REFUSALnodes: route: by: <...> - one of table, range, hash
- REFUSALnodes: spaces: <...>: <...>: the key space is not read (<...>)
- REFUSAL<...>: no database to keep the machines' records in on the target
- REFUSAL<...>: its machines have nowhere to agree on who writes - <...>. Keep the hop's run state in a bucket (state: {backend: s3}), or name a directory every machine sees (state: {shared: <path>})
- REFUSAL<...>: <...> cannot be trusted to keep one writer at a time - <...>. Nothing was written. Keep the machines' records where writes are conditional (a bucket of a store that honours If-Match and If-None-Match, a shared directory whose locks reach every machine)
- REFUSALthe target keeps records of migkit's, not files
- REFUSAL<...>: nothing here follows a <...> source, so the seed could not be carried on from its position - move it with --mode full
- REFUSALa carrier travels, and what it holds is sealed to the hop's at_rest recipients - this hop names none: add options.at_rest.recipients (an SSH or age public key whose private half the far end holds)
- REFUSALa part's name is <...> characters and <...> takes <...> at most
- REFUSALthe seed is about <...> parts and <...> holds <...> files at most (<...>)
- REFUSAL<...>: <...> tables still have parts to write (<...>); run again
- REFUSAL<...>: the seal is at <...> and the manifest is not
- REFUSAL<...>: the manifest at <...> is not the one the seal names - nothing is loaded from it
- REFUSAL<...>: the manifest carries no signature, and the hop names who must sign it | its seal says it was signed - nothing is loaded from it
- REFUSAL<...>: the manifest is of <...> <...>, not of this hop's <...>
- REFUSAL<...>: the seed is in format <...>, and this migkit reads <...>
- REFUSAL<...>: the manifest's signature does not hold (<...>) - nothing is loaded from it
- REFUSAL<...>: the manifest names <...> and <...> with the same digest - one carrier's part written twice under two names; the seed is refused
- REFUSAL<...>: the seed was exported under another scope than the hop's now, and <...> of its tables cannot be held to this one at the load: <...> ... | <...>. Export it again under this scope
- REFUSAL<...>: after the rows that changed were copied, <...> still differ -
migkit checknames the rows - REFUSALa part of <...> is past the largest file <...> takes (<...>; <...>)
- REFUSAL<...> holds <...> bytes of <...>, where <...> were written
- REFUSAL<...>: the source has columns the parts do not (<...>) - its shape changed since the export; move it again
- REFUSAL<...>: the parts are in the binary copy format, and the target's table does not take it: <...>
- REFUSAL<...>: the parts are the bulk load's lines, and the target's table does not take them: <...>
- REFUSAL<...>: every part is in, and the target holds <...> rows digesting <...>, where the parts add up to <...> rows and <...> - something else writes this table, or the target changes what it is given
- REFUSALsplit: is a mapping - with, shared, rest
- REFUSALsplit: rest: <...> - refuse, or stays
- REFUSALtable_engine: <...> - an engine, or {to, accept, foreign_keys}}
- REFUSALtable_engine: to: <...> is not an engine name
- REFUSALtable_engine: accept: <...> - one of <...>
- REFUSALtable_engine: foreign_keys: <...> - write table.column, or table(a, b)
- REFUSALtable_engine: foreign_keys: <...> names <...> columns and <...> <...>
- REFUSALtelemetry push and receive take the bucket to use
- REFUSALthe bucket holds other bytes under a sealed segment's digest - something else wrote to it; nothing more is sent
- REFUSALtelemetry is off (<...>), so nothing is pushed
- REFUSALthe organisation's policy says telemetry_push: off, so nothing is pushed
- REFUSALMIGKIT_BUNDLE_PLATFORM=<...> names no machine migkit builds bundles for: linux-x86_64, linux-arm64, darwin-arm64, darwin-x86_64, windows-x86_64, a Linux named after them (linux-x86_64-ubuntu-22.04)
- REFUSALthe bundle for Windows is not built: no wheel for win_amd64 of <...>. Nothing of it is signed
- REFUSAL<...> is not an offline bundle migkit made: it has no sums
- REFUSALthe offline bundle is not signed, and MIGKIT_BUNDLE_SIGNERS asks for a signed one. Nothing has been installed from it
- REFUSALthe offline bundle's sums are not signed by anyone MIGKIT_BUNDLE_SIGNERS names. Nothing has been installed from it
- REFUSALthe offline bundle's <...> is not what its sums say. Nothing has been installed from it
- REFUSALthe offline bundle's <...> is not in its sums
- REFUSAL<...>: made on the source while the tail runs, and the hop's ddl says stop. Nothing of it is copied. Start the tail again to follow it, or set ddl to apply (follow it as it is made) or park (leave it aside)
- REFUSAL<...>: deleted on the source, and the hop's ddl says stop. Its target topic is untouched; its saved offsets are kept
- REFUSAL<...>: came back to the tail, and <...>. Nothing of it is copied. Set ddl to park to leave it aside and go on with the other topics
- REFUSAL<...>: <...>. Nothing more of it is copied; set ddl to park to leave it aside
- REFUSAL<...>: <...>, and start the tail again
- REFUSAL<...>: the hops of one topology say different things - <...>
- REFUSAL<...>: the key space of <...> written by <...> differs from what another hop from the same source says
- REFUSAL<...>: <...> of <...> is not a key space (range, stride or values)
- REFUSAL<...>: <...> <...> differs from what another hop of the topology says
- REFUSAL<...>: <...> sends <...> to <...>, another hop to <...>
- REFUSAL
<...>is not a transform: null, constant <text>, hash, truncate <n>, fpe [alphabet] or token [domain] - REFUSALa random value cannot be held to anything after the load, and a second run writes another
- REFUSALa constant must be text without quotes or line breaks
- REFUSAL<...> takes nothing after it
- REFUSALtruncate takes how many characters to keep, a whole number above 0
- REFUSALhash needs the hop's mask_key (a secret reference): a digest without a key is a dictionary away from the value
- REFUSALfpe alphabet
<...>is neither digits, lower, upper, alpha, alnum nor two or more different characters - REFUSALfpe and token need the cryptography library, which is not installed
- REFUSALfpe over <...> refuses a value of <...> characters: only <...> values exist, fewer than the <...> below which the encryption is a dictionary away; the column takes a token or a hash
- REFUSALfpe over <...> refuses a value with a character outside the alphabet (position <...> of <...>): <...>
- REFUSALa token collided on every length; nothing is written
- REFUSALa value made by <...> cannot be reversed: only fpe and token keep the way back
- REFUSALthis token is not in the vault of this user: it was made elsewhere or the vault was removed
- REFUSALthe key does not open this token: it is not the key the token was made under
- REFUSALsql
<...>is not an expression of one value - REFUSALsql
<...>is not an expression: <...> - REFUSALsql
<...>aggregates or windows over rows: a batch would give another value than the table - REFUSALsql
<...>reads every column: name the one it is written on - REFUSALsql
<...>names <...> column(s): it names the column it is written on, and only that one - REFUSALsql
<...>names no column(s) - REFUSALsql
<...>calls <...>: it reads outside the batch | its value is not the same on another run, so nothing could be proved of it - REFUSALsql
<...>names column(s) not in table: <...> - REFUSALthe transform <...> cannot run over these values: <...>. Nothing was written of them
- REFUSALMIGKIT_UI_USER_HEADER names the header a signing-in proxy puts who it let in into, and anything that reaches the view can send that header: set MIGKIT_UI_PROXY_SECRET too - the value the proxy sends in <...> - and the view believes only the proxy