Exemplo n.º 1
0
    def _connect_and_execute(self, pantsd_handle):
        port = pantsd_handle.port
        # Merge the nailgun TTY capability environment variables with the passed environment dict.
        ng_env = NailgunProtocol.isatty_to_env(self._stdin, self._stdout,
                                               self._stderr)
        modified_env = combined_dict(self._env, ng_env)
        modified_env['PANTSD_RUNTRACKER_CLIENT_START_TIME'] = str(
            self._start_time)
        modified_env['PANTSD_REQUEST_TIMEOUT_LIMIT'] = str(
            self._bootstrap_options.for_global_scope(
            ).pantsd_timeout_when_multiple_invocations)

        assert isinstance(port, int), \
          'port {} is not an integer! It has type {}.'.format(port, type(port))

        # Instantiate a NailgunClient.
        client = NailgunClient(
            port=port,
            ins=self._stdin,
            out=self._stdout,
            err=self._stderr,
            exit_on_broken_pipe=True,
            metadata_base_dir=pantsd_handle.metadata_base_dir)

        with self._trapped_signals(client), STTYSettings.preserved():
            # Execute the command on the pailgun.
            result = client.execute(self.PANTS_COMMAND, *self._args,
                                    **modified_env)

        # Exit.
        self._exiter.exit(result)
Exemplo n.º 2
0
    def _connect_and_execute(self, pantsd_handle: PantsDaemon.Handle) -> ExitCode:
        port = pantsd_handle.port
        pid = pantsd_handle.pid
        # Merge the nailgun TTY capability environment variables with the passed environment dict.
        ng_env = NailgunProtocol.ttynames_to_env(self._stdin, self._stdout, self._stderr)
        modified_env = {
            **self._env,
            **ng_env,
            "PANTSD_RUNTRACKER_CLIENT_START_TIME": str(self._start_time),
            "PANTSD_REQUEST_TIMEOUT_LIMIT": str(
                self._bootstrap_options.for_global_scope().pantsd_timeout_when_multiple_invocations
            ),
        }

        assert isinstance(port, int), "port {} is not an integer! It has type {}.".format(
            port, type(port)
        )

        # Instantiate a NailgunClient.
        client = NailgunClient(
            port=port,
            remote_pid=pid,
            ins=self._stdin,
            out=self._stdout,
            err=self._stderr,
            exit_on_broken_pipe=True,
            metadata_base_dir=pantsd_handle.metadata_base_dir,
        )

        with self._trapped_signals(client, pantsd_handle.pid), STTYSettings.preserved():
            # Execute the command on the pailgun.
            return client.execute(self._args[0], self._args[1:], modified_env)
Exemplo n.º 3
0
    def _connect_and_execute(self, port):
        # Merge the nailgun TTY capability environment variables with the passed environment dict.
        ng_env = NailgunProtocol.isatty_to_env(self._stdin, self._stdout,
                                               self._stderr)
        modified_env = combined_dict(self._env, ng_env)
        modified_env['PANTSD_RUNTRACKER_CLIENT_START_TIME'] = str(
            self._start_time)

        assert isinstance(port, int), 'port {} is not an integer!'.format(port)

        # Instantiate a NailgunClient.
        client = NailgunClient(port=port,
                               ins=self._stdin,
                               out=self._stdout,
                               err=self._stderr,
                               exit_on_broken_pipe=True,
                               expects_pid=True)

        with self._trapped_signals(client), STTYSettings.preserved():
            # Execute the command on the pailgun.
            result = client.execute(self.PANTS_COMMAND, *self._args,
                                    **modified_env)

        # Exit.
        self._exiter.exit(result)
Exemplo n.º 4
0
  def run(self, args=None):
    # Merge the nailgun TTY capability environment variables with the passed environment dict.
    ng_env = NailgunProtocol.isatty_to_env(self._stdin, self._stdout, self._stderr)
    modified_env = self._combine_dicts(self._env, ng_env)

    # Instantiate a NailgunClient.
    client = NailgunClient(port=self._port, ins=self._stdin, out=self._stdout, err=self._stderr)

    with self._trapped_control_c(client):
      # Execute the command on the pailgun.
      result = client.execute(self.PANTS_COMMAND, *self._args, **modified_env)

    # Exit.
    self._exiter.exit(result)
