Synnefo » snf-ganeti » ganeti-local

#

#

# Copyright (C) 2006, 2007, 2010, 2011, 2012, 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""DRBD block device related functionality"""

import errno

import logging

import pyparsing as pyp

import re

import shlex

import time

from ganeti import constants

from ganeti import utils

from ganeti import errors

from ganeti import compat

from ganeti import netutils

from ganeti import objects

from ganeti.block import base

# Size of reads in _CanReadDevice

_DEVICE_READ_SIZE = 128 * 1024

class DRBD8Status(object): # pylint: disable=R0902

  """A DRBD status representation class.

  Note that this class is meant to be used to parse one of the entries returned

  from L{DRBD8Info._JoinLinesPerMinor}.

  """

  UNCONF_RE = re.compile(r"\s*[0-9]+:\s*cs:Unconfigured$")

  LINE_RE = re.compile(r"\s*[0-9]+:\s*cs:(\S+)\s+(?:st|ro):([^/]+)/(\S+)"

                       "\s+ds:([^/]+)/(\S+)\s+.*$")

  SYNC_RE = re.compile(r"^.*\ssync'ed:\s*([0-9.]+)%.*"

                       # Due to a bug in drbd in the kernel, introduced in

                       # commit 4b0715f096 (still unfixed as of 2011-08-22)

                       "(?:\s|M)"

                       "finish: ([0-9]+):([0-9]+):([0-9]+)\s.*$")

  CS_UNCONFIGURED = "Unconfigured"

  CS_STANDALONE = "StandAlone"

  CS_WFCONNECTION = "WFConnection"

  CS_WFREPORTPARAMS = "WFReportParams"

  CS_CONNECTED = "Connected"

  CS_STARTINGSYNCS = "StartingSyncS"

  CS_STARTINGSYNCT = "StartingSyncT"

  CS_WFBITMAPS = "WFBitMapS"

  CS_WFBITMAPT = "WFBitMapT"

  CS_WFSYNCUUID = "WFSyncUUID"

  CS_SYNCSOURCE = "SyncSource"

  CS_SYNCTARGET = "SyncTarget"

  CS_PAUSEDSYNCS = "PausedSyncS"

  CS_PAUSEDSYNCT = "PausedSyncT"

  CSET_SYNC = compat.UniqueFrozenset([

    CS_WFREPORTPARAMS,

    CS_STARTINGSYNCS,

    CS_STARTINGSYNCT,

    CS_WFBITMAPS,

    CS_WFBITMAPT,

    CS_WFSYNCUUID,

    CS_SYNCSOURCE,

    CS_SYNCTARGET,

    CS_PAUSEDSYNCS,

    CS_PAUSEDSYNCT,

    ])

  DS_DISKLESS = "Diskless"

  DS_ATTACHING = "Attaching" # transient state

  DS_FAILED = "Failed" # transient state, next: diskless

  DS_NEGOTIATING = "Negotiating" # transient state

  DS_INCONSISTENT = "Inconsistent" # while syncing or after creation

  DS_OUTDATED = "Outdated"

  DS_DUNKNOWN = "DUnknown" # shown for peer disk when not connected

  DS_CONSISTENT = "Consistent"

  DS_UPTODATE = "UpToDate" # normal state

  RO_PRIMARY = "Primary"

  RO_SECONDARY = "Secondary"

  RO_UNKNOWN = "Unknown"

  def __init__(self, procline):

    u = self.UNCONF_RE.match(procline)

    if u:

      self.cstatus = self.CS_UNCONFIGURED

      self.lrole = self.rrole = self.ldisk = self.rdisk = None

    else:

      m = self.LINE_RE.match(procline)

      if not m:

        raise errors.BlockDeviceError("Can't parse input data '%s'" % procline)

      self.cstatus = m.group(1)

      self.lrole = m.group(2)

      self.rrole = m.group(3)

      self.ldisk = m.group(4)

      self.rdisk = m.group(5)

    # end reading of data from the LINE_RE or UNCONF_RE

    self.is_standalone = self.cstatus == self.CS_STANDALONE

    self.is_wfconn = self.cstatus == self.CS_WFCONNECTION

    self.is_connected = self.cstatus == self.CS_CONNECTED

    self.is_unconfigured = self.cstatus == self.CS_UNCONFIGURED

    self.is_primary = self.lrole == self.RO_PRIMARY

    self.is_secondary = self.lrole == self.RO_SECONDARY

    self.peer_primary = self.rrole == self.RO_PRIMARY

    self.peer_secondary = self.rrole == self.RO_SECONDARY

    self.both_primary = self.is_primary and self.peer_primary

    self.both_secondary = self.is_secondary and self.peer_secondary

    self.is_diskless = self.ldisk == self.DS_DISKLESS

    self.is_disk_uptodate = self.ldisk == self.DS_UPTODATE

    self.is_in_resync = self.cstatus in self.CSET_SYNC

    self.is_in_use = self.cstatus != self.CS_UNCONFIGURED

    m = self.SYNC_RE.match(procline)

    if m:

      self.sync_percent = float(m.group(1))

      hours = int(m.group(2))

      minutes = int(m.group(3))

      seconds = int(m.group(4))

      self.est_time = hours * 3600 + minutes * 60 + seconds

    else:

      # we have (in this if branch) no percent information, but if

      # we're resyncing we need to 'fake' a sync percent information,

      # as this is how cmdlib determines if it makes sense to wait for

      # resyncing or not

      if self.is_in_resync:

        self.sync_percent = 0

      else:

        self.sync_percent = None

      self.est_time = None

