DataLink | DataLink是一个满足各种异构数据源之间的实时增量同步、离线全量同步，分布式、可扩展的数据交换平台。 | Change Data Capture library

Using merge with a second query the variable from the secong query can be used in the datalinks.

So my second query:

(label_replace (kube_pod_labels{namespace="awl-${umgebung}", label_group="awl", label_product="${product}", label_type="as"}, "product_link", "https://some_website/${umgebung}/$1", "label_context_root", "^(.*)$"))

Format : Table

Datalink

${__data.fields[product_link]}

In the transform tab, a simple merge is used.

This might have to do with you not using Generics with your java Collections

You can check if the element which is been clicked is i tag or button and depending on this change your selector to get required data.

Demo Code :

You can use $(event.target) to access element which has called click event and then use same to get attribute value.

Demo Code :

pnet is trying to open a raw socket which requires root permissions or the CAP_NET_RAW capability. That causes the Operation not permitted error. Running as root resolves the issue.

I'm afraid it does not depend on the programming language but on the operating system. As far as I know, packet-sockets can capture/emit frames but do not intercept them; this is the purpose of the firewall. A very long time ago, I used to experiment this; here is what I know about it.

It takes place in the firewall; you have to modprobe ip_queue then add a rule to send packets to that queue iptables -A OUTPUT -o eth1 -j QUEUE (adapt input/output/interface as needed).

Then you have to build and run in userspace a program which interacts with that queue and gives a verdict (ACCEPT/DROP) for every packet. This is done in C with and -lipq; I don't know if you can easily do the equivalent in Rust.

By the way, maybe the best solution is not to rely on a userspace process giving the verdict but just on usual firewall rules (if the criterion for the verdict is not too complicated). There exist many modules and iptables options which enable many complex rules.

( https://linux.die.net/man/3/libipq )

If data-layer transmits at 1500 byte frames, I want to know how is upper layer at the receiver able to handle such huge incoming data-frames.

1500 octets is a reasonable MTU (Maximum Transmission Unit), which is the size of the data-link protocol payload. Remember that not all frames are that size, it is just the maximum size of the frame payload. There are many, many things with much smaller payloads. For example, VoIP has very small payloads, often smaller than the overhead of the various protocols.

Frames and packets get lost or dropped all the time, often on purpose (see RED, Random Early Detection). The larger the data unit, the more data that is lost when a frame or packet is lost, and with reliable protocols, such as TCP, the more data must be resent.

Also, having a reasonable limit on frame or packet size keeps one host from monopolizing the network. Hosts must take turns.

For ex: If internet speed in 100 Mbps, upper layers will have to process 104857600 bytes/second or 104857600/1500 = 69905 frames/second. Network layer also need to re-assemble these frames. How network layer is able to handle at such scale.

Your statement has several problems.

First, 100 Mbps is 12,500,000 bytes per second. To calculate the number of frames per second, you must take into account the data-link overhead. For ethernet, you have 7 octet Preabmle, a 1 octet SoF, a 14 octet frame header, the payload (46 to 1500 octets), a four octet CRC, then a 12 octet Inter-Packet Gap. The ethernet overhead is 38 octets, not counting the payload. To now how many frames per second, you would need to know the payload size of each frame, but you seem to wrongly assume every frame payload is the maximum 1500 octets, and that is not true. You get just over 8,000 frames per second for the maximum frame size.

Next, the network layer does not reassemble frame payloads. The payload of the frame is one network-layer packet. The payload of the network packet is the transport-layer data unit (TCP segment, UDP datagram, etc.). The payload of the transport protocol is application data (remember that the OSI model is just a model, and OSes do not implement separate session and presentation layers; only the application layer). The payload of the transport protocol is presented to the application process, and it may be application data or an application-layer protocol, e.g. HTTP.

The bandwidth, 100 Mbps in your example, is how fast a host can serialize the bits onto the wire. That is a function of the NIC hardware and the physical/data-link protocol it uses.

which would mean lots and lots and lots of fragmentation and re-assembly at the receiver.

Packet fragmentation is basically obsolete. It is still part of IPv4, but fragmentation in the path has been eliminated in IPv6, and smart businesses, do not allow IPv4 packet fragments due to fragmentation attacks. IPv4 packets may be fragmented if the DF bit is not set in the packet header, and the MTU in the path shrinks smaller than the original MTU. For example, a tunnel will have a smaller MTU because of the tunnel overhead. If the DF bit is set, then a packet too large for the MTU on the next link, the packet is dropped. Packet fragmentation is very resource intensive on a router, and there is a set of steps that must be performed to fragment a packet.

You may be confusing IPv4 packet fragmentation and reassembly with TCP segmentation, which is something completely different.

preg_match_all works best for these type of problems

While designing InfluxDB measurement schema we need to be very careful on selecting the tags and fields.

Each tag value will create separate series and as the number of tag values increase the memory requirement of InfluxDB server will increase exponentially.

From the description of the measurement given in the question, I can see that you are keeping high cardinality values like temperature, pressure etc as tag values. These values should be kept as field instead.

By keeping these values as tags, influxdb will index those values for faster search. For each tag value a separate series will be created. As the number of tag values increase, the number of series also will increase leading to Out of Memory errors.

Quoting from InfluxDB documentation.

Tags containing highly variable information like UUIDs, hashes, and random strings lead to a large number of series in the database, also known as high series cardinality. High series cardinality is a primary driver of high memory usage for many database workloads.

Please refer the influxDB documentation for designing schema for more details.

https://docs.influxdata.com/influxdb/v1.8/concepts/schema_and_data_layout/