PyLint fixes for tools-webrtc and webrtc/tools

tools-webrtc/network_emulator/network_emulator.py

 #!/usr/bin/env python
 #  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
 #
 #  Use of this source code is governed by a BSD-style license
 #  that can be found in the LICENSE file in the root of the source
 #  tree. An additional intellectual property rights grant can be found
 #  in the file PATENTS.  All contributing project authors may
 #  be found in the AUTHORS file in the root of the source tree.
 
 """Script for constraining traffic on the local machine."""
@@ skipping 35 matching lines @@
     Args:
         connection_config: A config.ConnectionConfig object containing the
             characteristics for the connection to be emulation.
         port_range: Tuple containing two integers defining the port range.
     """
     self._pipe_counter = 0
     self._rule_counter = 0
     self._port_range = port_range
     self._connection_config = connection_config
 
-  def emulate(self, target_ip):
+  def Emulate(self, target_ip):
     """Starts a network emulation by setting up Dummynet rules.
 
     Args:
         target_ip: The IP address of the interface that shall be that have the
             network constraints applied to it.
     """
-    receive_pipe_id = self._create_dummynet_pipe(
+    receive_pipe_id = self._CreateDummynetPipe(
         self._connection_config.receive_bw_kbps,
         self._connection_config.delay_ms,
         self._connection_config.packet_loss_percent,
         self._connection_config.queue_slots)
     logging.debug('Created receive pipe: %s', receive_pipe_id)
-    send_pipe_id = self._create_dummynet_pipe(
+    send_pipe_id = self._CreateDummynetPipe(
         self._connection_config.send_bw_kbps,
         self._connection_config.delay_ms,
         self._connection_config.packet_loss_percent,
         self._connection_config.queue_slots)
     logging.debug('Created send pipe: %s', send_pipe_id)
 
     # Adding the rules will start the emulation.
-    incoming_rule_id = self._create_dummynet_rule(receive_pipe_id, 'any',
-                                                  target_ip, self._port_range)
+    incoming_rule_id = self._CreateDummynetRule(receive_pipe_id, 'any',
+                                                target_ip, self._port_range)
     logging.debug('Created incoming rule: %s', incoming_rule_id)
-    outgoing_rule_id = self._create_dummynet_rule(send_pipe_id, target_ip,
-                                                  'any', self._port_range)
+    outgoing_rule_id = self._CreateDummynetRule(send_pipe_id, target_ip,
+                                                'any', self._port_range)
     logging.debug('Created outgoing rule: %s', outgoing_rule_id)
 
   @staticmethod
-  def check_permissions():
+  def CheckPermissions():
     """Checks if permissions are available to run Dummynet commands.
 
     Raises:
       NetworkEmulatorError: If permissions to run Dummynet commands are not
       available.
     """
     try:
       if os.getuid() != 0:
         raise NetworkEmulatorError('You must run this script with sudo.')
     except AttributeError:
 
     # AttributeError will be raised on Windows.
       if ctypes.windll.shell32.IsUserAnAdmin() == 0:
         raise NetworkEmulatorError('You must run this script with administrator'
                                    ' privileges.')
 
-  def _create_dummynet_rule(self, pipe_id, from_address, to_address,
-                            port_range):
+  def _CreateDummynetRule(self, pipe_id, from_address, to_address,
+                          port_range):
     """Creates a network emulation rule and returns its ID.
 
     Args:
         pipe_id: integer ID of the pipe.
         from_address: The IP address to match source address. May be an IP or
           'any'.
         to_address: The IP address to match destination address. May be an IP or
           'any'.
         port_range: The range of ports the rule shall be applied on. Must be
           specified as a tuple of with two integers.
     Returns:
         The ID of the rule, starting at 100. The rule ID increments with 100 for
         each rule being added.
     """
     self._rule_counter += 100
     add_part = ['add', self._rule_counter, 'pipe', pipe_id,
                 'ip', 'from', from_address, 'to', to_address]
-    _run_ipfw_command(add_part + ['src-port', '%s-%s' % port_range],
+    _RunIpfwCommand(add_part + ['src-port', '%s-%s' % port_range],
                             'Failed to add Dummynet src-port rule.')
-    _run_ipfw_command(add_part + ['dst-port', '%s-%s' % port_range],
+    _RunIpfwCommand(add_part + ['dst-port', '%s-%s' % port_range],
                             'Failed to add Dummynet dst-port rule.')
     return self._rule_counter
 
-  def _create_dummynet_pipe(self, bandwidth_kbps, delay_ms, packet_loss_percent,
-                            queue_slots):
+  def _CreateDummynetPipe(self, bandwidth_kbps, delay_ms, packet_loss_percent,
+                          queue_slots):
     """Creates a Dummynet pipe and return its ID.
 
     Args:
         bandwidth_kbps: Bandwidth.
         delay_ms: Delay for a one-way trip of a packet.
         packet_loss_percent: Float value of packet loss, in percent.
         queue_slots: Size of the queue.
     Returns:
         The ID of the pipe, starting at 1.
     """
     self._pipe_counter += 1
     cmd = ['pipe', self._pipe_counter, 'config',
            'bw', str(bandwidth_kbps/8) + 'KByte/s',
            'delay', '%sms' % delay_ms,
            'plr', (packet_loss_percent/100.0),
            'queue', queue_slots]
     error_message = 'Failed to create Dummynet pipe. '
     if sys.platform.startswith('linux'):
       error_message += ('Make sure you have loaded the ipfw_mod.ko module to '
                         'your kernel (sudo insmod /path/to/ipfw_mod.ko).')
-    _run_ipfw_command(cmd, error_message)
+    _RunIpfwCommand(cmd, error_message)
     return self._pipe_counter
 
-def cleanup():
+def Cleanup():
   """Stops the network emulation by flushing all Dummynet rules.
 
   Notice that this will flush any rules that may have been created previously
   before starting the emulation.
   """
-  _run_ipfw_command(['-f', 'flush'],
+  _RunIpfwCommand(['-f', 'flush'],
                           'Failed to flush Dummynet rules!')
-  _run_ipfw_command(['-f', 'pipe', 'flush'],
+  _RunIpfwCommand(['-f', 'pipe', 'flush'],
                           'Failed to flush Dummynet pipes!')
 
-def _run_ipfw_command(command, fail_msg=None):
+def _RunIpfwCommand(command, fail_msg=None):
   """Executes a command and prefixes the appropriate command for
      Windows or Linux/UNIX.
 
   Args:
     command: Command list to execute.
     fail_msg: Message describing the error in case the command fails.
 
   Raises:
     NetworkEmulatorError: If command fails a message is set by the fail_msg
     parameter.
   """
   if sys.platform == 'win32':
     ipfw_command = ['ipfw.exe']
   else:
     ipfw_command = ['sudo', '-n', 'ipfw']
 
   cmd_list = ipfw_command[:] + [str(x) for x in command]
   cmd_string = ' '.join(cmd_list)
   logging.debug('Running command: %s', cmd_string)
   process = subprocess.Popen(cmd_list, stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
   output, error = process.communicate()
   if process.returncode != 0:
     raise NetworkEmulatorError(fail_msg, cmd_string, process.returncode, output,
                                error)
   return output.strip()