class DRBD8Info(object):

  """Represents information DRBD exports (usually via /proc/drbd).

  An instance of this class is created by one of the CreateFrom... methods.

  """

  _VERSION_RE = re.compile(r"^version: (\d+)\.(\d+)\.(\d+)(?:\.\d+)?"

                           r" \(api:(\d+)/proto:(\d+)(?:-(\d+))?\)")

  _VALID_LINE_RE = re.compile("^ *([0-9]+): cs:([^ ]+).*$")

  def __init__(self, lines):

    self._version = self._ParseVersion(lines)

    self._minors, self._line_per_minor = self._JoinLinesPerMinor(lines)

  def GetVersion(self):

    """Return the DRBD version.

    This will return a dict with keys:

      - k_major

      - k_minor

      - k_point

      - api

      - proto

      - proto2 (only on drbd > 8.2.X)

    """

    return self._version

  def GetMinors(self):

    """Return a list of minor for which information is available.

    This list is ordered in exactly the order which was found in the underlying

    data.

    """

    return self._minors

  def HasMinorStatus(self, minor):

    return minor in self._line_per_minor

  def GetMinorStatus(self, minor):

    return DRBD8Status(self._line_per_minor[minor])

  def _ParseVersion(self, lines):

    first_line = lines[0].strip()

    version = self._VERSION_RE.match(first_line)

    if not version:

      raise errors.BlockDeviceError("Can't parse DRBD version from '%s'" %

                                    first_line)

    values = version.groups()

    retval = {

      "k_major": int(values[0]),

      "k_minor": int(values[1]),

      "k_point": int(values[2]),

      "api": int(values[3]),

      "proto": int(values[4]),

      }

    if values[5] is not None:

      retval["proto2"] = values[5]

    return retval

  def _JoinLinesPerMinor(self, lines):

    """Transform the raw lines into a dictionary based on the minor.

    @return: a dictionary of minor: joined lines from /proc/drbd

        for that minor

    """

    minors = []

    results = {}

    old_minor = old_line = None

    for line in lines:

      if not line: # completely empty lines, as can be returned by drbd8.0+

        continue

      lresult = self._VALID_LINE_RE.match(line)

      if lresult is not None:

        if old_minor is not None:

          minors.append(old_minor)

          results[old_minor] = old_line

        old_minor = int(lresult.group(1))

        old_line = line

      else:

        if old_minor is not None:

          old_line += " " + line.strip()

    # add last line

    if old_minor is not None:

      minors.append(old_minor)

      results[old_minor] = old_line

    return minors, results

  @staticmethod

  def CreateFromLines(lines):

    return DRBD8Info(lines)

  @staticmethod

  def CreateFromFile(filename=constants.DRBD_STATUS_FILE):

    try:

      lines = utils.ReadFile(filename).splitlines()

    except EnvironmentError, err:

      if err.errno == errno.ENOENT:

        base.ThrowError("The file %s cannot be opened, check if the module"

                        " is loaded (%s)", filename, str(err))

      else:

        base.ThrowError("Can't read the DRBD proc file %s: %s",

                        filename, str(err))

    if not lines:

      base.ThrowError("Can't read any data from %s", filename)

    return DRBD8Info.CreateFromLines(lines)

