@@ -0,0 +1,2431 @@
2+{-# LANGUAGE FlexibleInstances #-}
3+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
4+{-# LANGUAGE MultiParamTypeClasses #-}
5+{-# LANGUAGE OverloadedStrings #-}
6+{-# LANGUAGE RecordWildCards #-}
7+{-# LANGUAGE UndecidableInstances #-}
9+module Database.Bloodhound.Internal.Client where
11+import Bloodhound.Import
13+#if defined(MIN_VERSION_GLASGOW_HASKELL)
14+#if MIN_VERSION_GLASGOW_HASKELL(8,6,0,0)
15+import Control.Monad.Fail (MonadFail)
18+import qualified Data.Text as T
19+import qualified Data.Traversable as DT
20+import qualified Data.HashMap.Strict as HM
21+import qualified Data.SemVer as SemVer
22+import qualified Data.Vector as V
24+import Network.HTTP.Client
25+import Text.Read (Read(..))
26+import qualified Text.Read as TR
28+import Database.Bloodhound.Internal.Analysis
29+import Database.Bloodhound.Internal.Newtypes
30+import Database.Bloodhound.Internal.Query
31+import Database.Bloodhound.Internal.StringlyTyped
33+{-| Common environment for Elasticsearch calls. Connections will be
34+ pipelined according to the provided HTTP connection manager.
36+data BHEnv = BHEnv { bhServer :: Server
37+ , bhManager :: Manager
38+ , bhRequestHook :: Request -> IO Request
39+ -- ^ Low-level hook that is run before every request is sent. Used to implement custom authentication strategies. Defaults to 'return' with 'mkBHEnv'.
42+instance (Functor m, Applicative m, MonadIO m) => MonadBH (ReaderT BHEnv m) where
45+{-| 'Server' is used with the client functions to point at the ES instance
47+newtype Server = Server Text deriving (Eq, Show, FromJSON)
49+{-| All API calls to Elasticsearch operate within
51+ . The idea is that it can be easily embedded in your
52+ own monad transformer stack. A default instance for a ReaderT and
53+ alias 'BH' is provided for the simple case.
55+class (Functor m, Applicative m, MonadIO m) => MonadBH m where
58+-- | Create a 'BHEnv' with all optional fields defaulted. HTTP hook
59+-- will be a noop. You can use the exported fields to customize
62+-- >> (mkBHEnv myServer myManager) { bhRequestHook = customHook }
63+mkBHEnv :: Server -> Manager -> BHEnv
64+mkBHEnv s m = BHEnv s m return
67+ unBH :: ReaderT BHEnv m a
80+#if defined(MIN_VERSION_GLASGOW_HASKELL)
81+#if MIN_VERSION_GLASGOW_HASKELL(8,6,0,0)
87+instance MonadTrans BH where
90+instance (MonadReader r m) => MonadReader r (BH m) where
92+ local f (BH (ReaderT m)) = BH $ ReaderT $ \r ->
95+instance (Functor m, Applicative m, MonadIO m) => MonadBH (BH m) where
96+ getBHEnv = BH getBHEnv
98+runBH :: BHEnv -> BH m a -> m a
99+runBH e f = runReaderT (unBH f) e
101+{-| 'Version' is embedded in 'Status' -}
102+data Version = Version { number :: VersionNumber
103+ , build_hash :: BuildHash
104+ , build_date :: UTCTime
105+ , build_snapshot :: Bool
106+ , lucene_version :: VersionNumber }
109+-- | Traditional software versioning number
110+newtype VersionNumber = VersionNumber
111+ { versionNumber :: SemVer.Version }
112+ deriving (Eq, Ord, Show)
114+{-| 'Status' is a data type for describing the JSON body returned by
115+ Elasticsearch when you query its status. This was deprecated in 1.2.0.
117+ <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-status.html#indices-status>
122+ , cluster_name :: Text
123+ , cluster_uuid :: Text
124+ , version :: Version
128+instance FromJSON Status where
129+ parseJSON (Object v) = Status <$>
131+ v .: "cluster_name" <*>
132+ v .: "cluster_uuid" <*>
137+{-| 'IndexSettings' is used to configure the shards and replicas when
138+ you create an Elasticsearch Index.
140+ <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html>
143+data IndexSettings = IndexSettings
144+ { indexShards :: ShardCount
145+ , indexReplicas :: ReplicaCount }
148+instance ToJSON IndexSettings where
149+ toJSON (IndexSettings s r) = object ["settings" .=
151+ object ["number_of_shards" .= s, "number_of_replicas" .= r]
155+instance FromJSON IndexSettings where
156+ parseJSON = withObject "IndexSettings" parse
157+ where parse o = do s <- o .: "settings"
159+ IndexSettings <$> i .: "number_of_shards"
160+ <*> i .: "number_of_replicas"
162+{-| 'defaultIndexSettings' is an 'IndexSettings' with 3 shards and
164+defaultIndexSettings :: IndexSettings
165+defaultIndexSettings = IndexSettings (ShardCount 3) (ReplicaCount 2)
166+-- defaultIndexSettings is exported by Database.Bloodhound as well
167+-- no trailing slashes in servers, library handles building the path.
170+{-| 'ForceMergeIndexSettings' is used to configure index optimization. See
171+ <https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-forcemerge.html>
174+data ForceMergeIndexSettings =
175+ ForceMergeIndexSettings { maxNumSegments :: Maybe Int
176+ -- ^ Number of segments to optimize to. 1 will fully optimize the index. If omitted, the default behavior is to only optimize if the server deems it necessary.
177+ , onlyExpungeDeletes :: Bool
178+ -- ^ Should the optimize process only expunge segments with deletes in them? If the purpose of the optimization is to free disk space, this should be set to True.
179+ , flushAfterOptimize :: Bool
180+ -- ^ Should a flush be performed after the optimize.
181+ } deriving (Eq, Show)
184+{-| 'defaultForceMergeIndexSettings' implements the default settings that
185+ Elasticsearch uses for index optimization. 'maxNumSegments' is Nothing,
186+ 'onlyExpungeDeletes' is False, and flushAfterOptimize is True.
188+defaultForceMergeIndexSettings :: ForceMergeIndexSettings
189+defaultForceMergeIndexSettings = ForceMergeIndexSettings Nothing False True
191+{-| 'UpdatableIndexSetting' are settings which may be updated after an index is created.
193+ <https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html>
195+data UpdatableIndexSetting = NumberOfReplicas ReplicaCount
196+ -- ^ The number of replicas each shard has.
197+ | AutoExpandReplicas ReplicaBounds
198+ | BlocksReadOnly Bool
199+ -- ^ Set to True to have the index read only. False to allow writes and metadata changes.
201+ -- ^ Set to True to disable read operations against the index.
203+ -- ^ Set to True to disable write operations against the index.
204+ | BlocksMetaData Bool
205+ -- ^ Set to True to disable metadata operations against the index.
206+ | RefreshInterval NominalDiffTime
207+ -- ^ The async refresh interval of a shard
208+ | IndexConcurrency Int
209+ | FailOnMergeFailure Bool
210+ | TranslogFlushThresholdOps Int
211+ -- ^ When to flush on operations.
212+ | TranslogFlushThresholdSize Bytes
213+ -- ^ When to flush based on translog (bytes) size.
214+ | TranslogFlushThresholdPeriod NominalDiffTime
215+ -- ^ When to flush based on a period of not flushing.
216+ | TranslogDisableFlush Bool
217+ -- ^ Disables flushing. Note, should be set for a short interval and then enabled.
218+ | CacheFilterMaxSize (Maybe Bytes)
219+ -- ^ The maximum size of filter cache (per segment in shard).
220+ | CacheFilterExpire (Maybe NominalDiffTime)
221+ -- ^ The expire after access time for filter cache.
222+ | GatewaySnapshotInterval NominalDiffTime
223+ -- ^ The gateway snapshot interval (only applies to shared gateways).
224+ | RoutingAllocationInclude (NonEmpty NodeAttrFilter)
225+ -- ^ A node matching any rule will be allowed to host shards from the index.
226+ | RoutingAllocationExclude (NonEmpty NodeAttrFilter)
227+ -- ^ A node matching any rule will NOT be allowed to host shards from the index.
228+ | RoutingAllocationRequire (NonEmpty NodeAttrFilter)
229+ -- ^ Only nodes matching all rules will be allowed to host shards from the index.
230+ | RoutingAllocationEnable AllocationPolicy
231+ -- ^ Enables shard allocation for a specific index.
232+ | RoutingAllocationShardsPerNode ShardCount
233+ -- ^ Controls the total number of shards (replicas and primaries) allowed to be allocated on a single node.
234+ | RecoveryInitialShards InitialShardCount
235+ -- ^ When using local gateway a particular shard is recovered only if there can be allocated quorum shards in the cluster.
236+ | GCDeletes NominalDiffTime
237+ | TTLDisablePurge Bool
238+ -- ^ Disables temporarily the purge of expired docs.
239+ | TranslogFSType FSType
240+ | CompressionSetting Compression
241+ | IndexCompoundFormat CompoundFormat
242+ | IndexCompoundOnFlush Bool
243+ | WarmerEnabled Bool
244+ | MappingTotalFieldsLimit Int
245+ | AnalysisSetting Analysis
246+ -- ^ Analysis is not a dynamic setting and can only be performed on a closed index.
249+attrFilterJSON :: NonEmpty NodeAttrFilter -> Value
250+attrFilterJSON fs = object [ n .= T.intercalate "," (toList vs)
251+ | NodeAttrFilter (NodeAttrName n) vs <- toList fs]
253+parseAttrFilter :: Value -> Parser (NonEmpty NodeAttrFilter)
254+parseAttrFilter = withObject "NonEmpty NodeAttrFilter" parse
255+ where parse o = case HM.toList o of
256+ [] -> fail "Expected non-empty list of NodeAttrFilters"
257+ x:xs -> DT.mapM (uncurry parse') (x :| xs)
258+ parse' n = withText "Text" $ \t ->
259+ case T.splitOn "," t of
260+ fv:fvs -> return (NodeAttrFilter (NodeAttrName n) (fv :| fvs))
261+ [] -> fail "Expected non-empty list of filter values"
263+instance ToJSON UpdatableIndexSetting where
264+ toJSON (NumberOfReplicas x) = oPath ("index" :| ["number_of_replicas"]) x
265+ toJSON (AutoExpandReplicas x) = oPath ("index" :| ["auto_expand_replicas"]) x
266+ toJSON (RefreshInterval x) = oPath ("index" :| ["refresh_interval"]) (NominalDiffTimeJSON x)
267+ toJSON (IndexConcurrency x) = oPath ("index" :| ["concurrency"]) x
268+ toJSON (FailOnMergeFailure x) = oPath ("index" :| ["fail_on_merge_failure"]) x
269+ toJSON (TranslogFlushThresholdOps x) = oPath ("index" :| ["translog", "flush_threshold_ops"]) x
270+ toJSON (TranslogFlushThresholdSize x) = oPath ("index" :| ["translog", "flush_threshold_size"]) x
271+ toJSON (TranslogFlushThresholdPeriod x) = oPath ("index" :| ["translog", "flush_threshold_period"]) (NominalDiffTimeJSON x)
272+ toJSON (TranslogDisableFlush x) = oPath ("index" :| ["translog", "disable_flush"]) x
273+ toJSON (CacheFilterMaxSize x) = oPath ("index" :| ["cache", "filter", "max_size"]) x
274+ toJSON (CacheFilterExpire x) = oPath ("index" :| ["cache", "filter", "expire"]) (NominalDiffTimeJSON <$> x)
275+ toJSON (GatewaySnapshotInterval x) = oPath ("index" :| ["gateway", "snapshot_interval"]) (NominalDiffTimeJSON x)
276+ toJSON (RoutingAllocationInclude fs) = oPath ("index" :| ["routing", "allocation", "include"]) (attrFilterJSON fs)
277+ toJSON (RoutingAllocationExclude fs) = oPath ("index" :| ["routing", "allocation", "exclude"]) (attrFilterJSON fs)
278+ toJSON (RoutingAllocationRequire fs) = oPath ("index" :| ["routing", "allocation", "require"]) (attrFilterJSON fs)
279+ toJSON (RoutingAllocationEnable x) = oPath ("index" :| ["routing", "allocation", "enable"]) x
280+ toJSON (RoutingAllocationShardsPerNode x) = oPath ("index" :| ["routing", "allocation", "total_shards_per_node"]) x
281+ toJSON (RecoveryInitialShards x) = oPath ("index" :| ["recovery", "initial_shards"]) x
282+ toJSON (GCDeletes x) = oPath ("index" :| ["gc_deletes"]) (NominalDiffTimeJSON x)
283+ toJSON (TTLDisablePurge x) = oPath ("index" :| ["ttl", "disable_purge"]) x
284+ toJSON (TranslogFSType x) = oPath ("index" :| ["translog", "fs", "type"]) x
285+ toJSON (CompressionSetting x) = oPath ("index" :| ["codec"]) x
286+ toJSON (IndexCompoundFormat x) = oPath ("index" :| ["compound_format"]) x
287+ toJSON (IndexCompoundOnFlush x) = oPath ("index" :| ["compound_on_flush"]) x
288+ toJSON (WarmerEnabled x) = oPath ("index" :| ["warmer", "enabled"]) x
289+ toJSON (BlocksReadOnly x) = oPath ("blocks" :| ["read_only"]) x
290+ toJSON (BlocksRead x) = oPath ("blocks" :| ["read"]) x
291+ toJSON (BlocksWrite x) = oPath ("blocks" :| ["write"]) x
292+ toJSON (BlocksMetaData x) = oPath ("blocks" :| ["metadata"]) x
293+ toJSON (MappingTotalFieldsLimit x) = oPath ("index" :| ["mapping","total_fields","limit"]) x
294+ toJSON (AnalysisSetting x) = oPath ("index" :| ["analysis"]) x
296+instance FromJSON UpdatableIndexSetting where
297+ parseJSON = withObject "UpdatableIndexSetting" parse
298+ where parse o = numberOfReplicas `taggedAt` ["index", "number_of_replicas"]
299+ <|> autoExpandReplicas `taggedAt` ["index", "auto_expand_replicas"]
300+ <|> refreshInterval `taggedAt` ["index", "refresh_interval"]
301+ <|> indexConcurrency `taggedAt` ["index", "concurrency"]
302+ <|> failOnMergeFailure `taggedAt` ["index", "fail_on_merge_failure"]
303+ <|> translogFlushThresholdOps `taggedAt` ["index", "translog", "flush_threshold_ops"]
304+ <|> translogFlushThresholdSize `taggedAt` ["index", "translog", "flush_threshold_size"]
305+ <|> translogFlushThresholdPeriod `taggedAt` ["index", "translog", "flush_threshold_period"]
306+ <|> translogDisableFlush `taggedAt` ["index", "translog", "disable_flush"]
307+ <|> cacheFilterMaxSize `taggedAt` ["index", "cache", "filter", "max_size"]
308+ <|> cacheFilterExpire `taggedAt` ["index", "cache", "filter", "expire"]
309+ <|> gatewaySnapshotInterval `taggedAt` ["index", "gateway", "snapshot_interval"]
310+ <|> routingAllocationInclude `taggedAt` ["index", "routing", "allocation", "include"]
311+ <|> routingAllocationExclude `taggedAt` ["index", "routing", "allocation", "exclude"]
312+ <|> routingAllocationRequire `taggedAt` ["index", "routing", "allocation", "require"]
313+ <|> routingAllocationEnable `taggedAt` ["index", "routing", "allocation", "enable"]
314+ <|> routingAllocationShardsPerNode `taggedAt` ["index", "routing", "allocation", "total_shards_per_node"]
315+ <|> recoveryInitialShards `taggedAt` ["index", "recovery", "initial_shards"]
316+ <|> gcDeletes `taggedAt` ["index", "gc_deletes"]
317+ <|> ttlDisablePurge `taggedAt` ["index", "ttl", "disable_purge"]
318+ <|> translogFSType `taggedAt` ["index", "translog", "fs", "type"]
319+ <|> compressionSetting `taggedAt` ["index", "codec"]
320+ <|> compoundFormat `taggedAt` ["index", "compound_format"]
321+ <|> compoundOnFlush `taggedAt` ["index", "compound_on_flush"]
322+ <|> warmerEnabled `taggedAt` ["index", "warmer", "enabled"]
323+ <|> blocksReadOnly `taggedAt` ["blocks", "read_only"]
324+ <|> blocksRead `taggedAt` ["blocks", "read"]
325+ <|> blocksWrite `taggedAt` ["blocks", "write"]
326+ <|> blocksMetaData `taggedAt` ["blocks", "metadata"]
327+ <|> mappingTotalFieldsLimit `taggedAt` ["index", "mapping", "total_fields", "limit"]
328+ <|> analysisSetting `taggedAt` ["index", "analysis"]
329+ where taggedAt f ks = taggedAt' f (Object o) ks
331+ f =<< (parseJSON v <|> parseJSON (unStringlyTypeJSON v))
332+ taggedAt' f v (k:ks) =
333+ withObject "Object" (\o -> do v' <- o .: k
334+ taggedAt' f v' ks) v
335+ numberOfReplicas = pure . NumberOfReplicas
336+ autoExpandReplicas = pure . AutoExpandReplicas
337+ refreshInterval = pure . RefreshInterval . ndtJSON
338+ indexConcurrency = pure . IndexConcurrency
339+ failOnMergeFailure = pure . FailOnMergeFailure
340+ translogFlushThresholdOps = pure . TranslogFlushThresholdOps
341+ translogFlushThresholdSize = pure . TranslogFlushThresholdSize
342+ translogFlushThresholdPeriod = pure . TranslogFlushThresholdPeriod . ndtJSON
343+ translogDisableFlush = pure . TranslogDisableFlush
344+ cacheFilterMaxSize = pure . CacheFilterMaxSize
345+ cacheFilterExpire = pure . CacheFilterExpire . fmap ndtJSON
346+ gatewaySnapshotInterval = pure . GatewaySnapshotInterval . ndtJSON
347+ routingAllocationInclude = fmap RoutingAllocationInclude . parseAttrFilter
348+ routingAllocationExclude = fmap RoutingAllocationExclude . parseAttrFilter
349+ routingAllocationRequire = fmap RoutingAllocationRequire . parseAttrFilter
350+ routingAllocationEnable = pure . RoutingAllocationEnable
351+ routingAllocationShardsPerNode = pure . RoutingAllocationShardsPerNode
352+ recoveryInitialShards = pure . RecoveryInitialShards
353+ gcDeletes = pure . GCDeletes . ndtJSON
354+ ttlDisablePurge = pure . TTLDisablePurge
355+ translogFSType = pure . TranslogFSType
356+ compressionSetting = pure . CompressionSetting
357+ compoundFormat = pure . IndexCompoundFormat
358+ compoundOnFlush = pure . IndexCompoundOnFlush
359+ warmerEnabled = pure . WarmerEnabled
360+ blocksReadOnly = pure . BlocksReadOnly
361+ blocksRead = pure . BlocksRead
362+ blocksWrite = pure . BlocksWrite
363+ blocksMetaData = pure . BlocksMetaData
364+ mappingTotalFieldsLimit = pure . MappingTotalFieldsLimit
365+ analysisSetting = pure . AnalysisSetting
367+data ReplicaBounds = ReplicasBounded Int Int
368+ | ReplicasLowerBounded Int
373+instance ToJSON ReplicaBounds where
374+ toJSON (ReplicasBounded a b) = String (showText a <> "-" <> showText b)
375+ toJSON (ReplicasLowerBounded a) = String (showText a <> "-all")
376+ toJSON ReplicasUnbounded = Bool False
378+instance FromJSON ReplicaBounds where
379+ parseJSON v = withText "ReplicaBounds" parseText v
380+ <|> withBool "ReplicaBounds" parseBool v
381+ where parseText t = case T.splitOn "-" t of
382+ [a, "all"] -> ReplicasLowerBounded <$> parseReadText a
383+ [a, b] -> ReplicasBounded <$> parseReadText a
385+ _ -> fail ("Could not parse ReplicaBounds: " <> show t)
386+ parseBool False = pure ReplicasUnbounded
387+ parseBool _ = fail "ReplicasUnbounded cannot be represented with True"
390+ = CompressionDefault
391+ -- ^ Compress with LZ4
393+ -- ^ Compress with DEFLATE. Elastic
394+ -- <https://www.elastic.co/blog/elasticsearch-storage-the-true-story-2.0 blogs>
395+ -- that this can reduce disk use by 15%-25%.
398+instance ToJSON Compression where
399+ toJSON x = case x of
400+ CompressionDefault -> toJSON ("default" :: Text)
401+ CompressionBest -> toJSON ("best_compression" :: Text)
403+instance FromJSON Compression where
404+ parseJSON = withText "Compression" $ \t -> case t of
405+ "default" -> return CompressionDefault
406+ "best_compression" -> return CompressionBest
407+ _ -> fail "invalid compression codec"
409+-- | A measure of bytes used for various configurations. You may want
410+-- to use smart constructors like 'gigabytes' for larger values.
422+ deriving (Eq, Show, Ord, ToJSON, FromJSON)
424+gigabytes :: Int -> Bytes
425+gigabytes n = megabytes (1000 * n)
428+megabytes :: Int -> Bytes
429+megabytes n = kilobytes (1000 * n)
432+kilobytes :: Int -> Bytes
433+kilobytes n = Bytes (1000 * n)
436+data FSType = FSSimple
437+ | FSBuffered deriving (Eq, Show)
439+instance ToJSON FSType where
440+ toJSON FSSimple = "simple"
441+ toJSON FSBuffered = "buffered"
443+instance FromJSON FSType where
444+ parseJSON = withText "FSType" parse
445+ where parse "simple" = pure FSSimple
446+ parse "buffered" = pure FSBuffered
447+ parse t = fail ("Invalid FSType: " <> show t)
449+data InitialShardCount = QuorumShards
450+ | QuorumMinus1Shards
453+ | ExplicitShards Int
456+instance FromJSON InitialShardCount where
457+ parseJSON v = withText "InitialShardCount" parseText v
458+ <|> ExplicitShards <$> parseJSON v
459+ where parseText "quorum" = pure QuorumShards
460+ parseText "quorum-1" = pure QuorumMinus1Shards
461+ parseText "full" = pure FullShards
462+ parseText "full-1" = pure FullMinus1Shards
465+instance ToJSON InitialShardCount where
466+ toJSON QuorumShards = String "quorum"
467+ toJSON QuorumMinus1Shards = String "quorum-1"
468+ toJSON FullShards = String "full"
469+ toJSON FullMinus1Shards = String "full-1"
470+ toJSON (ExplicitShards x) = toJSON x
472+data NodeAttrFilter = NodeAttrFilter
473+ { nodeAttrFilterName :: NodeAttrName
474+ , nodeAttrFilterValues :: NonEmpty Text }
475+ deriving (Eq, Ord, Show)
477+newtype NodeAttrName = NodeAttrName Text deriving (Eq, Ord, Show)
479+data CompoundFormat = CompoundFileFormat Bool
480+ | MergeSegmentVsTotalIndex Double
481+ -- ^ percentage between 0 and 1 where 0 is false, 1 is true
484+instance ToJSON CompoundFormat where
485+ toJSON (CompoundFileFormat x) = Bool x
486+ toJSON (MergeSegmentVsTotalIndex x) = toJSON x
488+instance FromJSON CompoundFormat where
489+ parseJSON v = CompoundFileFormat <$> parseJSON v
490+ <|> MergeSegmentVsTotalIndex <$> parseJSON v
492+newtype NominalDiffTimeJSON =
493+ NominalDiffTimeJSON { ndtJSON :: NominalDiffTime }
495+instance ToJSON NominalDiffTimeJSON where
496+ toJSON (NominalDiffTimeJSON t) = String (showText (round t :: Integer) <> "s")
498+instance FromJSON NominalDiffTimeJSON where
499+ parseJSON = withText "NominalDiffTime" parse
500+ where parse t = case T.takeEnd 1 t of
501+ "s" -> NominalDiffTimeJSON . fromInteger <$> parseReadText (T.dropEnd 1 t)
502+ _ -> fail "Invalid or missing NominalDiffTime unit (expected s)"
504+data IndexSettingsSummary = IndexSettingsSummary
505+ { sSummaryIndexName :: IndexName
506+ , sSummaryFixedSettings :: IndexSettings
507+ , sSummaryUpdateable :: [UpdatableIndexSetting]}
510+parseSettings :: Object -> Parser [UpdatableIndexSetting]
513+ -- slice the index object into singleton hashmaps and try to parse each
514+ parses <- forM (HM.toList o') $ \(k, v) -> do
515+ -- blocks are now nested into the "index" key, which is not how they're serialized
516+ let atRoot = Object (HM.singleton k v)
517+ let atIndex = Object (HM.singleton "index" atRoot)
518+ optional (parseJSON atRoot <|> parseJSON atIndex)
519+ return (catMaybes parses)
521+instance FromJSON IndexSettingsSummary where
522+ parseJSON = withObject "IndexSettingsSummary" parse
523+ where parse o = case HM.toList o of
524+ [(ixn, v@(Object o'))] -> IndexSettingsSummary (IndexName ixn)
526+ <*> (fmap (filter (not . redundant)) . parseSettings =<< o' .: "settings")
527+ _ -> fail "Expected single-key object with index name"
528+ redundant (NumberOfReplicas _) = True
531+{-| 'Reply' and 'Method' are type synonyms from 'Network.HTTP.Types.Method.Method' -}
532+type Reply = Network.HTTP.Client.Response LByteString
534+{-| 'OpenCloseIndex' is a sum type for opening and closing indices.
536+ <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html>
538+data OpenCloseIndex = OpenIndex | CloseIndex deriving (Eq, Show)
540+data FieldType = GeoPointType
546+ | ByteType deriving (Eq, Show)
548+newtype FieldDefinition = FieldDefinition
549+ { fieldType :: FieldType
550+ } deriving (Eq, Show)
552+{-| An 'IndexTemplate' defines a template that will automatically be
553+ applied to new indices created. The templates include both
554+ 'IndexSettings' and mappings, and a simple 'TemplatePattern' that
555+ controls if the template will be applied to the index created.
556+ Specify mappings as follows: @[toJSON TweetMapping, ...]@
558+ https://www.elastic.co/guide/en/elasticsearch/reference/1.7/indices-templates.html
561+ IndexTemplate { templatePattern :: TemplatePattern
562+ , templateSettings :: Maybe IndexSettings
563+ , templateMappings :: [Value]
566+instance ToJSON IndexTemplate where
567+ toJSON (IndexTemplate p s m) = merge
568+ (object [ "template" .= p
569+ , "mappings" .= foldl' merge (object []) m
573+ merge (Object o1) (Object o2) = toJSON $ HM.union o1 o2
575+ merge _ _ = undefined
578+ MappingField { mappingFieldName :: FieldName
579+ , fieldDefinition :: FieldDefinition }
582+{-| Support for type reification of 'Mapping's is currently incomplete, for
583+ now the mapping API verbiage expects a 'ToJSON'able blob.
585+ Indexes have mappings, mappings are schemas for the documents contained
586+ in the index. I'd recommend having only one mapping per index, always
587+ having a mapping, and keeping different kinds of documents separated
591+ Mapping { typeName :: TypeName
592+ , mappingFields :: [MappingField] }
595+data AllocationPolicy = AllocAll
596+ -- ^ Allows shard allocation for all shards.
598+ -- ^ Allows shard allocation only for primary shards.
600+ -- ^ Allows shard allocation only for primary shards for new indices.
602+ -- ^ No shard allocation is allowed
605+instance ToJSON AllocationPolicy where
606+ toJSON AllocAll = String "all"
607+ toJSON AllocPrimaries = String "primaries"
608+ toJSON AllocNewPrimaries = String "new_primaries"
609+ toJSON AllocNone = String "none"
611+instance FromJSON AllocationPolicy where
612+ parseJSON = withText "AllocationPolicy" parse
613+ where parse "all" = pure AllocAll
614+ parse "primaries" = pure AllocPrimaries
615+ parse "new_primaries" = pure AllocNewPrimaries
616+ parse "none" = pure AllocNone
617+ parse t = fail ("Invlaid AllocationPolicy: " <> show t)
619+{-| 'BulkOperation' is a sum type for expressing the four kinds of bulk
620+ operation index, create, delete, and update. 'BulkIndex' behaves like an
621+ "upsert", 'BulkCreate' will fail if a document already exists at the DocId.
622+ Consult the <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html#docs-bulk Bulk API documentation>
623+ for further explanation.
624+ Warning: Bulk operations suffixed with @Auto@ rely on Elasticsearch to
625+ generate the id. Often, people use auto-generated identifiers when
626+ Elasticsearch is the only place that their data is stored. Do not let
627+ Elasticsearch be the only place your data is stored. It does not guarantee
628+ durability, and it may silently discard data.
629+ This <https://github.com/elastic/elasticsearch/issues/10708 issue> is
630+ discussed further on github.
633+ BulkIndex IndexName MappingName DocId Value
634+ -- ^ Create the document, replacing it if it already exists.
635+ | BulkIndexAuto IndexName MappingName Value
636+ -- ^ Create a document with an autogenerated id.
637+ | BulkIndexEncodingAuto IndexName MappingName Encoding
638+ -- ^ Create a document with an autogenerated id. Use fast JSON encoding.
639+ | BulkCreate IndexName MappingName DocId Value
640+ -- ^ Create a document, failing if it already exists.
641+ | BulkCreateEncoding IndexName MappingName DocId Encoding
642+ -- ^ Create a document, failing if it already exists. Use fast JSON encoding.
643+ | BulkDelete IndexName MappingName DocId
644+ -- ^ Delete the document
645+ | BulkUpdate IndexName MappingName DocId Value
646+ -- ^ Update the document, merging the new value with the existing one.
649+{-| 'EsResult' describes the standard wrapper JSON document that you see in
650+ successful Elasticsearch lookups or lookups that couldn't find the document.
652+data EsResult a = EsResult { _index :: Text
655+ , foundResult :: Maybe (EsResultFound a)} deriving (Eq, Show)
657+{-| 'EsResultFound' contains the document and its metadata inside of an
658+ 'EsResult' when the document was successfully found.
660+data EsResultFound a =
661+ EsResultFound { _version :: DocVersion
665+instance (FromJSON a) => FromJSON (EsResult a) where
666+ parseJSON jsonVal@(Object v) = do
667+ found <- v .:? "found" .!= False
669+ then parseJSON jsonVal
671+ EsResult <$> v .: "_index" <*>
677+instance (FromJSON a) => FromJSON (EsResultFound a) where
678+ parseJSON (Object v) = EsResultFound <$>
683+{-| 'EsError' is the generic type that will be returned when there was a
684+ problem. If you can't parse the expected response, its a good idea to
688+ EsError { errorStatus :: Int
689+ , errorMessage :: Text }
692+instance FromJSON EsError where
693+ parseJSON (Object v) = EsError <$>
695+ (v .: "error" <|> (v .: "error" >>= (.: "reason")))
698+{-| 'EsProtocolException' will be thrown if Bloodhound cannot parse a response
699+returned by the Elasticsearch server. If you encounter this error, please
700+verify that your domain data types and FromJSON instances are working properly
701+(for example, the 'a' of '[Hit a]' in 'SearchResult.searchHits.hits'). If you're
702+sure that your mappings are correct, then this error may be an indication of an
703+incompatibility between Bloodhound and Elasticsearch. Please open a bug report
704+and be sure to include the exception body.
706+data EsProtocolException = EsProtocolException
707+ { esProtoExMessage :: !Text
708+ , esProtoExBody :: !LByteString
709+ } deriving (Eq, Show)
711+instance Exception EsProtocolException
713+data IndexAlias = IndexAlias { srcIndex :: IndexName
714+ , indexAlias :: IndexAliasName } deriving (Eq, Show)
716+data IndexAliasAction =
717+ AddAlias IndexAlias IndexAliasCreate
718+ | RemoveAlias IndexAlias
721+data IndexAliasCreate =
722+ IndexAliasCreate { aliasCreateRouting :: Maybe AliasRouting
723+ , aliasCreateFilter :: Maybe Filter}
727+ AllAliasRouting RoutingValue
728+ | GranularAliasRouting (Maybe SearchAliasRouting) (Maybe IndexAliasRouting)
731+newtype SearchAliasRouting =
732+ SearchAliasRouting (NonEmpty RoutingValue)
735+instance ToJSON SearchAliasRouting where
736+ toJSON (SearchAliasRouting rvs) = toJSON (T.intercalate "," (routingValue <$> toList rvs))
738+instance FromJSON SearchAliasRouting where
739+ parseJSON = withText "SearchAliasRouting" parse
740+ where parse t = SearchAliasRouting <$> parseNEJSON (String <$> T.splitOn "," t)
742+newtype IndexAliasRouting =
743+ IndexAliasRouting RoutingValue
744+ deriving (Eq, Show, ToJSON, FromJSON)
746+newtype RoutingValue =
747+ RoutingValue { routingValue :: Text }
748+ deriving (Eq, Show, ToJSON, FromJSON)
750+newtype IndexAliasesSummary =
751+ IndexAliasesSummary { indexAliasesSummary :: [IndexAliasSummary] }
754+instance FromJSON IndexAliasesSummary where
755+ parseJSON = withObject "IndexAliasesSummary" parse
756+ where parse o = IndexAliasesSummary . mconcat <$> mapM (uncurry go) (HM.toList o)
757+ go ixn = withObject "index aliases" $ \ia -> do
758+ aliases <- ia .:? "aliases" .!= mempty
759+ forM (HM.toList aliases) $ \(aName, v) -> do
760+ let indexAlias = IndexAlias (IndexName ixn) (IndexAliasName (IndexName aName))
761+ IndexAliasSummary indexAlias <$> parseJSON v
764+instance ToJSON IndexAliasAction where
765+ toJSON (AddAlias ia opts) = object ["add" .= (iaObj <> optsObj)]
766+ where Object iaObj = toJSON ia
767+ Object optsObj = toJSON opts
768+ toJSON (RemoveAlias ia) = object ["remove" .= iaObj]
769+ where Object iaObj = toJSON ia
771+instance ToJSON IndexAlias where
772+ toJSON IndexAlias {..} = object ["index" .= srcIndex
773+ , "alias" .= indexAlias
776+instance ToJSON IndexAliasCreate where
777+ toJSON IndexAliasCreate {..} = Object (filterObj <> routingObj)
778+ where filterObj = maybe mempty (HM.singleton "filter" . toJSON) aliasCreateFilter
779+ Object routingObj = maybe (Object mempty) toJSON aliasCreateRouting
781+instance ToJSON AliasRouting where
782+ toJSON (AllAliasRouting v) = object ["routing" .= v]
783+ toJSON (GranularAliasRouting srch idx) = object (catMaybes prs)
784+ where prs = [("search_routing" .=) <$> srch
785+ ,("index_routing" .=) <$> idx]
787+instance FromJSON AliasRouting where
788+ parseJSON = withObject "AliasRouting" parse
789+ where parse o = parseAll o <|> parseGranular o
790+ parseAll o = AllAliasRouting <$> o .: "routing"
791+ parseGranular o = do
792+ sr <- o .:? "search_routing"
793+ ir <- o .:? "index_routing"
794+ if isNothing sr && isNothing ir
795+ then fail "Both search_routing and index_routing can't be blank"
796+ else return (GranularAliasRouting sr ir)
798+instance FromJSON IndexAliasCreate where
799+ parseJSON v = withObject "IndexAliasCreate" parse v
800+ where parse o = IndexAliasCreate <$> optional (parseJSON v)
803+{-| 'IndexAliasSummary' is a summary of an index alias configured for a server. -}
804+data IndexAliasSummary = IndexAliasSummary
805+ { indexAliasSummaryAlias :: IndexAlias
806+ , indexAliasSummaryCreate :: IndexAliasCreate }
809+{-| 'DocVersion' is an integer version number for a document between 1
810+and 9.2e+18 used for <<https://www.elastic.co/guide/en/elasticsearch/guide/current/optimistic-concurrency-control.html optimistic concurrency control>>.
812+newtype DocVersion = DocVersion {
813+ docVersionNumber :: Int
814+ } deriving (Eq, Show, Ord, ToJSON)
816+-- | Smart constructor for in-range doc version
817+mkDocVersion :: Int -> Maybe DocVersion
819+ | i >= docVersionNumber minBound
820+ && i <= docVersionNumber maxBound =
822+ | otherwise = Nothing
824+instance Bounded DocVersion where
825+ minBound = DocVersion 1
826+ maxBound = DocVersion 9200000000000000000 -- 9.2e+18
828+instance Enum DocVersion where
830+ | x /= maxBound = DocVersion (succ $ docVersionNumber x)
831+ | otherwise = succError "DocVersion"
833+ | x /= minBound = DocVersion (pred $ docVersionNumber x)
834+ | otherwise = predError "DocVersion"
836+ fromMaybe (error $ show i ++ " out of DocVersion range") $ mkDocVersion i
837+ fromEnum = docVersionNumber
838+ enumFrom = boundedEnumFrom
839+ enumFromThen = boundedEnumFromThen
841+instance FromJSON DocVersion where
844+ maybe (fail "DocVersion out of range") return $ mkDocVersion i
846+{-| 'ExternalDocVersion' is a convenience wrapper if your code uses its
847+own version numbers instead of ones from ES.
849+newtype ExternalDocVersion = ExternalDocVersion DocVersion
850+ deriving (Eq, Show, Ord, Bounded, Enum, ToJSON)
852+{-| 'VersionControl' is specified when indexing documents as a
853+optimistic concurrency control.
855+data VersionControl = NoVersionControl
856+ -- ^ Don't send a version. This is a pure overwrite.
857+ | InternalVersion DocVersion
858+ -- ^ Use the default ES versioning scheme. Only
859+ -- index the document if the version is the same
860+ -- as the one specified. Only applicable to
861+ -- updates, as you should be getting Version from
863+ | ExternalGT ExternalDocVersion
864+ -- ^ Use your own version numbering. Only index
865+ -- the document if the version is strictly higher
866+ -- OR the document doesn't exist. The given
867+ -- version will be used as the new version number
868+ -- for the stored document. N.B. All updates must
869+ -- increment this number, meaning there is some
870+ -- global, external ordering of updates.
871+ | ExternalGTE ExternalDocVersion
872+ -- ^ Use your own version numbering. Only index
873+ -- the document if the version is equal or higher
874+ -- than the stored version. Will succeed if there
875+ -- is no existing document. The given version will
876+ -- be used as the new version number for the
877+ -- stored document. Use with care, as this could
878+ -- result in data loss.
879+ | ForceVersion ExternalDocVersion
880+ -- ^ The document will always be indexed and the
881+ -- given version will be the new version. This is
882+ -- typically used for correcting errors. Use with
883+ -- care, as this could result in data loss.
884+ deriving (Eq, Show, Ord)
886+{-| 'DocumentParent' is used to specify a parent document.
888+newtype DocumentParent = DocumentParent DocId
891+{-| 'IndexDocumentSettings' are special settings supplied when indexing
892+a document. For the best backwards compatiblity when new fields are
893+added, you should probably prefer to start with 'defaultIndexDocumentSettings'
895+data IndexDocumentSettings =
896+ IndexDocumentSettings { idsVersionControl :: VersionControl
897+ , idsParent :: Maybe DocumentParent
898+ } deriving (Eq, Show)
900+{-| Reasonable default settings. Chooses no version control and no parent.
902+defaultIndexDocumentSettings :: IndexDocumentSettings
903+defaultIndexDocumentSettings = IndexDocumentSettings NoVersionControl Nothing
905+{-| 'IndexSelection' is used for APIs which take a single index, a list of
906+ indexes, or the special @_all@ index.
908+--TODO: this does not fully support <https://www.elastic.co/guide/en/elasticsearch/reference/1.7/multi-index.html multi-index syntax>. It wouldn't be too hard to implement but you'd have to add the optional parameters (ignore_unavailable, allow_no_indices, expand_wildcards) to any APIs using it. Also would be a breaking API.
909+data IndexSelection =
910+ IndexList (NonEmpty IndexName)
914+{-| 'NodeSelection' is used for most cluster APIs. See <https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster.html#cluster-nodes here> for more details.
918+ -- ^ Whatever node receives this request
919+ | NodeList (NonEmpty NodeSelector)
924+-- | An exact match or pattern to identify a node. Note that All of
925+-- these options support wildcarding, so your node name, server, attr
926+-- name can all contain * characters to be a fuzzy match.
929+ | NodeByFullNodeId FullNodeId
931+ -- ^ e.g. 10.0.0.1 or even 10.0.0.*
932+ | NodeByAttribute NodeAttrName Text
933+ -- ^ NodeAttrName can be a pattern, e.g. rack*. The value can too.
936+{-| 'TemplateName' is used to describe which template to query/create/delete
938+newtype TemplateName = TemplateName Text deriving (Eq, Show, ToJSON, FromJSON)
940+{-| 'TemplatePattern' represents a pattern which is matched against index names
942+newtype TemplatePattern = TemplatePattern Text deriving (Eq, Show, ToJSON, FromJSON)
944+-- | Username type used for HTTP Basic authentication. See 'basicAuthHook'.
945+newtype EsUsername = EsUsername { esUsername :: Text } deriving (Read, Show, Eq)
947+-- | Password type used for HTTP Basic authentication. See 'basicAuthHook'.
948+newtype EsPassword = EsPassword { esPassword :: Text } deriving (Read, Show, Eq)
951+data SnapshotRepoSelection =
952+ SnapshotRepoList (NonEmpty SnapshotRepoPattern)
957+-- | Either specifies an exact repo name or one with globs in it,
958+-- e.g. @RepoPattern "foo*"@ __NOTE__: Patterns are not supported on ES < 1.7
959+data SnapshotRepoPattern =
960+ ExactRepo SnapshotRepoName
964+-- | The unique name of a snapshot repository.
965+newtype SnapshotRepoName =
966+ SnapshotRepoName { snapshotRepoName :: Text }
967+ deriving (Eq, Ord, Show, ToJSON, FromJSON)
970+-- | A generic representation of a snapshot repo. This is what gets
971+-- sent to and parsed from the server. For repo types enabled by
972+-- plugins that aren't exported by this library, consider making a
973+-- custom type which implements 'SnapshotRepo'. If it is a common repo
974+-- type, consider submitting a pull request to have it included in the
976+data GenericSnapshotRepo = GenericSnapshotRepo {
977+ gSnapshotRepoName :: SnapshotRepoName
978+ , gSnapshotRepoType :: SnapshotRepoType
979+ , gSnapshotRepoSettings :: GenericSnapshotRepoSettings
980+ } deriving (Eq, Show)
983+instance SnapshotRepo GenericSnapshotRepo where
984+ toGSnapshotRepo = id
985+ fromGSnapshotRepo = Right
988+newtype SnapshotRepoType =
989+ SnapshotRepoType { snapshotRepoType :: Text }
990+ deriving (Eq, Ord, Show, ToJSON, FromJSON)
993+-- | Opaque representation of snapshot repo settings. Instances of
994+-- 'SnapshotRepo' will produce this.
995+newtype GenericSnapshotRepoSettings =
996+ GenericSnapshotRepoSettings { gSnapshotRepoSettingsObject :: Object }
997+ deriving (Eq, Show, ToJSON)
1000+ -- Regardless of whether you send strongly typed json, my version of
1001+ -- ES sends back stringly typed json in the settings, e.g. booleans
1002+ -- as strings, so we'll try to convert them.
1003+instance FromJSON GenericSnapshotRepoSettings where
1004+ parseJSON = fmap (GenericSnapshotRepoSettings . fmap unStringlyTypeJSON). parseJSON
1006+-- | The result of running 'verifySnapshotRepo'.
1007+newtype SnapshotVerification =
1008+ SnapshotVerification {
1009+ snapshotNodeVerifications :: [SnapshotNodeVerification]
1010+ } deriving (Eq, Show)
1013+instance FromJSON SnapshotVerification where
1014+ parseJSON = withObject "SnapshotVerification" parse
1018+ SnapshotVerification <$> mapM (uncurry parse') (HM.toList o2)
1019+ parse' rawFullId = withObject "SnapshotNodeVerification" $ \o ->
1020+ SnapshotNodeVerification (FullNodeId rawFullId) <$> o .: "name"
1023+-- | A node that has verified a snapshot
1024+data SnapshotNodeVerification = SnapshotNodeVerification {
1025+ snvFullId :: FullNodeId
1026+ , snvNodeName :: NodeName
1027+ } deriving (Eq, Show)
1030+-- | Unique, automatically-generated name assigned to nodes that are
1031+-- usually returned in node-oriented APIs.
1032+newtype FullNodeId = FullNodeId { fullNodeId :: Text }
1033+ deriving (Eq, Ord, Show, FromJSON)
1036+-- | A human-readable node name that is supplied by the user in the
1037+-- node config or automatically generated by Elasticsearch.
1038+newtype NodeName = NodeName { nodeName :: Text }
1039+ deriving (Eq, Ord, Show, FromJSON)
1041+newtype ClusterName = ClusterName { clusterName :: Text }
1042+ deriving (Eq, Ord, Show, FromJSON)
1044+data NodesInfo = NodesInfo {
1045+ nodesInfo :: [NodeInfo]
1046+ , nodesClusterName :: ClusterName
1047+ } deriving (Eq, Show)
1049+data NodesStats = NodesStats {
1050+ nodesStats :: [NodeStats]
1051+ , nodesStatsClusterName :: ClusterName
1052+ } deriving (Eq, Show)
1054+data NodeStats = NodeStats {
1055+ nodeStatsName :: NodeName
1056+ , nodeStatsFullId :: FullNodeId
1057+ , nodeStatsBreakersStats :: Maybe NodeBreakersStats
1058+ , nodeStatsHTTP :: NodeHTTPStats
1059+ , nodeStatsTransport :: NodeTransportStats
1060+ , nodeStatsFS :: NodeFSStats
1061+ , nodeStatsNetwork :: Maybe NodeNetworkStats
1062+ , nodeStatsThreadPool :: NodeThreadPoolsStats
1063+ , nodeStatsJVM :: NodeJVMStats
1064+ , nodeStatsProcess :: NodeProcessStats
1065+ , nodeStatsOS :: NodeOSStats
1066+ , nodeStatsIndices :: NodeIndicesStats
1067+ } deriving (Eq, Show)
1069+data NodeBreakersStats = NodeBreakersStats {
1070+ nodeStatsParentBreaker :: NodeBreakerStats
1071+ , nodeStatsRequestBreaker :: NodeBreakerStats
1072+ , nodeStatsFieldDataBreaker :: NodeBreakerStats
1073+ } deriving (Eq, Show)
1075+data NodeBreakerStats = NodeBreakerStats {
1076+ nodeBreakersTripped :: Int
1077+ , nodeBreakersOverhead :: Double
1078+ , nodeBreakersEstSize :: Bytes
1079+ , nodeBreakersLimitSize :: Bytes
1080+ } deriving (Eq, Show)
1082+data NodeHTTPStats = NodeHTTPStats {
1083+ nodeHTTPTotalOpened :: Int
1084+ , nodeHTTPCurrentOpen :: Int
1085+ } deriving (Eq, Show)
1087+data NodeTransportStats = NodeTransportStats {
1088+ nodeTransportTXSize :: Bytes
1089+ , nodeTransportCount :: Int
1090+ , nodeTransportRXSize :: Bytes
1091+ , nodeTransportRXCount :: Int
1092+ , nodeTransportServerOpen :: Int
1093+ } deriving (Eq, Show)
1095+data NodeFSStats = NodeFSStats {
1096+ nodeFSDataPaths :: [NodeDataPathStats]
1097+ , nodeFSTotal :: NodeFSTotalStats
1098+ , nodeFSTimestamp :: UTCTime
1099+ } deriving (Eq, Show)
1101+data NodeDataPathStats = NodeDataPathStats {
1102+ nodeDataPathDiskServiceTime :: Maybe Double
1103+ , nodeDataPathDiskQueue :: Maybe Double
1104+ , nodeDataPathIOSize :: Maybe Bytes
1105+ , nodeDataPathWriteSize :: Maybe Bytes
1106+ , nodeDataPathReadSize :: Maybe Bytes
1107+ , nodeDataPathIOOps :: Maybe Int
1108+ , nodeDataPathWrites :: Maybe Int
1109+ , nodeDataPathReads :: Maybe Int
1110+ , nodeDataPathAvailable :: Bytes
1111+ , nodeDataPathFree :: Bytes
1112+ , nodeDataPathTotal :: Bytes
1113+ , nodeDataPathType :: Maybe Text
1114+ , nodeDataPathDevice :: Maybe Text
1115+ , nodeDataPathMount :: Text
1116+ , nodeDataPathPath :: Text
1117+ } deriving (Eq, Show)
1119+data NodeFSTotalStats = NodeFSTotalStats {
1120+ nodeFSTotalDiskServiceTime :: Maybe Double
1121+ , nodeFSTotalDiskQueue :: Maybe Double
1122+ , nodeFSTotalIOSize :: Maybe Bytes
1123+ , nodeFSTotalWriteSize :: Maybe Bytes
1124+ , nodeFSTotalReadSize :: Maybe Bytes
1125+ , nodeFSTotalIOOps :: Maybe Int
1126+ , nodeFSTotalWrites :: Maybe Int
1127+ , nodeFSTotalReads :: Maybe Int
1128+ , nodeFSTotalAvailable :: Bytes
1129+ , nodeFSTotalFree :: Bytes
1130+ , nodeFSTotalTotal :: Bytes
1131+ } deriving (Eq, Show)
1133+data NodeNetworkStats = NodeNetworkStats {
1134+ nodeNetTCPOutRSTs :: Int
1135+ , nodeNetTCPInErrs :: Int
1136+ , nodeNetTCPAttemptFails :: Int
1137+ , nodeNetTCPEstabResets :: Int
1138+ , nodeNetTCPRetransSegs :: Int
1139+ , nodeNetTCPOutSegs :: Int
1140+ , nodeNetTCPInSegs :: Int
1141+ , nodeNetTCPCurrEstab :: Int
1142+ , nodeNetTCPPassiveOpens :: Int
1143+ , nodeNetTCPActiveOpens :: Int
1144+ } deriving (Eq, Show)
1146+data NodeThreadPoolsStats = NodeThreadPoolsStats {
1147+ nodeThreadPoolsStatsSnapshot :: NodeThreadPoolStats
1148+ , nodeThreadPoolsStatsBulk :: NodeThreadPoolStats
1149+ , nodeThreadPoolsStatsMerge :: NodeThreadPoolStats
1150+ , nodeThreadPoolsStatsGet :: NodeThreadPoolStats
1151+ , nodeThreadPoolsStatsManagement :: NodeThreadPoolStats
1152+ , nodeThreadPoolsStatsFetchShardStore :: Maybe NodeThreadPoolStats
1153+ , nodeThreadPoolsStatsOptimize :: Maybe NodeThreadPoolStats
1154+ , nodeThreadPoolsStatsFlush :: NodeThreadPoolStats
1155+ , nodeThreadPoolsStatsSearch :: NodeThreadPoolStats
1156+ , nodeThreadPoolsStatsWarmer :: NodeThreadPoolStats
1157+ , nodeThreadPoolsStatsGeneric :: NodeThreadPoolStats
1158+ , nodeThreadPoolsStatsSuggest :: Maybe NodeThreadPoolStats
1159+ , nodeThreadPoolsStatsRefresh :: NodeThreadPoolStats
1160+ , nodeThreadPoolsStatsIndex :: NodeThreadPoolStats
1161+ , nodeThreadPoolsStatsListener :: Maybe NodeThreadPoolStats
1162+ , nodeThreadPoolsStatsFetchShardStarted :: Maybe NodeThreadPoolStats
1163+ , nodeThreadPoolsStatsPercolate :: Maybe NodeThreadPoolStats
1164+ } deriving (Eq, Show)
1166+data NodeThreadPoolStats = NodeThreadPoolStats {
1167+ nodeThreadPoolCompleted :: Int
1168+ , nodeThreadPoolLargest :: Int
1169+ , nodeThreadPoolRejected :: Int
1170+ , nodeThreadPoolActive :: Int
1171+ , nodeThreadPoolQueue :: Int
1172+ , nodeThreadPoolThreads :: Int
1173+ } deriving (Eq, Show)
1175+data NodeJVMStats = NodeJVMStats {
1176+ nodeJVMStatsMappedBufferPool :: JVMBufferPoolStats
1177+ , nodeJVMStatsDirectBufferPool :: JVMBufferPoolStats
1178+ , nodeJVMStatsGCOldCollector :: JVMGCStats
1179+ , nodeJVMStatsGCYoungCollector :: JVMGCStats
1180+ , nodeJVMStatsPeakThreadsCount :: Int
1181+ , nodeJVMStatsThreadsCount :: Int
1182+ , nodeJVMStatsOldPool :: JVMPoolStats
1183+ , nodeJVMStatsSurvivorPool :: JVMPoolStats
1184+ , nodeJVMStatsYoungPool :: JVMPoolStats
1185+ , nodeJVMStatsNonHeapCommitted :: Bytes
1186+ , nodeJVMStatsNonHeapUsed :: Bytes
1187+ , nodeJVMStatsHeapMax :: Bytes
1188+ , nodeJVMStatsHeapCommitted :: Bytes
1189+ , nodeJVMStatsHeapUsedPercent :: Int
1190+ , nodeJVMStatsHeapUsed :: Bytes
1191+ , nodeJVMStatsUptime :: NominalDiffTime
1192+ , nodeJVMStatsTimestamp :: UTCTime
1193+ } deriving (Eq, Show)
1195+data JVMBufferPoolStats = JVMBufferPoolStats {
1196+ jvmBufferPoolStatsTotalCapacity :: Bytes
1197+ , jvmBufferPoolStatsUsed :: Bytes
1198+ , jvmBufferPoolStatsCount :: Int
1199+ } deriving (Eq, Show)
1201+data JVMGCStats = JVMGCStats {
1202+ jvmGCStatsCollectionTime :: NominalDiffTime
1203+ , jvmGCStatsCollectionCount :: Int
1204+ } deriving (Eq, Show)
1206+data JVMPoolStats = JVMPoolStats {
1207+ jvmPoolStatsPeakMax :: Bytes
1208+ , jvmPoolStatsPeakUsed :: Bytes
1209+ , jvmPoolStatsMax :: Bytes
1210+ , jvmPoolStatsUsed :: Bytes
1211+ } deriving (Eq, Show)
1213+data NodeProcessStats = NodeProcessStats {
1214+ nodeProcessTimestamp :: UTCTime
1215+ , nodeProcessOpenFDs :: Int
1216+ , nodeProcessMaxFDs :: Int
1217+ , nodeProcessCPUPercent :: Int
1218+ , nodeProcessCPUTotal :: NominalDiffTime
1219+ , nodeProcessMemTotalVirtual :: Bytes
1220+ } deriving (Eq, Show)
1222+data NodeOSStats = NodeOSStats {
1223+ nodeOSTimestamp :: UTCTime
1224+ , nodeOSCPUPercent :: Int
1225+ , nodeOSLoad :: Maybe LoadAvgs
1226+ , nodeOSMemTotal :: Bytes
1227+ , nodeOSMemFree :: Bytes
1228+ , nodeOSMemFreePercent :: Int
1229+ , nodeOSMemUsed :: Bytes
1230+ , nodeOSMemUsedPercent :: Int
1231+ , nodeOSSwapTotal :: Bytes
1232+ , nodeOSSwapFree :: Bytes
1233+ , nodeOSSwapUsed :: Bytes
1234+ } deriving (Eq, Show)
1236+data LoadAvgs = LoadAvgs {
1237+ loadAvg1Min :: Double
1238+ , loadAvg5Min :: Double
1239+ , loadAvg15Min :: Double
1240+ } deriving (Eq, Show)
1242+data NodeIndicesStats = NodeIndicesStats {
1243+ nodeIndicesStatsRecoveryThrottleTime :: Maybe NominalDiffTime
1244+ , nodeIndicesStatsRecoveryCurrentAsTarget :: Maybe Int
1245+ , nodeIndicesStatsRecoveryCurrentAsSource :: Maybe Int
1246+ , nodeIndicesStatsQueryCacheMisses :: Maybe Int
1247+ , nodeIndicesStatsQueryCacheHits :: Maybe Int
1248+ , nodeIndicesStatsQueryCacheEvictions :: Maybe Int
1249+ , nodeIndicesStatsQueryCacheSize :: Maybe Bytes
1250+ , nodeIndicesStatsSuggestCurrent :: Maybe Int
1251+ , nodeIndicesStatsSuggestTime :: Maybe NominalDiffTime
1252+ , nodeIndicesStatsSuggestTotal :: Maybe Int
1253+ , nodeIndicesStatsTranslogSize :: Bytes
1254+ , nodeIndicesStatsTranslogOps :: Int
1255+ , nodeIndicesStatsSegFixedBitSetMemory :: Maybe Bytes
1256+ , nodeIndicesStatsSegVersionMapMemory :: Bytes
1257+ , nodeIndicesStatsSegIndexWriterMaxMemory :: Maybe Bytes
1258+ , nodeIndicesStatsSegIndexWriterMemory :: Bytes
1259+ , nodeIndicesStatsSegMemory :: Bytes
1260+ , nodeIndicesStatsSegCount :: Int
1261+ , nodeIndicesStatsCompletionSize :: Bytes
1262+ , nodeIndicesStatsPercolateQueries :: Maybe Int
1263+ , nodeIndicesStatsPercolateMemory :: Maybe Bytes
1264+ , nodeIndicesStatsPercolateCurrent :: Maybe Int
1265+ , nodeIndicesStatsPercolateTime :: Maybe NominalDiffTime
1266+ , nodeIndicesStatsPercolateTotal :: Maybe Int
1267+ , nodeIndicesStatsFieldDataEvictions :: Int
1268+ , nodeIndicesStatsFieldDataMemory :: Bytes
1269+ , nodeIndicesStatsWarmerTotalTime :: NominalDiffTime
1270+ , nodeIndicesStatsWarmerTotal :: Int
1271+ , nodeIndicesStatsWarmerCurrent :: Int
1272+ , nodeIndicesStatsFlushTotalTime :: NominalDiffTime
1273+ , nodeIndicesStatsFlushTotal :: Int
1274+ , nodeIndicesStatsRefreshTotalTime :: NominalDiffTime
1275+ , nodeIndicesStatsRefreshTotal :: Int
1276+ , nodeIndicesStatsMergesTotalSize :: Bytes
1277+ , nodeIndicesStatsMergesTotalDocs :: Int
1278+ , nodeIndicesStatsMergesTotalTime :: NominalDiffTime
1279+ , nodeIndicesStatsMergesTotal :: Int
1280+ , nodeIndicesStatsMergesCurrentSize :: Bytes
1281+ , nodeIndicesStatsMergesCurrentDocs :: Int
1282+ , nodeIndicesStatsMergesCurrent :: Int
1283+ , nodeIndicesStatsSearchFetchCurrent :: Int
1284+ , nodeIndicesStatsSearchFetchTime :: NominalDiffTime
1285+ , nodeIndicesStatsSearchFetchTotal :: Int
1286+ , nodeIndicesStatsSearchQueryCurrent :: Int
1287+ , nodeIndicesStatsSearchQueryTime :: NominalDiffTime
1288+ , nodeIndicesStatsSearchQueryTotal :: Int
1289+ , nodeIndicesStatsSearchOpenContexts :: Int
1290+ , nodeIndicesStatsGetCurrent :: Int
1291+ , nodeIndicesStatsGetMissingTime :: NominalDiffTime
1292+ , nodeIndicesStatsGetMissingTotal :: Int
1293+ , nodeIndicesStatsGetExistsTime :: NominalDiffTime
1294+ , nodeIndicesStatsGetExistsTotal :: Int
1295+ , nodeIndicesStatsGetTime :: NominalDiffTime
1296+ , nodeIndicesStatsGetTotal :: Int
1297+ , nodeIndicesStatsIndexingThrottleTime :: Maybe NominalDiffTime
1298+ , nodeIndicesStatsIndexingIsThrottled :: Maybe Bool
1299+ , nodeIndicesStatsIndexingNoopUpdateTotal :: Maybe Int
1300+ , nodeIndicesStatsIndexingDeleteCurrent :: Int
1301+ , nodeIndicesStatsIndexingDeleteTime :: NominalDiffTime
1302+ , nodeIndicesStatsIndexingDeleteTotal :: Int
1303+ , nodeIndicesStatsIndexingIndexCurrent :: Int
1304+ , nodeIndicesStatsIndexingIndexTime :: NominalDiffTime
1305+ , nodeIndicesStatsIndexingTotal :: Int
1306+ , nodeIndicesStatsStoreThrottleTime :: NominalDiffTime
1307+ , nodeIndicesStatsStoreSize :: Bytes
1308+ , nodeIndicesStatsDocsDeleted :: Int
1309+ , nodeIndicesStatsDocsCount :: Int
1310+ } deriving (Eq, Show)
1312+-- | A quirky address format used throughout Elasticsearch. An example
1313+-- would be inet[/1.1.1.1:9200]. inet may be a placeholder for a
1314+-- <https://en.wikipedia.org/wiki/Fully_qualified_domain_name FQDN>.
1315+newtype EsAddress = EsAddress { esAddress :: Text }
1316+ deriving (Eq, Ord, Show, FromJSON)
1318+-- | Typically a 7 character hex string.
1319+newtype BuildHash = BuildHash { buildHash :: Text }
1320+ deriving (Eq, Ord, Show, FromJSON, ToJSON)
1322+newtype PluginName = PluginName { pluginName :: Text }
1323+ deriving (Eq, Ord, Show, FromJSON)
1325+data NodeInfo = NodeInfo {
1326+ nodeInfoHTTPAddress :: Maybe EsAddress
1327+ , nodeInfoBuild :: BuildHash
1328+ , nodeInfoESVersion :: VersionNumber
1329+ , nodeInfoIP :: Server
1330+ , nodeInfoHost :: Server
1331+ , nodeInfoTransportAddress :: EsAddress
1332+ , nodeInfoName :: NodeName
1333+ , nodeInfoFullId :: FullNodeId
1334+ , nodeInfoPlugins :: [NodePluginInfo]
1335+ , nodeInfoHTTP :: NodeHTTPInfo
1336+ , nodeInfoTransport :: NodeTransportInfo
1337+ , nodeInfoNetwork :: Maybe NodeNetworkInfo
1338+ , nodeInfoThreadPool :: NodeThreadPoolsInfo
1339+ , nodeInfoJVM :: NodeJVMInfo
1340+ , nodeInfoProcess :: NodeProcessInfo
1341+ , nodeInfoOS :: NodeOSInfo
1342+ , nodeInfoSettings :: Object
1343+ -- ^ The members of the settings objects are not consistent,
1344+ -- dependent on plugins, etc.
1345+ } deriving (Eq, Show)
1347+data NodePluginInfo = NodePluginInfo {
1348+ nodePluginSite :: Maybe Bool
1349+ -- ^ Is this a site plugin?
1350+ , nodePluginJVM :: Maybe Bool
1351+ -- ^ Is this plugin running on the JVM
1352+ , nodePluginDescription :: Text
1353+ , nodePluginVersion :: MaybeNA VersionNumber
1354+ , nodePluginName :: PluginName
1355+ } deriving (Eq, Show)
1357+data NodeHTTPInfo = NodeHTTPInfo {
1358+ nodeHTTPMaxContentLength :: Bytes
1359+ , nodeHTTPTransportAddress :: BoundTransportAddress
1360+ } deriving (Eq, Show)
1362+data NodeTransportInfo = NodeTransportInfo {
1363+ nodeTransportProfiles :: [BoundTransportAddress]
1364+ , nodeTransportAddress :: BoundTransportAddress
1365+ } deriving (Eq, Show)
1367+data BoundTransportAddress = BoundTransportAddress {
1368+ publishAddress :: EsAddress
1369+ , boundAddress :: [EsAddress]
1370+ } deriving (Eq, Show)
1372+data NodeNetworkInfo = NodeNetworkInfo {
1373+ nodeNetworkPrimaryInterface :: NodeNetworkInterface
1374+ , nodeNetworkRefreshInterval :: NominalDiffTime
1375+ } deriving (Eq, Show)
1377+newtype MacAddress = MacAddress { macAddress :: Text }
1378+ deriving (Eq, Ord, Show, FromJSON)
1380+newtype NetworkInterfaceName = NetworkInterfaceName { networkInterfaceName :: Text }
1381+ deriving (Eq, Ord, Show, FromJSON)
1383+data NodeNetworkInterface = NodeNetworkInterface {
1384+ nodeNetIfaceMacAddress :: MacAddress
1385+ , nodeNetIfaceName :: NetworkInterfaceName
1386+ , nodeNetIfaceAddress :: Server
1387+ } deriving (Eq, Show)
1389+data NodeThreadPoolsInfo = NodeThreadPoolsInfo {
1390+ nodeThreadPoolsRefresh :: NodeThreadPoolInfo
1391+ , nodeThreadPoolsManagement :: NodeThreadPoolInfo
1392+ , nodeThreadPoolsPercolate :: Maybe NodeThreadPoolInfo
1393+ , nodeThreadPoolsListener :: Maybe NodeThreadPoolInfo
1394+ , nodeThreadPoolsFetchShardStarted :: Maybe NodeThreadPoolInfo
1395+ , nodeThreadPoolsSearch :: NodeThreadPoolInfo
1396+ , nodeThreadPoolsFlush :: NodeThreadPoolInfo
1397+ , nodeThreadPoolsWarmer :: NodeThreadPoolInfo
1398+ , nodeThreadPoolsOptimize :: Maybe NodeThreadPoolInfo
1399+ , nodeThreadPoolsBulk :: NodeThreadPoolInfo
1400+ , nodeThreadPoolsSuggest :: Maybe NodeThreadPoolInfo
1401+ , nodeThreadPoolsMerge :: NodeThreadPoolInfo
1402+ , nodeThreadPoolsSnapshot :: NodeThreadPoolInfo
1403+ , nodeThreadPoolsGet :: NodeThreadPoolInfo
1404+ , nodeThreadPoolsFetchShardStore :: Maybe NodeThreadPoolInfo
1405+ , nodeThreadPoolsIndex :: NodeThreadPoolInfo
1406+ , nodeThreadPoolsGeneric :: NodeThreadPoolInfo
1407+ } deriving (Eq, Show)
1409+data NodeThreadPoolInfo = NodeThreadPoolInfo {
1410+ nodeThreadPoolQueueSize :: ThreadPoolSize
1411+ , nodeThreadPoolKeepalive :: Maybe NominalDiffTime
1412+ , nodeThreadPoolMin :: Maybe Int
1413+ , nodeThreadPoolMax :: Maybe Int
1414+ , nodeThreadPoolType :: ThreadPoolType
1415+ } deriving (Eq, Show)
1417+data ThreadPoolSize = ThreadPoolBounded Int
1418+ | ThreadPoolUnbounded
1419+ deriving (Eq, Show)
1421+data ThreadPoolType = ThreadPoolScaling
1424+ deriving (Eq, Show)
1426+data NodeJVMInfo = NodeJVMInfo {
1427+ nodeJVMInfoMemoryPools :: [JVMMemoryPool]
1428+ , nodeJVMInfoMemoryPoolsGCCollectors :: [JVMGCCollector]
1429+ , nodeJVMInfoMemoryInfo :: JVMMemoryInfo
1430+ , nodeJVMInfoStartTime :: UTCTime
1431+ , nodeJVMInfoVMVendor :: Text
1432+ , nodeJVMVMVersion :: VMVersion
1433+ -- ^ JVM doesn't seme to follow normal version conventions
1434+ , nodeJVMVMName :: Text
1435+ , nodeJVMVersion :: JVMVersion
1436+ , nodeJVMPID :: PID
1437+ } deriving (Eq, Show)
1439+-- | We cannot parse JVM version numbers and we're not going to try.
1440+newtype JVMVersion =
1441+ JVMVersion { unJVMVersion :: Text }
1442+ deriving (Eq, Show)
1444+instance FromJSON JVMVersion where
1445+ parseJSON = withText "JVMVersion" (pure . JVMVersion)
1447+data JVMMemoryInfo = JVMMemoryInfo {
1448+ jvmMemoryInfoDirectMax :: Bytes
1449+ , jvmMemoryInfoNonHeapMax :: Bytes
1450+ , jvmMemoryInfoNonHeapInit :: Bytes
1451+ , jvmMemoryInfoHeapMax :: Bytes
1452+ , jvmMemoryInfoHeapInit :: Bytes
1453+ } deriving (Eq, Show)
1455+-- VM version numbers don't appear to be SemVer
1456+-- so we're special casing this jawn.
1458+ VMVersion { unVMVersion :: Text }
1459+ deriving (Eq, Show)
1461+instance ToJSON VMVersion where
1462+ toJSON = toJSON . unVMVersion
1464+instance FromJSON VMVersion where
1465+ parseJSON = withText "VMVersion" (pure . VMVersion)
1467+newtype JVMMemoryPool = JVMMemoryPool {
1468+ jvmMemoryPool :: Text
1469+ } deriving (Eq, Show, FromJSON)
1471+newtype JVMGCCollector = JVMGCCollector {
1472+ jvmGCCollector :: Text
1473+ } deriving (Eq, Show, FromJSON)
1477+ } deriving (Eq, Show, FromJSON)
1479+data NodeOSInfo = NodeOSInfo {
1480+ nodeOSRefreshInterval :: NominalDiffTime
1481+ , nodeOSName :: Text
1482+ , nodeOSArch :: Text
1483+ , nodeOSVersion :: VersionNumber
1484+ , nodeOSAvailableProcessors :: Int
1485+ , nodeOSAllocatedProcessors :: Int
1486+ } deriving (Eq, Show)
1488+data CPUInfo = CPUInfo {
1489+ cpuCacheSize :: Bytes
1490+ , cpuCoresPerSocket :: Int
1491+ , cpuTotalSockets :: Int
1492+ , cpuTotalCores :: Int
1495+ , cpuVendor :: Text
1496+ } deriving (Eq, Show)
1498+data NodeProcessInfo = NodeProcessInfo {
1499+ nodeProcessMLockAll :: Bool
1500+ -- ^ See <https://www.elastic.co/guide/en/elasticsearch/reference/current/setup-configuration.html>
1501+ , nodeProcessMaxFileDescriptors :: Maybe Int
1502+ , nodeProcessId :: PID
1503+ , nodeProcessRefreshInterval :: NominalDiffTime
1504+ } deriving (Eq, Show)
1507+ ShardResult { shardTotal :: Int
1508+ , shardsSuccessful :: Int
1509+ , shardsFailed :: Int } deriving (Eq, Show)
1511+instance FromJSON ShardResult where
1512+ parseJSON (Object v) = ShardResult <$>
1514+ v .: "successful" <*>
1516+ parseJSON _ = empty
1518+data SnapshotState = SnapshotInit
1525+ deriving (Eq, Show)
1527+instance FromJSON SnapshotState where
1528+ parseJSON = withText "SnapshotState" parse
1530+ parse "INIT" = return SnapshotInit
1531+ parse "STARTED" = return SnapshotStarted
1532+ parse "SUCCESS" = return SnapshotSuccess
1533+ parse "FAILED" = return SnapshotFailed
1534+ parse "ABORTED" = return SnapshotAborted
1535+ parse "MISSING" = return SnapshotMissing
1536+ parse "WAITING" = return SnapshotWaiting
1537+ parse t = fail ("Invalid snapshot state " <> T.unpack t)
1540+data SnapshotRestoreSettings = SnapshotRestoreSettings {
1541+ snapRestoreWaitForCompletion :: Bool
1542+ -- ^ Should the API call return immediately after initializing
1543+ -- the restore or wait until completed? Note that if this is
1544+ -- enabled, it could wait a long time, so you should adjust your
1545+ -- 'ManagerSettings' accordingly to set long timeouts or
1546+ -- explicitly handle timeouts.
1547+ , snapRestoreIndices :: Maybe IndexSelection
1548+ -- ^ Nothing will restore all indices in the snapshot. Just [] is
1549+ -- permissable and will essentially be a no-op restore.
1550+ , snapRestoreIgnoreUnavailable :: Bool
1551+ -- ^ If set to True, any indices that do not exist will be ignored
1552+ -- during snapshot rather than failing the restore.
1553+ , snapRestoreIncludeGlobalState :: Bool
1554+ -- ^ If set to false, will ignore any global state in the snapshot
1555+ -- and will not restore it.
1556+ , snapRestoreRenamePattern :: Maybe RestoreRenamePattern
1557+ -- ^ A regex pattern for matching indices. Used with
1558+ -- 'snapRestoreRenameReplacement', the restore can reference the
1559+ -- matched index and create a new index name upon restore.
1560+ , snapRestoreRenameReplacement :: Maybe (NonEmpty RestoreRenameToken)
1561+ -- ^ Expression of how index renames should be constructed.
1562+ , snapRestorePartial :: Bool
1563+ -- ^ If some indices fail to restore, should the process proceed?
1564+ , snapRestoreIncludeAliases :: Bool
1565+ -- ^ Should the restore also restore the aliases captured in the
1567+ , snapRestoreIndexSettingsOverrides :: Maybe RestoreIndexSettings
1568+ -- ^ Settings to apply during the restore process. __NOTE:__ This
1569+ -- option is not supported in ES < 1.5 and should be set to
1570+ -- Nothing in that case.
1571+ , snapRestoreIgnoreIndexSettings :: Maybe (NonEmpty Text)
1572+ -- ^ This type could be more rich but it isn't clear which
1573+ -- settings are allowed to be ignored during restore, so we're
1574+ -- going with including this feature in a basic form rather than
1575+ -- omitting it. One example here would be
1576+ -- "index.refresh_interval". Any setting specified here will
1577+ -- revert back to the server default during the restore process.
1578+ } deriving (Eq, Show)
1580+newtype SnapshotRepoUpdateSettings = SnapshotRepoUpdateSettings
1581+ { repoUpdateVerify :: Bool
1582+ -- ^ After creation/update, synchronously check that nodes can
1583+ -- write to this repo. Defaults to True. You may use False if you
1584+ -- need a faster response and plan on verifying manually later
1585+ -- with 'verifySnapshotRepo'.
1586+ } deriving (Eq, Show)
1589+-- | Reasonable defaults for repo creation/update
1591+-- * repoUpdateVerify True
1592+defaultSnapshotRepoUpdateSettings :: SnapshotRepoUpdateSettings
1593+defaultSnapshotRepoUpdateSettings = SnapshotRepoUpdateSettings True
1596+-- | A filesystem-based snapshot repo that ships with
1597+-- Elasticsearch. This is an instance of 'SnapshotRepo' so it can be
1598+-- used with 'updateSnapshotRepo'
1599+data FsSnapshotRepo = FsSnapshotRepo {
1600+ fsrName :: SnapshotRepoName
1601+ , fsrLocation :: FilePath
1602+ , fsrCompressMetadata :: Bool
1603+ , fsrChunkSize :: Maybe Bytes
1604+ -- ^ Size by which to split large files during snapshotting.
1605+ , fsrMaxRestoreBytesPerSec :: Maybe Bytes
1606+ -- ^ Throttle node restore rate. If not supplied, defaults to 40mb/sec
1607+ , fsrMaxSnapshotBytesPerSec :: Maybe Bytes
1608+ -- ^ Throttle node snapshot rate. If not supplied, defaults to 40mb/sec
1609+ } deriving (Eq, Show)
1612+instance SnapshotRepo FsSnapshotRepo where
1613+ toGSnapshotRepo FsSnapshotRepo {..} =
1614+ GenericSnapshotRepo fsrName fsRepoType (GenericSnapshotRepoSettings settings)
1616+ Object settings = object $ [ "location" .= fsrLocation
1617+ , "compress" .= fsrCompressMetadata
1619+ optionalPairs = catMaybes [ ("chunk_size" .=) <$> fsrChunkSize
1620+ , ("max_restore_bytes_per_sec" .=) <$> fsrMaxRestoreBytesPerSec
1621+ , ("max_snapshot_bytes_per_sec" .=) <$> fsrMaxSnapshotBytesPerSec
1623+ fromGSnapshotRepo GenericSnapshotRepo {..}
1624+ | gSnapshotRepoType == fsRepoType = do
1625+ let o = gSnapshotRepoSettingsObject gSnapshotRepoSettings
1627+ FsSnapshotRepo gSnapshotRepoName <$> o .: "location"
1628+ <*> o .:? "compress" .!= False
1629+ <*> o .:? "chunk_size"
1630+ <*> o .:? "max_restore_bytes_per_sec"
1631+ <*> o .:? "max_snapshot_bytes_per_sec"
1632+ | otherwise = Left (RepoTypeMismatch fsRepoType gSnapshotRepoType)
1635+parseRepo :: Parser a -> Either SnapshotRepoConversionError a
1636+parseRepo parser = case parseEither (const parser) () of
1637+ Left e -> Left (OtherRepoConversionError (T.pack e))
1641+fsRepoType :: SnapshotRepoType
1642+fsRepoType = SnapshotRepoType "fs"
1644+-- | Law: fromGSnapshotRepo (toGSnapshotRepo r) == Right r
1645+class SnapshotRepo r where
1646+ toGSnapshotRepo :: r -> GenericSnapshotRepo
1647+ fromGSnapshotRepo :: GenericSnapshotRepo -> Either SnapshotRepoConversionError r
1650+data SnapshotRepoConversionError = RepoTypeMismatch SnapshotRepoType SnapshotRepoType
1651+ -- ^ Expected type and actual type
1652+ | OtherRepoConversionError Text
1653+ deriving (Show, Eq)
1656+instance Exception SnapshotRepoConversionError
1659+data SnapshotCreateSettings = SnapshotCreateSettings {
1660+ snapWaitForCompletion :: Bool
1661+ -- ^ Should the API call return immediately after initializing
1662+ -- the snapshot or wait until completed? Note that if this is
1663+ -- enabled it could wait a long time, so you should adjust your
1664+ -- 'ManagerSettings' accordingly to set long timeouts or
1665+ -- explicitly handle timeouts.
1666+ , snapIndices :: Maybe IndexSelection
1667+ -- ^ Nothing will snapshot all indices. Just [] is permissable and
1668+ -- will essentially be a no-op snapshot.
1669+ , snapIgnoreUnavailable :: Bool
1670+ -- ^ If set to True, any matched indices that don't exist will be
1671+ -- ignored. Otherwise it will be an error and fail.
1672+ , snapIncludeGlobalState :: Bool
1673+ , snapPartial :: Bool
1674+ -- ^ If some indices failed to snapshot (e.g. if not all primary
1675+ -- shards are available), should the process proceed?
1676+ } deriving (Eq, Show)
1679+-- | Reasonable defaults for snapshot creation
1681+-- * snapWaitForCompletion False
1682+-- * snapIndices Nothing
1683+-- * snapIgnoreUnavailable False
1684+-- * snapIncludeGlobalState True
1685+-- * snapPartial False
1686+defaultSnapshotCreateSettings :: SnapshotCreateSettings
1687+defaultSnapshotCreateSettings = SnapshotCreateSettings {
1688+ snapWaitForCompletion = False
1689+ , snapIndices = Nothing
1690+ , snapIgnoreUnavailable = False
1691+ , snapIncludeGlobalState = True
1692+ , snapPartial = False
1696+data SnapshotSelection =
1697+ SnapshotList (NonEmpty SnapshotPattern)
1699+ deriving (Eq, Show)
1702+-- | Either specifies an exact snapshot name or one with globs in it,
1703+-- e.g. @SnapPattern "foo*"@ __NOTE__: Patterns are not supported on
1705+data SnapshotPattern =
1706+ ExactSnap SnapshotName
1708+ deriving (Eq, Show)
1711+-- | General information about the state of a snapshot. Has some
1712+-- redundancies with 'SnapshotStatus'
1713+data SnapshotInfo = SnapshotInfo {
1714+ snapInfoShards :: ShardResult
1715+ , snapInfoFailures :: [SnapshotShardFailure]
1716+ , snapInfoDuration :: NominalDiffTime
1717+ , snapInfoEndTime :: UTCTime
1718+ , snapInfoStartTime :: UTCTime
1719+ , snapInfoState :: SnapshotState
1720+ , snapInfoIndices :: [IndexName]
1721+ , snapInfoName :: SnapshotName
1722+ } deriving (Eq, Show)
1725+instance FromJSON SnapshotInfo where
1726+ parseJSON = withObject "SnapshotInfo" parse
1728+ parse o = SnapshotInfo <$> o .: "shards"
1729+ <*> o .: "failures"
1730+ <*> (unMS <$> o .: "duration_in_millis")
1731+ <*> (posixMS <$> o .: "end_time_in_millis")
1732+ <*> (posixMS <$> o .: "start_time_in_millis")
1735+ <*> o .: "snapshot"
1737+data SnapshotShardFailure = SnapshotShardFailure {
1738+ snapShardFailureIndex :: IndexName
1739+ , snapShardFailureNodeId :: Maybe NodeName -- I'm not 100% sure this isn't actually 'FullNodeId'
1740+ , snapShardFailureReason :: Text
1741+ , snapShardFailureShardId :: ShardId
1742+ } deriving (Eq, Show)
1745+instance FromJSON SnapshotShardFailure where
1746+ parseJSON = withObject "SnapshotShardFailure" parse
1748+ parse o = SnapshotShardFailure <$> o .: "index"
1749+ <*> o .:? "node_id"
1751+ <*> o .: "shard_id"
1753+-- | Regex-stype pattern, e.g. "index_(.+)" to match index names
1754+newtype RestoreRenamePattern =
1755+ RestoreRenamePattern { rrPattern :: Text }
1756+ deriving (Eq, Show, Ord, ToJSON)
1759+-- | A single token in a index renaming scheme for a restore. These
1760+-- are concatenated into a string before being sent to
1761+-- Elasticsearch. Check out these Java
1762+-- <https://docs.oracle.com/javase/7/docs/api/java/util/regex/Matcher.html docs> to find out more if you're into that sort of thing.
1763+data RestoreRenameToken = RRTLit Text
1764+ -- ^ Just a literal string of characters
1766+ -- ^ Equivalent to $0. The entire matched pattern, not any subgroup
1767+ | RRSubGroup RRGroupRefNum
1768+ -- ^ A specific reference to a group number
1769+ deriving (Eq, Show)
1772+-- | A group number for regex matching. Only values from 1-9 are
1773+-- supported. Construct with 'mkRRGroupRefNum'
1774+newtype RRGroupRefNum =
1775+ RRGroupRefNum { rrGroupRefNum :: Int }
1776+ deriving (Eq, Ord, Show)
1778+instance Bounded RRGroupRefNum where
1779+ minBound = RRGroupRefNum 1
1780+ maxBound = RRGroupRefNum 9
1783+-- | Only allows valid group number references (1-9).
1784+mkRRGroupRefNum :: Int -> Maybe RRGroupRefNum
1786+ | i >= rrGroupRefNum minBound
1787+ && i <= rrGroupRefNum maxBound =
1788+ Just $ RRGroupRefNum i
1789+ | otherwise = Nothing
1791+-- | Reasonable defaults for snapshot restores
1793+-- * snapRestoreWaitForCompletion False
1794+-- * snapRestoreIndices Nothing
1795+-- * snapRestoreIgnoreUnavailable False
1796+-- * snapRestoreIncludeGlobalState True
1797+-- * snapRestoreRenamePattern Nothing
1798+-- * snapRestoreRenameReplacement Nothing
1799+-- * snapRestorePartial False
1800+-- * snapRestoreIncludeAliases True
1801+-- * snapRestoreIndexSettingsOverrides Nothing
1802+-- * snapRestoreIgnoreIndexSettings Nothing
1803+defaultSnapshotRestoreSettings :: SnapshotRestoreSettings
1804+defaultSnapshotRestoreSettings = SnapshotRestoreSettings {
1805+ snapRestoreWaitForCompletion = False
1806+ , snapRestoreIndices = Nothing
1807+ , snapRestoreIgnoreUnavailable = False
1808+ , snapRestoreIncludeGlobalState = True
1809+ , snapRestoreRenamePattern = Nothing
1810+ , snapRestoreRenameReplacement = Nothing
1811+ , snapRestorePartial = False
1812+ , snapRestoreIncludeAliases = True
1813+ , snapRestoreIndexSettingsOverrides = Nothing
1814+ , snapRestoreIgnoreIndexSettings = Nothing
1818+-- | Index settings that can be overridden. The docs only mention you
1819+-- can update number of replicas, but there may be more. You
1820+-- definitely cannot override shard count.
1821+newtype RestoreIndexSettings = RestoreIndexSettings
1822+ { restoreOverrideReplicas :: Maybe ReplicaCount
1823+ } deriving (Eq, Show)
1826+instance ToJSON RestoreIndexSettings where
1827+ toJSON RestoreIndexSettings {..} = object prs
1829+ prs = catMaybes [("index.number_of_replicas" .=) <$> restoreOverrideReplicas]
1832+instance FromJSON NodesInfo where
1833+ parseJSON = withObject "NodesInfo" parse
1836+ nodes <- o .: "nodes"
1837+ infos <- forM (HM.toList nodes) $ \(fullNID, v) -> do
1838+ node <- parseJSON v
1839+ parseNodeInfo (FullNodeId fullNID) node
1840+ cn <- o .: "cluster_name"
1841+ return (NodesInfo infos cn)
1843+instance FromJSON NodesStats where
1844+ parseJSON = withObject "NodesStats" parse
1847+ nodes <- o .: "nodes"
1848+ stats <- forM (HM.toList nodes) $ \(fullNID, v) -> do
1849+ node <- parseJSON v
1850+ parseNodeStats (FullNodeId fullNID) node
1851+ cn <- o .: "cluster_name"
1852+ return (NodesStats stats cn)
1854+instance FromJSON NodeBreakerStats where
1855+ parseJSON = withObject "NodeBreakerStats" parse
1857+ parse o = NodeBreakerStats <$> o .: "tripped"
1858+ <*> o .: "overhead"
1859+ <*> o .: "estimated_size_in_bytes"
1860+ <*> o .: "limit_size_in_bytes"
1862+instance FromJSON NodeHTTPStats where
1863+ parseJSON = withObject "NodeHTTPStats" parse
1865+ parse o = NodeHTTPStats <$> o .: "total_opened"
1866+ <*> o .: "current_open"
1868+instance FromJSON NodeTransportStats where
1869+ parseJSON = withObject "NodeTransportStats" parse
1871+ parse o = NodeTransportStats <$> o .: "tx_size_in_bytes"
1872+ <*> o .: "tx_count"
1873+ <*> o .: "rx_size_in_bytes"
1874+ <*> o .: "rx_count"
1875+ <*> o .: "server_open"
1877+instance FromJSON NodeFSStats where
1878+ parseJSON = withObject "NodeFSStats" parse
1880+ parse o = NodeFSStats <$> o .: "data"
1882+ <*> (posixMS <$> o .: "timestamp")
1884+instance FromJSON NodeDataPathStats where
1885+ parseJSON = withObject "NodeDataPathStats" parse
1888+ NodeDataPathStats <$> (fmap unStringlyTypedDouble <$> o .:? "disk_service_time")
1889+ <*> (fmap unStringlyTypedDouble <$> o .:? "disk_queue")
1890+ <*> o .:? "disk_io_size_in_bytes"
1891+ <*> o .:? "disk_write_size_in_bytes"
1892+ <*> o .:? "disk_read_size_in_bytes"
1893+ <*> o .:? "disk_io_op"
1894+ <*> o .:? "disk_writes"
1895+ <*> o .:? "disk_reads"
1896+ <*> o .: "available_in_bytes"
1897+ <*> o .: "free_in_bytes"
1898+ <*> o .: "total_in_bytes"
1904+instance FromJSON NodeFSTotalStats where
1905+ parseJSON = withObject "NodeFSTotalStats" parse
1907+ parse o = NodeFSTotalStats <$> (fmap unStringlyTypedDouble <$> o .:? "disk_service_time")
1908+ <*> (fmap unStringlyTypedDouble <$> o .:? "disk_queue")
1909+ <*> o .:? "disk_io_size_in_bytes"
1910+ <*> o .:? "disk_write_size_in_bytes"
1911+ <*> o .:? "disk_read_size_in_bytes"
1912+ <*> o .:? "disk_io_op"
1913+ <*> o .:? "disk_writes"
1914+ <*> o .:? "disk_reads"
1915+ <*> o .: "available_in_bytes"
1916+ <*> o .: "free_in_bytes"
1917+ <*> o .: "total_in_bytes"
1919+instance FromJSON NodeNetworkStats where
1920+ parseJSON = withObject "NodeNetworkStats" parse
1924+ NodeNetworkStats <$> tcp .: "out_rsts"
1925+ <*> tcp .: "in_errs"
1926+ <*> tcp .: "attempt_fails"
1927+ <*> tcp .: "estab_resets"
1928+ <*> tcp .: "retrans_segs"
1929+ <*> tcp .: "out_segs"
1930+ <*> tcp .: "in_segs"
1931+ <*> tcp .: "curr_estab"
1932+ <*> tcp .: "passive_opens"
1933+ <*> tcp .: "active_opens"
1935+instance FromJSON NodeThreadPoolsStats where
1936+ parseJSON = withObject "NodeThreadPoolsStats" parse
1938+ parse o = NodeThreadPoolsStats <$> o .: "snapshot"
1940+ <*> o .: "force_merge"
1942+ <*> o .: "management"
1943+ <*> o .:? "fetch_shard_store"
1944+ <*> o .:? "optimize"
1949+ <*> o .:? "suggest"
1952+ <*> o .:? "listener"
1953+ <*> o .:? "fetch_shard_started"
1954+ <*> o .:? "percolate"
1955+instance FromJSON NodeThreadPoolStats where
1956+ parseJSON = withObject "NodeThreadPoolStats" parse
1958+ parse o = NodeThreadPoolStats <$> o .: "completed"
1960+ <*> o .: "rejected"
1965+instance FromJSON NodeJVMStats where
1966+ parseJSON = withObject "NodeJVMStats" parse
1969+ bufferPools <- o .: "buffer_pools"
1970+ mapped <- bufferPools .: "mapped"
1971+ direct <- bufferPools .: "direct"
1973+ collectors <- gc .: "collectors"
1974+ oldC <- collectors .: "old"
1975+ youngC <- collectors .: "young"
1976+ threads <- o .: "threads"
1978+ pools <- mem .: "pools"
1979+ oldM <- pools .: "old"
1980+ survivorM <- pools .: "survivor"
1981+ youngM <- pools .: "young"
1982+ NodeJVMStats <$> pure mapped
1986+ <*> threads .: "peak_count"
1987+ <*> threads .: "count"
1991+ <*> mem .: "non_heap_committed_in_bytes"
1992+ <*> mem .: "non_heap_used_in_bytes"
1993+ <*> mem .: "heap_max_in_bytes"
1994+ <*> mem .: "heap_committed_in_bytes"
1995+ <*> mem .: "heap_used_percent"
1996+ <*> mem .: "heap_used_in_bytes"
1997+ <*> (unMS <$> o .: "uptime_in_millis")
1998+ <*> (posixMS <$> o .: "timestamp")
2000+instance FromJSON JVMBufferPoolStats where
2001+ parseJSON = withObject "JVMBufferPoolStats" parse
2003+ parse o = JVMBufferPoolStats <$> o .: "total_capacity_in_bytes"
2004+ <*> o .: "used_in_bytes"
2007+instance FromJSON JVMGCStats where
2008+ parseJSON = withObject "JVMGCStats" parse
2010+ parse o = JVMGCStats <$> (unMS <$> o .: "collection_time_in_millis")
2011+ <*> o .: "collection_count"
2013+instance FromJSON JVMPoolStats where
2014+ parseJSON = withObject "JVMPoolStats" parse
2016+ parse o = JVMPoolStats <$> o .: "peak_max_in_bytes"
2017+ <*> o .: "peak_used_in_bytes"
2018+ <*> o .: "max_in_bytes"
2019+ <*> o .: "used_in_bytes"
2021+instance FromJSON NodeProcessStats where
2022+ parseJSON = withObject "NodeProcessStats" parse
2027+ NodeProcessStats <$> (posixMS <$> o .: "timestamp")
2028+ <*> o .: "open_file_descriptors"
2029+ <*> o .: "max_file_descriptors"
2030+ <*> cpu .: "percent"
2031+ <*> (unMS <$> cpu .: "total_in_millis")
2032+ <*> mem .: "total_virtual_in_bytes"
2034+instance FromJSON NodeOSStats where
2035+ parseJSON = withObject "NodeOSStats" parse
2038+ swap <- o .: "swap"
2041+ load <- o .:? "load_average"
2042+ NodeOSStats <$> (posixMS <$> o .: "timestamp")
2043+ <*> cpu .: "percent"
2045+ <*> mem .: "total_in_bytes"
2046+ <*> mem .: "free_in_bytes"
2047+ <*> mem .: "free_percent"
2048+ <*> mem .: "used_in_bytes"
2049+ <*> mem .: "used_percent"
2050+ <*> swap .: "total_in_bytes"
2051+ <*> swap .: "free_in_bytes"
2052+ <*> swap .: "used_in_bytes"
2054+instance FromJSON LoadAvgs where
2055+ parseJSON = withArray "LoadAvgs" parse
2057+ parse v = case V.toList v of
2058+ [one, five, fifteen] -> LoadAvgs <$> parseJSON one
2060+ <*> parseJSON fifteen
2061+ _ -> fail "Expecting a triple of Doubles"
2063+instance FromJSON NodeIndicesStats where
2064+ parseJSON = withObject "NodeIndicesStats" parse
2067+ let (.::) mv k = case mv of
2068+ Just v -> Just <$> v .: k
2069+ Nothing -> pure Nothing
2070+ mRecovery <- o .:? "recovery"
2071+ mQueryCache <- o .:? "query_cache"
2072+ mSuggest <- o .:? "suggest"
2073+ translog <- o .: "translog"
2074+ segments <- o .: "segments"
2075+ completion <- o .: "completion"
2076+ mPercolate <- o .:? "percolate"
2077+ fielddata <- o .: "fielddata"
2078+ warmer <- o .: "warmer"
2079+ flush <- o .: "flush"
2080+ refresh <- o .: "refresh"
2081+ merges <- o .: "merges"
2082+ search <- o .: "search"
2083+ getStats <- o .: "get"
2084+ indexing <- o .: "indexing"
2085+ store <- o .: "store"
2086+ docs <- o .: "docs"
2087+ NodeIndicesStats <$> (fmap unMS <$> mRecovery .:: "throttle_time_in_millis")
2088+ <*> mRecovery .:: "current_as_target"
2089+ <*> mRecovery .:: "current_as_source"
2090+ <*> mQueryCache .:: "miss_count"
2091+ <*> mQueryCache .:: "hit_count"
2092+ <*> mQueryCache .:: "evictions"
2093+ <*> mQueryCache .:: "memory_size_in_bytes"
2094+ <*> mSuggest .:: "current"
2095+ <*> (fmap unMS <$> mSuggest .:: "time_in_millis")
2096+ <*> mSuggest .:: "total"
2097+ <*> translog .: "size_in_bytes"
2098+ <*> translog .: "operations"
2099+ <*> segments .:? "fixed_bit_set_memory_in_bytes"
2100+ <*> segments .: "version_map_memory_in_bytes"
2101+ <*> segments .:? "index_writer_max_memory_in_bytes"
2102+ <*> segments .: "index_writer_memory_in_bytes"
2103+ <*> segments .: "memory_in_bytes"
2104+ <*> segments .: "count"
2105+ <*> completion .: "size_in_bytes"
2106+ <*> mPercolate .:: "queries"
2107+ <*> mPercolate .:: "memory_size_in_bytes"
2108+ <*> mPercolate .:: "current"
2109+ <*> (fmap unMS <$> mPercolate .:: "time_in_millis")
2110+ <*> mPercolate .:: "total"
2111+ <*> fielddata .: "evictions"
2112+ <*> fielddata .: "memory_size_in_bytes"
2113+ <*> (unMS <$> warmer .: "total_time_in_millis")
2114+ <*> warmer .: "total"
2115+ <*> warmer .: "current"
2116+ <*> (unMS <$> flush .: "total_time_in_millis")
2117+ <*> flush .: "total"
2118+ <*> (unMS <$> refresh .: "total_time_in_millis")
2119+ <*> refresh .: "total"
2120+ <*> merges .: "total_size_in_bytes"
2121+ <*> merges .: "total_docs"
2122+ <*> (unMS <$> merges .: "total_time_in_millis")
2123+ <*> merges .: "total"
2124+ <*> merges .: "current_size_in_bytes"
2125+ <*> merges .: "current_docs"
2126+ <*> merges .: "current"
2127+ <*> search .: "fetch_current"
2128+ <*> (unMS <$> search .: "fetch_time_in_millis")
2129+ <*> search .: "fetch_total"
2130+ <*> search .: "query_current"
2131+ <*> (unMS <$> search .: "query_time_in_millis")
2132+ <*> search .: "query_total"
2133+ <*> search .: "open_contexts"
2134+ <*> getStats .: "current"
2135+ <*> (unMS <$> getStats .: "missing_time_in_millis")
2136+ <*> getStats .: "missing_total"
2137+ <*> (unMS <$> getStats .: "exists_time_in_millis")
2138+ <*> getStats .: "exists_total"
2139+ <*> (unMS <$> getStats .: "time_in_millis")
2140+ <*> getStats .: "total"
2141+ <*> (fmap unMS <$> indexing .:? "throttle_time_in_millis")
2142+ <*> indexing .:? "is_throttled"
2143+ <*> indexing .:? "noop_update_total"
2144+ <*> indexing .: "delete_current"
2145+ <*> (unMS <$> indexing .: "delete_time_in_millis")
2146+ <*> indexing .: "delete_total"
2147+ <*> indexing .: "index_current"
2148+ <*> (unMS <$> indexing .: "index_time_in_millis")
2149+ <*> indexing .: "index_total"
2150+ <*> (unMS <$> store .: "throttle_time_in_millis")
2151+ <*> store .: "size_in_bytes"
2152+ <*> docs .: "deleted"
2153+ <*> docs .: "count"
2155+instance FromJSON NodeBreakersStats where
2156+ parseJSON = withObject "NodeBreakersStats" parse
2158+ parse o = NodeBreakersStats <$> o .: "parent"
2160+ <*> o .: "fielddata"
2162+parseNodeStats :: FullNodeId -> Object -> Parser NodeStats
2163+parseNodeStats fnid o =
2164+ NodeStats <$> o .: "name"
2166+ <*> o .:? "breakers"
2168+ <*> o .: "transport"
2170+ <*> o .:? "network"
2171+ <*> o .: "thread_pool"
2177+parseNodeInfo :: FullNodeId -> Object -> Parser NodeInfo
2178+parseNodeInfo nid o =
2179+ NodeInfo <$> o .:? "http_address"
2180+ <*> o .: "build_hash"
2184+ <*> o .: "transport_address"
2189+ <*> o .: "transport"
2190+ <*> o .:? "network"
2191+ <*> o .: "thread_pool"
2195+ <*> o .: "settings"
2197+instance FromJSON NodePluginInfo where
2198+ parseJSON = withObject "NodePluginInfo" parse
2200+ parse o = NodePluginInfo <$> o .:? "site"
2202+ <*> o .: "description"
2206+instance FromJSON NodeHTTPInfo where
2207+ parseJSON = withObject "NodeHTTPInfo" parse
2209+ parse o = NodeHTTPInfo <$> o .: "max_content_length_in_bytes"
2210+ <*> parseJSON (Object o)
2212+instance FromJSON BoundTransportAddress where
2213+ parseJSON = withObject "BoundTransportAddress" parse
2215+ parse o = BoundTransportAddress <$> o .: "publish_address"
2216+ <*> o .: "bound_address"
2218+instance FromJSON NodeOSInfo where
2219+ parseJSON = withObject "NodeOSInfo" parse
2222+ NodeOSInfo <$> (unMS <$> o .: "refresh_interval_in_millis")
2226+ <*> o .: "available_processors"
2227+ <*> o .: "allocated_processors"
2230+instance FromJSON CPUInfo where
2231+ parseJSON = withObject "CPUInfo" parse
2233+ parse o = CPUInfo <$> o .: "cache_size_in_bytes"
2234+ <*> o .: "cores_per_socket"
2235+ <*> o .: "total_sockets"
2236+ <*> o .: "total_cores"
2241+instance FromJSON NodeProcessInfo where
2242+ parseJSON = withObject "NodeProcessInfo" parse
2244+ parse o = NodeProcessInfo <$> o .: "mlockall"
2245+ <*> o .:? "max_file_descriptors"
2247+ <*> (unMS <$> o .: "refresh_interval_in_millis")
2249+instance FromJSON NodeJVMInfo where
2250+ parseJSON = withObject "NodeJVMInfo" parse
2252+ parse o = NodeJVMInfo <$> o .: "memory_pools"
2253+ <*> o .: "gc_collectors"
2255+ <*> (posixMS <$> o .: "start_time_in_millis")
2256+ <*> o .: "vm_vendor"
2257+ <*> o .: "vm_version"
2262+instance FromJSON JVMMemoryInfo where
2263+ parseJSON = withObject "JVMMemoryInfo" parse
2265+ parse o = JVMMemoryInfo <$> o .: "direct_max_in_bytes"
2266+ <*> o .: "non_heap_max_in_bytes"
2267+ <*> o .: "non_heap_init_in_bytes"
2268+ <*> o .: "heap_max_in_bytes"
2269+ <*> o .: "heap_init_in_bytes"
2271+instance FromJSON NodeThreadPoolsInfo where
2272+ parseJSON = withObject "NodeThreadPoolsInfo" parse
2274+ parse o = NodeThreadPoolsInfo <$> o .: "refresh"
2275+ <*> o .: "management"
2276+ <*> o .:? "percolate"
2277+ <*> o .:? "listener"
2278+ <*> o .:? "fetch_shard_started"
2282+ <*> o .:? "optimize"
2284+ <*> o .:? "suggest"
2285+ <*> o .: "force_merge"
2286+ <*> o .: "snapshot"
2288+ <*> o .:? "fetch_shard_store"
2292+instance FromJSON NodeThreadPoolInfo where
2293+ parseJSON = withObject "NodeThreadPoolInfo" parse
2296+ ka <- maybe (return Nothing) (fmap Just . parseStringInterval) =<< o .:? "keep_alive"
2297+ NodeThreadPoolInfo <$> (parseJSON . unStringlyTypeJSON =<< o .: "queue_size")
2303+data TimeInterval = Weeks
2307+ | Seconds deriving Eq
2309+instance Show TimeInterval where
2316+instance Read TimeInterval where
2317+ readPrec = f =<< TR.get
2319+ f 'w' = return Weeks
2320+ f 'd' = return Days
2321+ f 'h' = return Hours
2322+ f 'm' = return Minutes
2323+ f 's' = return Seconds
2324+ f _ = fail "TimeInterval expected one of w, d, h, m, s"
2326+data Interval = Year
2333+ | Second deriving (Eq, Show)
2335+instance ToJSON Interval where
2336+ toJSON Year = "year"
2337+ toJSON Quarter = "quarter"
2338+ toJSON Month = "month"
2339+ toJSON Week = "week"
2341+ toJSON Hour = "hour"
2342+ toJSON Minute = "minute"
2343+ toJSON Second = "second"
2345+parseStringInterval :: (Monad m) => String -> m NominalDiffTime
2346+parseStringInterval s = case span isNumber s of
2347+ ("", _) -> fail "Invalid interval"
2348+ (nS, unitS) -> case (readMay nS, readMay unitS) of
2349+ (Just n, Just unit) -> return (fromInteger (n * unitNDT unit))
2350+ (Nothing, _) -> fail "Invalid interval number"
2351+ (_, Nothing) -> fail "Invalid interval unit"
2353+ unitNDT Seconds = 1
2354+ unitNDT Minutes = 60
2355+ unitNDT Hours = 60 * 60
2356+ unitNDT Days = 24 * 60 * 60
2357+ unitNDT Weeks = 7 * 24 * 60 * 60
2359+instance FromJSON ThreadPoolSize where
2360+ parseJSON v = parseAsNumber v <|> parseAsString v
2362+ parseAsNumber = parseAsInt <=< parseJSON
2363+ parseAsInt (-1) = return ThreadPoolUnbounded
2365+ | n >= 0 = return (ThreadPoolBounded n)
2366+ | otherwise = fail "Thread pool size must be >= -1."
2367+ parseAsString = withText "ThreadPoolSize" $ \t ->
2368+ case first (readMay . T.unpack) (T.span isNumber t) of
2369+ (Just n, "k") -> return (ThreadPoolBounded (n * 1000))
2370+ (Just n, "") -> return (ThreadPoolBounded n)
2371+ _ -> fail ("Invalid thread pool size " <> T.unpack t)
2373+instance FromJSON ThreadPoolType where
2374+ parseJSON = withText "ThreadPoolType" parse
2376+ parse "scaling" = return ThreadPoolScaling
2377+ parse "fixed" = return ThreadPoolFixed
2378+ parse "cached" = return ThreadPoolCached
2379+ parse e = fail ("Unexpected thread pool type" <> T.unpack e)
2381+instance FromJSON NodeTransportInfo where
2382+ parseJSON = withObject "NodeTransportInfo" parse
2384+ parse o = NodeTransportInfo <$> (maybe (return mempty) parseProfiles =<< o .:? "profiles")
2385+ <*> parseJSON (Object o)
2386+ parseProfiles (Object o) | HM.null o = return []
2387+ parseProfiles v@(Array _) = parseJSON v
2388+ parseProfiles Null = return []
2389+ parseProfiles _ = fail "Could not parse profiles"
2391+instance FromJSON NodeNetworkInfo where
2392+ parseJSON = withObject "NodeNetworkInfo" parse
2394+ parse o = NodeNetworkInfo <$> o .: "primary_interface"
2395+ <*> (unMS <$> o .: "refresh_interval_in_millis")
2398+instance FromJSON NodeNetworkInterface where
2399+ parseJSON = withObject "NodeNetworkInterface" parse
2401+ parse o = NodeNetworkInterface <$> o .: "mac_address"
2406+instance ToJSON Version where
2407+ toJSON Version {..} = object ["number" .= number
2408+ ,"build_hash" .= build_hash
2409+ ,"build_date" .= build_date
2410+ ,"build_snapshot" .= build_snapshot
2411+ ,"lucene_version" .= lucene_version]
2413+instance FromJSON Version where
2414+ parseJSON = withObject "Version" parse
2415+ where parse o = Version
2417+ <*> o .: "build_hash"
2418+ <*> o .: "build_date"
2419+ <*> o .: "build_snapshot"
2420+ <*> o .: "lucene_version"
2422+instance ToJSON VersionNumber where
2423+ toJSON = toJSON . SemVer.toText . versionNumber
2425+instance FromJSON VersionNumber where
2426+ parseJSON = withText "VersionNumber" parse
2429+ case SemVer.fromText t of
2430+ (Left err) -> fail err
2431+ (Right v) -> return (VersionNumber v)