Exemplo n.º 5
0
    def _await_nailgun_server(self, stdout, stderr, debug_desc):
        # TODO(Eric Ayers) Make these cmdline/config parameters once we have a global way to fetch
        # the global options scope.
        nailgun_timeout_seconds = 10
        max_socket_connect_attempts = 5
        nailgun = None
        port_parse_start = time.time()
        with safe_open(self._ng_out, 'r') as ng_out:
            while not nailgun:
                started = ng_out.readline()
                if started.find(
                        'Listening for transport dt_socket at address:') >= 0:
                    nailgun_timeout_seconds = 60
                    logger.warn(
                        'Timeout extended to {timeout} seconds for debugger to attach to ng server.'
                        .format(timeout=nailgun_timeout_seconds))
                    started = ng_out.readline()
                if started:
                    port = self._parse_nailgun_port(started)
                    nailgun = self._create_ngclient(port, stdout, stderr)
                    logger.debug('Detected ng server up on port {port}'.format(
                        port=port))
                elif time.time() - port_parse_start > nailgun_timeout_seconds:
                    raise NailgunClient.NailgunError(
                        'Failed to read ng output after {sec} seconds.\n {desc}'
                        .format(sec=nailgun_timeout_seconds, desc=debug_desc))

        attempt = 0
        while nailgun:
            sock = nailgun.try_connect()
            if sock:
                sock.close()
                endpoint = self._get_nailgun_endpoint()
                if endpoint:
                    logger.debug(
                        'Connected to ng server launched with {endpoint}'.
                        format(endpoint=repr(endpoint)))
                else:
                    raise NailgunClient.NailgunError(
                        'Failed to connect to ng server.')
                return nailgun
            elif attempt > max_socket_connect_attempts:
                raise nailgun.NailgunError(
                    'Failed to connect to ng output after {count} connect attempts'
                    .format(count=max_socket_connect_attempts))
            attempt += 1
            logger.debug(
                'Failed to connect on attempt {count}'.format(count=attempt))
            time.sleep(0.1)
Exemplo n.º 6
0
    def test_execute_propagates_connection_error_on_connect(
            self, mock_session, mock_try_connect):
        mock_try_connect.side_effect = NailgunClient.NailgunConnectionError(
            'oops')

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.execute('test')
Exemplo n.º 7
0
 def _parse_nailgun_port(self, line):
     match = self._PARSE_NG_PORT.match(line)
     if not match:
         raise NailgunClient.NailgunError(
             'Failed to determine spawned ng port from response'
             ' line: {line}'.format(line=line))
     return int(match.group(1))
Exemplo n.º 8
0
    def test_execute_propagates_connection_error_on_connect(self, mock_session, mock_try_connect):
        mock_try_connect.side_effect = NailgunClient.NailgunConnectionError(
            "127.0.0.1:31337", 31337, -31336, Exception("oops"),
        )

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.execute("test")
Exemplo n.º 9
0
  def _await_socket(self, timeout):
    """Blocks for the nailgun subprocess to bind and emit a listening port in the nailgun stdout."""
    with safe_open(self._ng_stdout, 'r') as ng_stdout:
      start_time = time.time()
      accumulated_stdout = ''
      while 1:
        readable, _, _ = select.select([ng_stdout], [], [], self._SELECT_WAIT)
        if readable:
          line = ng_stdout.readline()                          # TODO: address deadlock risk here.
          try:
            return self._NG_PORT_REGEX.match(line).group(1)
          except AttributeError:
            pass
          accumulated_stdout += line

        if (time.time() - start_time) > timeout:
          stderr = read_file(self._ng_stderr)
          raise NailgunClient.NailgunError(
            'Failed to read nailgun output after {sec} seconds!\n'
            'Stdout:\n{stdout}\nStderr:\n{stderr}'.format(
              sec=timeout,
              stdout=accumulated_stdout,
              stderr=stderr,
            )
          )
