dataSync | 数据库同步工具支持oracle，sqlserver , mysql等异构数据库的表同步

I've taken your simplified configured with just 2 nodes using a non-wildcard queue with redistribution-delay of 0, and I reproduced the behavior you're seeing on my local machine (i.e. without Kubernetes). I believe I see why the behavior is such, but in order to understand the current behavior you first must understand how redistribution works in the first place.

In a cluster every time a consumer is created the node on which the consumer is created notifies every other node in the cluster about the consumer. If other nodes in the cluster have messages in their corresponding queue but don't have any consumers then those other nodes redistribute their messages to the node with the consumer (assuming the message-load-balancing is ON_DEMAND and the redistribution-delay is >= 0).

In your case however, the node with the messages is actually down when the consumer is created on the other node so it never actually receives the notification about the consumer. Therefore, once that node restarts it doesn't know about the other consumer and does not redistribute its messages.

I see you've opened ARTEMIS-3321 to enhance the broker to deal with this situation. However, that will take time to develop and release (assuming the change is approved). My recommendation to you in the mean-time would be to configure your client reconnection which is discussed in the documentation, e.g.:

First, it's important to note that there's no feature to make a client reconnect to the broker from which it disconnected after the client crashes/restarts. Generally speaking the client shouldn't really care about what broker it connects to; that's one of the main goals of horizontal scalability.

It's also worth noting that if the number of messages on the brokers and the number of connected clients is low enough that this condition arises frequently that almost certainly means you have too many brokers in your cluster.

That said, I believe the reason that your client isn't getting the messages it expects is because you're using the default redistribution-delay (i.e. -1) which means messages will not be redistributed to other nodes in the cluster. If you want to enable redistribution (which is seems like you do) then you should set it to >= 0, e.g.:

The solution was given by Teo in this more specific question:

Problem with LiveData observer changing rather than staying the same

Here is his solution:

// STEP 1 - make a function to notify the variable

This kind of behavior is expected when sending non-durable messages because non-durable messages are sent in a non-blocking manner. It's not clear whether or not you're sending non-durable messages, but you've also set blockOnDurableSend=false on your client's URL so even durable messages will be sent non-blocking.

From the broker's perspective the messages haven't actually arrived so there's no way to see the number of messages that have been sent but are not yet in the queue.

If you want to ensure that when the Camel route terminates all messages are written to the queue then you should send durable messages and set blockOnDurableSend=true (which is the default value).

Keep in mind that blocking will reduce performance (potentially substantially) based on the speed of you hard disk. This is because the client will have to wait for a response from the broker for every message it sends, and for every message the broker receives it will have to persist that message to disk and wait for the hard disk to sync before it sends a response back to the client. Therefore, if your hard disk can't sync quickly the client will have to wait a long time relatively speaking.

One of the configuration parameters that influences this behavior is journal-buffer-timeout. This value is calculated automatically and set when the broker instance is first created. You'll see evidence of this logged, e.g.:

As said by default only the Host/Server has the Network Authority over spawned objects.

Unless you spawn them with a certain client having the authority over the object (using Networking.NetworkServer.SpawnWithClientAuthority) but this also makes no sense if multiple clients shall be able to interact with the object as in your case.

And [SyncVar]

variables will have their values sychronized from the server to clients

.. and only in this direction!

Now there is the option to gain the authority over an object via Networking.NetworkIdentity.AssignClientAuthority so yes, you could send a [Command] to the Host/Server and tell it to assign the authority to you so you can call a [Command] on that object.

However, this has some huge flaws:

• As this might change very often and quick you always have to make sure first that you currently have the authority and also the Host/Server has to make sure authority is assignable to you
• You don't know when exactly the Host/Server is done assigning the authority so you would have to send a ClientRpc back to the client so he knows that now he can send a Command back to the host ... you see where this is going: Why not simply tell the Host/Server already with the very first [Command] what shall happen ;)

Instead you have to (should/ I would ^^) put your logic into your player script (or at least a script attached to the player object you have authority over) and rather do something like

When you download the tensor using dataSync() it just keeps the value. If you wanted the object with a description of each of the results without the tensors you would just have to console.log(result). Then you expand the result from your log in the browsers console it should return something like this:

Using SGD in regression could be tricky as outputs don't have an upper bound and that can lead NaN values in loss, in other words exploding gradients etc.

Changing optimizer to Adam or RMSProp works most of the times.

Even though I am not too much acquainted with pytorch documentation, a quick look at it shows that the first parameter for Normalize is for the mean of the dataset and the second parameter is for the standard deviation.

To normalize using these two parameters with tensorflow.js, the following can be used

It's really up to the subscriber to delete its subscription when it is done with it. In other words, the MQTT client should unsubscribe the existing subscriber before creating a new one. The broker has no way to know whether or not the subscriber plans to reconnect later to fetch the messages from its subscription.

If you really want the broker to delete the subscription queue you can use the following address-settings:

• : This must be true.
• : This is the delay (in milliseconds) from the time the last consumer disconnects until the broker deletes the subscription queue.
• : This must be -1 in order to ignore any messages in the subscription queue.

To be clear, I would recommend against this configuration as the broker may inadvertently delete legitimate messages. For example, if a subscriber mistakenly disconnects (e.g. due to a network failure, hardware failure, JVM crash, etc.) for longer than the configured then the broker will delete its subscription queue and all the subscriber's messages will effectively be lost.