Merge pull request #2 from anchor/gyarados

Added SSD

lib/Ceilometer/Fold.hs

@@ -23,6 +23,7 @@ module Ceilometer.Fold
   ( -- * Resource-specific Folds
     foldCPU
   , foldVolume
+  , foldSSD
   , foldInstanceFlavor
   , foldInstanceVCPU
   , foldInstanceRAM
@@ -48,6 +49,7 @@ import           Control.PFold
 type family FoldResult x where
   FoldResult PDCPU            = Word64
   FoldResult PDVolume         = Word64
+  FoldResult PDSSD            = Word64
   FoldResult PDInstanceVCPU   = Map PFValue32 Word64
   FoldResult PDInstanceRAM    = Map PFValue32 Word64
   FoldResult PDInstanceDisk   = Map PFValue32 Word64
@@ -69,6 +71,17 @@ foldVolume window = PFold step bEvent (eEvent window)
         go end acc (Just x) = M.insertWith (+) (x ^. value) (end - x ^. time) acc
         go _   acc  Nothing = acc
 
+foldSSD :: Window -> PFold (Timed PDSSD) (FoldResult PDSSD)
+foldSSD window = PFold step bEvent (eEvent window)
+  where -- Stop folding as soon as the volume is deleted
+        step (More (prev,acc)) (Timed end (PDSSD _ VolumeDelete _ _))
+          = Term (Nothing, go end acc prev)
+        step a x = sEvent window a x
+
+        -- Adds the duration up until volume delete
+        go end acc (Just x) = M.insertWith (+) (x ^. value) (end - x ^. time) acc
+        go _   acc  Nothing = acc
+
 foldInstanceFlavor :: L.Fold (Timed PDInstanceFlavor) (FoldResult PDInstanceFlavor)
 foldInstanceFlavor =  L.Fold sPollster bPollster snd
 

lib/Ceilometer/Infer.hs

@@ -1,4 +1,5 @@
 {-# LANGUAGE GADTs               #-}
+{-# LANGUAGE MultiWayIf          #-}
 {-# LANGUAGE OverloadedStrings   #-}
 {-# LANGUAGE RankNTypes          #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -60,20 +61,24 @@ inferPrismFold :: forall a. Typeable a
 inferPrismFold (Env fm sd (TimeStamp s) (TimeStamp e)) = do
   name <- lookupMetricName sd
   case name of
-    "cpu"             -> do Refl <- eqT :: Maybe (a :~: PDCPU)
-                            Just (pCPU, fCPU)
+    "cpu"                -> do Refl <- eqT :: Maybe (a :~: PDCPU)
+                               Just (pCPU, fCPU)
 
-    "volume.size"     -> do Refl <- eqT :: Maybe (a :~: PDVolume)
-                            Just (pVolume, fVolume s e)
+    "volume.size" -> if
+      | sourceIsBlock sd -> do Refl <- eqT :: Maybe (a :~: PDVolume)
+                               Just (pVolume, fVolume s e)
+      | sourceIsFast  sd -> do Refl <- eqT :: Maybe (a :~: PDSSD)
+                               Just (pSSD, fSSD s e)
+      | otherwise        ->    Nothing
 
-    "instance_flavor" -> do Refl <- eqT :: Maybe (a :~: PDInstanceFlavor)
-                            Just (pInstanceFlavor fm, fInstanceFlavor)
+    "instance_flavor"    -> do Refl <- eqT :: Maybe (a :~: PDInstanceFlavor)
+                               Just (pInstanceFlavor fm, fInstanceFlavor)
 
-    "instance_vcpu"   -> do Refl <- eqT :: Maybe (a :~: PDInstanceVCPU)
-                            Just (pInstanceVCPU, fInstanceVCPU)
+    "instance_vcpu"      -> do Refl <- eqT :: Maybe (a :~: PDInstanceVCPU)
+                               Just (pInstanceVCPU, fInstanceVCPU)
 
-    "instance_ram"    -> do Refl <- eqT :: Maybe (a :~: PDInstanceRAM)
-                            Just (pInstanceRAM, fInstanceRAM)
+    "instance_ram"       -> do Refl <- eqT :: Maybe (a :~: PDInstanceRAM)
+                               Just (pInstanceRAM, fInstanceRAM)
 
     -- TODO what about instance_disk??? does it exist? is it disk.read/write??
 
@@ -87,6 +92,9 @@ pCPU = prSimple . pdCPU
 pVolume :: APrism' Word64 PDVolume
 pVolume = prCompoundEvent . pdVolume
 
+pSSD :: APrism' Word64 PDSSD
+pSSD = prCompoundEvent . pdSSD
+
 pInstanceFlavor :: FlavorMap -> APrism' Word64 PDInstanceFlavor
 pInstanceFlavor fm = prCompoundPollster . pdInstanceFlavor fm
 
@@ -98,6 +106,7 @@ pInstanceRAM = prCompoundPollster . pdInstanceRAM
 
 fCPU            = generalizeFold (timewrapFold foldCPU)
 fVolume s e     = foldVolume (s,e)
+fSSD s e        = foldSSD (s,e)
 fInstanceFlavor = generalizeFold foldInstanceFlavor
 fInstanceVCPU   = generalizeFold foldInstanceVCPU
 fInstanceRAM    = generalizeFold foldInstanceRAM

lib/Ceilometer/Types.hs

@@ -35,12 +35,17 @@ module Ceilometer.Types
 
     -- * Payload Decoded Points
   , PDVolume(PDVolume), pdVolume
+  , PDSSD(PDSSD), pdSSD
   , PDCPU(PDCPU), pdCPU
   , PDInstanceVCPU(PDInstanceVCPU), pdInstanceVCPU
   , PDInstanceRAM(PDInstanceRAM), pdInstanceRAM
   , PDInstanceDisk(PDInstanceDisk), pdInstanceDisk
   , PDInstanceFlavor(PDInstanceFlavor), pdInstanceFlavor
 
+    -- * Extra Volume Related Values and Helpers
+  , volumeTypeBlockId, volumeTypeFastId
+  , lookupVolumeType, sourceIsBlock, sourceIsFast
+
     -- * Values
   , Valued, value
   , Timed(Timed), time
@@ -91,6 +96,10 @@ instance Valued PDVolume   where
   type PFValue PDVolume      = PFValue32
   value f (PDVolume a b c x) = PDVolume a b c <$> f x
 
+instance Valued PDSSD   where
+  type PFValue PDSSD      = PFValue32
+  value f (PDSSD a b c x) = PDSSD a b c <$> f x
+
 instance Valued PDInstanceFlavor where
   type PFValue PDInstanceFlavor  = PFValueText
   value f (PDInstanceFlavor s x) = PDInstanceFlavor s <$> f x

lib/Ceilometer/Types/Volume.hs

@@ -10,23 +10,49 @@
 -- This module defines the Ceilometer Volume type.
 --
 {-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE MultiWayIf         #-}
+{-# LANGUAGE OverloadedStrings  #-}
 {-# LANGUAGE TemplateHaskell    #-}
 
 module Ceilometer.Types.Volume
   ( -- * Fields
     PFVolumeStatus(..), pfVolumeStatus
   , PFVolumeVerb(..), pfVolumeVerb
   , PDVolume(..), pdVolume
+  , PDSSD(..), pdSSD
   , volumeStatus, volumeVerb, volumeEndpoint, volumeVal
+  , volumeTypeBlockId, volumeTypeFastId
+  , lookupVolumeType, sourceIsBlock, sourceIsFast
   ) where
 
 import           Control.Applicative
 import           Control.Lens
 import           Data.Binary           (Word8)
+import           Data.Text             (Text)
 import           Data.Typeable
 
 import           Ceilometer.Types.Base
 import           Ceilometer.Types.TH
+import           Vaultaire.Types
+
+volumeTypeBlockId, volumeTypeFastId :: Text
+volumeTypeBlockId = "7a522201-7c27-4eaa-9d95-d70cfaaeb16a"
+volumeTypeFastId  = "f7797fba-2ce2-4d19-a607-29f4bc2acb3f"
+
+lookupVolumeType :: SourceDict -> Maybe Text
+lookupVolumeType = lookupSource "volume_type"
+
+sourceIsBlock, sourceIsFast :: SourceDict -> Bool
+sourceIsBlock sd = case lookupVolumeType sd of
+  Nothing                      -> True
+  Just x  -> if
+    | x == volumeTypeBlockId -> True
+    | otherwise              -> False
+sourceIsFast  sd = case lookupVolumeType sd of
+  Nothing                      -> False
+  Just x -> if
+    | x == volumeTypeFastId  -> True
+    | otherwise              -> False
 
 $(declarePF    "Volume"
               ("Status", ''Word8)
@@ -37,16 +63,19 @@ $(declarePF    "Volume"
             , ("Deleting",  4)
             , ("Attaching", 5)
             , ("Detaching", 6)
-            , ("InUse",     7) ]
+            , ("InUse",     7)
+            , ("Retyping",  8)
+            , ("Uploading", 9) ]
             [ ''Show, ''Read, ''Eq, ''Bounded, ''Enum ])
 
 $(declarePF    "Volume"
               ("Verb", ''Word8)
             [ ("Create", 1)
             , ("Resize", 2)
             , ("Delete", 3)
-            , ("Attach", 5)
-            , ("Detach", 6) ]
+            , ("Attach", 4)
+            , ("Detach", 5)
+            , ("Update", 6) ]
             [ ''Show, ''Read, ''Eq, ''Bounded, ''Enum ])
 
 data PDVolume = PDVolume
@@ -56,7 +85,15 @@ data PDVolume = PDVolume
   , _volumeVal      :: PFValue32 }
   deriving (Eq, Show, Read, Typeable)
 
+data PDSSD = PDSSD
+  { _ssdStatus   :: PFVolumeStatus
+  , _ssdVerb     :: PFVolumeVerb
+  , _ssdEndpoint :: PFEndpoint
+  , _ssdVal      :: PFValue32 }
+  deriving (Eq, Show, Read, Typeable)
+
 $(makeLenses ''PDVolume)
+$(makeLenses ''PDSSD)
 
 pdVolume :: Prism' PRCompoundEvent PDVolume
 pdVolume = prism' pretty parse
@@ -72,3 +109,18 @@ pdVolume = prism' pretty parse
             (ep     ^. re pfEndpoint)
             (verb   ^. re pfVolumeVerb)
             (status ^. re pfVolumeStatus)
+
+pdSSD :: Prism' PRCompoundEvent PDSSD
+pdSSD = prism' pretty parse
+  where parse raw
+          =   PDSSD
+          <$> (raw ^? eventStatus   . pfVolumeStatus)
+          <*> (raw ^? eventVerb     . pfVolumeVerb)
+          <*> (raw ^? eventEndpoint . pfEndpoint)
+          <*> (raw ^? eventVal )
+        pretty (PDSSD status verb ep val)
+          = PRCompoundEvent
+            val
+            (ep     ^. re pfEndpoint)
+            (verb   ^. re pfVolumeVerb)
+            (status ^. re pfVolumeStatus)

tests/Fold.hs

@@ -30,6 +30,10 @@ suite = do
     it "ok for example payload"
       $ pFold foldVolumeAll volumeTimedPDs `shouldBe` volumeTimedPDsResult
 
+  describe "Folding points for EVENT resource: SSD" $
+    it "ok for example payload"
+      $ pFold foldSSDAll ssdTimedPDs `shouldBe` ssdTimedPDsResult
+
   -- "Pollster" resources
   describe "Folding points for POLLSTER resource: INSTANCE FLAVOR" $
     it "ok for example payload"
@@ -46,3 +50,4 @@ suite = do
       return $ pFold foldVolumeAll xs0 == pFold foldVolumeAll xs1
 
   where foldVolumeAll = foldVolume (testS, testE)
+        foldSSDAll    = foldSSD    (testS, testE)

tests/Prisms.hs

@@ -32,6 +32,7 @@ suite = do
 
   describe "CHECK: prism for DECODED PAYLOAD: " $ do
     prop "VOLUME   - is a proper prism" $ isPrism pdVolume
+    prop "SSD      - is a proper prism" $ isPrism pdSSD
     prop "CPU      - is a proper prism" $ isPrism pdCPU
     prop "VCPU     - is a proper prism" $ isPrism pdInstanceVCPU
     prop "RAM      - is a proper prism" $ isPrism pdInstanceRAM
@@ -43,6 +44,9 @@ suite = do
     it "parses/prints values correct to spec for: VOLUME" $
       shouldAllBe (preview pdVolume . view prCompoundEvent) volumePRs volumePDs
 
+    it "parses/prints values correct to spec for: SSD" $
+      shouldAllBe (preview pdSSD . view prCompoundEvent) ssdPRs ssdPDs
+
     it "parses/prints values correct to spec for: INSTANCE FLAVOR" $
       shouldAllBe (preview (pdInstanceFlavor testFlavors) . view prCompoundPollster) flavorPRs flavorPDs
 

tests/SampleData.hs

@@ -29,6 +29,7 @@ instance Function PFVolumeStatus   where function = functionShow
 instance Function PFVolumeVerb     where function = functionShow
 instance Function PDCPU            where function = functionShow
 instance Function PDVolume         where function = functionShow
+instance Function PDSSD            where function = functionShow
 instance Function PDInstanceVCPU   where function = functionShow
 instance Function PDInstanceRAM    where function = functionShow
 instance Function PDInstanceDisk   where function = functionShow
@@ -59,6 +60,11 @@ instance Arbitrary PDVolume   where arbitrary =   PDVolume
                                             <*> arbitrary
                                             <*> arbitrary
                                             <*> arbitrary
+instance Arbitrary PDSSD      where arbitrary =   PDSSD
+                                            <$> arbitrary
+                                            <*> arbitrary
+                                            <*> arbitrary
+                                            <*> arbitrary
 instance Arbitrary PDInstanceVCPU   where arbitrary =   PDInstanceVCPU
                                                   <$> arbitrary
                                                   <*> arbitrary
@@ -80,11 +86,13 @@ instance CoArbitrary PDCPU          where
   coarbitrary x = variant $ x ^. re pdCPU    . re prSimple
 instance CoArbitrary PDVolume       where
   coarbitrary x = variant $ x ^. re pdVolume . re prCompoundEvent
+instance CoArbitrary PDSSD          where
+  coarbitrary x = variant $ x ^. re pdSSD    . re prCompoundEvent
 instance CoArbitrary PDInstanceFlavor where
   coarbitrary x = variant $ x ^. re (pdInstanceFlavor testFlavors) . re prCompoundPollster
 instance CoArbitrary PDInstanceVCPU where
   coarbitrary x = variant $ x ^. re pdInstanceVCPU . re prCompoundPollster
-instance CoArbitrary PDInstanceRAM where
+instance CoArbitrary PDInstanceRAM  where
   coarbitrary x = variant $ x ^. re pdInstanceRAM . re prCompoundPollster
 instance CoArbitrary PDInstanceDisk where
   coarbitrary x = variant $ x ^. re pdInstanceDisk . re prCompoundPollster
@@ -151,6 +159,7 @@ volumeNonDelete = (arbitrary :: Gen PDVolume) `suchThat` ((/= VolumeDelete) . vi
 
 -- Raw payloads for volume points
 volumePRs = [volumePR0, volumePR1, volumePR2 ]
+ssdPRs = volumePRs
 
 volumePR0, volumePR1, volumePR2 :: Word64
 volumePR0 = 2 + (1 `shift` 8) + (2 `shift` 16) + (10 `shift` 32)
@@ -165,13 +174,27 @@ volumePD0 = PDVolume VolumeCreating VolumeCreate End 10
 volumePD1 = PDVolume VolumeCreating VolumeCreate End 30
 volumePD2 = PDVolume VolumeDeleting VolumeDelete End 30
 
+ssdPDs = [ssdPD0, ssdPD1, ssdPD2 ]
+
+ssdPD0, ssdPD1, ssdPD2 :: PDSSD
+ssdPD0 = PDSSD VolumeCreating VolumeCreate End 10
+ssdPD1 = PDSSD VolumeCreating VolumeCreate End 30
+ssdPD2 = PDSSD VolumeDeleting VolumeDelete End 30
+
 volumeTimedPDs :: [Timed PDVolume]
 volumeTimedPDs = [ Timed testS        volumePD0
                  , Timed (testS + 2)  volumePD1
                  , Timed (testS + 7)  volumePD1
                  , Timed (testS + 11) volumePD0
                  , Timed (testS + 21) volumePD2 ]
 
+ssdTimedPDs :: [Timed PDSSD]
+ssdTimedPDs = [ Timed testS        ssdPD0
+              , Timed (testS + 2)  ssdPD1
+              , Timed (testS + 7)  ssdPD1
+              , Timed (testS + 11) ssdPD0
+              , Timed (testS + 21) ssdPD2 ]
+
 -- Volume events
 -- Expected = 2 * 10 + 5 * 30 + 4 * 30 + 10 * 10
 --          = 20 + 150 + 120 + 100
@@ -180,3 +203,6 @@ volumeTimedPDs = [ Timed testS        volumePD0
 --
 volumeTimedPDsResult :: Word64
 volumeTimedPDsResult = 390
+
+ssdTimedPDsResult :: Word64
+ssdTimedPDsResult = volumeTimedPDsResult