| # |
| # Copyright 2016-present Ciena Corporation |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| import os,time |
| import io |
| import json |
| import yaml |
| from pyroute2 import IPRoute |
| from itertools import chain |
| from nsenter import Namespace |
| from docker import Client |
| from shutil import copy |
| from OnosCtrl import OnosCtrl |
| |
| class docker_netns(object): |
| |
| dckr = Client() |
| def __init__(self, name): |
| pid = int(self.dckr.inspect_container(name)['State']['Pid']) |
| if pid == 0: |
| raise Exception('no container named {0}'.format(name)) |
| self.pid = pid |
| |
| def __enter__(self): |
| pid = self.pid |
| if not os.path.exists('/var/run/netns'): |
| os.mkdir('/var/run/netns') |
| os.symlink('/proc/{0}/ns/net'.format(pid), '/var/run/netns/{0}'.format(pid)) |
| return str(pid) |
| |
| def __exit__(self, type, value, traceback): |
| pid = self.pid |
| os.unlink('/var/run/netns/{0}'.format(pid)) |
| |
| flatten = lambda l: chain.from_iterable(l) |
| |
| class Container(object): |
| dckr = Client() |
| IMAGE_PREFIX = '' ##for saving global prefix for all test classes |
| |
| def __init__(self, name, image, prefix='', tag = 'candidate', command = 'bash', quagga_config = None): |
| self.name = name |
| self.prefix = prefix |
| if prefix: |
| self.prefix += '/' |
| image = '{}{}'.format(self.prefix, image) |
| self.image = image |
| self.tag = tag |
| if tag: |
| self.image_name = image + ':' + tag |
| else: |
| self.image_name = image |
| self.id = None |
| self.command = command |
| self.quagga_config = quagga_config |
| |
| @classmethod |
| def build_image(cls, dockerfile, tag, force=True, nocache=False): |
| f = io.BytesIO(dockerfile.encode('utf-8')) |
| if force or not cls.image_exists(tag): |
| print('Build {0}...'.format(tag)) |
| for line in cls.dckr.build(fileobj=f, rm=True, tag=tag, decode=True, nocache=nocache): |
| if 'stream' in line: |
| print(line['stream'].strip()) |
| |
| @classmethod |
| def image_exists(cls, name): |
| return name in [ctn['RepoTags'][0] for ctn in cls.dckr.images()] |
| |
| @classmethod |
| def create_host_config(cls, port_list = None, host_guest_map = None, privileged = False): |
| port_bindings = None |
| binds = None |
| if port_list: |
| port_bindings = {} |
| for p in port_list: |
| port_bindings[str(p)] = str(p) |
| |
| if host_guest_map: |
| binds = [] |
| for h, g in host_guest_map: |
| binds.append('{0}:{1}'.format(h, g)) |
| |
| return cls.dckr.create_host_config(binds = binds, port_bindings = port_bindings, privileged = privileged) |
| |
| @classmethod |
| def cleanup(cls, image): |
| cnt_list = filter(lambda c: c['Image'] == image, cls.dckr.containers(all=True)) |
| for cnt in cnt_list: |
| print('Cleaning container %s' %cnt['Id']) |
| if cnt.has_key('State') and cnt['State'] == 'running': |
| cls.dckr.kill(cnt['Id']) |
| cls.dckr.remove_container(cnt['Id'], force=True) |
| |
| @classmethod |
| def remove_container(cls, name, force=True): |
| try: |
| cls.dckr.remove_container(name, force = force) |
| except: pass |
| |
| def exists(self): |
| return '/{0}'.format(self.name) in list(flatten(n['Names'] for n in self.dckr.containers())) |
| |
| def img_exists(self): |
| return self.image_name in [ctn['RepoTags'][0] if ctn['RepoTags'] else '' for ctn in self.dckr.images()] |
| |
| def ip(self): |
| cnt_list = filter(lambda c: c['Names'][0] == '/{}'.format(self.name), self.dckr.containers()) |
| #if not cnt_list: |
| # cnt_list = filter(lambda c: c['Image'] == self.image_name, self.dckr.containers()) |
| cnt_settings = cnt_list.pop() |
| return cnt_settings['NetworkSettings']['Networks']['bridge']['IPAddress'] |
| |
| @classmethod |
| def ips(cls, image_name): |
| cnt_list = filter(lambda c: c['Image'] == image_name, cls.dckr.containers()) |
| ips = [ cnt['NetworkSettings']['Networks']['bridge']['IPAddress'] for cnt in cnt_list ] |
| return ips |
| |
| def kill(self, remove = True): |
| self.dckr.kill(self.name) |
| self.dckr.remove_container(self.name, force=True) |
| |
| def start(self, rm = True, ports = None, volumes = None, host_config = None, |
| environment = None, tty = False, stdin_open = True): |
| |
| if rm and self.exists(): |
| print('Removing container:', self.name) |
| self.dckr.remove_container(self.name, force=True) |
| |
| ctn = self.dckr.create_container(image=self.image_name, ports = ports, command=self.command, |
| detach=True, name=self.name, |
| environment = environment, |
| volumes = volumes, |
| host_config = host_config, stdin_open=stdin_open, tty = tty) |
| self.dckr.start(container=self.name) |
| if self.quagga_config: |
| self.connect_to_br() |
| self.id = ctn['Id'] |
| return ctn |
| |
| def connect_to_br(self): |
| index = 0 |
| with docker_netns(self.name) as pid: |
| for quagga_config in self.quagga_config: |
| ip = IPRoute() |
| br = ip.link_lookup(ifname=quagga_config['bridge']) |
| if len(br) == 0: |
| ip.link_create(ifname=quagga_config['bridge'], kind='bridge') |
| br = ip.link_lookup(ifname=quagga_config['bridge']) |
| br = br[0] |
| ip.link('set', index=br, state='up') |
| ifname = '{0}-{1}'.format(self.name, index) |
| ifs = ip.link_lookup(ifname=ifname) |
| if len(ifs) > 0: |
| ip.link_remove(ifs[0]) |
| peer_ifname = '{0}-{1}'.format(pid, index) |
| ip.link_create(ifname=ifname, kind='veth', peer=peer_ifname) |
| host = ip.link_lookup(ifname=ifname)[0] |
| ip.link('set', index=host, master=br) |
| ip.link('set', index=host, state='up') |
| guest = ip.link_lookup(ifname=peer_ifname)[0] |
| ip.link('set', index=guest, net_ns_fd=pid) |
| with Namespace(pid, 'net'): |
| ip = IPRoute() |
| ip.link('set', index=guest, ifname='eth{}'.format(index+1)) |
| ip.addr('add', index=guest, address=quagga_config['ip'], mask=quagga_config['mask']) |
| ip.link('set', index=guest, state='up') |
| index += 1 |
| |
| def execute(self, cmd, tty = True, stream = False, shell = False): |
| res = 0 |
| if type(cmd) == str: |
| cmds = (cmd,) |
| else: |
| cmds = cmd |
| if shell: |
| for c in cmds: |
| res += os.system('docker exec {0} {1}'.format(self.name, c)) |
| return res |
| for c in cmds: |
| i = self.dckr.exec_create(container=self.name, cmd=c, tty = tty, privileged = True) |
| self.dckr.exec_start(i['Id'], stream = stream, detach=True) |
| result = self.dckr.exec_inspect(i['Id']) |
| res += 0 if result['ExitCode'] == None else result['ExitCode'] |
| return res |
| |
| def restart(self, timeout =10): |
| return self.dckr.restart(self.name, timeout) |
| |
| def get_mem(): |
| with open('/proc/meminfo', 'r') as fd: |
| meminfo = fd.readlines() |
| mem = 0 |
| for m in meminfo: |
| if m.startswith('MemTotal:') or m.startswith('SwapTotal:'): |
| mem += int(m.split(':')[1].strip().split()[0]) |
| |
| mem = max(mem/1024/1024/2, 1) |
| mem = min(mem, 16) |
| return str(mem) + 'G' |
| |
| class OnosCord(Container): |
| """Use this when running the cord tester agent on the onos compute node""" |
| onos_cord_dir = os.path.join(os.getenv('HOME'), 'cord-tester-cord') |
| onos_config_dir_guest = '/root/onos/config' |
| onos_config_dir = os.path.join(onos_cord_dir, 'config') |
| docker_yaml = os.path.join(onos_cord_dir, 'docker-compose.yml') |
| |
| def __init__(self, onos_ip, conf, boot_delay = 60): |
| self.onos_ip = onos_ip |
| self.cord_conf_dir = conf |
| self.boot_delay = boot_delay |
| if os.access(self.cord_conf_dir, os.F_OK) and not os.access(self.onos_cord_dir, os.F_OK): |
| os.mkdir(self.onos_cord_dir) |
| os.mkdir(self.onos_config_dir) |
| ##copy the config file from cord-tester-config |
| cmd = 'cp {}/* {}'.format(self.cord_conf_dir, self.onos_cord_dir) |
| os.system(cmd) |
| |
| ##update the docker yaml with the config volume |
| with open(self.docker_yaml, 'r') as f: |
| yaml_config = yaml.load(f) |
| image = yaml_config['services'].keys()[0] |
| name = 'cordtestercord_{}_1'.format(image) |
| volumes = yaml_config['services'][image]['volumes'] |
| config_volumes = filter(lambda e: e.find(self.onos_config_dir_guest) >= 0, volumes) |
| if not config_volumes: |
| config_volume = '{}:{}'.format(self.onos_config_dir, self.onos_config_dir_guest) |
| volumes.append(config_volume) |
| docker_yaml_changed = '{}-changed'.format(self.docker_yaml) |
| with open(docker_yaml_changed, 'w') as wf: |
| yaml.dump(yaml_config, wf) |
| |
| os.rename(docker_yaml_changed, self.docker_yaml) |
| self.volumes = volumes |
| |
| super(OnosCord, self).__init__(name, image, tag = '') |
| cord_conf_dir_basename = os.path.basename(self.cord_conf_dir.replace('-', '')) |
| self.xos_onos_name = '{}_{}_1'.format(cord_conf_dir_basename, image) |
| ##Create an container instance of xos onos |
| self.xos_onos = Container(self.xos_onos_name, image, tag = '') |
| |
| def start(self, restart = False, network_cfg = None): |
| if restart is True: |
| if self.exists(): |
| ##Kill the existing instance |
| print('Killing container %s' %self.name) |
| self.kill() |
| if self.xos_onos.exists(): |
| print('Killing container %s' %self.xos_onos.name) |
| self.xos_onos.kill() |
| |
| if network_cfg is not None: |
| json_data = json.dumps(network_cfg, indent=4) |
| with open('{}/network-cfg.json'.format(self.onos_config_dir), 'w') as f: |
| f.write(json_data) |
| |
| #start the container using docker-compose |
| cmd = 'cd {} && docker-compose up -d'.format(self.onos_cord_dir) |
| os.system(cmd) |
| #Delay to make sure ONOS fully boots |
| time.sleep(self.boot_delay) |
| Onos.install_cord_apps(onos_ip = self.onos_ip) |
| |
| def build_image(self): |
| build_cmd = 'cd {} && docker-compose build'.format(self.onos_cord_dir) |
| os.system(build_cmd) |
| |
| class Onos(Container): |
| |
| quagga_config = ( { 'bridge' : 'quagga-br', 'ip': '10.10.0.4', 'mask' : 16 }, ) |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| JAVA_OPTS = '-Xms{} -Xmx{} -XX:+UseConcMarkSweepGC -XX:+CMSIncrementalMode'.format(*SYSTEM_MEMORY)#-XX:+PrintGCDetails -XX:+PrintGCTimeStamps' |
| env = { 'ONOS_APPS' : 'drivers,openflow,proxyarp,vrouter', 'JAVA_OPTS' : JAVA_OPTS } |
| onos_cord_apps = ( ('cord-config', '1.0-SNAPSHOT'), |
| ('aaa', '1.0-SNAPSHOT'), |
| ('igmp', '1.0-SNAPSHOT'), |
| #('vtn', '1.0-SNAPSHOT'), |
| ) |
| ports = [ 8181, 8101, 9876, 6653, 6633, 2000, 2620 ] |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| host_config_dir = os.path.join(setup_dir, 'onos-config') |
| guest_config_dir = '/root/onos/config' |
| onos_gen_partitions = os.path.join(setup_dir, 'onos-gen-partitions') |
| onos_form_cluster = os.path.join(setup_dir, 'onos-form-cluster') |
| cord_apps_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'apps') |
| host_guest_map = ( (host_config_dir, guest_config_dir), ) |
| cluster_cfg = os.path.join(host_config_dir, 'cluster.json') |
| cluster_mode = False |
| cluster_instances = [] |
| NAME = 'cord-onos' |
| ##the ip of ONOS in default cluster.json in setup/onos-config |
| CLUSTER_CFG_IP = '172.17.0.2' |
| IMAGE = 'onosproject/onos' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| @classmethod |
| def generate_cluster_cfg(cls, ip): |
| if type(ip) in [ list, tuple ]: |
| ips = ' '.join(ip) |
| else: |
| ips = ip |
| try: |
| cmd = '{} {} {}'.format(cls.onos_gen_partitions, cls.cluster_cfg, ips) |
| os.system(cmd) |
| except: pass |
| |
| @classmethod |
| def form_cluster(cls, ips): |
| nodes = ' '.join(ips) |
| try: |
| cmd = '{} {}'.format(cls.onos_form_cluster, nodes) |
| os.system(cmd) |
| except: pass |
| |
| @classmethod |
| def cleanup_runtime(cls): |
| '''Cleanup ONOS runtime generated files''' |
| files = ( Onos.cluster_cfg, os.path.join(Onos.host_config_dir, 'network-cfg.json') ) |
| for f in files: |
| if os.access(f, os.F_OK): |
| try: |
| os.unlink(f) |
| except: pass |
| |
| def __init__(self, name = NAME, image = 'onosproject/onos', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, cluster = False): |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Onos, self).__init__(name, image, prefix = prefix, tag = tag, quagga_config = self.quagga_config) |
| self.boot_delay = boot_delay |
| if cluster is True: |
| self.ports = [] |
| if os.access(self.cluster_cfg, os.F_OK): |
| try: |
| os.unlink(self.cluster_cfg) |
| except: pass |
| |
| self.host_config = self.create_host_config(port_list = self.ports, |
| host_guest_map = self.host_guest_map) |
| self.volumes = [] |
| for _,g in self.host_guest_map: |
| self.volumes.append(g) |
| |
| if restart is True and self.exists(): |
| self.kill() |
| |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports, |
| host_guest_map = self.host_guest_map) |
| volumes = [] |
| for _,g in self.host_guest_map: |
| volumes.append(g) |
| if network_cfg is not None: |
| json_data = json.dumps(network_cfg, indent=4) |
| with open('{}/network-cfg.json'.format(self.host_config_dir), 'w') as f: |
| f.write(json_data) |
| print('Starting ONOS container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, |
| host_config = self.host_config, volumes = self.volumes, tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| ##Just a quick hack/check to ensure we don't regenerate in the common case. |
| ##As ONOS is usually the first test container that is started |
| if cluster is False: |
| if ip != self.CLUSTER_CFG_IP or not os.access(self.cluster_cfg, os.F_OK): |
| print('Regenerating ONOS cluster cfg for ip %s' %ip) |
| self.generate_cluster_cfg(ip) |
| self.kill() |
| self.remove_container(self.name, force=True) |
| print('Restarting ONOS container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, |
| host_config = self.host_config, volumes = self.volumes, tty = True) |
| print('Waiting %d seconds for ONOS to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| self.ipaddr = self.ip() |
| if cluster is False: |
| self.install_cord_apps(self.ipaddr) |
| |
| @classmethod |
| def setup_cluster_deprecated(cls, onos_instances, image_name = None): |
| if not onos_instances or len(onos_instances) < 2: |
| return |
| ips = [] |
| if image_name is not None: |
| ips = Container.ips(image_name) |
| else: |
| for onos in onos_instances: |
| ips.append(onos.ipaddr) |
| Onos.cluster_instances = onos_instances |
| Onos.cluster_mode = True |
| ##regenerate the cluster json with the 3 instance ips before restarting them back |
| print('Generating cluster cfg for ONOS instances with ips %s' %ips) |
| Onos.generate_cluster_cfg(ips) |
| for onos in onos_instances: |
| onos.kill() |
| onos.remove_container(onos.name, force=True) |
| print('Restarting ONOS container %s for forming cluster' %onos.name) |
| onos.start(ports = onos.ports, environment = onos.env, |
| host_config = onos.host_config, volumes = onos.volumes, tty = True) |
| print('Waiting %d seconds for ONOS %s to boot' %(onos.boot_delay, onos.name)) |
| time.sleep(onos.boot_delay) |
| onos.ipaddr = onos.ip() |
| onos.install_cord_apps(onos.ipaddr) |
| |
| @classmethod |
| def setup_cluster(cls, onos_instances, image_name = None): |
| if not onos_instances or len(onos_instances) < 2: |
| return |
| ips = [] |
| if image_name is not None: |
| ips = Container.ips(image_name) |
| else: |
| for onos in onos_instances: |
| ips.append(onos.ipaddr) |
| Onos.cluster_instances = onos_instances |
| Onos.cluster_mode = True |
| ##regenerate the cluster json with the 3 instance ips before restarting them back |
| print('Forming cluster for ONOS instances with ips %s' %ips) |
| Onos.form_cluster(ips) |
| ##wait for the cluster to be formed |
| print('Waiting for the cluster to be formed') |
| time.sleep(60) |
| for onos in onos_instances: |
| onos.install_cord_apps(onos.ipaddr) |
| |
| @classmethod |
| def restart_cluster(cls, network_cfg = None): |
| if cls.cluster_mode is False: |
| return |
| if not cls.cluster_instances: |
| return |
| |
| if network_cfg is not None: |
| json_data = json.dumps(network_cfg, indent=4) |
| with open('{}/network-cfg.json'.format(cls.host_config_dir), 'w') as f: |
| f.write(json_data) |
| |
| for onos in cls.cluster_instances: |
| if onos.exists(): |
| onos.kill() |
| onos.remove_container(onos.name, force=True) |
| print('Restarting ONOS container %s' %onos.name) |
| onos.start(ports = onos.ports, environment = onos.env, |
| host_config = onos.host_config, volumes = onos.volumes, tty = True) |
| print('Waiting %d seconds for ONOS %s to boot' %(onos.boot_delay, onos.name)) |
| time.sleep(onos.boot_delay) |
| onos.ipaddr = onos.ip() |
| |
| ##form the cluster |
| cls.setup_cluster(cls.cluster_instances) |
| |
| @classmethod |
| def cluster_ips(cls): |
| if cls.cluster_mode is False: |
| return [] |
| if not cls.cluster_instances: |
| return [] |
| ips = [ onos.ipaddr for onos in cls.cluster_instances ] |
| return ips |
| |
| @classmethod |
| def cleanup_cluster(cls): |
| if cls.cluster_mode is False: |
| return |
| if not cls.cluster_instances: |
| return |
| for onos in cls.cluster_instances: |
| if onos.exists(): |
| onos.kill() |
| onos.remove_container(onos.name, force=True) |
| |
| @classmethod |
| def install_cord_apps(cls, onos_ip = None): |
| for app, version in cls.onos_cord_apps: |
| app_file = '{}/{}-{}.oar'.format(cls.cord_apps_dir, app, version) |
| ok, code = OnosCtrl.install_app(app_file, onos_ip = onos_ip) |
| ##app already installed (conflicts) |
| if code in [ 409 ]: |
| ok = True |
| print('ONOS app %s, version %s %s' %(app, version, 'installed' if ok else 'failed to install')) |
| time.sleep(2) |
| |
| class Radius(Container): |
| ports = [ 1812, 1813 ] |
| env = {'TIMEZONE':'America/Los_Angeles', |
| 'DEBUG': 'true', 'cert_password':'whatever', 'primary_shared_secret':'radius_password' |
| } |
| host_db_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup/radius-config/db') |
| guest_db_dir = os.path.join(os.path.sep, 'opt', 'db') |
| host_config_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup/radius-config/freeradius') |
| guest_config_dir = os.path.join(os.path.sep, 'etc', 'freeradius') |
| start_command = os.path.join(guest_config_dir, 'start-radius.py') |
| host_guest_map = ( (host_db_dir, guest_db_dir), |
| (host_config_dir, guest_config_dir) |
| ) |
| IMAGE = 'cord-test/radius' |
| NAME = 'cord-radius' |
| |
| def __init__(self, name = NAME, image = IMAGE, prefix = '', tag = 'candidate', |
| boot_delay = 10, restart = False, update = False): |
| super(Radius, self).__init__(name, image, prefix = prefix, tag = tag, command = self.start_command) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports, |
| host_guest_map = self.host_guest_map) |
| volumes = [] |
| for _,g in self.host_guest_map: |
| volumes.append(g) |
| self.start(ports = self.ports, environment = self.env, |
| volumes = volumes, |
| host_config = host_config, tty = True) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building Radius image %s' %image) |
| dockerfile = ''' |
| FROM hbouvier/docker-radius |
| MAINTAINER chetan@ciena.com |
| LABEL RUN docker pull hbouvier/docker-radius |
| LABEL RUN docker run -it --name cord-radius hbouvier/docker-radius |
| RUN apt-get update && \ |
| apt-get -y install python python-pexpect strace |
| WORKDIR /root |
| CMD ["/etc/freeradius/start-radius.py"] |
| ''' |
| super(Radius, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Quagga(Container): |
| quagga_config = ( { 'bridge' : 'quagga-br', 'ip': '10.10.0.3', 'mask' : 16 }, |
| { 'bridge' : 'quagga-br', 'ip': '192.168.10.3', 'mask': 16 }, |
| ) |
| ports = [ 179, 2601, 2602, 2603, 2604, 2605, 2606 ] |
| host_quagga_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup/quagga-config') |
| guest_quagga_config = '/root/config' |
| quagga_config_file = os.path.join(guest_quagga_config, 'testrib.conf') |
| host_guest_map = ( (host_quagga_config, guest_quagga_config), ) |
| IMAGE = 'cord-test/quagga' |
| NAME = 'cord-quagga' |
| |
| def __init__(self, name = NAME, image = IMAGE, prefix = '', tag = 'candidate', |
| boot_delay = 15, restart = False, config_file = quagga_config_file, update = False): |
| super(Quagga, self).__init__(name, image, prefix = prefix, tag = tag, quagga_config = self.quagga_config) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports, |
| host_guest_map = self.host_guest_map, |
| privileged = True) |
| volumes = [] |
| for _,g in self.host_guest_map: |
| volumes.append(g) |
| self.start(ports = self.ports, |
| host_config = host_config, |
| volumes = volumes, tty = True) |
| print('Starting Quagga on container %s' %self.name) |
| self.execute('{0}/start.sh {1}'.format(self.guest_quagga_config, config_file)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| onos_quagga_ip = Onos.quagga_config[0]['ip'] |
| print('Building Quagga image %s' %image) |
| dockerfile = ''' |
| FROM ubuntu:14.04 |
| MAINTAINER chetan@ciena.com |
| WORKDIR /root |
| RUN useradd -M quagga |
| RUN mkdir /var/log/quagga && chown quagga:quagga /var/log/quagga |
| RUN mkdir /var/run/quagga && chown quagga:quagga /var/run/quagga |
| RUN apt-get update && apt-get install -qy git autoconf libtool gawk make telnet libreadline6-dev |
| RUN git clone git://git.savannah.nongnu.org/quagga.git quagga && \ |
| (cd quagga && git checkout HEAD && ./bootstrap.sh && \ |
| sed -i -r 's,htonl.*?\(INADDR_LOOPBACK\),inet_addr\("{0}"\),g' zebra/zebra_fpm.c && \ |
| ./configure --enable-fpm --disable-doc --localstatedir=/var/run/quagga && make && make install) |
| RUN ldconfig |
| '''.format(onos_quagga_ip) |
| super(Quagga, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| def reinitContainerClients(): |
| docker_netns.dckr = Client() |
| Container.dckr = Client() |
| |
| class Xos(Container): |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name, image, dockerfile = None, prefix = PREFIX, tag = TAG, |
| boot_delay = 30, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, check github repo') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| print('Waiting %d seconds for XOS Base Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS base image %s' %image) |
| super(Xos, cls).build_image(self.dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_base(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8000,9998,9999 ] |
| env = { 'XOS_GIT_REPO' : 'https://github.com/opencord/xos.git', 'XOS_GIT_BRANCH' : 'master', 'NG_XOS_LIB_URL' : ' https://github.com/opencord/ng-xos-lib.git', 'NG_XOS_LIB_VERSION' : '1.0.0',} |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos-base' |
| IMAGE = 'xosproject/xos-base' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-base', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_base, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS base container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS Base Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS base image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-base |
| MAINTAINER chetan@ciena.com |
| ADD local_certs.crt /usr/local/share/ca-certificates/local_certs.crt |
| RUN update-ca-certificates |
| RUN git clone $XOS_GIT_REPO -b $XOS_GIT_BRANCH /tmp/xos && \ |
| mv /tmp/xos/xos /opt/ && \ |
| chmod +x /opt/xos/tools/xos-manage && \ |
| /opt/xos/tools/xos-manage genkeys |
| |
| RUN git clone $NG_XOS_LIB_URL /tmp/ng-xos-lib |
| RUN cd /tmp/ng-xos-lib && git checkout tags/$NG_XOS_LIB_VERSION |
| RUN cp /tmp/ng-xos-lib/dist/ngXosHelpers.min.js /opt/xos/core/xoslib/static/vendor/ |
| RUN cp /tmp/ng-xos-lib/dist/ngXosVendor.min.js /opt/xos/core/xoslib/static/vendor/ |
| WORKDIR /opt/xos |
| CMD python /opt/xos/manage.py runserver 0.0.0.0:8000 --insecure --makemigrations |
| ''' |
| super(Xos_base, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_sync_openstack(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 2375 ] |
| env = {'DOCKER_URL' : 'https://get.docker.com/builds/Linux/x86_64/docker-1.10.3', 'DOCKER_SHA256' : 'd0df512afa109006a450f41873634951e19ddabf8c7bd419caeb5a526032d86d', 'DOCKER_COMPOSE_URL' : ' https://github.com/docker/compose/releases/download/1.5.2/docker-compose-Linux-x86_64', 'DOCKER_COMPOSE_SHA256' : ' b6b975badc5389647ef1c16fe8a33bdc5935c61f6afd5a15a28ff765427d01e3' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos-openstack' |
| IMAGE = 'xosproject/xos-synchronizer-openstack' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-synchronizer-openstack', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_sync_openstack, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS Synchronizer Openstack container %s' %self.name) |
| self.start(environment = self.env, |
| tty = True) |
| if not restart: |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS Synchronizer Openstack Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer Openstack image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-synchronizer-openstack |
| RUN curl -fLsS $DOCKER_URL -o docker && \ |
| echo "${DOCKER_SHA256} docker" | sha256sum -c - && \ |
| mv docker /usr/local/bin/docker && \ |
| chmod +x /usr/local/bin/docker |
| RUN curl -fLsS $DOCKER_COMPOSE_URL -o docker-compose && \ |
| echo "${DOCKER_COMPOSE_SHA256} docker-compose" | sha256sum -c - && \ |
| mv docker-compose /usr/local/bin/docker-compose && \ |
| chmod +x /usr/local/bin/docker-compose |
| CMD /usr/bin/supervisord -c /etc/supervisor/conf.d/synchronizer.conf |
| ''' |
| super(Xos_sync_openstack, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_openvpn(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [8000] |
| env = {'DOCKER_URL' : 'https://get.docker.com/builds/Linux/x86_64/docker-1.10.3', 'DOCKER_SHA256' : 'd0df512afa109006a450f41873634951e19ddabf8c7bd419caeb5a526032d86d', 'DOCKER_COMPOSE_URL' : ' https://github.com/docker/compose/releases/download/1.5.2/docker-compose-Linux-x86_64', 'DOCKER_COMPOSE_SHA256' : ' b6b975badc5389647ef1c16fe8a33bdc5935c61f6afd5a15a28ff765427d01e3' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'openvpn' |
| IMAGE = 'xosproject/xos-synchronizer-openstack' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-synchronizer-openstack', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_openvpn, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS Openvpn container %s' %self.name) |
| self.start(ports = self.ports, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS Openvpn Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer Openstack image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-synchronizer-openstack |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y \ |
| openvpn |
| RUN mkdir -p /opt/openvpn |
| RUN chmod 777 /opt/openvpn |
| RUN git clone https://github.com/OpenVPN/easy-rsa.git /opt/openvpn |
| RUN git -C /opt/openvpn pull origin master |
| RUN echo 'set_var EASYRSA "/opt/openvpn/easyrsa3"' | tee /opt/openvpn/vars |
| RUN echo 'set_var EASYRSA_BATCH "true"' | tee -a /opt/openvpn/vars |
| ''' |
| super(Xos_openvpn, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_postgresql(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 5432 ] |
| NAME = 'xos-postgresql' |
| IMAGE = 'xosproject/xos-postgres' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'ubuntu', prefix = '', tag = '14.04', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_postgresql, self).__init__(name, image, prefix = prefix, tag = tag) |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| volumes = ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"] |
| print('Starting Xos postgresql container %s' %self.name) |
| self.start(ports = self.ports, host_config = host_config, volumes = volumes, tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for Xos postgresql to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS postgresql image %s' %image) |
| dockerfile = ''' |
| FROM ubuntu:14.04 |
| RUN apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys B97B0AFCAA1A47F044F244A07FCC7D46ACCC4CF8 |
| RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main" > /etc/apt/sources.list.d/pgdg.list |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| python-software-properties \ |
| software-properties-common \ |
| postgresql-9.3 \ |
| postgresql-client-9.3 \ |
| postgresql-contrib-9.3 |
| |
| RUN mkdir /etc/ssl/private-copy; mv /etc/ssl/private/* /etc/ssl/private-copy/; rm -r /etc/ssl/private; mv /etc/ssl/private-copy /etc/ssl/private; chmod -R 0700 /etc/ssl/private; chown -R postgres /etc/ssl/private |
| USER postgres |
| RUN /etc/init.d/postgresql start && \ |
| psql --command "ALTER USER postgres WITH SUPERUSER PASSWORD 'password' " && \ |
| psql --command "CREATE DATABASE xos" |
| RUN echo "host all all 0.0.0.0/0 md5" >> /etc/postgresql/9.3/main/pg_hba.conf |
| RUN echo "host all all 0.0.0.0/0 password" >> /etc/postgresql/9.3/main/pg_hba.conf |
| RUN echo "listen_addresses='*'" >> /etc/postgresql/9.3/main/postgresql.conf |
| VOLUME ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"] |
| CMD ["/usr/lib/postgresql/9.3/bin/postgres", "-D", "/var/lib/postgresql/9.3/main", "-c", "config_file=/etc/postgresql/9.3/main/postgresql.conf"] |
| ''' |
| super(Xos_postgresql, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_synchronizer(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8000 ] |
| env = { 'XOS_GIT_REPO' : 'https://github.com/opencord/xos.git', 'XOS_GIT_BRANCH' : 'master', 'NG_XOS_LIB_URL' : ' https://github.com/opencord/ng-xos-lib.git', 'NG_XOS_LIB_VERSION' : '1.0.0',} |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos' |
| IMAGE = 'xosproject/xos' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_synchronizer, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS synchronizer container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS Synchronizer Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos |
| MAINTAINER chetan@ciena.com |
| COPY conf/synchronizer.conf /etc/supervisor/conf.d/ |
| CMD /usr/bin/supervisord -c /etc/supervisor/conf.d/synchronizer.conf |
| ''' |
| super(Xos_synchronizer, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_syndicate_ms(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8080 ] |
| env = { 'APT_KEY' : 'butler_opencloud_cs_arizona_edu_pub.gpg', 'MS_PORT': '8080', 'GAE_SDK' : 'google_appengine_1.9.35.zip', 'HOME' : '/home/syndicate' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'syndicate-ms' |
| IMAGE = 'xosproject/syndicate-ms' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'ubuntu', prefix = '', tag = '14.04.4', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_syndicate_ms, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS syndicate-ms container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS syndicate-ms Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Syndicate-ms image %s' %image) |
| dockerfile = ''' |
| FROM ubuntu:14.04.4 |
| MAINTAINER chetan@ciena.com |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| apt-transport-https |
| COPY butler.crt /usr/local/share/ca-certificates |
| RUN update-ca-certificates |
| COPY $APT_KEY /tmp/ |
| RUN apt-key add /tmp/$APT_KEY |
| RUN echo "deb https://butler.opencloud.cs.arizona.edu/repos/release/syndicate syndicate main" > /etc/apt/sources.list.d/butler.list |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| syndicate-core \ |
| syndicate-ms \ |
| wget \ |
| unzip |
| |
| RUN groupadd -r syndicate && useradd -m -r -g syndicate syndicate |
| USER syndicate |
| ENV HOME /home/syndicate |
| WORKDIR $HOME |
| RUN wget -nv https://storage.googleapis.com/appengine-sdks/featured/$GAE_SDK |
| RUN unzip -q $GAE_SDK |
| RUN mkdir $HOME/datastore |
| CMD $HOME/google_appengine/dev_appserver.py --admin_host=0.0.0.0 --host=0.0.0.0 --storage_path=$HOME/datastore --skip_sdk_update_check=true /usr/src/syndicate/ms |
| ''' |
| super(Xos_syndicate_ms, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_sync_vtr(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8080 ] |
| env = { 'APT_KEY' : 'butler_opencloud_cs_arizona_edu_pub.gpg', 'MS_PORT': '8080', 'GAE_SDK' : 'google_appengine_1.9.35.zip', 'HOME' : '/home/syndicate' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos-synchronizer-vtr' |
| IMAGE = 'xosproject/xos-synchronizer-vtr' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-synchronizer-vtr', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_sync_vtr, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS xos-synchronizer-vtr container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS synchronizer-vtr Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer-vtr image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-synchronizer-vtr |
| MAINTAINER chetan@ciena.com |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| apt-transport-https |
| COPY butler.crt /usr/local/share/ca-certificates |
| RUN update-ca-certificates |
| COPY $APT_KEY /tmp/ |
| RUN apt-key add /tmp/$APT_KEY |
| RUN echo "deb https://butler.opencloud.cs.arizona.edu/repos/release/syndicate syndicate main" > /etc/apt/sources.list.d/butler.list |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| syndicate-core \ |
| syndicate-ms \ |
| wget \ |
| unzip |
| |
| RUN groupadd -r syndicate && useradd -m -r -g syndicate syndicate |
| USER syndicate |
| ENV HOME /home/syndicate |
| WORKDIR $HOME |
| RUN wget -nv https://storage.googleapis.com/appengine-sdks/featured/$GAE_SDK |
| RUN unzip -q $GAE_SDK |
| RUN mkdir $HOME/datastore |
| CMD $HOME/google_appengine/dev_appserver.py --admin_host=0.0.0.0 --host=0.0.0.0 --storage_path=$HOME/datastore --skip_sdk_update_check=true /usr/src/syndicate/ms |
| ''' |
| super(Xos_sync_vtr, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_sync_vsg(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8080 ] |
| env = { 'APT_KEY' : 'butler_opencloud_cs_arizona_edu_pub.gpg', 'MS_PORT': '8080', 'GAE_SDK' : 'google_appengine_1.9.35.zip', 'HOME' : '/home/syndicate' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos-synchronizer-vsg' |
| IMAGE = 'xosproject/xos-synchronizer-vsg' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-synchronizer-vsg', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_sync_vsg, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS xos-synchronizer-vsg container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS synchronizer-vsg Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer-vsg image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-synchronizer-vsg |
| MAINTAINER chetan@ciena.com |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| apt-transport-https |
| COPY butler.crt /usr/local/share/ca-certificates |
| RUN update-ca-certificates |
| COPY $APT_KEY /tmp/ |
| RUN apt-key add /tmp/$APT_KEY |
| RUN echo "deb https://butler.opencloud.cs.arizona.edu/repos/release/syndicate syndicate main" > /etc/apt/sources.list.d/butler.list |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| syndicate-core \ |
| syndicate-ms \ |
| wget \ |
| unzip |
| |
| RUN groupadd -r syndicate && useradd -m -r -g syndicate syndicate |
| USER syndicate |
| ENV HOME /home/syndicate |
| WORKDIR $HOME |
| RUN wget -nv https://storage.googleapis.com/appengine-sdks/featured/$GAE_SDK |
| RUN unzip -q $GAE_SDK |
| RUN mkdir $HOME/datastore |
| CMD $HOME/google_appengine/dev_appserver.py --admin_host=0.0.0.0 --host=0.0.0.0 --storage_path=$HOME/datastore --skip_sdk_update_check=true /usr/src/syndicate/ms |
| ''' |
| super(Xos_sync_vsg, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_sync_onos(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8080 ] |
| env = { 'APT_KEY' : 'butler_opencloud_cs_arizona_edu_pub.gpg', 'MS_PORT': '8080', 'GAE_SDK' : 'google_appengine_1.9.35.zip', 'HOME' : '/home/syndicate' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos-synchronizer-onos' |
| IMAGE = 'xosproject/xos-synchronizer-onos' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-synchronizer-onos', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_sync_onos, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS xos-synchronizer-onos container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS synchronizer-onos Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer-onos image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-synchronizer-onos |
| MAINTAINER chetan@ciena.com |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| apt-transport-https |
| COPY butler.crt /usr/local/share/ca-certificates |
| RUN update-ca-certificates |
| COPY $APT_KEY /tmp/ |
| RUN apt-key add /tmp/$APT_KEY |
| RUN echo "deb https://butler.opencloud.cs.arizona.edu/repos/release/syndicate syndicate main" > /etc/apt/sources.list.d/butler.list |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| syndicate-core \ |
| syndicate-ms \ |
| wget \ |
| unzip |
| |
| RUN groupadd -r syndicate && useradd -m -r -g syndicate syndicate |
| USER syndicate |
| ENV HOME /home/syndicate |
| WORKDIR $HOME |
| RUN wget -nv https://storage.googleapis.com/appengine-sdks/featured/$GAE_SDK |
| RUN unzip -q $GAE_SDK |
| RUN mkdir $HOME/datastore |
| CMD $HOME/google_appengine/dev_appserver.py --admin_host=0.0.0.0 --host=0.0.0.0 --storage_path=$HOME/datastore --skip_sdk_update_check=true /usr/src/syndicate/ms |
| ''' |
| super(Xos_sync_onos, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_sync_fabric(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8080 ] |
| env = { 'APT_KEY' : 'butler_opencloud_cs_arizona_edu_pub.gpg', 'MS_PORT': '8080', 'GAE_SDK' : 'google_appengine_1.9.35.zip', 'HOME' : '/home/syndicate' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos-synchronizer-fabric' |
| IMAGE = 'xosproject/xos-synchronizer-fabric' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-synchronizer-fabric', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_sync_fabric, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS xos-synchronizer-fabric container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS synchronizer-fabric Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer-fabric image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-synchronizer-fabric |
| MAINTAINER chetan@ciena.com |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| apt-transport-https |
| COPY butler.crt /usr/local/share/ca-certificates |
| RUN update-ca-certificates |
| COPY $APT_KEY /tmp/ |
| RUN apt-key add /tmp/$APT_KEY |
| RUN echo "deb https://butler.opencloud.cs.arizona.edu/repos/release/syndicate syndicate main" > /etc/apt/sources.list.d/butler.list |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| syndicate-core \ |
| syndicate-ms \ |
| wget \ |
| unzip |
| |
| RUN groupadd -r syndicate && useradd -m -r -g syndicate syndicate |
| USER syndicate |
| ENV HOME /home/syndicate |
| WORKDIR $HOME |
| RUN wget -nv https://storage.googleapis.com/appengine-sdks/featured/$GAE_SDK |
| RUN unzip -q $GAE_SDK |
| RUN mkdir $HOME/datastore |
| CMD $HOME/google_appengine/dev_appserver.py --admin_host=0.0.0.0 --host=0.0.0.0 --storage_path=$HOME/datastore --skip_sdk_update_check=true /usr/src/syndicate/ms |
| ''' |
| super(Xos_sync_fabric, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_sync_vtn(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8080 ] |
| env = { 'APT_KEY' : 'butler_opencloud_cs_arizona_edu_pub.gpg', 'MS_PORT': '8080', 'GAE_SDK' : 'google_appengine_1.9.35.zip', 'HOME' : '/home/syndicate' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos-synchronizer-vtn' |
| IMAGE = 'xosproject/xos-synchronizer-vtn' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-synchronizer-vtn', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_sync_vtn, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS xos-synchronizer-vtn container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS synchronizer-vtn Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer-vtn image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-synchronizer-vtn |
| MAINTAINER chetan@ciena.com |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| apt-transport-https |
| COPY butler.crt /usr/local/share/ca-certificates |
| RUN update-ca-certificates |
| COPY $APT_KEY /tmp/ |
| RUN apt-key add /tmp/$APT_KEY |
| RUN echo "deb https://butler.opencloud.cs.arizona.edu/repos/release/syndicate syndicate main" > /etc/apt/sources.list.d/butler.list |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| syndicate-core \ |
| syndicate-ms \ |
| wget \ |
| unzip |
| |
| RUN groupadd -r syndicate && useradd -m -r -g syndicate syndicate |
| USER syndicate |
| ENV HOME /home/syndicate |
| WORKDIR $HOME |
| RUN wget -nv https://storage.googleapis.com/appengine-sdks/featured/$GAE_SDK |
| RUN unzip -q $GAE_SDK |
| RUN mkdir $HOME/datastore |
| CMD $HOME/google_appengine/dev_appserver.py --admin_host=0.0.0.0 --host=0.0.0.0 --storage_path=$HOME/datastore --skip_sdk_update_check=true /usr/src/syndicate/ms |
| ''' |
| super(Xos_sync_vtn, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| class Xos_sync_onboarding(Container): |
| SYSTEM_MEMORY = (get_mem(),) * 2 |
| ports = [ 8080 ] |
| env = { 'APT_KEY' : 'butler_opencloud_cs_arizona_edu_pub.gpg', 'MS_PORT': '8080', 'GAE_SDK' : 'google_appengine_1.9.35.zip', 'HOME' : '/home/syndicate' } |
| setup_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'setup') |
| NAME = 'xos-synchronizer-onboarding' |
| IMAGE = 'xosproject/xos-synchronizer-onboarding' |
| TAG = 'latest' |
| PREFIX = '' |
| |
| def __init__(self, name = NAME, image = 'xosproject/xos-synchronizer-onboarding', prefix = '', tag = 'latest', |
| boot_delay = 60, restart = False, network_cfg = None, update = False): |
| GITHUB_ERROR = False |
| if restart is True: |
| ##Find the right image to restart |
| running_image = filter(lambda c: c['Names'][0] == '/{}'.format(name), self.dckr.containers()) |
| if running_image: |
| image_name = running_image[0]['Image'] |
| try: |
| image = image_name.split(':')[0] |
| tag = image_name.split(':')[1] |
| except: pass |
| |
| super(Xos_sync_onboarding, self).__init__(name, image, prefix = prefix, tag = tag) |
| if update is True or not self.img_exists(): |
| self.build_image(self.image_name) |
| if not self.img_exists(): |
| print ('Xos base container image is not built on host, have to check github repository ') |
| GITHUB_ERROR = True |
| if GITHUB_ERROR is not True: |
| if restart is True and self.exists(): |
| self.kill() |
| if not self.exists(): |
| self.remove_container(name, force=True) |
| host_config = self.create_host_config(port_list = self.ports) |
| print('Starting XOS xos-synchronizer-onboarding container %s' %self.name) |
| self.start(ports = self.ports, environment = self.env, host_config = host_config, |
| tty = True) |
| if not restart: |
| ##wait a bit before fetching IP to regenerate cluster cfg |
| time.sleep(5) |
| ip = self.ip() |
| print('Waiting %d seconds for XOS synchronizer-onboarding Container to boot' %(boot_delay)) |
| time.sleep(boot_delay) |
| |
| @classmethod |
| def build_image(cls, image): |
| print('Building XOS Synchronizer-onboarding image %s' %image) |
| dockerfile = ''' |
| FROM xosproject/xos-synchronizer-onboarding |
| MAINTAINER chetan@ciena.com |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| apt-transport-https |
| COPY butler.crt /usr/local/share/ca-certificates |
| RUN update-ca-certificates |
| COPY $APT_KEY /tmp/ |
| RUN apt-key add /tmp/$APT_KEY |
| RUN echo "deb https://butler.opencloud.cs.arizona.edu/repos/release/syndicate syndicate main" > /etc/apt/sources.list.d/butler.list |
| RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --force-yes\ |
| syndicate-core \ |
| syndicate-ms \ |
| wget \ |
| unzip |
| |
| RUN groupadd -r syndicate && useradd -m -r -g syndicate syndicate |
| USER syndicate |
| ENV HOME /home/syndicate |
| WORKDIR $HOME |
| RUN wget -nv https://storage.googleapis.com/appengine-sdks/featured/$GAE_SDK |
| RUN unzip -q $GAE_SDK |
| RUN mkdir $HOME/datastore |
| CMD $HOME/google_appengine/dev_appserver.py --admin_host=0.0.0.0 --host=0.0.0.0 --storage_path=$HOME/datastore --skip_sdk_update_check=true /usr/src/syndicate/ms |
| ''' |
| super(Xos_sync_onboarding, cls).build_image(dockerfile, image) |
| print('Done building image %s' %image) |
| |
| |