from hcloud import Client
from hcloud.networks.domain import NetworkSubnet
from hcloud.locations.domain import Location
from hcloud.server_types.domain import ServerType
from hcloud.images.domain import Image
from hcloud.load_balancers.domain import (
    LoadBalancerService, 
    LoadBalancerServiceHttp, 
    LoadBalancerHealthCheck, 
    LoadBalancerHealtCheckHttp,
    LoadBalancerTarget
)
from hcloud.load_balancer_types.domain import LoadBalancerType


TOKEN = 'KccUEiddxtzGoLWSNC3V8tylq7MYHCjdnShtgasQ8jSbHqCjGoaa6Rq7yoz4uS23'
SSH_PUBKEY = ''

cloud_init = """#cloud-config
packages:
  - apt-transport-https
  - ca-certificates
  - curl
  - gnupg-agent
  - software-properties-common
      
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
  - systemctl start docker
  - systemctl enable docker
  - git clone https://git.wmi.amu.edu.pl/s444465/pzc-hetzner.git
  - cd pzc-hetzner/balancer
  - docker build -t webservice .
  - docker run -d -p 80:8080 -t webservice"""


PREFIX = '444465'
key_name = f'{PREFIX}-key'
net_name = f'{PREFIX}-vnet'

if __name__ == '__main__':
    client = Client(token=TOKEN)
    ssh_key = client.ssh_keys.get_by_name(key_name) or None
    if not ssh_key:
    	ssh_key = client.ssh_keys.create(name=key_name, public_key=SSH_PUBKEY)

    vnet = client.networks.get_by_name(net_name) or None
    if not vnet:
    	vnet = client.networks.create(
        	name=net_name, 
        	ip_range='10.10.10.0/24',
        	subnets=[
            	NetworkSubnet(ip_range='10.10.10.0/24', 
            	network_zone='eu-central', 
            	type='cloud')
        	]
    	)

    server1 = client.servers.create(
        name=f'{PREFIX}-webservice-1', 
        server_type=ServerType('cx11'), 
        image=Image(name='ubuntu-20.04'), 
        ssh_keys=[ssh_key], 
        networks=[vnet], 
        location=Location('hel1'),  
        user_data=cloud_init
    )
    server1.action.wait_until_finished()
    print(f'Server 1 created: {server1.action.complete}')
    server1 = client.servers.get_by_name(f'{PREFIX}-webservice-1')

    server2 = client.servers.create(
        name=f'{PREFIX}-webservice-2', 
        server_type=ServerType('cx11'), 
        image=Image(name='ubuntu-20.04'), 
        ssh_keys=[ssh_key], 
        networks=[vnet], 
        location=Location('hel1'),  
        user_data=cloud_init
    )
    server2.action.wait_until_finished()
    print(f'Server 2 created: {server2.action.complete}')
    server2 = client.servers.get_by_name(f'{PREFIX}-webservice-2')


    server3 = client.servers.create(
        name=f'{PREFIX}-webservice-3', 
        server_type=ServerType('cx11'), 
        image=Image(name='ubuntu-20.04'), 
        ssh_keys=[ssh_key], 
        networks=[vnet], 
        location=Location('hel1'),  
        user_data=cloud_init
    )
    server3.action.wait_until_finished()
    print(f'Server 3 created: {server3.action.complete}')
    server3 = client.servers.get_by_name(f'{PREFIX}-webservice-3')

    load_balancer = client.load_balancers.create(
        name=f'{PREFIX}-load-balancer',
        load_balancer_type=LoadBalancerType(name='lb11'),
        location=Location('hel1'),
        network=vnet,
        targets=[
            LoadBalancerTarget(
                type='server',
                server=server1,
                use_private_ip=True,
            ),
            LoadBalancerTarget(
                type='server',
                server=server2,
                use_private_ip=True,
            ),
            LoadBalancerTarget(
                type='server',
                server=server3,
                use_private_ip=True,
            )
        ],
        services=[
            LoadBalancerService(
                protocol='http',
                listen_port=80,
                destination_port=80,
                health_check=LoadBalancerHealthCheck(
                    protocol='http',
                    port=80,
                    interval=15,
                    timeout=10,
                    retries=3,
                    http=LoadBalancerHealtCheckHttp(
                        path='/factors/10',
                        status_codes=['2??', '3??'],
                        tls=False,
                    )
                ),
                http=LoadBalancerServiceHttp(
                    cookie_name='HCLBSTICKY',
                    cookie_lifetime=300,
                    sticky_sessions=True,
                    certificates=[],
                )
            ),
            ]
    )