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()