Synnefo » snf-ganeti » ganeti-local

:directory: network-add

:env. vars: NETWORK_NAME, NETWORK_SUBNET, NETWORK_GATEWAY, NETWORK_SUBNET6,

:pre-execution: master node

:post-execution: master node

:env. vars: GROUP_NAME, NETWORK_NAME,

            GROUP_NETWORK_MODE, GROUP_NETWORK_LINK,

            NETWORK_SUBNET, NETWORK_GATEWAY, NETWORK_SUBNET6,

:pre-execution: nodegroup nodes

:post-execution: nodegroup nodes

:env. vars: GROUP_NAME, NETWORK_NAME,

            GROUP_NETWORK_MODE, GROUP_NETWORK_LINK,

            NETWORK_SUBNET, NETWORK_GATEWAY, NETWORK_SUBNET6,

:pre-execution: nodegroup nodes

:post-execution: nodegroup nodes

:directory: network-modify

:env. vars: NETWORK_NAME, NETWORK_SUBNET, NETWORK_GATEWAY, NETWORK_SUBNET6,

:pre-execution: master node

:post-execution: master node

INSTANCE_NICn_NETWORK_UUID, INSTANCE_NICn_NETWORK_SUBNET,

INSTANCE_NICn_NETWORK_GATEWAY, INSTANCE_NICn_NETWORK_SUBNET6,

INSTANCE_NICn_NETWORK_GATEWAY6, INSTANCE_NICn_NETWORK_MAC_PREFIX,

The INSTANCE_NICn_* and INSTANCE_DISKn_* variables represent the

properties of the *n* -th NIC and disk, and are zero-indexed.

        'name': 'nat',

        'network': '10.0.0.0/28',

        'network6': None,

        'reserved_count': 3,

        'tags': ['nfdhcpd'],

        …

  "NET_OPT",

  "NETWORK_OPT",

  "NETWORK6_OPT",

  "NEW_CLUSTER_CERT_OPT",

  "NEW_CLUSTER_DOMAIN_SECRET_OPT",

  "NEW_CONFD_HMAC_KEY_OPT",

                                     help="Comma-delimited list of"

                                     " reserved IPs to remove")

NETWORK6_OPT = cli_option("--network6",

                          action="store", default=None, dest="network6",

                          help="IP network in CIDR notation")

#: default list of fields for L{ListNetworks}

