def remote(self): try: conn = Client(endpoint='https://45.76.43.148:8443', cert=(self.certfile, self.keyfile), verify=False) conn.authenticate(self.password) return {"error": False, "conn": conn} except Exception as e: return { "error": True, "message": "We have trouble connecting to the LXD daemon. LXC/LXD might not be installed or either daemon not initialised up properly !\n{}" .format(e) }
def detailsRemoteImage(self, alias): try: remoteImagesLink = Config().get(meta.APP_NAME, '{}.images.remote'.format(meta.APP_NAME.lower())) remoteClient = Client(endpoint=remoteImagesLink) fingerprint = remoteClient.api.images.aliases[alias].get().json()['metadata']['target'] return remoteClient.api.images[fingerprint].get().json()['metadata'] except Exception as e: raise ValueError(e)
def __init__(self): self.read_keys() # TODO Deal with error if key does not exist self.client = Client( endpoint=os.path.expandvars(self.LXD_ENDPOINT), cert=(os.path.expandvars(self.LXD_CRT), os.path.expandvars(self.LXD_KEY)), verify=False)
def detailsRemotePaesslerImage(self, alias): try: remotePaesslerImagesLink = Config().get(meta.APP_NAME, '{}.images.remote-paessler'.format(meta.APP_NAME.lower())) verify = False if Config().get(meta.APP_NAME, '{}.lxd.sslverify'.format(meta.APP_NAME.lower())) == 'false' else True remoteClient = Client(endpoint=remotePaesslerImagesLink, verify=False) fingerprint = remoteClient.api.images.aliases[alias].get().json()['metadata']['target'] return remoteClient.api.images[fingerprint].get().json()['metadata'] except Exception as e: raise ValueError(e)
def post_init(self, **kwargs): # Instantiate the LXD client self.lxd_client = Client() self.container_list = {"hoen04-embb": True, "hoen04-urllc": True, "hoen04-debug": True} """
def connect(self, access, credentials, vmc_name, extra_parms={}, diag=False, generate_rc=False): ''' TBD ''' try: _status = 100 _endpoint_ip = "NA" _fmsg = "An error has occurred, but no error message was captured" self.ssl_key = extra_parms["ssl_key"] self.ssl_cert = extra_parms["ssl_cert"] for _endpoint in access.split(','): _endpoint, _endpoint_name, _endpoint_ip = self.parse_endpoint( _endpoint, "https", "8443") if _endpoint_ip not in self.lxdconn: self.lxdconn[_endpoint_ip] = Client(endpoint=_endpoint, cert=(self.ssl_cert, self.ssl_key), verify=False) self.lxdconn[_endpoint_ip].authenticate(credentials) if not self.lxdconn[_endpoint_ip].trusted: _fmsg = "Unable to authenticate" _status = 101 _status -= 100 except LXDError.ClientConnectionFailed as obj: _status = 18127 _fmsg = str(obj.message) except LXDError.LXDAPIException as obj: _status = 18127 _fmsg = str(obj) except Exception as e: _status = 23 _fmsg = str(e) finally: if _status: _msg = self.get_description( ) + " connection to endpoint \"" + _endpoint_ip + "\" failed: " + _fmsg cberr(_msg) raise CldOpsException(_msg, _status) else: _msg = self.get_description() + " connection successful." cbdebug(_msg) return _status, _msg, ''
def listRemoteImages(self): try: remoteImagesLink = Config().get(meta.APP_NAME, '{}.images.remote'.format(meta.APP_NAME.lower())) logging.info('Reading remote image list') remoteClient = Client(endpoint=remoteImagesLink) return remoteImagesList(remoteClient.api.images.aliases.get().json()) except Exception as e: logging.error('Failed to get remote container images: ') logging.exception(e) raise ValueError(e)
def __init__(self) -> None: try: self.client = Client( endpoint=Config.endpoint, cert=(Config.cert, Config.key), verify=False, timeout=10) except ClientConnectionFailed: logger.error('Failed to connect to the LXD server, please check the connection') raise
def __init__(self, ip=None, db=None, https=False, https_ignore=False): self._user = "" if ip is None: import docker from pylxd import Client import sqlite3 self._user = "******" self.lock = RLock() self.modules = {} if db != None: self.db = db else: self.db = sqlite3.connect('fakernet.db') self.docker = docker.from_env() self.lxd = Client() self.ip = None self._https = False self._port = 0 self._https_ignore = https_ignore self.history_writer = HistoryWriter() self.depth = 0 else: import requests self.lock = None self.modules = {} self.db = None self.docker = None self.lxd = None self.ip = ip self._https = https if https: self._port = PORT_HTTPS else: self._port = PORT self._https_ignore = https_ignore self._r = requests self.history_writer = None self._logger = logging.getLogger("fakernet") fileLog = logging.FileHandler("./logs/fakernet.log") formatter = logging.Formatter( '%(asctime)s %(levelname)s USER=%(user)s : %(message)s') fileLog.setFormatter(formatter) self._logger.setLevel(logging.INFO) self._logger.handlers = [] self._logger.addHandler(fileLog) self.logger = logging.LoggerAdapter(self._logger, {"user": self._user})
def launch_container(): #============= img_alias = request.form['img_alias'] containerName = request.form['containerName'] #============= config = {'name': containerName, 'ephemeral': False,#'config': {'limits.cpu': '2', 'limits.memory': '1GB'}, 'source': {'type': 'image', 'alias': img_alias } } #============= client = connect() if client['error']: response = Response(client) return response.bad_request() client = client['conn'] #====================== #pre-check container name if client.containers.exists(containerName): data = {'success': False, 'payload': "Container with name <{0}> can not be created because it already exists !".format( containerName ), 'move_next' : True } response = Response(data) return response.success() local_cached_OS = None try: local_cached_OS = client.images.get_by_alias( img_alias ) except Exception, e: if str(e).lower() == "not found" : #>>START download it locally try: linux_repo = Client(endpoint='https://images.linuxcontainers.org') except Exception, e: print str(e) #NO INTERNET data = {'success': False, 'payload': "NO INTERNET CONNECTION to download the LXC Image <{}> !".format( img_alias ), 'move_next' : False } response = Response(data) return response.success() try: selected_image = linux_repo.images.get_by_alias( img_alias ) except Exception, e: data = {'success': False, 'payload': "There is no LXC IMAGE from the LXC Linux official repo, identified by this alias <{0}> !".format( img_alias ), 'move_next' : False } response = Response(data) return response.success()
def local(self): try: conn = Client() return {"error": False, "conn": conn} except Exception as e: return { "error": True, "message": "We have trouble connecting to the LXD daemon. LXC/LXD might not be installed or either daemon not initialised up properly !\n{}" .format(e) }
def _init_api(): global api config_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '../config') config_file = os.path.join(config_dir, 'lxd.yml') stream = open(config_file, 'r') config = yaml.load(stream, Loader=yaml.Loader) if not os.path.isabs(config['certificate']): config['certificate'] = os.path.join(config_dir, config['certificate']) if not os.path.isabs(config['key']): config['key'] = os.path.join(config_dir, config['key']) return Client(endpoint=config['server'], verify=False, cert=(config['certificate'], config['key']))
def start_runtime(self): self.agent.logger.info('startRuntime()', ' LXD Plugin - Connecting to LXD') self.conn = Client() self.agent.logger.info('startRuntime()', '[ DONE ] LXD Plugin - Connecting to LXD') uri = str('%s/%s/*' % (self.agent.dhome, self.HOME)) self.agent.logger.info('startRuntime()', ' LXD Plugin - Observing %s' % uri) self.agent.dstore.observe(uri, self.__react_to_cache) '''check if dirs exists if not exists create''' if self.agent.get_os_plugin().dir_exists(self.BASE_DIR): if not self.agent.get_os_plugin().dir_exists(str("%s/%s") % (self.BASE_DIR, self.DISK_DIR)): self.agent.get_os_plugin().create_dir(str("%s/%s") % (self.BASE_DIR, self.DISK_DIR)) if not self.agent.get_os_plugin().dir_exists(str("%s/%s") % (self.BASE_DIR, self.IMAGE_DIR)): self.agent.get_os_plugin().create_dir(str("%s/%s") % (self.BASE_DIR, self.IMAGE_DIR)) if not self.agent.get_os_plugin().dir_exists(str("%s/%s") % (self.BASE_DIR, self.LOG_DIR)): self.agent.get_os_plugin().create_dir(str("%s/%s") % (self.BASE_DIR, self.LOG_DIR)) else: self.agent.get_os_plugin().create_dir(str("%s") % self.BASE_DIR) self.agent.get_os_plugin().create_dir(str("%s/%s") % (self.BASE_DIR, self.DISK_DIR)) self.agent.get_os_plugin().create_dir(str("%s/%s") % (self.BASE_DIR, self.IMAGE_DIR)) self.agent.get_os_plugin().create_dir(str("%s/%s") % (self.BASE_DIR, self.LOG_DIR)) return self.uuid
def downloadImage(self, image): try: remoteImagesLink = Config().get(meta.APP_NAME, '{}.images.remote'.format(meta.APP_NAME.lower())) logging.info('Downloading remote image:', image) remoteClient = Client(endpoint=remoteImagesLink) try: remoteImage = remoteClient.images.get_by_alias(image) except: remoteImage = remoteClient.images.get(image) newImage = remoteImage.copy(self.client, auto_update=False, public=False, wait=True) return self.client.api.images[newImage.fingerprint].get().json()['metadata'] except Exception as e: logging.error('Failed to download image:') logging.exception(e) raise ValueError(e)
class Server(): def __init__(self, name, host, port, crt, key, password=None): self.containers = [] self.name = name self.key = key self.ip = host self.port = port self.crt = crt self.endpoint = "https://" + self.ip + ":" + str(self.port) self.client = Client(endpoint=self.endpoint, cert=(self.crt, self.key), verify=False) if not (self.client.trusted): try: self.client.authenticate(password) except pylxd.exceptions.LXDAPIException: print("Introduces the trust password to Client.autheticate") def scan(self): self.containers = self.client.containers.all() @property def containers(self): return self.client.containers
def downloadImage(self, image): try: logging.info('Downloading remote iamge:', image) remoteClient = Client( endpoint='https://images.linuxcontainers.org') remoteImage = remoteClient.images.get_by_alias(image) newImage = remoteImage.copy(self.client, auto_update=False, public=False, wait=True) return self.client.api.images[ newImage.fingerprint].get().json()['metadata'] except Exception as e: logging.error('Failed to download image:') logging.exception(e) raise ValueError(e)
def listRemotePaesslerImages(self): try: remotePaesslerImagesLink = Config().get(meta.APP_NAME, '{}.images.remote-paessler'.format(meta.APP_NAME.lower())) logging.info('Reading remote image list') verify = False if Config().get(meta.APP_NAME, '{}.lxd.sslverify'.format(meta.APP_NAME.lower())) == 'false' else True CERTS_PATH = Config().get(meta.APP_NAME, '{}.conf.dir'.format(meta.APP_NAME.lower())) cert = CertRemotePaessler( cert=os.path.expanduser(os.path.join(CERTS_PATH, 'client.crt')), key=os.path.expanduser(os.path.join(CERTS_PATH, 'client.key')) ) remoteClient = Client(endpoint=remotePaesslerImagesLink, verify=verify, cert=cert) return remoteImagesList(remoteClient.api.images.aliases.get().json()) except Exception as e: logging.error('Failed to get remote container images: ') logging.exception(e) raise ValueError(e)
def downloadImage(self, image): try: #response = requests.get(url='https://us.images.linuxcontainers.org/1.0/images/aliases/{}'.format(self.data.get('image'))) #image_details = requests.get(url='https://us.images.linuxcontainers.org/1.0/images/{}'.format(response.json()['metadata']['target'])) remoteClient = Client( endpoint='https://images.linuxcontainers.org') remoteImage = remoteClient.images.get_by_alias(image) newImage = remoteImage.copy(self.client, auto_update=False, public=False, wait=True) return self.client.api.images[ newImage.fingerprint].get().json()['metadata'] except Exception as e: raise ValueError(e)
def __init__(self, config, server): self.config = config endpoint = 'http+unix://{}'.format( parse.quote(config.lxd.socket, safe='')) self.client = Client(endpoint=endpoint) self.server = server self.admins = set(grp.getgrnam(ADMIN_GROUP).gr_mem) self.exec_sessions = {} self.console_sessions = {} self.reserved_options = { 'terminate_ssl': str2bool, 'startup_delay': self.startup_delay, 'http_port': port, 'https_port': port, } self.running_containers = list( map( lambda c: c.name, filter( lambda c: c.name.endswith(self.config.lxd.suffix) and c. status_code == 103, self.client.containers.all()))) self.container_lock = threading.RLock() logging.debug('containers running at startup: %s', self.running_containers) self.ip_cache = {} self.custom_domains = {} self.tcp_proxy = TcpProxy(config.ports.proxy_bin, config.bind_socket) self.forwarded_ports = set() for container in filter( lambda c: c.name.endswith(self.config.lxd.suffix), self.client.containers.all()): user = self.container_user(container) for domain in self.get_container_domains(container): self.custom_domains[domain] = user for iport, eport in self.get_container_ports(container).items(): logging.info('existing port forward %d -> %s:%d', eport, user, iport) self.forwarded_ports.add(eport) self.tcp_proxy.add_forwarding(eport, user, iport) logging.info('existing custom domain configuration: %s', self.custom_domains)
def __init__(self, input): logging.info('Connecting to LXD') self.client = Client() logging.debug('Setting network input to {}'.format(input)) self.input = input logging.debug('Setting network parameters') self.MAP = {"ipv4.address": ["IPv4_ENABLED", "IPv4_ADDR", "IPv4_NETMASK", "IPv4_AUTO"], "ipv6.address": ["IPv6_ENABLED", "IPv6_ADDR", "IPv6_NETMASK", "IPv6_AUTO"], "ipv4.nat": "IPv4_NAT", "ipv6.nat": "IPv6_NAT", "ipv4.dhcp": "IPv4_DHCP", "ipv4.dhcp.ranges": ["IPv4_DHCP_START", "IPv4_DHCP_END"], "ipv6.dhcp": "IPv6_DHCP", "ipv6.dhcp.ranges": ["IPv6_DHCP_START", "IPv6_DHCP_END"]} self.AUTO_YAML_TERMS = ['auto', '"auto"', "'auto'"] self.NONE_YAML_TERMS = ['none', '"none"', "'none'"] self.TRUE_YAML_TERMS = ['true', '"true"', "'true'"]
def __init__(self, url, cert, key): """ Configure logging. """ # Use the logger object created by Client. self.p = logging.getLogger('qb') self.p.debug("Using LXD API config:\n" " URL: %s\n" " Cert: %s\n" " Key: %s" % (url, cert, key)) # Create an LXD client instance. self.lxd = Client( endpoint=url, cert=(cert, key), verify=False ) return
def create_lxd_container(container_name, ovs_name, ip_address): print("Creating the container: {}".format(container_name)) client = Client() if not client.profiles.exists(ovs_name): client.profiles.create(ovs_name, config={ 'environment.http_proxy': 'http://[fe80::1%eth0]:13128', 'user.network_mode': 'link-local' }, devices={ 'eth0': { 'name': 'eth0', 'nictype': 'bridged', 'parent': ovs_name, 'type': 'nic' } }) config = { 'name': container_name, 'source': { 'type': 'image', "mode": "pull", "server": "https://cloud-images.ubuntu.com/daily", "protocol": "simplestreams", 'alias': 'bionic/amd64' }, 'profiles': [ovs_name] } container = client.containers.create(config, wait=True) container.start() while client.containers.get(container_name).status != 'Running': time.sleep(1) time.sleep(5) basic_cmd = "lxc exec {} -- ip addr add {}/24 dev eth0".format( container_name, ip_address) os.system(basic_cmd) basic_cmd = "lxc exec {} -- ip link set dev eth0 up".format(container_name) os.system(basic_cmd)
def __init__(self, name, version, port, alias=DEFAULT_SYSTEM_IMAGE): self.name = name self.version = version self.alias = alias if 'centos' in self.alias: self.pkg_format = 'rpm' else: self.pkg_format = 'deb' # prepare styling for traces self.style = random.choice(STYLES) print(colors.color('%s: %s' % (name, str(self.style)), **self.style)) # open separate connection to LXD self.lxd = Client() self.config = { 'name': name, 'source': { 'type': 'image', 'mode': 'pull', # 'server': 'https://cloud-images.ubuntu.com/daily', 'server': 'https://us.images.linuxcontainers.org/', 'protocol': 'simplestreams', 'alias': alias }, 'devices': { 'myproxy': { 'type': 'proxy', 'listen': 'tcp:0.0.0.0:%d' % port, 'connect': 'tcp:127.0.0.1:8080' } } } self.cntr = None self.thread = None self.bg_exc = None self.mgmt_ip = None
def __init__(self, input): self.client = Client() self.input = input self.MAP = { "ipv4.address": ["IPv4_ENABLED", "IPv4_ADDR", "IPv4_NETMASK", "IPv4_AUTO"], "ipv6.address": ["IPv6_ENABLED", "IPv6_ADDR", "IPv6_NETMASK", "IPv6_AUTO"], "ipv4.nat": "IPv4_NAT", "ipv6.nat": "IPv6_NAT", "ipv4.dhcp": "IPv4_DHCP", "ipv4.dhcp.ranges": ["IPv4_DHCP_START", "IPv4_DHCP_END"], "ipv6.dhcp": "IPv6_DHCP", "ipv6.dhcp.ranges": ["IPv6_DHCP_START", "IPv6_DHCP_END"] } self.AUTO_YAML_TERMS = ['auto', '"auto"', "'auto'"] self.NONE_YAML_TERMS = ['none', '"none"', "'none'"] self.TRUE_YAML_TERMS = ['true', '"true"', "'true'"]
def connect(self, access, credentials, vmc_name, extra_parms={}, diag=False, generate_rc=False): ''' TBD ''' try: _status = 100 _endpoint_ip = "NA" _fmsg = "An error has occurred, but no error message was captured" self.ssl_key = extra_parms["ssl_key"] self.ssl_cert = extra_parms["ssl_cert"] for _endpoint in access.split(','): _endpoint, _endpoint_name, _endpoint_ip = self.parse_endpoint( _endpoint, "https", "8443") if _endpoint_ip not in self.lxdconn: self.lxdconn[_endpoint_ip] = Client(endpoint=_endpoint, cert=(self.ssl_cert, self.ssl_key), verify=False) self.lxdconn[_endpoint_ip].authenticate(credentials) if not self.lxdconn[_endpoint_ip].trusted: _fmsg = "Unable to authenticate" _status = 101 _status -= 100 except LXDError.ClientConnectionFailed, obj: _status = 18127 _fmsg = str(obj.message)
#!/usr/bin/env python3 import sys from pylxd import Client client = Client() # we focus on local LXD socket vault_list = [ "unsealer", "vault01", "vault02", "vault03", "pki", ] consul_list = ["consul01", "consul02", "consul03"] all_list = vault_list + consul_list def main(): cluster_name = sys.argv[1] what = sys.argv[2] if what == "vault": c_list = vault_list elif what == "consul": c_list = consul_list else: c_list = all_list for c in c_list: # delete the containers name = cluster_name + "-" + c
def __init__(self): logging.basicConfig(format="%(asctime)s: %(message)s", level=logging.INFO, datefmt="%H:%M:%S") self.client = Client()
#! /usr/bin/env python3 import os import platform import shutil import sys import warnings from pylxd import Client client = Client() warnings.filterwarnings("ignore") def convert(num): unit = 1000.0 for x in ['', 'KB', 'MB', 'GB', 'TB']: if num < unit: return "%.0f%s" % (num, x) num /= unit def get_driver(): machine = platform.machine().lower() if machine.startswith(('arm', 'aarch64')): return "btrfs" return "zfs" def create_storage(): snap_data = os.environ['SNAP_DATA']
def __init__(self, input): logging.info('Connecting to LXD') self.client = Client() self.input = input
def __init__(self, input): self.client = Client() self.input = input