Exemplo n.º 10
0
    def _await_nailgun_server(self, stdout, stderr):
        nailgun_timeout_seconds = 5
        max_socket_connect_attempts = 10
        nailgun = None
        port_parse_start = time.time()
        with safe_open(self._ng_out, 'r') as ng_out:
            while not nailgun:
                started = ng_out.readline()
                if started.find(
                        'Listening for transport dt_socket at address:') >= 0:
                    nailgun_timeout_seconds = 60
                    log.warn(
                        'Timeout extended to {timeout} seconds for debugger to attach to ng server.'
                        .format(timeout=nailgun_timeout_seconds))
                    started = ng_out.readline()
                if started:
                    port = self._parse_nailgun_port(started)
                    nailgun = self._create_ngclient(port, stdout, stderr)
                    log.debug('Detected ng server up on port %d' % port)
                elif time.time() - port_parse_start > nailgun_timeout_seconds:
                    raise NailgunClient.NailgunError(
                        'Failed to read ng output after'
                        ' %s seconds' % nailgun_timeout_seconds)

        attempt = 0
        while nailgun:
            sock = nailgun.try_connect()
            if sock:
                sock.close()
                endpoint = self._get_nailgun_endpoint()
                if endpoint:
                    log.debug(
                        'Connected to ng server launched with %s fingerprint %s pid: %d @ port: %d'
                        % endpoint)
                else:
                    raise NailgunClient.NailgunError(
                        'Failed to connect to ng server.')
                return nailgun
            elif attempt > max_socket_connect_attempts:
                raise nailgun.NailgunError(
                    'Failed to connect to ng output after %d connect attempts'
                    % max_socket_connect_attempts)
            attempt += 1
            log.debug('Failed to connect on attempt %d' % attempt)
            time.sleep(0.1)
Exemplo n.º 11
0
  def run(self, args=None):
    # Merge the nailgun TTY capability environment variables with the passed environment dict.
    ng_env = NailgunProtocol.isatty_to_env(self._stdin, self._stdout, self._stderr)
    modified_env = self._combine_dicts(self._env, ng_env)

    # Instantiate a NailgunClient.
    client = NailgunClient(port=self._port,
                           ins=self._stdin,
                           out=self._stdout,
                           err=self._stderr,
                           exit_on_broken_pipe=True)

    with self._trapped_control_c(client):
      # Execute the command on the pailgun.
      result = client.execute(self.PANTS_COMMAND, *self._args, **modified_env)

    # Exit.
    self._exiter.exit(result)
Exemplo n.º 12
0
  def _connect_and_execute(self, port):
    # Merge the nailgun TTY capability environment variables with the passed environment dict.
    ng_env = NailgunProtocol.isatty_to_env(self._stdin, self._stdout, self._stderr)
    modified_env = combined_dict(self._env, ng_env)

    assert isinstance(port, int), 'port {} is not an integer!'.format(port)

    # Instantiate a NailgunClient.
    client = NailgunClient(port=port,
                           ins=self._stdin,
                           out=self._stdout,
                           err=self._stderr,
                           exit_on_broken_pipe=True)

    with self._trapped_signals(client), STTYSettings.preserved():
      # Execute the command on the pailgun.
      result = client.execute(self.PANTS_COMMAND, *self._args, **modified_env)

    # Exit.
    self._exiter.exit(result)
Exemplo n.º 13
0
  def _connect_and_execute(self, port):
    # Merge the nailgun TTY capability environment variables with the passed environment dict.
    ng_env = NailgunProtocol.isatty_to_env(self._stdin, self._stdout, self._stderr)
    modified_env = combined_dict(self._env, ng_env)

    assert isinstance(port, int), 'port {} is not an integer!'.format(port)

    # Instantiate a NailgunClient.
    client = NailgunClient(port=port,
                           ins=self._stdin,
                           out=self._stdout,
                           err=self._stderr,
                           exit_on_broken_pipe=True)

    with self._trapped_control_c(client):
      # Execute the command on the pailgun.
      result = client.execute(self.PANTS_COMMAND, *self._args, **modified_env)

    # Exit.
    self._exiter.exit(result)
Exemplo n.º 14
0
  def ensure_connectable(self, nailgun):
    """Ensures that a nailgun client is connectable or raises NailgunError."""
    attempt_count = 0
    while 1:
      if attempt_count > self._connect_attempts:
        logger.debug('Failed to connect to ng after {count} attempts'
                     .format(count=self._connect_attempts))
        raise NailgunClient.NailgunError('Failed to connect to ng server.')

      try:
        sock = nailgun.try_connect()
        if sock:
          logger.debug('Connected to ng server {server!r}'.format(server=self))
          return
      finally:
        sock.close()

      attempt_count += 1
      time.sleep(self.WAIT_INTERVAL)
