Exemple #1
0
    def get_create_amphora_flow(self):
        """Creates a flow to create an amphora.

        :returns: The flow for creating the amphora
        """
        create_amphora_flow = linear_flow.Flow(constants.CREATE_AMPHORA_FLOW)
        create_amphora_flow.add(
            database_tasks.CreateAmphoraInDB(provides=constants.AMPHORA_ID))
        create_amphora_flow.add(
            lifecycle_tasks.AmphoraIDToErrorOnRevertTask(
                requires=constants.AMPHORA_ID))
        if self.REST_AMPHORA_DRIVER:
            create_amphora_flow.add(
                cert_task.GenerateServerPEMTask(provides=constants.SERVER_PEM))

            create_amphora_flow.add(
                database_tasks.UpdateAmphoraDBCertExpiration(
                    requires=(constants.AMPHORA_ID, constants.SERVER_PEM)))

            create_amphora_flow.add(
                compute_tasks.CertComputeCreate(
                    requires=(constants.AMPHORA_ID, constants.SERVER_PEM,
                              constants.BUILD_TYPE_PRIORITY),
                    provides=constants.COMPUTE_ID))
        else:
            create_amphora_flow.add(
                compute_tasks.ComputeCreate(
                    requires=(constants.AMPHORA_ID,
                              constants.BUILD_TYPE_PRIORITY),
                    provides=constants.COMPUTE_ID))
        create_amphora_flow.add(
            database_tasks.MarkAmphoraBootingInDB(
                requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
        create_amphora_flow.add(
            compute_tasks.ComputeActiveWait(requires=(constants.COMPUTE_ID,
                                                      constants.AMPHORA_ID),
                                            provides=constants.COMPUTE_OBJ))
        create_amphora_flow.add(
            database_tasks.UpdateAmphoraInfo(requires=(constants.AMPHORA_ID,
                                                       constants.COMPUTE_OBJ),
                                             provides=constants.AMPHORA))
        create_amphora_flow.add(
            amphora_driver_tasks.AmphoraComputeConnectivityWait(
                requires=constants.AMPHORA))
        create_amphora_flow.add(
            database_tasks.ReloadAmphora(requires=constants.AMPHORA_ID,
                                         provides=constants.AMPHORA))
        create_amphora_flow.add(
            amphora_driver_tasks.AmphoraFinalize(requires=constants.AMPHORA))
        create_amphora_flow.add(
            database_tasks.MarkAmphoraReadyInDB(requires=constants.AMPHORA))

        return create_amphora_flow
    def test_AmphoraIDToErrorOnRevertTask(self, mock_amp_status_error):

        amp_id_to_error_on_revert = (
            lifecycle_tasks.AmphoraIDToErrorOnRevertTask())

        # Execute
        amp_id_to_error_on_revert.execute(self.AMPHORA_ID)

        self.assertFalse(mock_amp_status_error.called)

        # Revert
        amp_id_to_error_on_revert.revert(self.AMPHORA_ID)

        mock_amp_status_error.assert_called_once_with(self.AMPHORA_ID)