async def test_file_cred_v3(self, mock_cf):
with NamedTemporaryFile() as tempfile:
tempfile.close()
temppath = Path(tempfile.name)
temppath.write_text('cred-test')
cred = client.CloudCredential(auth_type='jsonfile',
attrs={'file': tempfile.name})
jujudata = mock.MagicMock()
c = Controller(jujudata=jujudata)
c._connector = base.AsyncMock()
up_creds = base.AsyncMock()
cloud_facade = mock_cf.from_connection()
cloud_facade.version = 3
cloud_facade.UpdateCredentialsCheckModels = up_creds
await c.add_credential(
name='name',
credential=cred,
cloud='cloud',
owner='owner',
force=True,
)
assert up_creds.called
assert up_creds.call_args[1]['force']
new_cred = up_creds.call_args[1]['credentials'][0].credential
assert cred.attrs['file'] == tempfile.name
assert new_cred.attrs['file'] == 'cred-test'
def load_credential(self, cloud, name=None):
"""Load a local credential.
:param str cloud: Name of cloud to load credentials from.
:param str name: Name of credential. If None, the default credential
will be used, if available.
:return: A CloudCredential instance, or None.
"""
try:
cloud = tag.untag('cloud-', cloud)
creds_data = self.credentials()[cloud]
if not name:
default_credential = creds_data.pop('default-credential', None)
default_region = creds_data.pop('default-region', None) # noqa
if default_credential:
name = creds_data['default-credential']
elif len(creds_data) == 1:
name = list(creds_data)[0]
else:
return None, None
cred_data = creds_data[name]
auth_type = cred_data.pop('auth-type')
return name, jujuclient.CloudCredential(
auth_type=auth_type,
attrs=cred_data,
)
except (KeyError, FileNotFoundError):
return None, None
async def add_credential(username, credentials):
try:
cred = ast.literal_eval(credentials)
token = JuJu_Token()
c_type = cred['type']
credential_name = 't{}'.format(
hashlib.md5(cred['name'].encode('utf')).hexdigest())
controllers = ds.get_cloud_controllers(c_type)
for con in controllers:
controller = juju.Controller_Connection(token, con)
if controller.c_type == c_type:
async with controller.connect(token) as con_juju:
logger.info('%s -> Adding credentials', con)
cloud_facade = client.CloudFacade.from_connection(
con_juju.connection)
credential = juju.generate_cred_file(
c_type, credential_name, cred['credential'])
logger.info('credentials generated %s', credential)
cloud_cred = client.UpdateCloudCredential(
client.CloudCredential(credential['key'],
credential['type']),
tag.credential(c_type, username, credential_name))
await cloud_facade.UpdateCredentials([cloud_cred])
logger.info('%s -> controller updated', con)
ds.add_credential(username, cred)
logger.info('Succesfully added credential')
except Exception as e:
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
for l in lines:
logger.error(l)
async def main():
kubecfg = os.popen('microk8s.config').read()
cfg = yaml.safe_load(kubecfg)
ctx = {v['name']: v['context'] for v in cfg['contexts']}[cfg['current-context']]
cluster = {v['name']: v['cluster'] for v in cfg['clusters']}[ctx['cluster']]
user = {v['name']: v['user'] for v in cfg['users']}[ctx['user']]
ep = cluster['server']
caCert = base64.b64decode(cluster['certificate-authority-data']).decode('utf-8')
controller = Controller()
await controller.connect()
cloud = client.Cloud(
auth_types=["userpass"],
ca_certificates=[caCert],
endpoint=ep,
host_cloud_region="microk8s/localhost",
regions=[client.CloudRegion(endpoint=ep, name="localhost")],
type_="kubernetes")
cloud = await controller.add_cloud("test", cloud)
cred = client.CloudCredential(
auth_type="userpass",
attrs={
"username": user['username'],
"password": user['password']
}
)
await controller.add_credential("test", credential=cred, cloud="test")
await controller.disconnect()
async def create_controller(c_type, name, region, cred_name):
try:
logger.info('Adding controller to database')
token = JuJu_Token()
datastore.create_controller(name, c_type, region, cred_name)
datastore.add_user_to_controller(name, 'admin', 'superuser')
logger.info('Bootstrapping controller')
credential = juju.get_credential(token.username, cred_name)
logger.info('credential found %s:', credential['credential'])
juju.get_controller_types()[c_type].create_controller(name, region, credential['credential'], 't{}'.format(hashlib.md5(cred_name.encode('utf')).hexdigest()))
pswd = token.password
logger.info('Setting admin password')
check_output(['juju', 'change-user-password', 'admin', '-c', name],
input=bytes('{}\n{}\n'.format(pswd, pswd), 'utf-8'))
logger.info('Updating controller in database')
with open(os.path.join(str(Path.home()), '.local', 'share', 'juju', 'controllers.yaml'), 'r') as data:
con_data = yaml.load(data)
datastore.set_controller_state(
name,
'ready',
con_data['controllers'][name]['api-endpoints'],
con_data['controllers'][name]['uuid'],
con_data['controllers'][name]['ca-cert'])
logger.info('Connecting to controller')
controller = juju.Controller_Connection(token, name)
logger.info('Adding existing credentials and models to database')
credentials = datastore.get_credentials(token.username)
async with controller.connect(token) as juju_con:
for cred in credentials:
if cred['name'] != cred_name:
credential_name = 't{}'.format(hashlib.md5(cred_name.encode('utf')).hexdigest())
cloud_facade = client.CloudFacade.from_connection(juju_con.connection)
credential = juju.generate_cred_file(c_type, credential_name, cred['credential'])
cloud_cred = client.UpdateCloudCredential(
client.CloudCredential(credential['key'], credential['type']),
tag.credential(c_type, token.username, credential_name)
)
await cloud_facade.UpdateCredentials([cloud_cred])
models = await juju_con.get_models()
for model in models.serialize()['user-models']:
model = model.serialize()['model'].serialize()
datastore.add_model_to_controller(name, model['name'])
datastore.set_model_state(name, model['name'], 'ready', credential=cred_name, uuid=model['uuid'])
datastore.set_model_access(name, model['name'], token.username, 'admin')
logger.info('Controller succesfully created!')
except Exception: #pylint: disable=W0703
datastore.destroy_controller(name)
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
for l in lines:
logger.error(l)
datastore.set_controller_state(name, 'error')
async def create_model(c_name, m_name, usr, pwd, url, port, cred_name):
try:
logger.info('%s -> Setting up Controllerconnection for %s', m_name,
c_name)
users = redis.StrictRedis(host=url,
port=port,
charset="utf-8",
decode_responses=True,
db=11)
controllers = redis.StrictRedis(host=url,
port=port,
charset="utf-8",
decode_responses=True,
db=10)
controller = Controller()
await controller.connect(
json.loads(controllers.get(c_name))['endpoints'][0], usr, pwd)
c_type = json.loads(controllers.get(c_name))['type']
logger.info('%s -> Adding credentials', m_name)
cloud_facade = client.CloudFacade.from_connection(
controller.connection)
for cred in json.loads(users.get(usr))['credentials']:
if cred['name'] == cred_name:
credential = cred
cloud_cred = client.UpdateCloudCredential(
client.CloudCredential(cred['key'], cred['type']),
tag.credential(c_type, usr, cred['name']))
await cloud_facade.UpdateCredentials([cloud_cred])
logger.info('%s -> Creating model: %s', m_name, m_name)
model = await controller.add_model(m_name,
cloud_name=c_type,
credential_name=credential['name'],
owner=tag.user(usr))
logger.info('%s -> model deployed on juju', m_name)
set_model_access(c_name, m_name, usr, users, 'admin')
set_model_state(c_name, m_name, 'ready', controllers, model.info.uuid)
logger.info('%s -> Adding ssh-keys to model: %s', m_name, m_name)
for key in json.loads(users.get(usr))['ssh-keys']:
try:
await model.add_ssh_key(usr, key)
except (JujuAPIError, JujuError):
pass
for u in json.loads(controllers.get(c_name))['users']:
if u['access'] == 'superuser':
await model.grant(u['name'], acl='admin')
set_model_access(c_name, m_name, u['name'], users, 'admin')
for key in json.loads(users.get(u['name']))['ssh-keys']:
try:
await model.add_ssh_key(u['name'], key)
except (JujuAPIError, JujuError):
pass
logger.info('%s -> succesfully deployed model', m_name)
except Exception as e:
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
for l in lines:
logger.error(l)
if 'model' in locals():
set_model_state(c_name, m_name, 'ready', controllers,
model.info.uuid)
else:
set_model_state(c_name, m_name, 'error', controllers)
finally:
if 'model' in locals():
await model.disconnect()
await controller.disconnect()
