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
