def _get_host(id_or_name):
if id_or_name.isdigit():
host = Host.get(id_or_name)
else:
host = Host.get_by_name(id_or_name)
if not host:
abort(404, 'Host %s not found' % id_or_name)
return host
def test_get_max_container_count_single_host(test_db):
pod = Pod.create('pod', 'pod', 10, -1)
Host.create(pod, random_ipv4(), random_string(), random_uuid(), 64, 4096)
assert get_max_container_count(pod, ncore=1, nshare=0) == 64
assert get_max_container_count(pod, ncore=2, nshare=0) == 32
assert get_max_container_count(pod, ncore=3, nshare=0) == 21
assert get_max_container_count(pod, ncore=4, nshare=0) == 16
assert get_max_container_count(pod, ncore=5, nshare=0) == 12
assert get_max_container_count(pod, ncore=1, nshare=5) == 42
assert get_max_container_count(pod, ncore=2, nshare=5) == 25
def test_get_max_container_count_single_host(test_db):
pod = Pod.create('pod', 'pod', 10, -1)
Host.create(pod, random_ipv4(), random_string(), random_uuid(), 64, 4096)
assert get_max_container_count(pod, ncore=1, nshare=0) == 64
assert get_max_container_count(pod, ncore=2, nshare=0) == 32
assert get_max_container_count(pod, ncore=3, nshare=0) == 21
assert get_max_container_count(pod, ncore=4, nshare=0) == 16
assert get_max_container_count(pod, ncore=5, nshare=0) == 12
assert get_max_container_count(pod, ncore=1, nshare=5) == 42
assert get_max_container_count(pod, ncore=2, nshare=5) == 25
def test_container_release_cores(test_db):
a = App.get_or_create('app', 'http://git.hunantv.com/group/app.git')
v = a.add_version(random_sha1())
p = Pod.create('pod', 'pod', 10, -1)
host = Host.create(p, random_ipv4(), random_string(), random_uuid(), 200, 0)
for core in host.cores:
assert core.host_id == host.id
assert core.remain == 10
containers = []
cores = sorted(host.cores, key=operator.attrgetter('label'))
for fcores, pcores in zip(chunked(cores[:100], 10), chunked(cores[100:], 10)):
used_cores = {'full': fcores, 'part': pcores}
host.occupy_cores(used_cores, 5)
c = Container.create(random_sha1(), host, v, random_string(), 'entrypoint', used_cores, 'env', nshare=5)
containers.append(c)
cores = sorted(host.cores, key=operator.attrgetter('label'))
for fcores, pcores in zip(chunked(cores[:100], 10), chunked(cores[100:], 10)):
for core in fcores:
assert core.remain == 0
for core in pcores:
assert core.remain == 5
for c in containers:
c.delete()
cores = sorted(host.cores, key=operator.attrgetter('label'))
for fcores, pcores in zip(chunked(cores[:100], 10), chunked(cores[100:], 10)):
for core in fcores:
assert core.remain == 10
for core in pcores:
assert core.remain == 10
def create_host():
"""为了文件, 只好不用json了"""
addr = request.form.get('addr', default='')
pod_name = request.form.get('pod_name', default='')
if not (addr and pod_name):
abort(400, 'Need addr and pod_name')
pod = Pod.get_by_name(pod_name)
if not pod:
abort(400, 'No pod found')
# 存证书, 没有就算了
if all(k in request.files for k in ['ca', 'cert', 'key']):
try:
ca, cert, key = request.files['ca'], request.files['cert'], request.files['key']
save_docker_certs(addr.split(':', 1)[0], ca.read(), cert.read(), key.read())
finally:
ca.close()
cert.close()
key.close()
try:
client = get_docker_client(addr, force_flush=True)
info = client.info()
except Exception as e:
abort(400, 'Docker daemon error on host %s, error: %s' % (addr, e.message))
if not Host.create(pod, addr, info['Name'], info['ID'], info['NCPU'], info['MemTotal']):
abort(400, 'Host create error.')
return 201, {'r':0, 'msg': consts.OK}
def create_host():
"""为了文件, 只好不用json了"""
addr = request.form.get('addr', default='')
ip = addr.split(':', 1)[0]
podname = request.form.get('podname', default='')
is_public = request.form.get('is_public', default=False, type=bool)
if not (addr and podname):
abort(400, 'Bad addr or podname: addr="{}", podname="{}"'.format(addr, podname))
pod = Pod.get_by_name(podname)
if not pod:
abort(400, 'Pod {} not found'.format(podname))
# 存证书, 没有就算了
certs = ['ca', 'cert', 'key']
if all(k in request.files for k in certs):
certs_contents = tuple(request.files[f].read() for f in certs)
save_docker_certs(ip, *certs_contents)
try:
client = get_docker_client(addr, force_flush=True)
info = client.info()
except Exception as e:
abort(400, 'Docker daemon error on host %s, error: %s' % (addr, e.message))
if not Host.create(pod, addr, info['Name'], info['ID'], info['NCPU'],
info['MemTotal'], is_public=is_public):
abort(400, 'Error while creating host')
return 201, DEFAULT_RETURN_VALUE
def build_image_v2():
# form post
appname = request.form.get('appname', default='')
version = request.form.get('version', default='')
base = request.form.get('base', default='')
if not base:
abort(400, 'base image must be set')
_, version = _get_app_and_version(appname, version)
if ':' not in base:
base = base + ':latest'
host = Host.get_random_public_host()
if not host:
abort(406, 'no host is available')
# if no artifacts.zip is set
# ignore and just do the cloning and building
file_path = None
if 'artifacts.zip' in request.files:
f = request.files['artifacts.zip']
file_path = os.path.join(tempfile.mkdtemp(), secure_filename(f.filename))
f.save(file_path)
task = Task.create(TASK_BUILD, version, host, {'base': base})
build_docker_image.apply_async(
args=(task.id, base, file_path),
task_id='task:%d' % task.id
)
return {'task': task.id, 'watch_key': task.result_key}
def create_local_test_data(private=False):
appyaml = {
'appname': 'blueberry',
'entrypoints': {
'web': {
'cmd': 'python app.py',
'ports': ['5000/tcp'],
},
'daemon': {
'cmd': 'python daemon.py',
},
'service': {
'cmd': 'python service.py'
},
},
'build': 'pip install -r ./requirements.txt',
}
app = App.get_or_create('blueberry', 'http://git.hunantv.com/tonic/blueberry.git', 'token')
version = app.add_version('abe23812aeb50a17a2509c02a28423462161d306')
appconfig = version.appconfig
appconfig.update(**appyaml)
appconfig.save()
group = Group.create('group', 'group')
pod = Pod.create('pod', 'pod')
pod.assigned_to_group(group)
c = docker.Client(**kwargs_from_env(assert_hostname=False))
r = c.info()
host = Host.create(pod, '192.168.59.103:2376', r['Name'], r['ID'], r['NCPU'], r['MemTotal'])
if private:
host.assigned_to_group(group)
return app, version, group, pod, host
def create_host():
"""为了文件, 只好不用json了"""
addr = request.form.get('addr', type=str, default='')
pod_name = request.form.get('pod_name', type=str, default='')
if not (addr and pod_name):
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'need addr and pod_name')
pod = Pod.get_by_name(pod_name)
if not pod:
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'No pod found')
# 存证书, 没有就算了
try:
ca, cert, key = request.files['ca'], request.files['cert'], request.files['key']
save_docker_certs(addr.split(':', 1)[0], ca.read(), cert.read(), key.read())
finally:
ca.close()
cert.close()
key.close()
try:
client = get_docker_client(addr, force_flush=True)
info = client.info()
except Exception:
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'Docker daemon error on host %s' % addr)
if not Host.create(pod, addr, info['Name'], info['ID'], info['NCPU'], info['MemTotal']):
raise EruAbortException(consts.HTTP_BAD_REQUEST)
return consts.HTTP_CREATED, {'r':0, 'msg': consts.OK}
def _create_data(core_share, max_share_core, host_count):
group = Group.create('group', 'group')
pod = Pod.create('pod', 'pod', core_share, max_share_core)
for _ in range(host_count):
host = Host.create(pod, random_ipv4(), random_string(), random_uuid(), 16, 4096)
host.assigned_to_group(group)
return group, pod
def create_local_test_data(private=False):
appyaml = {
'appname': 'blueberry',
'entrypoints': {
'web': {
'cmd': 'python app.py',
'ports': ['5000/tcp'],
},
'daemon': {
'cmd': 'python daemon.py',
},
'service': {
'cmd': 'python service.py'
},
},
'build': 'pip install -r ./requirements.txt',
}
app = App.get_or_create('blueberry',
'http://git.hunantv.com/tonic/blueberry.git')
version = app.add_version('abe23812aeb50a17a2509c02a28423462161d306')
appconfig = version.appconfig
appconfig.update(**appyaml)
appconfig.save()
pod = Pod.create('pod', 'pod')
c = docker.Client(**kwargs_from_env(assert_hostname=False))
r = c.info()
host = Host.create(pod, '192.168.59.103:2376', r['Name'], r['ID'],
r['NCPU'], r['MemTotal'])
if not private:
host.set_public()
return app, version, pod, host
def create_private():
data = request.get_json()
pod, _, version = _get_instances(**data)
ncore, nshare = pod.get_core_allocation(float(data['ncore']))
ports = data.get('ports', [])
args = data.get('args', [])
strategy = data.get('strategy', 'average')
callback_url = data.get('callback_url', '')
if callback_url and not is_strict_url(callback_url):
abort(400, 'callback_url must start with http:// or https://')
ncontainer = int(data['ncontainer'])
if not ncontainer:
abort(400, 'ncontainer must be > 0')
networks = [ipam.get_pool(n) for n in data.get('networks', [])]
spec_ips = data.get('spec_ips', [])
appconfig = version.appconfig
entrypoint = data['entrypoint']
if entrypoint not in appconfig.entrypoints:
abort(400, 'Entrypoint %s not in app.yaml' % entrypoint)
hostname = data.get('hostname', '')
host = hostname and Host.get_by_name(hostname) or None
task_ids, watch_keys = [], []
host_cores = _get_strategy(strategy)(pod, ncontainer, ncore, nshare, host)
if not host_cores:
abort(400, 'Not enough core resources')
for (host, container_count), cores in host_cores.iteritems():
t = _create_task(
version,
host,
container_count,
cores,
nshare,
networks,
ports,
args,
spec_ips,
entrypoint,
data['env'],
image=data.get('image', ''),
callback_url=callback_url,
)
if not t:
continue
host.occupy_cores(cores, nshare)
task_ids.append(t.id)
watch_keys.append(t.result_key)
return {'tasks': task_ids, 'watch_keys': watch_keys}
def create_private(group_name, pod_name, appname):
"""ncore: 需要的核心数, 可以是小数, 例如1.5个"""
data = request.get_json()
if data.get('raw', ''):
vstr = consts.RAW_VERSION_PLACEHOLDER
else:
vstr = data['version']
group, pod, application, version = validate_instance(group_name,
pod_name, appname, vstr)
# TODO check if group has this pod
core_require = int(float(data['ncore']) * pod.core_share) # 是说一个容器要几个核...
ncore = core_require / pod.core_share
nshare = core_require % pod.core_share
ncontainer = int(data['ncontainer'])
networks = Network.get_multi(data.get('networks', []))
spec_ips = data.get('spec_ips', [])
appconfig = version.appconfig
# 指定的host, 如果没有则按照编排分配host
hostname = data.get('hostname', '')
host = hostname and Host.get_by_name(hostname) or None
if host and not (host.group_id == group.id and host.pod_id == pod.id):
current_app.logger.error('Host must belong to pod/group (hostname=%s, pod=%s, group=%s)',
host, pod_name, group_name)
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'Host must belong to this pod and group')
if not data['entrypoint'] in appconfig.entrypoints:
current_app.logger.error('Entrypoint not in app.yaml (entry=%s, name=%s, version=%s)',
data['entrypoint'], appname, version.short_sha)
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'Entrypoint %s not in app.yaml' % data['entrypoint'])
ts, keys = [], []
with rds.lock('%s:%s' % (group_name, pod_name)):
host_cores = group.get_free_cores(pod, ncontainer, ncore, nshare, spec_host=host)
if not host_cores:
current_app.logger.error('Not enough cores (name=%s, version=%s, ncore=%s)',
appname, version.short_sha, data['ncore'])
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'Not enough core resources')
for (host, container_count), cores in host_cores.iteritems():
t = _create_task(consts.TASK_CREATE, version, host, container_count,
cores, nshare, networks, spec_ips, data['entrypoint'], data['env'],
image=data.get('image', ''))
if not t:
continue
host.occupy_cores(cores, nshare)
ts.append(t.id)
keys.append(t.result_key)
return {'r': 0, 'msg': 'ok', 'tasks': ts, 'watch_keys': keys}
def get_host_resource(host_id):
host = Host.get(host_id)
if not host:
raise EruAbortException(code.HTTP_NOT_FOUND, 'Host %s not found' % host_id)
core_count = len(host.cores.all())
free_cores = host.get_free_cores()
return {
'core_count': core_count,
'free_cores': [c.label for c in free_cores],
'memory': host.mem,
}
def test_container_transform(test_db):
a = App.get_or_create('app', 'http://git.hunantv.com/group/app.git', '')
assert a is not None
v = a.add_version(random_sha1())
v2 = a.add_version(random_sha1())
assert v is not None
assert v.app.id == a.id
assert v.name == a.name
assert len(v.containers.all()) == 0
assert len(v.tasks.all()) == 0
g = Group.create('group', 'group')
p = Pod.create('pod', 'pod')
assert p.assigned_to_group(g)
hosts = [Host.create(p, random_ipv4(), random_string(prefix='host'),
random_uuid(), 4, 4096) for i in range(6)]
for host in hosts[:3]:
host.assigned_to_group(g)
assert g.get_max_containers(p, 3, 0) == 3
host_cores = g.get_free_cores(p, 3, 3, 0)
assert len(host_cores) == 3
containers = []
for (host, count), cores in host_cores.iteritems():
cores_per_container = len(cores) / count
for i in range(count):
cid = random_sha1()
used_cores = {'full': cores['full'][i*cores_per_container:(i+1)*cores_per_container]}
c = Container.create(cid, host, v, random_string(), 'entrypoint', used_cores, 'env')
assert c is not None
containers.append(c)
host.occupy_cores(cores, 0)
for host in g.private_hosts.all():
assert len(host.get_free_cores()[0]) == 1
assert len(host.containers.all()) == 1
assert host.count == 1
assert len(containers) == 3
assert len(v.containers.all()) == 3
cids = [c.container_id for c in containers]
for c in containers:
host = c.host
cid = c.container_id
c.transform(v2, random_sha1(), random_string())
assert c.container_id != cid
new_cids = [c.container_id for c in containers]
assert new_cids != cids
def test_network(test_db):
n = Network.create('net', '10.1.0.0/16')
assert n is not None
assert len(n.ips.all()) == 0
assert n.hostmask_string == '16'
assert n.pool_size == 65436
assert n.used_count == 0
assert n.used_gate_count == 0
assert n.gate_pool_size == 100
ip = n.acquire_ip()
assert ip is not None
assert ip.network_id == n.id
assert ip.vethname == ''
assert not ip.container_id
assert ip.hostmask == n.hostmask_string
assert ip.vlan_seq_id == n.id
assert ip.address.startswith('10.1')
assert len(n.ips.all()) == 1
assert n.pool_size == 65435
assert n.used_count == 1
ip.release()
assert len(n.ips.all()) == 0
assert n.pool_size == 65436
assert n.used_count == 0
p = Pod.create('pod', 'pod', 10, -1)
host = Host.create(p, random_ipv4(), random_string(prefix='host'),
random_uuid(), 4, 4096)
gate = n.acquire_gateway_ip(host)
assert gate is not None
assert gate.network_id == n.id
assert gate.vlan_address.startswith('10.1.0.')
assert gate.vlan_seq_id == n.id
assert gate.name == 'vlan.%02d.br' % n.id
g = VLanGateway.get_by_host_and_network(host.id, n.id)
assert g is not None
assert g.id == gate.id
assert len(host.list_vlans()) == 1
assert n.used_gate_count == 1
assert n.gate_pool_size == 99
gate.release()
assert n.used_gate_count == 0
assert n.gate_pool_size == 100
assert VLanGateway.get_by_host_and_network(host.id, n.id) is None
assert len(host.list_vlans()) == 0
def get_host_resource(host_id):
host = Host.get(host_id)
if not host:
abort(404, 'Host %s not found' % host_id)
core_count = len(host.cores)
fe, fs = host.get_free_cores()
return {
'core_count': core_count,
'free_excluded_cores': [c.label for c in fe],
'free_shared_cores': [c.label for c in fs],
'memory': host.mem,
}
def create_host():
data = request.get_json()
addr = data['addr']
pod = Pod.get_by_name(data['pod_name'])
if not pod:
raise EruAbortException(code.HTTP_BAD_REQUEST)
client = get_docker_client(addr)
info = client.info()
if not Host.create(pod, addr, info['Name'], info['ID'], info['NCPU'], info['MemTotal']):
raise EruAbortException(code.HTTP_BAD_REQUEST)
return {'r':0, 'msg': code.OK}
def test_get_max_container_count_single_host(test_db):
group = Group.create('group', 'group')
pod = Pod.create('pod', 'pod', 10, -1)
host = Host.create(pod, random_ipv4(), random_string(), random_uuid(), 64, 4096)
host.assigned_to_group(group)
assert get_max_container_count(group, pod, ncore=1, nshare=0) == 64
assert get_max_container_count(group, pod, ncore=2, nshare=0) == 32
assert get_max_container_count(group, pod, ncore=3, nshare=0) == 21
assert get_max_container_count(group, pod, ncore=4, nshare=0) == 16
assert get_max_container_count(group, pod, ncore=5, nshare=0) == 12
assert get_max_container_count(group, pod, ncore=1, nshare=5) == 42
assert get_max_container_count(group, pod, ncore=2, nshare=5) == 25
def test_network(test_db):
n = Network.create('net', '10.1.0.0/16')
assert n is not None
assert len(n.ips.all()) == 0
assert n.hostmask_string == '16'
assert n.pool_size == 65436
assert n.used_count == 0
assert n.used_gate_count == 0
assert n.gate_pool_size == 100
ip = n.acquire_ip()
assert ip is not None
assert ip.network_id == n.id
assert ip.vethname == ''
assert not ip.container_id
assert ip.hostmask == n.hostmask_string
assert ip.vlan_seq_id == n.id
assert ip.address.startswith('10.1')
assert len(n.ips.all()) == 1
assert n.pool_size == 65435
assert n.used_count == 1
ip.release()
assert len(n.ips.all()) == 0
assert n.pool_size == 65436
assert n.used_count == 0
p = Pod.create('pod', 'pod', 10, -1)
host = Host.create(p, random_ipv4(), random_string(prefix='host'), random_uuid(), 4, 4096)
gate = n.acquire_gateway_ip(host)
assert gate is not None
assert gate.network_id == n.id
assert gate.vlan_address.startswith('10.1.0.')
assert gate.vlan_seq_id == n.id
assert gate.name == 'vlan.%02d.br' % n.id
g = VLanGateway.get_by_host_and_network(host.id, n.id)
assert g is not None
assert g.id == gate.id
assert len(host.list_vlans()) == 1
assert n.used_gate_count == 1
assert n.gate_pool_size == 99
gate.release()
assert n.used_gate_count == 0
assert n.gate_pool_size == 100
assert VLanGateway.get_by_host_and_network(host.id, n.id) is None
assert len(host.list_vlans()) == 0
def test_host(test_db):
g = Group.create('group', 'group')
p = Pod.create('pod', 'pod')
assert p.assigned_to_group(g)
hosts = [Host.create(p, random_ipv4(), random_string(prefix='host'),
random_uuid(), 4, 4096) for i in range(6)]
for host in hosts:
assert host is not None
assert len(host.cores.all()) == 4
assert len(host.get_free_cores()) == 4
assert len(g.private_hosts.all()) == 0
assert g.get_max_containers(p, 1) == 0
assert g.get_free_cores(p, 1, 1) == {}
for host in hosts[:3]:
host.assigned_to_group(g)
host_ids1 = {h.id for h in hosts[:3]}
host_ids2 = {h.id for h in hosts[3:]}
assert len(g.private_hosts.all()) == 3
assert g.get_max_containers(p, 1) == 12
host_cores = g.get_free_cores(p, 12, 1)
assert len(host_cores) == 3
for (host, count), cores in host_cores.iteritems():
assert host.id in host_ids1
assert host.id not in host_ids2
assert count == 4
assert len(cores) == 4
assert g.get_max_containers(p, 3) == 3
host_cores = g.get_free_cores(p, 3, 3)
assert len(host_cores) == 3
for (host, count), cores in host_cores.iteritems():
assert host.id in host_ids1
assert host.id not in host_ids2
assert count == 1
assert len(cores) == 3
assert g.get_max_containers(p, 2) == 6
host_cores = g.get_free_cores(p, 4, 2)
assert len(host_cores) == 2
for (host, count), cores in host_cores.iteritems():
assert host.id in host_ids1
assert host.id not in host_ids2
assert count == 2
assert len(cores) == 4
def assign_host_to_group(addr):
data = request.get_json()
group = Group.get_by_name(data['group_name'])
if not group:
raise EruAbortException(code.HTTP_BAD_REQUEST)
host = Host.get_by_addr(addr)
if not host:
raise EruAbortException(code.HTTP_BAD_REQUEST)
if not host.assigned_to_group(group):
raise EruAbortException(code.HTTP_BAD_REQUEST)
return {'r':0, 'msg': code.OK}
def test_occupy_and_release_cores(test_db):
g = Group.create('group', 'group')
p = Pod.create('pod', 'pod', 10, -1)
host = Host.create(p, random_ipv4(), random_string(), random_uuid(), 200, 0)
assert p.assigned_to_group(g)
assert host.assigned_to_group(g)
for core in host.cores:
assert core.host_id == host.id
assert core.remain == 10
cores = {
'full': host.cores[:100],
'part': host.cores[100:],
}
host.occupy_cores(cores, 5)
for core in host.cores[:100]:
assert core.remain == 0
for core in host.cores[100:]:
assert core.remain == 5
host.release_cores(cores, 5)
for core in host.cores:
assert core.remain == 10
host.occupy_cores(cores, 8)
for core in host.cores[:100]:
assert core.remain == 0
for core in host.cores[100:]:
assert core.remain == 2
host.release_cores(cores, 8)
for core in host.cores:
assert core.remain == 10
cores = {
'full': host.cores[:50],
'part': host.cores[50:100],
}
host.occupy_cores(cores, 8)
for core in host.cores[:50]:
assert core.remain == 0
for core in host.cores[50:100]:
assert core.remain == 2
host.release_cores(cores, 8)
for core in host.cores:
assert core.remain == 10
def build_image(group_name, pod_name, appname):
data = request.get_json()
group, pod, _, version = validate_instance(group_name, pod_name, appname, data['version'])
base = data['base']
if ':' not in base:
base = base + ':latest'
host = Host.get_random_public_host() or pod.get_random_host()
task = Task.create(consts.TASK_BUILD, version, host, {'base': base})
build_docker_image.apply_async(
args=(task.id, base),
task_id='task:%d' % task.id
)
return {'r': 0, 'msg': 'ok', 'task': task.id, 'watch_key': task.result_key}
def test_occupy_and_release_cores(test_db):
p = Pod.create('pod', 'pod', 10, -1)
host = Host.create(p, random_ipv4(), random_string(), random_uuid(), 200,
0)
for core in host.cores:
assert core.host_id == host.id
assert core.remain == 10
cores = {
'full': host.cores[:100],
'part': host.cores[100:],
}
host.occupy_cores(cores, 5)
for core in host.cores[:100]:
assert core.remain == 0
for core in host.cores[100:]:
assert core.remain == 5
host.release_cores(cores, 5)
for core in host.cores:
assert core.remain == 10
host.occupy_cores(cores, 8)
for core in host.cores[:100]:
assert core.remain == 0
for core in host.cores[100:]:
assert core.remain == 2
host.release_cores(cores, 8)
for core in host.cores:
assert core.remain == 10
cores = {
'full': host.cores[:50],
'part': host.cores[50:100],
}
host.occupy_cores(cores, 8)
for core in host.cores[:50]:
assert core.remain == 0
for core in host.cores[50:100]:
assert core.remain == 2
host.release_cores(cores, 8)
for core in host.cores:
assert core.remain == 10
def assign_host_to_group(addr):
data = request.get_json()
group = Group.get_by_name(data['group_name'])
if not group:
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'No group found')
host = Host.get_by_addr(addr)
if not host:
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'No host found')
if not host.assigned_to_group(group):
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'Assign failed')
current_app.logger.info('Host (addr=%s) assigned to group (name=%s)',
addr, data['group_name'])
return {'r':0, 'msg': consts.OK}
def create_host():
data = request.get_json()
addr = data['addr']
pod = Pod.get_by_name(data['pod_name'])
if not pod:
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'No pod found')
try:
client = get_docker_client(addr)
info = client.info()
except Exception:
raise EruAbortException(consts.HTTP_BAD_REQUEST, 'Docker daemon error on host %s' % addr)
if not Host.create(pod, addr, info['Name'], info['ID'], info['NCPU'], info['MemTotal']):
raise EruAbortException(consts.HTTP_BAD_REQUEST)
return consts.HTTP_CREATED, {'r':0, 'msg': consts.OK}
def test_container_release_cores(test_db):
a = App.get_or_create('app', 'http://git.hunantv.com/group/app.git')
v = a.add_version(random_sha1())
p = Pod.create('pod', 'pod', 10, -1)
host = Host.create(p, random_ipv4(), random_string(), random_uuid(), 200,
0)
for core in host.cores:
assert core.host_id == host.id
assert core.remain == 10
containers = []
cores = sorted(host.cores, key=operator.attrgetter('label'))
for fcores, pcores in zip(chunked(cores[:100], 10),
chunked(cores[100:], 10)):
used_cores = {'full': fcores, 'part': pcores}
host.occupy_cores(used_cores, 5)
c = Container.create(random_sha1(),
host,
v,
random_string(),
'entrypoint',
used_cores,
'env',
nshare=5)
containers.append(c)
cores = sorted(host.cores, key=operator.attrgetter('label'))
for fcores, pcores in zip(chunked(cores[:100], 10),
chunked(cores[100:], 10)):
for core in fcores:
assert core.remain == 0
for core in pcores:
assert core.remain == 5
for c in containers:
c.delete()
cores = sorted(host.cores, key=operator.attrgetter('label'))
for fcores, pcores in zip(chunked(cores[:100], 10),
chunked(cores[100:], 10)):
for core in fcores:
assert core.remain == 10
for core in pcores:
assert core.remain == 10
def create_test_suite():
appyaml = {
'appname': 'app',
'entrypoints': {
'web': {
'cmd': 'python app.py',
'ports': ['5000/tcp'],
},
'daemon': {
'cmd': 'python daemon.py',
},
'service': {
'cmd': 'python service.py'
},
},
'build': 'pip install -r ./requirements.txt',
}
app = App.get_or_create('app', 'http://git.hunantv.com/group/app.git')
version = app.add_version(random_sha1())
appconfig = version.appconfig
appconfig.update(**appyaml)
appconfig.save()
pod = Pod.create('pod', 'pod')
hosts = [
Host.create(pod, random_ipv4(), random_string(prefix='host'),
random_uuid(), 4, 4096) for i in range(4)
]
containers = []
for (host, count), cores in centralized_schedule(pod, 4, 4, 0).iteritems():
cores_per_container = len(cores) / count
for i in range(count):
cid = random_sha1()
used_cores = {
'full':
cores['full'][i * cores_per_container:(i + 1) *
cores_per_container]
}
c = Container.create(cid, host, version, random_string(), 'web',
used_cores, 'env')
containers.append(c)
host.occupy_cores(cores, 0)
return app, version, pod, hosts, containers
def build_image():
data = request.get_json()
_, version = _get_app_and_version(**data)
base = data['base']
if ':' not in base:
base = base + ':latest'
host = Host.get_random_public_host()
if not host:
abort(406, 'no host is available')
task = Task.create(TASK_BUILD, version, host, {'base': base})
build_docker_image.apply_async(
args=(task.id, base, None),
task_id='task:%d' % task.id
)
return {'task': task.id, 'watch_key': task.result_key}
def create_test_suite():
appyaml = {
'appname': 'app',
'entrypoints': {
'web': {
'cmd': 'python app.py',
'ports': ['5000/tcp'],
},
'daemon': {
'cmd': 'python daemon.py',
},
'service': {
'cmd': 'python service.py'
},
},
'build': 'pip install -r ./requirements.txt',
}
app = App.get_or_create('app', 'http://git.hunantv.com/group/app.git', 'token')
version = app.add_version(random_sha1())
appconfig = version.appconfig
appconfig.update(**appyaml)
appconfig.save()
group = Group.create('group', 'group')
pod = Pod.create('pod', 'pod')
pod.assigned_to_group(group)
hosts = [Host.create(pod, random_ipv4(), random_string(prefix='host'),
random_uuid(), 4, 4096) for i in range(4)]
for host in hosts:
host.assigned_to_group(group)
containers = []
for (host, count), cores in group.get_free_cores(pod, 4, 4, 0).iteritems():
cores_per_container = len(cores) / count
for i in range(count):
cid = random_sha1()
used_cores = cores['full'][i*cores_per_container:(i+1)*cores_per_container]
c = Container.create(cid, host, version, random_string(), 'entrypoint', used_cores, 'env')
containers.append(c)
host.occupy_cores(cores, 0)
return app, version, group, pod, hosts, containers
def rm_containers(group_name, pod_name, appname):
data = request.get_json()
group, pod, application, version = validate_instance(group_name,
pod_name, appname, data['version'])
host = Host.get_by_name(data['host'])
# 直接拿前ncontainer个吧, 反正他们都等价的
containers = host.get_containers_by_version(version)[:int(data['ncontainer'])]
try:
cids = [c.id for c in containers]
task_props = {'container_ids': cids}
task = Task.create(code.TASK_REMOVE, version, host, task_props)
remove_containers.apply_async(
args=(task.id, cids, False),
task_id='task:%d' % task.id
)
return {'r': 0, 'msg': 'ok', 'task': task.id, 'watch_key': task.result_key}
except Exception, e:
logger.exception(e)
return {'r': 1, 'msg': str(e), 'task': None, 'watch_key': None}
def fillup_data():
app, _ = create_app_with_celery()
with app.app_context():
db.drop_all()
db.create_all()
group = Group.create('test-group', 'test-group')
pod = Pod.create('test-pod', 'test-pod')
pod.assigned_to_group(group)
r = requests.get('http://192.168.59.103:2375/info').json()
host = Host.create(pod, '192.168.59.103:2375', r['Name'], r['ID'], r['NCPU'], r['MemTotal'])
host.assigned_to_group(group)
app = App.get_or_create('nbetest', 'http://git.hunantv.com/platform/nbetest.git', 'token')
app.add_version('96cbf8c68ed214f105d9f79fa4f22f0e80e75cf3')
app.assigned_to_group(group)
version = app.get_version('96cbf8')
host_cores = group.get_free_cores(pod, 2, 2)
cores = []
for (host, cn), coress in host_cores.iteritems():
print host, cn, coress
cores = coress
print cores
ports = host.get_free_ports(2)
print ports
props = {
'entrypoint': 'web',
'ncontainer': 2,
'env': 'PROD',
'cores': [c.id for c in cores],
'ports': [p.id for p in ports],
}
task = Task.create(1, version, host, props)
print task.props
host.occupy_cores(cores)
host.occupy_ports(ports)
print group.get_free_cores(pod, 1, 1)
def test_container(test_db):
a = App.get_or_create('app', 'http://git.hunantv.com/group/app.git', '')
assert a is not None
assert a.id == a.user_id
v = a.add_version(random_sha1())
assert v is not None
assert v.app.id == a.id
assert v.name == a.name
assert len(v.containers.all()) == 0
assert len(v.tasks.all()) == 0
g = Group.create('group', 'group')
p = Pod.create('pod', 'pod', 10, -1)
assert p.assigned_to_group(g)
hosts = [Host.create(p, random_ipv4(), random_string(prefix='host'),
random_uuid(), 4, 4096) for i in range(6)]
for host in hosts[:3]:
host.assigned_to_group(g)
host_ids1 = {h.id for h in hosts[:3]}
host_ids2 = {h.id for h in hosts[3:]}
host_cores = g.get_free_cores(p, 3, 3, 0)
#测试没有碎片核的情况
#获取核
containers = []
for (host, count), cores in host_cores.iteritems():
cores_per_container = len(cores['full']) / count
for i in range(count):
cid = random_sha1()
used_cores = {'full': cores['full'][i*cores_per_container:(i+1)*cores_per_container]}
# not using a port
c = Container.create(cid, host, v, random_string(), 'entrypoint', used_cores, 'env')
assert c is not None
containers.append(c)
host.occupy_cores(cores, 0)
for host in g.private_hosts.all():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 1
assert len(part_cores) == 0
assert len(host.containers.all()) == 1
assert host.count == 1
assert len(containers) == 3
assert len(v.containers.all()) == 3
for c in containers:
assert c.host_id in host_ids1
assert c.host_id not in host_ids2
assert c.app.id == a.id
assert c.version.id == v.id
assert c.is_alive
assert len(c.full_cores.all()) == 3
assert len(c.part_cores.all()) == 0
all_core_labels = sorted(['0', '1', '2', '3', ])
used_full_core_labels = [core.label for core in c.full_cores.all()]
used_part_core_labels = [core.label for core in c.part_cores.all()]
free_core_labels = [core.label for core in c.host.get_free_cores()[0]]
assert all_core_labels == sorted(used_full_core_labels + used_part_core_labels + free_core_labels)
#释放核
for c in containers:
c.delete()
assert len(v.containers.all()) == 0
assert g.get_max_containers(p, 3, 0) == 3
host_cores = g.get_free_cores(p, 3, 3, 0)
assert len(host_cores) == 3
for host in g.private_hosts.all():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 4
assert len(part_cores) == 0
assert len(host.containers.all()) == 0
assert host.count == 0
#测试有碎片的情况
#获取核
host_cores = g.get_free_cores(p, 3, 3, 4)
containers = []
for (host, count), cores in host_cores.iteritems():
cores_per_container = len(cores['full']) / count
for i in range(count):
cid = random_sha1()
used_cores = {'full': cores['full'][i*cores_per_container:(i+1)*cores_per_container],
'part': cores['part']}
# not using a port
c = Container.create(cid, host, v, random_string(), 'entrypoint', used_cores, 'env')
assert c is not None
containers.append(c)
host.occupy_cores(cores, 4)
for host in g.private_hosts.all():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 0
assert len(part_cores) == 1
assert part_cores[0].used == 4
assert len(host.containers.all()) == 1
assert host.count == 1
assert len(containers) == 3
assert len(v.containers.all()) == 3
for c in containers:
assert c.host_id in host_ids1
assert c.host_id not in host_ids2
assert c.app.id == a.id
assert c.version.id == v.id
assert c.is_alive
assert len(c.full_cores.all()) == 3
assert len(c.part_cores.all()) == 1
all_core_labels = sorted(['0', '1', '2', '3', ])
used_full_core_labels = [core.label for core in c.full_cores.all()]
used_part_core_labels = [core.label for core in c.part_cores.all()]
free_core_labels = [core.label for core in c.host.get_free_cores()[0]]
assert all_core_labels == sorted(used_full_core_labels + used_part_core_labels + free_core_labels)
#释放核
for c in containers:
c.delete(4)
assert len(v.containers.all()) == 0
assert g.get_max_containers(p, 3, 0) == 3
host_cores = g.get_free_cores(p, 3, 3, 0)
assert len(host_cores) == 3
for host in g.private_hosts.all():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 4
assert len(host.containers.all()) == 0
assert host.count == 0
#获取
host_cores = g.get_free_cores(p, 6, 1, 5)
containers = []
for (host, count), cores in host_cores.iteritems():
cores_per_container = len(cores['full']) / count
for i in range(count):
cid = random_sha1()
used_cores = {'full': cores['full'][i*cores_per_container:(i+1)*cores_per_container],
'part': cores['part'][i:i+1]}
# not using a port
c = Container.create(cid, host, v, random_string(), 'entrypoint', used_cores, 'env')
assert c is not None
containers.append(c)
host.occupy_cores(used_cores, 5)
for host in g.private_hosts.all():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 1
assert len(part_cores) == 0
assert len(host.containers.all()) == 2
assert host.count == 2
assert len(containers) == 6
assert len(v.containers.all()) == 6
for c in containers:
assert c.host_id in host_ids1
assert c.host_id not in host_ids2
assert c.app.id == a.id
assert c.version.id == v.id
assert c.is_alive
assert len(c.full_cores.all()) == 1
assert len(c.part_cores.all()) == 1
##释放核
for c in containers:
c.delete(5)
assert len(v.containers.all()) == 0
assert g.get_max_containers(p, 3, 0) == 3
host_cores = g.get_free_cores(p, 3, 3, 0)
assert len(host_cores) == 3
for host in g.private_hosts.all():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 4
assert len(part_cores) == 0
assert len(host.containers.all()) == 0
assert host.count == 0
#!/usr/bin/env python
# encoding: utf-8
from eru.app import create_app_with_celery
from eru.models import db, Group, Pod, Host, App
from tests.utils import random_ipv4, random_string, random_uuid, random_sha1
host_number = int(raw_input("how many hosts: "))
app, _ = create_app_with_celery
app.config['TESTING'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:@localhost:3306/erutest'
with app.app_context():
db.create_all()
a = App.get_or_create('app', 'http://git.hunantv.com/group/app.git', '')
v = a.add_version(random_sha1())
g = Group.create('group', 'group')
p = Pod.create('pod', 'pod', 10, -1)
p.assigned_to_group(g)
hosts = [Host.create(p, random_ipv4(), random_string(), random_uuid(), 24, 4096) for i in range(host_number)]
for host in hosts:
host.assigned_to_group(g)
def take_one(host_ip, netspace, vlan_ip):
host = Host.get_by_addr(host_ip + ':2376')
if not host:
print 'host %s not found' % host_ip
take_gateway(netspace, vlan_ip, host)
def take_one(host_ip, netspace, vlan_ip):
host = Host.get_by_addr(host_ip + ':2376')
if not host:
print 'host %s not found' % host_ip
take_gateway(netspace, vlan_ip, host)
def _get_host(id_or_name):
host = Host.get(id_or_name) or Host.get_by_name(id_or_name)
if not host:
abort(404, 'Host %s not found' % id_or_name)
return host
def test_host(test_db):
p = Pod.create('pod', 'pod', 10, -1)
hosts = [
Host.create(p, random_ipv4(), random_string(prefix='host'),
random_uuid(), 4, 4096) for i in range(6)
]
for host in hosts:
host.set_public()
assert host is not None
assert len(host.cores) == 4
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 4
assert len(part_cores) == 0
assert len(p.get_private_hosts()) == 0
assert get_max_container_count(p, 1, 0) == 0
assert centralized_schedule(p, 1, 1, 0) == {}
for host in hosts[:3]:
host.set_private()
host_ids1 = {h.id for h in hosts[:3]}
host_ids2 = {h.id for h in hosts[3:]}
assert get_max_container_count(p, 1, 0) == 12
host_cores = centralized_schedule(p, 12, 1, 0)
assert len(host_cores) == 3
for (host, count), cores in host_cores.iteritems():
assert host.id in host_ids1
assert host.id not in host_ids2
assert count == 4
assert len(cores['full']) == 4
assert get_max_container_count(p, 3, 0) == 3
host_cores = centralized_schedule(p, 3, 3, 0)
assert len(host_cores) == 3
for (host, count), cores in host_cores.iteritems():
assert host.id in host_ids1
assert host.id not in host_ids2
assert count == 1
assert len(cores['full']) == 3
assert get_max_container_count(p, 2, 0) == 6
host_cores = centralized_schedule(p, 4, 2, 0)
assert len(host_cores) == 2
for (host, count), cores in host_cores.iteritems():
assert host.id in host_ids1
assert host.id not in host_ids2
assert count == 2
assert len(cores['full']) == 4
assert get_max_container_count(p, 1, 1) == 9
host_cores = centralized_schedule(p, 3, 1, 1)
assert len(host_cores) == 1
for (host, count), cores in host_cores.iteritems():
assert host.id in host_ids1
assert host.id not in host_ids2
assert count == 3
assert len(cores['full']) == 3
assert len(cores['part']) == 3
assert get_max_container_count(p, 2, 3) == 3
host_cores = centralized_schedule(p, 3, 2, 3)
assert len(host_cores) == 3
for (host, count), cores in host_cores.iteritems():
assert host.id in host_ids1
assert host.id not in host_ids2
assert count == 1
assert len(cores['full']) == 2
assert len(cores['part']) == 1
def test_container(test_db):
a = App.get_or_create('app', 'http://git.hunantv.com/group/app.git')
assert a is not None
assert a.id == a.user_id
v = a.add_version(random_sha1())
assert v is not None
assert v.app.id == a.id
assert v.name == a.name
assert len(v.containers.all()) == 0
assert len(v.tasks.all()) == 0
p = Pod.create('pod', 'pod', 10, -1)
hosts = [
Host.create(p, random_ipv4(), random_string(prefix='host'),
random_uuid(), 4, 4096) for i in range(6)
]
for host in hosts[3:]:
host.set_public()
host_ids1 = {h.id for h in hosts[:3]}
host_ids2 = {h.id for h in hosts[3:]}
host_cores = centralized_schedule(p, 3, 3, 0)
#测试没有碎片核的情况
#获取核
containers = []
for (host, count), cores in host_cores.iteritems():
host.occupy_cores(cores, 0)
cores_per_container = len(cores['full']) / count
for i in range(count):
cid = random_sha1()
used_cores = {
'full':
cores['full'][i * cores_per_container:(i + 1) *
cores_per_container]
}
c = Container.create(cid,
host,
v,
random_string(),
'entrypoint',
used_cores,
'env',
nshare=0)
assert c is not None
containers.append(c)
for host in p.get_private_hosts():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 1
assert len(part_cores) == 0
assert len(host.containers.all()) == 1
assert host.count == 1
assert len(containers) == 3
assert len(v.containers.all()) == 3
for c in containers:
assert c.host_id in host_ids1
assert c.host_id not in host_ids2
assert c.app.id == a.id
assert c.version.id == v.id
assert c.is_alive
assert len(c.full_cores) == 3
assert len(c.part_cores) == 0
all_core_labels = sorted([
'0',
'1',
'2',
'3',
])
used_full_core_labels = [core.label for core in c.full_cores]
used_part_core_labels = [core.label for core in c.part_cores]
free_core_labels = [core.label for core in c.host.get_free_cores()[0]]
assert all_core_labels == sorted(used_full_core_labels +
used_part_core_labels +
free_core_labels)
#释放核
for c in containers:
c.delete()
assert len(v.containers.all()) == 0
assert get_max_container_count(p, 3, 0) == 3
host_cores = centralized_schedule(p, 3, 3, 0)
assert len(host_cores) == 3
for host in p.get_private_hosts():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 4
assert len(part_cores) == 0
assert len(host.containers.all()) == 0
assert host.count == 4
#测试有碎片的情况
#获取核
host_cores = centralized_schedule(p, 3, 3, 4)
containers = []
for (host, count), cores in host_cores.iteritems():
cores_per_container = len(cores['full']) / count
host.occupy_cores(cores, 4)
for i in range(count):
cid = random_sha1()
used_cores = {
'full':
cores['full'][i * cores_per_container:(i + 1) *
cores_per_container],
'part':
cores['part']
}
# not using a port
c = Container.create(cid,
host,
v,
random_string(),
'entrypoint',
used_cores,
'env',
nshare=4)
assert c is not None
containers.append(c)
for host in p.get_private_hosts():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 0
assert len(part_cores) == 1
assert part_cores[0].remain == 6
assert len(host.containers.all()) == 1
assert host.count == D('0.6')
assert len(containers) == 3
assert len(v.containers.all()) == 3
for c in containers:
assert c.host_id in host_ids1
assert c.host_id not in host_ids2
assert c.app.id == a.id
assert c.version.id == v.id
assert c.is_alive
assert len(c.full_cores) == 3
assert len(c.part_cores) == 1
all_core_labels = sorted([
'0',
'1',
'2',
'3',
])
used_full_core_labels = [core.label for core in c.full_cores]
used_part_core_labels = [core.label for core in c.part_cores]
free_core_labels = [core.label for core in c.host.get_free_cores()[0]]
assert all_core_labels == sorted(used_full_core_labels +
used_part_core_labels +
free_core_labels)
#释放核
for c in containers:
c.delete()
assert len(v.containers.all()) == 0
assert get_max_container_count(p, 3, 0) == 3
host_cores = centralized_schedule(p, 3, 3, 0)
assert len(host_cores) == 3
for host in p.get_private_hosts():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 4
assert len(host.containers.all()) == 0
assert host.count == 4
#获取
host_cores = centralized_schedule(p, 6, 1, 5)
containers = []
for (host, count), cores in host_cores.iteritems():
cores_per_container = len(cores['full']) / count
for i in range(count):
cid = random_sha1()
used_cores = {
'full':
cores['full'][i * cores_per_container:(i + 1) *
cores_per_container],
'part':
cores['part'][i:i + 1],
}
host.occupy_cores(used_cores, 5)
# not using a port
c = Container.create(cid,
host,
v,
random_string(),
'entrypoint',
used_cores,
'env',
nshare=5)
assert c is not None
containers.append(c)
for host in p.get_private_hosts():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 1
assert len(part_cores) == 0
assert len(host.containers.all()) == 2
assert host.count == D('1')
assert len(containers) == 6
assert len(v.containers.all()) == 6
for c in containers:
assert c.host_id in host_ids1
assert c.host_id not in host_ids2
assert c.app.id == a.id
assert c.version.id == v.id
assert c.is_alive
assert len(c.full_cores) == 1
assert len(c.part_cores) == 1
##释放核
for c in containers:
c.delete()
assert len(v.containers.all()) == 0
assert get_max_container_count(p, 3, 0) == 3
host_cores = centralized_schedule(p, 3, 3, 0)
assert len(host_cores) == 3
for host in p.get_private_hosts():
full_cores, part_cores = host.get_free_cores()
assert len(full_cores) == 4
assert len(part_cores) == 0
assert len(host.containers.all()) == 0
assert host.count == 4
def _create_data(core_share, max_share_core, host_count):
pod = Pod.create('pod', 'pod', core_share, max_share_core)
for _ in range(host_count):
Host.create(pod, random_ipv4(), random_string(), random_uuid(), 16,
4096)
return pod
