async def destroy():
model = Model()
controller = Controller()
await controller.connect(controller_endpoint, username, password, cacert)
await model.connect_current()
import ipdb
ipdb.set_trace()
await controller.destroy_model(model.info.uuid)
model.disconnect()
controller.disconnect()
async def set_controller_acc(c_name, access, user, username, password, url,
port):
try:
controllers = redis.StrictRedis(host=url,
port=port,
charset="utf-8",
decode_responses=True,
db=10)
users = redis.StrictRedis(host=url,
port=port,
charset="utf-8",
decode_responses=True,
db=11)
con = json.loads(controllers.get(c_name))
usr = json.loads(users.get(user))
logger.info('Connecting to controller %s', c_name)
controller = Controller()
await controller.connect(con['endpoints'][0], username, password,
con['ca-cert'])
logger.info('Connected to controller %s ', c_name)
await controller.grant(user, acl=access)
exists = False
for contr in usr['controllers']:
if contr['name'] == c_name:
contr['access'] = access
exists = True
break
if not exists:
usr['controllers'].append({'name': c_name, 'access': access})
logger.info('Controller access set for %s ', c_name)
if access == 'superuser':
model = Model()
models = []
for mod in con['models']:
logger.info('Setting up connection for model: %s', mod['name'])
await model.connect(con['endpoints'][0], mod['uuid'], username,
password, con['ca-cert'])
await model.grant(user, acl='admin')
models.append({'name': mod['name'], 'access': 'admin'})
logger.info('Admin Access granted for for %s:%s', c_name,
mod['name'])
for key in usr['ssh-keys']:
await model.add_ssh_key(user, key)
model.disconnect()
for contro in usr['controllers']:
if contro['name'] == c_name:
contro['models'] = models
users.set(user, json.dumps(usr))
controller.disconnect()
except Exception:
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 set_model_acc(c_name, m_name, access, user, username, password, url, port):
try:
controllers = redis.StrictRedis(host=url, port=port, charset="utf-8", decode_responses=True, db=10)
users = redis.StrictRedis(host=url, port=port, charset="utf-8", decode_responses=True, db=11)
controller = json.loads(controllers.get(c_name))
usr = json.loads(users.get(user))
for mod in controller['models']:
if mod['name'] == m_name:
model = Model()
await model.connect(controller['endpoints'][0], mod['uuid'], username, password, controller['ca-cert'])
await model.grant(user, acl=access)
exists_con = False
for con in usr['controllers']:
if con['name'] == c_name:
exists_mod = False
exists_con = True
for mod in con['models']:
if mod['name'] == m_name:
mod['access'] = access
exists_mod = True
break
if not exists_mod:
con['models'].append({'name': m_name, 'access': access})
if not exists_con:
usr['controllers'].append({'name': c_name, 'access': 'login', 'models': [{'name': m_name, 'access': access}]})
contro = Controller()
await contro.connect(controller['endpoints'][0], username, password, controller['ca-cert'])
await contro.grant(user)
await contro.disconnect()
logger.info('%s access granted on %s:%s for %s', access, c_name, m_name, user)
if access == 'admin' or access == 'write':
for key in usr['ssh-keys']:
await model.add_ssh_key(user, key)
model.disconnect()
controllers.set(c_name, json.dumps(controller))
users.set(user, json.dumps(usr))
except Exception:
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 deploy():
# Create a Model instance. We need to connect our Model to a Juju api
# server before we can use it.
model = Model()
# Connect to the currently active Juju model
#await model.connect(controller_endpoint, model_uuid, username, password, cacert,)
await model.connect(controller_endpoint, model_uuid, username, password,
cacert)
# Deploy a single unit of the ubuntu charm, using revision 0 from the
# stable channel of the Charm Store.
ubuntu_app = await model.deploy(
'ubuntu-0',
application_name='ubuntu',
series='xenial',
channel='stable',
)
# Disconnect from the api server and cleanup.
model.disconnect()
