664a376 · typeable/bloodhound

137emptyBody :: L.ByteString

138emptyBody = L.pack ""

139

140−dispatch :: MonadBloodhound m => Method -> String -> Maybe L.ByteString

140+dispatch :: MonadBH m => Method -> String -> Maybe L.ByteString

141 -> m Reply

142dispatch dMethod url body = do

143 initReq <- liftIO $ parseUrl url

151joinPath' :: [String] -> String

152joinPath' = intercalate "/"

153

154−joinPath :: MonadBloodhound m => [String] -> m String

154+joinPath :: MonadBH m => [String] -> m String

155joinPath ps = do

156 Server s <- bhServer <$> getBHEnv

157 return $ joinPath' (s:ps)

169 runReaderT f env

170

171-- Shortcut functions for HTTP methods

172−delete :: MonadBloodhound m => String -> m Reply

172+delete :: MonadBH m => String -> m Reply

173delete = flip (dispatch NHTM.methodDelete) Nothing

174−get :: MonadBloodhound m => String -> m Reply

174+get :: MonadBH m => String -> m Reply

175get = flip (dispatch NHTM.methodGet) Nothing

176−head :: MonadBloodhound m => String -> m Reply

176+head :: MonadBH m => String -> m Reply

177head = flip (dispatch NHTM.methodHead) Nothing

178−put :: MonadBloodhound m => String -> Maybe L.ByteString -> m Reply

178+put :: MonadBH m => String -> Maybe L.ByteString -> m Reply

179put = dispatch NHTM.methodPost

180−post :: MonadBloodhound m => String -> Maybe L.ByteString -> m Reply

180+post :: MonadBH m => String -> Maybe L.ByteString -> m Reply

181post = dispatch NHTM.methodPost

182

183-- indexDocument s ix name doc = put (root </> s </> ix </> name </> doc) (Just encode doc)

189-- >>> serverStatus <- runBH getStatus

190-- >>> fmap status (serverStatus)

191-- Just 200

192−getStatus :: MonadBloodhound m => m (Maybe Status)

192+getStatus :: MonadBH m => m (Maybe Status)

193getStatus = do

194 url <- joinPath []

195 request <- liftIO $ parseUrl url

204-- True

205-- >>> runBH $ indexExists (IndexName "didimakeanindex")

206-- True

207−createIndex :: MonadBloodhound m => IndexSettings -> IndexName -> m Reply

207+createIndex :: MonadBH m => IndexSettings -> IndexName -> m Reply

208createIndex indexSettings (IndexName indexName) =

209 bindM2 put url (return body)

210 where url = joinPath [indexName]

218-- True

219-- >>> runBH $ indexExists testIndex

220-- False

221−deleteIndex :: MonadBloodhound m => IndexName -> m Reply

221+deleteIndex :: MonadBH m => IndexName -> m Reply

222deleteIndex (IndexName indexName) =

223 delete =<< joinPath [indexName]

224

228respIsTwoHunna :: Reply -> Bool

229respIsTwoHunna = statusCodeIs 200

230

231−existentialQuery :: MonadBloodhound m => String -> m (Reply, Bool)

231+existentialQuery :: MonadBH m => String -> m (Reply, Bool)

232existentialQuery url = do

233 reply <- head url

234 return (reply, respIsTwoHunna reply)

237-- in IO

238--

239-- >>> exists <- runBH $ indexExists testIndex

240−indexExists :: MonadBloodhound m => IndexName -> m Bool

240+indexExists :: MonadBH m => IndexName -> m Bool

241indexExists (IndexName indexName) = do

242 (_, exists) <- existentialQuery =<< joinPath [indexName]

243 return exists

247--

248-- >>> _ <- runBH $ createIndex defaultIndexSettings testIndex

249-- >>> _ <- runBH $ refreshIndex testIndex

250−refreshIndex :: MonadBloodhound m => IndexName -> m Reply

250+refreshIndex :: MonadBH m => IndexName -> m Reply

251refreshIndex (IndexName indexName) =

252 bindM2 post url (return Nothing)

253 where url = joinPath [indexName, "_refresh"]

257 OpenIndex -> "_open"

258 CloseIndex -> "_close"

259

260−openOrCloseIndexes :: MonadBloodhound m => OpenCloseIndex -> IndexName -> m Reply

260+openOrCloseIndexes :: MonadBH m => OpenCloseIndex -> IndexName -> m Reply

261openOrCloseIndexes oci (IndexName indexName) =

262 bindM2 post url (return Nothing)

263 where ociString = stringifyOCIndex oci

267-- <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html>

268--

269-- >>> reply <- runBH $ openIndex testIndex

270−openIndex :: MonadBloodhound m => IndexName -> m Reply

270+openIndex :: MonadBH m => IndexName -> m Reply

271openIndex = openOrCloseIndexes OpenIndex

272

273-- | 'closeIndex' closes an index given a 'Server' and an 'IndexName'. Explained in further detail at

274-- <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html>

275--

276-- >>> reply <- runBH $ closeIndex testIndex

277−closeIndex :: MonadBloodhound m => IndexName -> m Reply

277+closeIndex :: MonadBH m => IndexName -> m Reply

278closeIndex = openOrCloseIndexes CloseIndex

279

280-- | 'putMapping' is an HTTP PUT and has upsert semantics. Mappings are schemas

284-- >>> resp <- runBH $ putMapping testIndex testMapping TweetMapping

285-- >>> print resp

