all

loadbalancer-init.py

@@ -0,0 +1,130 @@
+from hcloud import Client
+from hcloud.images.domain import Image
+from hcloud.server_types.domain import ServerType
+from hcloud.networks.domain import NetworkSubnet
+from hcloud.locations.domain import Location
+from hcloud.load_balancer_types.domain import LoadBalancerType
+from hcloud.load_balancers.domain import LoadBalancerTarget, LoadBalancerService, LoadBalancerServiceHttp, LoadBalancerHealthCheck, LoadBalancerHealtCheckHttp
+from pathlib import Path
+
+with open("secrets/token.txt", "r") as file:
+    api_token = file.read().strip()
+
+with open("secrets/ssh_key.txt", "r") as file:
+    ssh_key = file.read().strip()
+
+client = Client(token=api_token)
+
+PREFIX = "s444354"
+
+try:
+    ssh_key = client.ssh_keys.create(name=f"{PREFIX}-pzc-ssh-key", public_key=ssh_key)
+    print(f"Key {ssh_key.data_model.name} created: {ssh_key.data_model.public_key}")
+except:
+    ssh_key = client.ssh_keys.get_by_name(f"{PREFIX}-pzc-ssh-key")
+    print(f"Key {ssh_key.data_model.name} already in use: {ssh_key.data_model.public_key}")
+
+NUM_OF_SERVERS = 5
+loadbalancer_targets = []
+
+try:
+    vnet = client.networks.create(
+        name=f"{PREFIX}",
+        ip_range="10.10.10.0/24", 
+        subnets=[
+            NetworkSubnet(ip_range="10.10.10.0/24", network_zone="eu-central", type="cloud")
+        ]
+    )
+    print(f"Created network: {vnet.data_model.name} ({vnet.data_model.ip_range})")
+except:
+    vnet = client.networks.get_by_name(
+        f"{PREFIX}",
+    )
+    print(f"Network in use: {vnet.data_model.name} ({vnet.data_model.ip_range})")
+
+webservice_init=r'''#cloud-config
+packages:
+  - apt-transport-https
+  - ca-certificates
+  - curl
+  - gnupg-agent
+  - software-properties-common
+
+write_files:
+  - path: /root/Dockerfile
+    content: |
+        FROM ubuntu
+        COPY ./webservice /
+        RUN chmod +x ./webservice
+        EXPOSE 80:8080/tcp
+        CMD ./webservice
+
+runcmd:
+  - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
+  - add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
+  - apt-get update -y
+  - apt-get install -y docker-ce docker-ce-cli containerd.io
+  - curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
+  - chmod +x /usr/local/bin/docker-compose
+  - curl -fsSL https://git.wmi.amu.edu.pl/s444498/cloud/raw/branch/master/Public_cloud/webservice > /root/webservice
+  - systemctl start docker
+  - systemctl enable docker
+  - cd /root/
+  - docker build -t webservice .
+  - docker run -d -p 80:8080 -t webservice
+'''
+
+for i in range(NUM_OF_SERVERS):
+    webservice_server = client.servers.create(
+        name=f"{PREFIX}-webservice-{i+1}",
+        server_type=ServerType("cx11"),
+        image=Image(name="ubuntu-22.04"),
+        ssh_keys=[ssh_key],
+        networks=[vnet],
+        location=Location("hel1"),
+        user_data=webservice_init
+    )
+
+    webservice_server.action.wait_until_finished()
+    print(f"Creating webservice {i+1}: {webservice_server.action.complete}")
+    loadbalancer_targets.append(LoadBalancerTarget(type="server", server=webservice_server.server, use_private_ip=False))
+
+loadbalancer = client.load_balancers.create(
+    name= f"{PREFIX}-loadbalancer",
+    load_balancer_type=LoadBalancerType(name="lb11"),
+    location=Location("hel1"),
+    targets=loadbalancer_targets,
+    public_interface=True,
+    services=[
+        LoadBalancerService(
+            protocol="http",
+            listen_port=80,
+            destination_port=80,
+            proxyprotocol=False,
+            health_check=LoadBalancerHealthCheck(
+                protocol="http",
+                port=80,
+                interval=15,
+                timeout=10,
+                retries=3,
+                http=LoadBalancerHealtCheckHttp(
+                    path="/factors/32",
+                    status_codes=["2??", "3??"],
+                    tls=False
+                )
+            ),
+            http=LoadBalancerServiceHttp(
+                cookie_name='HCLBSTICKY',
+                cookie_lifetime=300,
+                sticky_sessions=True,
+                certificates=[],
+            ),
+        ),
+    ],
+)
+
+loadbalancer.action.wait_until_finished()
+print(f"Loadbalancer creating...: {loadbalancer.action.complete}")
+
+load_balancer = client.load_balancers.get_by_name(f"{PREFIX}-loadbalancer")
+print(f"Webserwis: http://{load_balancer.data_model.public_net.ipv4.ip}:80/factors/")

script_check.py

