| Age | Commit message (Collapse) | Author |
|---|
|
* dgud/mnesia/sticky-bug/ERL-768/OTP-15979:
mnesia: Bump protocol version
mnesia: Introduce sync_asym_trans protocol
|
|
Remove unsupported conversions from the old protocols.
This means mnesia on OTP-R18 nodes is no longer able to connect to
OTP-22 mnesia nodes.
Add protocol conversion for old nodes and sync_asym_trans transactions.
|
|
If add_table_copy was called when a node was starting it deadlock
waiting for mnesia_controller, when schema was not merged.
Abort if that is the case.
|
|
|
|
Take care of the call of erlang:get_stacktrace() in
module mnesia_lib.
|
|
The remaining call (in module mnesia_lib) is taken care
of in the following commit.
|
|
* maint-19:
Updated OTP version
Prepare release
mnesia: Read schema user properties directly
ssh: testcases for space trailing Hello msg
ssh: Don't remove trailing WS in Hello msg
|
|
Doing a proper transaction handling of user properties (in current
implmenentation) caused schema_transactions to be quadratic which
caused huge startup times for nodes with many tables since the merge schema
is a schema_transaction.
Do a direct read instead, cheap but implies that the plugin changes
will not be visible until the changes are commited and cannot be used
later in same transaction, which was possible before if undocumented
functions where used.
|
|
|
|
|
|
Which may hang if an application start does wait for tables
during initilization.
|
|
|
|
Make ram_copies index always use ordered_set
And use index type as prefered type not a implementation requirement,
the standard implmentation will currently ignore the prefered type.
|
|
|
|
|
|
Add ext to table/system information
Add add_backend_type
|
|
new protocol version to handle new schema fields
|
|
|
|
move_table_copy needs the lock that was set previously in del_table_copy.
This doesn't work on old nodes, so bump protocol version and check it.
Remove old protocol conversion code, which have been around since OTP-R15.
Checking if lock is needed requires rpc communication via mnesia_gvar
ets table to be backwards compatible.
|
|
del_table_copy grabs a write lock in a new process in prepare_op/3 to
change 'where_to_read' when a table copy is updated.
When del_table_copy(schema, Node) is called all copies located on Node
are deleted, and thus many locks are taken. Since this was done outside
of the schema-transaction, mnesia's deadlock prevention algorithms
was sidestepped and a deadlock could occur.
Fix by always grabbing write-locks for all changed tabs early and in the same
transaction, this might slow done the operation some but it must be done
and it also cleans up the code.
|
|
|
|
* dgud/mnesia/try-catch:
mnesia: Replace catch with try-catch
|
|
Avoids building stacktraces where it is not needed and do
not mask errors, i.e. only catch the relevant classes in each try.
|
|
|
|
create_table
|
|
|
|
Allow schema operation even if not all nodes are upgraded to
latest version.
|
|
|
|
|
|
|
|
The do_merge_schema function now converts cstructs from a remote node
when it detects that they are different. In order to be compatible the
other way around, mnesia_controller:get_cstructs() detects a remote caller,
and converts the cstructs before sending them.
|
|
* uw/mnesia-majority:
dialyzer warning on mnesia_tm
Add documentation text about majority checking
add mnesia_majority_test suite
where_to_wlock optimization + change_table_majority/2
bug in mnesia_tm:needs_majority/2
optimize sticky_lock maj. check
check majority for sticky locks
Write locks now check majority when needed.
Add {majority, boolean()} per-table option.
OTP-9304
|
|
|
|
Since the table loader also sets (table) write locks, a special
lock type, 'load', was needed. Unfortunately, this affects mnesia
activity callbacks that redefine the lock operation.
|
|
With {majority, true} set for a table, write transactions will
abort if they cannot commit to a majority of the nodes that
have a copy of the table. Currently, the implementation hooks
into the prepare_commit, and forces an asymmetric transaction
if the commit set affects any table with the majority flag set.
In the commit itself, the transaction will abort if it cannot
satisfy the majority requirement for all tables involved in the
thransaction.
A future optimization might be to abort already when a write
lock is attempted on such a table (/-object) and the lock cannot
be set on enough nodes.
This functionality introduces the possibility to automatically
"fence off" a table in the presence of failures.
This is a first implementation. Only basic tests have been
performed.
|
|
Fixes timing issue in test cases
|
|
|
|
* uw/mnesia-schema-merge:
remove debug printout and accidental variable name reuse
Allow a user_defined function to wrap mnesia_schema:merge_schema()
|
|
|
|
Mnesia currently notifies the user if it detects a partitioned
network, but the options for resolving the situation are limited.
In practice, the only safe options are:
- set master_nodes and restart one of the affected 'islands'
- restart the entire system from backup
This patch introduces a way to resolve the situation without
restarting any nodes. The key to doing this safely is to
lock affected tables and run the merge function inside the same
transaction that merges the schema. Otherwise, one transaction
will merge the schema, after which writes to the database will
be replicated across the (potentially) inconsistent copies;
the transaction triggered by the asynchronous inconsistency event
will have to race to be the first to access the tables.
The normal call to merge the schema is done from mnesia_controller.
Previously, this was mnesia_schema:merge_schema().
The new function is merge_schema(UserFun), with the
following behaviour:
merge_schema(UserFun) ->
schema_transaction(
fun() ->
UserFun(fun(Arg) -> do_merge_schema(Arg) end)
end).
Where do_merge_schema(LockTabs) will execute the schema merge
as before, but also lock all tables in the list LockTabs which
have copies on the affected nodes (that is, everywhere the schema
table is locked).
The effect of this is to allow a wrapper function that calls the
merge and, if successful, continues to resolve the inconsistency
on the tables, knowing that they have now been locked on all
affected nodes.
The function that is actually called by the deconflict function
is mnesia_controller:connect_nodes(Nodes, UserFun), as in:
Tables = tables_to_deconflict(Node),
mnesia_controller:connect_nodes(
[Node], fun(MergeF) ->
case MergeF(Tables) of
{merged,_,_} ->
deconflict(Tables, Node);
Other ->
Other
end).
In the case where the merge fails, it is probably wise to
restart from a backup...
I have not run the mnesia test suite, as it is not available.
I have not updated documentation, as these functions are not
documented in the first place.
|
|
|
