Synnefo » snf-ganeti » ganeti-local

-- | Constant node index for a non-moveable instance

noSecondary :: Int

noSecondary = -1

                 if Instance.snode elem == noSecondary then step_tbl

{- | Convert newline and delimiter-separated text.

This function converts a text in tabular format as generated by

@gnt-instance list@ and @gnt-node list@ to a list of objects using a

supplied conversion function.

-}

loadTabular :: (Monad m) => String -> ([String] -> m (String, a))

            -> (a -> Int -> a) -> m ([(String, Int)], [(Int, a)])

loadTabular text_data convert_fn set_fn = do

  let lines_data = lines text_data

      rows = map (sepSplit '|') lines_data

  kerows <- mapM convert_fn rows

  let idxrows = map (\ (idx, (k, v)) -> ((k, idx), (idx, set_fn v idx)))

                (zip [0..] kerows)

  return $ unzip idxrows

                  if sdx /= noSecondary then

-- | Safe 'read' function returning data encapsulated in a Result

tryRead :: (Monad m, Read a) => String -> String -> m a

tryRead name s =

    let sols = readsPrec 0 s

    in case sols of

         (v, ""):[] -> return v

         (_, e):[] -> fail $ name ++ ": leftover characters when parsing '"

                      ++ s ++ "': '" ++ e ++ "'"

         _ -> fail $ name ++ ": cannot parse string '" ++ s ++ "'"

-- | Lookups a node into an assoc list

lookupNode :: (Monad m) => String -> String -> [(String, Int)] -> m Int

lookupNode node inst ktn =

    case lookup node ktn of

      Nothing -> fail $ "Unknown node '" ++ node ++ "' for instance " ++ inst

      Just idx -> return idx

-- | Load a node from a field list

loadNode :: (Monad m) => [String] -> m (String, Node.Node)

loadNode (name:tm:nm:fm:td:fd:fo:[]) = do

  new_node <-

      if any (== "?") [tm,nm,fm,td,fd] || fo == "Y" then

          return $ Node.create 0 0 0 0 0 True

      else do

        vtm <- tryRead name tm

        vnm <- tryRead name nm

        vfm <- tryRead name fm

        vtd <- tryRead name td

        vfd <- tryRead name fd

        return $ Node.create vtm vnm vfm vtd vfd False

  return (name, new_node)

loadNode s = fail $ "Invalid/incomplete node data: '" ++ (show s) ++ "'"

-- | Load an instance from a field list

loadInst :: (Monad m) =>

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

loadInst ktn (name:mem:dsk:status:pnode:snode:[]) = do

  pidx <- lookupNode pnode name ktn

  sidx <- (if null snode then return noSecondary

           else lookupNode snode name ktn)

  vmem <- tryRead name mem

  vdsk <- tryRead name dsk

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

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

  let newinst = Instance.create vmem vdsk status pidx sidx

  return (name, newinst)

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

loadData :: String -- ^ Node data in text format

         -> String -- ^ Instance data in text format

         -> Result (Container.Container Node.Node,

                    Container.Container Instance.Instance,

                    String, NameList, NameList)

loadData ndata idata = do

  {- node file: name t_mem n_mem f_mem t_disk f_disk -}

  (ktn, nl) <- loadTabular ndata loadNode Node.setIdx

      {- instance file: name mem disk status pnode snode -}

  (kti, il) <- loadTabular idata (loadInst ktn) Instance.setIdx