def test_to_from_no_password(self):
u = User('root', email=None, groups=['adm', 'dev'])
db.session.add(u)
u_json = u.to_json()
smashed = User.from_json(u_json)
self.assertEqual(u, smashed)
self.assertEqual(u.id, smashed.id)
self.assertEqual(u.active, smashed.active)
self.assertEqual(u.created_at, smashed.created_at)
self.assertEqual(u.email, smashed.email)
self.assertEqual(u.groups, smashed.groups)
db.session.delete(u)
smashed = User.from_json(u_json)
db.session.add(smashed)
db.session.flush()
self.assertEqual(u.id, smashed.id)
self.assertEqual(u.active, smashed.active)
self.assertEqual(u.created_at, smashed.created_at)
self.assertEqual(u.email, smashed.email)
self.assertEqual(u.groups, smashed.groups)
def test_launch_orchestration_nested_orchestration(self):
self.o = Orchestration.query.filter_by(name='Create folder',
version=1).one()
self.o_wrapper = Orchestration.query.filter_by(
name="launch create folder", version=1).one()
resp = self.client.post(url_for('api_1_0.launch_orchestration',
orchestration_id=self.o_wrapper.id),
json={
'hosts': 'node1',
'params': {
'folder': '/new_folder',
'hosts': 'node2'
},
'background': False
},
headers=self.auth.header)
self.assertIn(resp.status_code, (200, 202))
o_id = self.o.id
with self.app2.app_context():
oe1: OrchExecution = OrchExecution.query.filter_by(
orchestration_id=o_id).one()
self.assertEqual(1, len(oe1.step_executions))
se1: StepExecution = oe1.step_executions[0]
self.assertEqual(True, se1.success)
self.assertEqual('mkdir -f /new_folder', se1.stdout)
self.assertEqual(None, se1.stderr)
self.assertEqual(0, se1.rc)
self.assertEqual(self.s2.id, se1.server.id)
# check inner orch
oe1: OrchExecution = OrchExecution.query.filter_by(
orchestration_id=self.o.id).one()
self.assertEqual(User.get_by_name('root'), oe1.executor)
self.assertEqual(True, oe1.success)
self.assertDictEqual({'folder': '/new_folder'}, oe1.params)
self.assertEqual(1, len(oe1.step_executions))
# check wrapper orch
oe2: OrchExecution = OrchExecution.query.filter_by(
orchestration_id=self.o_wrapper.id).one()
self.assertEqual(User.get_by_name('root'), oe2.executor)
self.assertEqual(True, oe2.success)
self.assertDictEqual({
'folder': '/new_folder',
'hosts': 'node2'
}, oe2.params)
self.assertEqual(1, len(oe2.step_executions))
se21: StepExecution = StepExecution.query.filter_by(
step=self.o_wrapper.steps[0]).one()
self.assertEqual(True, se21.success)
self.assertEqual(f'orch_execution_id={oe1.id}', se21.stdout)
self.assertEqual(None, se21.stderr)
self.assertEqual(None, se21.rc)
self.assertEqual(self.s1.id, se21.server.id)
def setUp(self):
"""Create and configure a new app instance for each test."""
# create the app with common test config
User.set_initial()
self.source = Server('source', port=8000, me=True)
self.dest = Server('dest', port=8000)
Route(self.dest, cost=0)
db.session.add_all([self.source, self.dest])
_PygtailBuffer._fh = mock.MagicMock()
self.mock_dm = mock.Mock()
self.log_sender = LogSender(dimensigon=self.mock_dm)
def populate_initial_data(dm: Dimensigon):
from dimensigon.domain.entities import ActionTemplate, Locker, Server, User, Parameter
with session_scope(session=dm.get_session()) as session:
gates = dm.config.http_conf.get('binds', None)
SchemaChanges.set_initial(session)
dm.server_id = Server.set_initial(session, gates)
Locker.set_initial(session, unlock=True)
ActionTemplate.set_initial(session)
User.set_initial(session)
Parameter.set_initial(session)
def wrapper(*args, **kwargs):
# app resolution
app = None
if 'app' in kwargs:
app = kwargs['app']
else:
for a in args:
if isinstance(a, Flask):
app = a
break
else:
app = current_app
if app:
ctx = app.app_context()
ctx.push()
try:
user = User.get_by_name(username)
if user is None:
raise errors.EntityNotFound("User", username, ['name'])
from flask_jwt_extended.utils import ctx_stack
ctx_stack.top.jwt_user = user
jwt = {'identity': str(user.id)}
ctx_stack.top.jwt = jwt
return f(*args, **kwargs)
finally:
db.session.close()
if app:
ctx.pop()
def cluster_in(server_id):
user = User.get_current()
data = request.get_json()
if user and user.name == 'root':
try:
keepalive = dt.datetime.strptime(data.get('keepalive'),
defaults.DATEMARK_FORMAT)
except ValueError:
raise errors.InvalidDateFormat(data.get('keepalive'),
defaults.DATEMARK_FORMAT)
current_app.dm.cluster_manager.put(server_id, keepalive)
_cluster_logger.debug(
f"{getattr(Server.query.get(server_id), 'name', server_id) or server_id} is a new alive server"
)
current_app.dm.route_manager.new_node_in_cluster(
server_id, data['routes'])
return {
'cluster':
current_app.dm.cluster_manager.get_cluster(
defaults.DATEMARK_FORMAT),
'neighbours': [s.id for s in Server.get_neighbours()]
}, 200
else:
raise errors.UserForbiddenError
def join_public():
if User.query.get(get_jwt_identity()) == User.get_by_name('join'):
return g.dimension.public.save_pkcs1(), 200, {
'content-type': 'application/octet-stream'
}
else:
return {}, 401
def setUp(self):
"""Create and configure a new app instance for each test."""
# create the app with common test config
self.app = create_app('test')
self.app_context = self.app.app_context()
self.app_context.push()
self.client = self.app.test_client()
db.create_all()
set_initial()
self.auth = HTTPBearerAuth(
create_access_token(User.get_by_name('root').id))
def test_get(self):
resp = self.client.get(url_for('api_1_0.userlist'),
headers=self.auth.header)
self.assertListEqual([self.user.to_json()], resp.get_json())
root = User('root')
db.session.add(root)
db.session.commit()
# test with filter
resp = self.client.get(url_for('api_1_0.userlist') +
"?filter[active]=True",
headers=self.auth.header)
self.assertListEqual([root.to_json()], resp.get_json())
# test with filter on a server
resp = self.client.get(url_for('api_1_0.userlist') +
f"?filter[name]=root",
headers=self.auth.header)
db.session.refresh(root)
self.assertListEqual([root.to_json()], resp.get_json())
def join_token():
if get_jwt_identity() == '00000000-0000-0000-0000-000000000001':
user_join = User.get_by_name('join')
expire_time = request.args.get('expires_time', type=int, default=None)
kwargs = {}
if expire_time:
kwargs['expires_delta'] = dt.timedelta(minutes=expire_time)
return {'token': create_access_token(str(user_join.id), **kwargs)}, 200
else:
return {}, 401
class TestUserResource(TestResourceBase):
def setUp(self) -> None:
self.initials = dict(self.initials)
self.initials.update(user=False)
super().setUp()
def fill_database(self):
self.user = User('user', active=False)
db.session.add(self.user)
@property
def auth(self):
return HTTPBearerAuth(create_access_token(self.user.id))
def test_get(self):
resp = self.client.get(url_for('api_1_0.userresource',
user_id=str(self.user.id)),
headers=self.auth.header)
self.assertEqual(200, resp.status_code)
self.assertEqual(self.user.to_json(), resp.get_json())
resp = self.client.get(url_for('api_1_0.userresource', user_id='aaaa'),
headers=self.auth.header)
self.assertEqual(404, resp.status_code)
def test_patch(self):
patch_user_json = {"name": "Kevin"}
resp = self.client.patch(url_for('api_1_0.userresource',
user_id=str(self.user.id)),
headers=self.auth.header,
json=patch_user_json)
self.assertEqual(400, resp.status_code)
db.session.refresh(self.user)
patch_user_json = {"email": "*****@*****.**"}
self.assertIsNone(self.user.email)
resp = self.client.patch(url_for('api_1_0.userresource',
user_id=str(self.user.id)),
headers=self.auth.header,
json=patch_user_json)
self.assertEqual(204, resp.status_code)
db.session.refresh(self.user)
self.assertEqual('*****@*****.**', self.user.email)
resp = self.client.patch(url_for('api_1_0.userresource',
user_id=str(self.user.id)),
headers=self.auth.header,
json=patch_user_json)
self.assertEqual(202, resp.status_code)
def test_post_user_already_exists(self):
root = User('root')
db.session.add(root)
db.session.commit()
new_user_json = {
"name": 'root',
"password": "******",
"email": '*****@*****.**',
}
resp = self.client.post(url_for('api_1_0.userlist'),
headers=self.auth.header,
json=new_user_json)
self.validate_error_response(
resp, errors.EntityAlreadyExists('User', 'root', ['name']))
def login():
user = User.get_by_name(name=request.get_json().get('username', None))
password = request.get_json().get('password', None)
try:
if not user or not user.verify_password(password):
return {"error": "Bad username or password"}, 401
except TypeError:
return {"error": "Bad username or password"}, 401
# Use create_access_token() and create_refresh_token() to create our
# access and refresh tokens
ret = {
'access_token': create_access_token(identity=str(user.id), fresh=True),
'refresh_token': create_refresh_token(identity=str(user.id))
}
return jsonify(ret), 200
def cluster_out(server_id):
user = User.get_current()
if user and user.name == 'root':
Server.query.get_or_raise(server_id)
data = request.get_json()
if data.get('death', None):
try:
death = dt.datetime.strptime(data['death'],
defaults.DATEMARK_FORMAT)
except:
death = get_now()
else:
death = None
current_app.dm.cluster_manager.put(server_id,
keepalive=death,
death=True)
# run background route
current_app.dm.route_manager.remove_node_from_cluster(server_id)
return {}, 202
else:
raise errors.UserForbiddenError
def fill_database(self):
self.user = User('user', active=False)
db.session.add(self.user)
def test_deploy_orchestration(self, mock_run):
mock_run.side_effect = [('', '', 0),
('', '', 0),
('', '', 0),
('', '', 0),
('', '', 0)]
g.server = self.s1
o = Orchestration.query.get('bbbbbbbb-1234-5678-1234-bbbbbbbb0001')
deploy_orchestration(o.id, var_context=self.vs,
hosts={'all': [self.s1.id, self.s2.id], 'frontend': [self.s1.id], 'backend': [self.s2.id]})
self.assertEqual(1, OrchExecution.query.count())
oe = OrchExecution.query.one()
orch_execution_id = oe.id
self.assertTrue(oe.success)
self.assertEqual(o, oe.orchestration)
self.assertDictEqual(
{'all': [str(self.s1.id), str(self.s2.id)], 'frontend': [str(self.s1.id)], 'backend': [str(self.s2.id)]},
oe.target)
self.assertDictEqual(dict(self.vs), oe.params)
self.assertEqual(User.get_by_name('root'), oe.executor)
self.assertIsNone(oe.service)
self.assertTrue(oe.success)
self.assertIsNone(oe.undo_success)
self.assertEqual(5, StepExecution.query.count())
e = StepExecution.query.filter_by(step_id='dddddddd-1234-5678-1234-dddddddd0001').filter_by(
server_id=self.s1.id).one()
self.assertTrue(e.success)
e = StepExecution.query.filter_by(step_id='dddddddd-1234-5678-1234-dddddddd0003').filter_by(
server_id=self.s1.id).one()
self.assertTrue(e.success)
e = StepExecution.query.filter_by(step_id='dddddddd-1234-5678-1234-dddddddd0007').filter_by(
server_id=self.s1.id).one()
self.assertTrue(e.success)
e = StepExecution.query.filter_by(step_id='dddddddd-1234-5678-1234-dddddddd0009').filter_by(
server_id=self.s2.id).one()
self.assertTrue(e.success)
e = StepExecution.query.filter_by(step_id='dddddddd-1234-5678-1234-dddddddd0007').filter_by(
server_id=self.s2.id).one()
self.assertTrue(e.success)
with self.app2.app_context():
self.assertEqual(1, OrchExecution.query.count())
oe = OrchExecution.query.one()
self.assertEqual(orch_execution_id, oe.id)
self.assertEqual(o.id, oe.orchestration.id)
self.assertDictEqual(
{'all': [str(self.s1.id), str(self.s2.id)], 'frontend': [str(self.s1.id)],
'backend': [str(self.s2.id)]}, oe.target)
self.assertDictEqual(dict(self.vs), oe.params)
self.assertEqual(User.get_by_name('root'), oe.executor)
self.assertIsNone(oe.service)
# self.assertTrue(oe.success)
# self.assertIsNone(oe.undo_success)
self.assertEqual(2, StepExecution.query.count())
e = StepExecution.query.filter_by(step_id='dddddddd-1234-5678-1234-dddddddd0009').one()
self.assertTrue(e.success)
e = StepExecution.query.filter_by(step_id='dddddddd-1234-5678-1234-dddddddd0007').one()
self.assertTrue(e.success)
def test_to_from_json(self):
start = dt.datetime(2019, 4, 1, tzinfo=dt.timezone.utc)
end = dt.datetime(2019, 4, 2, tzinfo=dt.timezone.utc)
u = User('user', id='cccccccc-1234-5678-1234-56781234ccc1')
db.session.add(u)
o = Orchestration('run_orch', 1, id='eeeeeeee-1234-5678-1234-56781234eee1')
s = o.add_step(undo=False,
action_template=ActionTemplate('orchestration', 1, ActionType.ORCHESTRATION, code=''))
co = Orchestration('child', 1, id='eeeeeeee-1234-5678-1234-56781234eee2')
cs = o.add_step(undo=False, action_template=ActionTemplate('action', 1, ActionType.SHELL, code=''))
db.session.add_all([o, s, co, cs])
oe = OrchExecution(id='bbbbbbbb-1234-5678-1234-56781234bbb1', start_time=start,
end_time=end,
target={'all': [str(self.me.id), str(self.remote.id)], 'backend': self.remote.name},
params={'params': 'content'},
executor=u,
orchestration=o
)
se = StepExecution(id='aaaaaaaa-1234-5678-1234-56781234aaa1', start_time=start, end_time=end, step=s,
orch_execution_id=oe.id,
params={'orchestration_id': 'eeeeeeee-1234-5678-1234-56781234eee2'}, rc=None, success=True,
server=self.remote)
coe = OrchExecution(id='bbbbbbbb-1234-5678-1234-56781234bbb2', start_time=start,
end_time=end,
target={'all': [str(self.me.id), str(self.remote.id)], 'backend': self.remote.name},
params={'params': 'content'},
executor=u,
orchestration=o,
parent_step_execution_id=se.id
)
cse = StepExecution(id='aaaaaaaa-1234-5678-1234-56781234aaa2', start_time=start, end_time=end, step=s,
orch_execution_id=coe.id,
params={'param': 'data'}, rc=0, success=True, server=self.remote,
)
se.child_orch_execution_id = coe.id
db.session.add_all([oe, se, coe, cse])
db.session.commit()
self.assertDictEqual(dict(id=str(oe.id),
start_time=start.strftime(defaults.DATETIME_FORMAT),
end_time=end.strftime(defaults.DATETIME_FORMAT),
target={'all': [str(self.me.id), str(self.remote.id)], 'backend': self.remote.name},
params={'params': 'content'}, orchestration_id=str(o.id),
success=None, undo_success=None,
executor_id='cccccccc-1234-5678-1234-56781234ccc1',
message=None),
oe.to_json())
self.assertDictEqual(dict(id=str(oe.id),
start_time=start.strftime(defaults.DATETIME_FORMAT),
end_time=end.strftime(defaults.DATETIME_FORMAT),
target={'all': [str(self.me), str(self.remote)], 'backend': self.remote.name},
params={'params': 'content'},
orchestration={'id': 'eeeeeeee-1234-5678-1234-56781234eee1',
'name': 'run_orch',
'version': 1},
success=None, undo_success=None,
executor='user',
message=None),
oe.to_json(human=True))
dumped = oe.to_json(add_step_exec=True)
self.assertEqual(1, len(dumped['steps']))
self.assertEqual('aaaaaaaa-1234-5678-1234-56781234aaa1', dumped['steps'][0]['id'])
self.assertIn('orch_execution', dumped['steps'][0])
o_e_json = oe.to_json()
db.session.commit()
del oe
# load existent object
smashed = OrchExecution.from_json(o_e_json)
self.assertEqual('bbbbbbbb-1234-5678-1234-56781234bbb1', smashed.id)
self.assertEqual(start, smashed.start_time)
self.assertEqual(end, smashed.end_time)
self.assertEqual(o.id, smashed.orchestration.id)
self.assertDictEqual({'all': [str(self.me.id), str(self.remote.id)], 'backend': self.remote.name},
smashed.target)
self.assertDictEqual({'params': 'content'}, smashed.params)
self.assertEqual(User.get_by_name('user'), smashed.executor)
self.assertEqual(None, smashed.service)
self.assertEqual(None, smashed.success)
self.assertEqual(None, smashed.undo_success)
# load new object and insert into database
new_obj = OrchExecution.from_json(dict(id='bbbbbbbb-1234-5678-1234-56781234bbb3',
start_time=start.strftime(defaults.DATETIME_FORMAT),
end_time=end.strftime(defaults.DATETIME_FORMAT),
target={'all': [str(self.me.id), str(self.remote.id)],
'backend': self.remote.name},
params={'params': 'content'},
orchestration_id=str(o.id),
service_id=None,
success=None, undo_success=None,
executor_id='cccccccc-1234-5678-1234-56781234ccc1'))
db.session.add(new_obj)
db.session.commit()
class TestUserResourceList(TestResourceBase):
def setUp(self) -> None:
self.initials = dict(self.initials)
self.initials.update(user=False)
super().setUp()
def fill_database(self):
self.user = User(name='user', active=False)
db.session.add(self.user)
@property
def auth(self):
return HTTPBearerAuth(create_access_token(self.user.id))
def test_get(self):
resp = self.client.get(url_for('api_1_0.userlist'),
headers=self.auth.header)
self.assertListEqual([self.user.to_json()], resp.get_json())
root = User('root')
db.session.add(root)
db.session.commit()
# test with filter
resp = self.client.get(url_for('api_1_0.userlist') +
"?filter[active]=True",
headers=self.auth.header)
self.assertListEqual([root.to_json()], resp.get_json())
# test with filter on a server
resp = self.client.get(url_for('api_1_0.userlist') +
f"?filter[name]=root",
headers=self.auth.header)
db.session.refresh(root)
self.assertListEqual([root.to_json()], resp.get_json())
def test_post(self):
new_user_json = {
"name": 'root',
"password": "******",
"email": '*****@*****.**',
}
resp = self.client.post(url_for('api_1_0.userlist'),
headers=self.auth.header,
json=new_user_json)
self.assertEqual(201, resp.status_code)
user = User.query.get(resp.get_json().get('id'))
self.assertEqual('root', user.name)
self.assertEqual("*****@*****.**", user.email)
self.assertIsNotNone(user._password)
self.assertNotEqual('1234', user._password)
self.assertTrue(user.active)
def test_post_user_already_exists(self):
root = User('root')
db.session.add(root)
db.session.commit()
new_user_json = {
"name": 'root',
"password": "******",
"email": '*****@*****.**',
}
resp = self.client.post(url_for('api_1_0.userlist'),
headers=self.auth.header,
json=new_user_json)
self.validate_error_response(
resp, errors.EntityAlreadyExists('User', 'root', ['name']))
def test_verify_password(self):
u = User('root', email=None, groups=['adm', 'dev'])
u.set_password('test')
self.assertIsNotNone(u._password)
self.assertTrue(u.verify_password('test'))