def setup_nodes(config, user_config, num=1, existing_nodes=None):
kube_nodes = []
kubernetes_master = rs.load('kubelet-master')
calico_master = rs.load('calico-master')
internal_network = IPAddress(config.args['network'])
if existing_nodes:
kube_nodes = [
setup_slave_node(config, kubernetes_master, calico_master,
internal_network, i, None, node)
for (i, node) in enumerate(existing_nodes)
]
else:
kube_nodes = [
setup_slave_node(config, kubernetes_master, calico_master,
internal_network, i, user_config[i])
for i in xrange(num)
]
kube_master = rs.load(MASTER_NODE_RESOURCE_NAME)
all_nodes = kube_nodes[:] + [kube_master]
hosts_files = rs.load_all(startswith='hosts_file_node_')
for node in all_nodes:
for host_file in hosts_files:
node.connect(host_file, {'name': 'hosts:name', 'ip': 'hosts:ip'})
def test_revert_create():
res = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res.inputs['a'] = '9'
res.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 1
logitem = staged_log[0]
operations.move_to_commited(logitem.log_action)
assert logitem.diff == [['add', '', [['a', '9']]]]
commited = CommitedResource.get('test1')
assert commited.inputs == {'a': '9'}
change.revert(logitem.uid)
staged_log = change.stage_changes()
assert len(staged_log) == 1
for item in staged_log:
operations.move_to_commited(item.log_action)
assert resource.load_all() == []
def test_revert_create():
res = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res.inputs['a'] = '9'
res.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 1
logitem = staged_log[0]
operations.move_to_commited(logitem.log_action)
assert logitem.diff == [['add', '', [['a', '9']]]]
commited = CommitedResource.get('test1')
assert commited.inputs == {'a': '9'}
change.revert(logitem.uid)
staged_log = change.stage_changes()
assert len(staged_log) == 1
for item in staged_log:
operations.move_to_commited(item.log_action)
assert resource.load_all() == []
def test_discard_all_pending_changes_resources_created():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = DBResource.from_dict('test2',
{'name': 'test2',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res2.inputs['a'] = '0'
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 2
change.discard_all()
staged_log = change.stage_changes()
assert len(staged_log) == 0
assert resource.load_all() == []
def test_discard_all_pending_changes_resources_created():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = DBResource.from_dict('test2',
{'name': 'test2',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res2.inputs['a'] = '0'
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 2
change.discard_all()
staged_log = change.stage_changes()
assert len(staged_log) == 0
assert resource.load_all() == []
def test_revert_create():
res = DBResource.from_dict(
"test1",
{
"name": "test1",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res.inputs["a"] = "9"
res.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 1
logitem = staged_log[0]
operations.move_to_commited(logitem.log_action)
assert logitem.diff == [["add", "", [["a", "9"]]]]
commited = CommitedResource.get("test1")
assert commited.inputs == {"a": "9"}
change.revert(logitem.uid)
staged_log = change.stage_changes()
assert len(staged_log) == 1
for item in staged_log:
operations.move_to_commited(item.log_action)
assert resource.load_all() == []
def test_discard_all_pending_changes_resources_created():
res1 = DBResource.from_dict(
"test1",
{
"name": "test1",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res1.inputs["a"] = "9"
res1.save_lazy()
res2 = DBResource.from_dict(
"test2",
{
"name": "test2",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res2.inputs["a"] = "0"
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 2
change.discard_all()
staged_log = change.stage_changes()
assert len(staged_log) == 0
assert resource.load_all() == []
def add_node(args, user_config):
config = rs.load('kube-config')
kubernetes_master = rs.load('kubelet-master')
calico_master = rs.load('calico-master')
internal_network = IPAddress(config.args['network'])
def get_node_id(n):
return n.name.split('-')[-1]
kube_nodes = get_slave_nodes()
newest_id = int(get_node_id(max(kube_nodes, key=get_node_id)))
new_nodes = [setup_slave_node(config, user_config['kube_slaves'],
kubernetes_master, calico_master,
internal_network, i)
for i in xrange(newest_id, newest_id + args.nodes)]
kube_master = rs.load('kube-node-master')
all_nodes = new_nodes[:] + [kube_master]
hosts_files = rs.load_all(startswith='hosts_file_node_kube-')
for node in all_nodes:
for host_file in hosts_files:
node.connect(host_file, {
'name': 'hosts:name',
'ip': 'hosts:ip'
})
def get_master_and_slave_nodes():
nodes = sorted(rs.load_all(startswith='node'), key=lambda x: x.name)
# We are using existing nodes only if there are 2 or more of them. One
# created node will result in all resources being created from scratch.
if len(nodes) >= 2:
return (nodes[0], nodes[1:])
else:
return (None, None)
def test_discard_all_pending_changes_resources_created():
res1 = create_resource('test1')
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = create_resource('test2')
res2.inputs['a'] = '0'
res2.save_lazy()
staged_log = map(change.create_run, (res1.name, res2.name))
change.discard_all()
staged_log = change.staged_log()
assert len(staged_log) == 0
assert resource.load_all() == []
def test_discard_all_pending_changes_resources_created():
res1 = create_resource('test1')
res1.db_obj.inputs['a'] = '9'
res1.db_obj.save_lazy()
res2 = create_resource('test2')
res2.db_obj.inputs['a'] = '0'
res2.db_obj.save_lazy()
staged_log = map(change.create_run, (res1, res2))
change.discard_all()
staged_log = change.staged_log()
assert len(staged_log) == 0
assert resource.load_all() == []
def run():
node1, node2 = rs.load_all(startswith='node')[:2]
hosts1, hosts2 = rs.load_all(startswith='hosts_file')[:2]
node1.connect(hosts1, {
'name': 'hosts:name',
'ip': 'hosts:ip',
})
node2.connect(hosts1, {
'name': 'hosts:name',
'ip': 'hosts:ip',
})
node1.connect(hosts2, {
'name': 'hosts:name',
'ip': 'hosts:ip',
})
node2.connect(hosts2, {
'name': 'hosts:name',
'ip': 'hosts:ip',
})
def setup_nodes(config, user_config, num=1):
kube_nodes = []
kubernetes_master = rs.load('kubelet-master')
calico_master = rs.load('calico-master')
internal_network = IPAddress(config.args['network'])
kube_nodes = [
setup_slave_node(config, user_config, kubernetes_master, calico_master,
internal_network, i) for i in xrange(num)
]
kube_master = rs.load('kube-node-master')
all_nodes = kube_nodes[:] + [kube_master]
hosts_files = rs.load_all(startswith='hosts_file_node_kube-')
for node in all_nodes:
for host_file in hosts_files:
node.connect(host_file, {'name': 'hosts:name', 'ip': 'hosts:ip'})
def test_revert_create():
res = create_resource('test1')
res.db_obj.inputs['a'] = '9'
logitem = change.create_run(res)
assert logitem.diff == [['add', '', [['a', '9']]]]
uid = logitem.uid
operations.commit_log_item(logitem)
commited = CommitedResource.get('test1')
assert commited.inputs == {'a': '9'}
change.revert(uid)
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert len(staged_log) == 1
for item in staged_log:
operations.commit_log_item(item)
assert resource.load_all() == []
def setup_nodes(config, user_config, num=1):
kube_nodes = []
kubernetes_master = rs.load('kubelet-master')
calico_master = rs.load('calico-master')
internal_network = IPAddress(config.args['network'])
kube_nodes = [
setup_slave_node(config, user_config, kubernetes_master, calico_master,
internal_network, i)
for i in xrange(num)]
kube_master = rs.load('kube-node-master')
all_nodes = kube_nodes[:] + [kube_master]
hosts_files = rs.load_all(startswith='hosts_file_node_kube-')
for node in all_nodes:
for host_file in hosts_files:
node.connect(host_file, {
'name': 'hosts:name',
'ip': 'hosts:ip'
})
def test_revert_create():
res = create_resource('test1')
res.inputs['a'] = '9'
res.save_lazy()
logitem = change.create_run(res.name)
assert logitem.diff == [['add', '', [['a', '9']]]]
uid = logitem.uid
operations.commit_log_item(logitem)
commited = CommitedResource.get('test1')
assert commited.inputs == {'a': '9'}
change.revert(uid)
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert len(staged_log) == 1
for item in staged_log:
operations.commit_log_item(item)
assert resource.load_all() == []
def add_node(args, user_config):
config = rs.load('kube-config')
kubernetes_master = rs.load('kubelet-master')
calico_master = rs.load('calico-master')
internal_network = IPAddress(config.args['network'])
def get_node_id(n):
return n.name.split('-')[-1]
kube_nodes = get_slave_nodes()
newest_id = int(get_node_id(max(kube_nodes, key=get_node_id)))
new_nodes = [
setup_slave_node(config, user_config['kube_slaves'], kubernetes_master,
calico_master, internal_network, i)
for i in xrange(newest_id, newest_id + args.nodes)
]
kube_master = rs.load('kube-node-master')
all_nodes = new_nodes[:] + [kube_master]
hosts_files = rs.load_all(startswith='hosts_file_node_kube-')
for node in all_nodes:
for host_file in hosts_files:
node.connect(host_file, {'name': 'hosts:name', 'ip': 'hosts:ip'})
def get_slave_nodes():
kube_nodes = rs.load_all(startswith='kube-node-')
p = re.compile('^kube-node-\d+$')
return [node for node in kube_nodes if p.match(node.name)]
def setup_nodes(num=1):
kube_nodes = []
kubernetes_master = rs.load('kubelet-master')
calico_master = rs.load('calico-master')
config = rs.load('kube-config')
for i in xrange(num):
j = i + 1
kube_node = cr.create(
'kube-node-%d' % j, 'k8s/node', {
'name': 'kube-node-%d' % j,
'ip': '10.0.0.%d' % (3 + j),
'ssh_user': '******',
'ssh_password': '******',
'ssh_key': None
})['kube-node-%d' % j]
iface_node = cr.create(
'kube-node-%d-iface' % j,
'k8s/virt_iface',
{
'name': 'cbr0',
'ipaddr': '172.20.%d.1' %
(i + 1), # TODO(jnowak) support config for it
'onboot': 'yes',
'bootproto': 'static',
'type': 'Bridge'
})['kube-node-%d-iface' % j]
kube_node.connect(iface_node, {})
config.connect(iface_node, {'netmask': 'netmask'})
calico_node = cr.create('calico-node-%d' % j, 'k8s/calico', {})[0]
kube_node.connect(calico_node, {'ip': 'ip'})
calico_master.connect(calico_node,
{'etcd_authority': 'etcd_authority'})
calico_node.connect(calico_node,
{'etcd_authority': 'etcd_authority_internal'})
calico_cni = cr.create('calico-cni-node-%d' % j, 'k8s/cni', {})[0]
calico_node.connect(calico_cni,
{'etcd_authority_internal': 'etcd_authority'})
docker = cr.create('kube-docker-%d' % j,
'k8s/docker')['kube-docker-%d' % j]
kube_node.connect(docker, {})
iface_node.connect(docker, {'name': 'iface'})
kubelet = cr.create('kubelet-node-%d' % j, 'k8s/kubelet', {
'kubelet_args': '--v=5',
})['kubelet-node-%d' % j]
kube_node.connect(kubelet, {'name': 'kubelet_hostname'})
kubernetes_master.connect(kubelet, {'master_address': 'master_api'})
config.connect(kubelet, {
'cluster_domain': 'cluster_domain',
'cluster_dns': 'cluster_dns'
})
add_event(Dep(docker.name, 'run', 'success', calico_node.name, 'run'))
add_event(Dep(docker.name, 'run', 'success', kubelet.name, 'run'))
add_event(Dep(calico_node.name, 'run', 'success', kubelet.name, 'run'))
kube_nodes.append(kube_node)
kube_master = rs.load('kube-node-master')
all_nodes = kube_nodes[:] + [kube_master]
hosts_files = rs.load_all(startswith='hosts_file_node_kube-')
for node in all_nodes:
for host_file in hosts_files:
node.connect(host_file, {'name': 'hosts:name', 'ip': 'hosts:ip'})
def get_slave_nodes():
kube_nodes = rs.load_all(startswith='kube-node-')
p = re.compile('^kube-node-\d+$')
return [node for node in kube_nodes if p.match(node.name)]
def setup_riak():
nodes = rs.load_all(startswith="node")
hosts_services = rs.load_all(startswith="hosts_file")
node1, node2, node3 = nodes[:3]
riak_services = []
ips = "10.0.0.%d"
for i in xrange(3):
num = i + 1
r = cr.create(
"riak_service%d" % num,
"resources/riak_node",
{
"riak_self_name": "riak%d" % num,
"storage_backend": "leveldb",
"riak_hostname": "riak_server%d.solar" % num,
},
)[0]
r.connect(r, {"riak_self_name": "riak_name", "riak_hostname": "riak_name"})
riak_services.append(r)
for i, riak in enumerate(riak_services):
nodes[i].connect(riak)
for i, riak in enumerate(riak_services[1:]):
riak_services[0].connect(riak, {"riak_name": "join_to"})
for riak in riak_services:
for hosts_file in hosts_services:
riak.connect_with_events(hosts_file, {"riak_hostname": "hosts:name", "ip": "hosts:ip"})
Resource.save_all_lazy()
errors = resource.validate_resources()
for r, error in errors:
click.echo("ERROR: %s: %s" % (r.name, error))
has_errors = False
if errors:
click.echo("ERRORS")
sys.exit(1)
events = [
Dep("hosts_file_node_node1", "run", "success", "riak_service1", "run"),
Dep("hosts_file_node_node2", "run", "success", "riak_service2", "run"),
Dep("hosts_file_node_node3", "run", "success", "riak_service3", "run"),
React("riak_service2", "run", "success", "riak_service2", "join"),
React("riak_service3", "run", "success", "riak_service3", "join"),
# Dep('riak_service1', 'run', 'success', 'riak_service2', 'join'),
# Dep('riak_service1', 'run', 'success', 'riak_service3', 'join'),
# React('riak_service2', 'join', 'error', 'riak_service2', 'leave'),
# React('riak_service3', 'join', 'error', 'riak_service3', 'leave'),
React("riak_service2", "leave", "success", "riak_service2", "join"),
React("riak_service3", "leave", "success", "riak_service3", "join"),
# React('riak_service2', 'leave', 'success', 'riak_service1', 'commit_leave'),
# React('riak_service3', 'leave', 'success', 'riak_service1', 'commit_leave'),
# Dep('riak_service1', 'commit_leave', 'success', 'riak_service2', 'join'),
# Dep('riak_service1', 'commit_leave', 'success', 'riak_service3', 'join'),
React("riak_service3", "join", "success", "riak_service1", "commit"),
React("riak_service2", "join", "success", "riak_service1", "commit"),
]
for event in events:
add_event(event)
click.echo("Use solar changes process & orch")
sys.exit(0)
def setup_nodes(num=1):
kube_nodes = []
etcd = rs.load('etcd')
kubernetes_master = rs.load('k8s-master')
calico_master = rs.load('calico-master')
for i in xrange(num):
j = i + 1
kube_node = cr.create(
'kube-node-%d' % j,
'k8s/node',
{'name': 'kube-node-%d' % j,
'ip': '10.0.0.%d' % (3 + j),
'ssh_user': '******',
'ssh_password': '******',
'ssh_key': None}
)['kube-node-%d' % j]
iface_node = cr.create(
'kube-node-%d-iface' % j,
'k8s/virt_iface',
{'name': 'cbr0',
'netmask': '255.255.255.0',
'ipaddr': '192.168.%d.1' % (i + 1),
'onboot': 'yes',
'bootproto': 'static',
'type': 'Bridge'})['kube-node-%d-iface' % j]
kube_node.connect(iface_node, {})
calico_node = cr.create('calico-node-%d' % j, 'k8s/calico', {
'kubernetes': True
})[0]
add_event(Dep(calico_master.name, 'run', 'success', calico_node.name, 'run'))
kube_node.connect(calico_node, {'ip': 'ip'})
calico_node.connect(calico_node, {
'etcd_authority': 'etcd_authority_internal'
})
etcd.connect(calico_node, {'listen_client_url': 'etcd_authority'})
docker = cr.create('kube-docker-%d' % j,
'k8s/docker')['kube-docker-%d' % j]
kube_node.connect(docker, {})
iface_node.connect(docker, {'name': 'iface'})
kubelet = cr.create('kubelet-node-%d' % j, 'k8s/kubelet', {
'kubelet_args': '--network-plugin=calico',
})['kubelet-node-%d' % j]
kube_node.connect(kubelet, {'name': 'kubelet_hostname'})
kubernetes_master.connect(kubelet, {'master_address': 'master_api'})
calico_node.connect(kubelet, {'etcd_authority_internal': 'etcd_authority'})
kube_nodes.append(kube_node)
kube_master = rs.load('kube-node-master')
all_nodes = kube_nodes[:] + [kube_master]
hosts_files = rs.load_all(startswith='hosts_file_node_kube-')
for node in all_nodes:
for host_file in hosts_files:
node.connect(host_file, {
'name': 'hosts:name',
'ip': 'hosts:ip'
})