class DRBD8ShowInfo(object):

  """Helper class which parses the output of drbdsetup show

  """

  _PARSE_SHOW = None

  @classmethod

  def _GetShowParser(cls):

    """Return a parser for `drbd show` output.

    This will either create or return an already-created parser for the

    output of the command `drbd show`.

    """

    if cls._PARSE_SHOW is not None:

      return cls._PARSE_SHOW

    # pyparsing setup

    lbrace = pyp.Literal("{").suppress()

    rbrace = pyp.Literal("}").suppress()

    lbracket = pyp.Literal("[").suppress()

    rbracket = pyp.Literal("]").suppress()

    semi = pyp.Literal(";").suppress()

    colon = pyp.Literal(":").suppress()

    # this also converts the value to an int

    number = pyp.Word(pyp.nums).setParseAction(lambda s, l, t: int(t[0]))

    comment = pyp.Literal("#") + pyp.Optional(pyp.restOfLine)

    defa = pyp.Literal("_is_default").suppress()

    dbl_quote = pyp.Literal('"').suppress()

    keyword = pyp.Word(pyp.alphanums + "-")

    # value types

    value = pyp.Word(pyp.alphanums + "_-/.:")

    quoted = dbl_quote + pyp.CharsNotIn('"') + dbl_quote

    ipv4_addr = (pyp.Optional(pyp.Literal("ipv4")).suppress() +

                 pyp.Word(pyp.nums + ".") + colon + number)

    ipv6_addr = (pyp.Optional(pyp.Literal("ipv6")).suppress() +

                 pyp.Optional(lbracket) + pyp.Word(pyp.hexnums + ":") +

                 pyp.Optional(rbracket) + colon + number)

    # meta device, extended syntax

    meta_value = ((value ^ quoted) + lbracket + number + rbracket)

    # device name, extended syntax

    device_value = pyp.Literal("minor").suppress() + number

    # a statement

    stmt = (~rbrace + keyword + ~lbrace +

            pyp.Optional(ipv4_addr ^ ipv6_addr ^ value ^ quoted ^ meta_value ^

                         device_value) +

            pyp.Optional(defa) + semi +

            pyp.Optional(pyp.restOfLine).suppress())

    # an entire section

    section_name = pyp.Word(pyp.alphas + "_")

    section = section_name + lbrace + pyp.ZeroOrMore(pyp.Group(stmt)) + rbrace

    bnf = pyp.ZeroOrMore(pyp.Group(section ^ stmt))

    bnf.ignore(comment)

    cls._PARSE_SHOW = bnf

    return bnf

  @classmethod

  def GetDevInfo(cls, show_data):

    """Parse details about a given DRBD minor.

    This returns, if available, the local backing device (as a path)

    and the local and remote (ip, port) information from a string

    containing the output of the `drbdsetup show` command as returned

    by DRBD8._GetShowData.

    This will return a dict with keys:

      - local_dev

      - meta_dev

      - meta_index

      - local_addr

      - remote_addr

    """

    retval = {}

    if not show_data:

      return retval

    try:

      # run pyparse

      results = (cls._GetShowParser()).parseString(show_data)

    except pyp.ParseException, err:

      base.ThrowError("Can't parse drbdsetup show output: %s", str(err))

    # and massage the results into our desired format

    for section in results:

      sname = section[0]

      if sname == "_this_host":

        for lst in section[1:]:

          if lst[0] == "disk":

            retval["local_dev"] = lst[1]

          elif lst[0] == "meta-disk":

            retval["meta_dev"] = lst[1]

            retval["meta_index"] = lst[2]

          elif lst[0] == "address":

            retval["local_addr"] = tuple(lst[1:])

      elif sname == "_remote_host":

        for lst in section[1:]:

          if lst[0] == "address":

            retval["remote_addr"] = tuple(lst[1:])

    return retval

