slave | IRC based customizable botnet framework | Bot library

You didn't describe omitting pg_replslot during your rsync, as the docs recommend. If you didn't omit it, then now your replica has a replication slot which is a clone of the one on the master. But if nothing ever connects to that slot on the replica and advances the cutoff, then the WAL never gets released to recycling. To fix you just need to shutdown the replica, remove that directory, restart it, (and wait for the next restart point to finish).

Do they need to go to wal_archive folder on the disk just like they go to wal_archive folder on the master node?

No, that is optional not necessary. It is set by archive_mode = always if you want it to happen.

Does the library auto-assign the slave number, or we have to define it?

With MinimalModbus you pass the slave ID through in the minimalmodbus.Instrument('/dev/ttyUSB0', 1) call (the 1 is the Slave ID). How you set the slave ID on the device itself varies (this is not covered by the Modbus over serial line spec; could be a configuration program, DIP switches, based on the serial number etc. Other libraries may take different approaches (for example defaulting to Slave ID 1).

From the datasheet, is it the register number is the address?

The header in the spec tables says "No(Address)" so "10001(0000)" means register 1, address 0 (these refer to the same thing; I recommend reading the "Modbus: When 40001 Really Means 1, or 0 Really Means 1" section in this article which explains some of the issues around addressing).

And how many decimals do I expect if there's two data sequence as a response?

Not quite sure what you mean by "two data sequence". The Modbus spec only details the sending of bits (coils) and 16 bit values (input/holding registers). From a quick look at your spec it looks like this device just uses a single registers; for instance "OUT1 Output time" has "unit: ×10㎳" so take whatever is in the register and divide by 10 to get ms.

Is the CRC16 check already included within the library as i shouldn't code it?

Any decent Modbus library will look after the protocol details (such as CRC) for you (so no you don't need to code this; MinimalModbus will calculate it for you)

Unless you expose port 9870, your personal laptop on another network will not be able to access the web interface.

You can check to see if it is exposed by trying :9870 to see if it is exposed. IP-address here has to be the global IP-address, not the local (10.* ) address.

To get the NameNode's IP address, ssh into the NameNode server, and type ifconfig (sudo apt install ifconfig if not already installed - I'm assuming Ubuntu/Linux here). ifconfig should give you a global IP address (not the 255.* - that is a mask).

static before a function declaration doesn't say that the return value is static. It says that the function is static to the compilation unit (it cannot be accessed by other .c files). You can just delete the static and stay with char *read_temperature(). Returning something that is static is no different from returning something that is global.

This probably is not your error (it can be that you wanted your function to be static, i just assumed you didn't). i think some code before the function declaration is the culprit.

The expected specifier-qualifier-list before usually says that you are using a type that you didn't define yet, which is strange in this case. it basically says that you are using a new type static inside a struct. we need more code before and after the function to know for sure

The device manual isn't clear about the register start address, but the first register it mentions has the address of 1.

Similarly, the mbpoll command-line utility (not the one with GUI) isn't very clear about the start address. But its documentation mentions that the default value for -r parameter is 1.

I think it's safe to assume that both use the same addressing which starts from 1, as the command-line tool has no problems accessing the value.

But MinimalModbus API clearly mentions that its register start address is 0. So when using this library, you need to use registeraddress = 45 for accessing the temperature, not 46 or 40046.

But why won't 46 work? Normally, one would expect it to grab data starting from the next register and print some garbage, but not timeout. But we can't know how the device works internally. Maybe a request to access the temperature register actually triggers some measurement function and then returns a value. A request to access an unaligned data (with a wrong register value) can be simply rejected by the firmware.

If you still get timeouts with registeraddress = 45, your Python runtime may have some problems accessing the serial port. As I stated in my comment, I recommend using a logic analyzer to see what's going on on the wire. Without such a tool, you're doing blind-debugging.

This question requires more than a short Stackoverflow answer. Here are a few initial thoughts.

When a controller goes offline, the instance itself continues running, but if the failed controller hosts a router, the instance might be cut off from the network. Generally, if the controller has anything that the instance needs, that thing won't be available anymore. There are measures like HA routers that can help in such a case.

When the instance's compute host goes down, the instance doesn't run anymore. You can evacuate instances from a failed compute host, which means that they are rebuilt on different hosts. If an instance's root disk resides on a volume or an ephemeral disk that is shared with other compute hosts, this means a mere instance reboot. If the instance has an ephemeral disk inside the failed host, it must be rebuilt from scratch.

OpenStack has a project named Masakari whose goal is to make instances resilient by redundancy. In short, instance HA. The application keeps running even if an instance crashes.

By the way, master and slave are not correct terminology in this context. Use controller and compute instead.

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.:

Yes, this is possible.

WebAssembly stores objects within linear memory, a contiguous array of bytes that the module can read and write to. The host environment (typically JavaScript within the web browser) can also read and write to linear memory, allowing it to access the objects that the WebAssembly modules stores there.

There are two challenges here:

1. How do you find where your WebAssembly module has stored an object?
2. How is the object encoded?

You need to ensure that you can read and write these objects from both the WebAssembly module and the JavaScript host.

I'd pick a known memory location, and a known serialisation format and use that to read/write from both sides.

Correct, settings connection_cache to false will disables connection pooling and on each connection to pgpool-II from client pgpool-II create will create a new connection to backend database)