ROOT=${HOME}/clusterstate
while read -r resource
do
    echo "  scanning resource '${resource}'"
    while read -r namespace item x
    do
        mkdir -p "${ROOT}/${namespace}/${resource}"
        echo "    exporting item '${namespace} ${item}'"
        kubectl get "$resource" -n "$namespace" "$item" -o yaml > "${ROOT}/${namespace}/${resource}/$item.yaml" &
    done < <(kubectl get "$resource" --all-namespaces 2>&1  | tail -n +2)
done < <(kubectl api-resources --namespaced=true 2>/dev/null | grep -v "events" | tail -n +2 | awk '{print $1}')

wait

BINARY=yq_linux_arm64
LATEST=$(wget -qO- https://api.github.com/repos/mikefarah/yq/releases/latest 2>/dev/null | grep browser_download_url | grep $BINARY\"\$|awk '{print $NF}' )
sudo wget -q $LATEST -O /usr/bin/yq && sudo chmod +x /usr/bin/yq

 kubectl get deployment nginx-deployment -o json | jq -r '.metadata.annotations."kubectl.kubernetes.io/last-applied-configuration"' | yq r -P - > deployment_cleaned.yaml

VER=$(curl -s https://api.github.com/repos/k0sproject/k0sctl/releases/latest|grep tag_name | cut -d '"' -f 4)
echo $VER
### For 64-bit ###
wget https://github.com/k0sproject/k0sctl/releases/download/${VER}/k0sctl-linux-x64 -O k0sctl

###For ARM64 ###
wget https://github.com/k0sproject/k0sctl/releases/download/${VER}/k0sctl-linux-arm64 -O k0sctl
chmod +x k0sctl
yes | cp -vr k0sctl /usr/local/bin/
### Bash ###
sh -c 'k0sctl completion >/etc/bash_completion.d/k0sctl'

kubectl patch app APP_NAME -p '{"metadata": {"finalizers": null}}' --type merge
kubectl patch crd CRD_NAME -p '{"metadata": {"finalizers": null}}' --type merge

kubectl rollout restart deployment/nginx-deployment

spec:
  replicas: 4
  strategy:
  type: RollingUpdate
  rollingUpdate:
    maxSurge: 3
    maxUnavailable: 1

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"

echo 'source <(kubectl completion bash)' >>~/.bashrc
kubectl completion bash >/etc/bash_completion.d/kubectl
echo "alias k=\'kubectl\'" >> ~/.bashrc
echo 'complete -F __start_kubectl k' >>~/.bashrc
source ~/.bashrc
export KUBECONFIG=~/admin.conf

curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl
kubectl completion bash >/etc/bash_completion.d/kubectl
export KUBECONFIG=~/admin.conf

for deployment in $(kubectl get deployments -n $namespace -o jsonpath='{.items[*].metadata.name}'); do
  kubectl logs deployment/$deployment -n $namespace --all-containers >> /mnt/nas/_tmp/all_deployments_logs.txt
done

namespaceToDelete=preload-kube-burner
kubectl get namespace "$namespaceToDelete" -o json   | jq 'del(.spec.finalizers)'   | kubectl replace --raw /api/v1/namespaces/$namespaceToDelete/finalize -f -

import time
import threading
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import parse_qs
import json
from datetime import datetime

log_counter = 0

def log_message(message):
    global log_counter
    stars = (log_counter % 5) + 1
    log_counter += 1
    progress = f"[{'*' * stars}{'-' * (5 - stars)}]"
    print(f"{progress} {datetime.now().isoformat()} - {message}")

class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path.startswith("/ping"):
            query_params = parse_qs(self.path[6:])  # Pobieramy parametry z URL
            message = query_params.get("msg", ["No message"])[0]
            log_message(f"Received message: {message}")
            response = {"response": f"Echo: {message}"}

            # Wysyłamy odpowiedź
            self.send_response(200)
            self.send_header("Content-type", "application/json")
            self.end_headers()
            self.wfile.write(json.dumps(response).encode('utf-8'))
        else:
            self.send_response(404)
            self.end_headers()

def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):
    server_address = ('', 5000)
    httpd = server_class(server_address, handler_class)
    print('Starting server...')
    httpd.serve_forever()

def start_server():
    server_thread = threading.Thread(target=run)
    server_thread.daemon = True
    server_thread.start()

if __name__ == "__main__":
    start_server()
    # Można dodać dodatkowe logowanie serwera, jeśli chcesz
    while True:
        time.sleep(1)

import urllib.request
import urllib.parse
import json
import time
from datetime import datetime
from urllib.error import URLError, HTTPError

log_counter = 0

def log_message(message):
    global log_counter
    stars = (log_counter % 5) + 1
    log_counter += 1
    progress = f"[{'*' * stars}{'-' * (5 - stars)}]"
    print(f"{progress} {datetime.now().isoformat()} - {message}")

def send_message(msg):
    url = f'http://localhost:5000/ping?msg={urllib.parse.quote(msg)}'
    try:
        # Timeout ustawiony na 1 sekundę
        with urllib.request.urlopen(url, timeout=1) as response:
            response_data = json.load(response)
            log_message(f"Sent: {msg}, Got: {response_data['response']}")
    except URLError as e:
        log_message(f"Failed to connect to server: {e.reason}. Retrying...")
    except HTTPError as e:
        log_message(f"HTTP error occurred: {e.code} - {e.reason}")
    except Exception as e:
        log_message(f"An unexpected error occurred: {e}")

def main():
    i = 0
    while True:
        msg = f"Hello {i}"
        send_message(msg)
        i += 1
        time.sleep(2)

if __name__ == "__main__":
    main()