Exemplo n.º 15
0
class TestNailgunClient(unittest.TestCase):
  def setUp(self):
    self.nailgun_client = NailgunClient()

  @mock.patch('pants.java.nailgun_client.RecvBufferedSocket', **PATCH_OPTS)
  def test_try_connect(self, mock_socket_cls):
    mock_socket = mock.Mock()
    mock_socket_cls.return_value = mock_socket

    self.assertEqual(self.nailgun_client.try_connect(), mock_socket)

    self.assertEqual(mock_socket_cls.call_count, 1)
    mock_socket.connect.assert_called_once_with(
      (NailgunClient.DEFAULT_NG_HOST, NailgunClient.DEFAULT_NG_PORT)
    )

  @mock.patch('pants.java.nailgun_client.RecvBufferedSocket', **PATCH_OPTS)
  def test_try_connect_socket_error(self, mock_socket_cls):
    mock_socket = mock.Mock()
    mock_socket.connect.side_effect = socket.error()
    mock_socket_cls.return_value = mock_socket

    with self.assertRaises(NailgunClient.NailgunConnectionError):
      self.nailgun_client.try_connect()

  @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
  @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
  def test_execute(self, mock_session, mock_try_connect):
    self.nailgun_client.execute('test')
    self.assertEqual(mock_try_connect.call_count, 1)
    self.assertEqual(mock_session.call_count, 1)

  @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
  @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
  def test_execute_propagates_connection_error_on_connect(self, mock_session, mock_try_connect):
    mock_try_connect.side_effect = NailgunClient.NailgunConnectionError(
      '127.0.0.1:31337',
      31337,
      -31336,
      Exception('oops'),
    )

    with self.assertRaises(NailgunClient.NailgunConnectionError):
      self.nailgun_client.execute('test')

  @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
  @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
  def test_execute_socketerror_on_execute(self, mock_session, mock_try_connect):
    mock_session.return_value.execute.side_effect = socket.error('oops')

    with self.assertRaises(NailgunClient.NailgunError):
      self.nailgun_client.execute('test')

  @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
  @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
  def test_execute_protocolerror_on_execute(self, mock_session, mock_try_connect):
    mock_session.return_value.ProtocolError = NailgunProtocol.ProtocolError
    mock_session.return_value.execute.side_effect = NailgunProtocol.ProtocolError('oops')

    with self.assertRaises(NailgunClient.NailgunError):
      self.nailgun_client.execute('test')

  def test_repr(self):
    self.assertIsNotNone(repr(self.nailgun_client))

  @mock.patch('os.kill', **PATCH_OPTS)
  def test_send_control_c(self, mock_kill):
    self.nailgun_client._maybe_last_pid = lambda: 31337
    self.nailgun_client._maybe_last_pgrp = lambda: -31336
    self.nailgun_client.maybe_send_signal(signal.SIGINT)
    mock_kill.assert_has_calls([
      # The pid is killed first, then the pgrp, if include_pgrp=True.
      mock.call(31337, signal.SIGINT),
      mock.call(-31336, signal.SIGINT),
    ])

  @mock.patch('os.kill', **PATCH_OPTS)
  def test_send_signal_no_pgrp(self, mock_kill):
    self.nailgun_client._maybe_last_pid = lambda: 111111
    self.nailgun_client.maybe_send_signal(signal.SIGINT, include_pgrp=False)
    mock_kill.assert_called_once_with(111111, signal.SIGINT)

  @mock.patch('os.kill', **PATCH_OPTS)
  def test_send_control_c_noop_none(self, mock_kill):
    self.nailgun_client._session = None
    self.nailgun_client.maybe_send_signal(signal.SIGINT)
    mock_kill.assert_not_called()

  @mock.patch('os.kill', **PATCH_OPTS)
  def test_send_control_c_noop_nopid(self, mock_kill):
    self.nailgun_client._session = mock.Mock(remote_pid=None, remote_pgrp=None)
    self.nailgun_client.maybe_send_signal(signal.SIGINT)
    mock_kill.assert_not_called()
Exemplo n.º 16
0
 def setUp(self):
     self.nailgun_client = NailgunClient()
