-- This module defines hard-coded sample data -- for parsing/printing and folding. -- {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverlappingInstances #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TypeSynonymInstances #-} {-# OPTIONS -fno-warn-orphans#-} {-# OPTIONS -fno-warn-missing-signatures #-} module SampleData where import Control.Applicative import qualified Control.Foldl as L import Control.Lens hiding (elements) import Control.Monad import qualified Data.Bimap as BM import Data.Binary (Word64) import Data.Bits import Data.List.Ordered import Data.Map (Map) import qualified Data.Map as M import Data.Maybe import Data.Word import Test.QuickCheck import Test.QuickCheck.Function import Ceilometer.Fold import Ceilometer.Types import Ceilometer.Types.Image (imageVerb) import Ceilometer.Types.Instance (siphashID) import Ceilometer.Types.IP (ipVerb) import Ceilometer.Types.Snapshot (snapshotVerb) import Ceilometer.Types.Volume (volumeVerb) -- Instances (DO NOT DEFNE NEW ONES IN TESTS) ---------------------------------- instance Function PFEndpoint where function = functionShow instance Function PFVolumeStatus where function = functionShow instance Function PFVolumeVerb where function = functionShow instance Function PFImageStatus where function = functionShow instance Function PFImageVerb where function = functionShow instance Function PFSnapshotStatus where function = functionShow instance Function PFSnapshotVerb where function = functionShow instance Function PFIPStatus where function = functionShow instance Function PFIPVerb where function = functionShow instance Function PDCPU where function = functionShow instance Function PDVolume where function = functionShow instance Function PDSSD where function = functionShow instance Function PDImage where function = functionShow instance Function PDImagePollster where function = functionShow instance Function PDIP where function = functionShow instance Function PDSnapshot where function = functionShow instance Function PDInstanceVCPU where function = functionShow instance Function PDInstanceRAM where function = functionShow instance Function PDInstanceDisk where function = functionShow instance Function PDInstanceFlavor where function = functionShow instance Arbitrary a => Arbitrary [Timed a] where arbitrary = do bigNumber <- choose (1, 10000) let ts = [1..bigNumber] vs <- replicateM (fromIntegral bigNumber) arbitrary return $ zipWith Timed ts vs instance Arbitrary PRSimple where arbitrary = PRSimple <$> arbitrary instance Arbitrary PRCompoundEvent where arbitrary = PRCompoundEvent <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary instance Arbitrary PRCompoundPollster where arbitrary = PRCompoundPollster <$> arbitrary <*> arbitrary instance Arbitrary PFEndpoint where arbitrary = arbitraryBoundedEnum instance Arbitrary PFVolumeVerb where arbitrary = arbitraryBoundedEnum instance Arbitrary PFVolumeStatus where arbitrary = arbitraryBoundedEnum instance Arbitrary PFInstanceStatus where arbitrary = arbitraryBoundedEnum instance Arbitrary PFImageVerb where arbitrary = arbitraryBoundedEnum instance Arbitrary PFImageStatus where arbitrary = arbitraryBoundedEnum instance Arbitrary PFSnapshotVerb where arbitrary = arbitraryBoundedEnum instance Arbitrary PFSnapshotStatus where arbitrary = arbitraryBoundedEnum instance Arbitrary PFIPVerb where arbitrary = arbitraryBoundedEnum instance Arbitrary PFIPStatus where arbitrary = arbitraryBoundedEnum instance Arbitrary PFIPAlloc where arbitrary = arbitraryBoundedEnum instance Arbitrary PFValueText where arbitrary = elements $ BM.keys testFlavors instance Arbitrary PDCPU where arbitrary = PDCPU <$> arbitrary instance Arbitrary PDVolume where arbitrary = PDVolume <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary instance Arbitrary PDSSD where arbitrary = PDSSD <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary instance Arbitrary PDInstanceVCPU where arbitrary = PDInstanceVCPU <$> arbitrary <*> arbitrary instance Arbitrary PDInstanceRAM where arbitrary = PDInstanceRAM <$> arbitrary <*> arbitrary instance Arbitrary PDInstanceDisk where arbitrary = PDInstanceDisk <$> arbitrary <*> arbitrary instance Arbitrary PDInstanceFlavor where arbitrary = PDInstanceFlavor <$> arbitrary <*> arbitrary instance Arbitrary PDImage where arbitrary = PDImage <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary instance Arbitrary PDImagePollster where arbitrary = PDImagePollster <$> arbitrary instance Arbitrary PDSnapshot where arbitrary = PDSnapshot <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary instance Arbitrary PDIP where arbitrary = PDIP <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary instance CoArbitrary PFEndpoint where coarbitrary = variant . fromEnum instance CoArbitrary PFVolumeStatus where coarbitrary = variant . fromEnum instance CoArbitrary PFVolumeVerb where coarbitrary = variant . fromEnum instance CoArbitrary PFImageVerb where coarbitrary = variant . fromEnum instance CoArbitrary PFImageStatus where coarbitrary = variant . fromEnum instance CoArbitrary PFSnapshotVerb where coarbitrary = variant . fromEnum instance CoArbitrary PFSnapshotStatus where coarbitrary = variant . fromEnum instance CoArbitrary PFIPVerb where coarbitrary = variant . fromEnum instance CoArbitrary PFIPStatus where coarbitrary = variant . fromEnum 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 PDImage where coarbitrary x = variant $ x ^. re pdImage . re prCompoundEvent instance CoArbitrary PDImagePollster where coarbitrary x = variant $ x ^. re pdImagePollster . re prSimple instance CoArbitrary PDSnapshot where coarbitrary x = variant $ x ^. re pdSnapshot . re prCompoundEvent instance CoArbitrary PDIP where coarbitrary x = variant $ x ^. re pdIP . 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 coarbitrary x = variant $ x ^. re pdInstanceRAM . re prCompoundPollster instance CoArbitrary PDInstanceDisk where coarbitrary x = variant $ x ^. re pdInstanceDisk . re prCompoundPollster testS, testE :: Word64 testS = 1300000000000000000 testE = 1400000000000000000 -- INSTANCES ------------------------------------------------------------------- testFlavors :: FlavorMap testFlavors = BM.fromList [ (flavorID0, flavorSP0) , (flavorID1, flavorSP1) , (flavorID2, flavorSP2) ] flavorID0 = "deadbeef" flavorSP0 = siphashID flavorID0 flavorID1 = "koolaid" flavorSP1 = siphashID flavorID1 flavorID2 = "chicken" flavorSP2 = siphashID flavorID2 flavorPR0, flavorPR1, flavorPR2 :: Word64 flavorPR0 = 1 + (0 `shift` 8) + (0 `shift` 16) + (fromIntegral flavorSP0 `shift` 32) flavorPR1 = 9 + (0 `shift` 8) + (0 `shift` 16) + (fromIntegral flavorSP1 `shift` 32) flavorPR2 = 15 + (0 `shift` 8) + (0 `shift` 16) + (fromIntegral flavorSP2 `shift` 32) flavorPRs = [ flavorPR0, flavorPR1, flavorPR2 ] flavorPD0 = PDInstanceFlavor InstanceActive flavorID0 flavorPD1 = PDInstanceFlavor InstanceReboot flavorID1 flavorPD2 = PDInstanceFlavor InstancePaused flavorID2 flavorPDs = [ flavorPD0, flavorPD1, flavorPD2 ] flavorTimedPDs = [ Timed testS flavorPD1 , Timed (testS + 2) flavorPD1 , Timed (testS + 7) flavorPD2 , Timed (testS + 11) flavorPD1 , Timed (testS + 13) flavorPD1 ] flavorTimedPDsResult :: [(PFValue PDInstanceFlavor, Word64)] flavorTimedPDsResult = [ (flavorID1, 9) , (flavorID2, 4) ] -- | Basic safety properties for filtered folding. -- The set of keys in the result of the filtered fold should be a subset of -- the result of the non-filtered fold. -- For each defined key in the filtered result, the corresponding value -- should be no larger than in the non-filtered result. propSafetyInstance :: [Timed PDInstanceFlavor] -> Bool propSafetyInstance x = let testPred (PDInstanceFlavor InstanceActive _) = True testPred _ = False fullResult = L.fold (foldInstanceFlavor (const True)) x filteredResult = L.fold (foldInstanceFlavor testPred ) x fullKeys = M.keys fullResult filteredKeys = M.keys filteredResult in subset filteredKeys fullKeys && all (\k -> isJust $ do v <- M.lookup k fullResult v' <- M.lookup k filteredResult return $ v' <= v) filteredKeys -- CPU ------------------------------------------------------------------------- cumulativeIncreasing = [30, 40, 50, 60] cumulativeDecreasing = [40, 30, 20, 10] cumulativeAny = [20, 30, 10, 20, 30, 40, 10] cpuIncreasing = map PDCPU cumulativeIncreasing cpuDecreasing = map PDCPU cumulativeDecreasing cpuAny = map PDCPU cumulativeAny neutronRxIncreasing = map PDNeutronRx cumulativeIncreasing neutronRxDecreasing = map PDNeutronRx cumulativeDecreasing neutronRxAny = map PDNeutronRx cumulativeAny neutronTxIncreasing = map PDNeutronTx cumulativeIncreasing neutronTxDecreasing = map PDNeutronTx cumulativeDecreasing neutronTxAny = map PDNeutronTx cumulativeAny diskReadIncreasing = map PDDiskRead cumulativeIncreasing diskReadDecreasing = map PDDiskRead cumulativeDecreasing diskReadAny = map PDDiskRead cumulativeAny diskWriteIncreasing = map PDDiskWrite cumulativeIncreasing diskWriteDecreasing = map PDDiskWrite cumulativeDecreasing diskWriteAny = map PDDiskWrite cumulativeAny cumulativeDecreasingResult, cumulativeIncreasingResult, cumulativeAnyResult :: Word64 cumulativeDecreasingResult = 60 cumulativeIncreasingResult = 30 cumulativeAnyResult = 60 -- VOLUME ---------------------------------------------------------------------- volumeNonDelete :: Gen PDVolume volumeNonDelete = (arbitrary :: Gen PDVolume) `suchThat` ((/= VolumeDelete) . view volumeVerb) -- 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) volumePR1 = 2 + (1 `shift` 8) + (2 `shift` 16) + (30 `shift` 32) volumePR2 = 4 + (3 `shift` 8) + (2 `shift` 16) + (30 `shift` 32) -- Decoded payloads for volume points volumePDs = [volumePD0, volumePD1, volumePD2 ] volumePD0, volumePD1, volumePD2 :: PDVolume 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 -- = (2 + 10) * 10 + (5 + 4) * 30 -- = 12 * 10 + 9 * 30 -- = 390 -- from borel-core -- volumeTimedPDsResult :: Word64 volumeTimedPDsResult = 390 ssdTimedPDsResult :: Word64 ssdTimedPDsResult = volumeTimedPDsResult -- IMAGE ---------------------------------------------------------------------- imageNonDelete :: Gen PDImage imageNonDelete = (arbitrary :: Gen PDImage) `suchThat` ((/= ImageDelete) . view imageVerb) -- Raw payloads for volume points imagePRs = [imagePR0, imagePR1, imagePR2 ] imagePR0, imagePR1, imagePR2 :: Word64 imagePR0 = 1 + (3 `shift` 8) + (0 `shift` 16) + (200000 `shift` 32) imagePR1 = 1 + (1 `shift` 8) + (0 `shift` 16) + (400000 `shift` 32) imagePR2 = 3 + (5 `shift` 8) + (0 `shift` 16) + (100000 `shift` 32) -- Decoded payloads for image points imagePDs = [imagePD0, imagePD1, imagePD2 ] imagePD0, imagePD1, imagePD2 :: PDImage imagePD0 = PDImage ImageActive ImageUpload Instant 200000 imagePD1 = PDImage ImageActive ImageServe Instant 400000 imagePD2 = PDImage ImageDeleted ImageDelete Instant 100000 imageTimedPDs :: [Timed PDImage] imageTimedPDs = [ Timed testS imagePD0 , Timed (testS + 5) imagePD1 , Timed (testS + 12) imagePD1 , Timed (testS + 21) imagePD0 , Timed (testS + 32) imagePD2 ] -- Image events -- Expected = 5 * 200000 -- + 7 * 400000 -- + 9 * 400000 -- + 11 * 200000 -- = 16 * 200000 -- + 16 * 400000 -- = 9600000 -- imageTimedPDsResult :: Word64 imageTimedPDsResult = 9600000 imagePPD0, imagePPD1, imagePPD2 :: PDImagePollster imagePPD0 = PDImagePollster 200000 imagePPD1 = PDImagePollster 400000 imagePPD2 = PDImagePollster 100000 imagePTimedPDs :: [Timed PDImagePollster] imagePTimedPDs = [ Timed testS imagePPD0 , Timed (testS + 5) imagePPD1 , Timed (testS + 12) imagePPD2 , Timed (testS + 21) imagePPD1 , Timed (testS + 32) imagePPD2 ] imagePTimedPDsResult :: Map Word64 Word64 imagePTimedPDsResult = M.fromList [ (200000, 5) , (400000, 18) , (100000, 9) ] -- SNAPSHOT ---------------------------------------------------------------------- snapshotNonDelete :: Gen PDSnapshot snapshotNonDelete = (arbitrary :: Gen PDSnapshot) `suchThat` ((/= SnapshotDelete) . view snapshotVerb) -- Raw payloads for volume points snapshotPRs = [snapshotPR0, snapshotPR1, snapshotPR2 ] snapshotPR0, snapshotPR1, snapshotPR2 :: Word64 snapshotPR0 = 1 + (2 `shift` 8) + (2 `shift` 16) + (200 `shift` 32) snapshotPR1 = 1 + (2 `shift` 8) + (2 `shift` 16) + (300 `shift` 32) snapshotPR2 = 3 + (3 `shift` 8) + (2 `shift` 16) + (100 `shift` 32) -- Decoded payloads for snapshot points snapshotPDs = [snapshotPD0, snapshotPD1, snapshotPD2 ] snapshotPD0, snapshotPD1, snapshotPD2 :: PDSnapshot snapshotPD0 = PDSnapshot SnapshotAvailable SnapshotUpdate End 200 snapshotPD1 = PDSnapshot SnapshotAvailable SnapshotUpdate End 300 snapshotPD2 = PDSnapshot SnapshotDeleting SnapshotDelete End 100 snapshotTimedPDs :: [Timed PDSnapshot] snapshotTimedPDs = [ Timed testS snapshotPD0 , Timed (testS + 5) snapshotPD1 , Timed (testS + 12) snapshotPD1 , Timed (testS + 21) snapshotPD0 , Timed (testS + 32) snapshotPD2 ] -- Snapshot events -- Expected = 5 * 200 -- + 7 * 300 -- + 9 * 300 -- + 11 * 200 -- = 16 * 200 -- + 16 * 300 -- = 8000 -- snapshotTimedPDsResult :: Word64 snapshotTimedPDsResult = 8000 -- IP ---------------------------------------------------------------------- -- Raw payloads for volume points ipPRs = [ipPR0, ipPR1, ipPR2 ] ipPR0, ipPR1, ipPR2 :: Word64 ipPR0 = 1 + (2 `shift` 8) + (2 `shift` 16) + (1 `shift` 32) ipPR1 = 2 + (2 `shift` 8) + (2 `shift` 16) + (1 `shift` 32) ipPR2 = 0 + (3 `shift` 8) + (2 `shift` 16) + (1 `shift` 32) -- Decoded payloads for ip points ipPDs = [ipPD0, ipPD1, ipPD2 ] ipPD0, ipPD1, ipPD2 :: PDIP ipPD0 = PDIP IPActive IPUpdate End IPAlloc ipPD1 = PDIP IPDown IPUpdate End IPAlloc ipPD2 = PDIP IPNone IPDelete End IPAlloc