Revision 7dd14211

b/htools/Ganeti/HTools/IAlloc.hs
68 68
  vcpus <- extract "vcpus"
69 69
  tags  <- extract "tags"
70 70
  dt    <- extract "disk_template"
71
  let running = "running"
72
  return (n, Instance.create n mem disk vcpus running tags True 0 0 dt)
71
  return (n, Instance.create n mem disk vcpus Running tags True 0 0 dt)
73 72

  
74 73
-- | Parses an instance as found in the cluster instance list.
75 74
parseInstance :: NameAssoc -- ^ The node name-to-index association list
b/htools/Ganeti/HTools/Instance.hs
62 62
    , dsk          :: Int       -- ^ Disk size of instance
63 63
    , vcpus        :: Int       -- ^ Number of VCPUs
64 64
    , running      :: Bool      -- ^ Is the instance running?
65
    , runSt        :: String    -- ^ Original (text) run status
65
    , runSt        :: T.InstanceStatus -- ^ Original run status
66 66
    , pNode        :: T.Ndx     -- ^ Original primary node
67 67
    , sNode        :: T.Ndx     -- ^ Original secondary node
68 68
    , idx          :: T.Idx     -- ^ Internal index
......
81 81
    allNames n = [name n, alias n]
82 82

  
83 83
-- | Constant holding the running instance states.
84
runningStates :: [String]
85
runningStates = [C.inststRunning, C.inststErrorup]
84
runningStates :: [T.InstanceStatus]
85
runningStates = [T.Running, T.ErrorUp]
86 86

  
87 87
-- | Constant holding the local storage templates.
88 88
--
......
115 115
--
116 116
-- Some parameters are not initialized by function, and must be set
117 117
-- later (via 'setIdx' for example).
118
create :: String -> Int -> Int -> Int -> String
118
create :: String -> Int -> Int -> Int -> T.InstanceStatus
119 119
       -> [String] -> Bool -> T.Ndx -> T.Ndx -> T.DiskTemplate -> Instance
120 120
create name_init mem_init dsk_init vcpus_init run_init tags_init
121 121
       auto_balance_init pn sn dt =
b/htools/Ganeti/HTools/Program/Hspace.hs
424 424

  
425 425
  -- utility functions
426 426
  let iofspec spx = Instance.create "new" (rspecMem spx) (rspecDsk spx)
427
                    (rspecCpu spx) "running" [] True (-1) (-1) disk_template
427
                    (rspecCpu spx) Running [] True (-1) (-1) disk_template
428 428

  
429 429
  allocnodes <- exitIfBad $ Cluster.genAllocNodes gl nl req_nodes True
430 430

  
b/htools/Ganeti/HTools/QC.hs
123 123

  
124 124
-- | Create an instance given its spec.
125 125
createInstance mem dsk vcpus =
126
    Instance.create "inst-unnamed" mem dsk vcpus "running" [] True (-1) (-1)
126
    Instance.create "inst-unnamed" mem dsk vcpus Types.Running [] True (-1) (-1)
127 127
                    Types.DTDrbd8
128 128

  
129 129
-- | Create a small cluster by repeating a node spec.
......
187 187
  let frest' = map (map dnsGetChar) frest
188 188
  return (felem ++ "." ++ intercalate "." frest')
189 189

  
190
instance Arbitrary Types.InstanceStatus where
191
    arbitrary = elements [ Types.AdminDown
192
                         , Types.AdminOffline
193
                         , Types.ErrorDown
194
                         , Types.ErrorUp
195
                         , Types.NodeDown
196
                         , Types.NodeOffline
197
                         , Types.Running
198
                         , Types.WrongNode]
199

  
190 200
-- let's generate a random instance
191 201
instance Arbitrary Instance.Instance where
192 202
    arbitrary = do
193 203
      name <- getFQDN
194 204
      mem <- choose (0, maxMem)
195 205
      dsk <- choose (0, maxDsk)
196
      run_st <- elements [ C.inststErrorup
197
                         , C.inststErrordown
198
                         , C.inststAdmindown
199
                         , C.inststNodedown
200
                         , C.inststNodeoffline
201
                         , C.inststRunning
202
                         , "no_such_status1"
203
                         , "no_such_status2"]
206
      run_st <- arbitrary
204 207
      pn <- arbitrary
205 208
      sn <- arbitrary
206 209
      vcpus <- choose (0, maxCpu)
......
591 594
    let vcpus_s = show vcpus
592 595
        dsk_s = show dsk
593 596
        mem_s = show mem
597
        status_s = Types.instanceStatusToRaw status
594 598
        ndx = if null snode
595 599
              then [(pnode, pdx)]
596 600
              else [(pnode, pdx), (snode, sdx)]
......
599 603
        sbal = if autobal then "Y" else "N"
600 604
        sdt = Types.diskTemplateToRaw dt
601 605
        inst = Text.loadInst nl
602
               [name, mem_s, dsk_s, vcpus_s, status,
606
               [name, mem_s, dsk_s, vcpus_s, status_s,
603 607
                sbal, pnode, snode, sdt, tags]
604 608
        fail1 = Text.loadInst nl
605
               [name, mem_s, dsk_s, vcpus_s, status,
609
               [name, mem_s, dsk_s, vcpus_s, status_s,
606 610
                sbal, pnode, pnode, tags]
607 611
        _types = ( name::String, mem::Int, dsk::Int
608
                 , vcpus::Int, status::String
612
                 , vcpus::Int, status::Types.InstanceStatus
609 613
                 , snode::String
610 614
                 , autobal::Bool)
611 615
    in
b/htools/Ganeti/HTools/Text.hs
95 95
    in
96 96
      printf "%s|%d|%d|%d|%s|%s|%s|%s|%s|%s"
97 97
             iname (Instance.mem inst) (Instance.dsk inst)
98
             (Instance.vcpus inst) (Instance.runSt inst)
98
             (Instance.vcpus inst) (instanceStatusToRaw (Instance.runSt inst))
99 99
             (if Instance.autoBalance inst then "Y" else "N")
100 100
             pnode snode (diskTemplateToRaw (Instance.diskTemplate inst))
101 101
             (intercalate "," (Instance.tags inst))
......
162 162
  vmem <- tryRead name mem
163 163
  vdsk <- tryRead name dsk
164 164
  vvcpus <- tryRead name vcpus
165
  vstatus <- instanceStatusFromRaw status
165 166
  auto_balance <- case auto_bal of
166 167
                    "Y" -> return True
167 168
                    "N" -> return False
......
172 173
  when (sidx == pidx) $ fail $ "Instance " ++ name ++
173 174
           " has same primary and secondary node - " ++ pnode
174 175
  let vtags = sepSplit ',' tags
175
      newinst = Instance.create name vmem vdsk vvcpus status vtags
176
      newinst = Instance.create name vmem vdsk vvcpus vstatus vtags
176 177
                auto_balance pidx sidx disk_template
177 178
  return (name, newinst)
178 179
loadInst _ s = fail $ "Invalid/incomplete instance data: '" ++ show s ++ "'"

Also available in: Unified diff