_LIST_DEF_FIELDS = ["name", "network", "gateway",

def _HandleReservedIPs(ips):

                            gateway6=opts.gateway6,

                            network6=opts.network6,

                            mac_prefix=opts.mac_prefix,

                            add_reserved_ips=reserved_ips,

                            conflicts_check=opts.conflicts_check,

                            tags=tags)

  cl = GetClient()

  result = cl.QueryNetworks(fields=["name", "network", "gateway",

                                    "network6", "gateway6",

                                    "free_count", "reserved_count",

                                    "map", "group_list", "inst_list",

                                    "external_reservations",

                            names=args, use_locking=False)

  for (name, network, gateway, network6, gateway6,

       mapping, group_list, instances, ext_res, serial, uuid) in result:

    size = free_count + reserved_count

    ToStdout("Network name: %s", name)

    ToStdout("  IPv6 Subnet: %s", network6)

    ToStdout("  IPv6 Gateway: %s", gateway6)

    ToStdout("  Mac Prefix: %s", mac_prefix)

    ToStdout("  Size: %d", size)

    ToStdout("  Free: %d (%.2f%%)", free_count,

             100 * float(free_count) / float(size))

    "add_reserved_ips": _HandleReservedIPs(opts.add_reserved_ips),

    "remove_reserved_ips": _HandleReservedIPs(opts.remove_reserved_ips),

    "mac_prefix": opts.mac_prefix,

    "gateway6": opts.gateway6,

    "network6": opts.network6,

  }

  "add": (

    AddNetwork, ARGS_ONE_NETWORK,

    [DRY_RUN_OPT, NETWORK_OPT, GATEWAY_OPT, ADD_RESERVED_IPS_OPT,

     NOCONFLICTSCHECK_OPT, TAG_ADD_OPT, PRIORITY_OPT, SUBMIT_OPT],

    "<network_name>", "Add a new IP network to the cluster"),

  "list": (

  "modify": (

    SetNetworkParams, ARGS_ONE_NETWORK,

    [DRY_RUN_OPT, SUBMIT_OPT, ADD_RESERVED_IPS_OPT, REMOVE_RESERVED_IPS_OPT,

     PRIORITY_OPT],

    "<network_name>", "Alters the parameters of a network"),

  "connect": (

def _BuildNetworkHookEnv(name, subnet, gateway, network6, gateway6,

  """Builds network related env variables for hooks

  This builds the hook environment from individual variables.

  @param network6: the ipv6 subnet

  @type gateway6: string

  @param gateway6: the ipv6 gateway

  @type mac_prefix: string

  @param mac_prefix: the mac_prefix

  @type tags: list

    env["NETWORK_GATEWAY6"] = gateway6

  if mac_prefix:

    env["NETWORK_MAC_PREFIX"] = mac_prefix

  if tags:

    env["NETWORK_TAGS"] = " ".join(tags)

      "network6": self.op.network6,

      "gateway6": self.op.gateway6,

      "mac_prefix": self.op.mac_prefix,

      "tags": self.op.tags,

      }

    return _BuildNetworkHookEnv(**args) # pylint: disable=W0142

                           network6=self.op.network6,

                           gateway6=self.op.gateway6,

                           mac_prefix=self.op.mac_prefix,

                           uuid=self.network_uuid,

                           family=constants.IP4_VERSION)

    # Initialize the associated address pool

    """

    self.network = self.cfg.GetNetwork(self.network_uuid)

    self.gateway = self.network.gateway

    self.mac_prefix = self.network.mac_prefix

    self.network6 = self.network.network6

    self.gateway6 = self.network.gateway6

                                     " reserved" % self.gateway,

                                     errors.ECODE_STATE)

    if self.op.mac_prefix:

      if self.op.mac_prefix == constants.VALUE_NONE:

        self.mac_prefix = None

      "network6": self.network6,

      "gateway6": self.gateway6,

      "mac_prefix": self.mac_prefix,

      "tags": self.tags,

      }

    return _BuildNetworkHookEnv(**args) # pylint: disable=W0142

    if self.op.gateway6:

      self.network.gateway6 = self.gateway6

    self.pool.Validate()

    self.cfg.Update(self.network, feedback_fn)

RESERVE_ACTION = "reserve"

RELEASE_ACTION = "release"

NICS_PARAMETER_TYPES = {

  NIC_MODE: VTYPE_STRING,

  NIC_LINK: VTYPE_STRING,

def _BuildNetworkEnv(name, network, gateway, network6, gateway6,

  """Build environment variables concerning a Network.

  """

    env["NETWORK_GATEWAY6"] = gateway6

  if mac_prefix:

    env["NETWORK_MAC_PREFIX"] = mac_prefix

  if tags:

    env["NETWORK_TAGS"] = " ".join(tags)

    if nic.network:

      n = objects.Network.FromDict(nic.netinfo)

      _BuildNetworkEnv(nic.network, n.network, n.gateway,

                       n.mac_prefix, n.tags, env)

    if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:

  __slots__ = [

    "name",

    "serial_no",

    "mac_prefix",

    "family",

    "network",

      result["%sNETWORK_GATEWAY6" % prefix] = self.gateway6

    if self.mac_prefix:

      result["%sNETWORK_MAC_PREFIX" % prefix] = self.mac_prefix

    return result

class SerializableConfigParser(ConfigParser.SafeConfigParser):

  """Simple wrapper over ConfigParse that allows serialization.

_PStorageType = ("storage_type", ht.NoDefault, _CheckStorageType,

                 "Storage type")

@ht.WithDesc("IPv4 network")

def _CheckCIDRNetNotation(value):

  OP_DSC_FIELD = "network_name"

  OP_PARAMS = [

    _PNetworkName,

    ("network", ht.NoDefault, _TIpNetwork4, "IPv4 subnet"),

    ("gateway", None, ht.TMaybe(_TIpAddress4), "IPv4 gateway"),

    ("network6", None, ht.TMaybe(_TIpNetwork6), "IPv6 subnet"),

  OP_DSC_FIELD = "network_name"

  OP_PARAMS = [

    _PNetworkName,

    ("gateway", None, ht.TMaybeValueNone(_TIpAddress4), "IPv4 gateway"),

    ("network6", None, ht.TMaybeValueNone(_TIpNetwork6), "IPv6 subnet"),

    ("gateway6", None, ht.TMaybeValueNone(_TIpAddress6), "IPv6 gateway"),

  "network6": ("IPv6Subnet", QFT_OTHER, 0, "IPv6 subnet"),

  "gateway6": ("IPv6Gateway", QFT_OTHER, 0, "IPv6 gateway"),

  "mac_prefix": ("MacPrefix", QFT_OTHER, 0, "MAC address prefix"),

  "serial_no": ("SerialNo", QFT_NUMBER, 0, _SERIAL_NO_DOC % "Network"),

  "uuid": ("UUID", QFT_TEXT, 0, "Network UUID"),

  }

                             None, None)

  def CreateNetwork(self, network_name, network, gateway=None, network6=None,

                    add_reserved_ips=None, tags=None, dry_run=False):

    """Creates a new network.

      "gateway6": gateway6,

      "network6": network6,

      "mac_prefix": mac_prefix,

      "add_reserved_ips": add_reserved_ips,

      "tags": tags,

      }

NET_FIELDS = ["name", "network", "gateway",

              "network6", "gateway6",

              "free_count", "reserved_count",

              "map", "group_list", "inst_list",

              "external_reservations", "tags",

NIC_%d_NETWORK_MAC_PREFIX

    (Optional) If a NIC network is specified, the network's mac prefix.

NIC_%d_NETWORK_TAGS

    (Optional) If a NIC network is specified, the network's tags, space

    separated.

| [--network6=*NETWORK6*]

| [--gateway6=*GATEWAY6*]

| [--mac-prefix=*MACPREFIX*]

| [--submit]

| {*network*}

The ``--gateway`` option allows you to specify the default gateway for

this network.

IPv6 semantics can be assigned to the network via the ``--network6`` and

``--gateway6`` options. IP pool is meaningless for IPV6 so those two

values can be used for EUI64 generation from a NIC's MAC address.

| [--network6=*NETWORK6*]

| [--gateway6=*GATEWAY6*]

| [--mac-prefix=*MACPREFIX*]

| [--submit]

| {*network*}

$(buildObject "Network" "network" $

  [ simpleField "name"             [t| NonEmptyString |]

  , optionalField $

    simpleField "mac_prefix"       [t| String |]

  , optionalField $

    simpleField "family"           [t| Int |]

     ])

  , ("OpNetworkAdd",

     [ pNetworkName

     , pNetworkAddress4

     , pNetworkGateway4

     , pNetworkAddress6

     ])

  , ("OpNetworkSetParams",

     [ pNetworkName

     , pNetworkGateway4

     , pNetworkAddress6

     , pNetworkGateway6

  , pTestDummyFail

  , pTestDummySubmitJobs

  , pNetworkName

  , pNetworkAddress4

  , pNetworkGateway4

  , pNetworkAddress6

pNetworkName :: Field

pNetworkName = simpleField "network_name" [t| NonEmptyString |]

-- | Network address (IPv4 subnet). FIXME: no real type for this.

pNetworkAddress4 :: Field

pNetworkAddress4 =

  , IAllocatorTestDir(..)

  , IAllocatorMode(..)

  , iAllocatorModeToRaw

  , NICMode(..)

  , nICModeToRaw

  , JobStatus(..)

  ])

$(THH.makeJSONInstance ''IAllocatorMode)

-- | Netork mode.

$(THH.declareSADT "NICMode"

  [ ("NMBridged", 'C.nicModeBridged)

module Test.Ganeti.Network

  ( testNetwork

  , genBitStringMaxLen

  ) where

import Test.QuickCheck

import Test.Ganeti.Objects

  ( genBitStringMaxLen

  , genValidNetwork )

import Test.Ganeti.TestHelper

import Test.Ganeti.TestCommon

  , Node(..)

  , genEmptyCluster

  , genValidNetwork

  , genBitStringMaxLen

  ) where

import qualified Data.Set as Set

import qualified Text.JSON as J

import Test.Ganeti.TestHelper

import Test.Ganeti.TestCommon

import Test.Ganeti.Types ()

  -- generate netmask for the IPv4 network

  netmask <- choose (24::Int, 30)

  name <- genName >>= mkNonEmpty

  mac_prefix <- genMaybe genName

  net <- genIp4NetWithNetmask netmask

  net6 <- genMaybe genIp6Net

  gateway <- genMaybe genIp4AddrStr

  gateway6 <- genMaybe genIp6Addr

  res <- liftM Just (genBitString $ netmask2NumHosts netmask)

  ext_res <- liftM Just (genBitString $ netmask2NumHosts netmask)

  return n

-- | Generate an arbitrary string consisting of '0' and '1' of the given length.

genBitString :: Int -> Gen String

genBitString len = vectorOf len (elements "01")

        OpCodes.OpTestDummy <$> pure J.JSNull <*> pure J.JSNull <*>

          pure J.JSNull <*> pure J.JSNull

      "OP_NETWORK_ADD" ->

          genMaybe genIp4Addr <*> pure Nothing <*> pure Nothing <*>

          genMaybe genMacPrefix <*> genMaybe (listOf genIp4Addr) <*>

          arbitrary <*> (genTags >>= mapM mkNonEmpty)

      "OP_NETWORK_REMOVE" ->

        OpCodes.OpNetworkRemove <$> genNameNE <*> arbitrary

      "OP_NETWORK_SET_PARAMS" ->

          genMaybe genIp4Addr <*> pure Nothing <*> pure Nothing <*>

          genMaybe genMacPrefix <*> genMaybe (listOf genIp4Addr) <*>

          genMaybe (listOf genIp4Addr)

$(genArbitrary ''IAllocatorMode)

$(genArbitrary ''NICMode)

$(genArbitrary ''JobStatus)

      all_hs_codes = sort $ map Types.iAllocatorModeToRaw [minBound..maxBound]

  assertEqual "for IAllocatorMode equivalence" all_py_codes all_hs_codes

-- | Test 'NICMode' serialisation.

prop_NICMode_serialisation :: NICMode -> Property

prop_NICMode_serialisation = testSerialisation

  , 'prop_IAllocatorTestDir_serialisation

  , 'prop_IAllocatorMode_serialisation

  , 'case_IAllocatorMode_pyequiv

  , 'prop_NICMode_serialisation

  , 'prop_OpStatus_serialization

  , 'prop_JobStatus_serialization