Exemplo n.º 17
0
class TestNailgunClient(unittest.TestCase):
    def setUp(self):
        self.nailgun_client = NailgunClient()

    @unittest.mock.patch("pants.java.nailgun_client.RecvBufferedSocket", **PATCH_OPTS)
    def test_try_connect(self, mock_socket_cls):
        mock_socket = unittest.mock.Mock()
        mock_socket_cls.return_value = mock_socket

        self.assertEqual(self.nailgun_client.try_connect(), mock_socket)

        self.assertEqual(mock_socket_cls.call_count, 1)
        mock_socket.connect.assert_called_once_with(
            (NailgunClient.DEFAULT_NG_HOST, NailgunClient.DEFAULT_NG_PORT)
        )

    @unittest.mock.patch("pants.java.nailgun_client.RecvBufferedSocket", **PATCH_OPTS)
    def test_try_connect_socket_error(self, mock_socket_cls):
        mock_socket = unittest.mock.Mock()
        mock_socket.connect.side_effect = socket.error()
        mock_socket_cls.return_value = mock_socket

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.try_connect()

    @unittest.mock.patch.object(NailgunClient, "try_connect", **PATCH_OPTS)
    @unittest.mock.patch("pants.java.nailgun_client.NailgunClientSession", **PATCH_OPTS)
    def test_execute(self, mock_session, mock_try_connect):
        self.nailgun_client.execute("test")
        self.assertEqual(mock_try_connect.call_count, 1)
        self.assertEqual(mock_session.call_count, 1)

    @unittest.mock.patch.object(NailgunClient, "try_connect", **PATCH_OPTS)
    @unittest.mock.patch("pants.java.nailgun_client.NailgunClientSession", **PATCH_OPTS)
    def test_execute_propagates_connection_error_on_connect(self, mock_session, mock_try_connect):
        mock_try_connect.side_effect = NailgunClient.NailgunConnectionError(
            "127.0.0.1:31337", 31337, -31336, Exception("oops"),
        )

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.execute("test")

    @unittest.mock.patch.object(NailgunClient, "try_connect", **PATCH_OPTS)
    @unittest.mock.patch("pants.java.nailgun_client.NailgunClientSession", **PATCH_OPTS)
    def test_execute_socketerror_on_execute(self, mock_session, mock_try_connect):
        mock_session.return_value.execute.side_effect = socket.error("oops")

        with self.assertRaises(NailgunClient.NailgunError):
            self.nailgun_client.execute("test")

    @unittest.mock.patch.object(NailgunClient, "try_connect", **PATCH_OPTS)
    @unittest.mock.patch("pants.java.nailgun_client.NailgunClientSession", **PATCH_OPTS)
    def test_execute_protocolerror_on_execute(self, mock_session, mock_try_connect):
        mock_session.return_value.ProtocolError = NailgunProtocol.ProtocolError
        mock_session.return_value.execute.side_effect = NailgunProtocol.ProtocolError("oops")

        with self.assertRaises(NailgunClient.NailgunError):
            self.nailgun_client.execute("test")

    def test_repr(self):
        self.assertIsNotNone(repr(self.nailgun_client))

    @unittest.mock.patch("os.kill", **PATCH_OPTS)
    def test_send_control_c(self, mock_kill):
        self.nailgun_client._maybe_last_pid = lambda: 31337
        self.nailgun_client._maybe_last_pgrp = lambda: -31336
        self.nailgun_client.maybe_send_signal(signal.SIGINT)
        mock_kill.assert_has_calls(
            [
                # The pid is killed first, then the pgrp, if include_pgrp=True.
                unittest.mock.call(31337, signal.SIGINT),
                unittest.mock.call(-31336, signal.SIGINT),
            ]
        )

    @unittest.mock.patch("os.kill", **PATCH_OPTS)
    def test_send_signal_no_pgrp(self, mock_kill):
        self.nailgun_client._maybe_last_pid = lambda: 111111
        self.nailgun_client.maybe_send_signal(signal.SIGINT, include_pgrp=False)
        mock_kill.assert_called_once_with(111111, signal.SIGINT)

    @unittest.mock.patch("os.kill", **PATCH_OPTS)
    def test_send_control_c_noop_none(self, mock_kill):
        self.nailgun_client._session = None
        self.nailgun_client.maybe_send_signal(signal.SIGINT)
        mock_kill.assert_not_called()

    @unittest.mock.patch("os.kill", **PATCH_OPTS)
    def test_send_control_c_noop_nopid(self, mock_kill):
        self.nailgun_client._session = unittest.mock.Mock(remote_pid=None, remote_pgrp=None)
        self.nailgun_client.maybe_send_signal(signal.SIGINT)
        mock_kill.assert_not_called()
