15 from juju
.controller
import Controller
17 # Disable InsecureRequestWarning w/LXD
19 urllib3
.disable_warnings()
20 logging
.getLogger("urllib3").setLevel(logging
.WARNING
)
22 here
= os
.path
.dirname(os
.path
.realpath(__file__
))
25 def is_bootstrapped():
26 result
= subprocess
.run(['juju', 'switch'], stdout
=subprocess
.PIPE
)
28 result
.returncode
== 0 and
29 len(result
.stdout
.decode().strip()) > 0)
32 bootstrapped
= pytest
.mark
.skipif(
33 not is_bootstrapped(),
34 reason
='bootstrapped Juju environment required')
37 class CleanController():
39 Context manager that automatically connects and disconnects from
40 the currently active controller.
42 Note: Unlike CleanModel, this will not create a new controller for you,
43 and an active controller must already be available.
46 self
._controller
= None
48 async def __aenter__(self
):
49 self
._controller
= Controller()
50 await self
._controller
.connect()
51 return self
._controller
53 async def __aexit__(self
, exc_type
, exc
, tb
):
54 await self
._controller
.disconnect()
58 """Format debug messages in a consistent way."""
59 now
= datetime
.datetime
.now()
61 # TODO: Decide on the best way to log. Output from `logging.debug` shows up
62 # when a test fails, but print() will always show up when running tox with
63 # `-s`, which is really useful for debugging single tests without having to
64 # insert a False assert to see the log.
66 "[{}] {}".format(now
.strftime('%Y-%m-%dT%H:%M:%S'), msg
)
69 # "[{}] {}".format(now.strftime('%Y-%m-%dT%H:%M:%S'), msg)
74 return "{}/charms".format(here
)
78 return "{}/charms/layers".format(here
)
81 def collect_metrics(application
):
82 """Invoke Juju's metrics collector.
84 Caveat: this shells out to the `juju collect-metrics` command, rather than
85 making an API call. At the time of writing, that API is not exposed through
90 subprocess
.check_call(['juju', 'collect-metrics', application
])
91 except subprocess
.CalledProcessError
as e
:
92 raise Exception("Unable to collect metrics: {}".format(e
))
95 def has_metrics(charm
):
96 """Check if a charm has metrics defined."""
97 metricsyaml
= "{}/{}/metrics.yaml".format(
101 if os
.path
.exists(metricsyaml
):
106 def get_descriptor(descriptor
):
109 tmp
= yaml
.load(descriptor
)
111 # Remove the envelope
112 root
= list(tmp
.keys())[0]
113 if root
== "nsd:nsd-catalog":
114 desc
= tmp
['nsd:nsd-catalog']['nsd'][0]
115 elif root
== "vnfd:vnfd-catalog":
116 desc
= tmp
['vnfd:vnfd-catalog']['vnfd'][0]
122 def get_n2vc(loop
=None):
123 """Return an instance of N2VC.VNF."""
124 log
= logging
.getLogger()
125 log
.level
= logging
.DEBUG
127 # Extract parameters from the environment in order to run our test
128 vca_host
= os
.getenv('VCA_HOST', '127.0.0.1')
129 vca_port
= os
.getenv('VCA_PORT', 17070)
130 vca_user
= os
.getenv('VCA_USER', 'admin')
131 vca_charms
= os
.getenv('VCA_CHARMS', None)
132 vca_secret
= os
.getenv('VCA_SECRET', None)
134 client
= n2vc
.vnf
.N2VC(
140 artifacts
=vca_charms
,
146 def create_lxd_container(public_key
=None, name
="test_name"):
148 Returns a container object
150 If public_key isn't set, we'll use the Juju ssh key
152 :param public_key: The public key to inject into the container
153 :param name: The name of the test being run
157 # Format name so it's valid
158 name
= name
.replace("_", "-").replace(".", "")
160 client
= get_lxd_client()
161 test_machine
= "test-{}-{}".format(
162 uuid
.uuid4().hex[-4:],
166 private_key_path
, public_key_path
= find_n2vc_ssh_keys()
169 # create profile w/cloud-init and juju ssh key
172 with
open(public_key_path
, "r") as f
:
173 public_key
= f
.readline()
175 client
.profiles
.create(
178 'user.user-data': '#cloud-config\nssh_authorized_keys:\n- {}'.format(public_key
)},
180 'root': {'path': '/', 'pool': 'default', 'type': 'disk'},
182 'nictype': 'bridged',
188 except Exception as ex
:
189 debug("Error creating lxd profile {}: {}".format(test_machine
, ex
))
195 'name': test_machine
,
200 'protocol': 'simplestreams',
201 'server': 'https://cloud-images.ubuntu.com/releases',
203 'profiles': [test_machine
],
205 container
= client
.containers
.create(config
, wait
=True)
206 container
.start(wait
=True)
207 except Exception as ex
:
208 debug("Error creating lxd container {}: {}".format(test_machine
, ex
))
209 # This is a test-ending failure.
212 def wait_for_network(container
, timeout
=30):
213 """Wait for eth0 to have an ipv4 address."""
214 starttime
= time
.time()
215 while(time
.time() < starttime
+ timeout
):
217 if 'eth0' in container
.state().network
:
218 addresses
= container
.state().network
['eth0']['addresses']
219 if len(addresses
) > 0:
220 if addresses
[0]['family'] == 'inet':
225 wait_for_network(container
)
226 except Exception as ex
:
228 "Error waiting for container {} network: {}".format(
234 # HACK: We need to give sshd a chance to bind to the interface,
235 # and pylxd's container.execute seems to be broken and fails and/or
236 # hangs trying to properly check if the service is up.
237 (exit_code
, stdout
, stderr
) = container
.execute([
239 '-c', '5', # Wait for 5 ECHO_REPLY
240 '8.8.8.8', # Ping Google's public DNS
241 '-W', '15', # Set a 15 second deadline
245 raise Exception("Unable to verify container network")
250 def destroy_lxd_container(container
):
251 """Stop and delete a LXD container.
253 Sometimes we see errors talking to LXD -- ephemerial issues like
254 load or a bug that's killed the API. We'll do our best to clean
255 up here, and we should run a cleanup after all tests are finished
256 to remove any extra containers and profiles belonging to us.
259 if type(container
) is bool:
262 name
= container
.name
263 debug("Destroying container {}".format(name
))
265 client
= get_lxd_client()
267 def wait_for_stop(timeout
=30):
268 """Wait for eth0 to have an ipv4 address."""
269 starttime
= time
.time()
270 while(time
.time() < starttime
+ timeout
):
272 if container
.state
== "Stopped":
275 def wait_for_delete(timeout
=30):
276 starttime
= time
.time()
277 while(time
.time() < starttime
+ timeout
):
279 if client
.containers
.exists(name
) is False:
283 container
.stop(wait
=False)
285 except Exception as ex
:
287 "Error stopping container {}: {}".format(
294 container
.delete(wait
=False)
296 except Exception as ex
:
298 "Error deleting container {}: {}".format(
305 # Delete the profile created for this container
306 profile
= client
.profiles
.get(name
)
309 except Exception as ex
:
311 "Error deleting profile {}: {}".format(
318 def find_lxd_config():
319 """Find the LXD configuration directory."""
321 paths
.append(os
.path
.expanduser("~/.config/lxc"))
322 paths
.append(os
.path
.expanduser("~/snap/lxd/current/.config/lxc"))
325 if os
.path
.exists(path
):
326 crt
= os
.path
.expanduser("{}/client.crt".format(path
))
327 key
= os
.path
.expanduser("{}/client.key".format(path
))
328 if os
.path
.exists(crt
) and os
.path
.exists(key
):
333 def find_n2vc_ssh_keys():
334 """Find the N2VC ssh keys."""
337 paths
.append(os
.path
.expanduser("~/.ssh/"))
340 if os
.path
.exists(path
):
341 private
= os
.path
.expanduser("{}/id_n2vc_rsa".format(path
))
342 public
= os
.path
.expanduser("{}/id_n2vc_rsa.pub".format(path
))
343 if os
.path
.exists(private
) and os
.path
.exists(public
):
344 return (private
, public
)
348 def find_juju_ssh_keys():
349 """Find the Juju ssh keys."""
352 paths
.append(os
.path
.expanduser("~/.local/share/juju/ssh/"))
355 if os
.path
.exists(path
):
356 private
= os
.path
.expanduser("{}/juju_id_rsa".format(path
))
357 public
= os
.path
.expanduser("{}/juju_id_rsa.pub".format(path
))
358 if os
.path
.exists(private
) and os
.path
.exists(public
):
359 return (private
, public
)
363 def get_juju_private_key():
364 keys
= find_juju_ssh_keys()
368 def get_lxd_client(host
="127.0.0.1", port
="8443", verify
=False):
369 """ Get the LXD client."""
371 (crt
, key
) = find_lxd_config()
374 client
= pylxd
.Client(
375 endpoint
="https://{}:{}".format(host
, port
),
383 # TODO: This is marked serial but can be run in parallel with work, including:
384 # - Fixing an event loop issue; seems that all tests stop when one test stops?
388 class TestN2VC(object):
390 1. Validator Validation
392 Automatically validate the descriptors we're using here, unless the test author explicitly wants to skip them. Useful to make sure tests aren't being run against invalid descriptors, validating functionality that may fail against a properly written descriptor.
394 We need to have a flag (instance variable) that controls this behavior. It may be necessary to skip validation and run against a descriptor implementing features that have not yet been released in the Information Model.
398 The six phases of integration testing, for the test itself and each charm?:
400 setup/teardown_class:
401 1. Prepare - Verify the environment and create a new model
402 2. Deploy - Mark the test as ready to execute
403 3. Configure - Configuration to reach Active state
404 4. Test - Execute primitive(s) to verify success
405 5. Collect - Collect any useful artifacts for debugging (charm, logs)
406 6. Destroy - Destroy the model
409 1. Prepare - Building of charm
410 2. Deploy - Deploying charm
411 3. Configure - Configuration to reach Active state
412 4. Test - Execute primitive(s) to verify success
413 5. Collect - Collect any useful artifacts for debugging (charm, logs)
414 6. Destroy - Destroy the charm
418 def setup_class(self
):
419 """ setup any state specific to the execution of the given class (which
420 usually contains tests).
422 # Initialize instance variable(s)
425 # Track internal state for each test run
428 # Parse the test's descriptors
429 self
.nsd
= get_descriptor(self
.NSD_YAML
)
430 self
.vnfd
= get_descriptor(self
.VNFD_YAML
)
432 self
.ns_name
= self
.nsd
['name']
433 self
.vnf_name
= self
.vnfd
['name']
435 # Hard-coded to default for now, but this may change in the future.
436 self
.model
= "default"
439 self
.parse_vnf_descriptor()
440 assert self
.charms
is not {}
442 # Track artifacts, like compiled charms, that will need to be removed
445 # Build the charm(s) needed for this test
446 for charm
in self
.get_charm_names():
447 self
.get_charm(charm
)
449 # A bit of a hack, in order to allow the N2VC callback to run parallel
450 # to pytest. Test(s) should wait for this flag to change to False
453 self
._stopping
= False
456 def teardown_class(self
):
457 """ teardown any state that was previously setup with a call to
460 debug("Running teardown_class...")
463 debug("Destroying LXD containers...")
464 for application
in self
.state
:
465 if self
.state
[application
]['container']:
466 destroy_lxd_container(self
.state
[application
]['container'])
467 debug("Destroying LXD containers...done.")
471 debug("teardown_class(): Logging out of N2VC...")
472 yield from self
.n2vc
.logout()
473 debug("teardown_class(): Logging out of N2VC...done.")
475 debug("Running teardown_class...done.")
476 except Exception as ex
:
477 debug("Exception in teardown_class: {}".format(ex
))
480 def all_charms_active(self
):
481 """Determine if the all deployed charms are active."""
484 for application
in self
.state
:
485 if 'status' in self
.state
[application
]:
486 debug("status of {} is '{}'".format(
488 self
.state
[application
]['status'],
490 if self
.state
[application
]['status'] == 'active':
493 debug("Active charms: {}/{}".format(
498 if active
== len(self
.charms
):
504 def are_tests_finished(self
):
505 appcount
= len(self
.state
)
507 # If we don't have state yet, keep running.
509 debug("No applications")
513 debug("_stopping is True")
517 for application
in self
.state
:
518 if self
.state
[application
]['done']:
521 debug("{}/{} charms tested".format(appdone
, appcount
))
523 if appcount
== appdone
:
529 async def running(self
, timeout
=600):
530 """Returns if the test is still running.
532 @param timeout The time, in seconds, to wait for the test to complete.
534 if self
.are_tests_finished():
538 await asyncio
.sleep(30)
543 def get_charm(self
, charm
):
544 """Build and return the path to the test charm.
546 Builds one of the charms in tests/charms/layers and returns the path
547 to the compiled charm. The charm will automatically be removed when
548 when the test is complete.
550 Returns: The path to the built charm or None if `charm build` failed.
553 # Make sure the charm snap is installed
555 subprocess
.check_call(['which', 'charm'])
556 except subprocess
.CalledProcessError
as e
:
557 raise Exception("charm snap not installed.")
559 if charm
not in self
.artifacts
:
561 # Note: This builds the charm under N2VC/tests/charms/builds/
562 # Currently, the snap-installed command only has write access
563 # to the $HOME (changing in an upcoming release) so writing to
564 # /tmp isn't possible at the moment.
565 builds
= get_charm_path()
567 if not os
.path
.exists("{}/builds/{}".format(builds
, charm
)):
568 cmd
= "charm build {}/{} -o {}/".format(
573 subprocess
.check_call(shlex
.split(cmd
))
575 self
.artifacts
[charm
] = {
577 'charm': "{}/builds/{}".format(builds
, charm
),
579 except subprocess
.CalledProcessError
as e
:
580 raise Exception("charm build failed: {}.".format(e
))
582 return self
.artifacts
[charm
]['charm']
585 async def deploy(self
, vnf_index
, charm
, params
, loop
):
586 """An inner function to do the deployment of a charm from
591 self
.n2vc
= get_n2vc(loop
=loop
)
593 application
= self
.n2vc
.FormatApplicationName(
599 # Initialize the state of the application
600 self
.state
[application
] = {
601 'status': None, # Juju status
602 'container': None, # lxd container, for proxy charms
603 'actions': {}, # Actions we've executed
604 'done': False, # Are we done testing this charm?
605 'phase': "deploy", # What phase is this application in?
608 debug("Deploying charm at {}".format(self
.artifacts
[charm
]))
610 # If this is a native charm, we need to provision the underlying
611 # machine ala an LXC container.
614 if not self
.isproxy(application
):
615 debug("Creating container for native charm")
616 # args = ("default", application, None, None)
617 self
.state
[application
]['container'] = create_lxd_container(
618 name
=os
.path
.basename(__file__
)
621 hostname
= self
.get_container_ip(
622 self
.state
[application
]['container'],
630 await self
.n2vc
.DeployCharms(
634 self
.get_charm(charm
),
641 def parse_vnf_descriptor(self
):
642 """Parse the VNF descriptor to make running tests easier.
644 Parse the charm information in the descriptor to make it easy to write
645 tests to run again it.
647 Each charm becomes a dictionary in a list:
650 'vnf-member-index': 1,
653 'initial-config-primitive': {},
654 'config-primitive': {}
657 - is this a proxy charm?
658 - what are the initial-config-primitives (day 1)?
659 - what are the config primitives (day 2)?
664 # You'd think this would be explicit, but it's just an incremental
665 # value that should be consistent.
668 """Get all vdu and/or vdu config in a descriptor."""
669 config
= self
.get_config()
673 # Get the name to be used for the deployed application
674 application_name
= n2vc
.vnf
.N2VC().FormatApplicationName(
677 str(vnf_member_index
),
681 'application-name': application_name
,
683 'vnf-member-index': vnf_member_index
,
684 'vnf-name': self
.vnf_name
,
686 'initial-config-primitive': {},
687 'config-primitive': {},
691 charm
['name'] = juju
['charm']
694 charm
['proxy'] = juju
['proxy']
696 if 'initial-config-primitive' in cfg
:
697 charm
['initial-config-primitive'] = \
698 cfg
['initial-config-primitive']
700 if 'config-primitive' in cfg
:
701 charm
['config-primitive'] = cfg
['config-primitive']
703 charms
[application_name
] = charm
705 # Increment the vnf-member-index
706 vnf_member_index
+= 1
711 def isproxy(self
, application_name
):
713 assert application_name
in self
.charms
714 assert 'proxy' in self
.charms
[application_name
]
715 assert type(self
.charms
[application_name
]['proxy']) is bool
717 # debug(self.charms[application_name])
718 return self
.charms
[application_name
]['proxy']
721 def get_config(self
):
722 """Return an iterable list of config items (vdu and vnf).
724 As far as N2VC is concerned, the config section for vdu and vnf are
725 identical. This joins them together so tests only need to iterate
730 """Get all vdu and/or vdu config in a descriptor."""
731 vnf_config
= self
.vnfd
.get("vnf-configuration")
733 juju
= vnf_config
['juju']
735 configs
.append(vnf_config
)
737 for vdu
in self
.vnfd
['vdu']:
738 vdu_config
= vdu
.get('vdu-configuration')
740 juju
= vdu_config
['juju']
742 configs
.append(vdu_config
)
747 def get_charm_names(self
):
748 """Return a list of charms used by the test descriptor."""
752 # Check if the VDUs in this VNF have a charm
753 for config
in self
.get_config():
754 juju
= config
['juju']
757 if name
not in charms
:
763 def get_phase(self
, application
):
764 return self
.state
[application
]['phase']
767 def set_phase(self
, application
, phase
):
768 self
.state
[application
]['phase'] = phase
771 async def configure_proxy_charm(self
, *args
):
772 """Configure a container for use via ssh."""
773 (model
, application
, _
, _
) = args
776 if self
.get_phase(application
) == "deploy":
777 self
.set_phase(application
, "configure")
779 debug("Start CreateContainer for {}".format(application
))
780 self
.state
[application
]['container'] = \
781 await self
.CreateContainer(*args
)
782 debug("Done CreateContainer for {}".format(application
))
784 if self
.state
[application
]['container']:
785 debug("Configure {} for container".format(application
))
786 if await self
.configure_ssh_proxy(application
):
787 await asyncio
.sleep(0.1)
790 debug("Failed to configure container for {}".format(application
))
792 debug("skipping CreateContainer for {}: {}".format(
794 self
.get_phase(application
),
797 except Exception as ex
:
798 debug("configure_proxy_charm exception: {}".format(ex
))
800 await asyncio
.sleep(0.1)
805 async def execute_charm_tests(self
, *args
):
806 (model
, application
, _
, _
) = args
808 debug("Executing charm test(s) for {}".format(application
))
810 if self
.state
[application
]['done']:
811 debug("Trying to execute tests against finished charm...aborting")
815 phase
= self
.get_phase(application
)
816 # We enter the test phase when after deploy (for native charms) or
817 # configure, for proxy charms.
818 if phase
in ["deploy", "configure"]:
819 self
.set_phase(application
, "test")
820 if self
.are_tests_finished():
821 raise Exception("Trying to execute init-config on finished test")
823 if await self
.execute_initial_config_primitives(application
):
825 await self
.check_metrics(application
)
827 debug("Done testing {}".format(application
))
828 self
.state
[application
]['done'] = True
830 except Exception as ex
:
831 debug("Exception in execute_charm_tests: {}".format(ex
))
833 await asyncio
.sleep(0.1)
838 async def CreateContainer(self
, *args
):
839 """Create a LXD container for use with a proxy charm.abs
841 1. Get the public key from the charm via `get-ssh-public-key` action
842 2. Create container with said key injected for the ubuntu user
844 Returns a Container object
846 # Create and configure a LXD container for use with a proxy charm.
847 (model
, application
, _
, _
) = args
849 debug("[CreateContainer] {}".format(args
))
853 # Execute 'get-ssh-public-key' primitive and get returned value
854 uuid
= await self
.n2vc
.ExecutePrimitive(
857 "get-ssh-public-key",
861 result
= await self
.n2vc
.GetPrimitiveOutput(model
, uuid
)
862 pubkey
= result
['pubkey']
864 container
= create_lxd_container(
866 name
=os
.path
.basename(__file__
)
870 except Exception as ex
:
871 debug("Error creating container: {}".format(ex
))
877 async def stop(self
):
881 - Stop and delete containers
884 TODO: Clean up duplicate code between teardown_class() and stop()
886 debug("stop() called")
888 if self
.n2vc
and self
._running
and not self
._stopping
:
889 self
._running
= False
890 self
._stopping
= True
892 for application
in self
.charms
:
894 await self
.n2vc
.RemoveCharms(self
.model
, application
)
897 # Wait for the application to be removed
898 await asyncio
.sleep(10)
899 if not await self
.n2vc
.HasApplication(
905 # Need to wait for the charm to finish, because native charms
906 if self
.state
[application
]['container']:
907 debug("Deleting LXD container...")
908 destroy_lxd_container(
909 self
.state
[application
]['container']
911 self
.state
[application
]['container'] = None
912 debug("Deleting LXD container...done.")
914 debug("No container found for {}".format(application
))
915 except Exception as e
:
916 debug("Error while deleting container: {}".format(e
))
920 debug("stop(): Logging out of N2VC...")
921 await self
.n2vc
.logout()
923 debug("stop(): Logging out of N2VC...Done.")
924 except Exception as ex
:
927 # Let the test know we're finished.
928 debug("Marking test as finished.")
929 # self._running = False
931 debug("Skipping stop()")
934 def get_container_ip(self
, container
):
935 """Return the IPv4 address of container's eth0 interface."""
938 addresses
= container
.state().network
['eth0']['addresses']
939 # The interface may have more than one address, but we only need
940 # the first one for testing purposes.
941 ipaddr
= addresses
[0]['address']
946 async def configure_ssh_proxy(self
, application
, task
=None):
947 """Configure the proxy charm to use the lxd container.
949 Configure the charm to use a LXD container as it's VNF.
951 debug("Configuring ssh proxy for {}".format(application
))
953 mgmtaddr
= self
.get_container_ip(
954 self
.state
[application
]['container'],
958 "Setting ssh-hostname for {} to {}".format(
964 await self
.n2vc
.ExecutePrimitive(
970 'ssh-hostname': mgmtaddr
,
971 'ssh-username': 'ubuntu',
978 async def execute_initial_config_primitives(self
, application
, task
=None):
979 debug("Executing initial_config_primitives for {}".format(application
))
981 init_config
= self
.charms
[application
]
984 The initial-config-primitive is run during deploy but may fail
985 on some steps because proxy charm access isn't configured.
987 Re-run those actions so we can inspect the status.
989 uuids
= await self
.n2vc
.ExecuteInitialPrimitives(
996 ExecutePrimitives will return a list of uuids. We need to check the
997 status of each. The test continues if all Actions succeed, and
998 fails if any of them fail.
1000 await self
.wait_for_uuids(application
, uuids
)
1001 debug("Primitives for {} finished.".format(application
))
1004 except Exception as ex
:
1005 debug("execute_initial_config_primitives exception: {}".format(ex
))
1010 async def check_metrics(self
, application
, task
=None):
1011 """Check and run metrics, if present.
1013 Checks to see if metrics are specified by the charm. If so, collects
1016 If no metrics, then mark the test as finished.
1018 if has_metrics(self
.charms
[application
]['name']):
1019 debug("Collecting metrics for {}".format(application
))
1021 metrics
= await self
.n2vc
.GetMetrics(
1026 return await self
.verify_metrics(application
, metrics
)
1029 async def verify_metrics(self
, application
, metrics
):
1030 """Verify the charm's metrics.
1032 Verify that the charm has sent metrics successfully.
1034 Stops the test when finished.
1036 debug("Verifying metrics for {}: {}".format(application
, metrics
))
1042 # TODO: Ran into a case where it took 9 attempts before metrics
1043 # were available; the controller is slow sometimes.
1044 await asyncio
.sleep(30)
1045 return await self
.check_metrics(application
)
1048 async def wait_for_uuids(self
, application
, uuids
):
1049 """Wait for primitives to execute.
1051 The task will provide a list of uuids representing primitives that are
1054 debug("Waiting for uuids for {}: {}".format(application
, uuids
))
1055 waitfor
= len(uuids
)
1058 while waitfor
> finished
:
1060 await asyncio
.sleep(10)
1062 if uuid
not in self
.state
[application
]['actions']:
1063 self
.state
[application
]['actions'][uid
] = "pending"
1065 status
= self
.state
[application
]['actions'][uid
]
1067 # Have we already marked this as done?
1068 if status
in ["pending", "running"]:
1070 debug("Getting status of {} ({})...".format(uid
, status
))
1071 status
= await self
.n2vc
.GetPrimitiveStatus(
1075 debug("...state of {} is {}".format(uid
, status
))
1076 self
.state
[application
]['actions'][uid
] = status
1078 if status
in ['completed', 'failed']:
1081 debug("{}/{} actions complete".format(finished
, waitfor
))
1083 # Wait for the primitive to finish and try again
1084 if waitfor
> finished
:
1085 debug("Waiting 10s for action to finish...")
1086 await asyncio
.sleep(10)
1089 def n2vc_callback(self
, *args
, **kwargs
):
1090 (model
, application
, status
, message
) = args
1091 # debug("callback: {}".format(args))
1093 if application
not in self
.state
:
1094 # Initialize the state of the application
1095 self
.state
[application
] = {
1096 'status': None, # Juju status
1097 'container': None, # lxd container, for proxy charms
1098 'actions': {}, # Actions we've executed
1099 'done': False, # Are we done testing this charm?
1100 'phase': "deploy", # What phase is this application in?
1103 self
.state
[application
]['status'] = status
1105 if status
in ['waiting', 'maintenance', 'unknown']:
1106 # Nothing to do for these
1109 debug("callback: {}".format(args
))
1111 if self
.state
[application
]['done']:
1112 debug("{} is done".format(application
))
1115 if status
in ["blocked"] and self
.isproxy(application
):
1116 if self
.state
[application
]['phase'] == "deploy":
1117 debug("Configuring proxy charm for {}".format(application
))
1118 asyncio
.ensure_future(self
.configure_proxy_charm(*args
))
1120 elif status
in ["active"]:
1121 """When a charm is active, we can assume that it has been properly
1122 configured (not blocked), regardless of if it's a proxy or not.
1124 All primitives should be complete by init_config_primitive
1126 asyncio
.ensure_future(self
.execute_charm_tests(*args
))