@@ -0,0 +1,152 @@
+import requests
+import random
+import math
+import time
+import threading
+import logging
+
+logging.getLogger().setLevel(logging.INFO)
+
+API_URL = "http://95.217.175.175"
+
+UNIT = 5.0  # secs
+
+# Pre generated primes
+first_primes_list = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
+                     31, 37, 41, 43, 47, 53, 59, 61, 67,
+                     71, 73, 79, 83, 89, 97, 101, 103,
+                     107, 109, 113, 127, 131, 137, 139,
+                     149, 151, 157, 163, 167, 173, 179,
+                     181, 191, 193, 197, 199, 211, 223,
+                     227, 229, 233, 239, 241, 251, 257,
+                     263, 269, 271, 277, 281, 283, 293,
+                     307, 311, 313, 317, 331, 337, 347, 349]
+
+
+def nBitRandom(n):
+    return random.randrange(2 ** (n - 1) + 1, 2 ** n - 1)
+
+
+def getLowLevelPrime(n):
+    '''Generate a prime candidate divisible
+    by first primes'''
+    while True:
+        # Obtain a random number
+        pc = nBitRandom(n)
+
+        # Test divisibility by pre-generated
+        # primes
+        for divisor in first_primes_list:
+            if pc % divisor == 0 and divisor ** 2 <= pc:
+                break
+        else:
+            return pc
+
+
+def isMillerRabinPassed(mrc):
+    '''Run 20 iterations of Rabin Miller Primality test'''
+    maxDivisionsByTwo = 0
+    ec = mrc - 1
+    while ec % 2 == 0:
+        ec >>= 1
+        maxDivisionsByTwo += 1
+    assert (2 ** maxDivisionsByTwo * ec == mrc - 1)
+
+    def trialComposite(round_tester):
+        if pow(round_tester, ec, mrc) == 1:
+            return False
+        for i in range(maxDivisionsByTwo):
+            if pow(round_tester, 2 ** i * ec, mrc) == mrc - 1:
+                return False
+        return True
+
+    # Set number of trials here
+    numberOfRabinTrials = 20
+    for i in range(numberOfRabinTrials):
+        round_tester = random.randrange(2, mrc)
+        if trialComposite(round_tester):
+            return False
+    return True
+
+
+def random_large_prime(bits):
+    while True:
+        prime_candidate = getLowLevelPrime(bits)
+        if not isMillerRabinPassed(prime_candidate):
+            continue
+        else:
+            return prime_candidate
+
+
+def thread_function(i, fast, timeout):
+    start = time.time()
+
+    c = 5  # bits: 20: 200ms; 21: 350ms; 22: 700ms  23: 1.5s; 25: 6s; 26: 10s; 27: 24s
+    bits = 19 if fast else 23
+    last_report = time.time()
+    processing_time = 0.0
+    reqs = 0
+    while True:
+        iter_start = time.time()
+        if iter_start - start > timeout:
+            logging.info("Thread: %d\treqs: %d\tmean time: %.3fs\t%s" % (
+            i, reqs, processing_time / reqs if reqs > 0 else 0.0, "fast\t" if fast else ""))
+            results[i][iter_start] = processing_time / reqs if reqs > 0 else 0.0
+            return
+        if iter_start - last_report > UNIT / 2:
+            if len(results[i]) % 2 == 0:
+                logging.info("Thread: %d\treqs: %d\tmean time: %.3fs\t%s" % (
+                i, reqs, processing_time / reqs if reqs > 0 else 0.0, "fast\t" if fast else ""))
+            results[i][iter_start] = processing_time / reqs if reqs > 0 else 0.0
+            processing_time = 0.0
+            reqs = 0
+            last_report = iter_start
+
+        factors = [random_large_prime(bits) for i in range(c)]
+        factors.sort()
+        n = math.prod(factors)
+
+        r = requests.get(API_URL + '/factors/%d' % (n))
+        if r.status_code != 200:
+            logging.error("wrong status code from webservice")
+        else:
+            result = r.json()
+            if result != factors:
+                logging.error("Wrong factors")
+
+        processing_time += time.time() - iter_start
+        reqs += 1
+        time.sleep(0.5)
+
+
+START = time.time()
+slow_threads = 4
+
+results = [{} for i in range(slow_threads + 1)]
+
+t0 = threading.Thread(target=thread_function, args=(0, True, (5 + slow_threads * 3) * UNIT))
+t0.start()
+time.sleep(2 * UNIT)
+for i in range(slow_threads):
+    t = threading.Thread(target=thread_function, args=(i + 1, False, (slow_threads - i) * 3 * UNIT))
+    t.start()
+    time.sleep(2 * UNIT)
+
+t0.join()
+
+
+
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+import scipy.stats as stats
+mu = 0
+std = 1
+for i, result in enumerate(results):
+    x = [(x - START)/UNIT for x in result.keys()]
+    y = result.values()
+    plt.plot(x, y, label="t%d"%(i,))
+
+plt.legend()
+plt.show()

secrets/ssh_key.txt

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDf6Xp5UPeqC8Ct+YMFan2Tw5Qcg/fXPblFxB4j06GL/QLviSw0aCBFFODGBdPFOoOnNDJjIsIr5gy4IAP2Wab5woP0ygnliqCrYQwjjRARkU8rfLeyAJ/o2PPsroiAsOf/wYJYqCnipuOe0OJBXuGlkM3rEgViQbVvXeiH7jQTt9HdxaH3nH8M6Mkj4i3wK2O4ot8J6IONJcpuVe65QvbhZM0+MS8nkG/wnJv4edAm6P/tfROy0wSP6OjK9JCU+SompT0C+jThU74xskYyZpQi1JRCUKEJTsInoRD7c7m4iwQKCyJaLAUUUOj+aCKgA3VZ5fNM6AAYhL9pl76JXrDnfLeUg4IHHiXeUwPEqLHHF4rcmfomPm98jQXkkaTx/Z8qAk9Vpj+XjGG39WscEXC2kANcM/d8Oy3FK8NnlFuXIB5UE5AU6I83OFeL4zQ9vtaNZh3u/V94Yn1COYn0CQJv0XYiT0co6hW8ptDU9BP9fv+hywk7QAAyAR1hCIMoNBM= geonode@geonode

secrets/token.txt

@@ -0,0 +1 @@
+KccUEiddxtzGoLWSNC3V8tylq7MYHCjdnShtgasQ8jSbHqCjGoaa6Rq7yoz4uS23