Exemplo n.º 18
0
class TestNailgunClient(unittest.TestCase):
    def setUp(self):
        self.nailgun_client = NailgunClient()

    @unittest.mock.patch("pants.java.nailgun_client.RecvBufferedSocket",
                         **PATCH_OPTS)
    def test_try_connect(self, mock_socket_cls):
        mock_socket = unittest.mock.Mock()
        mock_socket_cls.return_value = mock_socket

        self.assertEqual(self.nailgun_client.try_connect(), mock_socket)

        self.assertEqual(mock_socket_cls.call_count, 1)
        mock_socket.connect.assert_called_once_with(
            (NailgunClient.DEFAULT_NG_HOST, NailgunClient.DEFAULT_NG_PORT))

    @unittest.mock.patch("pants.java.nailgun_client.RecvBufferedSocket",
                         **PATCH_OPTS)
    def test_try_connect_socket_error(self, mock_socket_cls):
        mock_socket = unittest.mock.Mock()
        mock_socket.connect.side_effect = socket.error()
        mock_socket_cls.return_value = mock_socket

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.try_connect()

    @unittest.mock.patch.object(NailgunClient, "try_connect", **PATCH_OPTS)
    @unittest.mock.patch("pants.java.nailgun_client.NailgunClientSession",
                         **PATCH_OPTS)
    def test_execute(self, mock_session, mock_try_connect):
        self.nailgun_client.execute("test", [])
        self.assertEqual(mock_try_connect.call_count, 1)
        self.assertEqual(mock_session.call_count, 1)

    @unittest.mock.patch.object(NailgunClient, "try_connect", **PATCH_OPTS)
    @unittest.mock.patch("pants.java.nailgun_client.NailgunClientSession",
                         **PATCH_OPTS)
    def test_execute_propagates_connection_error_on_connect(
            self, mock_session, mock_try_connect):
        mock_try_connect.side_effect = NailgunClient.NailgunConnectionError(
            "127.0.0.1:31337",
            Exception("oops"),
        )

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.execute("test", [])

    @unittest.mock.patch.object(NailgunClient, "try_connect", **PATCH_OPTS)
    @unittest.mock.patch("pants.java.nailgun_client.NailgunClientSession",
                         **PATCH_OPTS)
    def test_execute_socketerror_on_execute(self, mock_session,
                                            mock_try_connect):
        mock_session.return_value.execute.side_effect = socket.error("oops")

        with self.assertRaises(NailgunClient.NailgunError):
            self.nailgun_client.execute("test", [])

    @unittest.mock.patch.object(NailgunClient, "try_connect", **PATCH_OPTS)
    @unittest.mock.patch("pants.java.nailgun_client.NailgunClientSession",
                         **PATCH_OPTS)
    def test_execute_protocolerror_on_execute(self, mock_session,
                                              mock_try_connect):
        mock_session.return_value.ProtocolError = NailgunProtocol.ProtocolError
        mock_session.return_value.execute.side_effect = NailgunProtocol.ProtocolError(
            "oops")

        with self.assertRaises(NailgunClient.NailgunError):
            self.nailgun_client.execute("test", [])

    def test_repr(self):
        self.assertIsNotNone(repr(self.nailgun_client))

    @unittest.mock.patch("os.kill", **PATCH_OPTS)
    def test_send_control_c(self, mock_kill):
        self.nailgun_client.remote_pid = 31337
        self.nailgun_client.maybe_send_signal(signal.SIGINT)
        mock_kill.assert_has_calls([unittest.mock.call(31337, signal.SIGINT)])