class DRBD8(base.BlockDev):

  """DRBD v8.x block device.

  This implements the local host part of the DRBD device, i.e. it

  doesn't do anything to the supposed peer. If you need a fully

  connected DRBD pair, you need to use this class on both hosts.

  The unique_id for the drbd device is a (local_ip, local_port,

  remote_ip, remote_port, local_minor, secret) tuple, and it must have

  two children: the data device and the meta_device. The meta device

  is checked for valid size and is zeroed on create.

  """

  _DRBD_MAJOR = 147

  _USERMODE_HELPER_FILE = "/sys/module/drbd/parameters/usermode_helper"

  _MAX_MINORS = 255

  # timeout constants

  _NET_RECONFIG_TIMEOUT = 60

  # command line options for barriers

  _DISABLE_DISK_OPTION = "--no-disk-barrier"  # -a

  _DISABLE_DRAIN_OPTION = "--no-disk-drain"   # -D

  _DISABLE_FLUSH_OPTION = "--no-disk-flushes" # -i

  _DISABLE_META_FLUSH_OPTION = "--no-md-flushes"  # -m

  def __init__(self, unique_id, children, size, params):

    if children and children.count(None) > 0:

      children = []

    if len(children) not in (0, 2):

      raise ValueError("Invalid configuration data %s" % str(children))

    if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 6:

      raise ValueError("Invalid configuration data %s" % str(unique_id))

    (self._lhost, self._lport,

     self._rhost, self._rport,

     self._aminor, self._secret) = unique_id

    if children:

      if not _CanReadDevice(children[1].dev_path):

        logging.info("drbd%s: Ignoring unreadable meta device", self._aminor)

        children = []

    super(DRBD8, self).__init__(unique_id, children, size, params)

    self.major = self._DRBD_MAJOR

    drbd_info = DRBD8Info.CreateFromFile()

    version = drbd_info.GetVersion()

    if version["k_major"] != 8:

      base.ThrowError("Mismatch in DRBD kernel version and requested ganeti"

                      " usage: kernel is %s.%s, ganeti wants 8.x",

                      version["k_major"], version["k_minor"])

    if (self._lhost is not None and self._lhost == self._rhost and

            self._lport == self._rport):

      raise ValueError("Invalid configuration data, same local/remote %s" %

                       (unique_id,))

    self.Attach()

  @staticmethod

  def GetUsermodeHelper(filename=_USERMODE_HELPER_FILE):

    """Returns DRBD usermode_helper currently set.

    """

    try:

      helper = utils.ReadFile(filename).splitlines()[0]

    except EnvironmentError, err:

      if err.errno == errno.ENOENT:

        base.ThrowError("The file %s cannot be opened, check if the module"

                        " is loaded (%s)", filename, str(err))

      else:

        base.ThrowError("Can't read DRBD helper file %s: %s",

                        filename, str(err))

    if not helper:

      base.ThrowError("Can't read any data from %s", filename)

    return helper

  @staticmethod

  def _DevPath(minor):

    """Return the path to a drbd device for a given minor.

    """

    return "/dev/drbd%d" % minor

  @classmethod

  def GetUsedDevs(cls):

    """Compute the list of used DRBD devices.

    """

    drbd_info = DRBD8Info.CreateFromFile()

    return filter(lambda m: not drbd_info.GetMinorStatus(m).is_unconfigured,

                  drbd_info.GetMinors())

  def _SetFromMinor(self, minor):

    """Set our parameters based on the given minor.

    This sets our minor variable and our dev_path.

    """

    if minor is None:

      self.minor = self.dev_path = None

      self.attached = False

    else:

      self.minor = minor

      self.dev_path = self._DevPath(minor)

      self.attached = True

  @staticmethod

  def _CheckMetaSize(meta_device):

    """Check if the given meta device looks like a valid one.

    This currently only checks the size, which must be around

    128MiB.

    """

    result = utils.RunCmd(["blockdev", "--getsize", meta_device])

    if result.failed:

      base.ThrowError("Failed to get device size: %s - %s",

                      result.fail_reason, result.output)

    try:

      sectors = int(result.stdout)

    except (TypeError, ValueError):

      base.ThrowError("Invalid output from blockdev: '%s'", result.stdout)

    num_bytes = sectors * 512

    if num_bytes < 128 * 1024 * 1024: # less than 128MiB

      base.ThrowError("Meta device too small (%.2fMib)",

                      (num_bytes / 1024 / 1024))

    # the maximum *valid* size of the meta device when living on top

    # of LVM is hard to compute: it depends on the number of stripes

    # and the PE size; e.g. a 2-stripe, 64MB PE will result in a 128MB

    # (normal size), but an eight-stripe 128MB PE will result in a 1GB

    # size meta device; as such, we restrict it to 1GB (a little bit

    # too generous, but making assumptions about PE size is hard)

    if num_bytes > 1024 * 1024 * 1024:

      base.ThrowError("Meta device too big (%.2fMiB)",

                      (num_bytes / 1024 / 1024))

  @classmethod

  def _InitMeta(cls, minor, dev_path):

    """Initialize a meta device.

    This will not work if the given minor is in use.

    """

    # Zero the metadata first, in order to make sure drbdmeta doesn't

    # try to auto-detect existing filesystems or similar (see

    # http://code.google.com/p/ganeti/issues/detail?id=182); we only

    # care about the first 128MB of data in the device, even though it

    # can be bigger

    result = utils.RunCmd([constants.DD_CMD,

                           "if=/dev/zero", "of=%s" % dev_path,

                           "bs=1048576", "count=128", "oflag=direct"])

    if result.failed:

      base.ThrowError("Can't wipe the meta device: %s", result.output)

    result = utils.RunCmd(["drbdmeta", "--force", cls._DevPath(minor),

                           "v08", dev_path, "0", "create-md"])

    if result.failed:

      base.ThrowError("Can't initialize meta device: %s", result.output)

  def _FindUnusedMinor(self):

    """Find an unused DRBD device.

    This is specific to 8.x as the minors are allocated dynamically,

    so non-existing numbers up to a max minor count are actually free.

    """

    highest = None

    drbd_info = DRBD8Info.CreateFromFile()

    for minor in drbd_info.GetMinors():

      status = drbd_info.GetMinorStatus(minor)

      if not status.is_in_use:

        return minor

      highest = max(highest, minor)

    if highest is None: # there are no minors in use at all

      return 0

    if highest >= self._MAX_MINORS:

      logging.error("Error: no free drbd minors!")

      raise errors.BlockDeviceError("Can't find a free DRBD minor")

    return highest + 1

  @classmethod

  def _GetShowData(cls, minor):

    """Return the `drbdsetup show` data for a minor.

    """

    result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "show"])

    if result.failed:

      logging.error("Can't display the drbd config: %s - %s",

                    result.fail_reason, result.output)

      return None

    return result.stdout

  def _MatchesLocal(self, info):

    """Test if our local config matches with an existing device.

    The parameter should be as returned from `_GetDevInfo()`. This

    method tests if our local backing device is the same as the one in

    the info parameter, in effect testing if we look like the given

    device.

    """

    if self._children:

      backend, meta = self._children

    else:

      backend = meta = None

    if backend is not None:

      retval = ("local_dev" in info and info["local_dev"] == backend.dev_path)

    else:

      retval = ("local_dev" not in info)

    if meta is not None:

      retval = retval and ("meta_dev" in info and

                           info["meta_dev"] == meta.dev_path)

      retval = retval and ("meta_index" in info and

                           info["meta_index"] == 0)

    else:

      retval = retval and ("meta_dev" not in info and

                           "meta_index" not in info)

    return retval

  def _MatchesNet(self, info):

    """Test if our network config matches with an existing device.

    The parameter should be as returned from `_GetDevInfo()`. This

    method tests if our network configuration is the same as the one

    in the info parameter, in effect testing if we look like the given

    device.

    """

    if (((self._lhost is None and not ("local_addr" in info)) and

         (self._rhost is None and not ("remote_addr" in info)))):

      return True

    if self._lhost is None:

      return False

    if not ("local_addr" in info and

            "remote_addr" in info):

      return False

    retval = (info["local_addr"] == (self._lhost, self._lport))

    retval = (retval and

              info["remote_addr"] == (self._rhost, self._rport))

    return retval

  def _AssembleLocal(self, minor, backend, meta, size):

    """Configure the local part of a DRBD device.

    """

    args = ["drbdsetup", self._DevPath(minor), "disk",

            backend, meta, "0",

            "-e", "detach",

            "--create-device"]

    if size:

      args.extend(["-d", "%sm" % size])

    drbd_info = DRBD8Info.CreateFromFile()

    version = drbd_info.GetVersion()

    vmaj = version["k_major"]

    vmin = version["k_minor"]

    vrel = version["k_point"]

    barrier_args = \

      self._ComputeDiskBarrierArgs(vmaj, vmin, vrel,

                                   self.params[constants.LDP_BARRIERS],

                                   self.params[constants.LDP_NO_META_FLUSH])

    args.extend(barrier_args)

    if self.params[constants.LDP_DISK_CUSTOM]:

      args.extend(shlex.split(self.params[constants.LDP_DISK_CUSTOM]))

    result = utils.RunCmd(args)

    if result.failed:

      base.ThrowError("drbd%d: can't attach local disk: %s",

                      minor, result.output)

  @classmethod

  def _ComputeDiskBarrierArgs(cls, vmaj, vmin, vrel, disabled_barriers,

                              disable_meta_flush):

    """Compute the DRBD command line parameters for disk barriers

    Returns a list of the disk barrier parameters as requested via the

    disabled_barriers and disable_meta_flush arguments, and according to the

    supported ones in the DRBD version vmaj.vmin.vrel

    If the desired option is unsupported, raises errors.BlockDeviceError.

    """

    disabled_barriers_set = frozenset(disabled_barriers)

    if not disabled_barriers_set in constants.DRBD_VALID_BARRIER_OPT:

      raise errors.BlockDeviceError("%s is not a valid option set for DRBD"

                                    " barriers" % disabled_barriers)

    args = []

    # The following code assumes DRBD 8.x, with x < 4 and x != 1 (DRBD 8.1.x

    # does not exist)

    if not vmaj == 8 and vmin in (0, 2, 3):

      raise errors.BlockDeviceError("Unsupported DRBD version: %d.%d.%d" %

                                    (vmaj, vmin, vrel))

    def _AppendOrRaise(option, min_version):

      """Helper for DRBD options"""

      if min_version is not None and vrel >= min_version:

        args.append(option)

      else:

        raise errors.BlockDeviceError("Could not use the option %s as the"

                                      " DRBD version %d.%d.%d does not support"

                                      " it." % (option, vmaj, vmin, vrel))

    # the minimum version for each feature is encoded via pairs of (minor

    # version -> x) where x is version in which support for the option was

    # introduced.

    meta_flush_supported = disk_flush_supported = {

      0: 12,

      2: 7,

      3: 0,

      }

    disk_drain_supported = {

      2: 7,

      3: 0,

      }

    disk_barriers_supported = {

      3: 0,

      }

    # meta flushes

    if disable_meta_flush:

      _AppendOrRaise(cls._DISABLE_META_FLUSH_OPTION,

                     meta_flush_supported.get(vmin, None))

    # disk flushes

    if constants.DRBD_B_DISK_FLUSH in disabled_barriers_set:

      _AppendOrRaise(cls._DISABLE_FLUSH_OPTION,

                     disk_flush_supported.get(vmin, None))

    # disk drain

    if constants.DRBD_B_DISK_DRAIN in disabled_barriers_set:

      _AppendOrRaise(cls._DISABLE_DRAIN_OPTION,

                     disk_drain_supported.get(vmin, None))

    # disk barriers

    if constants.DRBD_B_DISK_BARRIERS in disabled_barriers_set:

      _AppendOrRaise(cls._DISABLE_DISK_OPTION,

                     disk_barriers_supported.get(vmin, None))

    return args

  def _AssembleNet(self, minor, net_info, protocol,

                   dual_pri=False, hmac=None, secret=None):

    """Configure the network part of the device.

    """

    lhost, lport, rhost, rport = net_info

    if None in net_info:

      # we don't want network connection and actually want to make

      # sure its shutdown