Pickselfweighted() Weighting Not working correctly.

[baonghi1201]

Hi guys,

I have a question regarding the pickselfweighted() function, based on this example here:

pickselfweighted("http://example.com/weight", { "192.0.2.20", "203.0.113.4", "203.0.113.2" })

If I understand it correctly, with the provided IPs list, the function will automatically validate its availability, and THEN followed by the "/weight" that associates with the IPs accordingly, meaning if both "203.0.113.4", "203.0.113.2" are available as we speak AND the weighted IP like:
{
"192.0.2.20" : 10,
"203.0.113.4" : 30,
"203.0.113.2" : 70
}

Then the result should be --> 203.0.113.2 , right ?

But I keep getting 203.0.113.4, even though the weights have already been set, and logs shows no errors.

Questions:

1/ What am I missing?
2/ I already know "http://example.com/weight" has to be the endpoint checking, but the format of the "/weight" still unknown to me?

[omoerbeek]

A weighted hash of bestwho is used. It's not that the IP with the highest weight will always win.
As I understand it, with your example, for N calls with different bestwhos`, the proportion will be 30% 203.0.113.4 and 70% 203.0.113.2.

[baonghi1201]

Have you succeeded in testing out the pickselfweighted()? I running out of ideas already, log shows no errors at all.

[omoerbeek]

Have you succeeded in testing out the pickselfweighted()? I running out of ideas already, log shows no errors at all.

No, I read the docs and looked at the code. It is likely your logs show no errors because there are no errors. As far as I can see your expectations are wrong and I tried to explain that.

[omoerbeek]

Maybe my previous answer was a bit short.

The URL is supposed to return an answer with a number in the content.

It is not the case that the highest weight always wins.

From the client IP a hash is computed, and that hash is used to index (using the weights) into the list of available IPs. The hash is done to make sure that the same client IP maps to the same result IP. If you use different client IPs, the distribution of answers will be according to the weights: a high weight wil be chosen more often than a low weight.

[omoerbeek]

I set up a test with two http servers on the IPs below, one returning 30 and one returning 70 for /weight:
My LUA record is:

w.m6k.nl        10      IN      LUA     A "pickselfweighted('http://www.drijf.net/weight', { '46.23.93.236', '45.138.53.116' })"

I then run (I sleep to to give caches chance to expire. 1.1.1.1 has many PoPs, queries are coming from quite some IPs to my m6k.nl authoritative servers.

$ for i in $(seq 100); do dig +short @1.1.1.1 w.m6k.nl >> log; sleep 1; done
$ sort  log | uniq -c
     37 45.138.53.116
     63 46.23.93.236
$

So this all works as expected.

[baonghi1201]

I truly appreciate for taking your time explaining this to me, I might be a little bit dumb to fully understand.

Here is my test on the pickselfweighted():

selfweight.work.test IN LUA A "pickselfweighted('http://10.101.30.11/weight', { '10.101.20.11', '10.101.20.12'})"

The part where the URL will define the weight for the IPs, here my test script using Python Flask for HTTP weighting, the idea was to use 10.101.30.11 as a centralized to weight the IPs, with HTTP running on each of the IPs - 10.101.20.11 and 10.101.20.12

from flask import Flask, Response
import subprocess

app = Flask(__name__)

backends = {
    "10.101.20.11": 20,    
    "10.101.20.12": 60   # primary, most positive
}


def isUp(ip):
  
    try:
        # "-c 1" = send 1 packet, "-W 2" = 2 second timeout
        result = subprocess.run(
            ["ping", "-c", "1", "-W", "2", ip],
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL
        )
        return result.returncode == 0
    except Exception:
        return False

@app.route("/weight")
def weight():
    weights = []
    # Iterate over dictionary keys in the same order as defined above
    for ip in backends:
        if isUp(ip):
            weights.append(str(backends[ip]))
        else:
            weights.append("0")  # down → weight 0
    return Response(" ".join(weights), mimetype="text/plain")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80)

This is the script for HTTP - 10.101.20.11 and 10.101.20.12:

from flask import Flask, jsonify
app = Flask(__name__)

@app.get("/weight")
def readyz():
    return jsonify(ready=True), 200
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80)

Result:

selfweight.work.test. 60 IN A 10.101.20.11

Is this the correct way of creating the WEIGHT for the IPs?

[omoerbeek]

You are making things complicated.

The code in the PowerDNS server will call the URL for all listed IPs and use the value returned to determined the weight. If a call to the URL fails for an IP, the IP is disregarded as a candidate.

My test setup just returns fixed numbers by serving a static file for http://www.drijf.net/weight on both IPs. One with the content 30 and with the content 70.

[baonghi1201]

Ohhhhh I understand it now, since the pickselfweighted() already have the http endpoint calling for "/weight", all we need to do is create a small Python3 Flask to serve the HTTP on IPs. I tested it out your way and it did resolve just like you said, so it is the probability that we're talking, unlike pickwrandom(), which we can statically define in the LUA record. Thank you so much for explaining this to me!