Exemplo n.º 19
0
class TestNailgunClient(unittest.TestCase):
    def setUp(self):
        self.nailgun_client = NailgunClient()

    @mock.patch('pants.java.nailgun_client.RecvBufferedSocket', **PATCH_OPTS)
    def test_try_connect(self, mock_socket_cls):
        mock_socket = mock.Mock()
        mock_socket_cls.return_value = mock_socket

        self.assertEquals(self.nailgun_client.try_connect(), mock_socket)

        self.assertEquals(mock_socket_cls.call_count, 1)
        mock_socket.connect.assert_called_once_with(
            (NailgunClient.DEFAULT_NG_HOST, NailgunClient.DEFAULT_NG_PORT))

    @mock.patch('pants.java.nailgun_client.RecvBufferedSocket', **PATCH_OPTS)
    def test_try_connect_socket_error(self, mock_socket_cls):
        mock_socket = mock.Mock()
        mock_socket.connect.side_effect = socket.error()
        mock_socket_cls.return_value = mock_socket

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.try_connect()

    @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
    @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
    def test_execute(self, mock_session, mock_try_connect):
        self.nailgun_client.execute('test')
        self.assertEquals(mock_try_connect.call_count, 1)
        self.assertEquals(mock_session.call_count, 1)

    @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
    @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
    def test_execute_propagates_connection_error_on_connect(
            self, mock_session, mock_try_connect):
        mock_try_connect.side_effect = NailgunClient.NailgunConnectionError(
            'oops')

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.execute('test')

    @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
    @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
    def test_execute_socketerror_on_execute(self, mock_session,
                                            mock_try_connect):
        mock_session.return_value.execute.side_effect = socket.error('oops')

        with self.assertRaises(NailgunClient.NailgunError):
            self.nailgun_client.execute('test')

    @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
    @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
    def test_execute_protocolerror_on_execute(self, mock_session,
                                              mock_try_connect):
        mock_session.return_value.ProtocolError = NailgunProtocol.ProtocolError
        mock_session.return_value.execute.side_effect = NailgunProtocol.ProtocolError(
            'oops')

        with self.assertRaises(NailgunClient.NailgunError):
            self.nailgun_client.execute('test')

    def test_repr(self):
        self.assertIsNotNone(repr(self.nailgun_client))
Exemplo n.º 20
0
 def _create_ngclient(self, port, stdout, stderr, stdin):
     return NailgunClient(port=port, ins=stdin, out=stdout, err=stderr)
Exemplo n.º 21
0
class TestNailgunClient(unittest.TestCase):
    def setUp(self):
        self.nailgun_client = NailgunClient()

    @mock.patch('pants.java.nailgun_client.RecvBufferedSocket', **PATCH_OPTS)
    def test_try_connect(self, mock_socket_cls):
        mock_socket = mock.Mock()
        mock_socket_cls.return_value = mock_socket

        self.assertEquals(self.nailgun_client.try_connect(), mock_socket)

        self.assertEquals(mock_socket_cls.call_count, 1)
        mock_socket.connect.assert_called_once_with(
            (NailgunClient.DEFAULT_NG_HOST, NailgunClient.DEFAULT_NG_PORT))

    @mock.patch('pants.java.nailgun_client.RecvBufferedSocket', **PATCH_OPTS)
    def test_try_connect_socket_error(self, mock_socket_cls):
        mock_socket = mock.Mock()
        mock_socket.connect.side_effect = socket.error()
        mock_socket_cls.return_value = mock_socket

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.try_connect()

    @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
    @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
    def test_execute(self, mock_session, mock_try_connect):
        self.nailgun_client.execute('test')
        self.assertEquals(mock_try_connect.call_count, 1)
        self.assertEquals(mock_session.call_count, 1)

    @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
    @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
    def test_execute_propagates_connection_error_on_connect(
            self, mock_session, mock_try_connect):
        mock_try_connect.side_effect = NailgunClient.NailgunConnectionError(
            '127.0.0.1:31337', 31337, Exception('oops'), None)

        with self.assertRaises(NailgunClient.NailgunConnectionError):
            self.nailgun_client.execute('test')

    @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
    @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
    def test_execute_socketerror_on_execute(self, mock_session,
                                            mock_try_connect):
        mock_session.return_value.execute.side_effect = socket.error('oops')

        with self.assertRaises(NailgunClient.NailgunError):
            self.nailgun_client.execute('test')

    @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
    @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
    def test_execute_protocolerror_on_execute(self, mock_session,
                                              mock_try_connect):
        mock_session.return_value.ProtocolError = NailgunProtocol.ProtocolError
        mock_session.return_value.execute.side_effect = NailgunProtocol.ProtocolError(
            'oops')

        with self.assertRaises(NailgunClient.NailgunError):
            self.nailgun_client.execute('test')

    def test_repr(self):
        self.assertIsNotNone(repr(self.nailgun_client))

    @mock.patch('os.kill', **PATCH_OPTS)
    def test_send_control_c(self, mock_kill):
        self.nailgun_client._session = mock.Mock(remote_pid=31337)
        self.nailgun_client.send_control_c()
        mock_kill.assert_called_once_with(31337, signal.SIGINT)

    @mock.patch('os.kill', **PATCH_OPTS)
    def test_send_control_c_noop_none(self, mock_kill):
        self.nailgun_client._session = None
        self.nailgun_client.send_control_c()
        mock_kill.assert_not_called()

    @mock.patch('os.kill', **PATCH_OPTS)
    def test_send_control_c_noop_nopid(self, mock_kill):
        self.nailgun_client._session = mock.Mock(remote_pid=None)
        self.nailgun_client.send_control_c()
        mock_kill.assert_not_called()
