Synnefo » snf-ganeti

    http://www.openssh.com/portable.html

  - bridge utilities

    http://bridge.sourceforge.net/

  - iproute2

    http://developer.osdl.org/dev/iproute2

  - arping (part of iputils package)

  """Starts the master.

  """

      # we already have the ip:

      if debug:

        sys.stderr.write("Notice: already started.\n")

from ganeti import objects

from ganeti import errors

from ganeti import ssconf

from twisted.spread import pb

from twisted.internet import reactor

  # node --------------------------

  @staticmethod

  def perspective_node_info(params):

    """Query node information.

        </listitem>

        <listitem>

          <simpara><ulink

          url="http://developer.osdl.org/dev/iproute2">iproute2</ulink></simpara>

        </listitem>

        <listitem>

      </formalpara>

      <screen>

# apt-get install lvm2 ssh bridge-utils iproute iputils-arping \

  mdadm

      </screen>

    self.clustername = clustername = utils.HostInfo(self.op.cluster_name)

      raise errors.OpPrereqError("Inconsistency: this host's name resolves"

                                 " to %s,\nbut this ip address does not"

                                 " belong to this host."

    secondary_ip = getattr(self.op, "secondary_ip", None)

    if secondary_ip and not utils.IsValidIP(secondary_ip):

      raise errors.OpPrereqError("Invalid secondary ip given")

    self.secondary_ip = secondary_ip

    # checks presence of the volume group given

                                   " new node doesn't have one")

    # checks reachablity

      raise errors.OpPrereqError("Node not reachable by ping")

    if not newbie_singlehomed:

      # check reachability from my secondary ip to newbie's secondary ip

    self.new_node = objects.Node(name=node,

                                 primary_ip=primary_ip,

                      self.cfg.GetHostKey())

    if new_node.secondary_ip != new_node.primary_ip:

        raise errors.OpExecError("Node claims it doesn't have the"

                                 " secondary ip you gave (%s).\n"

                                 "Please fix and re-run this command." %

                                 " adding an instance in start mode")

    if self.op.ip_check:

    # bridge verification

    bridge = getattr(self.op, "bridge", None)

# others

DEFAULT_BRIDGE = "xen-br0"

SYNC_SPEED = 30 * 1024

  return c.getresult()

def call_node_info(node_list, vg_name):

  """Return node information.

from ganeti import logger

from ganeti import errors

_locksheld = []

_re_shell_unquoted = re.compile('^[-.,=:/_+@A-Za-z0-9]+$')

  return ' '.join([ShellQuote(i) for i in args])

  """Simple ping implementation using TCP connect(2).

  Try to do a TCP connect(2) from the specified source IP to the specified

  def _init_cluster(self, cfg):

    """Initializes the cfg object"""

  def _create_instance(self):

    """Create and return an instance object"""

import shutil

import ganeti

from ganeti.utils import IsProcessAlive, Lock, Unlock, RunCmd, \

     RemoveFile, CheckDict, MatchNameComponent, FormatUnit, \

     ParseUnit, AddAuthorizedKey, RemoveAuthorizedKey, \

from ganeti.errors import LockError, UnitParseError

    self.assertEqual(ShellQuoteArgs(['a', 'b\'', 'c']), "a 'b'\\\''' c")

class TestTcpPing(unittest.TestCase):

  """Testcase for TCP version of ping - against listen(2)ing port"""

  def setUp(self):

    self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    self.listenerport = self.listener.getsockname()[1]

    self.listener.listen(1)

    del self.listenerport

  def testTcpPingToLocalHostAccept(self):

                         self.listenerport,

                         timeout=10,

                         live_port_needed=True),

  def setUp(self):

    self.deaflistener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    self.deaflistenerport = self.deaflistener.getsockname()[1]

  def tearDown(self):

    del self.deaflistenerport

  def testTcpPingToLocalHostAcceptDeaf(self):

                        self.deaflistenerport,

                        live_port_needed=True), # need successful connect(2)

                "successfully connected to deaf listener")

  def testTcpPingToLocalHostNoAccept(self):

                         self.deaflistenerport,

                         live_port_needed=False), # ECONNREFUSED is OK

                 "failed to ping alive host on deaf port")