286-- Response {responseStatus = Status {statusCode = 200, statusMessage = "OK"}, responseVersion = HTTP/1.1, responseHeaders = [("Content-Type","application/json; charset=UTF-8"),("Content-Length","21")], responseBody = "{\"acknowledged\":true}", responseCookieJar = CJ {expose = []}, responseClose' = ResponseClose}

287−putMapping :: (MonadBloodhound m, ToJSON a) => IndexName

287+putMapping :: (MonadBH m, ToJSON a) => IndexName

288 -> MappingName -> a -> m Reply

289putMapping (IndexName indexName) (MappingName mappingName) mapping =

290 bindM2 put url (return body)

299-- >>> resp <- runBH $ deleteMapping testIndex testMapping

300-- >>> print resp

301-- Response {responseStatus = Status {statusCode = 200, statusMessage = "OK"}, responseVersion = HTTP/1.1, responseHeaders = [("Content-Type","application/json; charset=UTF-8"),("Content-Length","21")], responseBody = "{\"acknowledged\":true}", responseCookieJar = CJ {expose = []}, responseClose' = ResponseClose}

302−deleteMapping :: MonadBloodhound m => IndexName -> MappingName -> m Reply

302+deleteMapping :: MonadBH m => IndexName -> MappingName -> m Reply

303deleteMapping (IndexName indexName)

304 (MappingName mappingName) =

305 delete =<< joinPath [indexName, mappingName, "_mapping"]

312-- >>> resp <- runBH $ indexDocument testIndex testMapping exampleTweet (DocId "1")

313-- >>> print resp

314-- Response {responseStatus = Status {statusCode = 201, statusMessage = "Created"}, responseVersion = HTTP/1.1, responseHeaders = [("Content-Type","application/json; charset=UTF-8"),("Content-Length","74")], responseBody = "{\"_index\":\"twitter\",\"_type\":\"tweet\",\"_id\":\"1\",\"_version\":1,\"created\":true}", responseCookieJar = CJ {expose = []}, responseClose' = ResponseClose}

315−indexDocument :: (ToJSON doc, MonadBloodhound m) => IndexName -> MappingName

315+indexDocument :: (ToJSON doc, MonadBH m) => IndexName -> MappingName

316 -> doc -> DocId -> m Reply

317indexDocument (IndexName indexName)

318 (MappingName mappingName) document (DocId docId) =

323-- | 'deleteDocument' is the primary way to delete a single document.

324--

325-- >>> _ <- runBH $ deleteDocument testIndex testMapping (DocId "1")

326−deleteDocument :: MonadBloodhound m => IndexName -> MappingName

326+deleteDocument :: MonadBH m => IndexName -> MappingName

327 -> DocId -> m Reply

328deleteDocument (IndexName indexName)

329 (MappingName mappingName) (DocId docId) =

339-- >>> let stream = V.fromList [BulkIndex testIndex testMapping (DocId "2") (toJSON (BulkTest "blah"))]

340-- >>> _ <- runBH $ bulk stream

341-- >>> _ <- runBH $ refreshIndex testIndex

342−bulk :: MonadBloodhound m => V.Vector BulkOperation -> m Reply

342+bulk :: MonadBH m => V.Vector BulkOperation -> m Reply

343bulk bulkOps = bindM2 post url (return body)

344 where url = joinPath ["_bulk"]

345 body = Just $ encodeBulkOperations bulkOps

403-- The 'DocId' is the primary key for your Elasticsearch document.

404--

405-- >>> yourDoc <- runBH $ getDocument testIndex testMapping (DocId "1")

406−getDocument :: MonadBloodhound m => IndexName -> MappingName

406+getDocument :: MonadBH m => IndexName -> MappingName

407 -> DocId -> m Reply

408getDocument (IndexName indexName)

409 (MappingName mappingName) (DocId docId) =

413-- in IO

414--

415-- >>> exists <- runBH $ documentExists testIndex testMapping (DocId "1")

416−documentExists :: MonadBloodhound m => IndexName -> MappingName

416+documentExists :: MonadBH m => IndexName -> MappingName

417 -> DocId -> m Bool

418documentExists (IndexName indexName)

419 (MappingName mappingName) (DocId docId) = do

421 return exists

422 where url = joinPath [indexName, mappingName, docId]

423

424−dispatchSearch :: MonadBloodhound m => String -> Search -> m Reply

424+dispatchSearch :: MonadBH m => String -> Search -> m Reply

425dispatchSearch url search = post url (Just (encode search))

426

427-- | 'searchAll', given a 'Search', will perform that search against all indexes

430-- >>> let query = TermQuery (Term "user" "bitemyapp") Nothing

431-- >>> let search = mkSearch (Just query) Nothing

432-- >>> reply <- runBH $ searchAll search

433−searchAll :: MonadBloodhound m => Search -> m Reply

433+searchAll :: MonadBH m => Search -> m Reply

434searchAll = bindM2 dispatchSearch url . return

435 where url = joinPath ["_search"]

436

440-- >>> let query = TermQuery (Term "user" "bitemyapp") Nothing

441-- >>> let search = mkSearch (Just query) Nothing

442-- >>> reply <- runBH $ searchByIndex testIndex search

443−searchByIndex :: MonadBloodhound m => IndexName -> Search -> m Reply

443+searchByIndex :: MonadBH m => IndexName -> Search -> m Reply

444searchByIndex (IndexName indexName) = bindM2 dispatchSearch url . return

445 where url = joinPath [indexName, "_search"]

446

450-- >>> let query = TermQuery (Term "user" "bitemyapp") Nothing

451-- >>> let search = mkSearch (Just query) Nothing

452-- >>> reply <- runBH $ searchByType testIndex testMapping search

453−searchByType :: MonadBloodhound m => IndexName -> MappingName -> Search

453+searchByType :: MonadBH m => IndexName -> MappingName -> Search

454 -> m Reply

455searchByType (IndexName indexName)

456 (MappingName mappingName) = bindM2 dispatchSearch url . return