ACIL FM

Nama	Ukuran	Aksi
vmware	-	Open
__pycache__	-	Open
akamai.py	1.45 MB	View DL Edit
aliyun.py	7.18 MB	View DL Edit
azure.py	40.39 MB	View DL Edit
cloudsigma.py	2.88 MB	View DL Edit
digitalocean.py	6.75 MB	View DL Edit
ec2.py	8.58 MB	View DL Edit
hetzner.py	840 B	View DL Edit
netlink.py	11.65 MB	View DL Edit
openstack.py	27.18 MB	View DL Edit
upcloud.py	6.48 MB	View DL Edit
vultr.py	7.96 MB	View DL Edit
__init__.py	0 B	View DL Edit

Edit file: /lib/python3.9/site-packages/cloudinit/sources/helpers/digitalocean.py

# Author: Ben Howard  <bh@digitalocean.com>
#
# This file is part of cloud-init. See LICENSE file for license information.

import json
import logging
import random

from cloudinit import dmi
from cloudinit import net as cloudnet
from cloudinit import url_helper, util

NIC_MAP = {"public": "eth0", "private": "eth1"}

LOG = logging.getLogger(__name__)

def assign_ipv4_link_local(distro, nic=None):
    """Bring up NIC using an address using link-local (ip4LL) IPs.
    On DigitalOcean, the link-local domain is per-droplet routed, so there
    is no risk of collisions. However, to be more safe, the ip4LL
    address is random.
    """

if not nic:
        nic = get_link_local_nic(distro)
        LOG.debug("selected interface '%s' for reading metadata", nic)

if not nic:
        raise RuntimeError(
            "unable to find interfaces to access the"
            "meta-data server. This droplet is broken."
        )

addr = "169.254.{0}.{1}/16".format(
        random.randint(1, 168), random.randint(0, 255)
    )

try:
        distro.net_ops.add_addr(nic, addr)
        distro.net_ops.link_up(nic)
        LOG.debug("brought device '%s' up with address %s", nic, addr)
    except Exception:
        util.logexc(
            LOG,
            "ip4LL address assignment of '%s' to '%s' failed."
            " Droplet networking will be broken",
            addr,
            nic,
        )
        raise

return nic

def get_link_local_nic(distro):
    nics = [
        f
        for f in cloudnet.get_devicelist()
        if distro.networking.is_physical(f)
    ]
    if not nics:
        return None
    return min(nics, key=lambda d: cloudnet.read_sys_net_int(d, "ifindex"))

def del_ipv4_link_local(distro, nic=None):
    """Remove the ip4LL address. While this is not necessary, the ip4LL
    address is extraneous and confusing to users.
    """
    if not nic:
        LOG.debug(
            "no link_local address interface defined, skipping link "
            "local address cleanup"
        )
        return

LOG.debug("cleaning up ipv4LL address")

try:
        distro.net_ops.flush_addr(nic)
        LOG.debug("removed ip4LL addresses from %s", nic)

except Exception as e:
        util.logexc(LOG, "failed to remove ip4LL address from '%s'.", nic, e)

def convert_network_configuration(config, dns_servers):
    """Convert the DigitalOcean Network description into Cloud-init's netconfig
    format.

Example JSON:
     {'public': [
           {'mac': '04:01:58:27:7f:01',
            'ipv4': {'gateway': '45.55.32.1',
                     'netmask': '255.255.224.0',
                     'ip_address': '45.55.50.93'},
            'anchor_ipv4': {
                     'gateway': '10.17.0.1',
                     'netmask': '255.255.0.0',
                     'ip_address': '10.17.0.9'},
            'type': 'public',
            'ipv6': {'gateway': '....',
                     'ip_address': '....',
                     'cidr': 64}}
        ],
       'private': [
           {'mac': '04:01:58:27:7f:02',
            'ipv4': {'gateway': '10.132.0.1',
                     'netmask': '255.255.0.0',
                     'ip_address': '10.132.75.35'},
            'type': 'private'}
        ]
     }
    """

def _get_subnet_part(pcfg):
        subpart = {
            "type": "static",
            "control": "auto",
            "address": pcfg.get("ip_address"),
            "gateway": pcfg.get("gateway"),
        }

if ":" in pcfg.get("ip_address"):
            subpart["address"] = "{0}/{1}".format(
                pcfg.get("ip_address"), pcfg.get("cidr")
            )
        else:
            subpart["netmask"] = pcfg.get("netmask")

return subpart

nic_configs = []
    macs_to_nics = cloudnet.get_interfaces_by_mac()
    LOG.debug("nic mapping: %s", macs_to_nics)

for n in config:
        nic = config[n][0]
        LOG.debug("considering %s", nic)

mac_address = nic.get("mac")
        if mac_address not in macs_to_nics:
            raise RuntimeError(
                "Did not find network interface on system "
                "with mac '%s'. Cannot apply configuration: %s"
                % (mac_address, nic)
            )

sysfs_name = macs_to_nics.get(mac_address)
        nic_type = nic.get("type", "unknown")

if_name = NIC_MAP.get(nic_type, sysfs_name)
        if if_name != sysfs_name:
            LOG.debug(
                "Found %s interface '%s' on '%s', assigned name of '%s'",
                nic_type,
                mac_address,
                sysfs_name,
                if_name,
            )
        else:
            msg = (
                "Found interface '%s' on '%s', which is not a public "
                "or private interface. Using default system naming."
            )
            LOG.debug(msg, mac_address, sysfs_name)

ncfg = {
            "type": "physical",
            "mac_address": mac_address,
            "name": if_name,
        }

subnets = []
        for netdef in ("ipv4", "ipv6", "anchor_ipv4", "anchor_ipv6"):
            raw_subnet = nic.get(netdef, None)
            if not raw_subnet:
                continue

sub_part = _get_subnet_part(raw_subnet)
            if nic_type != "public" or "anchor" in netdef:
                del sub_part["gateway"]

subnets.append(sub_part)

ncfg["subnets"] = subnets
        nic_configs.append(ncfg)
        LOG.debug("nic '%s' configuration: %s", if_name, ncfg)

if dns_servers:
        LOG.debug("added dns servers: %s", dns_servers)
        nic_configs.append({"type": "nameserver", "address": dns_servers})

return {"version": 1, "config": nic_configs}

def read_metadata(url, timeout=2, sec_between=2, retries=30):
    response = url_helper.readurl(
        url, timeout=timeout, sec_between=sec_between, retries=retries
    )
    if not response.ok():
        raise RuntimeError("unable to read metadata at %s" % url)
    return json.loads(response.contents.decode())

def read_sysinfo():
    # DigitalOcean embeds vendor ID and instance/droplet_id in the
    # SMBIOS information

# Detect if we are on DigitalOcean and return the Droplet's ID
    vendor_name = dmi.read_dmi_data("system-manufacturer")
    if vendor_name != "DigitalOcean":
        return (False, None)

droplet_id = dmi.read_dmi_data("system-serial-number")
    if droplet_id:
        LOG.debug(
            "system identified via SMBIOS as DigitalOcean Droplet: %s",
            droplet_id,
        )
    else:
        msg = (
            "system identified via SMBIOS as a DigitalOcean "
            "Droplet, but did not provide an ID. Please file a "
            "support ticket at: "
            "https://cloud.digitalocean.com/support/tickets/new"
        )
        LOG.critical(msg)
        raise RuntimeError(msg)

return (True, droplet_id)

Batal