6 from .client
import client
7 from .client
import connection
8 from .model
import Model
10 log
= logging
.getLogger(__name__
)
13 class Controller(object):
14 def __init__(self
, loop
=None):
15 """Instantiate a new Controller.
17 One of the connect_* methods will need to be called before this
18 object can be used for anything interesting.
20 :param loop: an asyncio event loop
23 self
.loop
= loop
or asyncio
.get_event_loop()
24 self
.connection
= None
25 self
.controller_name
= None
28 self
, endpoint
, username
, password
, cacert
=None, macaroons
=None):
29 """Connect to an arbitrary Juju controller.
32 self
.connection
= await connection
.Connection
.connect(
33 endpoint
, None, username
, password
, cacert
, macaroons
)
35 async def connect_current(self
):
36 """Connect to the current Juju controller.
40 await connection
.Connection
.connect_current_controller())
42 async def connect_controller(self
, controller_name
):
43 """Connect to a Juju controller by name.
47 await connection
.Connection
.connect_controller(controller_name
))
48 self
.controller_name
= controller_name
50 async def disconnect(self
):
51 """Shut down the watcher task and close websockets.
54 if self
.connection
and self
.connection
.is_open
:
55 log
.debug('Closing controller connection')
56 await self
.connection
.close()
57 self
.connection
= None
60 self
, model_name
, cloud_name
=None, credential_name
=None,
61 owner
=None, config
=None, region
=None):
62 """Add a model to this controller.
64 :param str model_name: Name to give the new model.
65 :param str cloud_name: Name of the cloud in which to create the
66 model, e.g. 'aws'. Defaults to same cloud as controller.
67 :param str credential_name: Name of the credential to use when
68 creating the model. Defaults to current credential. If you
69 pass a credential_name, you must also pass a cloud_name,
70 even if it's the default cloud.
71 :param str owner: Username that will own the model. Defaults to
73 :param dict config: Model configuration.
74 :param str region: Region in which to create the model.
77 model_facade
= client
.ModelManagerFacade()
78 model_facade
.connect(self
.connection
)
80 owner
= owner
or self
.connection
.info
['user-info']['identity']
81 cloud_name
= cloud_name
or await self
.get_cloud()
84 credential
= tag
.credential(
86 tag
.untag('user-', owner
),
92 log
.debug('Creating model %s', model_name
)
94 model_info
= await model_facade
.CreateModel(
95 tag
.cloud(cloud_name
),
103 # Add our ssh key to the model, to work around
104 # https://bugs.launchpad.net/juju/+bug/1643076
106 ssh_key
= await utils
.read_ssh_key(loop
=self
.loop
)
108 if self
.controller_name
:
109 model_name
= "{}:{}".format(self
.controller_name
, model_name
)
111 cmd
= ['juju', 'add-ssh-key', '-m', model_name
, ssh_key
]
113 await utils
.execute_process(*cmd
, log
=log
, loop
=self
.loop
)
116 "Could not add ssh key to model. You will not be able "
117 "to ssh into machines in this model. "
118 "Manually running `juju add-ssh-key <key>` in the cli "
119 "may fix this problem.")
123 self
.connection
.endpoint
,
125 self
.connection
.username
,
126 self
.connection
.password
,
127 self
.connection
.cacert
,
128 self
.connection
.macaroons
,
134 async def destroy_models(self
, *uuids
):
135 """Destroy one or more models.
137 :param str \*uuids: UUIDs of models to destroy
140 model_facade
= client
.ModelManagerFacade()
141 model_facade
.connect(self
.connection
)
144 'Destroying model%s %s',
145 '' if len(uuids
) == 1 else 's',
149 await model_facade
.DestroyModels([
150 client
.Entity(tag
.model(uuid
))
153 destroy_model
= destroy_models
155 async def add_user(self
, username
, password
=None, display_name
=None):
156 """Add a user to this controller.
158 :param str username: Username
159 :param str display_name: Display name
160 :param str acl: Access control, e.g. 'read'
161 :param list models: Models to which the user is granted access
165 display_name
= username
166 user_facade
= client
.UserManagerFacade()
167 user_facade
.connect(self
.connection
)
168 users
= [{'display_name': display_name
,
169 'password': password
,
170 'username': username
}]
171 return await user_facade
.AddUser(users
)
173 async def change_user_password(self
, username
, password
):
174 """Change the password for a user in this controller.
176 :param str username: Username
177 :param str password: New password
180 user_facade
= client
.UserManagerFacade()
181 user_facade
.connect(self
.connection
)
182 entity
= client
.EntityPassword(password
, tag
.user(username
))
183 return await user_facade
.SetPassword([entity
])
185 async def destroy(self
, destroy_all_models
=False):
186 """Destroy this controller.
188 :param bool destroy_all_models: Destroy all hosted models in the
192 controller_facade
= client
.ControllerFacade()
193 controller_facade
.connect(self
.connection
)
194 return await controller_facade
.DestroyController(destroy_all_models
)
196 async def disable_user(self
, username
):
199 :param str username: Username
202 user_facade
= client
.UserManagerFacade()
203 user_facade
.connect(self
.connection
)
204 entity
= client
.Entity(tag
.user(username
))
205 return await user_facade
.DisableUser([entity
])
207 async def enable_user(self
, username
):
208 """Re-enable a previously disabled user.
211 user_facade
= client
.UserManagerFacade()
212 user_facade
.connect(self
.connection
)
213 entity
= client
.Entity(tag
.user(username
))
214 return await user_facade
.EnableUser([entity
])
217 """Forcibly terminate all machines and other associated resources for
221 raise NotImplementedError()
223 async def get_cloud(self
):
225 Get the name of the cloud that this controller lives on.
227 cloud_facade
= client
.CloudFacade()
228 cloud_facade
.connect(self
.connection
)
230 result
= await cloud_facade
.Clouds()
231 cloud
= list(result
.clouds
.keys())[0] # only lives on one cloud
232 return tag
.untag('cloud-', cloud
)
234 async def get_models(self
, all_
=False, username
=None):
235 """Return list of available models on this controller.
237 :param bool all_: List all models, regardless of user accessibilty
239 :param str username: User for which to list models (admin use only)
242 controller_facade
= client
.ControllerFacade()
243 controller_facade
.connect(self
.connection
)
244 return await controller_facade
.AllModels()
247 def get_payloads(self
, *patterns
):
248 """Return list of known payloads.
250 :param str \*patterns: Patterns to match against
252 Each pattern will be checked against the following info in Juju::
263 raise NotImplementedError()
265 def get_users(self
, all_
=False):
266 """Return list of users that can connect to this controller.
268 :param bool all_: Include disabled users
271 raise NotImplementedError()
274 """Log in to this controller.
277 raise NotImplementedError()
279 def logout(self
, force
=False):
280 """Log out of this controller.
282 :param bool force: Don't fail even if user not previously logged in
286 raise NotImplementedError()
288 def get_model(self
, name
):
289 """Get a model by name.
291 :param str name: Model name
294 raise NotImplementedError()
296 async def get_user(self
, username
, include_disabled
=False):
297 """Get a user by name.
299 :param str username: Username
302 client_facade
= client
.UserManagerFacade()
303 client_facade
.connect(self
.connection
)
304 user
= tag
.user(username
)
305 return await client_facade
.UserInfo([client
.Entity(user
)], include_disabled
)
307 async def grant(self
, username
, acl
='login'):
308 """Set access level of the given user on the controller
310 :param str username: Username
311 :param str acl: Access control ('login', 'add-model' or 'superuser')
314 controller_facade
= client
.ControllerFacade()
315 controller_facade
.connect(self
.connection
)
316 user
= tag
.user(username
)
317 await self
.revoke(username
)
318 changes
= client
.ModifyControllerAccess(acl
, 'grant', user
)
319 return await controller_facade
.ModifyControllerAccess([changes
])
321 async def revoke(self
, username
):
322 """Removes all access from a controller
324 :param str username: username
327 controller_facade
= client
.ControllerFacade()
328 controller_facade
.connect(self
.connection
)
329 user
= tag
.user(username
)
330 changes
= client
.ModifyControllerAccess('login', 'revoke', user
)
331 return await controller_facade
.ModifyControllerAccess([changes
])