Exemplo n.º 22
0
 def setUp(self):
   self.nailgun_client = NailgunClient()
Exemplo n.º 23
0
class TestNailgunClient(unittest.TestCase):
  def setUp(self):
    self.nailgun_client = NailgunClient()

  @mock.patch('pants.java.nailgun_client.RecvBufferedSocket', **PATCH_OPTS)
  def test_try_connect(self, mock_socket_cls):
    mock_socket = mock.Mock()
    mock_socket_cls.return_value = mock_socket

    self.assertEquals(self.nailgun_client.try_connect(), mock_socket)

    self.assertEquals(mock_socket_cls.call_count, 1)
    mock_socket.connect.assert_called_once_with(
      (NailgunClient.DEFAULT_NG_HOST, NailgunClient.DEFAULT_NG_PORT)
    )

  @mock.patch('pants.java.nailgun_client.RecvBufferedSocket', **PATCH_OPTS)
  def test_try_connect_socket_error(self, mock_socket_cls):
    mock_socket = mock.Mock()
    mock_socket.connect.side_effect = socket.error()
    mock_socket_cls.return_value = mock_socket

    with self.assertRaises(NailgunClient.NailgunConnectionError):
      self.nailgun_client.try_connect()

  @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
  @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
  def test_execute(self, mock_session, mock_try_connect):
    self.nailgun_client.execute('test')
    self.assertEquals(mock_try_connect.call_count, 1)
    self.assertEquals(mock_session.call_count, 1)

  @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
  @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
  def test_execute_propagates_connection_error_on_connect(self, mock_session, mock_try_connect):
    mock_try_connect.side_effect = NailgunClient.NailgunConnectionError('oops')

    with self.assertRaises(NailgunClient.NailgunConnectionError):
      self.nailgun_client.execute('test')

  @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
  @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
  def test_execute_socketerror_on_execute(self, mock_session, mock_try_connect):
    mock_session.return_value.execute.side_effect = socket.error('oops')

    with self.assertRaises(NailgunClient.NailgunError):
      self.nailgun_client.execute('test')

  @mock.patch.object(NailgunClient, 'try_connect', **PATCH_OPTS)
  @mock.patch('pants.java.nailgun_client.NailgunClientSession', **PATCH_OPTS)
  def test_execute_protocolerror_on_execute(self, mock_session, mock_try_connect):
    mock_session.return_value.ProtocolError = NailgunProtocol.ProtocolError
    mock_session.return_value.execute.side_effect = NailgunProtocol.ProtocolError('oops')

    with self.assertRaises(NailgunClient.NailgunError):
      self.nailgun_client.execute('test')

  def test_repr(self):
    self.assertIsNotNone(repr(self.nailgun_client))

  @mock.patch('os.kill', **PATCH_OPTS)
  def test_send_control_c(self, mock_kill):
    self.nailgun_client._session = mock.Mock(remote_pid=31337)
    self.nailgun_client.send_control_c()
    mock_kill.assert_called_once_with(31337, signal.SIGINT)

  @mock.patch('os.kill', **PATCH_OPTS)
  def test_send_control_c_noop_none(self, mock_kill):
    self.nailgun_client._session = None
    self.nailgun_client.send_control_c()
    mock_kill.assert_not_called()

  @mock.patch('os.kill', **PATCH_OPTS)
  def test_send_control_c_noop_nopid(self, mock_kill):
    self.nailgun_client._session = mock.Mock(remote_pid=None)
    self.nailgun_client.send_control_c()
    mock_kill.assert_not_called()
Exemplo n.º 24
0
 def _create_ngclient(self, port, stdout, stderr):
   return NailgunClient(port=port, ins=self._ins, out=stdout, err=stderr, workdir=get_buildroot())