Synnefo » snf-ganeti » ganeti-local

  disk <- fromObj "disk_space_total" a

  mem <- fromObj "memory" a

  vcpus <- fromObj "vcpus" a

  let running = "running"

-- | Parses an instance as found in the cluster instance listg.

parseInstance :: NameAssoc        -- ^ The node name-to-index association list

                         , sNode :: T.Ndx    -- ^ Original secondary node

                         , idx :: T.Idx      -- ^ Internal index

                         , util :: T.DynUtil -- ^ Dynamic resource usage

                         } deriving (Show)

instance T.Element Instance where

--

-- Some parameters are not initialized by function, and must be set

-- later (via 'setIdx' for example).

    Instance { name = name_init

             , mem = mem_init

             , dsk = dsk_init

             , sNode = sn

             , idx = -1

             , util = T.baseUtil

             }

-- | Changes the index.

    let nnames = JSArray []

        fnames = ["name",

                  "disk_usage", "be/memory", "be/vcpus",

        fields = JSArray $ map (JSString . toJSString) fnames

        use_locking = JSBool False

    in JSArray [nnames, fields, use_locking]

              -> JSValue

              -> Result (String, Instance.Instance)

parseInstance ktn (JSArray [ name, disk, mem, vcpus

  xname <- annotateResult "Parsing new instance" (fromJVal name)

  let convert v = annotateResult ("Instance '" ++ xname ++ "'") (fromJVal v)

  xdisk <- convert disk

  snode <- (if null xsnodes then return Node.noSecondary

            else lookupNode ktn xname (fromJSString $ head xsnodes))

  xrunning <- convert status

  return (xname, inst)

parseInstance _ v = fail ("Invalid instance query result: " ++ show v)

  snode <- (if null snodes then return Node.noSecondary

            else readEitherString (head snodes) >>= lookupNode ktn name)

  running <- extract "status" a

  return (name, inst)

-- | Construct a node from a JSON object.

-- | Load an instance from a field list.

loadInst :: (Monad m) =>

            [(String, Ndx)] -> [String] -> m (String, Instance.Instance)

  pidx <- lookupNode ktn name pnode

  sidx <- (if null snode then return Node.noSecondary

           else lookupNode ktn name snode)

  vvcpus <- tryRead name vcpus

  when (sidx == pidx) $ fail $ "Instance " ++ name ++

           " has same primary and secondary node - " ++ pnode

  return (name, newinst)

loadInst _ s = fail $ "Invalid/incomplete instance data: '" ++ show s ++ "'"

                    then ""

                    else Container.nameOf nl sidx ++ csf)

    in

             iname (Instance.mem inst) (Instance.dsk inst)

             (Instance.vcpus inst) (Instance.runSt inst)

-- | Generate instance file data from instance objects

serializeInstances :: String -> Node.List -> Instance.List -> String

  -- utility functions

  let iofspec spx = Instance.create "new" (rspecMem spx) (rspecDsk spx)

      exitifbad val = (case val of

                         Bad s -> do

                           hPrintf stderr "Failure: %s\n" s