Пример #1
0
    def test_default_send_stringifies_headers(self, header_values, requests,
                                              store_service):
        communicator = ClientCommunicator(None)
        requests.put.return_value = Mock(status_code=200)
        communicator._default_send('bogus', None)

        header_values.assert_called_with(None)
Пример #2
0
    def _start_child_process(self):
        """
        Start a child process with the command.
        :return:
        """
        communicator = ClientCommunicator(
            self.master_uri,
            self.quarantine,
            verify_certs=self.verify_certs,
            get_files_auth=self.rapid_config.get_files_basic_auth)

        # Cleanup first
        self.workspace = OSUtil.path_join(
            self.workspace, str(self.work_request.action_instance_id))
        self.clean_workspace()

        env = self.get_environment()
        try:
            command = self.get_command(communicator)
            command.extend(self.get_arguments())

            # Check and download required files that will execute in command.
            try:
                self._download_required_files([self.work_request.executable],
                                              communicator, self.logger)
            except Exception as exception:
                self.logger.exception(exception)
                raise exception

            stdout = None
            stderr = None
            if self.logger:
                stdout = subprocess.PIPE
                stderr = subprocess.STDOUT

            self.child_process = subprocess.Popen(command,
                                                  cwd=self.workspace,
                                                  env=env,
                                                  stderr=stderr,
                                                  stdout=stdout)
            self.pid = self.child_process.pid

            StoreService.save_executor(self)

            # wait for the process to finish
            self.reading_thread = threading.Thread(
                target=self._read_process_output,
                args=(self.logger, self.child_process))
            self.reading_thread.daemon = True
            self.reading_thread.start()

            self.child_process.wait()

            self._finalize_run(communicator)
        except (BaseException, Exception) as exception:
            self.logger.exception(exception)
            communicator.send_done(self.work_request.action_instance_id,
                                   'FAILED', None, None, None, self.logger)
        finally:
            self.clean_workspace()
Пример #3
0
 def test_trial(self):
     config = ClientConfiguration(
         '/Users/mbright/code/cihub/vagrantconf/configs/rapid.cfg')
     client_communicator = ClientCommunicator(None)
     print(
         client_communicator._get_real_file_name('/mnt/d/rapid/workspace',
                                                 '/ci/build.sh'))
Пример #4
0
    def test_default_send_throws_exception(self, requests, store_service):
        communicator = ClientCommunicator(None)
        requests.put.return_value = Mock(status_code=404)
        with self.assertRaises(Exception) as exception:
            communicator._default_send('bogus', None)

        self.assertEqual('Status Code Failure: 404', str(exception.exception))
Пример #5
0
    def test_default_send_includes_the_master_api_key(self, requests,
                                                      store_service):
        mock_app = Mock(rapid_config=Mock(verify_certs=False))
        store_service.get_master_key.return_value = 'bogus_key'
        communicator = ClientCommunicator(None, flask_app=mock_app)
        requests.put.return_value = Mock(status_code=200)
        communicator._default_send('bogus', None)

        store_service.get_master_key.assert_called_with(mock_app)
        requests.put.assert_called_with(
            'bogus',
            data=None,
            json=None,
            headers={'X-Rapidci-Api-Key': 'bogus_key'},
            verify=False)
Пример #6
0
    def test_init(self):
        mock_app = Mock()
        client_communicator = ClientCommunicator("bogus", "/tmp/trial",
                                                 mock_app)

        eq_("bogus", client_communicator.server_uri)
        eq_("/tmp/trial", client_communicator.quarantine_directory)
        eq_(mock_app, client_communicator.flask_app)
Пример #7
0
    def test_get_register_headers(self, time):
        time.time.return_value = 1
        config = MasterConfiguration()
        config.register_api_key = 'Testing!@$%^'

        # per requests > 2.11.0 - All header values must be strings
        test = {
            'Content-Type': 'application/json',
            'X-RAPIDCI-PORT': str(config.port),
            'X-RAPIDCI-REGISTER-KEY': config.register_api_key,
            'X-RAPIDCI-TIME': '1000',
            'X-RAPIDCI-CLIENT-KEY': config.api_key
        }
        eq_(test, ClientCommunicator._get_register_headers(config))
Пример #8
0
    def test_register_post_data(self, socket):
        config = MasterConfiguration()
        config.grain_restrict = False
        config.grains = "one;two"

        socket.gethostname.return_value = "bogus"

        test = {
            "grains": "one;two",
            "grain_restrict": False,
            "hostname": 'bogus'
        }
        eq_(test,
            json.loads(ClientCommunicator._get_register_post_data(config)))
Пример #9
0
    def test_default_send_supports_post(self, requests, store_service):
        communicator = ClientCommunicator(None)
        requests.post.return_value = Mock(status_code=200)
        communicator._default_send('bogus', None, 'post')

        requests.post.assert_called()
Пример #10
0
    def __get_quarantined_items(self):
        items = []
        quarantine_directory = self.app.rapid_config.quarantine_directory
        if quarantine_directory:
            communicator = None
            if not os.path.isdir(quarantine_directory):
                os.makedirs(quarantine_directory)

            for item in os.listdir(quarantine_directory):
                if item in ['.', '..']:
                    continue
                try:
                    items.append({
                        'action_instance_id': int(item),
                        'pid': 'quarantined'
                    })
                    if communicator is None:
                        communicator = ClientCommunicator(
                            self.app.rapid_config.master_uri,
                            self.app.rapid_config.quarantine_directory,
                            verify_certs=self.app.rapid_config.verify_certs,
                            get_files_auth=self.app.rapid_config.
                            get_files_basic_auth)
                    try:
                        delete_file = False
                        with open("{}/{}".format(quarantine_directory, item),
                                  'r') as tmp_file:
                            data = pickle.loads(tmp_file.read())
                            try:
                                status = data['status']
                                parameters = data[
                                    'parameters'] if 'parameters' in data else None
                                stats = data[
                                    'stats'] if 'stats' in data else None
                                results = data[
                                    'results'] if 'results' in data else None

                                communicator.send_done(
                                    int(item),
                                    status,
                                    parameters,
                                    stats,
                                    results,
                                    logger,
                                    headers={'X-Rapid-Quarantine': 'true'})
                                delete_file = True
                            except Exception:
                                import traceback
                                traceback.print_exc()

                        if delete_file:
                            try:
                                os.remove("{}/{}".format(
                                    quarantine_directory, item))
                            except Exception:
                                logger.error("Couldn't remove.")
                    except Exception:
                        import traceback
                        traceback.print_exc()

                except Exception:
                    pass
        return items
Пример #11
0
 def test_get_real_file_name_not_empty_override(self, patch_env):
     patch_env.return_value = 'foobie_bubcus'
     communicator = ClientCommunicator(None)
     self.assertEqual('foofoobie_bubcusbar',
                      communicator._get_real_file_name('foo', 'bar'))
Пример #12
0
 def test_get_real_file_name_empty_override_uses_os_path(self, patch_os):
     patch_os.path_join.return_value = '/testing/this/thing'
     communicator = ClientCommunicator(None)
     self.assertEqual('/testing/this/thing',
                      communicator._get_real_file_name('foo', 'bar'))
Пример #13
0
    def test_default_send_defaults_to_put(self, requests, store_service):
        communicator = ClientCommunicator(None, flask_app=Mock())
        requests.put.return_value = Mock(status_code=200)
        communicator._default_send('bogus', None)

        requests.put.assert_called()