From f741bc794386fe71a5e514680eeb80b5f99f97b0 Mon Sep 17 00:00:00 2001 From: Elon Cheng Date: Fri, 12 Aug 2022 06:58:33 -0500 Subject: [PATCH] intergrate opensearch v1 (#5135) opensearchv1 Signed-off-by: chengdehao Signed-off-by: chengdehao Co-authored-by: chengdehao --- go.mod | 5 +- go.sum | 2 + pkg/simple/client/es/client.go | 6 + .../es/versions/opensearchv1/opensearchv1.go | 128 +++ .../opensearch-go/.codecov.yml | 8 + .../opensearch-go/.dockerignore | 2 + .../opensearch-go/.gitignore | 5 + .../opensearch-go/.whitesource | 15 + .../opensearch-go/ADMINS.md | 31 + .../opensearch-go/CODE_OF_CONDUCT.md | 25 + .../opensearch-go/CONTRIBUTING.md | 96 +++ .../opensearch-go/DEVELOPER_GUIDE.md | 65 ++ .../opensearch-go/LICENSE.txt | 201 +++++ .../opensearch-go/MAINTAINERS.md | 70 ++ .../opensearch-project/opensearch-go/Makefile | 212 +++++ .../opensearch-go/NOTICE.txt | 8 + .../opensearch-go/OpenSearch.svg | 1 + .../opensearch-go/README.md | 47 + .../opensearch-go/RELEASING.md | 34 + .../opensearch-go/SECURITY.md | 3 + .../opensearch-go/USER_GUIDE.md | 127 +++ .../opensearch-project/opensearch-go/doc.go | 74 ++ .../opensearch-go/internal/version/version.go | 31 + .../opensearch-go/opensearch.go | 402 +++++++++ .../opensearch-go/opensearchapi/api._.go | 393 +++++++++ .../opensearch-go/opensearchapi/api.bulk.go | 361 ++++++++ .../opensearchapi/api.cat.aliases.go | 312 +++++++ .../opensearchapi/api.cat.allocation.go | 327 +++++++ .../opensearchapi/api.cat.count.go | 287 +++++++ .../opensearchapi/api.cat.fielddata.go | 304 +++++++ .../opensearchapi/api.cat.health.go | 296 +++++++ .../opensearchapi/api.cat.help.go | 230 +++++ .../opensearchapi/api.cat.indices.go | 391 +++++++++ .../opensearchapi/api.cat.master.go | 296 +++++++ .../opensearchapi/api.cat.nodeattrs.go | 296 +++++++ .../opensearchapi/api.cat.nodes.go | 348 ++++++++ .../opensearchapi/api.cat.pending_tasks.go | 309 +++++++ .../opensearchapi/api.cat.plugins.go | 309 +++++++ .../opensearchapi/api.cat.recovery.go | 342 ++++++++ .../opensearchapi/api.cat.repositories.go | 296 +++++++ .../opensearchapi/api.cat.segments.go | 299 +++++++ .../opensearchapi/api.cat.shards.go | 339 ++++++++ .../opensearchapi/api.cat.snapshots.go | 326 +++++++ .../opensearchapi/api.cat.tasks.go | 334 ++++++++ .../opensearchapi/api.cat.templates.go | 313 +++++++ .../opensearchapi/api.cat.thread_pool.go | 327 +++++++ .../opensearchapi/api.clear_scroll.go | 234 +++++ .../api.cluster.allocation_explain.go | 245 ++++++ .../api.cluster.delete_component_template.go | 235 +++++ ...cluster.delete_voting_config_exclusions.go | 217 +++++ .../api.cluster.exists_component_template.go | 236 +++++ .../api.cluster.get_component_template.go | 246 ++++++ .../opensearchapi/api.cluster.get_settings.go | 257 ++++++ .../opensearchapi/api.cluster.health.go | 365 ++++++++ .../api.cluster.pending_tasks.go | 232 +++++ ...i.cluster.post_voting_config_exclusions.go | 243 ++++++ .../api.cluster.put_component_template.go | 256 ++++++ .../opensearchapi/api.cluster.put_settings.go | 251 ++++++ .../opensearchapi/api.cluster.remote_info.go | 202 +++++ .../opensearchapi/api.cluster.reroute.go | 298 +++++++ .../opensearchapi/api.cluster.state.go | 340 ++++++++ .../opensearchapi/api.cluster.stats.go | 250 ++++++ .../opensearch-go/opensearchapi/api.count.go | 429 ++++++++++ .../opensearch-go/opensearchapi/api.create.go | 330 +++++++ ....dangling_indices.delete_dangling_index.go | 249 ++++++ ....dangling_indices.import_dangling_index.go | 249 ++++++ ....dangling_indices.list_dangling_indices.go | 202 +++++ .../opensearch-go/opensearchapi/api.delete.go | 332 +++++++ .../opensearchapi/api.delete_by_query.go | 660 ++++++++++++++ .../api.delete_by_query_rethrottle.go | 224 +++++ .../opensearchapi/api.delete_script.go | 235 +++++ .../opensearch-go/opensearchapi/api.exists.go | 357 ++++++++ .../opensearchapi/api.exists_source.go | 342 ++++++++ .../opensearchapi/api.explain.go | 400 +++++++++ .../opensearchapi/api.field_caps.go | 299 +++++++ .../opensearch-go/opensearchapi/api.get.go | 357 ++++++++ .../opensearchapi/api.get_script.go | 222 +++++ .../opensearchapi/api.get_script_context.go | 204 +++++ .../opensearchapi/api.get_script_languages.go | 204 +++++ .../opensearchapi/api.get_source.go | 346 ++++++++ .../opensearch-go/opensearchapi/api.index.go | 392 +++++++++ .../opensearchapi/api.indices.add_block.go | 279 ++++++ .../opensearchapi/api.indices.analyze.go | 236 +++++ .../opensearchapi/api.indices.clear_cache.go | 316 +++++++ .../opensearchapi/api.indices.clone.go | 267 ++++++ .../opensearchapi/api.indices.close.go | 288 +++++++ .../opensearchapi/api.indices.create.go | 275 ++++++ .../opensearchapi/api.indices.delete.go | 273 ++++++ .../opensearchapi/api.indices.delete_alias.go | 239 ++++++ .../api.indices.delete_index_template.go | 235 +++++ .../api.indices.delete_template.go | 235 +++++ .../opensearchapi/api.indices.disk_usage.go | 276 ++++++ .../opensearchapi/api.indices.exists.go | 285 ++++++ .../opensearchapi/api.indices.exists_alias.go | 275 ++++++ .../api.indices.exists_index_template.go | 249 ++++++ .../api.indices.exists_template.go | 249 ++++++ .../opensearchapi/api.indices.exists_type.go | 272 ++++++ .../api.indices.field_usage_stats.go | 263 ++++++ .../opensearchapi/api.indices.flush.go | 284 ++++++ .../opensearchapi/api.indices.flush_synced.go | 260 ++++++ .../opensearchapi/api.indices.forcemerge.go | 297 +++++++ .../opensearchapi/api.indices.get.go | 312 +++++++ .../opensearchapi/api.indices.get_alias.go | 285 ++++++ .../api.indices.get_field_mapping.go | 316 +++++++ .../api.indices.get_index_template.go | 259 ++++++ .../opensearchapi/api.indices.get_mapping.go | 311 +++++++ .../opensearchapi/api.indices.get_settings.go | 325 +++++++ .../opensearchapi/api.indices.get_template.go | 272 ++++++ .../opensearchapi/api.indices.get_upgrade.go | 258 ++++++ .../opensearchapi/api.indices.open.go | 288 +++++++ .../opensearchapi/api.indices.put_alias.go | 254 ++++++ .../api.indices.put_index_template.go | 256 ++++++ .../opensearchapi/api.indices.put_mapping.go | 331 +++++++ .../opensearchapi/api.indices.put_settings.go | 318 +++++++ .../opensearchapi/api.indices.put_template.go | 269 ++++++ .../opensearchapi/api.indices.recovery.go | 245 ++++++ .../opensearchapi/api.indices.refresh.go | 258 ++++++ .../api.indices.resolve_index.go | 225 +++++ .../opensearchapi/api.indices.rollover.go | 304 +++++++ .../opensearchapi/api.indices.segments.go | 271 ++++++ .../opensearchapi/api.indices.shard_stores.go | 271 ++++++ .../opensearchapi/api.indices.shrink.go | 281 ++++++ .../api.indices.simulate_index_template.go | 266 ++++++ .../api.indices.simulate_template.go | 276 ++++++ .../opensearchapi/api.indices.split.go | 281 ++++++ .../opensearchapi/api.indices.stats.go | 363 ++++++++ .../api.indices.update_aliases.go | 237 +++++ .../opensearchapi/api.indices.upgrade.go | 284 ++++++ .../api.indices.validate_query.go | 405 +++++++++ .../opensearch-go/opensearchapi/api.info.go | 194 +++++ .../api.ingest.delete_pipeline.go | 237 +++++ .../opensearchapi/api.ingest.get_pipeline.go | 248 ++++++ .../api.ingest.processor_grok.go | 202 +++++ .../opensearchapi/api.ingest.put_pipeline.go | 244 ++++++ .../opensearchapi/api.ingest.simulate.go | 243 ++++++ .../opensearch-go/opensearchapi/api.mget.go | 343 ++++++++ .../opensearchapi/api.msearch.go | 330 +++++++ .../opensearchapi/api.msearch_template.go | 306 +++++++ .../opensearchapi/api.mtermvectors.go | 403 +++++++++ .../opensearchapi/api.nodes.hot_threads.go | 302 +++++++ .../opensearchapi/api.nodes.info.go | 259 ++++++ .../api.nodes.reload_secure_settings.go | 249 ++++++ .../opensearchapi/api.nodes.stats.go | 365 ++++++++ .../opensearchapi/api.nodes.usage.go | 247 ++++++ .../opensearch-go/opensearchapi/api.ping.go | 202 +++++ .../opensearchapi/api.put_script.go | 260 ++++++ .../opensearchapi/api.rank_eval.go | 280 ++++++ .../opensearchapi/api.reindex.go | 319 +++++++ .../opensearchapi/api.reindex_rethrottle.go | 224 +++++ .../api.render_search_template.go | 234 +++++ .../api.scripts_painless_execute.go | 219 +++++ .../opensearch-go/opensearchapi/api.scroll.go | 260 ++++++ .../opensearch-go/opensearchapi/api.search.go | 808 ++++++++++++++++++ .../opensearchapi/api.search_shards.go | 297 +++++++ .../opensearchapi/api.search_template.go | 411 +++++++++ .../api.snapshot.cleanup_repository.go | 237 +++++ .../opensearchapi/api.snapshot.clone.go | 237 +++++ .../opensearchapi/api.snapshot.create.go | 254 ++++++ .../api.snapshot.create_repository.go | 256 ++++++ .../opensearchapi/api.snapshot.delete.go | 225 +++++ .../api.snapshot.delete_repository.go | 235 +++++ .../opensearchapi/api.snapshot.get.go | 278 ++++++ .../api.snapshot.get_repository.go | 246 ++++++ .../opensearchapi/api.snapshot.restore.go | 256 ++++++ .../opensearchapi/api.snapshot.status.go | 261 ++++++ .../api.snapshot.verify_repository.go | 237 +++++ .../opensearchapi/api.tasks.cancel.go | 275 ++++++ .../opensearchapi/api.tasks.get.go | 238 ++++++ .../opensearchapi/api.tasks.list.go | 298 +++++++ .../opensearchapi/api.terms_enum.go | 224 +++++ .../opensearchapi/api.termvectors.go | 397 +++++++++ .../opensearch-go/opensearchapi/api.update.go | 393 +++++++++ .../opensearchapi/api.update_by_query.go | 695 +++++++++++++++ .../api.update_by_query_rethrottle.go | 224 +++++ .../opensearch-go/opensearchapi/doc.go | 106 +++ .../opensearchapi/opensearchapi.go | 71 ++ .../opensearchapi/opensearchapi.request.go | 53 ++ .../opensearchapi/opensearchapi.response.go | 114 +++ .../opensearchtransport/connection.go | 338 ++++++++ .../opensearchtransport/discovery.go | 221 +++++ .../opensearch-go/opensearchtransport/doc.go | 59 ++ .../opensearchtransport/logger.go | 461 ++++++++++ .../opensearchtransport/metrics.go | 203 +++++ .../opensearchtransport.go | 521 +++++++++++ .../opensearch-go/signer/signer.go | 17 + vendor/modules.txt | 12 +- 186 files changed, 47471 insertions(+), 4 deletions(-) create mode 100644 pkg/simple/client/es/versions/opensearchv1/opensearchv1.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/.codecov.yml create mode 100644 vendor/github.com/opensearch-project/opensearch-go/.dockerignore create mode 100644 vendor/github.com/opensearch-project/opensearch-go/.gitignore create mode 100644 vendor/github.com/opensearch-project/opensearch-go/.whitesource create mode 100644 vendor/github.com/opensearch-project/opensearch-go/ADMINS.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/CODE_OF_CONDUCT.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/CONTRIBUTING.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/DEVELOPER_GUIDE.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/LICENSE.txt create mode 100644 vendor/github.com/opensearch-project/opensearch-go/MAINTAINERS.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/Makefile create mode 100644 vendor/github.com/opensearch-project/opensearch-go/NOTICE.txt create mode 100644 vendor/github.com/opensearch-project/opensearch-go/OpenSearch.svg create mode 100644 vendor/github.com/opensearch-project/opensearch-go/README.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/RELEASING.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/SECURITY.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/USER_GUIDE.md create mode 100644 vendor/github.com/opensearch-project/opensearch-go/doc.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/internal/version/version.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearch.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api._.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.bulk.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.aliases.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.allocation.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.count.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.fielddata.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.health.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.help.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.indices.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.master.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.nodeattrs.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.nodes.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.pending_tasks.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.plugins.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.recovery.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.repositories.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.segments.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.shards.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.snapshots.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.tasks.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.templates.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.thread_pool.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.clear_scroll.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.allocation_explain.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.delete_component_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.delete_voting_config_exclusions.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.exists_component_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.get_component_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.get_settings.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.health.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.pending_tasks.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.post_voting_config_exclusions.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.put_component_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.put_settings.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.remote_info.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.reroute.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.state.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.stats.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.count.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.create.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.delete_dangling_index.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.import_dangling_index.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.list_dangling_indices.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_by_query.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_by_query_rethrottle.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_script.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.exists.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.exists_source.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.explain.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.field_caps.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script_context.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script_languages.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_source.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.index.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.add_block.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.analyze.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.clear_cache.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.clone.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.close.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.create.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_alias.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_index_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.disk_usage.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_alias.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_index_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_type.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.field_usage_stats.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.flush.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.flush_synced.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.forcemerge.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_alias.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_field_mapping.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_index_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_mapping.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_settings.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_upgrade.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.open.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_alias.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_index_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_mapping.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_settings.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.recovery.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.refresh.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.resolve_index.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.rollover.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.segments.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.shard_stores.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.shrink.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.simulate_index_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.simulate_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.split.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.stats.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.update_aliases.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.upgrade.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.validate_query.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.info.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.delete_pipeline.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.get_pipeline.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.processor_grok.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.put_pipeline.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.simulate.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.mget.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.msearch.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.msearch_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.mtermvectors.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.hot_threads.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.info.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.reload_secure_settings.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.stats.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.usage.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ping.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.put_script.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.rank_eval.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.reindex.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.reindex_rethrottle.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.render_search_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.scripts_painless_execute.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.scroll.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search_shards.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search_template.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.cleanup_repository.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.clone.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.create.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.create_repository.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.delete.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.delete_repository.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.get.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.get_repository.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.restore.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.status.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.verify_repository.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.cancel.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.get.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.list.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.terms_enum.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.termvectors.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update_by_query.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update_by_query_rethrottle.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/doc.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.request.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.response.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/connection.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/discovery.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/doc.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/logger.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/metrics.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/opensearchtransport.go create mode 100644 vendor/github.com/opensearch-project/opensearch-go/signer/signer.go diff --git a/go.mod b/go.mod index df510d4e9..957c08ada 100644 --- a/go.mod +++ b/go.mod @@ -33,7 +33,7 @@ require ( github.com/go-ldap/ldap v3.0.3+incompatible github.com/go-logr/logr v0.4.0 github.com/go-openapi/loads v0.19.5 - github.com/go-openapi/spec v0.19.7 + github.com/go-openapi/spec v0.19.8 github.com/go-openapi/strfmt v0.19.5 github.com/go-openapi/validate v0.19.8 github.com/go-redis/redis v6.15.2+incompatible @@ -55,6 +55,7 @@ require ( github.com/onsi/gomega v1.15.0 github.com/open-policy-agent/opa v0.18.0 github.com/opencontainers/go-digest v1.0.0 + github.com/opensearch-project/opensearch-go v1.1.0 github.com/opensearch-project/opensearch-go/v2 v2.0.0 github.com/operator-framework/helm-operator-plugins v0.0.8-0.20210810182245-240cc447b3de github.com/pkg/errors v0.9.1 @@ -64,7 +65,7 @@ require ( github.com/prometheus-operator/prometheus-operator v0.42.2-0.20200928114327-fbd01683839a github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring v0.42.1 github.com/prometheus/client_golang v1.11.0 - github.com/prometheus/common v0.26.0 + github.com/prometheus/common v0.37.0 github.com/prometheus/prometheus v1.8.2-0.20200907175821-8219b442c864 github.com/sony/sonyflake v0.0.0-20181109022403-6d5bd6181009 github.com/speps/go-hashids v2.0.0+incompatible diff --git a/go.sum b/go.sum index 2a5eab511..5fd8c5655 100644 --- a/go.sum +++ b/go.sum @@ -651,6 +651,8 @@ github.com/opencontainers/image-spec v1.0.1 h1:JMemWkRwHx4Zj+fVxWoMCFm/8sYGGrUVo github.com/opencontainers/image-spec v1.0.1/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= github.com/opencontainers/runc v0.1.1 h1:GlxAyO6x8rfZYN9Tt0Kti5a/cP41iuiO2yYT0IJGY8Y= github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= +github.com/opensearch-project/opensearch-go v1.1.0 h1:eG5sh3843bbU1itPRjA9QXbxcg8LaZ+DjEzQH9aLN3M= +github.com/opensearch-project/opensearch-go v1.1.0/go.mod h1:+6/XHCuTH+fwsMJikZEWsucZ4eZMma3zNSeLrTtVGbo= github.com/opensearch-project/opensearch-go/v2 v2.0.0 h1:Ij3CpuHwey29cYPVMgi5h1pWBH2O0JaTXsa4c7pqhK4= github.com/opensearch-project/opensearch-go/v2 v2.0.0/go.mod h1:G3kbnV+SeVf4QTbNcrT7Ga3FCsavtp5NQfdRelJikIQ= github.com/opentracing-contrib/go-grpc v0.0.0-20180928155321-4b5a12d3ff02/go.mod h1:JNdpVEzCpXBgIiv4ds+TzhN1hrtxq6ClLrTlT9OQRSc= diff --git a/pkg/simple/client/es/client.go b/pkg/simple/client/es/client.go index 096d80963..59bcb5b50 100644 --- a/pkg/simple/client/es/client.go +++ b/pkg/simple/client/es/client.go @@ -27,6 +27,7 @@ import ( "kubesphere.io/kubesphere/pkg/simple/client/es/query" "kubesphere.io/kubesphere/pkg/simple/client/es/versions" + v1 "kubesphere.io/kubesphere/pkg/simple/client/es/versions/opensearchv1" v2 "kubesphere.io/kubesphere/pkg/simple/client/es/versions/opensearchv2" v5 "kubesphere.io/kubesphere/pkg/simple/client/es/versions/v5" v6 "kubesphere.io/kubesphere/pkg/simple/client/es/versions/v6" @@ -38,6 +39,7 @@ const ( ElasticV5 = "5" ElasticV6 = "6" ElasticV7 = "7" + OpenSearchV1 = "opensearchv1" OpenSearchV2 = "opensearchv2" ) @@ -66,6 +68,8 @@ func NewClient(host string, basicAuth bool, username, password, indexPrefix, ver } switch es.version { + case OpenSearchV1: + es.c, err = v1.New(es.host, es.basicAuth, es.username, es.password, es.index) case OpenSearchV2: es.c, err = v2.New(es.host, es.basicAuth, es.username, es.password, es.index) case ElasticV5: @@ -139,6 +143,8 @@ func (c *Client) loadClient() error { v = "opensearchv" + v } switch v { + case OpenSearchV1: + vc, err = v1.New(c.host, c.basicAuth, c.username, c.password, c.index) case OpenSearchV2: vc, err = v2.New(c.host, c.basicAuth, c.username, c.password, c.index) case ElasticV5: diff --git a/pkg/simple/client/es/versions/opensearchv1/opensearchv1.go b/pkg/simple/client/es/versions/opensearchv1/opensearchv1.go new file mode 100644 index 000000000..911b56855 --- /dev/null +++ b/pkg/simple/client/es/versions/opensearchv1/opensearchv1.go @@ -0,0 +1,128 @@ +/* +Copyright 2020 KubeSphere Authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1 + +import ( + "bytes" + "context" + "crypto/tls" + "encoding/json" + "fmt" + "io/ioutil" + "net/http" + "time" + + "github.com/opensearch-project/opensearch-go" + "github.com/opensearch-project/opensearch-go/opensearchapi" + + "kubesphere.io/kubesphere/pkg/simple/client/es/versions" +) + +type OpenSearch struct { + client *opensearch.Client + index string +} + +func New(address string, basicAuth bool, username, password, index string) (*OpenSearch, error) { + var client *opensearch.Client + var err error + + if !basicAuth { + username = "" + password = "" + } + + client, err = opensearch.NewClient(opensearch.Config{ + Addresses: []string{address}, + Username: username, + Password: password, + Transport: &http.Transport{ + TLSClientConfig: &tls.Config{ + InsecureSkipVerify: true, + }, + }, + }) + + return &OpenSearch{client: client, index: index}, err +} + +func (o *OpenSearch) Search(indices string, body []byte, scroll bool) ([]byte, error) { + opts := []func(*opensearchapi.SearchRequest){ + o.client.Search.WithContext(context.Background()), + o.client.Search.WithIndex(indices), + o.client.Search.WithIgnoreUnavailable(true), + o.client.Search.WithBody(bytes.NewBuffer(body)), + } + if scroll { + opts = append(opts, o.client.Search.WithScroll(time.Minute)) + } + + response, err := o.client.Search(opts...) + if err != nil { + return nil, err + } + defer response.Body.Close() + + if response.IsError() { + return nil, parseError(response) + } + + return ioutil.ReadAll(response.Body) +} + +func (o *OpenSearch) Scroll(id string) ([]byte, error) { + response, err := o.client.Scroll( + o.client.Scroll.WithContext(context.Background()), + o.client.Scroll.WithScrollID(id), + o.client.Scroll.WithScroll(time.Minute)) + if err != nil { + return nil, err + } + defer response.Body.Close() + + if response.IsError() { + return nil, parseError(response) + } + + return ioutil.ReadAll(response.Body) +} + +func (o *OpenSearch) ClearScroll(scrollId string) { + response, _ := o.client.ClearScroll( + o.client.ClearScroll.WithContext(context.Background()), + o.client.ClearScroll.WithScrollID(scrollId)) + defer response.Body.Close() +} + +func (o *OpenSearch) GetTotalHitCount(v interface{}) int64 { + f, _ := v.(float64) + return int64(f) +} + +func parseError(response *opensearchapi.Response) error { + var e versions.Error + if err := json.NewDecoder(response.Body).Decode(&e); err != nil { + return err + } else { + // Print the response status and error information. + if len(e.Details.RootCause) != 0 { + return fmt.Errorf("type: %v, reason: %v", e.Details.Type, e.Details.RootCause[0].Reason) + } else { + return fmt.Errorf("type: %v, reason: %v", e.Details.Type, e.Details.Reason) + } + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/.codecov.yml b/vendor/github.com/opensearch-project/opensearch-go/.codecov.yml new file mode 100644 index 000000000..27efcc8ea --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/.codecov.yml @@ -0,0 +1,8 @@ +comment: off + +coverage: + status: + patch: off + +ignore: + - "opensearchapi/api.*.go" diff --git a/vendor/github.com/opensearch-project/opensearch-go/.dockerignore b/vendor/github.com/opensearch-project/opensearch-go/.dockerignore new file mode 100644 index 000000000..4c8512b08 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/.dockerignore @@ -0,0 +1,2 @@ +.git/ +tmp/ diff --git a/vendor/github.com/opensearch-project/opensearch-go/.gitignore b/vendor/github.com/opensearch-project/opensearch-go/.gitignore new file mode 100644 index 000000000..7a915a038 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/.gitignore @@ -0,0 +1,5 @@ +tmp/ +*.test + +#jetBrains editors +.idea \ No newline at end of file diff --git a/vendor/github.com/opensearch-project/opensearch-go/.whitesource b/vendor/github.com/opensearch-project/opensearch-go/.whitesource new file mode 100644 index 000000000..db4b0fec8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/.whitesource @@ -0,0 +1,15 @@ +{ + "scanSettings": { + "configMode": "AUTO", + "configExternalURL": "", + "projectToken": "", + "baseBranches": [] + }, + "checkRunSettings": { + "vulnerableCheckRunConclusionLevel": "failure", + "displayMode": "diff" + }, + "issueSettings": { + "minSeverityLevel": "LOW" + } +} \ No newline at end of file diff --git a/vendor/github.com/opensearch-project/opensearch-go/ADMINS.md b/vendor/github.com/opensearch-project/opensearch-go/ADMINS.md new file mode 100644 index 000000000..60aeee311 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/ADMINS.md @@ -0,0 +1,31 @@ +## Overview + +This document explains who the admins are (see below), what they do in this repo, and how they should be doing it. If you're interested in becoming a maintainer, see [MAINTAINERS](MAINTAINERS.md). If you're interested in contributing, see [CONTRIBUTING](CONTRIBUTING.md). + +## Current Admins + +| Admin | GitHub ID | Affiliation | +| -------------------------| --------------------------------------- | ----------- | +| Charlotte | [CEHENKLE](https://github.com/CEHENKLE) | Amazon | +| Henri Yandell | [hyandell](https://github.com/hyandell) | Amazon | +| Jack Mazanec | [jmazanec15](https://github.com/jmazanec15) | Amazon | +| Vamshi Vijay Nakkirtha | [vamshin](https://github.com/vamshin) | Amazon | +| Vijayan Balasubramanian | [VijayanB](https://github.com/VijayanB) | Amazon | + +## Admin Responsibilities + +As an admin you own stewartship of the repository and its settings. Admins have [admin-level permissions on a repository](https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-permission-levels-for-an-organization). Use those privileges to serve the community and protect the repository as follows. + +### Prioritize Security + +Security is your number one priority. Manage security keys and safeguard access to the repository. + +Note that this repository is monitored and supported 24/7 by Amazon Security, see [Reporting a Vulnerability](SECURITY.md) for details. + +### Enforce Code of Conduct + +Act on [CODE_OF_CONDUCT](CODE_OF_CONDUCT.md) violations by revoking access, and blocking malicious actors. + +### Adopt Organizational Best Practices + +Adopt organizational best practices, work in the open, and collaborate with other admins by opening issues before making process changes. Prefer consistency, and avoid diverging from practices in the opensearch-project organization. \ No newline at end of file diff --git a/vendor/github.com/opensearch-project/opensearch-go/CODE_OF_CONDUCT.md b/vendor/github.com/opensearch-project/opensearch-go/CODE_OF_CONDUCT.md new file mode 100644 index 000000000..997bae660 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/CODE_OF_CONDUCT.md @@ -0,0 +1,25 @@ + +This code of conduct applies to all spaces provided by the OpenSource project including in code, documentation, issue trackers, mailing lists, chat channels, wikis, blogs, social media and any other communication channels used by the project. + + +**Our open source communities endeavor to:** + +* Be Inclusive: We are committed to being a community where everyone can join and contribute. This means using inclusive and welcoming language. +* Be Welcoming: We are committed to maintaining a safe space for everyone to be able to contribute. +* Be Respectful: We are committed to encouraging differing viewpoints, accepting constructive criticism and work collaboratively towards decisions that help the project grow. Disrespectful and unacceptable behavior will not be tolerated. +* Be Collaborative: We are committed to supporting what is best for our community and users. When we build anything for the benefit of the project, we should document the work we do and communicate to others on how this affects their work. + + +**Our Responsibility. As contributors, members, or bystanders we each individually have the responsibility to behave professionally and respectfully at all times. Disrespectful and unacceptable behaviors include, but are not limited to:** + +* The use of violent threats, abusive, discriminatory, or derogatory language; +* Offensive comments related to gender, gender identity and expression, sexual orientation, disability, mental illness, race, political or religious affiliation; +* Posting of sexually explicit or violent content; +* The use of sexualized language and unwelcome sexual attention or advances; +* Public or private harassment of any kind; +* Publishing private information, such as physical or electronic address, without permission; +* Other conduct which could reasonably be considered inappropriate in a professional setting; +* Advocating for or encouraging any of the above behaviors. +* Enforcement and Reporting Code of Conduct Issues: + +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported. [Contact us](mailto:opensource-codeofconduct@amazon.com). All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. diff --git a/vendor/github.com/opensearch-project/opensearch-go/CONTRIBUTING.md b/vendor/github.com/opensearch-project/opensearch-go/CONTRIBUTING.md new file mode 100644 index 000000000..abb75ab4c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/CONTRIBUTING.md @@ -0,0 +1,96 @@ +- [Contributing to OpenSearch](#contributing-to-opensearch) +- [First Things First](#first-things-first) +- [Ways to Contribute](#ways-to-contribute) + - [Bug Reports](#bug-reports) + - [Feature Requests](#feature-requests) + - [Contributing Code](#contributing-code) +- [Developer Certificate of Origin](#developer-certificate-of-origin) +- [Review Process](#review-process) + +## Contributing to OpenSearch + +OpenSearch is a community project that is built and maintained by people just like **you**. We're glad you're interested in helping out. There are several different ways you can do it, but before we talk about that, let's talk about how to get started. + +## First Things First + +1. **When in doubt, open an issue** - For almost any type of contribution, the first step is opening an issue. Even if you think you already know what the solution is, writing down a description of the problem you're trying to solve will help everyone get context when they review your pull request. If it's truly a trivial change (e.g. spelling error), you can skip this step -- but as the subject says, when it doubt, [open an issue](https://github.com/opensearch-project/opensearch-go/issues/new/choose). + +2. **Only submit your own work** (or work you have sufficient rights to submit) - Please make sure that any code or documentation you submit is your work or you have the rights to submit. We respect the intellectual property rights of others, and as part of contributing, we'll ask you to sign your contribution with a "Developer Certificate of Origin" (DCO) that states you have the rights to submit this work and you understand we'll use your contribution. There's more information about this topic in the [DCO section](#developer-certificate-of-origin). + +## Ways to Contribute + +### Bug Reports + +Ugh! Bugs! + +A bug is when software behaves in a way that you didn't expect and the developer didn't intend. To help us understand what's going on, we first want to make sure you're working from the latest version. + +Once you've confirmed that the bug still exists in the latest version, you'll want to check to make sure it's not something we already know about on the [open issues GitHub page](https://github.com/opensearch-project/opensearch-go/issues/new/choose). + +If you've upgraded to the latest version and you can't find it in our open issues list, then you'll need to tell us how to reproduce it Provide as much information as you can. You may think that the problem lies with your query, when actually it depends on how your data is indexed. The easier it is for us to recreate your problem, the faster it is likely to be fixed. + +### Feature Requests + +If you've thought of a way that OpenSearch could be better, we want to hear about it. We track feature requests using GitHub, so please feel free to open an issue which describes the feature you would like to see, why you need it, and how it should work. + + +### Contributing Code + +As with other types of contributions, the first step is to [open an issue on GitHub](https://github.com/opensearch-project/opensearch-go/issues/new/choose). Opening an issue before you make changes makes sure that someone else isn't already working on that particular problem. It also lets us all work together to find the right approach before you spend a bunch of time on a PR. So again, when in doubt, open an issue. + +## Developer Certificate of Origin + +OpenSearch is an open source product released under the Apache 2.0 license (see either [the Apache site](https://www.apache.org/licenses/LICENSE-2.0) or the [LICENSE.txt file](LICENSE.txt)). The Apache 2.0 license allows you to freely use, modify, distribute, and sell your own products that include Apache 2.0 licensed software. + +We respect intellectual property rights of others and we want to make sure all incoming contributions are correctly attributed and licensed. A Developer Certificate of Origin (DCO) is a lightweight mechanism to do that. + +The DCO is a declaration attached to every contribution made by every developer. In the commit message of the contribution, the developer simply adds a `Signed-off-by` statement and thereby agrees to the DCO, which you can find below or at [DeveloperCertificate.org](http://developercertificate.org/). + +``` +Developer's Certificate of Origin 1.1 + +By making a contribution to this project, I certify that: + +(a) The contribution was created in whole or in part by me and I + have the right to submit it under the open source license + indicated in the file; or + +(b) The contribution is based upon previous work that, to the + best of my knowledge, is covered under an appropriate open + source license and I have the right under that license to + submit that work with modifications, whether created in whole + or in part by me, under the same open source license (unless + I am permitted to submit under a different license), as + Indicated in the file; or + +(c) The contribution was provided directly to me by some other + person who certified (a), (b) or (c) and I have not modified + it. + +(d) I understand and agree that this project and the contribution + are public and that a record of the contribution (including + all personal information I submit with it, including my + sign-off) is maintained indefinitely and may be redistributed + consistent with this project or the open source license(s) + involved. + ``` + +We require that every contribution to OpenSearch is signed with a Developer Certificate of Origin. Additionally, please use your real name. We do not accept anonymous contributors nor those utilizing pseudonyms. + +Each commit must include a DCO which looks like this + +``` +Signed-off-by: Jane Smith +``` + +You may type this line on your own when writing your commit messages. However, if your user.name and user.email are set in your git configs, you can use `-s` or `– – signoff` to add the `Signed-off-by` line to the end of the commit message. + +## Review Process + +We deeply appreciate everyone who takes the time to make a contribution. We will review all contributions as quickly as possible. As a reminder, [opening an issue](https://github.com/opensearch-project/opensearch-go/issues/new/choose) discussing your change before you make it is the best way to smooth the PR process. This will prevent a rejection because someone else is already working on the problem, or because the solution is incompatible with the architectural direction. + +During the PR process, expect that there will be some back-and-forth. Please try to respond to comments in a timely fashion, and if you don't wish to continue with the PR, let us know. If a PR takes too many iterations for its complexity or size, we may reject it. Additionally, if you stop responding we may close the PR as abandoned. In either case, if you feel this was done in error, please add a comment on the PR. + +If we accept the PR, a [maintainer](MAINTAINERS.md) will merge your change and usually take care of backporting it to appropriate branches ourselves. + +If we reject the PR, we will close the pull request with a comment explaining why. This decision isn't always final: if you feel we have misunderstood your intended change or otherwise think that we should reconsider then please continue the conversation with a comment on the PR and we'll do our best to address any further points you raise. diff --git a/vendor/github.com/opensearch-project/opensearch-go/DEVELOPER_GUIDE.md b/vendor/github.com/opensearch-project/opensearch-go/DEVELOPER_GUIDE.md new file mode 100644 index 000000000..ac87c8840 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/DEVELOPER_GUIDE.md @@ -0,0 +1,65 @@ +# Developer Guide + +So you want to contribute code to the OpenSearch Go Client? Excellent! We're glad you're here. Here's what you need to do: + +## Getting Started + +### Git Clone OpenSearch Go Client Repository + +Fork [opensearch-project/opensearch-go](https://github.com/opensearch-project/opensearch-go) and clone locally, +e.g. `git clone https://github.com/[your username]/opensearch-go.git`. + +### Install Prerequisites + +#### Go 1.11 +OpenSearch Go Client builds using [Go](https://golang.org/doc/install) 1.11 at a minimum. + +#### Docker + +[Docker](https://docs.docker.com/install/) is required for building some OpenSearch artifacts and executing integration tests. + +### Unit Testing +Go has a simple tool for running tests, and we simplified it further by creating this make command: + ``` +make test-unit +``` + +Individual unit tests can be run with the following command: +``` +cd folder-path/to/test; +go test -v -run TestName; +``` + +### Integration Testing +In order to test opensearch-go client, you need a running OpenSearch cluster. You can use Docker to accomplish this. +The [Docker Compose file](.ci/opensearch/docker-compose.yml) supports the ability to run integration tests for the project in local environments. +If you have not installed docker-compose, you can install it from this [link](https://docs.docker.com/compose/install/). + +In order to differentiate unit tests from integration tests, Go has a built-in mechanism for allowing you to logically separate your tests +with [build tags](https://pkg.go.dev/cmd/go#hdr-Build_constraints). The build tag needs to be placed as close to the top of the file as possible, and must have a blank line beneath it. +Hence, create all integration tests with build tag 'integration'. + +#### Execute integration tests from your terminal +1. Run below command to start containers. By default, it will launch latest OpenSearch cluster. + ``` + make cluster.opensearch.build cluster.opensearch.start + ``` +2. Run all integration tests. + ``` + make test-integ race=true + ``` +3. Stop and clean containers. + ``` + make cluster.opensearch.stop cluster.clean + ``` +## Use an Editor + +### GoLand +You can import the OpenSearch project into GoLand as follows: + +1. Select **File | Open** +2. In the subsequent dialog navigate to the ~/go/src/opensearch-go and click **Open** + +After you have opened your project, you need to specify the location of the Go SDK. +You can either specify a local path to the SDK or download it. To set the Go SDK, navigate to **Go | GOROOT** and +set accordingly. diff --git a/vendor/github.com/opensearch-project/opensearch-go/LICENSE.txt b/vendor/github.com/opensearch-project/opensearch-go/LICENSE.txt new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/LICENSE.txt @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/opensearch-project/opensearch-go/MAINTAINERS.md b/vendor/github.com/opensearch-project/opensearch-go/MAINTAINERS.md new file mode 100644 index 000000000..98cfaddec --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/MAINTAINERS.md @@ -0,0 +1,70 @@ +- [Overview](#overview) +- [Current Maintainers](#current-maintainers) +- [Maintainer Responsibilities](#maintainer-responsibilities) + - [Uphold Code of Conduct](#uphold-code-of-conduct) + - [Prioritize Security](#prioritize-security) + - [Review Pull Requests](#review-pull-requests) + - [Triage Open Issues](#triage-open-issues) + - [Be Responsive](#be-responsive) + - [Maintain Overall Health of the Repo](#maintain-overall-health-of-the-repo) + - [Use Semver](#use-semver) + - [Release Frequently](#release-frequently) + - [Promote Other Maintainers](#promote-other-maintainers) + +## Overview + +This document explains who the maintainers are (see below), what they do in this repo, and how they should be doing it. If you're interested in contributing, see [CONTRIBUTING](CONTRIBUTING.md). + +## Current Maintainers + +| Maintainer | GitHub ID | Affiliation | +| ------------------------ | --------------------------------------- | ----------- | +| Jack Mazanec | [jmazanec15](https://github.com/jmazanec15) | Amazon | +| Vamshi Vijay Nakkirtha | [vamshin](https://github.com/vamshin) | Amazon | +| Vijayan Balasubramanian | [VijayanB](https://github.com/VijayanB) | Amazon | + +## Maintainer Responsibilities + +Maintainers are active and visible members of the community, and have [maintain-level permissions on a repository](https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-permission-levels-for-an-organization). Use those privileges to serve the community and evolve code as follows. + +### Uphold Code of Conduct + +Model the behavior set forward by the [Code of Conduct](CODE_OF_CONDUCT.md) and raise any violations to other maintainers and admins. + +### Prioritize Security + +Security is your number one priority. Maintainer's Github keys must be password protected securely and any reported security vulnerabilities are addressed before features or bugs. + +Note that this repository is monitored and supported 24/7 by Amazon Security, see [Reporting a Vulnerability](SECURITY.md) for details. + +### Review Pull Requests + +Review pull requests regularly, comment, suggest, reject, merge and close. Accept only high quality pull-requests. Provide code reviews and guidance on incomming pull requests. Don't let PRs be stale and do your best to be helpful to contributors. + +### Triage Open Issues + +Manage labels, review issues regularly, and triage by labelling them. + +All repositories in this organization have a standard set of labels, including `bug`, `documentation`, `duplicate`, `enhancement`, `good first issue`, `help wanted`, `blocker`, `invalid`, `question`, `wontfix`, and `untriaged`, along with release labels, such as `v1.0.0`, `v1.1.0` and `v2.0.0`, and `backport`. + +Use labels to target an issue or a PR for a given release, add `help wanted` to good issues for new community members, and `blocker` for issues that scare you or need immediate attention. Request for more information from a submitter if an issue is not clear. Create new labels as needed by the project. + +### Be Responsive + +Respond to enhancement requests, and forum posts. Allocate time to reviewing and commenting on issues and conversations as they come in. + +### Maintain Overall Health of the Repo + +Keep the `main` branch at production quality at all times. Backport features as needed. Cut release branches and tags to enable future patches. + +### Use Semver + +Use and enforce [semantic versioning](https://semver.org/) and do not let breaking changes be made outside of major releases. + +### Release Frequently + +Make frequent project releases to the community. + +### Promote Other Maintainers + +Assist, add, and remove [MAINTAINERS](MAINTAINERS.md). Exercise good judgement, and propose high quality contributors to become co-maintainers. diff --git a/vendor/github.com/opensearch-project/opensearch-go/Makefile b/vendor/github.com/opensearch-project/opensearch-go/Makefile new file mode 100644 index 000000000..ce3d06af9 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/Makefile @@ -0,0 +1,212 @@ +SHELL := /bin/bash + +##@ Format project using goimports tool +format: + goimports -w .; + +##@ Test +test-unit: ## Run unit tests + @printf "\033[2m→ Running unit tests...\033[0m\n" +ifdef race + $(eval testunitargs += "-race") +endif + $(eval testunitargs += "-cover" "-coverprofile=tmp/unit.cov" "./...") + @mkdir -p tmp + @if which gotestsum > /dev/null 2>&1 ; then \ + echo "gotestsum --format=short-verbose --junitfile=tmp/unit-report.xml --" $(testunitargs); \ + gotestsum --format=short-verbose --junitfile=tmp/unit-report.xml -- $(testunitargs); \ + else \ + echo "go test -v" $(testunitargs); \ + go test -v $(testunitargs); \ + fi; +test: test-unit + +test-integ: ## Run integration tests + @printf "\033[2m→ Running integration tests...\033[0m\n" + $(eval testintegtags += "integration") +ifdef multinode + $(eval testintegtags += "multinode") +endif +ifdef race + $(eval testintegargs += "-race") +endif + $(eval testintegargs += "-cover" "-coverprofile=tmp/integration-client.cov" "-tags='$(testintegtags)'" "-timeout=1h") + @mkdir -p tmp + @if which gotestsum > /dev/null 2>&1 ; then \ + echo "gotestsum --format=short-verbose --junitfile=tmp/integration-report.xml --" $(testintegargs); \ + gotestsum --format=short-verbose --junitfile=tmp/integration-report.xml -- $(testintegargs) "."; \ + gotestsum --format=short-verbose --junitfile=tmp/integration-report.xml -- $(testintegargs) "./opensearchtransport" "./opensearchapi" "./opensearchutil"; \ + else \ + echo "go test -v" $(testintegargs) "."; \ + go test -v $(testintegargs) "./opensearchtransport" "./opensearchapi" "./opensearchutil"; \ + fi; + +test-integ-secure: ##Run secure integration tests + go test -tags=secure,integration ./opensearch_secure_integration_test.go + +test-bench: ## Run benchmarks + @printf "\033[2m→ Running benchmarks...\033[0m\n" + go test -run=none -bench=. -benchmem ./... + +test-coverage: ## Generate test coverage report + @printf "\033[2m→ Generating test coverage report...\033[0m\n" + @go tool cover -html=tmp/unit.cov -o tmp/coverage.html + @go tool cover -func=tmp/unit.cov | 'grep' -v 'opensearchapi/api\.' | sed 's/github.com\/opensearch-project\/opensearch-go\///g' + @printf "\033[0m--------------------------------------------------------------------------------\nopen tmp/coverage.html\n\n\033[0m" + +##@ Development +lint: ## Run lint on the package + @printf "\033[2m→ Running lint...\033[0m\n" + go vet github.com/opensearch-project/opensearch-go/... + go list github.com/opensearch-project/opensearch-go/... | 'grep' -v internal | xargs golint -set_exit_status + @{ \ + set -e ; \ + trap "test -d ../../../.git && git checkout --quiet go.mod" INT TERM EXIT; \ + echo "cd internal/build/ && go vet ./..."; \ + cd "internal/build/" && go mod tidy && go mod download && go vet ./...; \ + } + + +backport: ## Backport one or more commits from master into version branches +ifeq ($(origin commits), undefined) + @echo "Missing commit(s), exiting..." + @exit 2 +endif +ifndef branches + $(eval branches_list = '1.x') +else + $(eval branches_list = $(shell echo $(branches) | tr ',' ' ') ) +endif + $(eval commits_list = $(shell echo $(commits) | tr ',' ' ')) + @printf "\033[2m→ Backporting commits [$(commits)]\033[0m\n" + @{ \ + set -e -o pipefail; \ + for commit in $(commits_list); do \ + git show --pretty='%h | %s' --no-patch $$commit; \ + done; \ + echo ""; \ + for branch in $(branches_list); do \ + printf "\033[2m→ $$branch\033[0m\n"; \ + git checkout $$branch; \ + for commit in $(commits_list); do \ + git cherry-pick -x $$commit; \ + done; \ + git status --short --branch; \ + echo ""; \ + done; \ + printf "\033[2m→ Push updates to Github:\033[0m\n"; \ + for branch in $(branches_list); do \ + echo "git push --verbose origin $$branch"; \ + done; \ + } + +release: ## Release a new version to Github + $(eval branch = $(shell git rev-parse --abbrev-ref HEAD)) + $(eval current_version = $(shell cat internal/version/version.go | sed -Ee 's/const Client = "(.*)"/\1/' | tail -1)) + @printf "\033[2m→ [$(branch)] Current version: $(current_version)...\033[0m\n" +ifndef version + @printf "\033[31m[!] Missing version argument, exiting...\033[0m\n" + @exit 2 +endif +ifeq ($(version), "") + @printf "\033[31m[!] Empty version argument, exiting...\033[0m\n" + @exit 2 +endif + @printf "\033[2m→ [$(branch)] Creating version $(version)...\033[0m\n" + @{ \ + set -e -o pipefail; \ + cp internal/version/version.go internal/version/version.go.OLD && \ + cat internal/version/version.go.OLD | sed -e 's/Client = ".*"/Client = "$(version)"/' > internal/version/version.go && \ + go vet internal/version/version.go && \ + go fmt internal/version/version.go && \ + git diff --color-words internal/version/version.go | tail -n 1; \ + } + @{ \ + set -e -o pipefail; \ + printf "\033[2m→ Commit and create Git tag? (y/n): \033[0m\c"; \ + read continue; \ + if [[ $$continue == "y" ]]; then \ + git add internal/version/version.go && \ + git commit --no-status --quiet --message "Release $(version)" && \ + git tag --annotate v$(version) --message 'Release $(version)'; \ + printf "\033[2m→ Push `git show --pretty='%h (%s)' --no-patch HEAD` to Github:\033[0m\n\n"; \ + printf "\033[1m git push origin HEAD && git push origin v$(version)\033[0m\n\n"; \ + mv internal/version/version.go.OLD internal/version/version.go && \ + git add internal/version/version.go && \ + original_version=`cat internal/version/version.go | sed -ne 's;^const Client = "\(.*\)"$$;\1;p'` && \ + git commit --no-status --quiet --message "Update version to $$original_version"; \ + printf "\033[2m→ Version updated to [$$original_version].\033[0m\n\n"; \ + else \ + echo "Aborting..."; \ + rm internal/version/version.go.OLD; \ + exit 1; \ + fi; \ + } + +godoc: ## Display documentation for the package + @printf "\033[2m→ Generating documentation...\033[0m\n" + @echo "* http://localhost:6060/pkg/github.com/opensearch-project/opensearch-go" + @echo "* http://localhost:6060/pkg/github.com/opensearch-project/opensearch-go/opensearchapi" + @echo "* http://localhost:6060/pkg/github.com/opensearch-project/opensearch-go/opensearchtransport" + @echo "* http://localhost:6060/pkg/github.com/opensearch-project/opensearch-go/opensearchutil" + @printf "\n" + godoc --http=localhost:6060 --play + +cluster.opendistro.build: + docker-compose --project-directory .ci/opendistro build; + +cluster.opendistro.start: + docker-compose --project-directory .ci/opendistro up -d ; + sleep 20; + +cluster.opendistro.stop: + docker-compose --project-directory .ci/opendistro down ; + +cluster.opensearch.build: + docker-compose --project-directory .ci/opensearch build; + +cluster.opensearch.start: + docker-compose --project-directory .ci/opensearch up -d ; + sleep 20; + +cluster.opensearch.stop: + docker-compose --project-directory .ci/opensearch down ; + + +cluster.clean: ## Remove unused Docker volumes and networks + @printf "\033[2m→ Cleaning up Docker assets...\033[0m\n" + docker volume prune --force + docker network prune --force + docker system prune --volumes --force + + + + +workflow: ## Run all github workflow commands here sequentially + +# Lint + make lint +# License Checker + .github/check-license-headers.sh +# Unit Test + make test-unit race=true +# Benchmarks Test + make test-bench +# Integration Test +### OpenDistro + make cluster.clean cluster.opendistro.build cluster.opendistro.start + make test-integ race=true + make cluster.opendistro.stop +### OpenSearch + make cluster.clean cluster.opensearch.build cluster.opensearch.start + make test-integ race=true + make cluster.opensearch.stop + +##@ Other +#------------------------------------------------------------------------------ +help: ## Display help + @awk 'BEGIN {FS = ":.*##"; printf "Usage:\n make \033[36m\033[0m\n"} /^[a-zA-Z_-]+:.*?##/ { printf " \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST) +#------------- -------------- + +.DEFAULT_GOAL := help +.PHONY: help backport cluster cluster.opendistro.build cluster.opendistro.start cluster.opendistro.stop cluster.clean coverage godoc lint release test test-bench test-integ test-unit diff --git a/vendor/github.com/opensearch-project/opensearch-go/NOTICE.txt b/vendor/github.com/opensearch-project/opensearch-go/NOTICE.txt new file mode 100644 index 000000000..eec263f0c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/NOTICE.txt @@ -0,0 +1,8 @@ +OpenSearch (https://opensearch.org/) +Copyright 2021 OpenSearch Contributors + +This product includes software developed by +Elasticsearch (http://www.elastic.co). + +This product includes software developed by The Apache Software +Foundation (http://www.apache.org/). \ No newline at end of file diff --git a/vendor/github.com/opensearch-project/opensearch-go/OpenSearch.svg b/vendor/github.com/opensearch-project/opensearch-go/OpenSearch.svg new file mode 100644 index 000000000..bd4ae0fe8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/OpenSearch.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/vendor/github.com/opensearch-project/opensearch-go/README.md b/vendor/github.com/opensearch-project/opensearch-go/README.md new file mode 100644 index 000000000..16560d445 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/README.md @@ -0,0 +1,47 @@ +[![Go Reference](https://pkg.go.dev/badge/github.com/opensearch-project/opensearch-go.svg)](https://pkg.go.dev/github.com/opensearch-project/opensearch-go) +[![Build](https://github.com/opensearch-project/opensearch-go/actions/workflows/build.yml/badge.svg)](https://github.com/opensearch-project/opensearch-go/actions/workflows/build.yml) +[![Unit](https://github.com/opensearch-project/opensearch-go/actions/workflows/test-unit.yml/badge.svg)](https://github.com/opensearch-project/opensearch-go/actions/workflows/test-unit.yml) +[![Integration](https://github.com/opensearch-project/opensearch-go/actions/workflows/test-integration.yml/badge.svg)](https://github.com/opensearch-project/opensearch-go/actions/workflows/test-integration.yml) +[![codecov](https://codecov.io/gh/opensearch-project/opensearch-go/branch/main/graph/badge.svg?token=MI9g3KYHVx)](https://codecov.io/gh/opensearch-project/opensearch-go) +[![Chat](https://img.shields.io/badge/chat-on%20forums-blue)](https://discuss.opendistrocommunity.dev/c/clients/) +![PRs welcome!](https://img.shields.io/badge/PRs-welcome!-success) + +![OpenSearch logo](OpenSearch.svg) + +OpenSearch Go Client + +- [Welcome!](#welcome) +- [Project Resources](#project-resources) +- [Code of Conduct](#code-of-conduct) +- [License](#license) +- [Copyright](#copyright) + +## Welcome! + +**opensearch-go** is [a community-driven, open source fork](https://aws.amazon.com/blogs/opensource/introducing-opensearch/) of go-elasticsearch licensed under the [Apache v2.0 License](LICENSE.txt). For more information, see [opensearch.org](https://opensearch.org/). + +## Project Resources + +* [Project Website](https://opensearch.org/) +* [Developer Guide](DEVELOPER_GUIDE.md) +* [User Guide](USER_GUIDE.md) +* [Documentation](https://opensearch.org/docs/) +* Need help? Try [Forums](https://discuss.opendistrocommunity.dev/c/clients/) +* [Project Principles](https://opensearch.org/#principles) +* [Contributing to OpenSearch](CONTRIBUTING.md) +* [Maintainer Responsibilities](MAINTAINERS.md) +* [Release Management](RELEASING.md) +* [Admin Responsibilities](ADMINS.md) +* [Security](SECURITY.md) + +## Code of Conduct + +This project has adopted the [Amazon Open Source Code of Conduct](CODE_OF_CONDUCT.md). For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq), or contact [opensource-codeofconduct@amazon.com](mailto:opensource-codeofconduct@amazon.com) with any additional questions or comments. + +## License + +This project is licensed under the [Apache v2.0 License](LICENSE.txt). + +## Copyright + +Copyright OpenSearch Contributors. See [NOTICE](NOTICE.txt) for details. diff --git a/vendor/github.com/opensearch-project/opensearch-go/RELEASING.md b/vendor/github.com/opensearch-project/opensearch-go/RELEASING.md new file mode 100644 index 000000000..674cc2116 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/RELEASING.md @@ -0,0 +1,34 @@ +- [Overview](#overview) +- [Branching](#branching) + - [Release Branching](#release-branching) + - [Feature Branches](#feature-branches) +- [Release Labels](#release-labels) +- [Releasing](#releasing) + +## Overview + +This document explains the release strategy for artifacts in this organization. + +## Branching + +### Release Branching + +Given the current major release of 1.0, projects in this organization maintain the following active branches. + +* **main**: The next _major_ release. This is the branch where all merges take place and code moves fast. +* **1.x**: The next _minor_ release. Once a change is merged into `main`, decide whether to backport it to `1.x`. +* **1.0**: The _current_ release. In between minor releases, only hotfixes (e.g. security) are backported to `1.0`. + +Label PRs with the next major version label (e.g. `2.0.0`) and merge changes into `main`. Label PRs that you believe need to be backported as `1.x` and `1.0`. Backport PRs by checking out the versioned branch, cherry-pick changes and open a PR against each target backport branch. + +### Feature Branches + +Do not creating branches in the upstream repo, use your fork, for the exception of long lasting feature branches that require active collaboration from multiple developers. Name feature branches `feature/`. Once the work is merged to `main`, please make sure to delete the feature branch. + +## Release Labels + +Repositories create consistent release labels, such as `v1.0.0`, `v1.1.0` and `v2.0.0`, as well as `patch` and `backport`. Use release labels to target an issue or a PR for a given release. See [MAINTAINERS](MAINTAINERS.md#triage-open-issues) for more information on triaging issues. + +## Releasing + +The release process is standard across repositories in this org and is run by a release manager volunteering from amongst [MAINTAINERS](MAINTAINERS.md). diff --git a/vendor/github.com/opensearch-project/opensearch-go/SECURITY.md b/vendor/github.com/opensearch-project/opensearch-go/SECURITY.md new file mode 100644 index 000000000..0b85ca04e --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/SECURITY.md @@ -0,0 +1,3 @@ +## Reporting a Vulnerability + +If you discover a potential security issue in this project we ask that you notify AWS/Amazon Security via our [vulnerability reporting page](http://aws.amazon.com/security/vulnerability-reporting/) or directly via email to aws-security@amazon.com. Please do **not** create a public GitHub issue. \ No newline at end of file diff --git a/vendor/github.com/opensearch-project/opensearch-go/USER_GUIDE.md b/vendor/github.com/opensearch-project/opensearch-go/USER_GUIDE.md new file mode 100644 index 000000000..c406098e8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/USER_GUIDE.md @@ -0,0 +1,127 @@ +# User Guide + +## Example +In the example below, we create a client, an index with non-default settings, insert a document to the index, +search for the document, delete the document and finally delete the index. + +```go +package main + +import ( + "os" + "context" + "crypto/tls" + "fmt" + opensearch "github.com/opensearch-project/opensearch-go" + opensearchapi "github.com/opensearch-project/opensearch-go/opensearchapi" + "net/http" + "strings" +) + +const IndexName = "go-test-index1" + +func main() { + + // Initialize the client with SSL/TLS enabled. + client, err := opensearch.NewClient(opensearch.Config{ + Transport: &http.Transport{ + TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // For testing only. Use certificate for validation. + }, + Addresses: []string{"https://localhost:9200"}, + Username: "admin", // For testing only. Don't store credentials in code. + Password: "admin", + }) + if err != nil { + fmt.Println("cannot initialize", err) + os.Exit(1) + } + + // Print OpenSearch version information on console. + fmt.Println(client.Info()) + + // Define index mapping. + mapping := strings.NewReader(`{ + 'settings': { + 'index': { + 'number_of_shards': 4 + } + } + }`) + + // Create an index with non-default settings. + res := opensearchapi.CreateRequest{ + Index: IndexName, + Body: mapping, + } + fmt.Println("creating index", res) + + // Add a document to the index. + document := strings.NewReader(`{ + "title": "Moneyball", + "director": "Bennett Miller", + "year": "2011" + }`) + + docId := "1" + req := opensearchapi.IndexRequest{ + Index: IndexName, + DocumentID: docId, + Body: document, + } + insertResponse, err := req.Do(context.Background(), client) + if err != nil { + fmt.Println("failed to insert document ", err) + os.Exit(1) + } + fmt.Println(insertResponse) + + // Search for the document. + content := strings.NewReader(`{ + "size": 5, + "query": { + "multi_match": { + "query": "miller", + "fields": ["title^2", "director"] + } + } + }`) + + search := opensearchapi.SearchRequest{ + Body: content, + } + + searchResponse, err := search.Do(context.Background(), client) + if err != nil { + fmt.Println("failed to search document ", err) + os.Exit(1) + } + fmt.Println(searchResponse) + + // Delete the document. + delete := opensearchapi.DeleteRequest{ + Index: IndexName, + DocumentID: docId, + } + + deleteResponse, err := delete.Do(context.Background(), client) + if err != nil { + fmt.Println("failed to delete document ", err) + os.Exit(1) + } + fmt.Println("deleting document") + fmt.Println(deleteResponse) + + // Delete previously created index. + deleteIndex := opensearchapi.IndicesDeleteRequest{ + Index: []string{IndexName}, + } + + deleteIndexResponse, err := deleteIndex.Do(context.Background(), client) + if err != nil { + fmt.Println("failed to delete index ", err) + os.Exit(1) + } + fmt.Println("deleting index", deleteIndexResponse) +} + +``` \ No newline at end of file diff --git a/vendor/github.com/opensearch-project/opensearch-go/doc.go b/vendor/github.com/opensearch-project/opensearch-go/doc.go new file mode 100644 index 000000000..c6c44dcf7 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/doc.go @@ -0,0 +1,74 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to opensearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +/* +Package opensearch provides a Go client for OpenSearch. + +Create the client with the NewDefaultClient function: + + opensearch.NewDefaultClient() + +The OPENSEARCH_URL/ELASTICSEARCH_URL environment variable is used instead of the default URL, when set. +Use a comma to separate multiple URLs. +It is an error to set both environment variable. + +To configure the client, pass a Config object to the NewClient function: + + cfg := opensearch.Config{ + Addresses: []string{ + "http://localhost:9200", + "http://localhost:9201", + }, + Username: "foo", + Password: "bar", + Transport: &http.Transport{ + MaxIdleConnsPerHost: 10, + ResponseHeaderTimeout: time.Second, + DialContext: (&net.Dialer{Timeout: time.Second}).DialContext, + TLSClientConfig: &tls.Config{ + MinVersion: tls.VersionTLS11, + }, + }, + } + + opensearch.NewClient(cfg) + +See the opensearch_integration_test.go file for more information. + +Call the OpenSearch APIs by invoking the corresponding methods on the client: + + res, err := client.Info() + if err != nil { + log.Fatalf("Error getting response: %s", err) + } + + log.Println(res) + +See the github.com/opensearch-project/opensearch-go/opensearchapi package for more information about using the API. + +See the github.com/opensearch-project/opensearch-go/opensearchtransport package for more information about configuring the transport. +*/ +package opensearch diff --git a/vendor/github.com/opensearch-project/opensearch-go/internal/version/version.go b/vendor/github.com/opensearch-project/opensearch-go/internal/version/version.go new file mode 100644 index 000000000..f63775c28 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/internal/version/version.go @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package version + +// Client returns the client version as a string. +// +const Client = "1.0.0" diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearch.go b/vendor/github.com/opensearch-project/opensearch-go/opensearch.go new file mode 100644 index 000000000..cb6e733b3 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearch.go @@ -0,0 +1,402 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearch + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "io" + "io/ioutil" + "net/http" + "net/url" + "os" + "regexp" + "strconv" + "strings" + "sync" + "time" + + "github.com/opensearch-project/opensearch-go/signer" + + "github.com/opensearch-project/opensearch-go/internal/version" + "github.com/opensearch-project/opensearch-go/opensearchapi" + "github.com/opensearch-project/opensearch-go/opensearchtransport" +) + +var ( + reVersion *regexp.Regexp +) + +func init() { + versionPattern := `^([0-9]+)\.([0-9]+)\.([0-9]+)` + reVersion = regexp.MustCompile(versionPattern) +} + +const ( + defaultURL = "http://localhost:9200" + openSearch = "opensearch" + unsupportedProduct = "the client noticed that the server is not a supported distribution" + envOpenSearchURL = "OPENSEARCH_URL" + envElasticsearchURL = "ELASTICSEARCH_URL" +) + +// Version returns the package version as a string. +// +const Version = version.Client + +// Config represents the client configuration. +// +type Config struct { + Addresses []string // A list of nodes to use. + Username string // Username for HTTP Basic Authentication. + Password string // Password for HTTP Basic Authentication. + + Header http.Header // Global HTTP request header. + + Signer signer.Signer + + // PEM-encoded certificate authorities. + // When set, an empty certificate pool will be created, and the certificates will be appended to it. + // The option is only valid when the transport is not specified, or when it's http.Transport. + CACert []byte + + RetryOnStatus []int // List of status codes for retry. Default: 502, 503, 504. + DisableRetry bool // Default: false. + EnableRetryOnTimeout bool // Default: false. + MaxRetries int // Default: 3. + + CompressRequestBody bool // Default: false. + + DiscoverNodesOnStart bool // Discover nodes when initializing the client. Default: false. + DiscoverNodesInterval time.Duration // Discover nodes periodically. Default: disabled. + + EnableMetrics bool // Enable the metrics collection. + EnableDebugLogger bool // Enable the debug logging. + + UseResponseCheckOnly bool + + RetryBackoff func(attempt int) time.Duration // Optional backoff duration. Default: nil. + + Transport http.RoundTripper // The HTTP transport object. + Logger opensearchtransport.Logger // The logger object. + Selector opensearchtransport.Selector // The selector object. + + // Optional constructor function for a custom ConnectionPool. Default: nil. + ConnectionPoolFunc func([]*opensearchtransport.Connection, opensearchtransport.Selector) opensearchtransport.ConnectionPool +} + +// Client represents the OpenSearch client. +// +type Client struct { + *opensearchapi.API // Embeds the API methods + Transport opensearchtransport.Interface + useResponseCheckOnly bool + + productCheckMu sync.RWMutex + productCheckSuccess bool +} + +type esVersion struct { + Number string `json:"number"` + BuildFlavor string `json:"build_flavor"` + Distribution string `json:"distribution"` +} + +type info struct { + Version esVersion `json:"version"` + Tagline string `json:"tagline"` +} + +// NewDefaultClient creates a new client with default options. +// +// It will use http://localhost:9200 as the default address. +// +// It will use the OPENSEARCH_URL/ELASTICSEARCH_URL environment variable, if set, +// to configure the addresses; use a comma to separate multiple URLs. +// +// It's an error to set both OPENSEARCH_URL and ELASTICSEARCH_URL. +// +func NewDefaultClient() (*Client, error) { + return NewClient(Config{}) +} + +// NewClient creates a new client with configuration from cfg. +// +// It will use http://localhost:9200 as the default address. +// +// It will use the OPENSEARCH_URL/ELASTICSEARCH_URL environment variable, if set, +// to configure the addresses; use a comma to separate multiple URLs. +// +// It's an error to set both OPENSEARCH_URL and ELASTICSEARCH_URL. +// +func NewClient(cfg Config) (*Client, error) { + var addrs []string + + if len(cfg.Addresses) == 0 { + envAddress, err := getAddressFromEnvironment() + if err != nil { + return nil, err + } + addrs = envAddress + } else { + addrs = append(addrs, cfg.Addresses...) + } + + urls, err := addrsToURLs(addrs) + if err != nil { + return nil, fmt.Errorf("cannot create client: %s", err) + } + + if len(urls) == 0 { + u, _ := url.Parse(defaultURL) // errcheck exclude + urls = append(urls, u) + } + + // TODO: Refactor + if urls[0].User != nil { + cfg.Username = urls[0].User.Username() + pw, _ := urls[0].User.Password() + cfg.Password = pw + } + + tp, err := opensearchtransport.New(opensearchtransport.Config{ + URLs: urls, + Username: cfg.Username, + Password: cfg.Password, + + Header: cfg.Header, + CACert: cfg.CACert, + + Signer: cfg.Signer, + + RetryOnStatus: cfg.RetryOnStatus, + DisableRetry: cfg.DisableRetry, + EnableRetryOnTimeout: cfg.EnableRetryOnTimeout, + MaxRetries: cfg.MaxRetries, + RetryBackoff: cfg.RetryBackoff, + + CompressRequestBody: cfg.CompressRequestBody, + + EnableMetrics: cfg.EnableMetrics, + EnableDebugLogger: cfg.EnableDebugLogger, + + DiscoverNodesInterval: cfg.DiscoverNodesInterval, + + Transport: cfg.Transport, + Logger: cfg.Logger, + Selector: cfg.Selector, + ConnectionPoolFunc: cfg.ConnectionPoolFunc, + }) + if err != nil { + return nil, fmt.Errorf("error creating transport: %s", err) + } + + client := &Client{Transport: tp, useResponseCheckOnly: cfg.UseResponseCheckOnly} + client.API = opensearchapi.New(client) + + if cfg.DiscoverNodesOnStart { + go client.DiscoverNodes() + } + + return client, err +} + +func getAddressFromEnvironment() ([]string, error) { + fromOpenSearchEnv := addrsFromEnvironment(envOpenSearchURL) + fromElasticsearchEnv := addrsFromEnvironment(envElasticsearchURL) + + if len(fromElasticsearchEnv) > 0 && len(fromOpenSearchEnv) > 0 { + return nil, fmt.Errorf("cannot create client: both %s and %s are set", envOpenSearchURL, envElasticsearchURL) + } + if len(fromOpenSearchEnv) > 0 { + return fromOpenSearchEnv, nil + } + return fromElasticsearchEnv, nil +} + +// checkCompatibleInfo validates the information given by OpenSearch +// +func checkCompatibleInfo(info info) error { + major, _, _, err := ParseVersion(info.Version.Number) + if err != nil { + return err + } + if info.Version.Distribution == openSearch { + return nil + } + if major != 7 { + return errors.New(unsupportedProduct) + } + return nil +} + +// ParseVersion returns an int64 representation of version. +// +func ParseVersion(version string) (int64, int64, int64, error) { + matches := reVersion.FindStringSubmatch(version) + + if len(matches) < 4 { + return 0, 0, 0, fmt.Errorf("") + } + major, _ := strconv.ParseInt(matches[1], 10, 0) + minor, _ := strconv.ParseInt(matches[2], 10, 0) + patch, _ := strconv.ParseInt(matches[3], 10, 0) + + return major, minor, patch, nil +} + +// Perform delegates to Transport to execute a request and return a response. +// +func (c *Client) Perform(req *http.Request) (*http.Response, error) { + if !c.useResponseCheckOnly { + // Launch product check, request info, check header then payload. + if err := c.doProductCheck(c.productCheck); err != nil { + return nil, err + } + } + + // Retrieve the original request. + return c.Transport.Perform(req) +} + +// doProductCheck calls f if there as not been a prior successful call to doProductCheck, +// returning nil otherwise. +func (c *Client) doProductCheck(f func() error) error { + c.productCheckMu.RLock() + productCheckSuccess := c.productCheckSuccess + c.productCheckMu.RUnlock() + + if productCheckSuccess { + return nil + } + + c.productCheckMu.Lock() + defer c.productCheckMu.Unlock() + + if c.productCheckSuccess { + return nil + } + + if err := f(); err != nil { + return err + } + + c.productCheckSuccess = true + + return nil +} + +// productCheck runs an opensearchapi.Info query to retrieve information of the current cluster +// decodes the response and decides if the cluster can be supported or not. +func (c *Client) productCheck() error { + req := opensearchapi.InfoRequest{} + res, err := req.Do(context.Background(), c.Transport) + if err != nil { + return err + } + defer res.Body.Close() + + if res.IsError() { + _, err = io.Copy(ioutil.Discard, res.Body) + if err != nil { + return err + } + switch res.StatusCode { + case http.StatusUnauthorized: + return nil + case http.StatusForbidden: + return nil + default: + return fmt.Errorf("cannot retrieve information from OpenSearch") + } + } + + var info info + contentType := res.Header.Get("Content-Type") + if strings.Contains(contentType, "json") { + err = json.NewDecoder(res.Body).Decode(&info) + if err != nil { + return fmt.Errorf("error decoding OpenSearch informations: %s", err) + } + } + + if info.Version.Number != "" { + return checkCompatibleInfo(info) + } + return nil +} + +// Metrics returns the client metrics. +// +func (c *Client) Metrics() (opensearchtransport.Metrics, error) { + if mt, ok := c.Transport.(opensearchtransport.Measurable); ok { + return mt.Metrics() + } + return opensearchtransport.Metrics{}, errors.New("transport is missing method Metrics()") +} + +// DiscoverNodes reloads the client connections by fetching information from the cluster. +// +func (c *Client) DiscoverNodes() error { + if dt, ok := c.Transport.(opensearchtransport.Discoverable); ok { + return dt.DiscoverNodes() + } + return errors.New("transport is missing method DiscoverNodes()") +} + +// addrsFromEnvironment returns a list of addresses by splitting +// the given environment variable with comma, or an empty list. +// +func addrsFromEnvironment(name string) []string { + var addrs []string + + if envURLs, ok := os.LookupEnv(name); ok && envURLs != "" { + list := strings.Split(envURLs, ",") + for _, u := range list { + addrs = append(addrs, strings.TrimSpace(u)) + } + } + + return addrs +} + +// addrsToURLs creates a list of url.URL structures from url list. +// +func addrsToURLs(addrs []string) ([]*url.URL, error) { + var urls []*url.URL + for _, addr := range addrs { + u, err := url.Parse(strings.TrimRight(addr, "/")) + if err != nil { + return nil, fmt.Errorf("cannot parse url: %v", err) + } + + urls = append(urls, u) + } + return urls, nil +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api._.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api._.go new file mode 100644 index 000000000..fe37dc9d4 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api._.go @@ -0,0 +1,393 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +// API contains the OpenSearch APIs +// +type API struct { + Cat *Cat + Cluster *Cluster + Indices *Indices + Ingest *Ingest + Nodes *Nodes + Remote *Remote + Snapshot *Snapshot + Tasks *Tasks + + Bulk Bulk + ClearScroll ClearScroll + Count Count + Create Create + DanglingIndicesDeleteDanglingIndex DanglingIndicesDeleteDanglingIndex + DanglingIndicesImportDanglingIndex DanglingIndicesImportDanglingIndex + DanglingIndicesListDanglingIndices DanglingIndicesListDanglingIndices + DeleteByQuery DeleteByQuery + DeleteByQueryRethrottle DeleteByQueryRethrottle + Delete Delete + DeleteScript DeleteScript + Exists Exists + ExistsSource ExistsSource + Explain Explain + FieldCaps FieldCaps + Get Get + GetScriptContext GetScriptContext + GetScriptLanguages GetScriptLanguages + GetScript GetScript + GetSource GetSource + Index Index + Info Info + Mget Mget + Msearch Msearch + MsearchTemplate MsearchTemplate + Mtermvectors Mtermvectors + Ping Ping + PutScript PutScript + RankEval RankEval + Reindex Reindex + ReindexRethrottle ReindexRethrottle + RenderSearchTemplate RenderSearchTemplate + ScriptsPainlessExecute ScriptsPainlessExecute + Scroll Scroll + Search Search + SearchShards SearchShards + SearchTemplate SearchTemplate + TermsEnum TermsEnum + Termvectors Termvectors + UpdateByQuery UpdateByQuery + UpdateByQueryRethrottle UpdateByQueryRethrottle + Update Update +} + +// Cat contains the Cat APIs +type Cat struct { + Aliases CatAliases + Allocation CatAllocation + Count CatCount + Fielddata CatFielddata + Health CatHealth + Help CatHelp + Indices CatIndices + Master CatMaster + Nodeattrs CatNodeattrs + Nodes CatNodes + PendingTasks CatPendingTasks + Plugins CatPlugins + Recovery CatRecovery + Repositories CatRepositories + Segments CatSegments + Shards CatShards + Snapshots CatSnapshots + Tasks CatTasks + Templates CatTemplates + ThreadPool CatThreadPool +} + +// Cluster contains the Cluster APIs +type Cluster struct { + AllocationExplain ClusterAllocationExplain + DeleteComponentTemplate ClusterDeleteComponentTemplate + DeleteVotingConfigExclusions ClusterDeleteVotingConfigExclusions + ExistsComponentTemplate ClusterExistsComponentTemplate + GetComponentTemplate ClusterGetComponentTemplate + GetSettings ClusterGetSettings + Health ClusterHealth + PendingTasks ClusterPendingTasks + PostVotingConfigExclusions ClusterPostVotingConfigExclusions + PutComponentTemplate ClusterPutComponentTemplate + PutSettings ClusterPutSettings + RemoteInfo ClusterRemoteInfo + Reroute ClusterReroute + State ClusterState + Stats ClusterStats +} + +// Indices contains the Indices APIs +type Indices struct { + AddBlock IndicesAddBlock + Analyze IndicesAnalyze + ClearCache IndicesClearCache + Clone IndicesClone + Close IndicesClose + Create IndicesCreate + DeleteAlias IndicesDeleteAlias + DeleteIndexTemplate IndicesDeleteIndexTemplate + Delete IndicesDelete + DeleteTemplate IndicesDeleteTemplate + DiskUsage IndicesDiskUsage + ExistsAlias IndicesExistsAlias + ExistsDocumentType IndicesExistsDocumentType + ExistsIndexTemplate IndicesExistsIndexTemplate + Exists IndicesExists + ExistsTemplate IndicesExistsTemplate + FieldUsageStats IndicesFieldUsageStats + Flush IndicesFlush + FlushSynced IndicesFlushSynced + Forcemerge IndicesForcemerge + GetAlias IndicesGetAlias + GetFieldMapping IndicesGetFieldMapping + GetIndexTemplate IndicesGetIndexTemplate + GetMapping IndicesGetMapping + Get IndicesGet + GetSettings IndicesGetSettings + GetTemplate IndicesGetTemplate + GetUpgrade IndicesGetUpgrade + Open IndicesOpen + PutAlias IndicesPutAlias + PutIndexTemplate IndicesPutIndexTemplate + PutMapping IndicesPutMapping + PutSettings IndicesPutSettings + PutTemplate IndicesPutTemplate + Recovery IndicesRecovery + Refresh IndicesRefresh + ResolveIndex IndicesResolveIndex + Rollover IndicesRollover + Segments IndicesSegments + ShardStores IndicesShardStores + Shrink IndicesShrink + SimulateIndexTemplate IndicesSimulateIndexTemplate + SimulateTemplate IndicesSimulateTemplate + Split IndicesSplit + Stats IndicesStats + UpdateAliases IndicesUpdateAliases + Upgrade IndicesUpgrade + ValidateQuery IndicesValidateQuery +} + +// Ingest contains the Ingest APIs +type Ingest struct { + DeletePipeline IngestDeletePipeline + GetPipeline IngestGetPipeline + ProcessorGrok IngestProcessorGrok + PutPipeline IngestPutPipeline + Simulate IngestSimulate +} + +// Nodes contains the Nodes APIs +type Nodes struct { + HotThreads NodesHotThreads + Info NodesInfo + ReloadSecureSettings NodesReloadSecureSettings + Stats NodesStats + Usage NodesUsage +} + +// Remote contains the Remote APIs +type Remote struct { +} + +// Snapshot contains the Snapshot APIs +type Snapshot struct { + CleanupRepository SnapshotCleanupRepository + Clone SnapshotClone + CreateRepository SnapshotCreateRepository + Create SnapshotCreate + DeleteRepository SnapshotDeleteRepository + Delete SnapshotDelete + GetRepository SnapshotGetRepository + Get SnapshotGet + Restore SnapshotRestore + Status SnapshotStatus + VerifyRepository SnapshotVerifyRepository +} + +// Tasks contains the Tasks APIs +type Tasks struct { + Cancel TasksCancel + Get TasksGet + List TasksList +} + +// New creates new API +// +func New(t Transport) *API { + return &API{ + Bulk: newBulkFunc(t), + ClearScroll: newClearScrollFunc(t), + Count: newCountFunc(t), + Create: newCreateFunc(t), + DanglingIndicesDeleteDanglingIndex: newDanglingIndicesDeleteDanglingIndexFunc(t), + DanglingIndicesImportDanglingIndex: newDanglingIndicesImportDanglingIndexFunc(t), + DanglingIndicesListDanglingIndices: newDanglingIndicesListDanglingIndicesFunc(t), + DeleteByQuery: newDeleteByQueryFunc(t), + DeleteByQueryRethrottle: newDeleteByQueryRethrottleFunc(t), + Delete: newDeleteFunc(t), + DeleteScript: newDeleteScriptFunc(t), + Exists: newExistsFunc(t), + ExistsSource: newExistsSourceFunc(t), + Explain: newExplainFunc(t), + FieldCaps: newFieldCapsFunc(t), + Get: newGetFunc(t), + GetScriptContext: newGetScriptContextFunc(t), + GetScriptLanguages: newGetScriptLanguagesFunc(t), + GetScript: newGetScriptFunc(t), + GetSource: newGetSourceFunc(t), + Index: newIndexFunc(t), + Info: newInfoFunc(t), + Mget: newMgetFunc(t), + Msearch: newMsearchFunc(t), + MsearchTemplate: newMsearchTemplateFunc(t), + Mtermvectors: newMtermvectorsFunc(t), + Ping: newPingFunc(t), + PutScript: newPutScriptFunc(t), + RankEval: newRankEvalFunc(t), + Reindex: newReindexFunc(t), + ReindexRethrottle: newReindexRethrottleFunc(t), + RenderSearchTemplate: newRenderSearchTemplateFunc(t), + ScriptsPainlessExecute: newScriptsPainlessExecuteFunc(t), + Scroll: newScrollFunc(t), + Search: newSearchFunc(t), + SearchShards: newSearchShardsFunc(t), + SearchTemplate: newSearchTemplateFunc(t), + TermsEnum: newTermsEnumFunc(t), + Termvectors: newTermvectorsFunc(t), + UpdateByQuery: newUpdateByQueryFunc(t), + UpdateByQueryRethrottle: newUpdateByQueryRethrottleFunc(t), + Update: newUpdateFunc(t), + Cat: &Cat{ + Aliases: newCatAliasesFunc(t), + Allocation: newCatAllocationFunc(t), + Count: newCatCountFunc(t), + Fielddata: newCatFielddataFunc(t), + Health: newCatHealthFunc(t), + Help: newCatHelpFunc(t), + Indices: newCatIndicesFunc(t), + Master: newCatMasterFunc(t), + Nodeattrs: newCatNodeattrsFunc(t), + Nodes: newCatNodesFunc(t), + PendingTasks: newCatPendingTasksFunc(t), + Plugins: newCatPluginsFunc(t), + Recovery: newCatRecoveryFunc(t), + Repositories: newCatRepositoriesFunc(t), + Segments: newCatSegmentsFunc(t), + Shards: newCatShardsFunc(t), + Snapshots: newCatSnapshotsFunc(t), + Tasks: newCatTasksFunc(t), + Templates: newCatTemplatesFunc(t), + ThreadPool: newCatThreadPoolFunc(t), + }, + Cluster: &Cluster{ + AllocationExplain: newClusterAllocationExplainFunc(t), + DeleteComponentTemplate: newClusterDeleteComponentTemplateFunc(t), + DeleteVotingConfigExclusions: newClusterDeleteVotingConfigExclusionsFunc(t), + ExistsComponentTemplate: newClusterExistsComponentTemplateFunc(t), + GetComponentTemplate: newClusterGetComponentTemplateFunc(t), + GetSettings: newClusterGetSettingsFunc(t), + Health: newClusterHealthFunc(t), + PendingTasks: newClusterPendingTasksFunc(t), + PostVotingConfigExclusions: newClusterPostVotingConfigExclusionsFunc(t), + PutComponentTemplate: newClusterPutComponentTemplateFunc(t), + PutSettings: newClusterPutSettingsFunc(t), + RemoteInfo: newClusterRemoteInfoFunc(t), + Reroute: newClusterRerouteFunc(t), + State: newClusterStateFunc(t), + Stats: newClusterStatsFunc(t), + }, + Indices: &Indices{ + AddBlock: newIndicesAddBlockFunc(t), + Analyze: newIndicesAnalyzeFunc(t), + ClearCache: newIndicesClearCacheFunc(t), + Clone: newIndicesCloneFunc(t), + Close: newIndicesCloseFunc(t), + Create: newIndicesCreateFunc(t), + DeleteAlias: newIndicesDeleteAliasFunc(t), + DeleteIndexTemplate: newIndicesDeleteIndexTemplateFunc(t), + Delete: newIndicesDeleteFunc(t), + DeleteTemplate: newIndicesDeleteTemplateFunc(t), + DiskUsage: newIndicesDiskUsageFunc(t), + ExistsAlias: newIndicesExistsAliasFunc(t), + ExistsDocumentType: newIndicesExistsDocumentTypeFunc(t), + ExistsIndexTemplate: newIndicesExistsIndexTemplateFunc(t), + Exists: newIndicesExistsFunc(t), + ExistsTemplate: newIndicesExistsTemplateFunc(t), + FieldUsageStats: newIndicesFieldUsageStatsFunc(t), + Flush: newIndicesFlushFunc(t), + FlushSynced: newIndicesFlushSyncedFunc(t), + Forcemerge: newIndicesForcemergeFunc(t), + GetAlias: newIndicesGetAliasFunc(t), + GetFieldMapping: newIndicesGetFieldMappingFunc(t), + GetIndexTemplate: newIndicesGetIndexTemplateFunc(t), + GetMapping: newIndicesGetMappingFunc(t), + Get: newIndicesGetFunc(t), + GetSettings: newIndicesGetSettingsFunc(t), + GetTemplate: newIndicesGetTemplateFunc(t), + GetUpgrade: newIndicesGetUpgradeFunc(t), + Open: newIndicesOpenFunc(t), + PutAlias: newIndicesPutAliasFunc(t), + PutIndexTemplate: newIndicesPutIndexTemplateFunc(t), + PutMapping: newIndicesPutMappingFunc(t), + PutSettings: newIndicesPutSettingsFunc(t), + PutTemplate: newIndicesPutTemplateFunc(t), + Recovery: newIndicesRecoveryFunc(t), + Refresh: newIndicesRefreshFunc(t), + ResolveIndex: newIndicesResolveIndexFunc(t), + Rollover: newIndicesRolloverFunc(t), + Segments: newIndicesSegmentsFunc(t), + ShardStores: newIndicesShardStoresFunc(t), + Shrink: newIndicesShrinkFunc(t), + SimulateIndexTemplate: newIndicesSimulateIndexTemplateFunc(t), + SimulateTemplate: newIndicesSimulateTemplateFunc(t), + Split: newIndicesSplitFunc(t), + Stats: newIndicesStatsFunc(t), + UpdateAliases: newIndicesUpdateAliasesFunc(t), + Upgrade: newIndicesUpgradeFunc(t), + ValidateQuery: newIndicesValidateQueryFunc(t), + }, + Ingest: &Ingest{ + DeletePipeline: newIngestDeletePipelineFunc(t), + GetPipeline: newIngestGetPipelineFunc(t), + ProcessorGrok: newIngestProcessorGrokFunc(t), + PutPipeline: newIngestPutPipelineFunc(t), + Simulate: newIngestSimulateFunc(t), + }, + Nodes: &Nodes{ + HotThreads: newNodesHotThreadsFunc(t), + Info: newNodesInfoFunc(t), + ReloadSecureSettings: newNodesReloadSecureSettingsFunc(t), + Stats: newNodesStatsFunc(t), + Usage: newNodesUsageFunc(t), + }, + Remote: &Remote{}, + Snapshot: &Snapshot{ + CleanupRepository: newSnapshotCleanupRepositoryFunc(t), + Clone: newSnapshotCloneFunc(t), + CreateRepository: newSnapshotCreateRepositoryFunc(t), + Create: newSnapshotCreateFunc(t), + DeleteRepository: newSnapshotDeleteRepositoryFunc(t), + Delete: newSnapshotDeleteFunc(t), + GetRepository: newSnapshotGetRepositoryFunc(t), + Get: newSnapshotGetFunc(t), + Restore: newSnapshotRestoreFunc(t), + Status: newSnapshotStatusFunc(t), + VerifyRepository: newSnapshotVerifyRepositoryFunc(t), + }, + Tasks: &Tasks{ + Cancel: newTasksCancelFunc(t), + Get: newTasksGetFunc(t), + List: newTasksListFunc(t), + }, + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.bulk.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.bulk.go new file mode 100644 index 000000000..c8f3a8d55 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.bulk.go @@ -0,0 +1,361 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newBulkFunc(t Transport) Bulk { + return func(body io.Reader, o ...func(*BulkRequest)) (*Response, error) { + var r = BulkRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Bulk allows to perform multiple index/update/delete operations in a single request. +// +// +type Bulk func(body io.Reader, o ...func(*BulkRequest)) (*Response, error) + +// BulkRequest configures the Bulk API request. +// +type BulkRequest struct { + Index string + DocumentType string + + Body io.Reader + + Pipeline string + Refresh string + RequireAlias *bool + Routing string + Source []string + SourceExcludes []string + SourceIncludes []string + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r BulkRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len("_bulk")) + if r.Index != "" { + path.WriteString("/") + path.WriteString(r.Index) + } + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString("_bulk") + + params = make(map[string]string) + + if r.Pipeline != "" { + params["pipeline"] = r.Pipeline + } + + if r.Refresh != "" { + params["refresh"] = r.Refresh + } + + if r.RequireAlias != nil { + params["require_alias"] = strconv.FormatBool(*r.RequireAlias) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.DocumentType != "" { + params["type"] = r.DocumentType + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Bulk) WithContext(v context.Context) func(*BulkRequest) { + return func(r *BulkRequest) { + r.ctx = v + } +} + +// WithIndex - default index for items which don't provide one. +// +func (f Bulk) WithIndex(v string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.Index = v + } +} + +// WithDocumentType - default document type for items which don't provide one. +// +func (f Bulk) WithDocumentType(v string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.DocumentType = v + } +} + +// WithPipeline - the pipeline ID to preprocess incoming documents with. +// +func (f Bulk) WithPipeline(v string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.Pipeline = v + } +} + +// WithRefresh - if `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.. +// +func (f Bulk) WithRefresh(v string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.Refresh = v + } +} + +// WithRequireAlias - sets require_alias for all incoming documents. defaults to unset (false). +// +func (f Bulk) WithRequireAlias(v bool) func(*BulkRequest) { + return func(r *BulkRequest) { + r.RequireAlias = &v + } +} + +// WithRouting - specific routing value. +// +func (f Bulk) WithRouting(v string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.Routing = v + } +} + +// WithSource - true or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request. +// +func (f Bulk) WithSource(v ...string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.Source = v + } +} + +// WithSourceExcludes - default list of fields to exclude from the returned _source field, can be overridden on each sub-request. +// +func (f Bulk) WithSourceExcludes(v ...string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - default list of fields to extract and return from the _source field, can be overridden on each sub-request. +// +func (f Bulk) WithSourceIncludes(v ...string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.SourceIncludes = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f Bulk) WithTimeout(v time.Duration) func(*BulkRequest) { + return func(r *BulkRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - sets the number of shard copies that must be active before proceeding with the bulk operation. defaults to 1, meaning the primary shard only. set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1). +// +func (f Bulk) WithWaitForActiveShards(v string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Bulk) WithPretty() func(*BulkRequest) { + return func(r *BulkRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Bulk) WithHuman() func(*BulkRequest) { + return func(r *BulkRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Bulk) WithErrorTrace() func(*BulkRequest) { + return func(r *BulkRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Bulk) WithFilterPath(v ...string) func(*BulkRequest) { + return func(r *BulkRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Bulk) WithHeader(h map[string]string) func(*BulkRequest) { + return func(r *BulkRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Bulk) WithOpaqueID(s string) func(*BulkRequest) { + return func(r *BulkRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.aliases.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.aliases.go new file mode 100644 index 000000000..e0776f0c9 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.aliases.go @@ -0,0 +1,312 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newCatAliasesFunc(t Transport) CatAliases { + return func(o ...func(*CatAliasesRequest)) (*Response, error) { + var r = CatAliasesRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatAliases shows information about currently configured aliases to indices including filter and routing infos. +// +// +type CatAliases func(o ...func(*CatAliasesRequest)) (*Response, error) + +// CatAliasesRequest configures the Cat Aliases API request. +// +type CatAliasesRequest struct { + Name []string + + ExpandWildcards string + Format string + H []string + Help *bool + Local *bool + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatAliasesRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("aliases") + 1 + len(strings.Join(r.Name, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("aliases") + if len(r.Name) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + } + + params = make(map[string]string) + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatAliases) WithContext(v context.Context) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.ctx = v + } +} + +// WithName - a list of alias names to return. +// +func (f CatAliases) WithName(v ...string) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.Name = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f CatAliases) WithExpandWildcards(v string) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.ExpandWildcards = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatAliases) WithFormat(v string) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatAliases) WithH(v ...string) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatAliases) WithHelp(v bool) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatAliases) WithLocal(v bool) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.Local = &v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatAliases) WithS(v ...string) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatAliases) WithV(v bool) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatAliases) WithPretty() func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatAliases) WithHuman() func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatAliases) WithErrorTrace() func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatAliases) WithFilterPath(v ...string) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatAliases) WithHeader(h map[string]string) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatAliases) WithOpaqueID(s string) func(*CatAliasesRequest) { + return func(r *CatAliasesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.allocation.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.allocation.go new file mode 100644 index 000000000..181ba139b --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.allocation.go @@ -0,0 +1,327 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatAllocationFunc(t Transport) CatAllocation { + return func(o ...func(*CatAllocationRequest)) (*Response, error) { + var r = CatAllocationRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatAllocation provides a snapshot of how many shards are allocated to each data node and how much disk space they are using. +// +// +type CatAllocation func(o ...func(*CatAllocationRequest)) (*Response, error) + +// CatAllocationRequest configures the Cat Allocation API request. +// +type CatAllocationRequest struct { + NodeID []string + + Bytes string + Format string + H []string + Help *bool + Local *bool + MasterTimeout time.Duration + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatAllocationRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("allocation") + 1 + len(strings.Join(r.NodeID, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("allocation") + if len(r.NodeID) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.NodeID, ",")) + } + + params = make(map[string]string) + + if r.Bytes != "" { + params["bytes"] = r.Bytes + } + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatAllocation) WithContext(v context.Context) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.ctx = v + } +} + +// WithNodeID - a list of node ids or names to limit the returned information. +// +func (f CatAllocation) WithNodeID(v ...string) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.NodeID = v + } +} + +// WithBytes - the unit in which to display byte values. +// +func (f CatAllocation) WithBytes(v string) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.Bytes = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatAllocation) WithFormat(v string) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatAllocation) WithH(v ...string) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatAllocation) WithHelp(v bool) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatAllocation) WithLocal(v bool) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatAllocation) WithMasterTimeout(v time.Duration) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatAllocation) WithS(v ...string) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatAllocation) WithV(v bool) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatAllocation) WithPretty() func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatAllocation) WithHuman() func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatAllocation) WithErrorTrace() func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatAllocation) WithFilterPath(v ...string) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatAllocation) WithHeader(h map[string]string) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatAllocation) WithOpaqueID(s string) func(*CatAllocationRequest) { + return func(r *CatAllocationRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.count.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.count.go new file mode 100644 index 000000000..f56f6bc51 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.count.go @@ -0,0 +1,287 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newCatCountFunc(t Transport) CatCount { + return func(o ...func(*CatCountRequest)) (*Response, error) { + var r = CatCountRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatCount provides quick access to the document count of the entire cluster, or individual indices. +// +// +type CatCount func(o ...func(*CatCountRequest)) (*Response, error) + +// CatCountRequest configures the Cat Count API request. +// +type CatCountRequest struct { + Index []string + + Format string + H []string + Help *bool + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatCountRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("count") + 1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("count") + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatCount) WithContext(v context.Context) func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to limit the returned information. +// +func (f CatCount) WithIndex(v ...string) func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.Index = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatCount) WithFormat(v string) func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatCount) WithH(v ...string) func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatCount) WithHelp(v bool) func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.Help = &v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatCount) WithS(v ...string) func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatCount) WithV(v bool) func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatCount) WithPretty() func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatCount) WithHuman() func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatCount) WithErrorTrace() func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatCount) WithFilterPath(v ...string) func(*CatCountRequest) { + return func(r *CatCountRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatCount) WithHeader(h map[string]string) func(*CatCountRequest) { + return func(r *CatCountRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatCount) WithOpaqueID(s string) func(*CatCountRequest) { + return func(r *CatCountRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.fielddata.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.fielddata.go new file mode 100644 index 000000000..931c35417 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.fielddata.go @@ -0,0 +1,304 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newCatFielddataFunc(t Transport) CatFielddata { + return func(o ...func(*CatFielddataRequest)) (*Response, error) { + var r = CatFielddataRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatFielddata shows how much heap memory is currently being used by fielddata on every data node in the cluster. +// +// +type CatFielddata func(o ...func(*CatFielddataRequest)) (*Response, error) + +// CatFielddataRequest configures the Cat Fielddata API request. +// +type CatFielddataRequest struct { + Fields []string + + Bytes string + Format string + H []string + Help *bool + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatFielddataRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("fielddata") + 1 + len(strings.Join(r.Fields, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("fielddata") + if len(r.Fields) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Fields, ",")) + } + + params = make(map[string]string) + + if r.Bytes != "" { + params["bytes"] = r.Bytes + } + + if len(r.Fields) > 0 { + params["fields"] = strings.Join(r.Fields, ",") + } + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatFielddata) WithContext(v context.Context) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.ctx = v + } +} + +// WithFields - a list of fields to return the fielddata size. +// +func (f CatFielddata) WithFields(v ...string) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.Fields = v + } +} + +// WithBytes - the unit in which to display byte values. +// +func (f CatFielddata) WithBytes(v string) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.Bytes = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatFielddata) WithFormat(v string) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatFielddata) WithH(v ...string) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatFielddata) WithHelp(v bool) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.Help = &v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatFielddata) WithS(v ...string) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatFielddata) WithV(v bool) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatFielddata) WithPretty() func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatFielddata) WithHuman() func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatFielddata) WithErrorTrace() func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatFielddata) WithFilterPath(v ...string) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatFielddata) WithHeader(h map[string]string) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatFielddata) WithOpaqueID(s string) func(*CatFielddataRequest) { + return func(r *CatFielddataRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.health.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.health.go new file mode 100644 index 000000000..3b32976ca --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.health.go @@ -0,0 +1,296 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newCatHealthFunc(t Transport) CatHealth { + return func(o ...func(*CatHealthRequest)) (*Response, error) { + var r = CatHealthRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatHealth returns a concise representation of the cluster health. +// +// +type CatHealth func(o ...func(*CatHealthRequest)) (*Response, error) + +// CatHealthRequest configures the Cat Health API request. +// +type CatHealthRequest struct { + Format string + H []string + Help *bool + S []string + Time string + Ts *bool + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatHealthRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat/health")) + path.WriteString("/_cat/health") + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Time != "" { + params["time"] = r.Time + } + + if r.Ts != nil { + params["ts"] = strconv.FormatBool(*r.Ts) + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatHealth) WithContext(v context.Context) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.ctx = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatHealth) WithFormat(v string) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatHealth) WithH(v ...string) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatHealth) WithHelp(v bool) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.Help = &v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatHealth) WithS(v ...string) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.S = v + } +} + +// WithTime - the unit in which to display time values. +// +func (f CatHealth) WithTime(v string) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.Time = v + } +} + +// WithTs - set to false to disable timestamping. +// +func (f CatHealth) WithTs(v bool) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.Ts = &v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatHealth) WithV(v bool) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatHealth) WithPretty() func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatHealth) WithHuman() func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatHealth) WithErrorTrace() func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatHealth) WithFilterPath(v ...string) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatHealth) WithHeader(h map[string]string) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatHealth) WithOpaqueID(s string) func(*CatHealthRequest) { + return func(r *CatHealthRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.help.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.help.go new file mode 100644 index 000000000..4663cfd16 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.help.go @@ -0,0 +1,230 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newCatHelpFunc(t Transport) CatHelp { + return func(o ...func(*CatHelpRequest)) (*Response, error) { + var r = CatHelpRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatHelp returns help for the Cat APIs. +// +// +type CatHelp func(o ...func(*CatHelpRequest)) (*Response, error) + +// CatHelpRequest configures the Cat Help API request. +// +type CatHelpRequest struct { + Help *bool + S []string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatHelpRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat")) + path.WriteString("/_cat") + + params = make(map[string]string) + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatHelp) WithContext(v context.Context) func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + r.ctx = v + } +} + +// WithHelp - return help information. +// +func (f CatHelp) WithHelp(v bool) func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + r.Help = &v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatHelp) WithS(v ...string) func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + r.S = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatHelp) WithPretty() func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatHelp) WithHuman() func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatHelp) WithErrorTrace() func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatHelp) WithFilterPath(v ...string) func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatHelp) WithHeader(h map[string]string) func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatHelp) WithOpaqueID(s string) func(*CatHelpRequest) { + return func(r *CatHelpRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.indices.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.indices.go new file mode 100644 index 000000000..c8f17ed4b --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.indices.go @@ -0,0 +1,391 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatIndicesFunc(t Transport) CatIndices { + return func(o ...func(*CatIndicesRequest)) (*Response, error) { + var r = CatIndicesRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatIndices returns information about indices: number of primaries and replicas, document counts, disk size, ... +// +// +type CatIndices func(o ...func(*CatIndicesRequest)) (*Response, error) + +// CatIndicesRequest configures the Cat Indices API request. +// +type CatIndicesRequest struct { + Index []string + + Bytes string + ExpandWildcards string + Format string + H []string + Health string + Help *bool + IncludeUnloadedSegments *bool + Local *bool + MasterTimeout time.Duration + Pri *bool + S []string + Time string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatIndicesRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("indices") + 1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("indices") + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + + params = make(map[string]string) + + if r.Bytes != "" { + params["bytes"] = r.Bytes + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Health != "" { + params["health"] = r.Health + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.IncludeUnloadedSegments != nil { + params["include_unloaded_segments"] = strconv.FormatBool(*r.IncludeUnloadedSegments) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pri != nil { + params["pri"] = strconv.FormatBool(*r.Pri) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Time != "" { + params["time"] = r.Time + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatIndices) WithContext(v context.Context) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to limit the returned information. +// +func (f CatIndices) WithIndex(v ...string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Index = v + } +} + +// WithBytes - the unit in which to display byte values. +// +func (f CatIndices) WithBytes(v string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Bytes = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f CatIndices) WithExpandWildcards(v string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.ExpandWildcards = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatIndices) WithFormat(v string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatIndices) WithH(v ...string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.H = v + } +} + +// WithHealth - a health status ("green", "yellow", or "red" to filter only indices matching the specified health status. +// +func (f CatIndices) WithHealth(v string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Health = v + } +} + +// WithHelp - return help information. +// +func (f CatIndices) WithHelp(v bool) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Help = &v + } +} + +// WithIncludeUnloadedSegments - if set to true segment stats will include stats for segments that are not currently loaded into memory. +// +func (f CatIndices) WithIncludeUnloadedSegments(v bool) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.IncludeUnloadedSegments = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatIndices) WithLocal(v bool) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatIndices) WithMasterTimeout(v time.Duration) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.MasterTimeout = v + } +} + +// WithPri - set to true to return stats only for primary shards. +// +func (f CatIndices) WithPri(v bool) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Pri = &v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatIndices) WithS(v ...string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.S = v + } +} + +// WithTime - the unit in which to display time values. +// +func (f CatIndices) WithTime(v string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Time = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatIndices) WithV(v bool) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatIndices) WithPretty() func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatIndices) WithHuman() func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatIndices) WithErrorTrace() func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatIndices) WithFilterPath(v ...string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatIndices) WithHeader(h map[string]string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatIndices) WithOpaqueID(s string) func(*CatIndicesRequest) { + return func(r *CatIndicesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.master.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.master.go new file mode 100644 index 000000000..0aab1edab --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.master.go @@ -0,0 +1,296 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatMasterFunc(t Transport) CatMaster { + return func(o ...func(*CatMasterRequest)) (*Response, error) { + var r = CatMasterRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatMaster returns information about the master node. +// +// +type CatMaster func(o ...func(*CatMasterRequest)) (*Response, error) + +// CatMasterRequest configures the Cat Master API request. +// +type CatMasterRequest struct { + Format string + H []string + Help *bool + Local *bool + MasterTimeout time.Duration + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatMasterRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat/master")) + path.WriteString("/_cat/master") + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatMaster) WithContext(v context.Context) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.ctx = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatMaster) WithFormat(v string) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatMaster) WithH(v ...string) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatMaster) WithHelp(v bool) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatMaster) WithLocal(v bool) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatMaster) WithMasterTimeout(v time.Duration) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatMaster) WithS(v ...string) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatMaster) WithV(v bool) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatMaster) WithPretty() func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatMaster) WithHuman() func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatMaster) WithErrorTrace() func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatMaster) WithFilterPath(v ...string) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatMaster) WithHeader(h map[string]string) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatMaster) WithOpaqueID(s string) func(*CatMasterRequest) { + return func(r *CatMasterRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.nodeattrs.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.nodeattrs.go new file mode 100644 index 000000000..7b54ea626 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.nodeattrs.go @@ -0,0 +1,296 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatNodeattrsFunc(t Transport) CatNodeattrs { + return func(o ...func(*CatNodeattrsRequest)) (*Response, error) { + var r = CatNodeattrsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatNodeattrs returns information about custom node attributes. +// +// +type CatNodeattrs func(o ...func(*CatNodeattrsRequest)) (*Response, error) + +// CatNodeattrsRequest configures the Cat Nodeattrs API request. +// +type CatNodeattrsRequest struct { + Format string + H []string + Help *bool + Local *bool + MasterTimeout time.Duration + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatNodeattrsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat/nodeattrs")) + path.WriteString("/_cat/nodeattrs") + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatNodeattrs) WithContext(v context.Context) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.ctx = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatNodeattrs) WithFormat(v string) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatNodeattrs) WithH(v ...string) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatNodeattrs) WithHelp(v bool) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatNodeattrs) WithLocal(v bool) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatNodeattrs) WithMasterTimeout(v time.Duration) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatNodeattrs) WithS(v ...string) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatNodeattrs) WithV(v bool) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatNodeattrs) WithPretty() func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatNodeattrs) WithHuman() func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatNodeattrs) WithErrorTrace() func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatNodeattrs) WithFilterPath(v ...string) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatNodeattrs) WithHeader(h map[string]string) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatNodeattrs) WithOpaqueID(s string) func(*CatNodeattrsRequest) { + return func(r *CatNodeattrsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.nodes.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.nodes.go new file mode 100644 index 000000000..2bd5d9533 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.nodes.go @@ -0,0 +1,348 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatNodesFunc(t Transport) CatNodes { + return func(o ...func(*CatNodesRequest)) (*Response, error) { + var r = CatNodesRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatNodes returns basic statistics about performance of cluster nodes. +// +// +type CatNodes func(o ...func(*CatNodesRequest)) (*Response, error) + +// CatNodesRequest configures the Cat Nodes API request. +// +type CatNodesRequest struct { + Bytes string + Format string + FullID *bool + H []string + Help *bool + IncludeUnloadedSegments *bool + Local *bool + MasterTimeout time.Duration + S []string + Time string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatNodesRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat/nodes")) + path.WriteString("/_cat/nodes") + + params = make(map[string]string) + + if r.Bytes != "" { + params["bytes"] = r.Bytes + } + + if r.Format != "" { + params["format"] = r.Format + } + + if r.FullID != nil { + params["full_id"] = strconv.FormatBool(*r.FullID) + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.IncludeUnloadedSegments != nil { + params["include_unloaded_segments"] = strconv.FormatBool(*r.IncludeUnloadedSegments) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Time != "" { + params["time"] = r.Time + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatNodes) WithContext(v context.Context) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.ctx = v + } +} + +// WithBytes - the unit in which to display byte values. +// +func (f CatNodes) WithBytes(v string) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.Bytes = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatNodes) WithFormat(v string) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.Format = v + } +} + +// WithFullID - return the full node ID instead of the shortened version (default: false). +// +func (f CatNodes) WithFullID(v bool) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.FullID = &v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatNodes) WithH(v ...string) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatNodes) WithHelp(v bool) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.Help = &v + } +} + +// WithIncludeUnloadedSegments - if set to true segment stats will include stats for segments that are not currently loaded into memory. +// +func (f CatNodes) WithIncludeUnloadedSegments(v bool) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.IncludeUnloadedSegments = &v + } +} + +// WithLocal - calculate the selected nodes using the local cluster state rather than the state from master node (default: false). +// +func (f CatNodes) WithLocal(v bool) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatNodes) WithMasterTimeout(v time.Duration) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatNodes) WithS(v ...string) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.S = v + } +} + +// WithTime - the unit in which to display time values. +// +func (f CatNodes) WithTime(v string) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.Time = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatNodes) WithV(v bool) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatNodes) WithPretty() func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatNodes) WithHuman() func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatNodes) WithErrorTrace() func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatNodes) WithFilterPath(v ...string) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatNodes) WithHeader(h map[string]string) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatNodes) WithOpaqueID(s string) func(*CatNodesRequest) { + return func(r *CatNodesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.pending_tasks.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.pending_tasks.go new file mode 100644 index 000000000..1729d6b3c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.pending_tasks.go @@ -0,0 +1,309 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatPendingTasksFunc(t Transport) CatPendingTasks { + return func(o ...func(*CatPendingTasksRequest)) (*Response, error) { + var r = CatPendingTasksRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatPendingTasks returns a concise representation of the cluster pending tasks. +// +// +type CatPendingTasks func(o ...func(*CatPendingTasksRequest)) (*Response, error) + +// CatPendingTasksRequest configures the Cat Pending Tasks API request. +// +type CatPendingTasksRequest struct { + Format string + H []string + Help *bool + Local *bool + MasterTimeout time.Duration + S []string + Time string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatPendingTasksRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat/pending_tasks")) + path.WriteString("/_cat/pending_tasks") + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Time != "" { + params["time"] = r.Time + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatPendingTasks) WithContext(v context.Context) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.ctx = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatPendingTasks) WithFormat(v string) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatPendingTasks) WithH(v ...string) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatPendingTasks) WithHelp(v bool) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatPendingTasks) WithLocal(v bool) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatPendingTasks) WithMasterTimeout(v time.Duration) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatPendingTasks) WithS(v ...string) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.S = v + } +} + +// WithTime - the unit in which to display time values. +// +func (f CatPendingTasks) WithTime(v string) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.Time = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatPendingTasks) WithV(v bool) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatPendingTasks) WithPretty() func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatPendingTasks) WithHuman() func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatPendingTasks) WithErrorTrace() func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatPendingTasks) WithFilterPath(v ...string) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatPendingTasks) WithHeader(h map[string]string) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatPendingTasks) WithOpaqueID(s string) func(*CatPendingTasksRequest) { + return func(r *CatPendingTasksRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.plugins.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.plugins.go new file mode 100644 index 000000000..1d281c3a5 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.plugins.go @@ -0,0 +1,309 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatPluginsFunc(t Transport) CatPlugins { + return func(o ...func(*CatPluginsRequest)) (*Response, error) { + var r = CatPluginsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatPlugins returns information about installed plugins across nodes node. +// +// +type CatPlugins func(o ...func(*CatPluginsRequest)) (*Response, error) + +// CatPluginsRequest configures the Cat Plugins API request. +// +type CatPluginsRequest struct { + Format string + H []string + Help *bool + IncludeBootstrap *bool + Local *bool + MasterTimeout time.Duration + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatPluginsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat/plugins")) + path.WriteString("/_cat/plugins") + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.IncludeBootstrap != nil { + params["include_bootstrap"] = strconv.FormatBool(*r.IncludeBootstrap) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatPlugins) WithContext(v context.Context) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.ctx = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatPlugins) WithFormat(v string) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatPlugins) WithH(v ...string) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatPlugins) WithHelp(v bool) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.Help = &v + } +} + +// WithIncludeBootstrap - include bootstrap plugins in the response. +// +func (f CatPlugins) WithIncludeBootstrap(v bool) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.IncludeBootstrap = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatPlugins) WithLocal(v bool) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatPlugins) WithMasterTimeout(v time.Duration) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatPlugins) WithS(v ...string) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatPlugins) WithV(v bool) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatPlugins) WithPretty() func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatPlugins) WithHuman() func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatPlugins) WithErrorTrace() func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatPlugins) WithFilterPath(v ...string) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatPlugins) WithHeader(h map[string]string) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatPlugins) WithOpaqueID(s string) func(*CatPluginsRequest) { + return func(r *CatPluginsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.recovery.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.recovery.go new file mode 100644 index 000000000..1ab175837 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.recovery.go @@ -0,0 +1,342 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newCatRecoveryFunc(t Transport) CatRecovery { + return func(o ...func(*CatRecoveryRequest)) (*Response, error) { + var r = CatRecoveryRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatRecovery returns information about index shard recoveries, both on-going completed. +// +// +type CatRecovery func(o ...func(*CatRecoveryRequest)) (*Response, error) + +// CatRecoveryRequest configures the Cat Recovery API request. +// +type CatRecoveryRequest struct { + Index []string + + ActiveOnly *bool + Bytes string + Detailed *bool + Format string + H []string + Help *bool + S []string + Time string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatRecoveryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("recovery") + 1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("recovery") + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + + params = make(map[string]string) + + if r.ActiveOnly != nil { + params["active_only"] = strconv.FormatBool(*r.ActiveOnly) + } + + if r.Bytes != "" { + params["bytes"] = r.Bytes + } + + if r.Detailed != nil { + params["detailed"] = strconv.FormatBool(*r.Detailed) + } + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if len(r.Index) > 0 { + params["index"] = strings.Join(r.Index, ",") + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Time != "" { + params["time"] = r.Time + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatRecovery) WithContext(v context.Context) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.ctx = v + } +} + +// WithIndex - comma-separated list or wildcard expression of index names to limit the returned information. +// +func (f CatRecovery) WithIndex(v ...string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.Index = v + } +} + +// WithActiveOnly - if `true`, the response only includes ongoing shard recoveries. +// +func (f CatRecovery) WithActiveOnly(v bool) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.ActiveOnly = &v + } +} + +// WithBytes - the unit in which to display byte values. +// +func (f CatRecovery) WithBytes(v string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.Bytes = v + } +} + +// WithDetailed - if `true`, the response includes detailed information about shard recoveries. +// +func (f CatRecovery) WithDetailed(v bool) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.Detailed = &v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatRecovery) WithFormat(v string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatRecovery) WithH(v ...string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatRecovery) WithHelp(v bool) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.Help = &v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatRecovery) WithS(v ...string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.S = v + } +} + +// WithTime - the unit in which to display time values. +// +func (f CatRecovery) WithTime(v string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.Time = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatRecovery) WithV(v bool) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatRecovery) WithPretty() func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatRecovery) WithHuman() func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatRecovery) WithErrorTrace() func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatRecovery) WithFilterPath(v ...string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatRecovery) WithHeader(h map[string]string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatRecovery) WithOpaqueID(s string) func(*CatRecoveryRequest) { + return func(r *CatRecoveryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.repositories.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.repositories.go new file mode 100644 index 000000000..60c5bdc76 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.repositories.go @@ -0,0 +1,296 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatRepositoriesFunc(t Transport) CatRepositories { + return func(o ...func(*CatRepositoriesRequest)) (*Response, error) { + var r = CatRepositoriesRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatRepositories returns information about snapshot repositories registered in the cluster. +// +// +type CatRepositories func(o ...func(*CatRepositoriesRequest)) (*Response, error) + +// CatRepositoriesRequest configures the Cat Repositories API request. +// +type CatRepositoriesRequest struct { + Format string + H []string + Help *bool + Local *bool + MasterTimeout time.Duration + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatRepositoriesRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat/repositories")) + path.WriteString("/_cat/repositories") + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatRepositories) WithContext(v context.Context) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.ctx = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatRepositories) WithFormat(v string) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatRepositories) WithH(v ...string) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatRepositories) WithHelp(v bool) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node. +// +func (f CatRepositories) WithLocal(v bool) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatRepositories) WithMasterTimeout(v time.Duration) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatRepositories) WithS(v ...string) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatRepositories) WithV(v bool) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatRepositories) WithPretty() func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatRepositories) WithHuman() func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatRepositories) WithErrorTrace() func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatRepositories) WithFilterPath(v ...string) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatRepositories) WithHeader(h map[string]string) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatRepositories) WithOpaqueID(s string) func(*CatRepositoriesRequest) { + return func(r *CatRepositoriesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.segments.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.segments.go new file mode 100644 index 000000000..1ee4ab8eb --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.segments.go @@ -0,0 +1,299 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newCatSegmentsFunc(t Transport) CatSegments { + return func(o ...func(*CatSegmentsRequest)) (*Response, error) { + var r = CatSegmentsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatSegments provides low-level information about the segments in the shards of an index. +// +// +type CatSegments func(o ...func(*CatSegmentsRequest)) (*Response, error) + +// CatSegmentsRequest configures the Cat Segments API request. +// +type CatSegmentsRequest struct { + Index []string + + Bytes string + Format string + H []string + Help *bool + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatSegmentsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("segments") + 1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("segments") + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + + params = make(map[string]string) + + if r.Bytes != "" { + params["bytes"] = r.Bytes + } + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatSegments) WithContext(v context.Context) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to limit the returned information. +// +func (f CatSegments) WithIndex(v ...string) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.Index = v + } +} + +// WithBytes - the unit in which to display byte values. +// +func (f CatSegments) WithBytes(v string) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.Bytes = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatSegments) WithFormat(v string) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatSegments) WithH(v ...string) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatSegments) WithHelp(v bool) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.Help = &v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatSegments) WithS(v ...string) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatSegments) WithV(v bool) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatSegments) WithPretty() func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatSegments) WithHuman() func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatSegments) WithErrorTrace() func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatSegments) WithFilterPath(v ...string) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatSegments) WithHeader(h map[string]string) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatSegments) WithOpaqueID(s string) func(*CatSegmentsRequest) { + return func(r *CatSegmentsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.shards.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.shards.go new file mode 100644 index 000000000..34b8da47c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.shards.go @@ -0,0 +1,339 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatShardsFunc(t Transport) CatShards { + return func(o ...func(*CatShardsRequest)) (*Response, error) { + var r = CatShardsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatShards provides a detailed view of shard allocation on nodes. +// +// +type CatShards func(o ...func(*CatShardsRequest)) (*Response, error) + +// CatShardsRequest configures the Cat Shards API request. +// +type CatShardsRequest struct { + Index []string + + Bytes string + Format string + H []string + Help *bool + Local *bool + MasterTimeout time.Duration + S []string + Time string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatShardsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("shards") + 1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("shards") + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + + params = make(map[string]string) + + if r.Bytes != "" { + params["bytes"] = r.Bytes + } + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Time != "" { + params["time"] = r.Time + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatShards) WithContext(v context.Context) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to limit the returned information. +// +func (f CatShards) WithIndex(v ...string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.Index = v + } +} + +// WithBytes - the unit in which to display byte values. +// +func (f CatShards) WithBytes(v string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.Bytes = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatShards) WithFormat(v string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatShards) WithH(v ...string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatShards) WithHelp(v bool) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatShards) WithLocal(v bool) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatShards) WithMasterTimeout(v time.Duration) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatShards) WithS(v ...string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.S = v + } +} + +// WithTime - the unit in which to display time values. +// +func (f CatShards) WithTime(v string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.Time = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatShards) WithV(v bool) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatShards) WithPretty() func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatShards) WithHuman() func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatShards) WithErrorTrace() func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatShards) WithFilterPath(v ...string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatShards) WithHeader(h map[string]string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatShards) WithOpaqueID(s string) func(*CatShardsRequest) { + return func(r *CatShardsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.snapshots.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.snapshots.go new file mode 100644 index 000000000..f3d8da153 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.snapshots.go @@ -0,0 +1,326 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatSnapshotsFunc(t Transport) CatSnapshots { + return func(o ...func(*CatSnapshotsRequest)) (*Response, error) { + var r = CatSnapshotsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatSnapshots returns all snapshots in a specific repository. +// +// +type CatSnapshots func(o ...func(*CatSnapshotsRequest)) (*Response, error) + +// CatSnapshotsRequest configures the Cat Snapshots API request. +// +type CatSnapshotsRequest struct { + Repository []string + + Format string + H []string + Help *bool + IgnoreUnavailable *bool + MasterTimeout time.Duration + S []string + Time string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatSnapshotsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("snapshots") + 1 + len(strings.Join(r.Repository, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("snapshots") + if len(r.Repository) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Repository, ",")) + } + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Time != "" { + params["time"] = r.Time + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatSnapshots) WithContext(v context.Context) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.ctx = v + } +} + +// WithRepository - name of repository from which to fetch the snapshot information. +// +func (f CatSnapshots) WithRepository(v ...string) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.Repository = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatSnapshots) WithFormat(v string) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatSnapshots) WithH(v ...string) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatSnapshots) WithHelp(v bool) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.Help = &v + } +} + +// WithIgnoreUnavailable - set to true to ignore unavailable snapshots. +// +func (f CatSnapshots) WithIgnoreUnavailable(v bool) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatSnapshots) WithMasterTimeout(v time.Duration) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatSnapshots) WithS(v ...string) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.S = v + } +} + +// WithTime - the unit in which to display time values. +// +func (f CatSnapshots) WithTime(v string) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.Time = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatSnapshots) WithV(v bool) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatSnapshots) WithPretty() func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatSnapshots) WithHuman() func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatSnapshots) WithErrorTrace() func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatSnapshots) WithFilterPath(v ...string) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatSnapshots) WithHeader(h map[string]string) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatSnapshots) WithOpaqueID(s string) func(*CatSnapshotsRequest) { + return func(r *CatSnapshotsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.tasks.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.tasks.go new file mode 100644 index 000000000..32412b7c8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.tasks.go @@ -0,0 +1,334 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newCatTasksFunc(t Transport) CatTasks { + return func(o ...func(*CatTasksRequest)) (*Response, error) { + var r = CatTasksRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatTasks returns information about the tasks currently executing on one or more nodes in the cluster. +// +// +type CatTasks func(o ...func(*CatTasksRequest)) (*Response, error) + +// CatTasksRequest configures the Cat Tasks API request. +// +type CatTasksRequest struct { + Actions []string + Detailed *bool + Format string + H []string + Help *bool + Nodes []string + ParentTaskID string + S []string + Time string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatTasksRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cat/tasks")) + path.WriteString("/_cat/tasks") + + params = make(map[string]string) + + if len(r.Actions) > 0 { + params["actions"] = strings.Join(r.Actions, ",") + } + + if r.Detailed != nil { + params["detailed"] = strconv.FormatBool(*r.Detailed) + } + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if len(r.Nodes) > 0 { + params["nodes"] = strings.Join(r.Nodes, ",") + } + + if r.ParentTaskID != "" { + params["parent_task_id"] = r.ParentTaskID + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Time != "" { + params["time"] = r.Time + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatTasks) WithContext(v context.Context) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.ctx = v + } +} + +// WithActions - a list of actions that should be returned. leave empty to return all.. +// +func (f CatTasks) WithActions(v ...string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.Actions = v + } +} + +// WithDetailed - return detailed task information (default: false). +// +func (f CatTasks) WithDetailed(v bool) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.Detailed = &v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatTasks) WithFormat(v string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatTasks) WithH(v ...string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatTasks) WithHelp(v bool) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.Help = &v + } +} + +// WithNodes - a list of node ids or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes. +// +func (f CatTasks) WithNodes(v ...string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.Nodes = v + } +} + +// WithParentTaskID - return tasks with specified parent task ID (node_id:task_number). set to -1 to return all.. +// +func (f CatTasks) WithParentTaskID(v string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.ParentTaskID = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatTasks) WithS(v ...string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.S = v + } +} + +// WithTime - the unit in which to display time values. +// +func (f CatTasks) WithTime(v string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.Time = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatTasks) WithV(v bool) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatTasks) WithPretty() func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatTasks) WithHuman() func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatTasks) WithErrorTrace() func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatTasks) WithFilterPath(v ...string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatTasks) WithHeader(h map[string]string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatTasks) WithOpaqueID(s string) func(*CatTasksRequest) { + return func(r *CatTasksRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.templates.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.templates.go new file mode 100644 index 000000000..4df7dea66 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.templates.go @@ -0,0 +1,313 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatTemplatesFunc(t Transport) CatTemplates { + return func(o ...func(*CatTemplatesRequest)) (*Response, error) { + var r = CatTemplatesRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatTemplates returns information about existing templates. +// +// +type CatTemplates func(o ...func(*CatTemplatesRequest)) (*Response, error) + +// CatTemplatesRequest configures the Cat Templates API request. +// +type CatTemplatesRequest struct { + Name string + + Format string + H []string + Help *bool + Local *bool + MasterTimeout time.Duration + S []string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatTemplatesRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("templates") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("templates") + if r.Name != "" { + path.WriteString("/") + path.WriteString(r.Name) + } + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatTemplates) WithContext(v context.Context) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.ctx = v + } +} + +// WithName - a pattern that returned template names must match. +// +func (f CatTemplates) WithName(v string) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.Name = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatTemplates) WithFormat(v string) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatTemplates) WithH(v ...string) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatTemplates) WithHelp(v bool) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatTemplates) WithLocal(v bool) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatTemplates) WithMasterTimeout(v time.Duration) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatTemplates) WithS(v ...string) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.S = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatTemplates) WithV(v bool) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatTemplates) WithPretty() func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatTemplates) WithHuman() func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatTemplates) WithErrorTrace() func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatTemplates) WithFilterPath(v ...string) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatTemplates) WithHeader(h map[string]string) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatTemplates) WithOpaqueID(s string) func(*CatTemplatesRequest) { + return func(r *CatTemplatesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.thread_pool.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.thread_pool.go new file mode 100644 index 000000000..80a90dc5a --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cat.thread_pool.go @@ -0,0 +1,327 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newCatThreadPoolFunc(t Transport) CatThreadPool { + return func(o ...func(*CatThreadPoolRequest)) (*Response, error) { + var r = CatThreadPoolRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// CatThreadPool returns cluster-wide thread pool statistics per node. +// By default the active, queue and rejected statistics are returned for all thread pools. +// +// +type CatThreadPool func(o ...func(*CatThreadPoolRequest)) (*Response, error) + +// CatThreadPoolRequest configures the Cat Thread Pool API request. +// +type CatThreadPoolRequest struct { + ThreadPoolPatterns []string + + Format string + H []string + Help *bool + Local *bool + MasterTimeout time.Duration + S []string + Size string + V *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CatThreadPoolRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cat") + 1 + len("thread_pool") + 1 + len(strings.Join(r.ThreadPoolPatterns, ","))) + path.WriteString("/") + path.WriteString("_cat") + path.WriteString("/") + path.WriteString("thread_pool") + if len(r.ThreadPoolPatterns) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.ThreadPoolPatterns, ",")) + } + + params = make(map[string]string) + + if r.Format != "" { + params["format"] = r.Format + } + + if len(r.H) > 0 { + params["h"] = strings.Join(r.H, ",") + } + + if r.Help != nil { + params["help"] = strconv.FormatBool(*r.Help) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.S) > 0 { + params["s"] = strings.Join(r.S, ",") + } + + if r.Size != "" { + params["size"] = r.Size + } + + if r.V != nil { + params["v"] = strconv.FormatBool(*r.V) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f CatThreadPool) WithContext(v context.Context) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.ctx = v + } +} + +// WithThreadPoolPatterns - a list of regular-expressions to filter the thread pools in the output. +// +func (f CatThreadPool) WithThreadPoolPatterns(v ...string) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.ThreadPoolPatterns = v + } +} + +// WithFormat - a short version of the accept header, e.g. json, yaml. +// +func (f CatThreadPool) WithFormat(v string) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.Format = v + } +} + +// WithH - comma-separated list of column names to display. +// +func (f CatThreadPool) WithH(v ...string) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.H = v + } +} + +// WithHelp - return help information. +// +func (f CatThreadPool) WithHelp(v bool) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.Help = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f CatThreadPool) WithLocal(v bool) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f CatThreadPool) WithMasterTimeout(v time.Duration) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.MasterTimeout = v + } +} + +// WithS - comma-separated list of column names or column aliases to sort by. +// +func (f CatThreadPool) WithS(v ...string) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.S = v + } +} + +// WithSize - the multiplier in which to display values. +// +func (f CatThreadPool) WithSize(v string) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.Size = v + } +} + +// WithV - verbose mode. display column headers. +// +func (f CatThreadPool) WithV(v bool) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.V = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f CatThreadPool) WithPretty() func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f CatThreadPool) WithHuman() func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f CatThreadPool) WithErrorTrace() func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f CatThreadPool) WithFilterPath(v ...string) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f CatThreadPool) WithHeader(h map[string]string) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f CatThreadPool) WithOpaqueID(s string) func(*CatThreadPoolRequest) { + return func(r *CatThreadPoolRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.clear_scroll.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.clear_scroll.go new file mode 100644 index 000000000..c205171e4 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.clear_scroll.go @@ -0,0 +1,234 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" +) + +func newClearScrollFunc(t Transport) ClearScroll { + return func(o ...func(*ClearScrollRequest)) (*Response, error) { + var r = ClearScrollRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClearScroll explicitly clears the search context for a scroll. +// +// +type ClearScroll func(o ...func(*ClearScrollRequest)) (*Response, error) + +// ClearScrollRequest configures the Clear Scroll API request. +// +type ClearScrollRequest struct { + Body io.Reader + + ScrollID []string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClearScrollRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_search") + 1 + len("scroll") + 1 + len(strings.Join(r.ScrollID, ","))) + path.WriteString("/") + path.WriteString("_search") + path.WriteString("/") + path.WriteString("scroll") + if len(r.ScrollID) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.ScrollID, ",")) + } + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClearScroll) WithContext(v context.Context) func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + r.ctx = v + } +} + +// WithBody - A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter. +// +func (f ClearScroll) WithBody(v io.Reader) func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + r.Body = v + } +} + +// WithScrollID - a list of scroll ids to clear. +// +func (f ClearScroll) WithScrollID(v ...string) func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + r.ScrollID = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClearScroll) WithPretty() func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClearScroll) WithHuman() func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClearScroll) WithErrorTrace() func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClearScroll) WithFilterPath(v ...string) func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClearScroll) WithHeader(h map[string]string) func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClearScroll) WithOpaqueID(s string) func(*ClearScrollRequest) { + return func(r *ClearScrollRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.allocation_explain.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.allocation_explain.go new file mode 100644 index 000000000..7da7ce72a --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.allocation_explain.go @@ -0,0 +1,245 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newClusterAllocationExplainFunc(t Transport) ClusterAllocationExplain { + return func(o ...func(*ClusterAllocationExplainRequest)) (*Response, error) { + var r = ClusterAllocationExplainRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterAllocationExplain provides explanations for shard allocations in the cluster. +// +// +type ClusterAllocationExplain func(o ...func(*ClusterAllocationExplainRequest)) (*Response, error) + +// ClusterAllocationExplainRequest configures the Cluster Allocation Explain API request. +// +type ClusterAllocationExplainRequest struct { + Body io.Reader + + IncludeDiskInfo *bool + IncludeYesDecisions *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterAllocationExplainRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(len("/_cluster/allocation/explain")) + path.WriteString("/_cluster/allocation/explain") + + params = make(map[string]string) + + if r.IncludeDiskInfo != nil { + params["include_disk_info"] = strconv.FormatBool(*r.IncludeDiskInfo) + } + + if r.IncludeYesDecisions != nil { + params["include_yes_decisions"] = strconv.FormatBool(*r.IncludeYesDecisions) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterAllocationExplain) WithContext(v context.Context) func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + r.ctx = v + } +} + +// WithBody - The index, shard, and primary flag to explain. Empty means 'explain the first unassigned shard'. +// +func (f ClusterAllocationExplain) WithBody(v io.Reader) func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + r.Body = v + } +} + +// WithIncludeDiskInfo - return information about disk usage and shard sizes (default: false). +// +func (f ClusterAllocationExplain) WithIncludeDiskInfo(v bool) func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + r.IncludeDiskInfo = &v + } +} + +// WithIncludeYesDecisions - return 'yes' decisions in explanation (default: false). +// +func (f ClusterAllocationExplain) WithIncludeYesDecisions(v bool) func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + r.IncludeYesDecisions = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterAllocationExplain) WithPretty() func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterAllocationExplain) WithHuman() func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterAllocationExplain) WithErrorTrace() func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterAllocationExplain) WithFilterPath(v ...string) func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterAllocationExplain) WithHeader(h map[string]string) func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterAllocationExplain) WithOpaqueID(s string) func(*ClusterAllocationExplainRequest) { + return func(r *ClusterAllocationExplainRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.delete_component_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.delete_component_template.go new file mode 100644 index 000000000..c6b9ddf6a --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.delete_component_template.go @@ -0,0 +1,235 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newClusterDeleteComponentTemplateFunc(t Transport) ClusterDeleteComponentTemplate { + return func(name string, o ...func(*ClusterDeleteComponentTemplateRequest)) (*Response, error) { + var r = ClusterDeleteComponentTemplateRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterDeleteComponentTemplate deletes a component template +// +// +type ClusterDeleteComponentTemplate func(name string, o ...func(*ClusterDeleteComponentTemplateRequest)) (*Response, error) + +// ClusterDeleteComponentTemplateRequest configures the Cluster Delete Component Template API request. +// +type ClusterDeleteComponentTemplateRequest struct { + Name string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterDeleteComponentTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_component_template") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_component_template") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterDeleteComponentTemplate) WithContext(v context.Context) func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f ClusterDeleteComponentTemplate) WithMasterTimeout(v time.Duration) func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f ClusterDeleteComponentTemplate) WithTimeout(v time.Duration) func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterDeleteComponentTemplate) WithPretty() func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterDeleteComponentTemplate) WithHuman() func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterDeleteComponentTemplate) WithErrorTrace() func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterDeleteComponentTemplate) WithFilterPath(v ...string) func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterDeleteComponentTemplate) WithHeader(h map[string]string) func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterDeleteComponentTemplate) WithOpaqueID(s string) func(*ClusterDeleteComponentTemplateRequest) { + return func(r *ClusterDeleteComponentTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.delete_voting_config_exclusions.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.delete_voting_config_exclusions.go new file mode 100644 index 000000000..046b08058 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.delete_voting_config_exclusions.go @@ -0,0 +1,217 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newClusterDeleteVotingConfigExclusionsFunc(t Transport) ClusterDeleteVotingConfigExclusions { + return func(o ...func(*ClusterDeleteVotingConfigExclusionsRequest)) (*Response, error) { + var r = ClusterDeleteVotingConfigExclusionsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterDeleteVotingConfigExclusions clears cluster voting config exclusions. +// +// +type ClusterDeleteVotingConfigExclusions func(o ...func(*ClusterDeleteVotingConfigExclusionsRequest)) (*Response, error) + +// ClusterDeleteVotingConfigExclusionsRequest configures the Cluster Delete Voting Config Exclusions API request. +// +type ClusterDeleteVotingConfigExclusionsRequest struct { + WaitForRemoval *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterDeleteVotingConfigExclusionsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(len("/_cluster/voting_config_exclusions")) + path.WriteString("/_cluster/voting_config_exclusions") + + params = make(map[string]string) + + if r.WaitForRemoval != nil { + params["wait_for_removal"] = strconv.FormatBool(*r.WaitForRemoval) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterDeleteVotingConfigExclusions) WithContext(v context.Context) func(*ClusterDeleteVotingConfigExclusionsRequest) { + return func(r *ClusterDeleteVotingConfigExclusionsRequest) { + r.ctx = v + } +} + +// WithWaitForRemoval - specifies whether to wait for all excluded nodes to be removed from the cluster before clearing the voting configuration exclusions list.. +// +func (f ClusterDeleteVotingConfigExclusions) WithWaitForRemoval(v bool) func(*ClusterDeleteVotingConfigExclusionsRequest) { + return func(r *ClusterDeleteVotingConfigExclusionsRequest) { + r.WaitForRemoval = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterDeleteVotingConfigExclusions) WithPretty() func(*ClusterDeleteVotingConfigExclusionsRequest) { + return func(r *ClusterDeleteVotingConfigExclusionsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterDeleteVotingConfigExclusions) WithHuman() func(*ClusterDeleteVotingConfigExclusionsRequest) { + return func(r *ClusterDeleteVotingConfigExclusionsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterDeleteVotingConfigExclusions) WithErrorTrace() func(*ClusterDeleteVotingConfigExclusionsRequest) { + return func(r *ClusterDeleteVotingConfigExclusionsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterDeleteVotingConfigExclusions) WithFilterPath(v ...string) func(*ClusterDeleteVotingConfigExclusionsRequest) { + return func(r *ClusterDeleteVotingConfigExclusionsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterDeleteVotingConfigExclusions) WithHeader(h map[string]string) func(*ClusterDeleteVotingConfigExclusionsRequest) { + return func(r *ClusterDeleteVotingConfigExclusionsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterDeleteVotingConfigExclusions) WithOpaqueID(s string) func(*ClusterDeleteVotingConfigExclusionsRequest) { + return func(r *ClusterDeleteVotingConfigExclusionsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.exists_component_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.exists_component_template.go new file mode 100644 index 000000000..def02c64b --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.exists_component_template.go @@ -0,0 +1,236 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterExistsComponentTemplateFunc(t Transport) ClusterExistsComponentTemplate { + return func(name string, o ...func(*ClusterExistsComponentTemplateRequest)) (*Response, error) { + var r = ClusterExistsComponentTemplateRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterExistsComponentTemplate returns information about whether a particular component template exist +// +// +type ClusterExistsComponentTemplate func(name string, o ...func(*ClusterExistsComponentTemplateRequest)) (*Response, error) + +// ClusterExistsComponentTemplateRequest configures the Cluster Exists Component Template API request. +// +type ClusterExistsComponentTemplateRequest struct { + Name string + + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterExistsComponentTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + path.Grow(1 + len("_component_template") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_component_template") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterExistsComponentTemplate) WithContext(v context.Context) func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + r.ctx = v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f ClusterExistsComponentTemplate) WithLocal(v bool) func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f ClusterExistsComponentTemplate) WithMasterTimeout(v time.Duration) func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterExistsComponentTemplate) WithPretty() func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterExistsComponentTemplate) WithHuman() func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterExistsComponentTemplate) WithErrorTrace() func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterExistsComponentTemplate) WithFilterPath(v ...string) func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterExistsComponentTemplate) WithHeader(h map[string]string) func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterExistsComponentTemplate) WithOpaqueID(s string) func(*ClusterExistsComponentTemplateRequest) { + return func(r *ClusterExistsComponentTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.get_component_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.get_component_template.go new file mode 100644 index 000000000..72a5fdbb8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.get_component_template.go @@ -0,0 +1,246 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterGetComponentTemplateFunc(t Transport) ClusterGetComponentTemplate { + return func(o ...func(*ClusterGetComponentTemplateRequest)) (*Response, error) { + var r = ClusterGetComponentTemplateRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterGetComponentTemplate returns one or more component templates +// +// +type ClusterGetComponentTemplate func(o ...func(*ClusterGetComponentTemplateRequest)) (*Response, error) + +// ClusterGetComponentTemplateRequest configures the Cluster Get Component Template API request. +// +type ClusterGetComponentTemplateRequest struct { + Name []string + + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterGetComponentTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_component_template") + 1 + len(strings.Join(r.Name, ","))) + path.WriteString("/") + path.WriteString("_component_template") + if len(r.Name) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + } + + params = make(map[string]string) + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterGetComponentTemplate) WithContext(v context.Context) func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + r.ctx = v + } +} + +// WithName - the comma separated names of the component templates. +// +func (f ClusterGetComponentTemplate) WithName(v ...string) func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + r.Name = v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f ClusterGetComponentTemplate) WithLocal(v bool) func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f ClusterGetComponentTemplate) WithMasterTimeout(v time.Duration) func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterGetComponentTemplate) WithPretty() func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterGetComponentTemplate) WithHuman() func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterGetComponentTemplate) WithErrorTrace() func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterGetComponentTemplate) WithFilterPath(v ...string) func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterGetComponentTemplate) WithHeader(h map[string]string) func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterGetComponentTemplate) WithOpaqueID(s string) func(*ClusterGetComponentTemplateRequest) { + return func(r *ClusterGetComponentTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.get_settings.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.get_settings.go new file mode 100644 index 000000000..20709a912 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.get_settings.go @@ -0,0 +1,257 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterGetSettingsFunc(t Transport) ClusterGetSettings { + return func(o ...func(*ClusterGetSettingsRequest)) (*Response, error) { + var r = ClusterGetSettingsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterGetSettings returns cluster settings. +// +// +type ClusterGetSettings func(o ...func(*ClusterGetSettingsRequest)) (*Response, error) + +// ClusterGetSettingsRequest configures the Cluster Get Settings API request. +// +type ClusterGetSettingsRequest struct { + FlatSettings *bool + IncludeDefaults *bool + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterGetSettingsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cluster/settings")) + path.WriteString("/_cluster/settings") + + params = make(map[string]string) + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.IncludeDefaults != nil { + params["include_defaults"] = strconv.FormatBool(*r.IncludeDefaults) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterGetSettings) WithContext(v context.Context) func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.ctx = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f ClusterGetSettings) WithFlatSettings(v bool) func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.FlatSettings = &v + } +} + +// WithIncludeDefaults - whether to return all default clusters setting.. +// +func (f ClusterGetSettings) WithIncludeDefaults(v bool) func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.IncludeDefaults = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f ClusterGetSettings) WithMasterTimeout(v time.Duration) func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f ClusterGetSettings) WithTimeout(v time.Duration) func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterGetSettings) WithPretty() func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterGetSettings) WithHuman() func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterGetSettings) WithErrorTrace() func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterGetSettings) WithFilterPath(v ...string) func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterGetSettings) WithHeader(h map[string]string) func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterGetSettings) WithOpaqueID(s string) func(*ClusterGetSettingsRequest) { + return func(r *ClusterGetSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.health.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.health.go new file mode 100644 index 000000000..630b5b467 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.health.go @@ -0,0 +1,365 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterHealthFunc(t Transport) ClusterHealth { + return func(o ...func(*ClusterHealthRequest)) (*Response, error) { + var r = ClusterHealthRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterHealth returns basic information about the health of the cluster. +// +// +type ClusterHealth func(o ...func(*ClusterHealthRequest)) (*Response, error) + +// ClusterHealthRequest configures the Cluster Health API request. +// +type ClusterHealthRequest struct { + Index []string + + ExpandWildcards string + Level string + Local *bool + MasterTimeout time.Duration + Timeout time.Duration + WaitForActiveShards string + WaitForEvents string + WaitForNoInitializingShards *bool + WaitForNoRelocatingShards *bool + WaitForNodes string + WaitForStatus string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterHealthRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cluster") + 1 + len("health") + 1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString("_cluster") + path.WriteString("/") + path.WriteString("health") + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + + params = make(map[string]string) + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Level != "" { + params["level"] = r.Level + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.WaitForEvents != "" { + params["wait_for_events"] = r.WaitForEvents + } + + if r.WaitForNoInitializingShards != nil { + params["wait_for_no_initializing_shards"] = strconv.FormatBool(*r.WaitForNoInitializingShards) + } + + if r.WaitForNoRelocatingShards != nil { + params["wait_for_no_relocating_shards"] = strconv.FormatBool(*r.WaitForNoRelocatingShards) + } + + if r.WaitForNodes != "" { + params["wait_for_nodes"] = r.WaitForNodes + } + + if r.WaitForStatus != "" { + params["wait_for_status"] = r.WaitForStatus + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterHealth) WithContext(v context.Context) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.ctx = v + } +} + +// WithIndex - limit the information returned to a specific index. +// +func (f ClusterHealth) WithIndex(v ...string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.Index = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f ClusterHealth) WithExpandWildcards(v string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.ExpandWildcards = v + } +} + +// WithLevel - specify the level of detail for returned information. +// +func (f ClusterHealth) WithLevel(v string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.Level = v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f ClusterHealth) WithLocal(v bool) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f ClusterHealth) WithMasterTimeout(v time.Duration) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f ClusterHealth) WithTimeout(v time.Duration) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - wait until the specified number of shards is active. +// +func (f ClusterHealth) WithWaitForActiveShards(v string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.WaitForActiveShards = v + } +} + +// WithWaitForEvents - wait until all currently queued events with the given priority are processed. +// +func (f ClusterHealth) WithWaitForEvents(v string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.WaitForEvents = v + } +} + +// WithWaitForNoInitializingShards - whether to wait until there are no initializing shards in the cluster. +// +func (f ClusterHealth) WithWaitForNoInitializingShards(v bool) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.WaitForNoInitializingShards = &v + } +} + +// WithWaitForNoRelocatingShards - whether to wait until there are no relocating shards in the cluster. +// +func (f ClusterHealth) WithWaitForNoRelocatingShards(v bool) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.WaitForNoRelocatingShards = &v + } +} + +// WithWaitForNodes - wait until the specified number of nodes is available. +// +func (f ClusterHealth) WithWaitForNodes(v string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.WaitForNodes = v + } +} + +// WithWaitForStatus - wait until cluster is in a specific state. +// +func (f ClusterHealth) WithWaitForStatus(v string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.WaitForStatus = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterHealth) WithPretty() func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterHealth) WithHuman() func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterHealth) WithErrorTrace() func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterHealth) WithFilterPath(v ...string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterHealth) WithHeader(h map[string]string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterHealth) WithOpaqueID(s string) func(*ClusterHealthRequest) { + return func(r *ClusterHealthRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.pending_tasks.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.pending_tasks.go new file mode 100644 index 000000000..15e64449c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.pending_tasks.go @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterPendingTasksFunc(t Transport) ClusterPendingTasks { + return func(o ...func(*ClusterPendingTasksRequest)) (*Response, error) { + var r = ClusterPendingTasksRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterPendingTasks returns a list of any cluster-level changes (e.g. create index, update mapping, +// allocate or fail shard) which have not yet been executed. +// +// +type ClusterPendingTasks func(o ...func(*ClusterPendingTasksRequest)) (*Response, error) + +// ClusterPendingTasksRequest configures the Cluster Pending Tasks API request. +// +type ClusterPendingTasksRequest struct { + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterPendingTasksRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_cluster/pending_tasks")) + path.WriteString("/_cluster/pending_tasks") + + params = make(map[string]string) + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterPendingTasks) WithContext(v context.Context) func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + r.ctx = v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f ClusterPendingTasks) WithLocal(v bool) func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f ClusterPendingTasks) WithMasterTimeout(v time.Duration) func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterPendingTasks) WithPretty() func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterPendingTasks) WithHuman() func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterPendingTasks) WithErrorTrace() func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterPendingTasks) WithFilterPath(v ...string) func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterPendingTasks) WithHeader(h map[string]string) func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterPendingTasks) WithOpaqueID(s string) func(*ClusterPendingTasksRequest) { + return func(r *ClusterPendingTasksRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.post_voting_config_exclusions.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.post_voting_config_exclusions.go new file mode 100644 index 000000000..63692fcc5 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.post_voting_config_exclusions.go @@ -0,0 +1,243 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newClusterPostVotingConfigExclusionsFunc(t Transport) ClusterPostVotingConfigExclusions { + return func(o ...func(*ClusterPostVotingConfigExclusionsRequest)) (*Response, error) { + var r = ClusterPostVotingConfigExclusionsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterPostVotingConfigExclusions updates the cluster voting config exclusions by node ids or node names. +// +// +type ClusterPostVotingConfigExclusions func(o ...func(*ClusterPostVotingConfigExclusionsRequest)) (*Response, error) + +// ClusterPostVotingConfigExclusionsRequest configures the Cluster Post Voting Config Exclusions API request. +// +type ClusterPostVotingConfigExclusionsRequest struct { + NodeIds string + NodeNames string + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterPostVotingConfigExclusionsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(len("/_cluster/voting_config_exclusions")) + path.WriteString("/_cluster/voting_config_exclusions") + + params = make(map[string]string) + + if r.NodeIds != "" { + params["node_ids"] = r.NodeIds + } + + if r.NodeNames != "" { + params["node_names"] = r.NodeNames + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterPostVotingConfigExclusions) WithContext(v context.Context) func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + r.ctx = v + } +} + +// WithNodeIds - a list of the persistent ids of the nodes to exclude from the voting configuration. if specified, you may not also specify ?node_names.. +// +func (f ClusterPostVotingConfigExclusions) WithNodeIds(v string) func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + r.NodeIds = v + } +} + +// WithNodeNames - a list of the names of the nodes to exclude from the voting configuration. if specified, you may not also specify ?node_ids.. +// +func (f ClusterPostVotingConfigExclusions) WithNodeNames(v string) func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + r.NodeNames = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f ClusterPostVotingConfigExclusions) WithTimeout(v time.Duration) func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterPostVotingConfigExclusions) WithPretty() func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterPostVotingConfigExclusions) WithHuman() func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterPostVotingConfigExclusions) WithErrorTrace() func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterPostVotingConfigExclusions) WithFilterPath(v ...string) func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterPostVotingConfigExclusions) WithHeader(h map[string]string) func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterPostVotingConfigExclusions) WithOpaqueID(s string) func(*ClusterPostVotingConfigExclusionsRequest) { + return func(r *ClusterPostVotingConfigExclusionsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.put_component_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.put_component_template.go new file mode 100644 index 000000000..c54cebe8d --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.put_component_template.go @@ -0,0 +1,256 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterPutComponentTemplateFunc(t Transport) ClusterPutComponentTemplate { + return func(name string, body io.Reader, o ...func(*ClusterPutComponentTemplateRequest)) (*Response, error) { + var r = ClusterPutComponentTemplateRequest{Name: name, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterPutComponentTemplate creates or updates a component template +// +// +type ClusterPutComponentTemplate func(name string, body io.Reader, o ...func(*ClusterPutComponentTemplateRequest)) (*Response, error) + +// ClusterPutComponentTemplateRequest configures the Cluster Put Component Template API request. +// +type ClusterPutComponentTemplateRequest struct { + Body io.Reader + + Name string + + Create *bool + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterPutComponentTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len("_component_template") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_component_template") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.Create != nil { + params["create"] = strconv.FormatBool(*r.Create) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterPutComponentTemplate) WithContext(v context.Context) func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + r.ctx = v + } +} + +// WithCreate - whether the index template should only be added if new or can also replace an existing one. +// +func (f ClusterPutComponentTemplate) WithCreate(v bool) func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + r.Create = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f ClusterPutComponentTemplate) WithMasterTimeout(v time.Duration) func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f ClusterPutComponentTemplate) WithTimeout(v time.Duration) func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterPutComponentTemplate) WithPretty() func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterPutComponentTemplate) WithHuman() func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterPutComponentTemplate) WithErrorTrace() func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterPutComponentTemplate) WithFilterPath(v ...string) func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterPutComponentTemplate) WithHeader(h map[string]string) func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterPutComponentTemplate) WithOpaqueID(s string) func(*ClusterPutComponentTemplateRequest) { + return func(r *ClusterPutComponentTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.put_settings.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.put_settings.go new file mode 100644 index 000000000..64ed6bc58 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.put_settings.go @@ -0,0 +1,251 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterPutSettingsFunc(t Transport) ClusterPutSettings { + return func(body io.Reader, o ...func(*ClusterPutSettingsRequest)) (*Response, error) { + var r = ClusterPutSettingsRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterPutSettings updates the cluster settings. +// +// +type ClusterPutSettings func(body io.Reader, o ...func(*ClusterPutSettingsRequest)) (*Response, error) + +// ClusterPutSettingsRequest configures the Cluster Put Settings API request. +// +type ClusterPutSettingsRequest struct { + Body io.Reader + + FlatSettings *bool + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterPutSettingsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(len("/_cluster/settings")) + path.WriteString("/_cluster/settings") + + params = make(map[string]string) + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterPutSettings) WithContext(v context.Context) func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + r.ctx = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f ClusterPutSettings) WithFlatSettings(v bool) func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + r.FlatSettings = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f ClusterPutSettings) WithMasterTimeout(v time.Duration) func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f ClusterPutSettings) WithTimeout(v time.Duration) func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterPutSettings) WithPretty() func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterPutSettings) WithHuman() func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterPutSettings) WithErrorTrace() func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterPutSettings) WithFilterPath(v ...string) func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterPutSettings) WithHeader(h map[string]string) func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterPutSettings) WithOpaqueID(s string) func(*ClusterPutSettingsRequest) { + return func(r *ClusterPutSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.remote_info.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.remote_info.go new file mode 100644 index 000000000..c35166be5 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.remote_info.go @@ -0,0 +1,202 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" +) + +func newClusterRemoteInfoFunc(t Transport) ClusterRemoteInfo { + return func(o ...func(*ClusterRemoteInfoRequest)) (*Response, error) { + var r = ClusterRemoteInfoRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterRemoteInfo returns the information about configured remote clusters. +// +// +type ClusterRemoteInfo func(o ...func(*ClusterRemoteInfoRequest)) (*Response, error) + +// ClusterRemoteInfoRequest configures the Cluster Remote Info API request. +// +type ClusterRemoteInfoRequest struct { + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterRemoteInfoRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_remote/info")) + path.WriteString("/_remote/info") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterRemoteInfo) WithContext(v context.Context) func(*ClusterRemoteInfoRequest) { + return func(r *ClusterRemoteInfoRequest) { + r.ctx = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterRemoteInfo) WithPretty() func(*ClusterRemoteInfoRequest) { + return func(r *ClusterRemoteInfoRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterRemoteInfo) WithHuman() func(*ClusterRemoteInfoRequest) { + return func(r *ClusterRemoteInfoRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterRemoteInfo) WithErrorTrace() func(*ClusterRemoteInfoRequest) { + return func(r *ClusterRemoteInfoRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterRemoteInfo) WithFilterPath(v ...string) func(*ClusterRemoteInfoRequest) { + return func(r *ClusterRemoteInfoRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterRemoteInfo) WithHeader(h map[string]string) func(*ClusterRemoteInfoRequest) { + return func(r *ClusterRemoteInfoRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterRemoteInfo) WithOpaqueID(s string) func(*ClusterRemoteInfoRequest) { + return func(r *ClusterRemoteInfoRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.reroute.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.reroute.go new file mode 100644 index 000000000..a810f3726 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.reroute.go @@ -0,0 +1,298 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterRerouteFunc(t Transport) ClusterReroute { + return func(o ...func(*ClusterRerouteRequest)) (*Response, error) { + var r = ClusterRerouteRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterReroute allows to manually change the allocation of individual shards in the cluster. +// +// +type ClusterReroute func(o ...func(*ClusterRerouteRequest)) (*Response, error) + +// ClusterRerouteRequest configures the Cluster Reroute API request. +// +type ClusterRerouteRequest struct { + Body io.Reader + + DryRun *bool + Explain *bool + MasterTimeout time.Duration + Metric []string + RetryFailed *bool + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterRerouteRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(len("/_cluster/reroute")) + path.WriteString("/_cluster/reroute") + + params = make(map[string]string) + + if r.DryRun != nil { + params["dry_run"] = strconv.FormatBool(*r.DryRun) + } + + if r.Explain != nil { + params["explain"] = strconv.FormatBool(*r.Explain) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if len(r.Metric) > 0 { + params["metric"] = strings.Join(r.Metric, ",") + } + + if r.RetryFailed != nil { + params["retry_failed"] = strconv.FormatBool(*r.RetryFailed) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterReroute) WithContext(v context.Context) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.ctx = v + } +} + +// WithBody - The definition of `commands` to perform (`move`, `cancel`, `allocate`). +// +func (f ClusterReroute) WithBody(v io.Reader) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.Body = v + } +} + +// WithDryRun - simulate the operation only and return the resulting state. +// +func (f ClusterReroute) WithDryRun(v bool) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.DryRun = &v + } +} + +// WithExplain - return an explanation of why the commands can or cannot be executed. +// +func (f ClusterReroute) WithExplain(v bool) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.Explain = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f ClusterReroute) WithMasterTimeout(v time.Duration) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.MasterTimeout = v + } +} + +// WithMetric - limit the information returned to the specified metrics. defaults to all but metadata. +// +func (f ClusterReroute) WithMetric(v ...string) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.Metric = v + } +} + +// WithRetryFailed - retries allocation of shards that are blocked due to too many subsequent allocation failures. +// +func (f ClusterReroute) WithRetryFailed(v bool) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.RetryFailed = &v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f ClusterReroute) WithTimeout(v time.Duration) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterReroute) WithPretty() func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterReroute) WithHuman() func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterReroute) WithErrorTrace() func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterReroute) WithFilterPath(v ...string) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterReroute) WithHeader(h map[string]string) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterReroute) WithOpaqueID(s string) func(*ClusterRerouteRequest) { + return func(r *ClusterRerouteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.state.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.state.go new file mode 100644 index 000000000..3abced62e --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.state.go @@ -0,0 +1,340 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterStateFunc(t Transport) ClusterState { + return func(o ...func(*ClusterStateRequest)) (*Response, error) { + var r = ClusterStateRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterState returns a comprehensive information about the state of the cluster. +// +// +type ClusterState func(o ...func(*ClusterStateRequest)) (*Response, error) + +// ClusterStateRequest configures the Cluster State API request. +// +type ClusterStateRequest struct { + Index []string + + Metric []string + + AllowNoIndices *bool + ExpandWildcards string + FlatSettings *bool + IgnoreUnavailable *bool + Local *bool + MasterTimeout time.Duration + WaitForMetadataVersion *int + WaitForTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterStateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cluster") + 1 + len("state") + 1 + len(strings.Join(r.Metric, ",")) + 1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString("_cluster") + path.WriteString("/") + path.WriteString("state") + if len(r.Metric) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Metric, ",")) + } + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.WaitForMetadataVersion != nil { + params["wait_for_metadata_version"] = strconv.FormatInt(int64(*r.WaitForMetadataVersion), 10) + } + + if r.WaitForTimeout != 0 { + params["wait_for_timeout"] = formatDuration(r.WaitForTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterState) WithContext(v context.Context) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f ClusterState) WithIndex(v ...string) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.Index = v + } +} + +// WithMetric - limit the information returned to the specified metrics. +// +func (f ClusterState) WithMetric(v ...string) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.Metric = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f ClusterState) WithAllowNoIndices(v bool) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f ClusterState) WithExpandWildcards(v string) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.ExpandWildcards = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f ClusterState) WithFlatSettings(v bool) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.FlatSettings = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f ClusterState) WithIgnoreUnavailable(v bool) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f ClusterState) WithLocal(v bool) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f ClusterState) WithMasterTimeout(v time.Duration) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.MasterTimeout = v + } +} + +// WithWaitForMetadataVersion - wait for the metadata version to be equal or greater than the specified metadata version. +// +func (f ClusterState) WithWaitForMetadataVersion(v int) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.WaitForMetadataVersion = &v + } +} + +// WithWaitForTimeout - the maximum time to wait for wait_for_metadata_version before timing out. +// +func (f ClusterState) WithWaitForTimeout(v time.Duration) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.WaitForTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterState) WithPretty() func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterState) WithHuman() func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterState) WithErrorTrace() func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterState) WithFilterPath(v ...string) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterState) WithHeader(h map[string]string) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterState) WithOpaqueID(s string) func(*ClusterStateRequest) { + return func(r *ClusterStateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.stats.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.stats.go new file mode 100644 index 000000000..a40067876 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.cluster.stats.go @@ -0,0 +1,250 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newClusterStatsFunc(t Transport) ClusterStats { + return func(o ...func(*ClusterStatsRequest)) (*Response, error) { + var r = ClusterStatsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ClusterStats returns high-level overview of cluster statistics. +// +// +type ClusterStats func(o ...func(*ClusterStatsRequest)) (*Response, error) + +// ClusterStatsRequest configures the Cluster Stats API request. +// +type ClusterStatsRequest struct { + NodeID []string + + FlatSettings *bool + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ClusterStatsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/nodes/_cluster/stats/nodes/") + len(strings.Join(r.NodeID, ","))) + path.WriteString("/") + path.WriteString("_cluster") + path.WriteString("/") + path.WriteString("stats") + if len(r.NodeID) > 0 { + path.WriteString("/") + path.WriteString("nodes") + path.WriteString("/") + path.WriteString(strings.Join(r.NodeID, ",")) + } + + params = make(map[string]string) + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ClusterStats) WithContext(v context.Context) func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + r.ctx = v + } +} + +// WithNodeID - a list of node ids or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes. +// +func (f ClusterStats) WithNodeID(v ...string) func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + r.NodeID = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f ClusterStats) WithFlatSettings(v bool) func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + r.FlatSettings = &v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f ClusterStats) WithTimeout(v time.Duration) func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ClusterStats) WithPretty() func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ClusterStats) WithHuman() func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ClusterStats) WithErrorTrace() func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ClusterStats) WithFilterPath(v ...string) func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ClusterStats) WithHeader(h map[string]string) func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ClusterStats) WithOpaqueID(s string) func(*ClusterStatsRequest) { + return func(r *ClusterStatsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.count.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.count.go new file mode 100644 index 000000000..4d2605bd3 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.count.go @@ -0,0 +1,429 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newCountFunc(t Transport) Count { + return func(o ...func(*CountRequest)) (*Response, error) { + var r = CountRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Count returns number of documents matching a query. +// +// +type Count func(o ...func(*CountRequest)) (*Response, error) + +// CountRequest configures the Count API request. +// +type CountRequest struct { + Index []string + DocumentType []string + + Body io.Reader + + AllowNoIndices *bool + Analyzer string + AnalyzeWildcard *bool + DefaultOperator string + Df string + ExpandWildcards string + IgnoreThrottled *bool + IgnoreUnavailable *bool + Lenient *bool + MinScore *int + Preference string + Query string + Routing []string + TerminateAfter *int + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CountRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("_count")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("_count") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.Analyzer != "" { + params["analyzer"] = r.Analyzer + } + + if r.AnalyzeWildcard != nil { + params["analyze_wildcard"] = strconv.FormatBool(*r.AnalyzeWildcard) + } + + if r.DefaultOperator != "" { + params["default_operator"] = r.DefaultOperator + } + + if r.Df != "" { + params["df"] = r.Df + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreThrottled != nil { + params["ignore_throttled"] = strconv.FormatBool(*r.IgnoreThrottled) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Lenient != nil { + params["lenient"] = strconv.FormatBool(*r.Lenient) + } + + if r.MinScore != nil { + params["min_score"] = strconv.FormatInt(int64(*r.MinScore), 10) + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Query != "" { + params["q"] = r.Query + } + + if len(r.Routing) > 0 { + params["routing"] = strings.Join(r.Routing, ",") + } + + if r.TerminateAfter != nil { + params["terminate_after"] = strconv.FormatInt(int64(*r.TerminateAfter), 10) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Count) WithContext(v context.Context) func(*CountRequest) { + return func(r *CountRequest) { + r.ctx = v + } +} + +// WithBody - A query to restrict the results specified with the Query DSL (optional). +// +func (f Count) WithBody(v io.Reader) func(*CountRequest) { + return func(r *CountRequest) { + r.Body = v + } +} + +// WithIndex - a list of indices to restrict the results. +// +func (f Count) WithIndex(v ...string) func(*CountRequest) { + return func(r *CountRequest) { + r.Index = v + } +} + +// WithDocumentType - a list of types to restrict the results. +// +func (f Count) WithDocumentType(v ...string) func(*CountRequest) { + return func(r *CountRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f Count) WithAllowNoIndices(v bool) func(*CountRequest) { + return func(r *CountRequest) { + r.AllowNoIndices = &v + } +} + +// WithAnalyzer - the analyzer to use for the query string. +// +func (f Count) WithAnalyzer(v string) func(*CountRequest) { + return func(r *CountRequest) { + r.Analyzer = v + } +} + +// WithAnalyzeWildcard - specify whether wildcard and prefix queries should be analyzed (default: false). +// +func (f Count) WithAnalyzeWildcard(v bool) func(*CountRequest) { + return func(r *CountRequest) { + r.AnalyzeWildcard = &v + } +} + +// WithDefaultOperator - the default operator for query string query (and or or). +// +func (f Count) WithDefaultOperator(v string) func(*CountRequest) { + return func(r *CountRequest) { + r.DefaultOperator = v + } +} + +// WithDf - the field to use as default where no field prefix is given in the query string. +// +func (f Count) WithDf(v string) func(*CountRequest) { + return func(r *CountRequest) { + r.Df = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f Count) WithExpandWildcards(v string) func(*CountRequest) { + return func(r *CountRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreThrottled - whether specified concrete, expanded or aliased indices should be ignored when throttled. +// +func (f Count) WithIgnoreThrottled(v bool) func(*CountRequest) { + return func(r *CountRequest) { + r.IgnoreThrottled = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f Count) WithIgnoreUnavailable(v bool) func(*CountRequest) { + return func(r *CountRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLenient - specify whether format-based query failures (such as providing text to a numeric field) should be ignored. +// +func (f Count) WithLenient(v bool) func(*CountRequest) { + return func(r *CountRequest) { + r.Lenient = &v + } +} + +// WithMinScore - include only documents with a specific `_score` value in the result. +// +func (f Count) WithMinScore(v int) func(*CountRequest) { + return func(r *CountRequest) { + r.MinScore = &v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f Count) WithPreference(v string) func(*CountRequest) { + return func(r *CountRequest) { + r.Preference = v + } +} + +// WithQuery - query in the lucene query string syntax. +// +func (f Count) WithQuery(v string) func(*CountRequest) { + return func(r *CountRequest) { + r.Query = v + } +} + +// WithRouting - a list of specific routing values. +// +func (f Count) WithRouting(v ...string) func(*CountRequest) { + return func(r *CountRequest) { + r.Routing = v + } +} + +// WithTerminateAfter - the maximum count for each shard, upon reaching which the query execution will terminate early. +// +func (f Count) WithTerminateAfter(v int) func(*CountRequest) { + return func(r *CountRequest) { + r.TerminateAfter = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Count) WithPretty() func(*CountRequest) { + return func(r *CountRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Count) WithHuman() func(*CountRequest) { + return func(r *CountRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Count) WithErrorTrace() func(*CountRequest) { + return func(r *CountRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Count) WithFilterPath(v ...string) func(*CountRequest) { + return func(r *CountRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Count) WithHeader(h map[string]string) func(*CountRequest) { + return func(r *CountRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Count) WithOpaqueID(s string) func(*CountRequest) { + return func(r *CountRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.create.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.create.go new file mode 100644 index 000000000..e16d9c98c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.create.go @@ -0,0 +1,330 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newCreateFunc(t Transport) Create { + return func(index string, id string, body io.Reader, o ...func(*CreateRequest)) (*Response, error) { + var r = CreateRequest{Index: index, DocumentID: id, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Create creates a new document in the index. +// +// Returns a 409 response when a document with a same ID already exists in the index. +// +// +type Create func(index string, id string, body io.Reader, o ...func(*CreateRequest)) (*Response, error) + +// CreateRequest configures the Create API request. +// +type CreateRequest struct { + Index string + DocumentType string + DocumentID string + + Body io.Reader + + Pipeline string + Refresh string + Routing string + Timeout time.Duration + Version *int + VersionType string + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r CreateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID) + 1 + len("_create")) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString(r.DocumentID) + path.WriteString("/") + path.WriteString("_create") + + params = make(map[string]string) + + if r.Pipeline != "" { + params["pipeline"] = r.Pipeline + } + + if r.Refresh != "" { + params["refresh"] = r.Refresh + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Create) WithContext(v context.Context) func(*CreateRequest) { + return func(r *CreateRequest) { + r.ctx = v + } +} + +// WithDocumentType - the type of the document. +// +func (f Create) WithDocumentType(v string) func(*CreateRequest) { + return func(r *CreateRequest) { + r.DocumentType = v + } +} + +// WithPipeline - the pipeline ID to preprocess incoming documents with. +// +func (f Create) WithPipeline(v string) func(*CreateRequest) { + return func(r *CreateRequest) { + r.Pipeline = v + } +} + +// WithRefresh - if `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.. +// +func (f Create) WithRefresh(v string) func(*CreateRequest) { + return func(r *CreateRequest) { + r.Refresh = v + } +} + +// WithRouting - specific routing value. +// +func (f Create) WithRouting(v string) func(*CreateRequest) { + return func(r *CreateRequest) { + r.Routing = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f Create) WithTimeout(v time.Duration) func(*CreateRequest) { + return func(r *CreateRequest) { + r.Timeout = v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f Create) WithVersion(v int) func(*CreateRequest) { + return func(r *CreateRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f Create) WithVersionType(v string) func(*CreateRequest) { + return func(r *CreateRequest) { + r.VersionType = v + } +} + +// WithWaitForActiveShards - sets the number of shard copies that must be active before proceeding with the index operation. defaults to 1, meaning the primary shard only. set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1). +// +func (f Create) WithWaitForActiveShards(v string) func(*CreateRequest) { + return func(r *CreateRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Create) WithPretty() func(*CreateRequest) { + return func(r *CreateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Create) WithHuman() func(*CreateRequest) { + return func(r *CreateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Create) WithErrorTrace() func(*CreateRequest) { + return func(r *CreateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Create) WithFilterPath(v ...string) func(*CreateRequest) { + return func(r *CreateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Create) WithHeader(h map[string]string) func(*CreateRequest) { + return func(r *CreateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Create) WithOpaqueID(s string) func(*CreateRequest) { + return func(r *CreateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.delete_dangling_index.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.delete_dangling_index.go new file mode 100644 index 000000000..b931235ae --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.delete_dangling_index.go @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newDanglingIndicesDeleteDanglingIndexFunc(t Transport) DanglingIndicesDeleteDanglingIndex { + return func(index_uuid string, o ...func(*DanglingIndicesDeleteDanglingIndexRequest)) (*Response, error) { + var r = DanglingIndicesDeleteDanglingIndexRequest{IndexUUID: index_uuid} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// DanglingIndicesDeleteDanglingIndex deletes the specified dangling index +// +// +type DanglingIndicesDeleteDanglingIndex func(index_uuid string, o ...func(*DanglingIndicesDeleteDanglingIndexRequest)) (*Response, error) + +// DanglingIndicesDeleteDanglingIndexRequest configures the Dangling Indices Delete Dangling Index API request. +// +type DanglingIndicesDeleteDanglingIndexRequest struct { + IndexUUID string + + AcceptDataLoss *bool + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r DanglingIndicesDeleteDanglingIndexRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_dangling") + 1 + len(r.IndexUUID)) + path.WriteString("/") + path.WriteString("_dangling") + path.WriteString("/") + path.WriteString(r.IndexUUID) + + params = make(map[string]string) + + if r.AcceptDataLoss != nil { + params["accept_data_loss"] = strconv.FormatBool(*r.AcceptDataLoss) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f DanglingIndicesDeleteDanglingIndex) WithContext(v context.Context) func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + r.ctx = v + } +} + +// WithAcceptDataLoss - must be set to true in order to delete the dangling index. +// +func (f DanglingIndicesDeleteDanglingIndex) WithAcceptDataLoss(v bool) func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + r.AcceptDataLoss = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f DanglingIndicesDeleteDanglingIndex) WithMasterTimeout(v time.Duration) func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f DanglingIndicesDeleteDanglingIndex) WithTimeout(v time.Duration) func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f DanglingIndicesDeleteDanglingIndex) WithPretty() func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f DanglingIndicesDeleteDanglingIndex) WithHuman() func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f DanglingIndicesDeleteDanglingIndex) WithErrorTrace() func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f DanglingIndicesDeleteDanglingIndex) WithFilterPath(v ...string) func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f DanglingIndicesDeleteDanglingIndex) WithHeader(h map[string]string) func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f DanglingIndicesDeleteDanglingIndex) WithOpaqueID(s string) func(*DanglingIndicesDeleteDanglingIndexRequest) { + return func(r *DanglingIndicesDeleteDanglingIndexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.import_dangling_index.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.import_dangling_index.go new file mode 100644 index 000000000..fb46c0668 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.import_dangling_index.go @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newDanglingIndicesImportDanglingIndexFunc(t Transport) DanglingIndicesImportDanglingIndex { + return func(index_uuid string, o ...func(*DanglingIndicesImportDanglingIndexRequest)) (*Response, error) { + var r = DanglingIndicesImportDanglingIndexRequest{IndexUUID: index_uuid} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// DanglingIndicesImportDanglingIndex imports the specified dangling index +// +// +type DanglingIndicesImportDanglingIndex func(index_uuid string, o ...func(*DanglingIndicesImportDanglingIndexRequest)) (*Response, error) + +// DanglingIndicesImportDanglingIndexRequest configures the Dangling Indices Import Dangling Index API request. +// +type DanglingIndicesImportDanglingIndexRequest struct { + IndexUUID string + + AcceptDataLoss *bool + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r DanglingIndicesImportDanglingIndexRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_dangling") + 1 + len(r.IndexUUID)) + path.WriteString("/") + path.WriteString("_dangling") + path.WriteString("/") + path.WriteString(r.IndexUUID) + + params = make(map[string]string) + + if r.AcceptDataLoss != nil { + params["accept_data_loss"] = strconv.FormatBool(*r.AcceptDataLoss) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f DanglingIndicesImportDanglingIndex) WithContext(v context.Context) func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + r.ctx = v + } +} + +// WithAcceptDataLoss - must be set to true in order to import the dangling index. +// +func (f DanglingIndicesImportDanglingIndex) WithAcceptDataLoss(v bool) func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + r.AcceptDataLoss = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f DanglingIndicesImportDanglingIndex) WithMasterTimeout(v time.Duration) func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f DanglingIndicesImportDanglingIndex) WithTimeout(v time.Duration) func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f DanglingIndicesImportDanglingIndex) WithPretty() func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f DanglingIndicesImportDanglingIndex) WithHuman() func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f DanglingIndicesImportDanglingIndex) WithErrorTrace() func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f DanglingIndicesImportDanglingIndex) WithFilterPath(v ...string) func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f DanglingIndicesImportDanglingIndex) WithHeader(h map[string]string) func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f DanglingIndicesImportDanglingIndex) WithOpaqueID(s string) func(*DanglingIndicesImportDanglingIndexRequest) { + return func(r *DanglingIndicesImportDanglingIndexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.list_dangling_indices.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.list_dangling_indices.go new file mode 100644 index 000000000..a45237767 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.dangling_indices.list_dangling_indices.go @@ -0,0 +1,202 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" +) + +func newDanglingIndicesListDanglingIndicesFunc(t Transport) DanglingIndicesListDanglingIndices { + return func(o ...func(*DanglingIndicesListDanglingIndicesRequest)) (*Response, error) { + var r = DanglingIndicesListDanglingIndicesRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// DanglingIndicesListDanglingIndices returns all dangling indices. +// +// +type DanglingIndicesListDanglingIndices func(o ...func(*DanglingIndicesListDanglingIndicesRequest)) (*Response, error) + +// DanglingIndicesListDanglingIndicesRequest configures the Dangling Indices List Dangling Indices API request. +// +type DanglingIndicesListDanglingIndicesRequest struct { + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r DanglingIndicesListDanglingIndicesRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_dangling")) + path.WriteString("/_dangling") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f DanglingIndicesListDanglingIndices) WithContext(v context.Context) func(*DanglingIndicesListDanglingIndicesRequest) { + return func(r *DanglingIndicesListDanglingIndicesRequest) { + r.ctx = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f DanglingIndicesListDanglingIndices) WithPretty() func(*DanglingIndicesListDanglingIndicesRequest) { + return func(r *DanglingIndicesListDanglingIndicesRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f DanglingIndicesListDanglingIndices) WithHuman() func(*DanglingIndicesListDanglingIndicesRequest) { + return func(r *DanglingIndicesListDanglingIndicesRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f DanglingIndicesListDanglingIndices) WithErrorTrace() func(*DanglingIndicesListDanglingIndicesRequest) { + return func(r *DanglingIndicesListDanglingIndicesRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f DanglingIndicesListDanglingIndices) WithFilterPath(v ...string) func(*DanglingIndicesListDanglingIndicesRequest) { + return func(r *DanglingIndicesListDanglingIndicesRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f DanglingIndicesListDanglingIndices) WithHeader(h map[string]string) func(*DanglingIndicesListDanglingIndicesRequest) { + return func(r *DanglingIndicesListDanglingIndicesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f DanglingIndicesListDanglingIndices) WithOpaqueID(s string) func(*DanglingIndicesListDanglingIndicesRequest) { + return func(r *DanglingIndicesListDanglingIndicesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete.go new file mode 100644 index 000000000..ac62544fa --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete.go @@ -0,0 +1,332 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newDeleteFunc(t Transport) Delete { + return func(index string, id string, o ...func(*DeleteRequest)) (*Response, error) { + var r = DeleteRequest{Index: index, DocumentID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Delete removes a document from the index. +// +// +type Delete func(index string, id string, o ...func(*DeleteRequest)) (*Response, error) + +// DeleteRequest configures the Delete API request. +// +type DeleteRequest struct { + Index string + DocumentType string + DocumentID string + + IfPrimaryTerm *int + IfSeqNo *int + Refresh string + Routing string + Timeout time.Duration + Version *int + VersionType string + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r DeleteRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID)) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString(r.DocumentID) + + params = make(map[string]string) + + if r.IfPrimaryTerm != nil { + params["if_primary_term"] = strconv.FormatInt(int64(*r.IfPrimaryTerm), 10) + } + + if r.IfSeqNo != nil { + params["if_seq_no"] = strconv.FormatInt(int64(*r.IfSeqNo), 10) + } + + if r.Refresh != "" { + params["refresh"] = r.Refresh + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Delete) WithContext(v context.Context) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.ctx = v + } +} + +// WithDocumentType - the type of the document. +// +func (f Delete) WithDocumentType(v string) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.DocumentType = v + } +} + +// WithIfPrimaryTerm - only perform the delete operation if the last operation that has changed the document has the specified primary term. +// +func (f Delete) WithIfPrimaryTerm(v int) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.IfPrimaryTerm = &v + } +} + +// WithIfSeqNo - only perform the delete operation if the last operation that has changed the document has the specified sequence number. +// +func (f Delete) WithIfSeqNo(v int) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.IfSeqNo = &v + } +} + +// WithRefresh - if `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.. +// +func (f Delete) WithRefresh(v string) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.Refresh = v + } +} + +// WithRouting - specific routing value. +// +func (f Delete) WithRouting(v string) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.Routing = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f Delete) WithTimeout(v time.Duration) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.Timeout = v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f Delete) WithVersion(v int) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f Delete) WithVersionType(v string) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.VersionType = v + } +} + +// WithWaitForActiveShards - sets the number of shard copies that must be active before proceeding with the delete operation. defaults to 1, meaning the primary shard only. set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1). +// +func (f Delete) WithWaitForActiveShards(v string) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Delete) WithPretty() func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Delete) WithHuman() func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Delete) WithErrorTrace() func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Delete) WithFilterPath(v ...string) func(*DeleteRequest) { + return func(r *DeleteRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Delete) WithHeader(h map[string]string) func(*DeleteRequest) { + return func(r *DeleteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Delete) WithOpaqueID(s string) func(*DeleteRequest) { + return func(r *DeleteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_by_query.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_by_query.go new file mode 100644 index 000000000..0b30fe3e2 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_by_query.go @@ -0,0 +1,660 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "fmt" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newDeleteByQueryFunc(t Transport) DeleteByQuery { + return func(index []string, body io.Reader, o ...func(*DeleteByQueryRequest)) (*Response, error) { + var r = DeleteByQueryRequest{Index: index, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// DeleteByQuery deletes documents matching the provided query. +// +// +type DeleteByQuery func(index []string, body io.Reader, o ...func(*DeleteByQueryRequest)) (*Response, error) + +// DeleteByQueryRequest configures the Delete By Query API request. +// +type DeleteByQueryRequest struct { + Index []string + DocumentType []string + + Body io.Reader + + AllowNoIndices *bool + Analyzer string + AnalyzeWildcard *bool + Conflicts string + DefaultOperator string + Df string + ExpandWildcards string + From *int + IgnoreUnavailable *bool + Lenient *bool + MaxDocs *int + Preference string + Query string + Refresh *bool + RequestCache *bool + RequestsPerSecond *int + Routing []string + Scroll time.Duration + ScrollSize *int + SearchTimeout time.Duration + SearchType string + Size *int + Slices interface{} + Sort []string + Source []string + SourceExcludes []string + SourceIncludes []string + Stats []string + TerminateAfter *int + Timeout time.Duration + Version *bool + WaitForActiveShards string + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r DeleteByQueryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("_delete_by_query")) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("_delete_by_query") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.Analyzer != "" { + params["analyzer"] = r.Analyzer + } + + if r.AnalyzeWildcard != nil { + params["analyze_wildcard"] = strconv.FormatBool(*r.AnalyzeWildcard) + } + + if r.Conflicts != "" { + params["conflicts"] = r.Conflicts + } + + if r.DefaultOperator != "" { + params["default_operator"] = r.DefaultOperator + } + + if r.Df != "" { + params["df"] = r.Df + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.From != nil { + params["from"] = strconv.FormatInt(int64(*r.From), 10) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Lenient != nil { + params["lenient"] = strconv.FormatBool(*r.Lenient) + } + + if r.MaxDocs != nil { + params["max_docs"] = strconv.FormatInt(int64(*r.MaxDocs), 10) + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Query != "" { + params["q"] = r.Query + } + + if r.Refresh != nil { + params["refresh"] = strconv.FormatBool(*r.Refresh) + } + + if r.RequestCache != nil { + params["request_cache"] = strconv.FormatBool(*r.RequestCache) + } + + if r.RequestsPerSecond != nil { + params["requests_per_second"] = strconv.FormatInt(int64(*r.RequestsPerSecond), 10) + } + + if len(r.Routing) > 0 { + params["routing"] = strings.Join(r.Routing, ",") + } + + if r.Scroll != 0 { + params["scroll"] = formatDuration(r.Scroll) + } + + if r.ScrollSize != nil { + params["scroll_size"] = strconv.FormatInt(int64(*r.ScrollSize), 10) + } + + if r.SearchTimeout != 0 { + params["search_timeout"] = formatDuration(r.SearchTimeout) + } + + if r.SearchType != "" { + params["search_type"] = r.SearchType + } + + if r.Size != nil { + params["size"] = strconv.FormatInt(int64(*r.Size), 10) + } + + if r.Slices != nil { + params["slices"] = fmt.Sprintf("%v", r.Slices) + } + + if len(r.Sort) > 0 { + params["sort"] = strings.Join(r.Sort, ",") + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if len(r.Stats) > 0 { + params["stats"] = strings.Join(r.Stats, ",") + } + + if r.TerminateAfter != nil { + params["terminate_after"] = strconv.FormatInt(int64(*r.TerminateAfter), 10) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Version != nil { + params["version"] = strconv.FormatBool(*r.Version) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f DeleteByQuery) WithContext(v context.Context) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.ctx = v + } +} + +// WithDocumentType - a list of document types to search; leave empty to perform the operation on all types. +// +func (f DeleteByQuery) WithDocumentType(v ...string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f DeleteByQuery) WithAllowNoIndices(v bool) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.AllowNoIndices = &v + } +} + +// WithAnalyzer - the analyzer to use for the query string. +// +func (f DeleteByQuery) WithAnalyzer(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Analyzer = v + } +} + +// WithAnalyzeWildcard - specify whether wildcard and prefix queries should be analyzed (default: false). +// +func (f DeleteByQuery) WithAnalyzeWildcard(v bool) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.AnalyzeWildcard = &v + } +} + +// WithConflicts - what to do when the delete by query hits version conflicts?. +// +func (f DeleteByQuery) WithConflicts(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Conflicts = v + } +} + +// WithDefaultOperator - the default operator for query string query (and or or). +// +func (f DeleteByQuery) WithDefaultOperator(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.DefaultOperator = v + } +} + +// WithDf - the field to use as default where no field prefix is given in the query string. +// +func (f DeleteByQuery) WithDf(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Df = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f DeleteByQuery) WithExpandWildcards(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.ExpandWildcards = v + } +} + +// WithFrom - starting offset (default: 0). +// +func (f DeleteByQuery) WithFrom(v int) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.From = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f DeleteByQuery) WithIgnoreUnavailable(v bool) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLenient - specify whether format-based query failures (such as providing text to a numeric field) should be ignored. +// +func (f DeleteByQuery) WithLenient(v bool) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Lenient = &v + } +} + +// WithMaxDocs - maximum number of documents to process (default: all documents). +// +func (f DeleteByQuery) WithMaxDocs(v int) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.MaxDocs = &v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f DeleteByQuery) WithPreference(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Preference = v + } +} + +// WithQuery - query in the lucene query string syntax. +// +func (f DeleteByQuery) WithQuery(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Query = v + } +} + +// WithRefresh - should the effected indexes be refreshed?. +// +func (f DeleteByQuery) WithRefresh(v bool) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Refresh = &v + } +} + +// WithRequestCache - specify if request cache should be used for this request or not, defaults to index level setting. +// +func (f DeleteByQuery) WithRequestCache(v bool) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.RequestCache = &v + } +} + +// WithRequestsPerSecond - the throttle for this request in sub-requests per second. -1 means no throttle.. +// +func (f DeleteByQuery) WithRequestsPerSecond(v int) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.RequestsPerSecond = &v + } +} + +// WithRouting - a list of specific routing values. +// +func (f DeleteByQuery) WithRouting(v ...string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Routing = v + } +} + +// WithScroll - specify how long a consistent view of the index should be maintained for scrolled search. +// +func (f DeleteByQuery) WithScroll(v time.Duration) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Scroll = v + } +} + +// WithScrollSize - size on the scroll request powering the delete by query. +// +func (f DeleteByQuery) WithScrollSize(v int) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.ScrollSize = &v + } +} + +// WithSearchTimeout - explicit timeout for each search request. defaults to no timeout.. +// +func (f DeleteByQuery) WithSearchTimeout(v time.Duration) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.SearchTimeout = v + } +} + +// WithSearchType - search operation type. +// +func (f DeleteByQuery) WithSearchType(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.SearchType = v + } +} + +// WithSize - deprecated, please use `max_docs` instead. +// +func (f DeleteByQuery) WithSize(v int) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Size = &v + } +} + +// WithSlices - the number of slices this task should be divided into. defaults to 1, meaning the task isn't sliced into subtasks. can be set to `auto`.. +// +func (f DeleteByQuery) WithSlices(v interface{}) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Slices = v + } +} + +// WithSort - a list of : pairs. +// +func (f DeleteByQuery) WithSort(v ...string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Sort = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f DeleteByQuery) WithSource(v ...string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f DeleteByQuery) WithSourceExcludes(v ...string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f DeleteByQuery) WithSourceIncludes(v ...string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.SourceIncludes = v + } +} + +// WithStats - specific 'tag' of the request for logging and statistical purposes. +// +func (f DeleteByQuery) WithStats(v ...string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Stats = v + } +} + +// WithTerminateAfter - the maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.. +// +func (f DeleteByQuery) WithTerminateAfter(v int) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.TerminateAfter = &v + } +} + +// WithTimeout - time each individual bulk request should wait for shards that are unavailable.. +// +func (f DeleteByQuery) WithTimeout(v time.Duration) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Timeout = v + } +} + +// WithVersion - specify whether to return document version as part of a hit. +// +func (f DeleteByQuery) WithVersion(v bool) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Version = &v + } +} + +// WithWaitForActiveShards - sets the number of shard copies that must be active before proceeding with the delete by query operation. defaults to 1, meaning the primary shard only. set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1). +// +func (f DeleteByQuery) WithWaitForActiveShards(v string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.WaitForActiveShards = v + } +} + +// WithWaitForCompletion - should the request should block until the delete by query is complete.. +// +func (f DeleteByQuery) WithWaitForCompletion(v bool) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f DeleteByQuery) WithPretty() func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f DeleteByQuery) WithHuman() func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f DeleteByQuery) WithErrorTrace() func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f DeleteByQuery) WithFilterPath(v ...string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f DeleteByQuery) WithHeader(h map[string]string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f DeleteByQuery) WithOpaqueID(s string) func(*DeleteByQueryRequest) { + return func(r *DeleteByQueryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_by_query_rethrottle.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_by_query_rethrottle.go new file mode 100644 index 000000000..befdf5adb --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_by_query_rethrottle.go @@ -0,0 +1,224 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newDeleteByQueryRethrottleFunc(t Transport) DeleteByQueryRethrottle { + return func(task_id string, requests_per_second *int, o ...func(*DeleteByQueryRethrottleRequest)) (*Response, error) { + var r = DeleteByQueryRethrottleRequest{TaskID: task_id, RequestsPerSecond: requests_per_second} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// DeleteByQueryRethrottle changes the number of requests per second for a particular Delete By Query operation. +// +// +type DeleteByQueryRethrottle func(task_id string, requests_per_second *int, o ...func(*DeleteByQueryRethrottleRequest)) (*Response, error) + +// DeleteByQueryRethrottleRequest configures the Delete By Query Rethrottle API request. +// +type DeleteByQueryRethrottleRequest struct { + TaskID string + + RequestsPerSecond *int + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r DeleteByQueryRethrottleRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_delete_by_query") + 1 + len(r.TaskID) + 1 + len("_rethrottle")) + path.WriteString("/") + path.WriteString("_delete_by_query") + path.WriteString("/") + path.WriteString(r.TaskID) + path.WriteString("/") + path.WriteString("_rethrottle") + + params = make(map[string]string) + + if r.RequestsPerSecond != nil { + params["requests_per_second"] = strconv.FormatInt(int64(*r.RequestsPerSecond), 10) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f DeleteByQueryRethrottle) WithContext(v context.Context) func(*DeleteByQueryRethrottleRequest) { + return func(r *DeleteByQueryRethrottleRequest) { + r.ctx = v + } +} + +// WithRequestsPerSecond - the throttle to set on this request in floating sub-requests per second. -1 means set no throttle.. +// +func (f DeleteByQueryRethrottle) WithRequestsPerSecond(v int) func(*DeleteByQueryRethrottleRequest) { + return func(r *DeleteByQueryRethrottleRequest) { + r.RequestsPerSecond = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f DeleteByQueryRethrottle) WithPretty() func(*DeleteByQueryRethrottleRequest) { + return func(r *DeleteByQueryRethrottleRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f DeleteByQueryRethrottle) WithHuman() func(*DeleteByQueryRethrottleRequest) { + return func(r *DeleteByQueryRethrottleRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f DeleteByQueryRethrottle) WithErrorTrace() func(*DeleteByQueryRethrottleRequest) { + return func(r *DeleteByQueryRethrottleRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f DeleteByQueryRethrottle) WithFilterPath(v ...string) func(*DeleteByQueryRethrottleRequest) { + return func(r *DeleteByQueryRethrottleRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f DeleteByQueryRethrottle) WithHeader(h map[string]string) func(*DeleteByQueryRethrottleRequest) { + return func(r *DeleteByQueryRethrottleRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f DeleteByQueryRethrottle) WithOpaqueID(s string) func(*DeleteByQueryRethrottleRequest) { + return func(r *DeleteByQueryRethrottleRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_script.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_script.go new file mode 100644 index 000000000..e2a7aee61 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.delete_script.go @@ -0,0 +1,235 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newDeleteScriptFunc(t Transport) DeleteScript { + return func(id string, o ...func(*DeleteScriptRequest)) (*Response, error) { + var r = DeleteScriptRequest{ScriptID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// DeleteScript deletes a script. +// +// +type DeleteScript func(id string, o ...func(*DeleteScriptRequest)) (*Response, error) + +// DeleteScriptRequest configures the Delete Script API request. +// +type DeleteScriptRequest struct { + ScriptID string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r DeleteScriptRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_scripts") + 1 + len(r.ScriptID)) + path.WriteString("/") + path.WriteString("_scripts") + path.WriteString("/") + path.WriteString(r.ScriptID) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f DeleteScript) WithContext(v context.Context) func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f DeleteScript) WithMasterTimeout(v time.Duration) func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f DeleteScript) WithTimeout(v time.Duration) func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f DeleteScript) WithPretty() func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f DeleteScript) WithHuman() func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f DeleteScript) WithErrorTrace() func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f DeleteScript) WithFilterPath(v ...string) func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f DeleteScript) WithHeader(h map[string]string) func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f DeleteScript) WithOpaqueID(s string) func(*DeleteScriptRequest) { + return func(r *DeleteScriptRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.exists.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.exists.go new file mode 100644 index 000000000..2918844a8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.exists.go @@ -0,0 +1,357 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newExistsFunc(t Transport) Exists { + return func(index string, id string, o ...func(*ExistsRequest)) (*Response, error) { + var r = ExistsRequest{Index: index, DocumentID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Exists returns information about whether a document exists in an index. +// +// +type Exists func(index string, id string, o ...func(*ExistsRequest)) (*Response, error) + +// ExistsRequest configures the Exists API request. +// +type ExistsRequest struct { + Index string + DocumentType string + DocumentID string + + Preference string + Realtime *bool + Refresh *bool + Routing string + Source []string + SourceExcludes []string + SourceIncludes []string + StoredFields []string + Version *int + VersionType string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ExistsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID)) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString(r.DocumentID) + + params = make(map[string]string) + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Realtime != nil { + params["realtime"] = strconv.FormatBool(*r.Realtime) + } + + if r.Refresh != nil { + params["refresh"] = strconv.FormatBool(*r.Refresh) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if len(r.StoredFields) > 0 { + params["stored_fields"] = strings.Join(r.StoredFields, ",") + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Exists) WithContext(v context.Context) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.ctx = v + } +} + +// WithDocumentType - the type of the document (use `_all` to fetch the first document matching the ID across all types). +// +func (f Exists) WithDocumentType(v string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.DocumentType = v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f Exists) WithPreference(v string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.Preference = v + } +} + +// WithRealtime - specify whether to perform the operation in realtime or search mode. +// +func (f Exists) WithRealtime(v bool) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.Realtime = &v + } +} + +// WithRefresh - refresh the shard containing the document before performing the operation. +// +func (f Exists) WithRefresh(v bool) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.Refresh = &v + } +} + +// WithRouting - specific routing value. +// +func (f Exists) WithRouting(v string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.Routing = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f Exists) WithSource(v ...string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f Exists) WithSourceExcludes(v ...string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f Exists) WithSourceIncludes(v ...string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.SourceIncludes = v + } +} + +// WithStoredFields - a list of stored fields to return in the response. +// +func (f Exists) WithStoredFields(v ...string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.StoredFields = v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f Exists) WithVersion(v int) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f Exists) WithVersionType(v string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.VersionType = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Exists) WithPretty() func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Exists) WithHuman() func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Exists) WithErrorTrace() func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Exists) WithFilterPath(v ...string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Exists) WithHeader(h map[string]string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Exists) WithOpaqueID(s string) func(*ExistsRequest) { + return func(r *ExistsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.exists_source.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.exists_source.go new file mode 100644 index 000000000..b6e702a67 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.exists_source.go @@ -0,0 +1,342 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newExistsSourceFunc(t Transport) ExistsSource { + return func(index string, id string, o ...func(*ExistsSourceRequest)) (*Response, error) { + var r = ExistsSourceRequest{Index: index, DocumentID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ExistsSource returns information about whether a document source exists in an index. +// +// +type ExistsSource func(index string, id string, o ...func(*ExistsSourceRequest)) (*Response, error) + +// ExistsSourceRequest configures the Exists Source API request. +// +type ExistsSourceRequest struct { + Index string + DocumentType string + DocumentID string + + Preference string + Realtime *bool + Refresh *bool + Routing string + Source []string + SourceExcludes []string + SourceIncludes []string + Version *int + VersionType string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ExistsSourceRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID) + 1 + len("_source")) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString(r.DocumentID) + path.WriteString("/") + path.WriteString("_source") + + params = make(map[string]string) + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Realtime != nil { + params["realtime"] = strconv.FormatBool(*r.Realtime) + } + + if r.Refresh != nil { + params["refresh"] = strconv.FormatBool(*r.Refresh) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ExistsSource) WithContext(v context.Context) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.ctx = v + } +} + +// WithDocumentType - the type of the document; deprecated and optional starting with 7.0. +// +func (f ExistsSource) WithDocumentType(v string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.DocumentType = v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f ExistsSource) WithPreference(v string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.Preference = v + } +} + +// WithRealtime - specify whether to perform the operation in realtime or search mode. +// +func (f ExistsSource) WithRealtime(v bool) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.Realtime = &v + } +} + +// WithRefresh - refresh the shard containing the document before performing the operation. +// +func (f ExistsSource) WithRefresh(v bool) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.Refresh = &v + } +} + +// WithRouting - specific routing value. +// +func (f ExistsSource) WithRouting(v string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.Routing = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f ExistsSource) WithSource(v ...string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f ExistsSource) WithSourceExcludes(v ...string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f ExistsSource) WithSourceIncludes(v ...string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.SourceIncludes = v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f ExistsSource) WithVersion(v int) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f ExistsSource) WithVersionType(v string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.VersionType = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ExistsSource) WithPretty() func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ExistsSource) WithHuman() func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ExistsSource) WithErrorTrace() func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ExistsSource) WithFilterPath(v ...string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ExistsSource) WithHeader(h map[string]string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ExistsSource) WithOpaqueID(s string) func(*ExistsSourceRequest) { + return func(r *ExistsSourceRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.explain.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.explain.go new file mode 100644 index 000000000..cc855a29b --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.explain.go @@ -0,0 +1,400 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newExplainFunc(t Transport) Explain { + return func(index string, id string, o ...func(*ExplainRequest)) (*Response, error) { + var r = ExplainRequest{Index: index, DocumentID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Explain returns information about why a specific matches (or doesn't match) a query. +// +// +type Explain func(index string, id string, o ...func(*ExplainRequest)) (*Response, error) + +// ExplainRequest configures the Explain API request. +// +type ExplainRequest struct { + Index string + DocumentType string + DocumentID string + + Body io.Reader + + Analyzer string + AnalyzeWildcard *bool + DefaultOperator string + Df string + Lenient *bool + Preference string + Query string + Routing string + Source []string + SourceExcludes []string + SourceIncludes []string + StoredFields []string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ExplainRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID) + 1 + len("_explain")) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString(r.DocumentID) + path.WriteString("/") + path.WriteString("_explain") + + params = make(map[string]string) + + if r.Analyzer != "" { + params["analyzer"] = r.Analyzer + } + + if r.AnalyzeWildcard != nil { + params["analyze_wildcard"] = strconv.FormatBool(*r.AnalyzeWildcard) + } + + if r.DefaultOperator != "" { + params["default_operator"] = r.DefaultOperator + } + + if r.Df != "" { + params["df"] = r.Df + } + + if r.Lenient != nil { + params["lenient"] = strconv.FormatBool(*r.Lenient) + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Query != "" { + params["q"] = r.Query + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if len(r.StoredFields) > 0 { + params["stored_fields"] = strings.Join(r.StoredFields, ",") + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Explain) WithContext(v context.Context) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.ctx = v + } +} + +// WithBody - The query definition using the Query DSL. +// +func (f Explain) WithBody(v io.Reader) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Body = v + } +} + +// WithDocumentType - the type of the document. +// +func (f Explain) WithDocumentType(v string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.DocumentType = v + } +} + +// WithAnalyzer - the analyzer for the query string query. +// +func (f Explain) WithAnalyzer(v string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Analyzer = v + } +} + +// WithAnalyzeWildcard - specify whether wildcards and prefix queries in the query string query should be analyzed (default: false). +// +func (f Explain) WithAnalyzeWildcard(v bool) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.AnalyzeWildcard = &v + } +} + +// WithDefaultOperator - the default operator for query string query (and or or). +// +func (f Explain) WithDefaultOperator(v string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.DefaultOperator = v + } +} + +// WithDf - the default field for query string query (default: _all). +// +func (f Explain) WithDf(v string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Df = v + } +} + +// WithLenient - specify whether format-based query failures (such as providing text to a numeric field) should be ignored. +// +func (f Explain) WithLenient(v bool) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Lenient = &v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f Explain) WithPreference(v string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Preference = v + } +} + +// WithQuery - query in the lucene query string syntax. +// +func (f Explain) WithQuery(v string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Query = v + } +} + +// WithRouting - specific routing value. +// +func (f Explain) WithRouting(v string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Routing = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f Explain) WithSource(v ...string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f Explain) WithSourceExcludes(v ...string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f Explain) WithSourceIncludes(v ...string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.SourceIncludes = v + } +} + +// WithStoredFields - a list of stored fields to return in the response. +// +func (f Explain) WithStoredFields(v ...string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.StoredFields = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Explain) WithPretty() func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Explain) WithHuman() func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Explain) WithErrorTrace() func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Explain) WithFilterPath(v ...string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Explain) WithHeader(h map[string]string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Explain) WithOpaqueID(s string) func(*ExplainRequest) { + return func(r *ExplainRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.field_caps.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.field_caps.go new file mode 100644 index 000000000..5dfedc896 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.field_caps.go @@ -0,0 +1,299 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newFieldCapsFunc(t Transport) FieldCaps { + return func(o ...func(*FieldCapsRequest)) (*Response, error) { + var r = FieldCapsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// FieldCaps returns the information about the capabilities of fields among multiple indices. +// +// +type FieldCaps func(o ...func(*FieldCapsRequest)) (*Response, error) + +// FieldCapsRequest configures the Field Caps API request. +// +type FieldCapsRequest struct { + Index []string + + Body io.Reader + + AllowNoIndices *bool + ExpandWildcards string + Fields []string + IgnoreUnavailable *bool + IncludeUnmapped *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r FieldCapsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_field_caps")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_field_caps") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if len(r.Fields) > 0 { + params["fields"] = strings.Join(r.Fields, ",") + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.IncludeUnmapped != nil { + params["include_unmapped"] = strconv.FormatBool(*r.IncludeUnmapped) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f FieldCaps) WithContext(v context.Context) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.ctx = v + } +} + +// WithBody - An index filter specified with the Query DSL. +// +func (f FieldCaps) WithBody(v io.Reader) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.Body = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f FieldCaps) WithIndex(v ...string) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f FieldCaps) WithAllowNoIndices(v bool) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f FieldCaps) WithExpandWildcards(v string) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.ExpandWildcards = v + } +} + +// WithFields - a list of field names. +// +func (f FieldCaps) WithFields(v ...string) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.Fields = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f FieldCaps) WithIgnoreUnavailable(v bool) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithIncludeUnmapped - indicates whether unmapped fields should be included in the response.. +// +func (f FieldCaps) WithIncludeUnmapped(v bool) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.IncludeUnmapped = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f FieldCaps) WithPretty() func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f FieldCaps) WithHuman() func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f FieldCaps) WithErrorTrace() func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f FieldCaps) WithFilterPath(v ...string) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f FieldCaps) WithHeader(h map[string]string) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f FieldCaps) WithOpaqueID(s string) func(*FieldCapsRequest) { + return func(r *FieldCapsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get.go new file mode 100644 index 000000000..615dd7b63 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get.go @@ -0,0 +1,357 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newGetFunc(t Transport) Get { + return func(index string, id string, o ...func(*GetRequest)) (*Response, error) { + var r = GetRequest{Index: index, DocumentID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Get returns a document. +// +// +type Get func(index string, id string, o ...func(*GetRequest)) (*Response, error) + +// GetRequest configures the Get API request. +// +type GetRequest struct { + Index string + DocumentType string + DocumentID string + + Preference string + Realtime *bool + Refresh *bool + Routing string + Source []string + SourceExcludes []string + SourceIncludes []string + StoredFields []string + Version *int + VersionType string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r GetRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID)) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString(r.DocumentID) + + params = make(map[string]string) + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Realtime != nil { + params["realtime"] = strconv.FormatBool(*r.Realtime) + } + + if r.Refresh != nil { + params["refresh"] = strconv.FormatBool(*r.Refresh) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if len(r.StoredFields) > 0 { + params["stored_fields"] = strings.Join(r.StoredFields, ",") + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Get) WithContext(v context.Context) func(*GetRequest) { + return func(r *GetRequest) { + r.ctx = v + } +} + +// WithDocumentType - the type of the document (use `_all` to fetch the first document matching the ID across all types). +// +func (f Get) WithDocumentType(v string) func(*GetRequest) { + return func(r *GetRequest) { + r.DocumentType = v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f Get) WithPreference(v string) func(*GetRequest) { + return func(r *GetRequest) { + r.Preference = v + } +} + +// WithRealtime - specify whether to perform the operation in realtime or search mode. +// +func (f Get) WithRealtime(v bool) func(*GetRequest) { + return func(r *GetRequest) { + r.Realtime = &v + } +} + +// WithRefresh - refresh the shard containing the document before performing the operation. +// +func (f Get) WithRefresh(v bool) func(*GetRequest) { + return func(r *GetRequest) { + r.Refresh = &v + } +} + +// WithRouting - specific routing value. +// +func (f Get) WithRouting(v string) func(*GetRequest) { + return func(r *GetRequest) { + r.Routing = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f Get) WithSource(v ...string) func(*GetRequest) { + return func(r *GetRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f Get) WithSourceExcludes(v ...string) func(*GetRequest) { + return func(r *GetRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f Get) WithSourceIncludes(v ...string) func(*GetRequest) { + return func(r *GetRequest) { + r.SourceIncludes = v + } +} + +// WithStoredFields - a list of stored fields to return in the response. +// +func (f Get) WithStoredFields(v ...string) func(*GetRequest) { + return func(r *GetRequest) { + r.StoredFields = v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f Get) WithVersion(v int) func(*GetRequest) { + return func(r *GetRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f Get) WithVersionType(v string) func(*GetRequest) { + return func(r *GetRequest) { + r.VersionType = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Get) WithPretty() func(*GetRequest) { + return func(r *GetRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Get) WithHuman() func(*GetRequest) { + return func(r *GetRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Get) WithErrorTrace() func(*GetRequest) { + return func(r *GetRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Get) WithFilterPath(v ...string) func(*GetRequest) { + return func(r *GetRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Get) WithHeader(h map[string]string) func(*GetRequest) { + return func(r *GetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Get) WithOpaqueID(s string) func(*GetRequest) { + return func(r *GetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script.go new file mode 100644 index 000000000..4af9cc227 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script.go @@ -0,0 +1,222 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newGetScriptFunc(t Transport) GetScript { + return func(id string, o ...func(*GetScriptRequest)) (*Response, error) { + var r = GetScriptRequest{ScriptID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// GetScript returns a script. +// +// +type GetScript func(id string, o ...func(*GetScriptRequest)) (*Response, error) + +// GetScriptRequest configures the Get Script API request. +// +type GetScriptRequest struct { + ScriptID string + + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r GetScriptRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_scripts") + 1 + len(r.ScriptID)) + path.WriteString("/") + path.WriteString("_scripts") + path.WriteString("/") + path.WriteString(r.ScriptID) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f GetScript) WithContext(v context.Context) func(*GetScriptRequest) { + return func(r *GetScriptRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f GetScript) WithMasterTimeout(v time.Duration) func(*GetScriptRequest) { + return func(r *GetScriptRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f GetScript) WithPretty() func(*GetScriptRequest) { + return func(r *GetScriptRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f GetScript) WithHuman() func(*GetScriptRequest) { + return func(r *GetScriptRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f GetScript) WithErrorTrace() func(*GetScriptRequest) { + return func(r *GetScriptRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f GetScript) WithFilterPath(v ...string) func(*GetScriptRequest) { + return func(r *GetScriptRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f GetScript) WithHeader(h map[string]string) func(*GetScriptRequest) { + return func(r *GetScriptRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f GetScript) WithOpaqueID(s string) func(*GetScriptRequest) { + return func(r *GetScriptRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script_context.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script_context.go new file mode 100644 index 000000000..769a3d0c0 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script_context.go @@ -0,0 +1,204 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" +) + +func newGetScriptContextFunc(t Transport) GetScriptContext { + return func(o ...func(*GetScriptContextRequest)) (*Response, error) { + var r = GetScriptContextRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// GetScriptContext returns all script contexts. +// +// This API is experimental. +// +// +type GetScriptContext func(o ...func(*GetScriptContextRequest)) (*Response, error) + +// GetScriptContextRequest configures the Get Script Context API request. +// +type GetScriptContextRequest struct { + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r GetScriptContextRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_script_context")) + path.WriteString("/_script_context") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f GetScriptContext) WithContext(v context.Context) func(*GetScriptContextRequest) { + return func(r *GetScriptContextRequest) { + r.ctx = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f GetScriptContext) WithPretty() func(*GetScriptContextRequest) { + return func(r *GetScriptContextRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f GetScriptContext) WithHuman() func(*GetScriptContextRequest) { + return func(r *GetScriptContextRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f GetScriptContext) WithErrorTrace() func(*GetScriptContextRequest) { + return func(r *GetScriptContextRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f GetScriptContext) WithFilterPath(v ...string) func(*GetScriptContextRequest) { + return func(r *GetScriptContextRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f GetScriptContext) WithHeader(h map[string]string) func(*GetScriptContextRequest) { + return func(r *GetScriptContextRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f GetScriptContext) WithOpaqueID(s string) func(*GetScriptContextRequest) { + return func(r *GetScriptContextRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script_languages.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script_languages.go new file mode 100644 index 000000000..647bc8e0f --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_script_languages.go @@ -0,0 +1,204 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" +) + +func newGetScriptLanguagesFunc(t Transport) GetScriptLanguages { + return func(o ...func(*GetScriptLanguagesRequest)) (*Response, error) { + var r = GetScriptLanguagesRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// GetScriptLanguages returns available script types, languages and contexts +// +// This API is experimental. +// +// +type GetScriptLanguages func(o ...func(*GetScriptLanguagesRequest)) (*Response, error) + +// GetScriptLanguagesRequest configures the Get Script Languages API request. +// +type GetScriptLanguagesRequest struct { + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r GetScriptLanguagesRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_script_language")) + path.WriteString("/_script_language") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f GetScriptLanguages) WithContext(v context.Context) func(*GetScriptLanguagesRequest) { + return func(r *GetScriptLanguagesRequest) { + r.ctx = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f GetScriptLanguages) WithPretty() func(*GetScriptLanguagesRequest) { + return func(r *GetScriptLanguagesRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f GetScriptLanguages) WithHuman() func(*GetScriptLanguagesRequest) { + return func(r *GetScriptLanguagesRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f GetScriptLanguages) WithErrorTrace() func(*GetScriptLanguagesRequest) { + return func(r *GetScriptLanguagesRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f GetScriptLanguages) WithFilterPath(v ...string) func(*GetScriptLanguagesRequest) { + return func(r *GetScriptLanguagesRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f GetScriptLanguages) WithHeader(h map[string]string) func(*GetScriptLanguagesRequest) { + return func(r *GetScriptLanguagesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f GetScriptLanguages) WithOpaqueID(s string) func(*GetScriptLanguagesRequest) { + return func(r *GetScriptLanguagesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_source.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_source.go new file mode 100644 index 000000000..f204a9b09 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.get_source.go @@ -0,0 +1,346 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newGetSourceFunc(t Transport) GetSource { + return func(index string, id string, o ...func(*GetSourceRequest)) (*Response, error) { + var r = GetSourceRequest{Index: index, DocumentID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// GetSource returns the source of a document. +// +// +type GetSource func(index string, id string, o ...func(*GetSourceRequest)) (*Response, error) + +// GetSourceRequest configures the Get Source API request. +// +type GetSourceRequest struct { + Index string + DocumentType string + DocumentID string + + Preference string + Realtime *bool + Refresh *bool + Routing string + Source []string + SourceExcludes []string + SourceIncludes []string + Version *int + VersionType string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r GetSourceRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID) + 1 + len("_source")) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString(r.DocumentID) + path.WriteString("/") + path.WriteString("_source") + + params = make(map[string]string) + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Realtime != nil { + params["realtime"] = strconv.FormatBool(*r.Realtime) + } + + if r.Refresh != nil { + params["refresh"] = strconv.FormatBool(*r.Refresh) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f GetSource) WithContext(v context.Context) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.ctx = v + } +} + +// WithDocumentType - the type of the document; deprecated and optional starting with 7.0. +// +func (f GetSource) WithDocumentType(v string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.DocumentType = v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f GetSource) WithPreference(v string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.Preference = v + } +} + +// WithRealtime - specify whether to perform the operation in realtime or search mode. +// +func (f GetSource) WithRealtime(v bool) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.Realtime = &v + } +} + +// WithRefresh - refresh the shard containing the document before performing the operation. +// +func (f GetSource) WithRefresh(v bool) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.Refresh = &v + } +} + +// WithRouting - specific routing value. +// +func (f GetSource) WithRouting(v string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.Routing = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f GetSource) WithSource(v ...string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f GetSource) WithSourceExcludes(v ...string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f GetSource) WithSourceIncludes(v ...string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.SourceIncludes = v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f GetSource) WithVersion(v int) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f GetSource) WithVersionType(v string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.VersionType = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f GetSource) WithPretty() func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f GetSource) WithHuman() func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f GetSource) WithErrorTrace() func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f GetSource) WithFilterPath(v ...string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f GetSource) WithHeader(h map[string]string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f GetSource) WithOpaqueID(s string) func(*GetSourceRequest) { + return func(r *GetSourceRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.index.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.index.go new file mode 100644 index 000000000..c526ae8f9 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.index.go @@ -0,0 +1,392 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndexFunc(t Transport) Index { + return func(index string, body io.Reader, o ...func(*IndexRequest)) (*Response, error) { + var r = IndexRequest{Index: index, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Index creates or updates a document in an index. +// +// +type Index func(index string, body io.Reader, o ...func(*IndexRequest)) (*Response, error) + +// IndexRequest configures the Index API request. +// +type IndexRequest struct { + Index string + DocumentType string + DocumentID string + + Body io.Reader + + IfPrimaryTerm *int + IfSeqNo *int + OpType string + Pipeline string + Refresh string + RequireAlias *bool + Routing string + Timeout time.Duration + Version *int + VersionType string + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndexRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + if r.DocumentID != "" { + method = "PUT" + } else { + method = "POST" + } + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID)) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + if r.DocumentID != "" { + path.WriteString("/") + path.WriteString(r.DocumentID) + } + + params = make(map[string]string) + + if r.IfPrimaryTerm != nil { + params["if_primary_term"] = strconv.FormatInt(int64(*r.IfPrimaryTerm), 10) + } + + if r.IfSeqNo != nil { + params["if_seq_no"] = strconv.FormatInt(int64(*r.IfSeqNo), 10) + } + + if r.OpType != "" { + params["op_type"] = r.OpType + } + + if r.Pipeline != "" { + params["pipeline"] = r.Pipeline + } + + if r.Refresh != "" { + params["refresh"] = r.Refresh + } + + if r.RequireAlias != nil { + params["require_alias"] = strconv.FormatBool(*r.RequireAlias) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Index) WithContext(v context.Context) func(*IndexRequest) { + return func(r *IndexRequest) { + r.ctx = v + } +} + +// WithDocumentID - document ID. +// +func (f Index) WithDocumentID(v string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.DocumentID = v + } +} + +// WithDocumentType - the type of the document. +// +func (f Index) WithDocumentType(v string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.DocumentType = v + } +} + +// WithIfPrimaryTerm - only perform the index operation if the last operation that has changed the document has the specified primary term. +// +func (f Index) WithIfPrimaryTerm(v int) func(*IndexRequest) { + return func(r *IndexRequest) { + r.IfPrimaryTerm = &v + } +} + +// WithIfSeqNo - only perform the index operation if the last operation that has changed the document has the specified sequence number. +// +func (f Index) WithIfSeqNo(v int) func(*IndexRequest) { + return func(r *IndexRequest) { + r.IfSeqNo = &v + } +} + +// WithOpType - explicit operation type. defaults to `index` for requests with an explicit document ID, and to `create`for requests without an explicit document ID. +// +func (f Index) WithOpType(v string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.OpType = v + } +} + +// WithPipeline - the pipeline ID to preprocess incoming documents with. +// +func (f Index) WithPipeline(v string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.Pipeline = v + } +} + +// WithRefresh - if `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.. +// +func (f Index) WithRefresh(v string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.Refresh = v + } +} + +// WithRequireAlias - when true, requires destination to be an alias. default is false. +// +func (f Index) WithRequireAlias(v bool) func(*IndexRequest) { + return func(r *IndexRequest) { + r.RequireAlias = &v + } +} + +// WithRouting - specific routing value. +// +func (f Index) WithRouting(v string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.Routing = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f Index) WithTimeout(v time.Duration) func(*IndexRequest) { + return func(r *IndexRequest) { + r.Timeout = v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f Index) WithVersion(v int) func(*IndexRequest) { + return func(r *IndexRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f Index) WithVersionType(v string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.VersionType = v + } +} + +// WithWaitForActiveShards - sets the number of shard copies that must be active before proceeding with the index operation. defaults to 1, meaning the primary shard only. set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1). +// +func (f Index) WithWaitForActiveShards(v string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Index) WithPretty() func(*IndexRequest) { + return func(r *IndexRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Index) WithHuman() func(*IndexRequest) { + return func(r *IndexRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Index) WithErrorTrace() func(*IndexRequest) { + return func(r *IndexRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Index) WithFilterPath(v ...string) func(*IndexRequest) { + return func(r *IndexRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Index) WithHeader(h map[string]string) func(*IndexRequest) { + return func(r *IndexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Index) WithOpaqueID(s string) func(*IndexRequest) { + return func(r *IndexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.add_block.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.add_block.go new file mode 100644 index 000000000..0f2417180 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.add_block.go @@ -0,0 +1,279 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesAddBlockFunc(t Transport) IndicesAddBlock { + return func(index []string, block string, o ...func(*IndicesAddBlockRequest)) (*Response, error) { + var r = IndicesAddBlockRequest{Index: index, Block: block} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesAddBlock adds a block to an index. +// +// +type IndicesAddBlock func(index []string, block string, o ...func(*IndicesAddBlockRequest)) (*Response, error) + +// IndicesAddBlockRequest configures the Indices Add Block API request. +// +type IndicesAddBlockRequest struct { + Index []string + + Block string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesAddBlockRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_block") + 1 + len(r.Block)) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + path.WriteString("/") + path.WriteString("_block") + path.WriteString("/") + path.WriteString(r.Block) + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesAddBlock) WithContext(v context.Context) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.ctx = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesAddBlock) WithAllowNoIndices(v bool) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesAddBlock) WithExpandWildcards(v string) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesAddBlock) WithIgnoreUnavailable(v bool) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesAddBlock) WithMasterTimeout(v time.Duration) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesAddBlock) WithTimeout(v time.Duration) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesAddBlock) WithPretty() func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesAddBlock) WithHuman() func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesAddBlock) WithErrorTrace() func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesAddBlock) WithFilterPath(v ...string) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesAddBlock) WithHeader(h map[string]string) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesAddBlock) WithOpaqueID(s string) func(*IndicesAddBlockRequest) { + return func(r *IndicesAddBlockRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.analyze.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.analyze.go new file mode 100644 index 000000000..e3f039d1f --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.analyze.go @@ -0,0 +1,236 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" +) + +func newIndicesAnalyzeFunc(t Transport) IndicesAnalyze { + return func(o ...func(*IndicesAnalyzeRequest)) (*Response, error) { + var r = IndicesAnalyzeRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesAnalyze performs the analysis process on a text and return the tokens breakdown of the text. +// +// +type IndicesAnalyze func(o ...func(*IndicesAnalyzeRequest)) (*Response, error) + +// IndicesAnalyzeRequest configures the Indices Analyze API request. +// +type IndicesAnalyzeRequest struct { + Index string + + Body io.Reader + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesAnalyzeRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(r.Index) + 1 + len("_analyze")) + if r.Index != "" { + path.WriteString("/") + path.WriteString(r.Index) + } + path.WriteString("/") + path.WriteString("_analyze") + + params = make(map[string]string) + + if r.Index != "" { + params["index"] = r.Index + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesAnalyze) WithContext(v context.Context) func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + r.ctx = v + } +} + +// WithBody - Define analyzer/tokenizer parameters and the text on which the analysis should be performed. +// +func (f IndicesAnalyze) WithBody(v io.Reader) func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + r.Body = v + } +} + +// WithIndex - the name of the index to scope the operation. +// +func (f IndicesAnalyze) WithIndex(v string) func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + r.Index = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesAnalyze) WithPretty() func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesAnalyze) WithHuman() func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesAnalyze) WithErrorTrace() func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesAnalyze) WithFilterPath(v ...string) func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesAnalyze) WithHeader(h map[string]string) func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesAnalyze) WithOpaqueID(s string) func(*IndicesAnalyzeRequest) { + return func(r *IndicesAnalyzeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.clear_cache.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.clear_cache.go new file mode 100644 index 000000000..f3ce8cef6 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.clear_cache.go @@ -0,0 +1,316 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesClearCacheFunc(t Transport) IndicesClearCache { + return func(o ...func(*IndicesClearCacheRequest)) (*Response, error) { + var r = IndicesClearCacheRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesClearCache clears all or specific caches for one or more indices. +// +// +type IndicesClearCache func(o ...func(*IndicesClearCacheRequest)) (*Response, error) + +// IndicesClearCacheRequest configures the Indices Clear Cache API request. +// +type IndicesClearCacheRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + Fielddata *bool + Fields []string + IgnoreUnavailable *bool + Query *bool + Request *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesClearCacheRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_cache") + 1 + len("clear")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_cache") + path.WriteString("/") + path.WriteString("clear") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Fielddata != nil { + params["fielddata"] = strconv.FormatBool(*r.Fielddata) + } + + if len(r.Fields) > 0 { + params["fields"] = strings.Join(r.Fields, ",") + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if len(r.Index) > 0 { + params["index"] = strings.Join(r.Index, ",") + } + + if r.Query != nil { + params["query"] = strconv.FormatBool(*r.Query) + } + + if r.Request != nil { + params["request"] = strconv.FormatBool(*r.Request) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesClearCache) WithContext(v context.Context) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index name to limit the operation. +// +func (f IndicesClearCache) WithIndex(v ...string) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesClearCache) WithAllowNoIndices(v bool) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesClearCache) WithExpandWildcards(v string) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.ExpandWildcards = v + } +} + +// WithFielddata - clear field data. +// +func (f IndicesClearCache) WithFielddata(v bool) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.Fielddata = &v + } +} + +// WithFields - a list of fields to clear when using the `fielddata` parameter (default: all). +// +func (f IndicesClearCache) WithFields(v ...string) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.Fields = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesClearCache) WithIgnoreUnavailable(v bool) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithQuery - clear query caches. +// +func (f IndicesClearCache) WithQuery(v bool) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.Query = &v + } +} + +// WithRequest - clear request cache. +// +func (f IndicesClearCache) WithRequest(v bool) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.Request = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesClearCache) WithPretty() func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesClearCache) WithHuman() func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesClearCache) WithErrorTrace() func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesClearCache) WithFilterPath(v ...string) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesClearCache) WithHeader(h map[string]string) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesClearCache) WithOpaqueID(s string) func(*IndicesClearCacheRequest) { + return func(r *IndicesClearCacheRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.clone.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.clone.go new file mode 100644 index 000000000..177085178 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.clone.go @@ -0,0 +1,267 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" + "time" +) + +func newIndicesCloneFunc(t Transport) IndicesClone { + return func(index string, target string, o ...func(*IndicesCloneRequest)) (*Response, error) { + var r = IndicesCloneRequest{Index: index, Target: target} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesClone clones an index +// +// +type IndicesClone func(index string, target string, o ...func(*IndicesCloneRequest)) (*Response, error) + +// IndicesCloneRequest configures the Indices Clone API request. +// +type IndicesCloneRequest struct { + Index string + + Body io.Reader + + Target string + + MasterTimeout time.Duration + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesCloneRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len(r.Index) + 1 + len("_clone") + 1 + len(r.Target)) + path.WriteString("/") + path.WriteString(r.Index) + path.WriteString("/") + path.WriteString("_clone") + path.WriteString("/") + path.WriteString(r.Target) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesClone) WithContext(v context.Context) func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.ctx = v + } +} + +// WithBody - The configuration for the target index (`settings` and `aliases`). +// +func (f IndicesClone) WithBody(v io.Reader) func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.Body = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesClone) WithMasterTimeout(v time.Duration) func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesClone) WithTimeout(v time.Duration) func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - set the number of active shards to wait for on the cloned index before the operation returns.. +// +func (f IndicesClone) WithWaitForActiveShards(v string) func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesClone) WithPretty() func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesClone) WithHuman() func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesClone) WithErrorTrace() func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesClone) WithFilterPath(v ...string) func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesClone) WithHeader(h map[string]string) func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesClone) WithOpaqueID(s string) func(*IndicesCloneRequest) { + return func(r *IndicesCloneRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.close.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.close.go new file mode 100644 index 000000000..32bf1b54e --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.close.go @@ -0,0 +1,288 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesCloseFunc(t Transport) IndicesClose { + return func(index []string, o ...func(*IndicesCloseRequest)) (*Response, error) { + var r = IndicesCloseRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesClose closes an index. +// +// +type IndicesClose func(index []string, o ...func(*IndicesCloseRequest)) (*Response, error) + +// IndicesCloseRequest configures the Indices Close API request. +// +type IndicesCloseRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + MasterTimeout time.Duration + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesCloseRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_close")) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + path.WriteString("/") + path.WriteString("_close") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesClose) WithContext(v context.Context) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.ctx = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesClose) WithAllowNoIndices(v bool) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesClose) WithExpandWildcards(v string) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesClose) WithIgnoreUnavailable(v bool) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesClose) WithMasterTimeout(v time.Duration) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesClose) WithTimeout(v time.Duration) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - sets the number of active shards to wait for before the operation returns. set to `index-setting` to wait according to the index setting `index.write.wait_for_active_shards`, or `all` to wait for all shards, or an integer. defaults to `0`.. +// +func (f IndicesClose) WithWaitForActiveShards(v string) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesClose) WithPretty() func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesClose) WithHuman() func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesClose) WithErrorTrace() func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesClose) WithFilterPath(v ...string) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesClose) WithHeader(h map[string]string) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesClose) WithOpaqueID(s string) func(*IndicesCloseRequest) { + return func(r *IndicesCloseRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.create.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.create.go new file mode 100644 index 000000000..b01703732 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.create.go @@ -0,0 +1,275 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesCreateFunc(t Transport) IndicesCreate { + return func(index string, o ...func(*IndicesCreateRequest)) (*Response, error) { + var r = IndicesCreateRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesCreate creates an index with optional settings and mappings. +// +// +type IndicesCreate func(index string, o ...func(*IndicesCreateRequest)) (*Response, error) + +// IndicesCreateRequest configures the Indices Create API request. +// +type IndicesCreateRequest struct { + Index string + + Body io.Reader + + IncludeTypeName *bool + MasterTimeout time.Duration + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesCreateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len(r.Index)) + path.WriteString("/") + path.WriteString(r.Index) + + params = make(map[string]string) + + if r.IncludeTypeName != nil { + params["include_type_name"] = strconv.FormatBool(*r.IncludeTypeName) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesCreate) WithContext(v context.Context) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.ctx = v + } +} + +// WithBody - The configuration for the index (`settings` and `mappings`). +// +func (f IndicesCreate) WithBody(v io.Reader) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.Body = v + } +} + +// WithIncludeTypeName - whether a type should be expected in the body of the mappings.. +// +func (f IndicesCreate) WithIncludeTypeName(v bool) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.IncludeTypeName = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesCreate) WithMasterTimeout(v time.Duration) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesCreate) WithTimeout(v time.Duration) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - set the number of active shards to wait for before the operation returns.. +// +func (f IndicesCreate) WithWaitForActiveShards(v string) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesCreate) WithPretty() func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesCreate) WithHuman() func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesCreate) WithErrorTrace() func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesCreate) WithFilterPath(v ...string) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesCreate) WithHeader(h map[string]string) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesCreate) WithOpaqueID(s string) func(*IndicesCreateRequest) { + return func(r *IndicesCreateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete.go new file mode 100644 index 000000000..401e6eb71 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete.go @@ -0,0 +1,273 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesDeleteFunc(t Transport) IndicesDelete { + return func(index []string, o ...func(*IndicesDeleteRequest)) (*Response, error) { + var r = IndicesDeleteRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesDelete deletes an index. +// +// +type IndicesDelete func(index []string, o ...func(*IndicesDeleteRequest)) (*Response, error) + +// IndicesDeleteRequest configures the Indices Delete API request. +// +type IndicesDeleteRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesDeleteRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesDelete) WithContext(v context.Context) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.ctx = v + } +} + +// WithAllowNoIndices - ignore if a wildcard expression resolves to no concrete indices (default: false). +// +func (f IndicesDelete) WithAllowNoIndices(v bool) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether wildcard expressions should get expanded to open or closed indices (default: open). +// +func (f IndicesDelete) WithExpandWildcards(v string) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - ignore unavailable indexes (default: false). +// +func (f IndicesDelete) WithIgnoreUnavailable(v bool) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesDelete) WithMasterTimeout(v time.Duration) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesDelete) WithTimeout(v time.Duration) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesDelete) WithPretty() func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesDelete) WithHuman() func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesDelete) WithErrorTrace() func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesDelete) WithFilterPath(v ...string) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesDelete) WithHeader(h map[string]string) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesDelete) WithOpaqueID(s string) func(*IndicesDeleteRequest) { + return func(r *IndicesDeleteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_alias.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_alias.go new file mode 100644 index 000000000..46220832a --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_alias.go @@ -0,0 +1,239 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newIndicesDeleteAliasFunc(t Transport) IndicesDeleteAlias { + return func(index []string, name []string, o ...func(*IndicesDeleteAliasRequest)) (*Response, error) { + var r = IndicesDeleteAliasRequest{Index: index, Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesDeleteAlias deletes an alias. +// +// +type IndicesDeleteAlias func(index []string, name []string, o ...func(*IndicesDeleteAliasRequest)) (*Response, error) + +// IndicesDeleteAliasRequest configures the Indices Delete Alias API request. +// +type IndicesDeleteAliasRequest struct { + Index []string + + Name []string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesDeleteAliasRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_aliases") + 1 + len(strings.Join(r.Name, ","))) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + path.WriteString("/") + path.WriteString("_aliases") + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesDeleteAlias) WithContext(v context.Context) func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesDeleteAlias) WithMasterTimeout(v time.Duration) func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit timestamp for the document. +// +func (f IndicesDeleteAlias) WithTimeout(v time.Duration) func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesDeleteAlias) WithPretty() func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesDeleteAlias) WithHuman() func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesDeleteAlias) WithErrorTrace() func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesDeleteAlias) WithFilterPath(v ...string) func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesDeleteAlias) WithHeader(h map[string]string) func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesDeleteAlias) WithOpaqueID(s string) func(*IndicesDeleteAliasRequest) { + return func(r *IndicesDeleteAliasRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_index_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_index_template.go new file mode 100644 index 000000000..19e77aedf --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_index_template.go @@ -0,0 +1,235 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newIndicesDeleteIndexTemplateFunc(t Transport) IndicesDeleteIndexTemplate { + return func(name string, o ...func(*IndicesDeleteIndexTemplateRequest)) (*Response, error) { + var r = IndicesDeleteIndexTemplateRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesDeleteIndexTemplate deletes an index template. +// +// +type IndicesDeleteIndexTemplate func(name string, o ...func(*IndicesDeleteIndexTemplateRequest)) (*Response, error) + +// IndicesDeleteIndexTemplateRequest configures the Indices Delete Index Template API request. +// +type IndicesDeleteIndexTemplateRequest struct { + Name string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesDeleteIndexTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_index_template") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_index_template") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesDeleteIndexTemplate) WithContext(v context.Context) func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesDeleteIndexTemplate) WithMasterTimeout(v time.Duration) func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesDeleteIndexTemplate) WithTimeout(v time.Duration) func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesDeleteIndexTemplate) WithPretty() func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesDeleteIndexTemplate) WithHuman() func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesDeleteIndexTemplate) WithErrorTrace() func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesDeleteIndexTemplate) WithFilterPath(v ...string) func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesDeleteIndexTemplate) WithHeader(h map[string]string) func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesDeleteIndexTemplate) WithOpaqueID(s string) func(*IndicesDeleteIndexTemplateRequest) { + return func(r *IndicesDeleteIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_template.go new file mode 100644 index 000000000..c5f22b22e --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.delete_template.go @@ -0,0 +1,235 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newIndicesDeleteTemplateFunc(t Transport) IndicesDeleteTemplate { + return func(name string, o ...func(*IndicesDeleteTemplateRequest)) (*Response, error) { + var r = IndicesDeleteTemplateRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesDeleteTemplate deletes an index template. +// +// +type IndicesDeleteTemplate func(name string, o ...func(*IndicesDeleteTemplateRequest)) (*Response, error) + +// IndicesDeleteTemplateRequest configures the Indices Delete Template API request. +// +type IndicesDeleteTemplateRequest struct { + Name string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesDeleteTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_template") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_template") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesDeleteTemplate) WithContext(v context.Context) func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesDeleteTemplate) WithMasterTimeout(v time.Duration) func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesDeleteTemplate) WithTimeout(v time.Duration) func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesDeleteTemplate) WithPretty() func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesDeleteTemplate) WithHuman() func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesDeleteTemplate) WithErrorTrace() func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesDeleteTemplate) WithFilterPath(v ...string) func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesDeleteTemplate) WithHeader(h map[string]string) func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesDeleteTemplate) WithOpaqueID(s string) func(*IndicesDeleteTemplateRequest) { + return func(r *IndicesDeleteTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.disk_usage.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.disk_usage.go new file mode 100644 index 000000000..da3ac56f5 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.disk_usage.go @@ -0,0 +1,276 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesDiskUsageFunc(t Transport) IndicesDiskUsage { + return func(index string, o ...func(*IndicesDiskUsageRequest)) (*Response, error) { + var r = IndicesDiskUsageRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesDiskUsage analyzes the disk usage of each field of an index or data stream +// +// This API is experimental. +// +// +type IndicesDiskUsage func(index string, o ...func(*IndicesDiskUsageRequest)) (*Response, error) + +// IndicesDiskUsageRequest configures the Indices Disk Usage API request. +// +type IndicesDiskUsageRequest struct { + Index string + + AllowNoIndices *bool + ExpandWildcards string + Flush *bool + IgnoreUnavailable *bool + RunExpensiveTasks *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesDiskUsageRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(r.Index) + 1 + len("_disk_usage")) + path.WriteString("/") + path.WriteString(r.Index) + path.WriteString("/") + path.WriteString("_disk_usage") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Flush != nil { + params["flush"] = strconv.FormatBool(*r.Flush) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.RunExpensiveTasks != nil { + params["run_expensive_tasks"] = strconv.FormatBool(*r.RunExpensiveTasks) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesDiskUsage) WithContext(v context.Context) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.ctx = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesDiskUsage) WithAllowNoIndices(v bool) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesDiskUsage) WithExpandWildcards(v string) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.ExpandWildcards = v + } +} + +// WithFlush - whether flush or not before analyzing the index disk usage. defaults to true. +// +func (f IndicesDiskUsage) WithFlush(v bool) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.Flush = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesDiskUsage) WithIgnoreUnavailable(v bool) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithRunExpensiveTasks - must be set to [true] in order for the task to be performed. defaults to false.. +// +func (f IndicesDiskUsage) WithRunExpensiveTasks(v bool) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.RunExpensiveTasks = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesDiskUsage) WithPretty() func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesDiskUsage) WithHuman() func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesDiskUsage) WithErrorTrace() func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesDiskUsage) WithFilterPath(v ...string) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesDiskUsage) WithHeader(h map[string]string) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesDiskUsage) WithOpaqueID(s string) func(*IndicesDiskUsageRequest) { + return func(r *IndicesDiskUsageRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists.go new file mode 100644 index 000000000..b27334336 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists.go @@ -0,0 +1,285 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesExistsFunc(t Transport) IndicesExists { + return func(index []string, o ...func(*IndicesExistsRequest)) (*Response, error) { + var r = IndicesExistsRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesExists returns information about whether a particular index exists. +// +// +type IndicesExists func(index []string, o ...func(*IndicesExistsRequest)) (*Response, error) + +// IndicesExistsRequest configures the Indices Exists API request. +// +type IndicesExistsRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + FlatSettings *bool + IgnoreUnavailable *bool + IncludeDefaults *bool + Local *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesExistsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + path.Grow(1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.IncludeDefaults != nil { + params["include_defaults"] = strconv.FormatBool(*r.IncludeDefaults) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesExists) WithContext(v context.Context) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.ctx = v + } +} + +// WithAllowNoIndices - ignore if a wildcard expression resolves to no concrete indices (default: false). +// +func (f IndicesExists) WithAllowNoIndices(v bool) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether wildcard expressions should get expanded to open or closed indices (default: open). +// +func (f IndicesExists) WithExpandWildcards(v string) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.ExpandWildcards = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f IndicesExists) WithFlatSettings(v bool) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.FlatSettings = &v + } +} + +// WithIgnoreUnavailable - ignore unavailable indexes (default: false). +// +func (f IndicesExists) WithIgnoreUnavailable(v bool) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithIncludeDefaults - whether to return all default setting for each of the indices.. +// +func (f IndicesExists) WithIncludeDefaults(v bool) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.IncludeDefaults = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesExists) WithLocal(v bool) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.Local = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesExists) WithPretty() func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesExists) WithHuman() func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesExists) WithErrorTrace() func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesExists) WithFilterPath(v ...string) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesExists) WithHeader(h map[string]string) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesExists) WithOpaqueID(s string) func(*IndicesExistsRequest) { + return func(r *IndicesExistsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_alias.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_alias.go new file mode 100644 index 000000000..cf80d38a5 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_alias.go @@ -0,0 +1,275 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesExistsAliasFunc(t Transport) IndicesExistsAlias { + return func(name []string, o ...func(*IndicesExistsAliasRequest)) (*Response, error) { + var r = IndicesExistsAliasRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesExistsAlias returns information about whether a particular alias exists. +// +// +type IndicesExistsAlias func(name []string, o ...func(*IndicesExistsAliasRequest)) (*Response, error) + +// IndicesExistsAliasRequest configures the Indices Exists Alias API request. +// +type IndicesExistsAliasRequest struct { + Index []string + + Name []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + Local *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesExistsAliasRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_alias") + 1 + len(strings.Join(r.Name, ","))) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_alias") + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesExistsAlias) WithContext(v context.Context) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to filter aliases. +// +func (f IndicesExistsAlias) WithIndex(v ...string) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesExistsAlias) WithAllowNoIndices(v bool) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesExistsAlias) WithExpandWildcards(v string) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesExistsAlias) WithIgnoreUnavailable(v bool) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesExistsAlias) WithLocal(v bool) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.Local = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesExistsAlias) WithPretty() func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesExistsAlias) WithHuman() func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesExistsAlias) WithErrorTrace() func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesExistsAlias) WithFilterPath(v ...string) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesExistsAlias) WithHeader(h map[string]string) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesExistsAlias) WithOpaqueID(s string) func(*IndicesExistsAliasRequest) { + return func(r *IndicesExistsAliasRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_index_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_index_template.go new file mode 100644 index 000000000..3e8b11a41 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_index_template.go @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesExistsIndexTemplateFunc(t Transport) IndicesExistsIndexTemplate { + return func(name string, o ...func(*IndicesExistsIndexTemplateRequest)) (*Response, error) { + var r = IndicesExistsIndexTemplateRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesExistsIndexTemplate returns information about whether a particular index template exists. +// +// +type IndicesExistsIndexTemplate func(name string, o ...func(*IndicesExistsIndexTemplateRequest)) (*Response, error) + +// IndicesExistsIndexTemplateRequest configures the Indices Exists Index Template API request. +// +type IndicesExistsIndexTemplateRequest struct { + Name string + + FlatSettings *bool + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesExistsIndexTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + path.Grow(1 + len("_index_template") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_index_template") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesExistsIndexTemplate) WithContext(v context.Context) func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + r.ctx = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f IndicesExistsIndexTemplate) WithFlatSettings(v bool) func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + r.FlatSettings = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesExistsIndexTemplate) WithLocal(v bool) func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f IndicesExistsIndexTemplate) WithMasterTimeout(v time.Duration) func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesExistsIndexTemplate) WithPretty() func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesExistsIndexTemplate) WithHuman() func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesExistsIndexTemplate) WithErrorTrace() func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesExistsIndexTemplate) WithFilterPath(v ...string) func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesExistsIndexTemplate) WithHeader(h map[string]string) func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesExistsIndexTemplate) WithOpaqueID(s string) func(*IndicesExistsIndexTemplateRequest) { + return func(r *IndicesExistsIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_template.go new file mode 100644 index 000000000..6feb7daa7 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_template.go @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesExistsTemplateFunc(t Transport) IndicesExistsTemplate { + return func(name []string, o ...func(*IndicesExistsTemplateRequest)) (*Response, error) { + var r = IndicesExistsTemplateRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesExistsTemplate returns information about whether a particular index template exists. +// +// +type IndicesExistsTemplate func(name []string, o ...func(*IndicesExistsTemplateRequest)) (*Response, error) + +// IndicesExistsTemplateRequest configures the Indices Exists Template API request. +// +type IndicesExistsTemplateRequest struct { + Name []string + + FlatSettings *bool + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesExistsTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + path.Grow(1 + len("_template") + 1 + len(strings.Join(r.Name, ","))) + path.WriteString("/") + path.WriteString("_template") + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + + params = make(map[string]string) + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesExistsTemplate) WithContext(v context.Context) func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + r.ctx = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f IndicesExistsTemplate) WithFlatSettings(v bool) func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + r.FlatSettings = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesExistsTemplate) WithLocal(v bool) func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f IndicesExistsTemplate) WithMasterTimeout(v time.Duration) func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesExistsTemplate) WithPretty() func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesExistsTemplate) WithHuman() func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesExistsTemplate) WithErrorTrace() func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesExistsTemplate) WithFilterPath(v ...string) func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesExistsTemplate) WithHeader(h map[string]string) func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesExistsTemplate) WithOpaqueID(s string) func(*IndicesExistsTemplateRequest) { + return func(r *IndicesExistsTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_type.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_type.go new file mode 100644 index 000000000..6241053a7 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.exists_type.go @@ -0,0 +1,272 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesExistsDocumentTypeFunc(t Transport) IndicesExistsDocumentType { + return func(index []string, o ...func(*IndicesExistsDocumentTypeRequest)) (*Response, error) { + var r = IndicesExistsDocumentTypeRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesExistsDocumentType returns information about whether a particular document type exists. (DEPRECATED) +// +// +type IndicesExistsDocumentType func(index []string, o ...func(*IndicesExistsDocumentTypeRequest)) (*Response, error) + +// IndicesExistsDocumentTypeRequest configures the Indices Exists Document Type API request. +// +type IndicesExistsDocumentTypeRequest struct { + Index []string + DocumentType []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + Local *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesExistsDocumentTypeRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_mapping") + 1 + len(strings.Join(r.DocumentType, ","))) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + path.WriteString("/") + path.WriteString("_mapping") + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesExistsDocumentType) WithContext(v context.Context) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.ctx = v + } +} + +// WithDocumentType - a list of document types to check. +// +func (f IndicesExistsDocumentType) WithDocumentType(v ...string) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesExistsDocumentType) WithAllowNoIndices(v bool) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesExistsDocumentType) WithExpandWildcards(v string) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesExistsDocumentType) WithIgnoreUnavailable(v bool) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesExistsDocumentType) WithLocal(v bool) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.Local = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesExistsDocumentType) WithPretty() func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesExistsDocumentType) WithHuman() func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesExistsDocumentType) WithErrorTrace() func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesExistsDocumentType) WithFilterPath(v ...string) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesExistsDocumentType) WithHeader(h map[string]string) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesExistsDocumentType) WithOpaqueID(s string) func(*IndicesExistsDocumentTypeRequest) { + return func(r *IndicesExistsDocumentTypeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.field_usage_stats.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.field_usage_stats.go new file mode 100644 index 000000000..d4a81306d --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.field_usage_stats.go @@ -0,0 +1,263 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesFieldUsageStatsFunc(t Transport) IndicesFieldUsageStats { + return func(index string, o ...func(*IndicesFieldUsageStatsRequest)) (*Response, error) { + var r = IndicesFieldUsageStatsRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesFieldUsageStats returns the field usage stats for each field of an index +// +// This API is experimental. +// +// +type IndicesFieldUsageStats func(index string, o ...func(*IndicesFieldUsageStatsRequest)) (*Response, error) + +// IndicesFieldUsageStatsRequest configures the Indices Field Usage Stats API request. +// +type IndicesFieldUsageStatsRequest struct { + Index string + + AllowNoIndices *bool + ExpandWildcards string + Fields []string + IgnoreUnavailable *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesFieldUsageStatsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(r.Index) + 1 + len("_field_usage_stats")) + path.WriteString("/") + path.WriteString(r.Index) + path.WriteString("/") + path.WriteString("_field_usage_stats") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if len(r.Fields) > 0 { + params["fields"] = strings.Join(r.Fields, ",") + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesFieldUsageStats) WithContext(v context.Context) func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.ctx = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesFieldUsageStats) WithAllowNoIndices(v bool) func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesFieldUsageStats) WithExpandWildcards(v string) func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.ExpandWildcards = v + } +} + +// WithFields - a list of fields to include in the stats if only a subset of fields should be returned (supports wildcards). +// +func (f IndicesFieldUsageStats) WithFields(v ...string) func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.Fields = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesFieldUsageStats) WithIgnoreUnavailable(v bool) func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesFieldUsageStats) WithPretty() func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesFieldUsageStats) WithHuman() func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesFieldUsageStats) WithErrorTrace() func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesFieldUsageStats) WithFilterPath(v ...string) func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesFieldUsageStats) WithHeader(h map[string]string) func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesFieldUsageStats) WithOpaqueID(s string) func(*IndicesFieldUsageStatsRequest) { + return func(r *IndicesFieldUsageStatsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.flush.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.flush.go new file mode 100644 index 000000000..347d474c9 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.flush.go @@ -0,0 +1,284 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesFlushFunc(t Transport) IndicesFlush { + return func(o ...func(*IndicesFlushRequest)) (*Response, error) { + var r = IndicesFlushRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesFlush performs the flush operation on one or more indices. +// +// +type IndicesFlush func(o ...func(*IndicesFlushRequest)) (*Response, error) + +// IndicesFlushRequest configures the Indices Flush API request. +// +type IndicesFlushRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + Force *bool + IgnoreUnavailable *bool + WaitIfOngoing *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesFlushRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_flush")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_flush") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Force != nil { + params["force"] = strconv.FormatBool(*r.Force) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.WaitIfOngoing != nil { + params["wait_if_ongoing"] = strconv.FormatBool(*r.WaitIfOngoing) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesFlush) WithContext(v context.Context) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all for all indices. +// +func (f IndicesFlush) WithIndex(v ...string) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesFlush) WithAllowNoIndices(v bool) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesFlush) WithExpandWildcards(v string) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.ExpandWildcards = v + } +} + +// WithForce - whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. this is useful if transaction log ids should be incremented even if no uncommitted changes are present. (this setting can be considered as internal). +// +func (f IndicesFlush) WithForce(v bool) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.Force = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesFlush) WithIgnoreUnavailable(v bool) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithWaitIfOngoing - if set to true the flush operation will block until the flush can be executed if another flush operation is already executing. the default is true. if set to false the flush will be skipped iff if another flush operation is already running.. +// +func (f IndicesFlush) WithWaitIfOngoing(v bool) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.WaitIfOngoing = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesFlush) WithPretty() func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesFlush) WithHuman() func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesFlush) WithErrorTrace() func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesFlush) WithFilterPath(v ...string) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesFlush) WithHeader(h map[string]string) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesFlush) WithOpaqueID(s string) func(*IndicesFlushRequest) { + return func(r *IndicesFlushRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.flush_synced.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.flush_synced.go new file mode 100644 index 000000000..a1d866ace --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.flush_synced.go @@ -0,0 +1,260 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesFlushSyncedFunc(t Transport) IndicesFlushSynced { + return func(o ...func(*IndicesFlushSyncedRequest)) (*Response, error) { + var r = IndicesFlushSyncedRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesFlushSynced performs a synced flush operation on one or more indices. Synced flush is deprecated and will be removed in 8.0. Use flush instead +// +// +type IndicesFlushSynced func(o ...func(*IndicesFlushSyncedRequest)) (*Response, error) + +// IndicesFlushSyncedRequest configures the Indices Flush Synced API request. +// +type IndicesFlushSyncedRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesFlushSyncedRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_flush") + 1 + len("synced")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_flush") + path.WriteString("/") + path.WriteString("synced") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesFlushSynced) WithContext(v context.Context) func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all for all indices. +// +func (f IndicesFlushSynced) WithIndex(v ...string) func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesFlushSynced) WithAllowNoIndices(v bool) func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesFlushSynced) WithExpandWildcards(v string) func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesFlushSynced) WithIgnoreUnavailable(v bool) func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesFlushSynced) WithPretty() func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesFlushSynced) WithHuman() func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesFlushSynced) WithErrorTrace() func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesFlushSynced) WithFilterPath(v ...string) func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesFlushSynced) WithHeader(h map[string]string) func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesFlushSynced) WithOpaqueID(s string) func(*IndicesFlushSyncedRequest) { + return func(r *IndicesFlushSyncedRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.forcemerge.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.forcemerge.go new file mode 100644 index 000000000..712cb6d5a --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.forcemerge.go @@ -0,0 +1,297 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesForcemergeFunc(t Transport) IndicesForcemerge { + return func(o ...func(*IndicesForcemergeRequest)) (*Response, error) { + var r = IndicesForcemergeRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesForcemerge performs the force merge operation on one or more indices. +// +// +type IndicesForcemerge func(o ...func(*IndicesForcemergeRequest)) (*Response, error) + +// IndicesForcemergeRequest configures the Indices Forcemerge API request. +// +type IndicesForcemergeRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + Flush *bool + IgnoreUnavailable *bool + MaxNumSegments *int + OnlyExpungeDeletes *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesForcemergeRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_forcemerge")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_forcemerge") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Flush != nil { + params["flush"] = strconv.FormatBool(*r.Flush) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.MaxNumSegments != nil { + params["max_num_segments"] = strconv.FormatInt(int64(*r.MaxNumSegments), 10) + } + + if r.OnlyExpungeDeletes != nil { + params["only_expunge_deletes"] = strconv.FormatBool(*r.OnlyExpungeDeletes) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesForcemerge) WithContext(v context.Context) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesForcemerge) WithIndex(v ...string) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesForcemerge) WithAllowNoIndices(v bool) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesForcemerge) WithExpandWildcards(v string) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.ExpandWildcards = v + } +} + +// WithFlush - specify whether the index should be flushed after performing the operation (default: true). +// +func (f IndicesForcemerge) WithFlush(v bool) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.Flush = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesForcemerge) WithIgnoreUnavailable(v bool) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithMaxNumSegments - the number of segments the index should be merged into (default: dynamic). +// +func (f IndicesForcemerge) WithMaxNumSegments(v int) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.MaxNumSegments = &v + } +} + +// WithOnlyExpungeDeletes - specify whether the operation should only expunge deleted documents. +// +func (f IndicesForcemerge) WithOnlyExpungeDeletes(v bool) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.OnlyExpungeDeletes = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesForcemerge) WithPretty() func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesForcemerge) WithHuman() func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesForcemerge) WithErrorTrace() func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesForcemerge) WithFilterPath(v ...string) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesForcemerge) WithHeader(h map[string]string) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesForcemerge) WithOpaqueID(s string) func(*IndicesForcemergeRequest) { + return func(r *IndicesForcemergeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get.go new file mode 100644 index 000000000..c852f7ea8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get.go @@ -0,0 +1,312 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesGetFunc(t Transport) IndicesGet { + return func(index []string, o ...func(*IndicesGetRequest)) (*Response, error) { + var r = IndicesGetRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesGet returns information about one or more indices. +// +// +type IndicesGet func(index []string, o ...func(*IndicesGetRequest)) (*Response, error) + +// IndicesGetRequest configures the Indices Get API request. +// +type IndicesGetRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + FlatSettings *bool + IgnoreUnavailable *bool + IncludeDefaults *bool + IncludeTypeName *bool + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesGetRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ","))) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.IncludeDefaults != nil { + params["include_defaults"] = strconv.FormatBool(*r.IncludeDefaults) + } + + if r.IncludeTypeName != nil { + params["include_type_name"] = strconv.FormatBool(*r.IncludeTypeName) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesGet) WithContext(v context.Context) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.ctx = v + } +} + +// WithAllowNoIndices - ignore if a wildcard expression resolves to no concrete indices (default: false). +// +func (f IndicesGet) WithAllowNoIndices(v bool) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether wildcard expressions should get expanded to open or closed indices (default: open). +// +func (f IndicesGet) WithExpandWildcards(v string) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.ExpandWildcards = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f IndicesGet) WithFlatSettings(v bool) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.FlatSettings = &v + } +} + +// WithIgnoreUnavailable - ignore unavailable indexes (default: false). +// +func (f IndicesGet) WithIgnoreUnavailable(v bool) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithIncludeDefaults - whether to return all default setting for each of the indices.. +// +func (f IndicesGet) WithIncludeDefaults(v bool) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.IncludeDefaults = &v + } +} + +// WithIncludeTypeName - whether to add the type name to the response (default: false). +// +func (f IndicesGet) WithIncludeTypeName(v bool) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.IncludeTypeName = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesGet) WithLocal(v bool) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesGet) WithMasterTimeout(v time.Duration) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesGet) WithPretty() func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesGet) WithHuman() func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesGet) WithErrorTrace() func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesGet) WithFilterPath(v ...string) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesGet) WithHeader(h map[string]string) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesGet) WithOpaqueID(s string) func(*IndicesGetRequest) { + return func(r *IndicesGetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_alias.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_alias.go new file mode 100644 index 000000000..5c9153878 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_alias.go @@ -0,0 +1,285 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesGetAliasFunc(t Transport) IndicesGetAlias { + return func(o ...func(*IndicesGetAliasRequest)) (*Response, error) { + var r = IndicesGetAliasRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesGetAlias returns an alias. +// +// +type IndicesGetAlias func(o ...func(*IndicesGetAliasRequest)) (*Response, error) + +// IndicesGetAliasRequest configures the Indices Get Alias API request. +// +type IndicesGetAliasRequest struct { + Index []string + + Name []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + Local *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesGetAliasRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_alias") + 1 + len(strings.Join(r.Name, ","))) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_alias") + if len(r.Name) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + } + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesGetAlias) WithContext(v context.Context) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to filter aliases. +// +func (f IndicesGetAlias) WithIndex(v ...string) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.Index = v + } +} + +// WithName - a list of alias names to return. +// +func (f IndicesGetAlias) WithName(v ...string) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.Name = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesGetAlias) WithAllowNoIndices(v bool) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesGetAlias) WithExpandWildcards(v string) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesGetAlias) WithIgnoreUnavailable(v bool) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesGetAlias) WithLocal(v bool) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.Local = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesGetAlias) WithPretty() func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesGetAlias) WithHuman() func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesGetAlias) WithErrorTrace() func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesGetAlias) WithFilterPath(v ...string) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesGetAlias) WithHeader(h map[string]string) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesGetAlias) WithOpaqueID(s string) func(*IndicesGetAliasRequest) { + return func(r *IndicesGetAliasRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_field_mapping.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_field_mapping.go new file mode 100644 index 000000000..18db396d5 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_field_mapping.go @@ -0,0 +1,316 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesGetFieldMappingFunc(t Transport) IndicesGetFieldMapping { + return func(fields []string, o ...func(*IndicesGetFieldMappingRequest)) (*Response, error) { + var r = IndicesGetFieldMappingRequest{Fields: fields} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesGetFieldMapping returns mapping for one or more fields. +// +// +type IndicesGetFieldMapping func(fields []string, o ...func(*IndicesGetFieldMappingRequest)) (*Response, error) + +// IndicesGetFieldMappingRequest configures the Indices Get Field Mapping API request. +// +type IndicesGetFieldMappingRequest struct { + Index []string + DocumentType []string + + Fields []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + IncludeDefaults *bool + IncludeTypeName *bool + Local *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesGetFieldMappingRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_mapping") + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("field") + 1 + len(strings.Join(r.Fields, ","))) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_mapping") + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("field") + path.WriteString("/") + path.WriteString(strings.Join(r.Fields, ",")) + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.IncludeDefaults != nil { + params["include_defaults"] = strconv.FormatBool(*r.IncludeDefaults) + } + + if r.IncludeTypeName != nil { + params["include_type_name"] = strconv.FormatBool(*r.IncludeTypeName) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesGetFieldMapping) WithContext(v context.Context) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names. +// +func (f IndicesGetFieldMapping) WithIndex(v ...string) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.Index = v + } +} + +// WithDocumentType - a list of document types. +// +func (f IndicesGetFieldMapping) WithDocumentType(v ...string) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesGetFieldMapping) WithAllowNoIndices(v bool) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesGetFieldMapping) WithExpandWildcards(v string) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesGetFieldMapping) WithIgnoreUnavailable(v bool) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithIncludeDefaults - whether the default mapping values should be returned as well. +// +func (f IndicesGetFieldMapping) WithIncludeDefaults(v bool) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.IncludeDefaults = &v + } +} + +// WithIncludeTypeName - whether a type should be returned in the body of the mappings.. +// +func (f IndicesGetFieldMapping) WithIncludeTypeName(v bool) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.IncludeTypeName = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesGetFieldMapping) WithLocal(v bool) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.Local = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesGetFieldMapping) WithPretty() func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesGetFieldMapping) WithHuman() func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesGetFieldMapping) WithErrorTrace() func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesGetFieldMapping) WithFilterPath(v ...string) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesGetFieldMapping) WithHeader(h map[string]string) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesGetFieldMapping) WithOpaqueID(s string) func(*IndicesGetFieldMappingRequest) { + return func(r *IndicesGetFieldMappingRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_index_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_index_template.go new file mode 100644 index 000000000..e5bb78409 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_index_template.go @@ -0,0 +1,259 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesGetIndexTemplateFunc(t Transport) IndicesGetIndexTemplate { + return func(o ...func(*IndicesGetIndexTemplateRequest)) (*Response, error) { + var r = IndicesGetIndexTemplateRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesGetIndexTemplate returns an index template. +// +// +type IndicesGetIndexTemplate func(o ...func(*IndicesGetIndexTemplateRequest)) (*Response, error) + +// IndicesGetIndexTemplateRequest configures the Indices Get Index Template API request. +// +type IndicesGetIndexTemplateRequest struct { + Name []string + + FlatSettings *bool + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesGetIndexTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_index_template") + 1 + len(strings.Join(r.Name, ","))) + path.WriteString("/") + path.WriteString("_index_template") + if len(r.Name) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + } + + params = make(map[string]string) + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesGetIndexTemplate) WithContext(v context.Context) func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.ctx = v + } +} + +// WithName - the comma separated names of the index templates. +// +func (f IndicesGetIndexTemplate) WithName(v ...string) func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.Name = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f IndicesGetIndexTemplate) WithFlatSettings(v bool) func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.FlatSettings = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesGetIndexTemplate) WithLocal(v bool) func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f IndicesGetIndexTemplate) WithMasterTimeout(v time.Duration) func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesGetIndexTemplate) WithPretty() func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesGetIndexTemplate) WithHuman() func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesGetIndexTemplate) WithErrorTrace() func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesGetIndexTemplate) WithFilterPath(v ...string) func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesGetIndexTemplate) WithHeader(h map[string]string) func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesGetIndexTemplate) WithOpaqueID(s string) func(*IndicesGetIndexTemplateRequest) { + return func(r *IndicesGetIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_mapping.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_mapping.go new file mode 100644 index 000000000..f91f6921d --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_mapping.go @@ -0,0 +1,311 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesGetMappingFunc(t Transport) IndicesGetMapping { + return func(o ...func(*IndicesGetMappingRequest)) (*Response, error) { + var r = IndicesGetMappingRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesGetMapping returns mappings for one or more indices. +// +// +type IndicesGetMapping func(o ...func(*IndicesGetMappingRequest)) (*Response, error) + +// IndicesGetMappingRequest configures the Indices Get Mapping API request. +// +type IndicesGetMappingRequest struct { + Index []string + DocumentType []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + IncludeTypeName *bool + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesGetMappingRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_mapping") + 1 + len(strings.Join(r.DocumentType, ","))) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_mapping") + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.IncludeTypeName != nil { + params["include_type_name"] = strconv.FormatBool(*r.IncludeTypeName) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesGetMapping) WithContext(v context.Context) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names. +// +func (f IndicesGetMapping) WithIndex(v ...string) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.Index = v + } +} + +// WithDocumentType - a list of document types. +// +func (f IndicesGetMapping) WithDocumentType(v ...string) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesGetMapping) WithAllowNoIndices(v bool) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesGetMapping) WithExpandWildcards(v string) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesGetMapping) WithIgnoreUnavailable(v bool) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithIncludeTypeName - whether to add the type name to the response (default: false). +// +func (f IndicesGetMapping) WithIncludeTypeName(v bool) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.IncludeTypeName = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesGetMapping) WithLocal(v bool) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesGetMapping) WithMasterTimeout(v time.Duration) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesGetMapping) WithPretty() func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesGetMapping) WithHuman() func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesGetMapping) WithErrorTrace() func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesGetMapping) WithFilterPath(v ...string) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesGetMapping) WithHeader(h map[string]string) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesGetMapping) WithOpaqueID(s string) func(*IndicesGetMappingRequest) { + return func(r *IndicesGetMappingRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_settings.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_settings.go new file mode 100644 index 000000000..f16ecdffd --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_settings.go @@ -0,0 +1,325 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesGetSettingsFunc(t Transport) IndicesGetSettings { + return func(o ...func(*IndicesGetSettingsRequest)) (*Response, error) { + var r = IndicesGetSettingsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesGetSettings returns settings for one or more indices. +// +// +type IndicesGetSettings func(o ...func(*IndicesGetSettingsRequest)) (*Response, error) + +// IndicesGetSettingsRequest configures the Indices Get Settings API request. +// +type IndicesGetSettingsRequest struct { + Index []string + + Name []string + + AllowNoIndices *bool + ExpandWildcards string + FlatSettings *bool + IgnoreUnavailable *bool + IncludeDefaults *bool + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesGetSettingsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_settings") + 1 + len(strings.Join(r.Name, ","))) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_settings") + if len(r.Name) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + } + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.IncludeDefaults != nil { + params["include_defaults"] = strconv.FormatBool(*r.IncludeDefaults) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesGetSettings) WithContext(v context.Context) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesGetSettings) WithIndex(v ...string) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.Index = v + } +} + +// WithName - the name of the settings that should be included. +// +func (f IndicesGetSettings) WithName(v ...string) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.Name = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesGetSettings) WithAllowNoIndices(v bool) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesGetSettings) WithExpandWildcards(v string) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.ExpandWildcards = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f IndicesGetSettings) WithFlatSettings(v bool) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.FlatSettings = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesGetSettings) WithIgnoreUnavailable(v bool) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithIncludeDefaults - whether to return all default setting for each of the indices.. +// +func (f IndicesGetSettings) WithIncludeDefaults(v bool) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.IncludeDefaults = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesGetSettings) WithLocal(v bool) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesGetSettings) WithMasterTimeout(v time.Duration) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesGetSettings) WithPretty() func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesGetSettings) WithHuman() func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesGetSettings) WithErrorTrace() func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesGetSettings) WithFilterPath(v ...string) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesGetSettings) WithHeader(h map[string]string) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesGetSettings) WithOpaqueID(s string) func(*IndicesGetSettingsRequest) { + return func(r *IndicesGetSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_template.go new file mode 100644 index 000000000..96cfcea55 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_template.go @@ -0,0 +1,272 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesGetTemplateFunc(t Transport) IndicesGetTemplate { + return func(o ...func(*IndicesGetTemplateRequest)) (*Response, error) { + var r = IndicesGetTemplateRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesGetTemplate returns an index template. +// +// +type IndicesGetTemplate func(o ...func(*IndicesGetTemplateRequest)) (*Response, error) + +// IndicesGetTemplateRequest configures the Indices Get Template API request. +// +type IndicesGetTemplateRequest struct { + Name []string + + FlatSettings *bool + IncludeTypeName *bool + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesGetTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_template") + 1 + len(strings.Join(r.Name, ","))) + path.WriteString("/") + path.WriteString("_template") + if len(r.Name) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + } + + params = make(map[string]string) + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.IncludeTypeName != nil { + params["include_type_name"] = strconv.FormatBool(*r.IncludeTypeName) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesGetTemplate) WithContext(v context.Context) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.ctx = v + } +} + +// WithName - the comma separated names of the index templates. +// +func (f IndicesGetTemplate) WithName(v ...string) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.Name = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f IndicesGetTemplate) WithFlatSettings(v bool) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.FlatSettings = &v + } +} + +// WithIncludeTypeName - whether a type should be returned in the body of the mappings.. +// +func (f IndicesGetTemplate) WithIncludeTypeName(v bool) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.IncludeTypeName = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f IndicesGetTemplate) WithLocal(v bool) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f IndicesGetTemplate) WithMasterTimeout(v time.Duration) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesGetTemplate) WithPretty() func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesGetTemplate) WithHuman() func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesGetTemplate) WithErrorTrace() func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesGetTemplate) WithFilterPath(v ...string) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesGetTemplate) WithHeader(h map[string]string) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesGetTemplate) WithOpaqueID(s string) func(*IndicesGetTemplateRequest) { + return func(r *IndicesGetTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_upgrade.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_upgrade.go new file mode 100644 index 000000000..b18843dc8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.get_upgrade.go @@ -0,0 +1,258 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesGetUpgradeFunc(t Transport) IndicesGetUpgrade { + return func(o ...func(*IndicesGetUpgradeRequest)) (*Response, error) { + var r = IndicesGetUpgradeRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesGetUpgrade deprecated Returns a progress status of current upgrade. +// +// +type IndicesGetUpgrade func(o ...func(*IndicesGetUpgradeRequest)) (*Response, error) + +// IndicesGetUpgradeRequest configures the Indices Get Upgrade API request. +// +type IndicesGetUpgradeRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesGetUpgradeRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_upgrade")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_upgrade") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesGetUpgrade) WithContext(v context.Context) func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesGetUpgrade) WithIndex(v ...string) func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesGetUpgrade) WithAllowNoIndices(v bool) func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesGetUpgrade) WithExpandWildcards(v string) func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesGetUpgrade) WithIgnoreUnavailable(v bool) func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesGetUpgrade) WithPretty() func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesGetUpgrade) WithHuman() func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesGetUpgrade) WithErrorTrace() func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesGetUpgrade) WithFilterPath(v ...string) func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesGetUpgrade) WithHeader(h map[string]string) func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesGetUpgrade) WithOpaqueID(s string) func(*IndicesGetUpgradeRequest) { + return func(r *IndicesGetUpgradeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.open.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.open.go new file mode 100644 index 000000000..8e7607005 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.open.go @@ -0,0 +1,288 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesOpenFunc(t Transport) IndicesOpen { + return func(index []string, o ...func(*IndicesOpenRequest)) (*Response, error) { + var r = IndicesOpenRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesOpen opens an index. +// +// +type IndicesOpen func(index []string, o ...func(*IndicesOpenRequest)) (*Response, error) + +// IndicesOpenRequest configures the Indices Open API request. +// +type IndicesOpenRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + MasterTimeout time.Duration + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesOpenRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_open")) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + path.WriteString("/") + path.WriteString("_open") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesOpen) WithContext(v context.Context) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.ctx = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesOpen) WithAllowNoIndices(v bool) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesOpen) WithExpandWildcards(v string) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesOpen) WithIgnoreUnavailable(v bool) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesOpen) WithMasterTimeout(v time.Duration) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesOpen) WithTimeout(v time.Duration) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - sets the number of active shards to wait for before the operation returns.. +// +func (f IndicesOpen) WithWaitForActiveShards(v string) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesOpen) WithPretty() func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesOpen) WithHuman() func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesOpen) WithErrorTrace() func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesOpen) WithFilterPath(v ...string) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesOpen) WithHeader(h map[string]string) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesOpen) WithOpaqueID(s string) func(*IndicesOpenRequest) { + return func(r *IndicesOpenRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_alias.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_alias.go new file mode 100644 index 000000000..64bf6ffe4 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_alias.go @@ -0,0 +1,254 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" + "time" +) + +func newIndicesPutAliasFunc(t Transport) IndicesPutAlias { + return func(index []string, name string, o ...func(*IndicesPutAliasRequest)) (*Response, error) { + var r = IndicesPutAliasRequest{Index: index, Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesPutAlias creates or updates an alias. +// +// +type IndicesPutAlias func(index []string, name string, o ...func(*IndicesPutAliasRequest)) (*Response, error) + +// IndicesPutAliasRequest configures the Indices Put Alias API request. +// +type IndicesPutAliasRequest struct { + Index []string + + Body io.Reader + + Name string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesPutAliasRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_aliases") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + path.WriteString("/") + path.WriteString("_aliases") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesPutAlias) WithContext(v context.Context) func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + r.ctx = v + } +} + +// WithBody - The settings for the alias, such as `routing` or `filter`. +// +func (f IndicesPutAlias) WithBody(v io.Reader) func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + r.Body = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesPutAlias) WithMasterTimeout(v time.Duration) func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit timestamp for the document. +// +func (f IndicesPutAlias) WithTimeout(v time.Duration) func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesPutAlias) WithPretty() func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesPutAlias) WithHuman() func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesPutAlias) WithErrorTrace() func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesPutAlias) WithFilterPath(v ...string) func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesPutAlias) WithHeader(h map[string]string) func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesPutAlias) WithOpaqueID(s string) func(*IndicesPutAliasRequest) { + return func(r *IndicesPutAliasRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_index_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_index_template.go new file mode 100644 index 000000000..05e85b133 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_index_template.go @@ -0,0 +1,256 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesPutIndexTemplateFunc(t Transport) IndicesPutIndexTemplate { + return func(name string, body io.Reader, o ...func(*IndicesPutIndexTemplateRequest)) (*Response, error) { + var r = IndicesPutIndexTemplateRequest{Name: name, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesPutIndexTemplate creates or updates an index template. +// +// +type IndicesPutIndexTemplate func(name string, body io.Reader, o ...func(*IndicesPutIndexTemplateRequest)) (*Response, error) + +// IndicesPutIndexTemplateRequest configures the Indices Put Index Template API request. +// +type IndicesPutIndexTemplateRequest struct { + Body io.Reader + + Name string + + Cause string + Create *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesPutIndexTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len("_index_template") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_index_template") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.Cause != "" { + params["cause"] = r.Cause + } + + if r.Create != nil { + params["create"] = strconv.FormatBool(*r.Create) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesPutIndexTemplate) WithContext(v context.Context) func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + r.ctx = v + } +} + +// WithCause - user defined reason for creating/updating the index template. +// +func (f IndicesPutIndexTemplate) WithCause(v string) func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + r.Cause = v + } +} + +// WithCreate - whether the index template should only be added if new or can also replace an existing one. +// +func (f IndicesPutIndexTemplate) WithCreate(v bool) func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + r.Create = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesPutIndexTemplate) WithMasterTimeout(v time.Duration) func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesPutIndexTemplate) WithPretty() func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesPutIndexTemplate) WithHuman() func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesPutIndexTemplate) WithErrorTrace() func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesPutIndexTemplate) WithFilterPath(v ...string) func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesPutIndexTemplate) WithHeader(h map[string]string) func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesPutIndexTemplate) WithOpaqueID(s string) func(*IndicesPutIndexTemplateRequest) { + return func(r *IndicesPutIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_mapping.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_mapping.go new file mode 100644 index 000000000..254b48375 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_mapping.go @@ -0,0 +1,331 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesPutMappingFunc(t Transport) IndicesPutMapping { + return func(body io.Reader, o ...func(*IndicesPutMappingRequest)) (*Response, error) { + var r = IndicesPutMappingRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesPutMapping updates the index mappings. +// +// +type IndicesPutMapping func(body io.Reader, o ...func(*IndicesPutMappingRequest)) (*Response, error) + +// IndicesPutMappingRequest configures the Indices Put Mapping API request. +// +type IndicesPutMappingRequest struct { + Index []string + DocumentType string + + Body io.Reader + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + IncludeTypeName *bool + MasterTimeout time.Duration + Timeout time.Duration + WriteIndexOnly *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesPutMappingRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(len(strings.Join(r.Index, ",")) + len("/_mapping") + len(r.DocumentType) + 2) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_mapping") + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.IncludeTypeName != nil { + params["include_type_name"] = strconv.FormatBool(*r.IncludeTypeName) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WriteIndexOnly != nil { + params["write_index_only"] = strconv.FormatBool(*r.WriteIndexOnly) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesPutMapping) WithContext(v context.Context) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.. +// +func (f IndicesPutMapping) WithIndex(v ...string) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.Index = v + } +} + +// WithDocumentType - the name of the document type. +// +func (f IndicesPutMapping) WithDocumentType(v string) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesPutMapping) WithAllowNoIndices(v bool) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesPutMapping) WithExpandWildcards(v string) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesPutMapping) WithIgnoreUnavailable(v bool) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithIncludeTypeName - whether a type should be expected in the body of the mappings.. +// +func (f IndicesPutMapping) WithIncludeTypeName(v bool) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.IncludeTypeName = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesPutMapping) WithMasterTimeout(v time.Duration) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesPutMapping) WithTimeout(v time.Duration) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.Timeout = v + } +} + +// WithWriteIndexOnly - when true, applies mappings only to the write index of an alias or data stream. +// +func (f IndicesPutMapping) WithWriteIndexOnly(v bool) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.WriteIndexOnly = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesPutMapping) WithPretty() func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesPutMapping) WithHuman() func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesPutMapping) WithErrorTrace() func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesPutMapping) WithFilterPath(v ...string) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesPutMapping) WithHeader(h map[string]string) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesPutMapping) WithOpaqueID(s string) func(*IndicesPutMappingRequest) { + return func(r *IndicesPutMappingRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_settings.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_settings.go new file mode 100644 index 000000000..ea4848056 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_settings.go @@ -0,0 +1,318 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesPutSettingsFunc(t Transport) IndicesPutSettings { + return func(body io.Reader, o ...func(*IndicesPutSettingsRequest)) (*Response, error) { + var r = IndicesPutSettingsRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesPutSettings updates the index settings. +// +// +type IndicesPutSettings func(body io.Reader, o ...func(*IndicesPutSettingsRequest)) (*Response, error) + +// IndicesPutSettingsRequest configures the Indices Put Settings API request. +// +type IndicesPutSettingsRequest struct { + Index []string + + Body io.Reader + + AllowNoIndices *bool + ExpandWildcards string + FlatSettings *bool + IgnoreUnavailable *bool + MasterTimeout time.Duration + PreserveExisting *bool + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesPutSettingsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_settings")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_settings") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.PreserveExisting != nil { + params["preserve_existing"] = strconv.FormatBool(*r.PreserveExisting) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesPutSettings) WithContext(v context.Context) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesPutSettings) WithIndex(v ...string) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesPutSettings) WithAllowNoIndices(v bool) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesPutSettings) WithExpandWildcards(v string) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.ExpandWildcards = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f IndicesPutSettings) WithFlatSettings(v bool) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.FlatSettings = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesPutSettings) WithIgnoreUnavailable(v bool) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesPutSettings) WithMasterTimeout(v time.Duration) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.MasterTimeout = v + } +} + +// WithPreserveExisting - whether to update existing settings. if set to `true` existing settings on an index remain unchanged, the default is `false`. +// +func (f IndicesPutSettings) WithPreserveExisting(v bool) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.PreserveExisting = &v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesPutSettings) WithTimeout(v time.Duration) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesPutSettings) WithPretty() func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesPutSettings) WithHuman() func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesPutSettings) WithErrorTrace() func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesPutSettings) WithFilterPath(v ...string) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesPutSettings) WithHeader(h map[string]string) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesPutSettings) WithOpaqueID(s string) func(*IndicesPutSettingsRequest) { + return func(r *IndicesPutSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_template.go new file mode 100644 index 000000000..c6468bb0f --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.put_template.go @@ -0,0 +1,269 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesPutTemplateFunc(t Transport) IndicesPutTemplate { + return func(name string, body io.Reader, o ...func(*IndicesPutTemplateRequest)) (*Response, error) { + var r = IndicesPutTemplateRequest{Name: name, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesPutTemplate creates or updates an index template. +// +// +type IndicesPutTemplate func(name string, body io.Reader, o ...func(*IndicesPutTemplateRequest)) (*Response, error) + +// IndicesPutTemplateRequest configures the Indices Put Template API request. +// +type IndicesPutTemplateRequest struct { + Body io.Reader + + Name string + + Create *bool + IncludeTypeName *bool + MasterTimeout time.Duration + Order *int + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesPutTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len("_template") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_template") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.Create != nil { + params["create"] = strconv.FormatBool(*r.Create) + } + + if r.IncludeTypeName != nil { + params["include_type_name"] = strconv.FormatBool(*r.IncludeTypeName) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Order != nil { + params["order"] = strconv.FormatInt(int64(*r.Order), 10) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesPutTemplate) WithContext(v context.Context) func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.ctx = v + } +} + +// WithCreate - whether the index template should only be added if new or can also replace an existing one. +// +func (f IndicesPutTemplate) WithCreate(v bool) func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.Create = &v + } +} + +// WithIncludeTypeName - whether a type should be returned in the body of the mappings.. +// +func (f IndicesPutTemplate) WithIncludeTypeName(v bool) func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.IncludeTypeName = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesPutTemplate) WithMasterTimeout(v time.Duration) func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithOrder - the order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers). +// +func (f IndicesPutTemplate) WithOrder(v int) func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.Order = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesPutTemplate) WithPretty() func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesPutTemplate) WithHuman() func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesPutTemplate) WithErrorTrace() func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesPutTemplate) WithFilterPath(v ...string) func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesPutTemplate) WithHeader(h map[string]string) func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesPutTemplate) WithOpaqueID(s string) func(*IndicesPutTemplateRequest) { + return func(r *IndicesPutTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.recovery.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.recovery.go new file mode 100644 index 000000000..af634d6bf --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.recovery.go @@ -0,0 +1,245 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesRecoveryFunc(t Transport) IndicesRecovery { + return func(o ...func(*IndicesRecoveryRequest)) (*Response, error) { + var r = IndicesRecoveryRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesRecovery returns information about ongoing index shard recoveries. +// +// +type IndicesRecovery func(o ...func(*IndicesRecoveryRequest)) (*Response, error) + +// IndicesRecoveryRequest configures the Indices Recovery API request. +// +type IndicesRecoveryRequest struct { + Index []string + + ActiveOnly *bool + Detailed *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesRecoveryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_recovery")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_recovery") + + params = make(map[string]string) + + if r.ActiveOnly != nil { + params["active_only"] = strconv.FormatBool(*r.ActiveOnly) + } + + if r.Detailed != nil { + params["detailed"] = strconv.FormatBool(*r.Detailed) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesRecovery) WithContext(v context.Context) func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesRecovery) WithIndex(v ...string) func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + r.Index = v + } +} + +// WithActiveOnly - display only those recoveries that are currently on-going. +// +func (f IndicesRecovery) WithActiveOnly(v bool) func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + r.ActiveOnly = &v + } +} + +// WithDetailed - whether to display detailed information about shard recovery. +// +func (f IndicesRecovery) WithDetailed(v bool) func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + r.Detailed = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesRecovery) WithPretty() func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesRecovery) WithHuman() func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesRecovery) WithErrorTrace() func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesRecovery) WithFilterPath(v ...string) func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesRecovery) WithHeader(h map[string]string) func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesRecovery) WithOpaqueID(s string) func(*IndicesRecoveryRequest) { + return func(r *IndicesRecoveryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.refresh.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.refresh.go new file mode 100644 index 000000000..f666309a9 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.refresh.go @@ -0,0 +1,258 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesRefreshFunc(t Transport) IndicesRefresh { + return func(o ...func(*IndicesRefreshRequest)) (*Response, error) { + var r = IndicesRefreshRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesRefresh performs the refresh operation in one or more indices. +// +// +type IndicesRefresh func(o ...func(*IndicesRefreshRequest)) (*Response, error) + +// IndicesRefreshRequest configures the Indices Refresh API request. +// +type IndicesRefreshRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesRefreshRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_refresh")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_refresh") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesRefresh) WithContext(v context.Context) func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesRefresh) WithIndex(v ...string) func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesRefresh) WithAllowNoIndices(v bool) func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesRefresh) WithExpandWildcards(v string) func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesRefresh) WithIgnoreUnavailable(v bool) func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesRefresh) WithPretty() func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesRefresh) WithHuman() func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesRefresh) WithErrorTrace() func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesRefresh) WithFilterPath(v ...string) func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesRefresh) WithHeader(h map[string]string) func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesRefresh) WithOpaqueID(s string) func(*IndicesRefreshRequest) { + return func(r *IndicesRefreshRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.resolve_index.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.resolve_index.go new file mode 100644 index 000000000..1411d980e --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.resolve_index.go @@ -0,0 +1,225 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" +) + +func newIndicesResolveIndexFunc(t Transport) IndicesResolveIndex { + return func(name []string, o ...func(*IndicesResolveIndexRequest)) (*Response, error) { + var r = IndicesResolveIndexRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesResolveIndex returns information about any matching indices, aliases, and data streams +// +// This API is experimental. +// +// +type IndicesResolveIndex func(name []string, o ...func(*IndicesResolveIndexRequest)) (*Response, error) + +// IndicesResolveIndexRequest configures the Indices Resolve Index API request. +// +type IndicesResolveIndexRequest struct { + Name []string + + ExpandWildcards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesResolveIndexRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_resolve") + 1 + len("index") + 1 + len(strings.Join(r.Name, ","))) + path.WriteString("/") + path.WriteString("_resolve") + path.WriteString("/") + path.WriteString("index") + path.WriteString("/") + path.WriteString(strings.Join(r.Name, ",")) + + params = make(map[string]string) + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesResolveIndex) WithContext(v context.Context) func(*IndicesResolveIndexRequest) { + return func(r *IndicesResolveIndexRequest) { + r.ctx = v + } +} + +// WithExpandWildcards - whether wildcard expressions should get expanded to open or closed indices (default: open). +// +func (f IndicesResolveIndex) WithExpandWildcards(v string) func(*IndicesResolveIndexRequest) { + return func(r *IndicesResolveIndexRequest) { + r.ExpandWildcards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesResolveIndex) WithPretty() func(*IndicesResolveIndexRequest) { + return func(r *IndicesResolveIndexRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesResolveIndex) WithHuman() func(*IndicesResolveIndexRequest) { + return func(r *IndicesResolveIndexRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesResolveIndex) WithErrorTrace() func(*IndicesResolveIndexRequest) { + return func(r *IndicesResolveIndexRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesResolveIndex) WithFilterPath(v ...string) func(*IndicesResolveIndexRequest) { + return func(r *IndicesResolveIndexRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesResolveIndex) WithHeader(h map[string]string) func(*IndicesResolveIndexRequest) { + return func(r *IndicesResolveIndexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesResolveIndex) WithOpaqueID(s string) func(*IndicesResolveIndexRequest) { + return func(r *IndicesResolveIndexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.rollover.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.rollover.go new file mode 100644 index 000000000..ffd5fa93e --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.rollover.go @@ -0,0 +1,304 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesRolloverFunc(t Transport) IndicesRollover { + return func(alias string, o ...func(*IndicesRolloverRequest)) (*Response, error) { + var r = IndicesRolloverRequest{Alias: alias} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesRollover updates an alias to point to a new index when the existing index +// is considered to be too large or too old. +// +// +type IndicesRollover func(alias string, o ...func(*IndicesRolloverRequest)) (*Response, error) + +// IndicesRolloverRequest configures the Indices Rollover API request. +// +type IndicesRolloverRequest struct { + Body io.Reader + + Alias string + NewIndex string + + DryRun *bool + IncludeTypeName *bool + MasterTimeout time.Duration + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesRolloverRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(r.Alias) + 1 + len("_rollover") + 1 + len(r.NewIndex)) + path.WriteString("/") + path.WriteString(r.Alias) + path.WriteString("/") + path.WriteString("_rollover") + if r.NewIndex != "" { + path.WriteString("/") + path.WriteString(r.NewIndex) + } + + params = make(map[string]string) + + if r.DryRun != nil { + params["dry_run"] = strconv.FormatBool(*r.DryRun) + } + + if r.IncludeTypeName != nil { + params["include_type_name"] = strconv.FormatBool(*r.IncludeTypeName) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesRollover) WithContext(v context.Context) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.ctx = v + } +} + +// WithBody - The conditions that needs to be met for executing rollover. +// +func (f IndicesRollover) WithBody(v io.Reader) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.Body = v + } +} + +// WithNewIndex - the name of the rollover index. +// +func (f IndicesRollover) WithNewIndex(v string) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.NewIndex = v + } +} + +// WithDryRun - if set to true the rollover action will only be validated but not actually performed even if a condition matches. the default is false. +// +func (f IndicesRollover) WithDryRun(v bool) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.DryRun = &v + } +} + +// WithIncludeTypeName - whether a type should be included in the body of the mappings.. +// +func (f IndicesRollover) WithIncludeTypeName(v bool) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.IncludeTypeName = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesRollover) WithMasterTimeout(v time.Duration) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesRollover) WithTimeout(v time.Duration) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - set the number of active shards to wait for on the newly created rollover index before the operation returns.. +// +func (f IndicesRollover) WithWaitForActiveShards(v string) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesRollover) WithPretty() func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesRollover) WithHuman() func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesRollover) WithErrorTrace() func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesRollover) WithFilterPath(v ...string) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesRollover) WithHeader(h map[string]string) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesRollover) WithOpaqueID(s string) func(*IndicesRolloverRequest) { + return func(r *IndicesRolloverRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.segments.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.segments.go new file mode 100644 index 000000000..60367e39e --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.segments.go @@ -0,0 +1,271 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesSegmentsFunc(t Transport) IndicesSegments { + return func(o ...func(*IndicesSegmentsRequest)) (*Response, error) { + var r = IndicesSegmentsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesSegments provides low-level information about segments in a Lucene index. +// +// +type IndicesSegments func(o ...func(*IndicesSegmentsRequest)) (*Response, error) + +// IndicesSegmentsRequest configures the Indices Segments API request. +// +type IndicesSegmentsRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + Verbose *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesSegmentsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_segments")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_segments") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Verbose != nil { + params["verbose"] = strconv.FormatBool(*r.Verbose) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesSegments) WithContext(v context.Context) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesSegments) WithIndex(v ...string) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesSegments) WithAllowNoIndices(v bool) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesSegments) WithExpandWildcards(v string) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesSegments) WithIgnoreUnavailable(v bool) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithVerbose - includes detailed memory usage by lucene.. +// +func (f IndicesSegments) WithVerbose(v bool) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.Verbose = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesSegments) WithPretty() func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesSegments) WithHuman() func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesSegments) WithErrorTrace() func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesSegments) WithFilterPath(v ...string) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesSegments) WithHeader(h map[string]string) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesSegments) WithOpaqueID(s string) func(*IndicesSegmentsRequest) { + return func(r *IndicesSegmentsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.shard_stores.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.shard_stores.go new file mode 100644 index 000000000..181c0bcf8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.shard_stores.go @@ -0,0 +1,271 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesShardStoresFunc(t Transport) IndicesShardStores { + return func(o ...func(*IndicesShardStoresRequest)) (*Response, error) { + var r = IndicesShardStoresRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesShardStores provides store information for shard copies of indices. +// +// +type IndicesShardStores func(o ...func(*IndicesShardStoresRequest)) (*Response, error) + +// IndicesShardStoresRequest configures the Indices Shard Stores API request. +// +type IndicesShardStoresRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + Status []string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesShardStoresRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_shard_stores")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_shard_stores") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if len(r.Status) > 0 { + params["status"] = strings.Join(r.Status, ",") + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesShardStores) WithContext(v context.Context) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesShardStores) WithIndex(v ...string) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesShardStores) WithAllowNoIndices(v bool) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesShardStores) WithExpandWildcards(v string) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesShardStores) WithIgnoreUnavailable(v bool) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithStatus - a list of statuses used to filter on shards to get store information for. +// +func (f IndicesShardStores) WithStatus(v ...string) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.Status = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesShardStores) WithPretty() func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesShardStores) WithHuman() func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesShardStores) WithErrorTrace() func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesShardStores) WithFilterPath(v ...string) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesShardStores) WithHeader(h map[string]string) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesShardStores) WithOpaqueID(s string) func(*IndicesShardStoresRequest) { + return func(r *IndicesShardStoresRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.shrink.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.shrink.go new file mode 100644 index 000000000..d37b4bbfd --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.shrink.go @@ -0,0 +1,281 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesShrinkFunc(t Transport) IndicesShrink { + return func(index string, target string, o ...func(*IndicesShrinkRequest)) (*Response, error) { + var r = IndicesShrinkRequest{Index: index, Target: target} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesShrink allow to shrink an existing index into a new index with fewer primary shards. +// +// +type IndicesShrink func(index string, target string, o ...func(*IndicesShrinkRequest)) (*Response, error) + +// IndicesShrinkRequest configures the Indices Shrink API request. +// +type IndicesShrinkRequest struct { + Index string + + Body io.Reader + + Target string + + CopySettings *bool + MasterTimeout time.Duration + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesShrinkRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len(r.Index) + 1 + len("_shrink") + 1 + len(r.Target)) + path.WriteString("/") + path.WriteString(r.Index) + path.WriteString("/") + path.WriteString("_shrink") + path.WriteString("/") + path.WriteString(r.Target) + + params = make(map[string]string) + + if r.CopySettings != nil { + params["copy_settings"] = strconv.FormatBool(*r.CopySettings) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesShrink) WithContext(v context.Context) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.ctx = v + } +} + +// WithBody - The configuration for the target index (`settings` and `aliases`). +// +func (f IndicesShrink) WithBody(v io.Reader) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.Body = v + } +} + +// WithCopySettings - whether or not to copy settings from the source index (defaults to false). +// +func (f IndicesShrink) WithCopySettings(v bool) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.CopySettings = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesShrink) WithMasterTimeout(v time.Duration) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesShrink) WithTimeout(v time.Duration) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - set the number of active shards to wait for on the shrunken index before the operation returns.. +// +func (f IndicesShrink) WithWaitForActiveShards(v string) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesShrink) WithPretty() func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesShrink) WithHuman() func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesShrink) WithErrorTrace() func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesShrink) WithFilterPath(v ...string) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesShrink) WithHeader(h map[string]string) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesShrink) WithOpaqueID(s string) func(*IndicesShrinkRequest) { + return func(r *IndicesShrinkRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.simulate_index_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.simulate_index_template.go new file mode 100644 index 000000000..87951d3dc --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.simulate_index_template.go @@ -0,0 +1,266 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesSimulateIndexTemplateFunc(t Transport) IndicesSimulateIndexTemplate { + return func(name string, o ...func(*IndicesSimulateIndexTemplateRequest)) (*Response, error) { + var r = IndicesSimulateIndexTemplateRequest{Name: name} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesSimulateIndexTemplate simulate matching the given index name against the index templates in the system +// +// +type IndicesSimulateIndexTemplate func(name string, o ...func(*IndicesSimulateIndexTemplateRequest)) (*Response, error) + +// IndicesSimulateIndexTemplateRequest configures the Indices Simulate Index Template API request. +// +type IndicesSimulateIndexTemplateRequest struct { + Body io.Reader + + Name string + + Cause string + Create *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesSimulateIndexTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_index_template") + 1 + len("_simulate_index") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_index_template") + path.WriteString("/") + path.WriteString("_simulate_index") + path.WriteString("/") + path.WriteString(r.Name) + + params = make(map[string]string) + + if r.Cause != "" { + params["cause"] = r.Cause + } + + if r.Create != nil { + params["create"] = strconv.FormatBool(*r.Create) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesSimulateIndexTemplate) WithContext(v context.Context) func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.ctx = v + } +} + +// WithBody - New index template definition, which will be included in the simulation, as if it already exists in the system. +// +func (f IndicesSimulateIndexTemplate) WithBody(v io.Reader) func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.Body = v + } +} + +// WithCause - user defined reason for dry-run creating the new template for simulation purposes. +// +func (f IndicesSimulateIndexTemplate) WithCause(v string) func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.Cause = v + } +} + +// WithCreate - whether the index template we optionally defined in the body should only be dry-run added if new or can also replace an existing one. +// +func (f IndicesSimulateIndexTemplate) WithCreate(v bool) func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.Create = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesSimulateIndexTemplate) WithMasterTimeout(v time.Duration) func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesSimulateIndexTemplate) WithPretty() func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesSimulateIndexTemplate) WithHuman() func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesSimulateIndexTemplate) WithErrorTrace() func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesSimulateIndexTemplate) WithFilterPath(v ...string) func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesSimulateIndexTemplate) WithHeader(h map[string]string) func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesSimulateIndexTemplate) WithOpaqueID(s string) func(*IndicesSimulateIndexTemplateRequest) { + return func(r *IndicesSimulateIndexTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.simulate_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.simulate_template.go new file mode 100644 index 000000000..12ce8e9a7 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.simulate_template.go @@ -0,0 +1,276 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesSimulateTemplateFunc(t Transport) IndicesSimulateTemplate { + return func(o ...func(*IndicesSimulateTemplateRequest)) (*Response, error) { + var r = IndicesSimulateTemplateRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesSimulateTemplate simulate resolving the given template name or body +// +// +type IndicesSimulateTemplate func(o ...func(*IndicesSimulateTemplateRequest)) (*Response, error) + +// IndicesSimulateTemplateRequest configures the Indices Simulate Template API request. +// +type IndicesSimulateTemplateRequest struct { + Body io.Reader + + Name string + + Cause string + Create *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesSimulateTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_index_template") + 1 + len("_simulate") + 1 + len(r.Name)) + path.WriteString("/") + path.WriteString("_index_template") + path.WriteString("/") + path.WriteString("_simulate") + if r.Name != "" { + path.WriteString("/") + path.WriteString(r.Name) + } + + params = make(map[string]string) + + if r.Cause != "" { + params["cause"] = r.Cause + } + + if r.Create != nil { + params["create"] = strconv.FormatBool(*r.Create) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesSimulateTemplate) WithContext(v context.Context) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.ctx = v + } +} + +// WithBody - New index template definition to be simulated, if no index template name is specified. +// +func (f IndicesSimulateTemplate) WithBody(v io.Reader) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.Body = v + } +} + +// WithName - the name of the index template. +// +func (f IndicesSimulateTemplate) WithName(v string) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.Name = v + } +} + +// WithCause - user defined reason for dry-run creating the new template for simulation purposes. +// +func (f IndicesSimulateTemplate) WithCause(v string) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.Cause = v + } +} + +// WithCreate - whether the index template we optionally defined in the body should only be dry-run added if new or can also replace an existing one. +// +func (f IndicesSimulateTemplate) WithCreate(v bool) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.Create = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesSimulateTemplate) WithMasterTimeout(v time.Duration) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesSimulateTemplate) WithPretty() func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesSimulateTemplate) WithHuman() func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesSimulateTemplate) WithErrorTrace() func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesSimulateTemplate) WithFilterPath(v ...string) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesSimulateTemplate) WithHeader(h map[string]string) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesSimulateTemplate) WithOpaqueID(s string) func(*IndicesSimulateTemplateRequest) { + return func(r *IndicesSimulateTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.split.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.split.go new file mode 100644 index 000000000..de2c9bacf --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.split.go @@ -0,0 +1,281 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newIndicesSplitFunc(t Transport) IndicesSplit { + return func(index string, target string, o ...func(*IndicesSplitRequest)) (*Response, error) { + var r = IndicesSplitRequest{Index: index, Target: target} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesSplit allows you to split an existing index into a new index with more primary shards. +// +// +type IndicesSplit func(index string, target string, o ...func(*IndicesSplitRequest)) (*Response, error) + +// IndicesSplitRequest configures the Indices Split API request. +// +type IndicesSplitRequest struct { + Index string + + Body io.Reader + + Target string + + CopySettings *bool + MasterTimeout time.Duration + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesSplitRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len(r.Index) + 1 + len("_split") + 1 + len(r.Target)) + path.WriteString("/") + path.WriteString(r.Index) + path.WriteString("/") + path.WriteString("_split") + path.WriteString("/") + path.WriteString(r.Target) + + params = make(map[string]string) + + if r.CopySettings != nil { + params["copy_settings"] = strconv.FormatBool(*r.CopySettings) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesSplit) WithContext(v context.Context) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.ctx = v + } +} + +// WithBody - The configuration for the target index (`settings` and `aliases`). +// +func (f IndicesSplit) WithBody(v io.Reader) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.Body = v + } +} + +// WithCopySettings - whether or not to copy settings from the source index (defaults to false). +// +func (f IndicesSplit) WithCopySettings(v bool) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.CopySettings = &v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesSplit) WithMasterTimeout(v time.Duration) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IndicesSplit) WithTimeout(v time.Duration) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - set the number of active shards to wait for on the shrunken index before the operation returns.. +// +func (f IndicesSplit) WithWaitForActiveShards(v string) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesSplit) WithPretty() func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesSplit) WithHuman() func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesSplit) WithErrorTrace() func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesSplit) WithFilterPath(v ...string) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesSplit) WithHeader(h map[string]string) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesSplit) WithOpaqueID(s string) func(*IndicesSplitRequest) { + return func(r *IndicesSplitRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.stats.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.stats.go new file mode 100644 index 000000000..38065bd7c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.stats.go @@ -0,0 +1,363 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesStatsFunc(t Transport) IndicesStats { + return func(o ...func(*IndicesStatsRequest)) (*Response, error) { + var r = IndicesStatsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesStats provides statistics on operations happening in an index. +// +// +type IndicesStats func(o ...func(*IndicesStatsRequest)) (*Response, error) + +// IndicesStatsRequest configures the Indices Stats API request. +// +type IndicesStatsRequest struct { + Index []string + + Metric []string + + CompletionFields []string + ExpandWildcards string + FielddataFields []string + Fields []string + ForbidClosedIndices *bool + Groups []string + IncludeSegmentFileSizes *bool + IncludeUnloadedSegments *bool + Level string + Types []string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesStatsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_stats") + 1 + len(strings.Join(r.Metric, ","))) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_stats") + if len(r.Metric) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Metric, ",")) + } + + params = make(map[string]string) + + if len(r.CompletionFields) > 0 { + params["completion_fields"] = strings.Join(r.CompletionFields, ",") + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if len(r.FielddataFields) > 0 { + params["fielddata_fields"] = strings.Join(r.FielddataFields, ",") + } + + if len(r.Fields) > 0 { + params["fields"] = strings.Join(r.Fields, ",") + } + + if r.ForbidClosedIndices != nil { + params["forbid_closed_indices"] = strconv.FormatBool(*r.ForbidClosedIndices) + } + + if len(r.Groups) > 0 { + params["groups"] = strings.Join(r.Groups, ",") + } + + if r.IncludeSegmentFileSizes != nil { + params["include_segment_file_sizes"] = strconv.FormatBool(*r.IncludeSegmentFileSizes) + } + + if r.IncludeUnloadedSegments != nil { + params["include_unloaded_segments"] = strconv.FormatBool(*r.IncludeUnloadedSegments) + } + + if r.Level != "" { + params["level"] = r.Level + } + + if len(r.Types) > 0 { + params["types"] = strings.Join(r.Types, ",") + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesStats) WithContext(v context.Context) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesStats) WithIndex(v ...string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.Index = v + } +} + +// WithMetric - limit the information returned the specific metrics.. +// +func (f IndicesStats) WithMetric(v ...string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.Metric = v + } +} + +// WithCompletionFields - a list of fields for `fielddata` and `suggest` index metric (supports wildcards). +// +func (f IndicesStats) WithCompletionFields(v ...string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.CompletionFields = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesStats) WithExpandWildcards(v string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.ExpandWildcards = v + } +} + +// WithFielddataFields - a list of fields for `fielddata` index metric (supports wildcards). +// +func (f IndicesStats) WithFielddataFields(v ...string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.FielddataFields = v + } +} + +// WithFields - a list of fields for `fielddata` and `completion` index metric (supports wildcards). +// +func (f IndicesStats) WithFields(v ...string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.Fields = v + } +} + +// WithForbidClosedIndices - if set to false stats will also collected from closed indices if explicitly specified or if expand_wildcards expands to closed indices. +// +func (f IndicesStats) WithForbidClosedIndices(v bool) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.ForbidClosedIndices = &v + } +} + +// WithGroups - a list of search groups for `search` index metric. +// +func (f IndicesStats) WithGroups(v ...string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.Groups = v + } +} + +// WithIncludeSegmentFileSizes - whether to report the aggregated disk usage of each one of the lucene index files (only applies if segment stats are requested). +// +func (f IndicesStats) WithIncludeSegmentFileSizes(v bool) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.IncludeSegmentFileSizes = &v + } +} + +// WithIncludeUnloadedSegments - if set to true segment stats will include stats for segments that are not currently loaded into memory. +// +func (f IndicesStats) WithIncludeUnloadedSegments(v bool) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.IncludeUnloadedSegments = &v + } +} + +// WithLevel - return stats aggregated at cluster, index or shard level. +// +func (f IndicesStats) WithLevel(v string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.Level = v + } +} + +// WithTypes - a list of document types for the `indexing` index metric. +// +func (f IndicesStats) WithTypes(v ...string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.Types = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesStats) WithPretty() func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesStats) WithHuman() func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesStats) WithErrorTrace() func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesStats) WithFilterPath(v ...string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesStats) WithHeader(h map[string]string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesStats) WithOpaqueID(s string) func(*IndicesStatsRequest) { + return func(r *IndicesStatsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.update_aliases.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.update_aliases.go new file mode 100644 index 000000000..49f0bc998 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.update_aliases.go @@ -0,0 +1,237 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" + "time" +) + +func newIndicesUpdateAliasesFunc(t Transport) IndicesUpdateAliases { + return func(body io.Reader, o ...func(*IndicesUpdateAliasesRequest)) (*Response, error) { + var r = IndicesUpdateAliasesRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesUpdateAliases updates index aliases. +// +// +type IndicesUpdateAliases func(body io.Reader, o ...func(*IndicesUpdateAliasesRequest)) (*Response, error) + +// IndicesUpdateAliasesRequest configures the Indices Update Aliases API request. +// +type IndicesUpdateAliasesRequest struct { + Body io.Reader + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesUpdateAliasesRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(len("/_aliases")) + path.WriteString("/_aliases") + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesUpdateAliases) WithContext(v context.Context) func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f IndicesUpdateAliases) WithMasterTimeout(v time.Duration) func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - request timeout. +// +func (f IndicesUpdateAliases) WithTimeout(v time.Duration) func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesUpdateAliases) WithPretty() func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesUpdateAliases) WithHuman() func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesUpdateAliases) WithErrorTrace() func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesUpdateAliases) WithFilterPath(v ...string) func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesUpdateAliases) WithHeader(h map[string]string) func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesUpdateAliases) WithOpaqueID(s string) func(*IndicesUpdateAliasesRequest) { + return func(r *IndicesUpdateAliasesRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.upgrade.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.upgrade.go new file mode 100644 index 000000000..bf8550a47 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.upgrade.go @@ -0,0 +1,284 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newIndicesUpgradeFunc(t Transport) IndicesUpgrade { + return func(o ...func(*IndicesUpgradeRequest)) (*Response, error) { + var r = IndicesUpgradeRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesUpgrade deprecated Upgrades to the current version of Lucene. +// +// +type IndicesUpgrade func(o ...func(*IndicesUpgradeRequest)) (*Response, error) + +// IndicesUpgradeRequest configures the Indices Upgrade API request. +// +type IndicesUpgradeRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + OnlyAncientSegments *bool + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesUpgradeRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_upgrade")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_upgrade") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.OnlyAncientSegments != nil { + params["only_ancient_segments"] = strconv.FormatBool(*r.OnlyAncientSegments) + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesUpgrade) WithContext(v context.Context) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names; use _all to perform the operation on all indices. +// +func (f IndicesUpgrade) WithIndex(v ...string) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesUpgrade) WithAllowNoIndices(v bool) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesUpgrade) WithExpandWildcards(v string) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesUpgrade) WithIgnoreUnavailable(v bool) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithOnlyAncientSegments - if true, only ancient (an older lucene major release) segments will be upgraded. +// +func (f IndicesUpgrade) WithOnlyAncientSegments(v bool) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.OnlyAncientSegments = &v + } +} + +// WithWaitForCompletion - specify whether the request should block until the all segments are upgraded (default: false). +// +func (f IndicesUpgrade) WithWaitForCompletion(v bool) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesUpgrade) WithPretty() func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesUpgrade) WithHuman() func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesUpgrade) WithErrorTrace() func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesUpgrade) WithFilterPath(v ...string) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesUpgrade) WithHeader(h map[string]string) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesUpgrade) WithOpaqueID(s string) func(*IndicesUpgradeRequest) { + return func(r *IndicesUpgradeRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.validate_query.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.validate_query.go new file mode 100644 index 000000000..2fe444726 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.indices.validate_query.go @@ -0,0 +1,405 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newIndicesValidateQueryFunc(t Transport) IndicesValidateQuery { + return func(o ...func(*IndicesValidateQueryRequest)) (*Response, error) { + var r = IndicesValidateQueryRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IndicesValidateQuery allows a user to validate a potentially expensive query without executing it. +// +// +type IndicesValidateQuery func(o ...func(*IndicesValidateQueryRequest)) (*Response, error) + +// IndicesValidateQueryRequest configures the Indices Validate Query API request. +// +type IndicesValidateQueryRequest struct { + Index []string + DocumentType []string + + Body io.Reader + + AllowNoIndices *bool + AllShards *bool + Analyzer string + AnalyzeWildcard *bool + DefaultOperator string + Df string + ExpandWildcards string + Explain *bool + IgnoreUnavailable *bool + Lenient *bool + Query string + Rewrite *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IndicesValidateQueryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("_validate") + 1 + len("query")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("_validate") + path.WriteString("/") + path.WriteString("query") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.AllShards != nil { + params["all_shards"] = strconv.FormatBool(*r.AllShards) + } + + if r.Analyzer != "" { + params["analyzer"] = r.Analyzer + } + + if r.AnalyzeWildcard != nil { + params["analyze_wildcard"] = strconv.FormatBool(*r.AnalyzeWildcard) + } + + if r.DefaultOperator != "" { + params["default_operator"] = r.DefaultOperator + } + + if r.Df != "" { + params["df"] = r.Df + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Explain != nil { + params["explain"] = strconv.FormatBool(*r.Explain) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Lenient != nil { + params["lenient"] = strconv.FormatBool(*r.Lenient) + } + + if r.Query != "" { + params["q"] = r.Query + } + + if r.Rewrite != nil { + params["rewrite"] = strconv.FormatBool(*r.Rewrite) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IndicesValidateQuery) WithContext(v context.Context) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.ctx = v + } +} + +// WithBody - The query definition specified with the Query DSL. +// +func (f IndicesValidateQuery) WithBody(v io.Reader) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Body = v + } +} + +// WithIndex - a list of index names to restrict the operation; use _all to perform the operation on all indices. +// +func (f IndicesValidateQuery) WithIndex(v ...string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Index = v + } +} + +// WithDocumentType - a list of document types to restrict the operation; leave empty to perform the operation on all types. +// +func (f IndicesValidateQuery) WithDocumentType(v ...string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f IndicesValidateQuery) WithAllowNoIndices(v bool) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.AllowNoIndices = &v + } +} + +// WithAllShards - execute validation on all shards instead of one random shard per index. +// +func (f IndicesValidateQuery) WithAllShards(v bool) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.AllShards = &v + } +} + +// WithAnalyzer - the analyzer to use for the query string. +// +func (f IndicesValidateQuery) WithAnalyzer(v string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Analyzer = v + } +} + +// WithAnalyzeWildcard - specify whether wildcard and prefix queries should be analyzed (default: false). +// +func (f IndicesValidateQuery) WithAnalyzeWildcard(v bool) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.AnalyzeWildcard = &v + } +} + +// WithDefaultOperator - the default operator for query string query (and or or). +// +func (f IndicesValidateQuery) WithDefaultOperator(v string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.DefaultOperator = v + } +} + +// WithDf - the field to use as default where no field prefix is given in the query string. +// +func (f IndicesValidateQuery) WithDf(v string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Df = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f IndicesValidateQuery) WithExpandWildcards(v string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.ExpandWildcards = v + } +} + +// WithExplain - return detailed information about the error. +// +func (f IndicesValidateQuery) WithExplain(v bool) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Explain = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f IndicesValidateQuery) WithIgnoreUnavailable(v bool) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLenient - specify whether format-based query failures (such as providing text to a numeric field) should be ignored. +// +func (f IndicesValidateQuery) WithLenient(v bool) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Lenient = &v + } +} + +// WithQuery - query in the lucene query string syntax. +// +func (f IndicesValidateQuery) WithQuery(v string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Query = v + } +} + +// WithRewrite - provide a more detailed explanation showing the actual lucene query that will be executed.. +// +func (f IndicesValidateQuery) WithRewrite(v bool) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Rewrite = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IndicesValidateQuery) WithPretty() func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IndicesValidateQuery) WithHuman() func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IndicesValidateQuery) WithErrorTrace() func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IndicesValidateQuery) WithFilterPath(v ...string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IndicesValidateQuery) WithHeader(h map[string]string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IndicesValidateQuery) WithOpaqueID(s string) func(*IndicesValidateQueryRequest) { + return func(r *IndicesValidateQueryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.info.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.info.go new file mode 100644 index 000000000..c506a52fa --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.info.go @@ -0,0 +1,194 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" +) + +func newInfoFunc(t Transport) Info { + return func(o ...func(*InfoRequest)) (*Response, error) { + var r = InfoRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Info returns basic information about the cluster. +// +// +type Info func(o ...func(*InfoRequest)) (*Response, error) + +// InfoRequest configures the Info API request. +// +type InfoRequest struct { + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r InfoRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/")) + path.WriteString("/") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Info) WithContext(v context.Context) func(*InfoRequest) { + return func(r *InfoRequest) { + r.ctx = v + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Info) WithHuman() func(*InfoRequest) { + return func(r *InfoRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Info) WithErrorTrace() func(*InfoRequest) { + return func(r *InfoRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Info) WithFilterPath(v ...string) func(*InfoRequest) { + return func(r *InfoRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Info) WithHeader(h map[string]string) func(*InfoRequest) { + return func(r *InfoRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Info) WithOpaqueID(s string) func(*InfoRequest) { + return func(r *InfoRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.delete_pipeline.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.delete_pipeline.go new file mode 100644 index 000000000..a88d8dd79 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.delete_pipeline.go @@ -0,0 +1,237 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newIngestDeletePipelineFunc(t Transport) IngestDeletePipeline { + return func(id string, o ...func(*IngestDeletePipelineRequest)) (*Response, error) { + var r = IngestDeletePipelineRequest{PipelineID: id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IngestDeletePipeline deletes a pipeline. +// +// +type IngestDeletePipeline func(id string, o ...func(*IngestDeletePipelineRequest)) (*Response, error) + +// IngestDeletePipelineRequest configures the Ingest Delete Pipeline API request. +// +type IngestDeletePipelineRequest struct { + PipelineID string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IngestDeletePipelineRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_ingest") + 1 + len("pipeline") + 1 + len(r.PipelineID)) + path.WriteString("/") + path.WriteString("_ingest") + path.WriteString("/") + path.WriteString("pipeline") + path.WriteString("/") + path.WriteString(r.PipelineID) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IngestDeletePipeline) WithContext(v context.Context) func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f IngestDeletePipeline) WithMasterTimeout(v time.Duration) func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IngestDeletePipeline) WithTimeout(v time.Duration) func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IngestDeletePipeline) WithPretty() func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IngestDeletePipeline) WithHuman() func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IngestDeletePipeline) WithErrorTrace() func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IngestDeletePipeline) WithFilterPath(v ...string) func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IngestDeletePipeline) WithHeader(h map[string]string) func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IngestDeletePipeline) WithOpaqueID(s string) func(*IngestDeletePipelineRequest) { + return func(r *IngestDeletePipelineRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.get_pipeline.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.get_pipeline.go new file mode 100644 index 000000000..57038bbc4 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.get_pipeline.go @@ -0,0 +1,248 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newIngestGetPipelineFunc(t Transport) IngestGetPipeline { + return func(o ...func(*IngestGetPipelineRequest)) (*Response, error) { + var r = IngestGetPipelineRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IngestGetPipeline returns a pipeline. +// +// +type IngestGetPipeline func(o ...func(*IngestGetPipelineRequest)) (*Response, error) + +// IngestGetPipelineRequest configures the Ingest Get Pipeline API request. +// +type IngestGetPipelineRequest struct { + PipelineID string + + MasterTimeout time.Duration + Summary *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IngestGetPipelineRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_ingest") + 1 + len("pipeline") + 1 + len(r.PipelineID)) + path.WriteString("/") + path.WriteString("_ingest") + path.WriteString("/") + path.WriteString("pipeline") + if r.PipelineID != "" { + path.WriteString("/") + path.WriteString(r.PipelineID) + } + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Summary != nil { + params["summary"] = strconv.FormatBool(*r.Summary) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IngestGetPipeline) WithContext(v context.Context) func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + r.ctx = v + } +} + +// WithPipelineID - comma separated list of pipeline ids. wildcards supported. +// +func (f IngestGetPipeline) WithPipelineID(v string) func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + r.PipelineID = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f IngestGetPipeline) WithMasterTimeout(v time.Duration) func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + r.MasterTimeout = v + } +} + +// WithSummary - return pipelines without their definitions (default: false). +// +func (f IngestGetPipeline) WithSummary(v bool) func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + r.Summary = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IngestGetPipeline) WithPretty() func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IngestGetPipeline) WithHuman() func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IngestGetPipeline) WithErrorTrace() func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IngestGetPipeline) WithFilterPath(v ...string) func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IngestGetPipeline) WithHeader(h map[string]string) func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IngestGetPipeline) WithOpaqueID(s string) func(*IngestGetPipelineRequest) { + return func(r *IngestGetPipelineRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.processor_grok.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.processor_grok.go new file mode 100644 index 000000000..978dbeece --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.processor_grok.go @@ -0,0 +1,202 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" +) + +func newIngestProcessorGrokFunc(t Transport) IngestProcessorGrok { + return func(o ...func(*IngestProcessorGrokRequest)) (*Response, error) { + var r = IngestProcessorGrokRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IngestProcessorGrok returns a list of the built-in patterns. +// +// +type IngestProcessorGrok func(o ...func(*IngestProcessorGrokRequest)) (*Response, error) + +// IngestProcessorGrokRequest configures the Ingest Processor Grok API request. +// +type IngestProcessorGrokRequest struct { + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IngestProcessorGrokRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_ingest/processor/grok")) + path.WriteString("/_ingest/processor/grok") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IngestProcessorGrok) WithContext(v context.Context) func(*IngestProcessorGrokRequest) { + return func(r *IngestProcessorGrokRequest) { + r.ctx = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IngestProcessorGrok) WithPretty() func(*IngestProcessorGrokRequest) { + return func(r *IngestProcessorGrokRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IngestProcessorGrok) WithHuman() func(*IngestProcessorGrokRequest) { + return func(r *IngestProcessorGrokRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IngestProcessorGrok) WithErrorTrace() func(*IngestProcessorGrokRequest) { + return func(r *IngestProcessorGrokRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IngestProcessorGrok) WithFilterPath(v ...string) func(*IngestProcessorGrokRequest) { + return func(r *IngestProcessorGrokRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IngestProcessorGrok) WithHeader(h map[string]string) func(*IngestProcessorGrokRequest) { + return func(r *IngestProcessorGrokRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IngestProcessorGrok) WithOpaqueID(s string) func(*IngestProcessorGrokRequest) { + return func(r *IngestProcessorGrokRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.put_pipeline.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.put_pipeline.go new file mode 100644 index 000000000..228832b2b --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.put_pipeline.go @@ -0,0 +1,244 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" + "time" +) + +func newIngestPutPipelineFunc(t Transport) IngestPutPipeline { + return func(id string, body io.Reader, o ...func(*IngestPutPipelineRequest)) (*Response, error) { + var r = IngestPutPipelineRequest{PipelineID: id, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IngestPutPipeline creates or updates a pipeline. +// +// +type IngestPutPipeline func(id string, body io.Reader, o ...func(*IngestPutPipelineRequest)) (*Response, error) + +// IngestPutPipelineRequest configures the Ingest Put Pipeline API request. +// +type IngestPutPipelineRequest struct { + PipelineID string + + Body io.Reader + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IngestPutPipelineRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len("_ingest") + 1 + len("pipeline") + 1 + len(r.PipelineID)) + path.WriteString("/") + path.WriteString("_ingest") + path.WriteString("/") + path.WriteString("pipeline") + path.WriteString("/") + path.WriteString(r.PipelineID) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IngestPutPipeline) WithContext(v context.Context) func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f IngestPutPipeline) WithMasterTimeout(v time.Duration) func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f IngestPutPipeline) WithTimeout(v time.Duration) func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IngestPutPipeline) WithPretty() func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IngestPutPipeline) WithHuman() func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IngestPutPipeline) WithErrorTrace() func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IngestPutPipeline) WithFilterPath(v ...string) func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IngestPutPipeline) WithHeader(h map[string]string) func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IngestPutPipeline) WithOpaqueID(s string) func(*IngestPutPipelineRequest) { + return func(r *IngestPutPipelineRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.simulate.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.simulate.go new file mode 100644 index 000000000..682b8d30b --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ingest.simulate.go @@ -0,0 +1,243 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newIngestSimulateFunc(t Transport) IngestSimulate { + return func(body io.Reader, o ...func(*IngestSimulateRequest)) (*Response, error) { + var r = IngestSimulateRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// IngestSimulate allows to simulate a pipeline with example documents. +// +// +type IngestSimulate func(body io.Reader, o ...func(*IngestSimulateRequest)) (*Response, error) + +// IngestSimulateRequest configures the Ingest Simulate API request. +// +type IngestSimulateRequest struct { + PipelineID string + + Body io.Reader + + Verbose *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r IngestSimulateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_ingest") + 1 + len("pipeline") + 1 + len(r.PipelineID) + 1 + len("_simulate")) + path.WriteString("/") + path.WriteString("_ingest") + path.WriteString("/") + path.WriteString("pipeline") + if r.PipelineID != "" { + path.WriteString("/") + path.WriteString(r.PipelineID) + } + path.WriteString("/") + path.WriteString("_simulate") + + params = make(map[string]string) + + if r.Verbose != nil { + params["verbose"] = strconv.FormatBool(*r.Verbose) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f IngestSimulate) WithContext(v context.Context) func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + r.ctx = v + } +} + +// WithPipelineID - pipeline ID. +// +func (f IngestSimulate) WithPipelineID(v string) func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + r.PipelineID = v + } +} + +// WithVerbose - verbose mode. display data output for each processor in executed pipeline. +// +func (f IngestSimulate) WithVerbose(v bool) func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + r.Verbose = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f IngestSimulate) WithPretty() func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f IngestSimulate) WithHuman() func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f IngestSimulate) WithErrorTrace() func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f IngestSimulate) WithFilterPath(v ...string) func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f IngestSimulate) WithHeader(h map[string]string) func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f IngestSimulate) WithOpaqueID(s string) func(*IngestSimulateRequest) { + return func(r *IngestSimulateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.mget.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.mget.go new file mode 100644 index 000000000..cd0daa519 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.mget.go @@ -0,0 +1,343 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newMgetFunc(t Transport) Mget { + return func(body io.Reader, o ...func(*MgetRequest)) (*Response, error) { + var r = MgetRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Mget allows to get multiple documents in one request. +// +// +type Mget func(body io.Reader, o ...func(*MgetRequest)) (*Response, error) + +// MgetRequest configures the Mget API request. +// +type MgetRequest struct { + Index string + DocumentType string + + Body io.Reader + + Preference string + Realtime *bool + Refresh *bool + Routing string + Source []string + SourceExcludes []string + SourceIncludes []string + StoredFields []string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r MgetRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len("_mget")) + if r.Index != "" { + path.WriteString("/") + path.WriteString(r.Index) + } + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString("_mget") + + params = make(map[string]string) + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Realtime != nil { + params["realtime"] = strconv.FormatBool(*r.Realtime) + } + + if r.Refresh != nil { + params["refresh"] = strconv.FormatBool(*r.Refresh) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if len(r.StoredFields) > 0 { + params["stored_fields"] = strings.Join(r.StoredFields, ",") + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Mget) WithContext(v context.Context) func(*MgetRequest) { + return func(r *MgetRequest) { + r.ctx = v + } +} + +// WithIndex - the name of the index. +// +func (f Mget) WithIndex(v string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.Index = v + } +} + +// WithDocumentType - the type of the document. +// +func (f Mget) WithDocumentType(v string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.DocumentType = v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f Mget) WithPreference(v string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.Preference = v + } +} + +// WithRealtime - specify whether to perform the operation in realtime or search mode. +// +func (f Mget) WithRealtime(v bool) func(*MgetRequest) { + return func(r *MgetRequest) { + r.Realtime = &v + } +} + +// WithRefresh - refresh the shard containing the document before performing the operation. +// +func (f Mget) WithRefresh(v bool) func(*MgetRequest) { + return func(r *MgetRequest) { + r.Refresh = &v + } +} + +// WithRouting - specific routing value. +// +func (f Mget) WithRouting(v string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.Routing = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f Mget) WithSource(v ...string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f Mget) WithSourceExcludes(v ...string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f Mget) WithSourceIncludes(v ...string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.SourceIncludes = v + } +} + +// WithStoredFields - a list of stored fields to return in the response. +// +func (f Mget) WithStoredFields(v ...string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.StoredFields = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Mget) WithPretty() func(*MgetRequest) { + return func(r *MgetRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Mget) WithHuman() func(*MgetRequest) { + return func(r *MgetRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Mget) WithErrorTrace() func(*MgetRequest) { + return func(r *MgetRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Mget) WithFilterPath(v ...string) func(*MgetRequest) { + return func(r *MgetRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Mget) WithHeader(h map[string]string) func(*MgetRequest) { + return func(r *MgetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Mget) WithOpaqueID(s string) func(*MgetRequest) { + return func(r *MgetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.msearch.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.msearch.go new file mode 100644 index 000000000..bd6ef8922 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.msearch.go @@ -0,0 +1,330 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newMsearchFunc(t Transport) Msearch { + return func(body io.Reader, o ...func(*MsearchRequest)) (*Response, error) { + var r = MsearchRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Msearch allows to execute several search operations in one request. +// +// +type Msearch func(body io.Reader, o ...func(*MsearchRequest)) (*Response, error) + +// MsearchRequest configures the Msearch API request. +// +type MsearchRequest struct { + Index []string + DocumentType []string + + Body io.Reader + + CcsMinimizeRoundtrips *bool + MaxConcurrentSearches *int + MaxConcurrentShardRequests *int + PreFilterShardSize *int + RestTotalHitsAsInt *bool + SearchType string + TypedKeys *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r MsearchRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("_msearch")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("_msearch") + + params = make(map[string]string) + + if r.CcsMinimizeRoundtrips != nil { + params["ccs_minimize_roundtrips"] = strconv.FormatBool(*r.CcsMinimizeRoundtrips) + } + + if r.MaxConcurrentSearches != nil { + params["max_concurrent_searches"] = strconv.FormatInt(int64(*r.MaxConcurrentSearches), 10) + } + + if r.MaxConcurrentShardRequests != nil { + params["max_concurrent_shard_requests"] = strconv.FormatInt(int64(*r.MaxConcurrentShardRequests), 10) + } + + if r.PreFilterShardSize != nil { + params["pre_filter_shard_size"] = strconv.FormatInt(int64(*r.PreFilterShardSize), 10) + } + + if r.RestTotalHitsAsInt != nil { + params["rest_total_hits_as_int"] = strconv.FormatBool(*r.RestTotalHitsAsInt) + } + + if r.SearchType != "" { + params["search_type"] = r.SearchType + } + + if r.TypedKeys != nil { + params["typed_keys"] = strconv.FormatBool(*r.TypedKeys) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Msearch) WithContext(v context.Context) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to use as default. +// +func (f Msearch) WithIndex(v ...string) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.Index = v + } +} + +// WithDocumentType - a list of document types to use as default. +// +func (f Msearch) WithDocumentType(v ...string) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.DocumentType = v + } +} + +// WithCcsMinimizeRoundtrips - indicates whether network round-trips should be minimized as part of cross-cluster search requests execution. +// +func (f Msearch) WithCcsMinimizeRoundtrips(v bool) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.CcsMinimizeRoundtrips = &v + } +} + +// WithMaxConcurrentSearches - controls the maximum number of concurrent searches the multi search api will execute. +// +func (f Msearch) WithMaxConcurrentSearches(v int) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.MaxConcurrentSearches = &v + } +} + +// WithMaxConcurrentShardRequests - the number of concurrent shard requests each sub search executes concurrently per node. this value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests. +// +func (f Msearch) WithMaxConcurrentShardRequests(v int) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.MaxConcurrentShardRequests = &v + } +} + +// WithPreFilterShardSize - a threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. this filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on its rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.. +// +func (f Msearch) WithPreFilterShardSize(v int) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.PreFilterShardSize = &v + } +} + +// WithRestTotalHitsAsInt - indicates whether hits.total should be rendered as an integer or an object in the rest search response. +// +func (f Msearch) WithRestTotalHitsAsInt(v bool) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.RestTotalHitsAsInt = &v + } +} + +// WithSearchType - search operation type. +// +func (f Msearch) WithSearchType(v string) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.SearchType = v + } +} + +// WithTypedKeys - specify whether aggregation and suggester names should be prefixed by their respective types in the response. +// +func (f Msearch) WithTypedKeys(v bool) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.TypedKeys = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Msearch) WithPretty() func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Msearch) WithHuman() func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Msearch) WithErrorTrace() func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Msearch) WithFilterPath(v ...string) func(*MsearchRequest) { + return func(r *MsearchRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Msearch) WithHeader(h map[string]string) func(*MsearchRequest) { + return func(r *MsearchRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Msearch) WithOpaqueID(s string) func(*MsearchRequest) { + return func(r *MsearchRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.msearch_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.msearch_template.go new file mode 100644 index 000000000..e9dfcda48 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.msearch_template.go @@ -0,0 +1,306 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newMsearchTemplateFunc(t Transport) MsearchTemplate { + return func(body io.Reader, o ...func(*MsearchTemplateRequest)) (*Response, error) { + var r = MsearchTemplateRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// MsearchTemplate allows to execute several search template operations in one request. +// +// +type MsearchTemplate func(body io.Reader, o ...func(*MsearchTemplateRequest)) (*Response, error) + +// MsearchTemplateRequest configures the Msearch Template API request. +// +type MsearchTemplateRequest struct { + Index []string + DocumentType []string + + Body io.Reader + + CcsMinimizeRoundtrips *bool + MaxConcurrentSearches *int + RestTotalHitsAsInt *bool + SearchType string + TypedKeys *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r MsearchTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("_msearch") + 1 + len("template")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("_msearch") + path.WriteString("/") + path.WriteString("template") + + params = make(map[string]string) + + if r.CcsMinimizeRoundtrips != nil { + params["ccs_minimize_roundtrips"] = strconv.FormatBool(*r.CcsMinimizeRoundtrips) + } + + if r.MaxConcurrentSearches != nil { + params["max_concurrent_searches"] = strconv.FormatInt(int64(*r.MaxConcurrentSearches), 10) + } + + if r.RestTotalHitsAsInt != nil { + params["rest_total_hits_as_int"] = strconv.FormatBool(*r.RestTotalHitsAsInt) + } + + if r.SearchType != "" { + params["search_type"] = r.SearchType + } + + if r.TypedKeys != nil { + params["typed_keys"] = strconv.FormatBool(*r.TypedKeys) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f MsearchTemplate) WithContext(v context.Context) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to use as default. +// +func (f MsearchTemplate) WithIndex(v ...string) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.Index = v + } +} + +// WithDocumentType - a list of document types to use as default. +// +func (f MsearchTemplate) WithDocumentType(v ...string) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.DocumentType = v + } +} + +// WithCcsMinimizeRoundtrips - indicates whether network round-trips should be minimized as part of cross-cluster search requests execution. +// +func (f MsearchTemplate) WithCcsMinimizeRoundtrips(v bool) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.CcsMinimizeRoundtrips = &v + } +} + +// WithMaxConcurrentSearches - controls the maximum number of concurrent searches the multi search api will execute. +// +func (f MsearchTemplate) WithMaxConcurrentSearches(v int) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.MaxConcurrentSearches = &v + } +} + +// WithRestTotalHitsAsInt - indicates whether hits.total should be rendered as an integer or an object in the rest search response. +// +func (f MsearchTemplate) WithRestTotalHitsAsInt(v bool) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.RestTotalHitsAsInt = &v + } +} + +// WithSearchType - search operation type. +// +func (f MsearchTemplate) WithSearchType(v string) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.SearchType = v + } +} + +// WithTypedKeys - specify whether aggregation and suggester names should be prefixed by their respective types in the response. +// +func (f MsearchTemplate) WithTypedKeys(v bool) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.TypedKeys = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f MsearchTemplate) WithPretty() func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f MsearchTemplate) WithHuman() func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f MsearchTemplate) WithErrorTrace() func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f MsearchTemplate) WithFilterPath(v ...string) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f MsearchTemplate) WithHeader(h map[string]string) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f MsearchTemplate) WithOpaqueID(s string) func(*MsearchTemplateRequest) { + return func(r *MsearchTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.mtermvectors.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.mtermvectors.go new file mode 100644 index 000000000..22d00e6a5 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.mtermvectors.go @@ -0,0 +1,403 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newMtermvectorsFunc(t Transport) Mtermvectors { + return func(o ...func(*MtermvectorsRequest)) (*Response, error) { + var r = MtermvectorsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Mtermvectors returns multiple termvectors in one request. +// +// +type Mtermvectors func(o ...func(*MtermvectorsRequest)) (*Response, error) + +// MtermvectorsRequest configures the Mtermvectors API request. +// +type MtermvectorsRequest struct { + Index string + DocumentType string + + Body io.Reader + + Fields []string + FieldStatistics *bool + Ids []string + Offsets *bool + Payloads *bool + Positions *bool + Preference string + Realtime *bool + Routing string + TermStatistics *bool + Version *int + VersionType string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r MtermvectorsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len("_mtermvectors")) + if r.Index != "" { + path.WriteString("/") + path.WriteString(r.Index) + } + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString("_mtermvectors") + + params = make(map[string]string) + + if len(r.Fields) > 0 { + params["fields"] = strings.Join(r.Fields, ",") + } + + if r.FieldStatistics != nil { + params["field_statistics"] = strconv.FormatBool(*r.FieldStatistics) + } + + if len(r.Ids) > 0 { + params["ids"] = strings.Join(r.Ids, ",") + } + + if r.Offsets != nil { + params["offsets"] = strconv.FormatBool(*r.Offsets) + } + + if r.Payloads != nil { + params["payloads"] = strconv.FormatBool(*r.Payloads) + } + + if r.Positions != nil { + params["positions"] = strconv.FormatBool(*r.Positions) + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Realtime != nil { + params["realtime"] = strconv.FormatBool(*r.Realtime) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if r.TermStatistics != nil { + params["term_statistics"] = strconv.FormatBool(*r.TermStatistics) + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Mtermvectors) WithContext(v context.Context) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.ctx = v + } +} + +// WithBody - Define ids, documents, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.. +// +func (f Mtermvectors) WithBody(v io.Reader) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Body = v + } +} + +// WithIndex - the index in which the document resides.. +// +func (f Mtermvectors) WithIndex(v string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Index = v + } +} + +// WithDocumentType - the type of the document.. +// +func (f Mtermvectors) WithDocumentType(v string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.DocumentType = v + } +} + +// WithFields - a list of fields to return. applies to all returned documents unless otherwise specified in body "params" or "docs".. +// +func (f Mtermvectors) WithFields(v ...string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Fields = v + } +} + +// WithFieldStatistics - specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. applies to all returned documents unless otherwise specified in body "params" or "docs".. +// +func (f Mtermvectors) WithFieldStatistics(v bool) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.FieldStatistics = &v + } +} + +// WithIds - a list of documents ids. you must define ids as parameter or set "ids" or "docs" in the request body. +// +func (f Mtermvectors) WithIds(v ...string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Ids = v + } +} + +// WithOffsets - specifies if term offsets should be returned. applies to all returned documents unless otherwise specified in body "params" or "docs".. +// +func (f Mtermvectors) WithOffsets(v bool) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Offsets = &v + } +} + +// WithPayloads - specifies if term payloads should be returned. applies to all returned documents unless otherwise specified in body "params" or "docs".. +// +func (f Mtermvectors) WithPayloads(v bool) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Payloads = &v + } +} + +// WithPositions - specifies if term positions should be returned. applies to all returned documents unless otherwise specified in body "params" or "docs".. +// +func (f Mtermvectors) WithPositions(v bool) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Positions = &v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random) .applies to all returned documents unless otherwise specified in body "params" or "docs".. +// +func (f Mtermvectors) WithPreference(v string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Preference = v + } +} + +// WithRealtime - specifies if requests are real-time as opposed to near-real-time (default: true).. +// +func (f Mtermvectors) WithRealtime(v bool) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Realtime = &v + } +} + +// WithRouting - specific routing value. applies to all returned documents unless otherwise specified in body "params" or "docs".. +// +func (f Mtermvectors) WithRouting(v string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Routing = v + } +} + +// WithTermStatistics - specifies if total term frequency and document frequency should be returned. applies to all returned documents unless otherwise specified in body "params" or "docs".. +// +func (f Mtermvectors) WithTermStatistics(v bool) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.TermStatistics = &v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f Mtermvectors) WithVersion(v int) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f Mtermvectors) WithVersionType(v string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.VersionType = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Mtermvectors) WithPretty() func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Mtermvectors) WithHuman() func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Mtermvectors) WithErrorTrace() func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Mtermvectors) WithFilterPath(v ...string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Mtermvectors) WithHeader(h map[string]string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Mtermvectors) WithOpaqueID(s string) func(*MtermvectorsRequest) { + return func(r *MtermvectorsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.hot_threads.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.hot_threads.go new file mode 100644 index 000000000..aff3ec833 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.hot_threads.go @@ -0,0 +1,302 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newNodesHotThreadsFunc(t Transport) NodesHotThreads { + return func(o ...func(*NodesHotThreadsRequest)) (*Response, error) { + var r = NodesHotThreadsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// NodesHotThreads returns information about hot threads on each node in the cluster. +// +// +type NodesHotThreads func(o ...func(*NodesHotThreadsRequest)) (*Response, error) + +// NodesHotThreadsRequest configures the Nodes Hot Threads API request. +// +type NodesHotThreadsRequest struct { + NodeID []string + + IgnoreIdleThreads *bool + Interval time.Duration + Snapshots *int + Threads *int + Timeout time.Duration + DocumentType string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r NodesHotThreadsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_cluster") + 1 + len("nodes") + 1 + len(strings.Join(r.NodeID, ",")) + 1 + len("hot_threads")) + path.WriteString("/") + path.WriteString("_cluster") + path.WriteString("/") + path.WriteString("nodes") + if len(r.NodeID) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.NodeID, ",")) + } + path.WriteString("/") + path.WriteString("hot_threads") + + params = make(map[string]string) + + if r.IgnoreIdleThreads != nil { + params["ignore_idle_threads"] = strconv.FormatBool(*r.IgnoreIdleThreads) + } + + if r.Interval != 0 { + params["interval"] = formatDuration(r.Interval) + } + + if r.Snapshots != nil { + params["snapshots"] = strconv.FormatInt(int64(*r.Snapshots), 10) + } + + if r.Threads != nil { + params["threads"] = strconv.FormatInt(int64(*r.Threads), 10) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.DocumentType != "" { + params["type"] = r.DocumentType + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f NodesHotThreads) WithContext(v context.Context) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.ctx = v + } +} + +// WithNodeID - a list of node ids or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes. +// +func (f NodesHotThreads) WithNodeID(v ...string) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.NodeID = v + } +} + +// WithIgnoreIdleThreads - don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true). +// +func (f NodesHotThreads) WithIgnoreIdleThreads(v bool) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.IgnoreIdleThreads = &v + } +} + +// WithInterval - the interval for the second sampling of threads. +// +func (f NodesHotThreads) WithInterval(v time.Duration) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.Interval = v + } +} + +// WithSnapshots - number of samples of thread stacktrace (default: 10). +// +func (f NodesHotThreads) WithSnapshots(v int) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.Snapshots = &v + } +} + +// WithThreads - specify the number of threads to provide information for (default: 3). +// +func (f NodesHotThreads) WithThreads(v int) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.Threads = &v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f NodesHotThreads) WithTimeout(v time.Duration) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.Timeout = v + } +} + +// WithDocumentType - the type to sample (default: cpu). +// +func (f NodesHotThreads) WithDocumentType(v string) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.DocumentType = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f NodesHotThreads) WithPretty() func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f NodesHotThreads) WithHuman() func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f NodesHotThreads) WithErrorTrace() func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f NodesHotThreads) WithFilterPath(v ...string) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f NodesHotThreads) WithHeader(h map[string]string) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f NodesHotThreads) WithOpaqueID(s string) func(*NodesHotThreadsRequest) { + return func(r *NodesHotThreadsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.info.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.info.go new file mode 100644 index 000000000..39b92976f --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.info.go @@ -0,0 +1,259 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newNodesInfoFunc(t Transport) NodesInfo { + return func(o ...func(*NodesInfoRequest)) (*Response, error) { + var r = NodesInfoRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// NodesInfo returns information about nodes in the cluster. +// +// +type NodesInfo func(o ...func(*NodesInfoRequest)) (*Response, error) + +// NodesInfoRequest configures the Nodes Info API request. +// +type NodesInfoRequest struct { + Metric []string + NodeID []string + + FlatSettings *bool + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r NodesInfoRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_nodes") + 1 + len(strings.Join(r.NodeID, ",")) + 1 + len(strings.Join(r.Metric, ","))) + path.WriteString("/") + path.WriteString("_nodes") + if len(r.NodeID) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.NodeID, ",")) + } + if len(r.Metric) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Metric, ",")) + } + + params = make(map[string]string) + + if r.FlatSettings != nil { + params["flat_settings"] = strconv.FormatBool(*r.FlatSettings) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f NodesInfo) WithContext(v context.Context) func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.ctx = v + } +} + +// WithMetric - a list of metrics you wish returned. leave empty to return all.. +// +func (f NodesInfo) WithMetric(v ...string) func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.Metric = v + } +} + +// WithNodeID - a list of node ids or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes. +// +func (f NodesInfo) WithNodeID(v ...string) func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.NodeID = v + } +} + +// WithFlatSettings - return settings in flat format (default: false). +// +func (f NodesInfo) WithFlatSettings(v bool) func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.FlatSettings = &v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f NodesInfo) WithTimeout(v time.Duration) func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f NodesInfo) WithPretty() func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f NodesInfo) WithHuman() func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f NodesInfo) WithErrorTrace() func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f NodesInfo) WithFilterPath(v ...string) func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f NodesInfo) WithHeader(h map[string]string) func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f NodesInfo) WithOpaqueID(s string) func(*NodesInfoRequest) { + return func(r *NodesInfoRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.reload_secure_settings.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.reload_secure_settings.go new file mode 100644 index 000000000..9030f0273 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.reload_secure_settings.go @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" + "time" +) + +func newNodesReloadSecureSettingsFunc(t Transport) NodesReloadSecureSettings { + return func(o ...func(*NodesReloadSecureSettingsRequest)) (*Response, error) { + var r = NodesReloadSecureSettingsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// NodesReloadSecureSettings reloads secure settings. +// +// +type NodesReloadSecureSettings func(o ...func(*NodesReloadSecureSettingsRequest)) (*Response, error) + +// NodesReloadSecureSettingsRequest configures the Nodes Reload Secure Settings API request. +// +type NodesReloadSecureSettingsRequest struct { + Body io.Reader + + NodeID []string + + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r NodesReloadSecureSettingsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_nodes") + 1 + len(strings.Join(r.NodeID, ",")) + 1 + len("reload_secure_settings")) + path.WriteString("/") + path.WriteString("_nodes") + if len(r.NodeID) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.NodeID, ",")) + } + path.WriteString("/") + path.WriteString("reload_secure_settings") + + params = make(map[string]string) + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f NodesReloadSecureSettings) WithContext(v context.Context) func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + r.ctx = v + } +} + +// WithBody - An object containing the password for the opensearch keystore. +// +func (f NodesReloadSecureSettings) WithBody(v io.Reader) func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + r.Body = v + } +} + +// WithNodeID - a list of node ids to span the reload/reinit call. should stay empty because reloading usually involves all cluster nodes.. +// +func (f NodesReloadSecureSettings) WithNodeID(v ...string) func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + r.NodeID = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f NodesReloadSecureSettings) WithTimeout(v time.Duration) func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f NodesReloadSecureSettings) WithPretty() func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f NodesReloadSecureSettings) WithHuman() func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f NodesReloadSecureSettings) WithErrorTrace() func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f NodesReloadSecureSettings) WithFilterPath(v ...string) func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f NodesReloadSecureSettings) WithHeader(h map[string]string) func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f NodesReloadSecureSettings) WithOpaqueID(s string) func(*NodesReloadSecureSettingsRequest) { + return func(r *NodesReloadSecureSettingsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.stats.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.stats.go new file mode 100644 index 000000000..6021814fb --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.stats.go @@ -0,0 +1,365 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newNodesStatsFunc(t Transport) NodesStats { + return func(o ...func(*NodesStatsRequest)) (*Response, error) { + var r = NodesStatsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// NodesStats returns statistical information about nodes in the cluster. +// +// +type NodesStats func(o ...func(*NodesStatsRequest)) (*Response, error) + +// NodesStatsRequest configures the Nodes Stats API request. +// +type NodesStatsRequest struct { + IndexMetric []string + Metric []string + NodeID []string + + CompletionFields []string + FielddataFields []string + Fields []string + Groups *bool + IncludeSegmentFileSizes *bool + IncludeUnloadedSegments *bool + Level string + Timeout time.Duration + Types []string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r NodesStatsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_nodes") + 1 + len(strings.Join(r.NodeID, ",")) + 1 + len("stats") + 1 + len(strings.Join(r.Metric, ",")) + 1 + len(strings.Join(r.IndexMetric, ","))) + path.WriteString("/") + path.WriteString("_nodes") + if len(r.NodeID) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.NodeID, ",")) + } + path.WriteString("/") + path.WriteString("stats") + if len(r.Metric) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Metric, ",")) + } + if len(r.IndexMetric) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.IndexMetric, ",")) + } + + params = make(map[string]string) + + if len(r.CompletionFields) > 0 { + params["completion_fields"] = strings.Join(r.CompletionFields, ",") + } + + if len(r.FielddataFields) > 0 { + params["fielddata_fields"] = strings.Join(r.FielddataFields, ",") + } + + if len(r.Fields) > 0 { + params["fields"] = strings.Join(r.Fields, ",") + } + + if r.Groups != nil { + params["groups"] = strconv.FormatBool(*r.Groups) + } + + if r.IncludeSegmentFileSizes != nil { + params["include_segment_file_sizes"] = strconv.FormatBool(*r.IncludeSegmentFileSizes) + } + + if r.IncludeUnloadedSegments != nil { + params["include_unloaded_segments"] = strconv.FormatBool(*r.IncludeUnloadedSegments) + } + + if r.Level != "" { + params["level"] = r.Level + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if len(r.Types) > 0 { + params["types"] = strings.Join(r.Types, ",") + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f NodesStats) WithContext(v context.Context) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.ctx = v + } +} + +// WithIndexMetric - limit the information returned for `indices` metric to the specific index metrics. isn't used if `indices` (or `all`) metric isn't specified.. +// +func (f NodesStats) WithIndexMetric(v ...string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.IndexMetric = v + } +} + +// WithMetric - limit the information returned to the specified metrics. +// +func (f NodesStats) WithMetric(v ...string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.Metric = v + } +} + +// WithNodeID - a list of node ids or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes. +// +func (f NodesStats) WithNodeID(v ...string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.NodeID = v + } +} + +// WithCompletionFields - a list of fields for `fielddata` and `suggest` index metric (supports wildcards). +// +func (f NodesStats) WithCompletionFields(v ...string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.CompletionFields = v + } +} + +// WithFielddataFields - a list of fields for `fielddata` index metric (supports wildcards). +// +func (f NodesStats) WithFielddataFields(v ...string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.FielddataFields = v + } +} + +// WithFields - a list of fields for `fielddata` and `completion` index metric (supports wildcards). +// +func (f NodesStats) WithFields(v ...string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.Fields = v + } +} + +// WithGroups - a list of search groups for `search` index metric. +// +func (f NodesStats) WithGroups(v bool) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.Groups = &v + } +} + +// WithIncludeSegmentFileSizes - whether to report the aggregated disk usage of each one of the lucene index files (only applies if segment stats are requested). +// +func (f NodesStats) WithIncludeSegmentFileSizes(v bool) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.IncludeSegmentFileSizes = &v + } +} + +// WithIncludeUnloadedSegments - if set to true segment stats will include stats for segments that are not currently loaded into memory. +// +func (f NodesStats) WithIncludeUnloadedSegments(v bool) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.IncludeUnloadedSegments = &v + } +} + +// WithLevel - return indices stats aggregated at index, node or shard level. +// +func (f NodesStats) WithLevel(v string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.Level = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f NodesStats) WithTimeout(v time.Duration) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.Timeout = v + } +} + +// WithTypes - a list of document types for the `indexing` index metric. +// +func (f NodesStats) WithTypes(v ...string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.Types = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f NodesStats) WithPretty() func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f NodesStats) WithHuman() func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f NodesStats) WithErrorTrace() func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f NodesStats) WithFilterPath(v ...string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f NodesStats) WithHeader(h map[string]string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f NodesStats) WithOpaqueID(s string) func(*NodesStatsRequest) { + return func(r *NodesStatsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.usage.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.usage.go new file mode 100644 index 000000000..25db9326f --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.nodes.usage.go @@ -0,0 +1,247 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newNodesUsageFunc(t Transport) NodesUsage { + return func(o ...func(*NodesUsageRequest)) (*Response, error) { + var r = NodesUsageRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// NodesUsage returns low-level information about REST actions usage on nodes. +// +// +type NodesUsage func(o ...func(*NodesUsageRequest)) (*Response, error) + +// NodesUsageRequest configures the Nodes Usage API request. +// +type NodesUsageRequest struct { + Metric []string + NodeID []string + + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r NodesUsageRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_nodes") + 1 + len(strings.Join(r.NodeID, ",")) + 1 + len("usage") + 1 + len(strings.Join(r.Metric, ","))) + path.WriteString("/") + path.WriteString("_nodes") + if len(r.NodeID) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.NodeID, ",")) + } + path.WriteString("/") + path.WriteString("usage") + if len(r.Metric) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Metric, ",")) + } + + params = make(map[string]string) + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f NodesUsage) WithContext(v context.Context) func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + r.ctx = v + } +} + +// WithMetric - limit the information returned to the specified metrics. +// +func (f NodesUsage) WithMetric(v ...string) func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + r.Metric = v + } +} + +// WithNodeID - a list of node ids or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes. +// +func (f NodesUsage) WithNodeID(v ...string) func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + r.NodeID = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f NodesUsage) WithTimeout(v time.Duration) func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f NodesUsage) WithPretty() func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f NodesUsage) WithHuman() func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f NodesUsage) WithErrorTrace() func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f NodesUsage) WithFilterPath(v ...string) func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f NodesUsage) WithHeader(h map[string]string) func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f NodesUsage) WithOpaqueID(s string) func(*NodesUsageRequest) { + return func(r *NodesUsageRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ping.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ping.go new file mode 100644 index 000000000..f30ef61c0 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.ping.go @@ -0,0 +1,202 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" +) + +func newPingFunc(t Transport) Ping { + return func(o ...func(*PingRequest)) (*Response, error) { + var r = PingRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Ping returns whether the cluster is running. +// +// +type Ping func(o ...func(*PingRequest)) (*Response, error) + +// PingRequest configures the Ping API request. +// +type PingRequest struct { + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r PingRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "HEAD" + + path.Grow(len("/")) + path.WriteString("/") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Ping) WithContext(v context.Context) func(*PingRequest) { + return func(r *PingRequest) { + r.ctx = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Ping) WithPretty() func(*PingRequest) { + return func(r *PingRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Ping) WithHuman() func(*PingRequest) { + return func(r *PingRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Ping) WithErrorTrace() func(*PingRequest) { + return func(r *PingRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Ping) WithFilterPath(v ...string) func(*PingRequest) { + return func(r *PingRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Ping) WithHeader(h map[string]string) func(*PingRequest) { + return func(r *PingRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Ping) WithOpaqueID(s string) func(*PingRequest) { + return func(r *PingRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.put_script.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.put_script.go new file mode 100644 index 000000000..2349b42e1 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.put_script.go @@ -0,0 +1,260 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" + "time" +) + +func newPutScriptFunc(t Transport) PutScript { + return func(id string, body io.Reader, o ...func(*PutScriptRequest)) (*Response, error) { + var r = PutScriptRequest{ScriptID: id, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// PutScript creates or updates a script. +// +// +type PutScript func(id string, body io.Reader, o ...func(*PutScriptRequest)) (*Response, error) + +// PutScriptRequest configures the Put Script API request. +// +type PutScriptRequest struct { + ScriptID string + + Body io.Reader + + ScriptContext string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r PutScriptRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len("_scripts") + 1 + len(r.ScriptID) + 1 + len(r.ScriptContext)) + path.WriteString("/") + path.WriteString("_scripts") + path.WriteString("/") + path.WriteString(r.ScriptID) + if r.ScriptContext != "" { + path.WriteString("/") + path.WriteString(r.ScriptContext) + } + + params = make(map[string]string) + + if r.ScriptContext != "" { + params["context"] = r.ScriptContext + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f PutScript) WithContext(v context.Context) func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + r.ctx = v + } +} + +// WithScriptContext - script context. +// +func (f PutScript) WithScriptContext(v string) func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + r.ScriptContext = v + } +} + +// WithMasterTimeout - specify timeout for connection to master. +// +func (f PutScript) WithMasterTimeout(v time.Duration) func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f PutScript) WithTimeout(v time.Duration) func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f PutScript) WithPretty() func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f PutScript) WithHuman() func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f PutScript) WithErrorTrace() func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f PutScript) WithFilterPath(v ...string) func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f PutScript) WithHeader(h map[string]string) func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f PutScript) WithOpaqueID(s string) func(*PutScriptRequest) { + return func(r *PutScriptRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.rank_eval.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.rank_eval.go new file mode 100644 index 000000000..68a819e17 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.rank_eval.go @@ -0,0 +1,280 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newRankEvalFunc(t Transport) RankEval { + return func(body io.Reader, o ...func(*RankEvalRequest)) (*Response, error) { + var r = RankEvalRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// RankEval allows to evaluate the quality of ranked search results over a set of typical search queries +// +// This API is experimental. +// +// +type RankEval func(body io.Reader, o ...func(*RankEvalRequest)) (*Response, error) + +// RankEvalRequest configures the Rank Eval API request. +// +type RankEvalRequest struct { + Index []string + + Body io.Reader + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + SearchType string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r RankEvalRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_rank_eval")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_rank_eval") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.SearchType != "" { + params["search_type"] = r.SearchType + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f RankEval) WithContext(v context.Context) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to search; use _all to perform the operation on all indices. +// +func (f RankEval) WithIndex(v ...string) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f RankEval) WithAllowNoIndices(v bool) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f RankEval) WithExpandWildcards(v string) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f RankEval) WithIgnoreUnavailable(v bool) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithSearchType - search operation type. +// +func (f RankEval) WithSearchType(v string) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.SearchType = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f RankEval) WithPretty() func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f RankEval) WithHuman() func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f RankEval) WithErrorTrace() func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f RankEval) WithFilterPath(v ...string) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f RankEval) WithHeader(h map[string]string) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f RankEval) WithOpaqueID(s string) func(*RankEvalRequest) { + return func(r *RankEvalRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.reindex.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.reindex.go new file mode 100644 index 000000000..2311ecb38 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.reindex.go @@ -0,0 +1,319 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "fmt" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newReindexFunc(t Transport) Reindex { + return func(body io.Reader, o ...func(*ReindexRequest)) (*Response, error) { + var r = ReindexRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Reindex allows to copy documents from one index to another, optionally filtering the source +// documents by a query, changing the destination index settings, or fetching the +// documents from a remote cluster. +// +// +type Reindex func(body io.Reader, o ...func(*ReindexRequest)) (*Response, error) + +// ReindexRequest configures the Reindex API request. +// +type ReindexRequest struct { + Body io.Reader + + MaxDocs *int + Refresh *bool + RequestsPerSecond *int + Scroll time.Duration + Slices interface{} + Timeout time.Duration + WaitForActiveShards string + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ReindexRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(len("/_reindex")) + path.WriteString("/_reindex") + + params = make(map[string]string) + + if r.MaxDocs != nil { + params["max_docs"] = strconv.FormatInt(int64(*r.MaxDocs), 10) + } + + if r.Refresh != nil { + params["refresh"] = strconv.FormatBool(*r.Refresh) + } + + if r.RequestsPerSecond != nil { + params["requests_per_second"] = strconv.FormatInt(int64(*r.RequestsPerSecond), 10) + } + + if r.Scroll != 0 { + params["scroll"] = formatDuration(r.Scroll) + } + + if r.Slices != nil { + params["slices"] = fmt.Sprintf("%v", r.Slices) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Reindex) WithContext(v context.Context) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.ctx = v + } +} + +// WithMaxDocs - maximum number of documents to process (default: all documents). +// +func (f Reindex) WithMaxDocs(v int) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.MaxDocs = &v + } +} + +// WithRefresh - should the affected indexes be refreshed?. +// +func (f Reindex) WithRefresh(v bool) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.Refresh = &v + } +} + +// WithRequestsPerSecond - the throttle to set on this request in sub-requests per second. -1 means no throttle.. +// +func (f Reindex) WithRequestsPerSecond(v int) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.RequestsPerSecond = &v + } +} + +// WithScroll - control how long to keep the search context alive. +// +func (f Reindex) WithScroll(v time.Duration) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.Scroll = v + } +} + +// WithSlices - the number of slices this task should be divided into. defaults to 1, meaning the task isn't sliced into subtasks. can be set to `auto`.. +// +func (f Reindex) WithSlices(v interface{}) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.Slices = v + } +} + +// WithTimeout - time each individual bulk request should wait for shards that are unavailable.. +// +func (f Reindex) WithTimeout(v time.Duration) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - sets the number of shard copies that must be active before proceeding with the reindex operation. defaults to 1, meaning the primary shard only. set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1). +// +func (f Reindex) WithWaitForActiveShards(v string) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.WaitForActiveShards = v + } +} + +// WithWaitForCompletion - should the request should block until the reindex is complete.. +// +func (f Reindex) WithWaitForCompletion(v bool) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Reindex) WithPretty() func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Reindex) WithHuman() func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Reindex) WithErrorTrace() func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Reindex) WithFilterPath(v ...string) func(*ReindexRequest) { + return func(r *ReindexRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Reindex) WithHeader(h map[string]string) func(*ReindexRequest) { + return func(r *ReindexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Reindex) WithOpaqueID(s string) func(*ReindexRequest) { + return func(r *ReindexRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.reindex_rethrottle.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.reindex_rethrottle.go new file mode 100644 index 000000000..f51b414e1 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.reindex_rethrottle.go @@ -0,0 +1,224 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newReindexRethrottleFunc(t Transport) ReindexRethrottle { + return func(task_id string, requests_per_second *int, o ...func(*ReindexRethrottleRequest)) (*Response, error) { + var r = ReindexRethrottleRequest{TaskID: task_id, RequestsPerSecond: requests_per_second} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ReindexRethrottle changes the number of requests per second for a particular Reindex operation. +// +// +type ReindexRethrottle func(task_id string, requests_per_second *int, o ...func(*ReindexRethrottleRequest)) (*Response, error) + +// ReindexRethrottleRequest configures the Reindex Rethrottle API request. +// +type ReindexRethrottleRequest struct { + TaskID string + + RequestsPerSecond *int + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ReindexRethrottleRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_reindex") + 1 + len(r.TaskID) + 1 + len("_rethrottle")) + path.WriteString("/") + path.WriteString("_reindex") + path.WriteString("/") + path.WriteString(r.TaskID) + path.WriteString("/") + path.WriteString("_rethrottle") + + params = make(map[string]string) + + if r.RequestsPerSecond != nil { + params["requests_per_second"] = strconv.FormatInt(int64(*r.RequestsPerSecond), 10) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ReindexRethrottle) WithContext(v context.Context) func(*ReindexRethrottleRequest) { + return func(r *ReindexRethrottleRequest) { + r.ctx = v + } +} + +// WithRequestsPerSecond - the throttle to set on this request in floating sub-requests per second. -1 means set no throttle.. +// +func (f ReindexRethrottle) WithRequestsPerSecond(v int) func(*ReindexRethrottleRequest) { + return func(r *ReindexRethrottleRequest) { + r.RequestsPerSecond = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ReindexRethrottle) WithPretty() func(*ReindexRethrottleRequest) { + return func(r *ReindexRethrottleRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ReindexRethrottle) WithHuman() func(*ReindexRethrottleRequest) { + return func(r *ReindexRethrottleRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ReindexRethrottle) WithErrorTrace() func(*ReindexRethrottleRequest) { + return func(r *ReindexRethrottleRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ReindexRethrottle) WithFilterPath(v ...string) func(*ReindexRethrottleRequest) { + return func(r *ReindexRethrottleRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ReindexRethrottle) WithHeader(h map[string]string) func(*ReindexRethrottleRequest) { + return func(r *ReindexRethrottleRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ReindexRethrottle) WithOpaqueID(s string) func(*ReindexRethrottleRequest) { + return func(r *ReindexRethrottleRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.render_search_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.render_search_template.go new file mode 100644 index 000000000..d5ddfdb3a --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.render_search_template.go @@ -0,0 +1,234 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" +) + +func newRenderSearchTemplateFunc(t Transport) RenderSearchTemplate { + return func(o ...func(*RenderSearchTemplateRequest)) (*Response, error) { + var r = RenderSearchTemplateRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// RenderSearchTemplate allows to use the Mustache language to pre-render a search definition. +// +// +type RenderSearchTemplate func(o ...func(*RenderSearchTemplateRequest)) (*Response, error) + +// RenderSearchTemplateRequest configures the Render Search Template API request. +// +type RenderSearchTemplateRequest struct { + TemplateID string + + Body io.Reader + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r RenderSearchTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_render") + 1 + len("template") + 1 + len(r.TemplateID)) + path.WriteString("/") + path.WriteString("_render") + path.WriteString("/") + path.WriteString("template") + if r.TemplateID != "" { + path.WriteString("/") + path.WriteString(r.TemplateID) + } + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f RenderSearchTemplate) WithContext(v context.Context) func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + r.ctx = v + } +} + +// WithBody - The search definition template and its params. +// +func (f RenderSearchTemplate) WithBody(v io.Reader) func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + r.Body = v + } +} + +// WithTemplateID - the ID of the stored search template. +// +func (f RenderSearchTemplate) WithTemplateID(v string) func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + r.TemplateID = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f RenderSearchTemplate) WithPretty() func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f RenderSearchTemplate) WithHuman() func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f RenderSearchTemplate) WithErrorTrace() func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f RenderSearchTemplate) WithFilterPath(v ...string) func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f RenderSearchTemplate) WithHeader(h map[string]string) func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f RenderSearchTemplate) WithOpaqueID(s string) func(*RenderSearchTemplateRequest) { + return func(r *RenderSearchTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.scripts_painless_execute.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.scripts_painless_execute.go new file mode 100644 index 000000000..818954d55 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.scripts_painless_execute.go @@ -0,0 +1,219 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" +) + +func newScriptsPainlessExecuteFunc(t Transport) ScriptsPainlessExecute { + return func(o ...func(*ScriptsPainlessExecuteRequest)) (*Response, error) { + var r = ScriptsPainlessExecuteRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// ScriptsPainlessExecute allows an arbitrary script to be executed and a result to be returned +// +// This API is experimental. +// +// +type ScriptsPainlessExecute func(o ...func(*ScriptsPainlessExecuteRequest)) (*Response, error) + +// ScriptsPainlessExecuteRequest configures the Scripts Painless Execute API request. +// +type ScriptsPainlessExecuteRequest struct { + Body io.Reader + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ScriptsPainlessExecuteRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(len("/_scripts/painless/_execute")) + path.WriteString("/_scripts/painless/_execute") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f ScriptsPainlessExecute) WithContext(v context.Context) func(*ScriptsPainlessExecuteRequest) { + return func(r *ScriptsPainlessExecuteRequest) { + r.ctx = v + } +} + +// WithBody - The script to execute. +// +func (f ScriptsPainlessExecute) WithBody(v io.Reader) func(*ScriptsPainlessExecuteRequest) { + return func(r *ScriptsPainlessExecuteRequest) { + r.Body = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f ScriptsPainlessExecute) WithPretty() func(*ScriptsPainlessExecuteRequest) { + return func(r *ScriptsPainlessExecuteRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f ScriptsPainlessExecute) WithHuman() func(*ScriptsPainlessExecuteRequest) { + return func(r *ScriptsPainlessExecuteRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f ScriptsPainlessExecute) WithErrorTrace() func(*ScriptsPainlessExecuteRequest) { + return func(r *ScriptsPainlessExecuteRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f ScriptsPainlessExecute) WithFilterPath(v ...string) func(*ScriptsPainlessExecuteRequest) { + return func(r *ScriptsPainlessExecuteRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f ScriptsPainlessExecute) WithHeader(h map[string]string) func(*ScriptsPainlessExecuteRequest) { + return func(r *ScriptsPainlessExecuteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f ScriptsPainlessExecute) WithOpaqueID(s string) func(*ScriptsPainlessExecuteRequest) { + return func(r *ScriptsPainlessExecuteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.scroll.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.scroll.go new file mode 100644 index 000000000..329828173 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.scroll.go @@ -0,0 +1,260 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newScrollFunc(t Transport) Scroll { + return func(o ...func(*ScrollRequest)) (*Response, error) { + var r = ScrollRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Scroll allows to retrieve a large numbers of results from a single search request. +// +// +type Scroll func(o ...func(*ScrollRequest)) (*Response, error) + +// ScrollRequest configures the Scroll API request. +// +type ScrollRequest struct { + Body io.Reader + + ScrollID string + + RestTotalHitsAsInt *bool + Scroll time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r ScrollRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(len("/_search/scroll")) + path.WriteString("/_search/scroll") + + params = make(map[string]string) + + if r.RestTotalHitsAsInt != nil { + params["rest_total_hits_as_int"] = strconv.FormatBool(*r.RestTotalHitsAsInt) + } + + if r.Scroll != 0 { + params["scroll"] = formatDuration(r.Scroll) + } + + if r.ScrollID != "" { + params["scroll_id"] = r.ScrollID + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Scroll) WithContext(v context.Context) func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.ctx = v + } +} + +// WithBody - The scroll ID if not passed by URL or query parameter.. +// +func (f Scroll) WithBody(v io.Reader) func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.Body = v + } +} + +// WithScrollID - the scroll ID. +// +func (f Scroll) WithScrollID(v string) func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.ScrollID = v + } +} + +// WithRestTotalHitsAsInt - indicates whether hits.total should be rendered as an integer or an object in the rest search response. +// +func (f Scroll) WithRestTotalHitsAsInt(v bool) func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.RestTotalHitsAsInt = &v + } +} + +// WithScroll - specify how long a consistent view of the index should be maintained for scrolled search. +// +func (f Scroll) WithScroll(v time.Duration) func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.Scroll = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Scroll) WithPretty() func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Scroll) WithHuman() func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Scroll) WithErrorTrace() func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Scroll) WithFilterPath(v ...string) func(*ScrollRequest) { + return func(r *ScrollRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Scroll) WithHeader(h map[string]string) func(*ScrollRequest) { + return func(r *ScrollRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Scroll) WithOpaqueID(s string) func(*ScrollRequest) { + return func(r *ScrollRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search.go new file mode 100644 index 000000000..8d76675bd --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search.go @@ -0,0 +1,808 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "fmt" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newSearchFunc(t Transport) Search { + return func(o ...func(*SearchRequest)) (*Response, error) { + var r = SearchRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Search returns results matching a query. +// +// +type Search func(o ...func(*SearchRequest)) (*Response, error) + +// SearchRequest configures the Search API request. +// +type SearchRequest struct { + Index []string + DocumentType []string + + Body io.Reader + + AllowNoIndices *bool + AllowPartialSearchResults *bool + Analyzer string + AnalyzeWildcard *bool + BatchedReduceSize *int + CcsMinimizeRoundtrips *bool + DefaultOperator string + Df string + DocvalueFields []string + ExpandWildcards string + Explain *bool + From *int + IgnoreThrottled *bool + IgnoreUnavailable *bool + Lenient *bool + MaxConcurrentShardRequests *int + MinCompatibleShardNode string + Preference string + PreFilterShardSize *int + Query string + RequestCache *bool + RestTotalHitsAsInt *bool + Routing []string + Scroll time.Duration + SearchType string + SeqNoPrimaryTerm *bool + Size *int + Sort []string + Source []string + SourceExcludes []string + SourceIncludes []string + Stats []string + StoredFields []string + SuggestField string + SuggestMode string + SuggestSize *int + SuggestText string + TerminateAfter *int + Timeout time.Duration + TrackScores *bool + TrackTotalHits interface{} + TypedKeys *bool + Version *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SearchRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("_search")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("_search") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.AllowPartialSearchResults != nil { + params["allow_partial_search_results"] = strconv.FormatBool(*r.AllowPartialSearchResults) + } + + if r.Analyzer != "" { + params["analyzer"] = r.Analyzer + } + + if r.AnalyzeWildcard != nil { + params["analyze_wildcard"] = strconv.FormatBool(*r.AnalyzeWildcard) + } + + if r.BatchedReduceSize != nil { + params["batched_reduce_size"] = strconv.FormatInt(int64(*r.BatchedReduceSize), 10) + } + + if r.CcsMinimizeRoundtrips != nil { + params["ccs_minimize_roundtrips"] = strconv.FormatBool(*r.CcsMinimizeRoundtrips) + } + + if r.DefaultOperator != "" { + params["default_operator"] = r.DefaultOperator + } + + if r.Df != "" { + params["df"] = r.Df + } + + if len(r.DocvalueFields) > 0 { + params["docvalue_fields"] = strings.Join(r.DocvalueFields, ",") + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Explain != nil { + params["explain"] = strconv.FormatBool(*r.Explain) + } + + if r.From != nil { + params["from"] = strconv.FormatInt(int64(*r.From), 10) + } + + if r.IgnoreThrottled != nil { + params["ignore_throttled"] = strconv.FormatBool(*r.IgnoreThrottled) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Lenient != nil { + params["lenient"] = strconv.FormatBool(*r.Lenient) + } + + if r.MaxConcurrentShardRequests != nil { + params["max_concurrent_shard_requests"] = strconv.FormatInt(int64(*r.MaxConcurrentShardRequests), 10) + } + + if r.MinCompatibleShardNode != "" { + params["min_compatible_shard_node"] = r.MinCompatibleShardNode + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.PreFilterShardSize != nil { + params["pre_filter_shard_size"] = strconv.FormatInt(int64(*r.PreFilterShardSize), 10) + } + + if r.Query != "" { + params["q"] = r.Query + } + + if r.RequestCache != nil { + params["request_cache"] = strconv.FormatBool(*r.RequestCache) + } + + if r.RestTotalHitsAsInt != nil { + params["rest_total_hits_as_int"] = strconv.FormatBool(*r.RestTotalHitsAsInt) + } + + if len(r.Routing) > 0 { + params["routing"] = strings.Join(r.Routing, ",") + } + + if r.Scroll != 0 { + params["scroll"] = formatDuration(r.Scroll) + } + + if r.SearchType != "" { + params["search_type"] = r.SearchType + } + + if r.SeqNoPrimaryTerm != nil { + params["seq_no_primary_term"] = strconv.FormatBool(*r.SeqNoPrimaryTerm) + } + + if r.Size != nil { + params["size"] = strconv.FormatInt(int64(*r.Size), 10) + } + + if len(r.Sort) > 0 { + params["sort"] = strings.Join(r.Sort, ",") + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if len(r.Stats) > 0 { + params["stats"] = strings.Join(r.Stats, ",") + } + + if len(r.StoredFields) > 0 { + params["stored_fields"] = strings.Join(r.StoredFields, ",") + } + + if r.SuggestField != "" { + params["suggest_field"] = r.SuggestField + } + + if r.SuggestMode != "" { + params["suggest_mode"] = r.SuggestMode + } + + if r.SuggestSize != nil { + params["suggest_size"] = strconv.FormatInt(int64(*r.SuggestSize), 10) + } + + if r.SuggestText != "" { + params["suggest_text"] = r.SuggestText + } + + if r.TerminateAfter != nil { + params["terminate_after"] = strconv.FormatInt(int64(*r.TerminateAfter), 10) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.TrackScores != nil { + params["track_scores"] = strconv.FormatBool(*r.TrackScores) + } + + if r.TrackTotalHits != nil { + params["track_total_hits"] = fmt.Sprintf("%v", r.TrackTotalHits) + } + + if r.TypedKeys != nil { + params["typed_keys"] = strconv.FormatBool(*r.TypedKeys) + } + + if r.Version != nil { + params["version"] = strconv.FormatBool(*r.Version) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Search) WithContext(v context.Context) func(*SearchRequest) { + return func(r *SearchRequest) { + r.ctx = v + } +} + +// WithBody - The search definition using the Query DSL. +// +func (f Search) WithBody(v io.Reader) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Body = v + } +} + +// WithIndex - a list of index names to search; use _all to perform the operation on all indices. +// +func (f Search) WithIndex(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Index = v + } +} + +// WithDocumentType - a list of document types to search; leave empty to perform the operation on all types. +// +func (f Search) WithDocumentType(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f Search) WithAllowNoIndices(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.AllowNoIndices = &v + } +} + +// WithAllowPartialSearchResults - indicate if an error should be returned if there is a partial search failure or timeout. +// +func (f Search) WithAllowPartialSearchResults(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.AllowPartialSearchResults = &v + } +} + +// WithAnalyzer - the analyzer to use for the query string. +// +func (f Search) WithAnalyzer(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Analyzer = v + } +} + +// WithAnalyzeWildcard - specify whether wildcard and prefix queries should be analyzed (default: false). +// +func (f Search) WithAnalyzeWildcard(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.AnalyzeWildcard = &v + } +} + +// WithBatchedReduceSize - the number of shard results that should be reduced at once on the coordinating node. this value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.. +// +func (f Search) WithBatchedReduceSize(v int) func(*SearchRequest) { + return func(r *SearchRequest) { + r.BatchedReduceSize = &v + } +} + +// WithCcsMinimizeRoundtrips - indicates whether network round-trips should be minimized as part of cross-cluster search requests execution. +// +func (f Search) WithCcsMinimizeRoundtrips(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.CcsMinimizeRoundtrips = &v + } +} + +// WithDefaultOperator - the default operator for query string query (and or or). +// +func (f Search) WithDefaultOperator(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.DefaultOperator = v + } +} + +// WithDf - the field to use as default where no field prefix is given in the query string. +// +func (f Search) WithDf(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Df = v + } +} + +// WithDocvalueFields - a list of fields to return as the docvalue representation of a field for each hit. +// +func (f Search) WithDocvalueFields(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.DocvalueFields = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f Search) WithExpandWildcards(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.ExpandWildcards = v + } +} + +// WithExplain - specify whether to return detailed information about score computation as part of a hit. +// +func (f Search) WithExplain(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Explain = &v + } +} + +// WithFrom - starting offset (default: 0). +// +func (f Search) WithFrom(v int) func(*SearchRequest) { + return func(r *SearchRequest) { + r.From = &v + } +} + +// WithIgnoreThrottled - whether specified concrete, expanded or aliased indices should be ignored when throttled. +// +func (f Search) WithIgnoreThrottled(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.IgnoreThrottled = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f Search) WithIgnoreUnavailable(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLenient - specify whether format-based query failures (such as providing text to a numeric field) should be ignored. +// +func (f Search) WithLenient(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Lenient = &v + } +} + +// WithMaxConcurrentShardRequests - the number of concurrent shard requests per node this search executes concurrently. this value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests. +// +func (f Search) WithMaxConcurrentShardRequests(v int) func(*SearchRequest) { + return func(r *SearchRequest) { + r.MaxConcurrentShardRequests = &v + } +} + +// WithMinCompatibleShardNode - the minimum compatible version that all shards involved in search should have for this request to be successful. +// +func (f Search) WithMinCompatibleShardNode(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.MinCompatibleShardNode = v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f Search) WithPreference(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Preference = v + } +} + +// WithPreFilterShardSize - a threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. this filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on its rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.. +// +func (f Search) WithPreFilterShardSize(v int) func(*SearchRequest) { + return func(r *SearchRequest) { + r.PreFilterShardSize = &v + } +} + +// WithQuery - query in the lucene query string syntax. +// +func (f Search) WithQuery(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Query = v + } +} + +// WithRequestCache - specify if request cache should be used for this request or not, defaults to index level setting. +// +func (f Search) WithRequestCache(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.RequestCache = &v + } +} + +// WithRestTotalHitsAsInt - indicates whether hits.total should be rendered as an integer or an object in the rest search response. +// +func (f Search) WithRestTotalHitsAsInt(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.RestTotalHitsAsInt = &v + } +} + +// WithRouting - a list of specific routing values. +// +func (f Search) WithRouting(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Routing = v + } +} + +// WithScroll - specify how long a consistent view of the index should be maintained for scrolled search. +// +func (f Search) WithScroll(v time.Duration) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Scroll = v + } +} + +// WithSearchType - search operation type. +// +func (f Search) WithSearchType(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.SearchType = v + } +} + +// WithSeqNoPrimaryTerm - specify whether to return sequence number and primary term of the last modification of each hit. +// +func (f Search) WithSeqNoPrimaryTerm(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.SeqNoPrimaryTerm = &v + } +} + +// WithSize - number of hits to return (default: 10). +// +func (f Search) WithSize(v int) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Size = &v + } +} + +// WithSort - a list of : pairs. +// +func (f Search) WithSort(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Sort = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f Search) WithSource(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f Search) WithSourceExcludes(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f Search) WithSourceIncludes(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.SourceIncludes = v + } +} + +// WithStats - specific 'tag' of the request for logging and statistical purposes. +// +func (f Search) WithStats(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Stats = v + } +} + +// WithStoredFields - a list of stored fields to return as part of a hit. +// +func (f Search) WithStoredFields(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.StoredFields = v + } +} + +// WithSuggestField - specify which field to use for suggestions. +// +func (f Search) WithSuggestField(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.SuggestField = v + } +} + +// WithSuggestMode - specify suggest mode. +// +func (f Search) WithSuggestMode(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.SuggestMode = v + } +} + +// WithSuggestSize - how many suggestions to return in response. +// +func (f Search) WithSuggestSize(v int) func(*SearchRequest) { + return func(r *SearchRequest) { + r.SuggestSize = &v + } +} + +// WithSuggestText - the source text for which the suggestions should be returned. +// +func (f Search) WithSuggestText(v string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.SuggestText = v + } +} + +// WithTerminateAfter - the maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.. +// +func (f Search) WithTerminateAfter(v int) func(*SearchRequest) { + return func(r *SearchRequest) { + r.TerminateAfter = &v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f Search) WithTimeout(v time.Duration) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Timeout = v + } +} + +// WithTrackScores - whether to calculate and return scores even if they are not used for sorting. +// +func (f Search) WithTrackScores(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.TrackScores = &v + } +} + +// WithTrackTotalHits - indicate if the number of documents that match the query should be tracked. +// +func (f Search) WithTrackTotalHits(v interface{}) func(*SearchRequest) { + return func(r *SearchRequest) { + r.TrackTotalHits = v + } +} + +// WithTypedKeys - specify whether aggregation and suggester names should be prefixed by their respective types in the response. +// +func (f Search) WithTypedKeys(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.TypedKeys = &v + } +} + +// WithVersion - specify whether to return document version as part of a hit. +// +func (f Search) WithVersion(v bool) func(*SearchRequest) { + return func(r *SearchRequest) { + r.Version = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Search) WithPretty() func(*SearchRequest) { + return func(r *SearchRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Search) WithHuman() func(*SearchRequest) { + return func(r *SearchRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Search) WithErrorTrace() func(*SearchRequest) { + return func(r *SearchRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Search) WithFilterPath(v ...string) func(*SearchRequest) { + return func(r *SearchRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Search) WithHeader(h map[string]string) func(*SearchRequest) { + return func(r *SearchRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Search) WithOpaqueID(s string) func(*SearchRequest) { + return func(r *SearchRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search_shards.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search_shards.go new file mode 100644 index 000000000..7baefdb89 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search_shards.go @@ -0,0 +1,297 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newSearchShardsFunc(t Transport) SearchShards { + return func(o ...func(*SearchShardsRequest)) (*Response, error) { + var r = SearchShardsRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SearchShards returns information about the indices and shards that a search request would be executed against. +// +// +type SearchShards func(o ...func(*SearchShardsRequest)) (*Response, error) + +// SearchShardsRequest configures the Search Shards API request. +// +type SearchShardsRequest struct { + Index []string + + AllowNoIndices *bool + ExpandWildcards string + IgnoreUnavailable *bool + Local *bool + Preference string + Routing string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SearchShardsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_search_shards")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + path.WriteString("/") + path.WriteString("_search_shards") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SearchShards) WithContext(v context.Context) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to search; use _all to perform the operation on all indices. +// +func (f SearchShards) WithIndex(v ...string) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.Index = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f SearchShards) WithAllowNoIndices(v bool) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.AllowNoIndices = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f SearchShards) WithExpandWildcards(v string) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.ExpandWildcards = v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f SearchShards) WithIgnoreUnavailable(v bool) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f SearchShards) WithLocal(v bool) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.Local = &v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f SearchShards) WithPreference(v string) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.Preference = v + } +} + +// WithRouting - specific routing value. +// +func (f SearchShards) WithRouting(v string) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.Routing = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SearchShards) WithPretty() func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SearchShards) WithHuman() func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SearchShards) WithErrorTrace() func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SearchShards) WithFilterPath(v ...string) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SearchShards) WithHeader(h map[string]string) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SearchShards) WithOpaqueID(s string) func(*SearchShardsRequest) { + return func(r *SearchShardsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search_template.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search_template.go new file mode 100644 index 000000000..4d5b79c3d --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.search_template.go @@ -0,0 +1,411 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newSearchTemplateFunc(t Transport) SearchTemplate { + return func(body io.Reader, o ...func(*SearchTemplateRequest)) (*Response, error) { + var r = SearchTemplateRequest{Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SearchTemplate allows to use the Mustache language to pre-render a search definition. +// +// +type SearchTemplate func(body io.Reader, o ...func(*SearchTemplateRequest)) (*Response, error) + +// SearchTemplateRequest configures the Search Template API request. +// +type SearchTemplateRequest struct { + Index []string + DocumentType []string + + Body io.Reader + + AllowNoIndices *bool + CcsMinimizeRoundtrips *bool + ExpandWildcards string + Explain *bool + IgnoreThrottled *bool + IgnoreUnavailable *bool + Preference string + Profile *bool + RestTotalHitsAsInt *bool + Routing []string + Scroll time.Duration + SearchType string + TypedKeys *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SearchTemplateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("_search") + 1 + len("template")) + if len(r.Index) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + } + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("_search") + path.WriteString("/") + path.WriteString("template") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.CcsMinimizeRoundtrips != nil { + params["ccs_minimize_roundtrips"] = strconv.FormatBool(*r.CcsMinimizeRoundtrips) + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.Explain != nil { + params["explain"] = strconv.FormatBool(*r.Explain) + } + + if r.IgnoreThrottled != nil { + params["ignore_throttled"] = strconv.FormatBool(*r.IgnoreThrottled) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Profile != nil { + params["profile"] = strconv.FormatBool(*r.Profile) + } + + if r.RestTotalHitsAsInt != nil { + params["rest_total_hits_as_int"] = strconv.FormatBool(*r.RestTotalHitsAsInt) + } + + if len(r.Routing) > 0 { + params["routing"] = strings.Join(r.Routing, ",") + } + + if r.Scroll != 0 { + params["scroll"] = formatDuration(r.Scroll) + } + + if r.SearchType != "" { + params["search_type"] = r.SearchType + } + + if r.TypedKeys != nil { + params["typed_keys"] = strconv.FormatBool(*r.TypedKeys) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SearchTemplate) WithContext(v context.Context) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.ctx = v + } +} + +// WithIndex - a list of index names to search; use _all to perform the operation on all indices. +// +func (f SearchTemplate) WithIndex(v ...string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.Index = v + } +} + +// WithDocumentType - a list of document types to search; leave empty to perform the operation on all types. +// +func (f SearchTemplate) WithDocumentType(v ...string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f SearchTemplate) WithAllowNoIndices(v bool) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.AllowNoIndices = &v + } +} + +// WithCcsMinimizeRoundtrips - indicates whether network round-trips should be minimized as part of cross-cluster search requests execution. +// +func (f SearchTemplate) WithCcsMinimizeRoundtrips(v bool) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.CcsMinimizeRoundtrips = &v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f SearchTemplate) WithExpandWildcards(v string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.ExpandWildcards = v + } +} + +// WithExplain - specify whether to return detailed information about score computation as part of a hit. +// +func (f SearchTemplate) WithExplain(v bool) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.Explain = &v + } +} + +// WithIgnoreThrottled - whether specified concrete, expanded or aliased indices should be ignored when throttled. +// +func (f SearchTemplate) WithIgnoreThrottled(v bool) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.IgnoreThrottled = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f SearchTemplate) WithIgnoreUnavailable(v bool) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f SearchTemplate) WithPreference(v string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.Preference = v + } +} + +// WithProfile - specify whether to profile the query execution. +// +func (f SearchTemplate) WithProfile(v bool) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.Profile = &v + } +} + +// WithRestTotalHitsAsInt - indicates whether hits.total should be rendered as an integer or an object in the rest search response. +// +func (f SearchTemplate) WithRestTotalHitsAsInt(v bool) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.RestTotalHitsAsInt = &v + } +} + +// WithRouting - a list of specific routing values. +// +func (f SearchTemplate) WithRouting(v ...string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.Routing = v + } +} + +// WithScroll - specify how long a consistent view of the index should be maintained for scrolled search. +// +func (f SearchTemplate) WithScroll(v time.Duration) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.Scroll = v + } +} + +// WithSearchType - search operation type. +// +func (f SearchTemplate) WithSearchType(v string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.SearchType = v + } +} + +// WithTypedKeys - specify whether aggregation and suggester names should be prefixed by their respective types in the response. +// +func (f SearchTemplate) WithTypedKeys(v bool) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.TypedKeys = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SearchTemplate) WithPretty() func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SearchTemplate) WithHuman() func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SearchTemplate) WithErrorTrace() func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SearchTemplate) WithFilterPath(v ...string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SearchTemplate) WithHeader(h map[string]string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SearchTemplate) WithOpaqueID(s string) func(*SearchTemplateRequest) { + return func(r *SearchTemplateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.cleanup_repository.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.cleanup_repository.go new file mode 100644 index 000000000..8d734ce94 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.cleanup_repository.go @@ -0,0 +1,237 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newSnapshotCleanupRepositoryFunc(t Transport) SnapshotCleanupRepository { + return func(repository string, o ...func(*SnapshotCleanupRepositoryRequest)) (*Response, error) { + var r = SnapshotCleanupRepositoryRequest{Repository: repository} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotCleanupRepository removes stale data from repository. +// +// +type SnapshotCleanupRepository func(repository string, o ...func(*SnapshotCleanupRepositoryRequest)) (*Response, error) + +// SnapshotCleanupRepositoryRequest configures the Snapshot Cleanup Repository API request. +// +type SnapshotCleanupRepositoryRequest struct { + Repository string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotCleanupRepositoryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len("_cleanup")) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(r.Repository) + path.WriteString("/") + path.WriteString("_cleanup") + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotCleanupRepository) WithContext(v context.Context) func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotCleanupRepository) WithMasterTimeout(v time.Duration) func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f SnapshotCleanupRepository) WithTimeout(v time.Duration) func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotCleanupRepository) WithPretty() func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotCleanupRepository) WithHuman() func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotCleanupRepository) WithErrorTrace() func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotCleanupRepository) WithFilterPath(v ...string) func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotCleanupRepository) WithHeader(h map[string]string) func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotCleanupRepository) WithOpaqueID(s string) func(*SnapshotCleanupRepositoryRequest) { + return func(r *SnapshotCleanupRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.clone.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.clone.go new file mode 100644 index 000000000..10ab03a44 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.clone.go @@ -0,0 +1,237 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" + "time" +) + +func newSnapshotCloneFunc(t Transport) SnapshotClone { + return func(repository string, snapshot string, body io.Reader, target_snapshot string, o ...func(*SnapshotCloneRequest)) (*Response, error) { + var r = SnapshotCloneRequest{Repository: repository, Snapshot: snapshot, Body: body, TargetSnapshot: target_snapshot} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotClone clones indices from one snapshot into another snapshot in the same repository. +// +// +type SnapshotClone func(repository string, snapshot string, body io.Reader, target_snapshot string, o ...func(*SnapshotCloneRequest)) (*Response, error) + +// SnapshotCloneRequest configures the Snapshot Clone API request. +// +type SnapshotCloneRequest struct { + Body io.Reader + + Repository string + Snapshot string + TargetSnapshot string + + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotCloneRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len(r.Snapshot) + 1 + len("_clone") + 1 + len(r.TargetSnapshot)) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(r.Repository) + path.WriteString("/") + path.WriteString(r.Snapshot) + path.WriteString("/") + path.WriteString("_clone") + path.WriteString("/") + path.WriteString(r.TargetSnapshot) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotClone) WithContext(v context.Context) func(*SnapshotCloneRequest) { + return func(r *SnapshotCloneRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotClone) WithMasterTimeout(v time.Duration) func(*SnapshotCloneRequest) { + return func(r *SnapshotCloneRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotClone) WithPretty() func(*SnapshotCloneRequest) { + return func(r *SnapshotCloneRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotClone) WithHuman() func(*SnapshotCloneRequest) { + return func(r *SnapshotCloneRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotClone) WithErrorTrace() func(*SnapshotCloneRequest) { + return func(r *SnapshotCloneRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotClone) WithFilterPath(v ...string) func(*SnapshotCloneRequest) { + return func(r *SnapshotCloneRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotClone) WithHeader(h map[string]string) func(*SnapshotCloneRequest) { + return func(r *SnapshotCloneRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotClone) WithOpaqueID(s string) func(*SnapshotCloneRequest) { + return func(r *SnapshotCloneRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.create.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.create.go new file mode 100644 index 000000000..7dc6223e9 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.create.go @@ -0,0 +1,254 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newSnapshotCreateFunc(t Transport) SnapshotCreate { + return func(repository string, snapshot string, o ...func(*SnapshotCreateRequest)) (*Response, error) { + var r = SnapshotCreateRequest{Repository: repository, Snapshot: snapshot} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotCreate creates a snapshot in a repository. +// +// +type SnapshotCreate func(repository string, snapshot string, o ...func(*SnapshotCreateRequest)) (*Response, error) + +// SnapshotCreateRequest configures the Snapshot Create API request. +// +type SnapshotCreateRequest struct { + Body io.Reader + + Repository string + Snapshot string + + MasterTimeout time.Duration + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotCreateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len(r.Snapshot)) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(r.Repository) + path.WriteString("/") + path.WriteString(r.Snapshot) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotCreate) WithContext(v context.Context) func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + r.ctx = v + } +} + +// WithBody - The snapshot definition. +// +func (f SnapshotCreate) WithBody(v io.Reader) func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + r.Body = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotCreate) WithMasterTimeout(v time.Duration) func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + r.MasterTimeout = v + } +} + +// WithWaitForCompletion - should this request wait until the operation has completed before returning. +// +func (f SnapshotCreate) WithWaitForCompletion(v bool) func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotCreate) WithPretty() func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotCreate) WithHuman() func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotCreate) WithErrorTrace() func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotCreate) WithFilterPath(v ...string) func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotCreate) WithHeader(h map[string]string) func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotCreate) WithOpaqueID(s string) func(*SnapshotCreateRequest) { + return func(r *SnapshotCreateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.create_repository.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.create_repository.go new file mode 100644 index 000000000..615ce23eb --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.create_repository.go @@ -0,0 +1,256 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newSnapshotCreateRepositoryFunc(t Transport) SnapshotCreateRepository { + return func(repository string, body io.Reader, o ...func(*SnapshotCreateRepositoryRequest)) (*Response, error) { + var r = SnapshotCreateRepositoryRequest{Repository: repository, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotCreateRepository creates a repository. +// +// +type SnapshotCreateRepository func(repository string, body io.Reader, o ...func(*SnapshotCreateRepositoryRequest)) (*Response, error) + +// SnapshotCreateRepositoryRequest configures the Snapshot Create Repository API request. +// +type SnapshotCreateRepositoryRequest struct { + Body io.Reader + + Repository string + + MasterTimeout time.Duration + Timeout time.Duration + Verify *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotCreateRepositoryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "PUT" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository)) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(r.Repository) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Verify != nil { + params["verify"] = strconv.FormatBool(*r.Verify) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotCreateRepository) WithContext(v context.Context) func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotCreateRepository) WithMasterTimeout(v time.Duration) func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f SnapshotCreateRepository) WithTimeout(v time.Duration) func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + r.Timeout = v + } +} + +// WithVerify - whether to verify the repository after creation. +// +func (f SnapshotCreateRepository) WithVerify(v bool) func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + r.Verify = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotCreateRepository) WithPretty() func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotCreateRepository) WithHuman() func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotCreateRepository) WithErrorTrace() func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotCreateRepository) WithFilterPath(v ...string) func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotCreateRepository) WithHeader(h map[string]string) func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotCreateRepository) WithOpaqueID(s string) func(*SnapshotCreateRepositoryRequest) { + return func(r *SnapshotCreateRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.delete.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.delete.go new file mode 100644 index 000000000..6de65646b --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.delete.go @@ -0,0 +1,225 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newSnapshotDeleteFunc(t Transport) SnapshotDelete { + return func(repository string, snapshot string, o ...func(*SnapshotDeleteRequest)) (*Response, error) { + var r = SnapshotDeleteRequest{Repository: repository, Snapshot: snapshot} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotDelete deletes a snapshot. +// +// +type SnapshotDelete func(repository string, snapshot string, o ...func(*SnapshotDeleteRequest)) (*Response, error) + +// SnapshotDeleteRequest configures the Snapshot Delete API request. +// +type SnapshotDeleteRequest struct { + Repository string + Snapshot string + + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotDeleteRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len(r.Snapshot)) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(r.Repository) + path.WriteString("/") + path.WriteString(r.Snapshot) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotDelete) WithContext(v context.Context) func(*SnapshotDeleteRequest) { + return func(r *SnapshotDeleteRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotDelete) WithMasterTimeout(v time.Duration) func(*SnapshotDeleteRequest) { + return func(r *SnapshotDeleteRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotDelete) WithPretty() func(*SnapshotDeleteRequest) { + return func(r *SnapshotDeleteRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotDelete) WithHuman() func(*SnapshotDeleteRequest) { + return func(r *SnapshotDeleteRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotDelete) WithErrorTrace() func(*SnapshotDeleteRequest) { + return func(r *SnapshotDeleteRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotDelete) WithFilterPath(v ...string) func(*SnapshotDeleteRequest) { + return func(r *SnapshotDeleteRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotDelete) WithHeader(h map[string]string) func(*SnapshotDeleteRequest) { + return func(r *SnapshotDeleteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotDelete) WithOpaqueID(s string) func(*SnapshotDeleteRequest) { + return func(r *SnapshotDeleteRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.delete_repository.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.delete_repository.go new file mode 100644 index 000000000..261e14cb1 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.delete_repository.go @@ -0,0 +1,235 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newSnapshotDeleteRepositoryFunc(t Transport) SnapshotDeleteRepository { + return func(repository []string, o ...func(*SnapshotDeleteRepositoryRequest)) (*Response, error) { + var r = SnapshotDeleteRepositoryRequest{Repository: repository} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotDeleteRepository deletes a repository. +// +// +type SnapshotDeleteRepository func(repository []string, o ...func(*SnapshotDeleteRepositoryRequest)) (*Response, error) + +// SnapshotDeleteRepositoryRequest configures the Snapshot Delete Repository API request. +// +type SnapshotDeleteRepositoryRequest struct { + Repository []string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotDeleteRepositoryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "DELETE" + + path.Grow(1 + len("_snapshot") + 1 + len(strings.Join(r.Repository, ","))) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(strings.Join(r.Repository, ",")) + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotDeleteRepository) WithContext(v context.Context) func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotDeleteRepository) WithMasterTimeout(v time.Duration) func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f SnapshotDeleteRepository) WithTimeout(v time.Duration) func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotDeleteRepository) WithPretty() func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotDeleteRepository) WithHuman() func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotDeleteRepository) WithErrorTrace() func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotDeleteRepository) WithFilterPath(v ...string) func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotDeleteRepository) WithHeader(h map[string]string) func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotDeleteRepository) WithOpaqueID(s string) func(*SnapshotDeleteRepositoryRequest) { + return func(r *SnapshotDeleteRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.get.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.get.go new file mode 100644 index 000000000..c6e3317a5 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.get.go @@ -0,0 +1,278 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newSnapshotGetFunc(t Transport) SnapshotGet { + return func(repository string, snapshot []string, o ...func(*SnapshotGetRequest)) (*Response, error) { + var r = SnapshotGetRequest{Repository: repository, Snapshot: snapshot} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotGet returns information about a snapshot. +// +// +type SnapshotGet func(repository string, snapshot []string, o ...func(*SnapshotGetRequest)) (*Response, error) + +// SnapshotGetRequest configures the Snapshot Get API request. +// +type SnapshotGetRequest struct { + Repository string + Snapshot []string + + IgnoreUnavailable *bool + IncludeRepository *bool + IndexDetails *bool + MasterTimeout time.Duration + Verbose *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotGetRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len(strings.Join(r.Snapshot, ","))) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(r.Repository) + path.WriteString("/") + path.WriteString(strings.Join(r.Snapshot, ",")) + + params = make(map[string]string) + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.IncludeRepository != nil { + params["include_repository"] = strconv.FormatBool(*r.IncludeRepository) + } + + if r.IndexDetails != nil { + params["index_details"] = strconv.FormatBool(*r.IndexDetails) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Verbose != nil { + params["verbose"] = strconv.FormatBool(*r.Verbose) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotGet) WithContext(v context.Context) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.ctx = v + } +} + +// WithIgnoreUnavailable - whether to ignore unavailable snapshots, defaults to false which means a snapshotmissingexception is thrown. +// +func (f SnapshotGet) WithIgnoreUnavailable(v bool) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithIncludeRepository - whether to include the repository name in the snapshot info. defaults to true.. +// +func (f SnapshotGet) WithIncludeRepository(v bool) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.IncludeRepository = &v + } +} + +// WithIndexDetails - whether to include details of each index in the snapshot, if those details are available. defaults to false.. +// +func (f SnapshotGet) WithIndexDetails(v bool) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.IndexDetails = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotGet) WithMasterTimeout(v time.Duration) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.MasterTimeout = v + } +} + +// WithVerbose - whether to show verbose snapshot info or only show the basic info found in the repository index blob. +// +func (f SnapshotGet) WithVerbose(v bool) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.Verbose = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotGet) WithPretty() func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotGet) WithHuman() func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotGet) WithErrorTrace() func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotGet) WithFilterPath(v ...string) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotGet) WithHeader(h map[string]string) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotGet) WithOpaqueID(s string) func(*SnapshotGetRequest) { + return func(r *SnapshotGetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.get_repository.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.get_repository.go new file mode 100644 index 000000000..d03428648 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.get_repository.go @@ -0,0 +1,246 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newSnapshotGetRepositoryFunc(t Transport) SnapshotGetRepository { + return func(o ...func(*SnapshotGetRepositoryRequest)) (*Response, error) { + var r = SnapshotGetRepositoryRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotGetRepository returns information about a repository. +// +// +type SnapshotGetRepository func(o ...func(*SnapshotGetRepositoryRequest)) (*Response, error) + +// SnapshotGetRepositoryRequest configures the Snapshot Get Repository API request. +// +type SnapshotGetRepositoryRequest struct { + Repository []string + + Local *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotGetRepositoryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_snapshot") + 1 + len(strings.Join(r.Repository, ","))) + path.WriteString("/") + path.WriteString("_snapshot") + if len(r.Repository) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Repository, ",")) + } + + params = make(map[string]string) + + if r.Local != nil { + params["local"] = strconv.FormatBool(*r.Local) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotGetRepository) WithContext(v context.Context) func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + r.ctx = v + } +} + +// WithRepository - a list of repository names. +// +func (f SnapshotGetRepository) WithRepository(v ...string) func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + r.Repository = v + } +} + +// WithLocal - return local information, do not retrieve the state from master node (default: false). +// +func (f SnapshotGetRepository) WithLocal(v bool) func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + r.Local = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotGetRepository) WithMasterTimeout(v time.Duration) func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotGetRepository) WithPretty() func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotGetRepository) WithHuman() func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotGetRepository) WithErrorTrace() func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotGetRepository) WithFilterPath(v ...string) func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotGetRepository) WithHeader(h map[string]string) func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotGetRepository) WithOpaqueID(s string) func(*SnapshotGetRepositoryRequest) { + return func(r *SnapshotGetRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.restore.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.restore.go new file mode 100644 index 000000000..d6e9fe5b3 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.restore.go @@ -0,0 +1,256 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newSnapshotRestoreFunc(t Transport) SnapshotRestore { + return func(repository string, snapshot string, o ...func(*SnapshotRestoreRequest)) (*Response, error) { + var r = SnapshotRestoreRequest{Repository: repository, Snapshot: snapshot} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotRestore restores a snapshot. +// +// +type SnapshotRestore func(repository string, snapshot string, o ...func(*SnapshotRestoreRequest)) (*Response, error) + +// SnapshotRestoreRequest configures the Snapshot Restore API request. +// +type SnapshotRestoreRequest struct { + Body io.Reader + + Repository string + Snapshot string + + MasterTimeout time.Duration + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotRestoreRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len(r.Snapshot) + 1 + len("_restore")) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(r.Repository) + path.WriteString("/") + path.WriteString(r.Snapshot) + path.WriteString("/") + path.WriteString("_restore") + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotRestore) WithContext(v context.Context) func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + r.ctx = v + } +} + +// WithBody - Details of what to restore. +// +func (f SnapshotRestore) WithBody(v io.Reader) func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + r.Body = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotRestore) WithMasterTimeout(v time.Duration) func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + r.MasterTimeout = v + } +} + +// WithWaitForCompletion - should this request wait until the operation has completed before returning. +// +func (f SnapshotRestore) WithWaitForCompletion(v bool) func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotRestore) WithPretty() func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotRestore) WithHuman() func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotRestore) WithErrorTrace() func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotRestore) WithFilterPath(v ...string) func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotRestore) WithHeader(h map[string]string) func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotRestore) WithOpaqueID(s string) func(*SnapshotRestoreRequest) { + return func(r *SnapshotRestoreRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.status.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.status.go new file mode 100644 index 000000000..d642c3c1a --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.status.go @@ -0,0 +1,261 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newSnapshotStatusFunc(t Transport) SnapshotStatus { + return func(o ...func(*SnapshotStatusRequest)) (*Response, error) { + var r = SnapshotStatusRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotStatus returns information about the status of a snapshot. +// +// +type SnapshotStatus func(o ...func(*SnapshotStatusRequest)) (*Response, error) + +// SnapshotStatusRequest configures the Snapshot Status API request. +// +type SnapshotStatusRequest struct { + Repository string + Snapshot []string + + IgnoreUnavailable *bool + MasterTimeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotStatusRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len(strings.Join(r.Snapshot, ",")) + 1 + len("_status")) + path.WriteString("/") + path.WriteString("_snapshot") + if r.Repository != "" { + path.WriteString("/") + path.WriteString(r.Repository) + } + if len(r.Snapshot) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.Snapshot, ",")) + } + path.WriteString("/") + path.WriteString("_status") + + params = make(map[string]string) + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotStatus) WithContext(v context.Context) func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.ctx = v + } +} + +// WithRepository - a repository name. +// +func (f SnapshotStatus) WithRepository(v string) func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.Repository = v + } +} + +// WithSnapshot - a list of snapshot names. +// +func (f SnapshotStatus) WithSnapshot(v ...string) func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.Snapshot = v + } +} + +// WithIgnoreUnavailable - whether to ignore unavailable snapshots, defaults to false which means a snapshotmissingexception is thrown. +// +func (f SnapshotStatus) WithIgnoreUnavailable(v bool) func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotStatus) WithMasterTimeout(v time.Duration) func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.MasterTimeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotStatus) WithPretty() func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotStatus) WithHuman() func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotStatus) WithErrorTrace() func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotStatus) WithFilterPath(v ...string) func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotStatus) WithHeader(h map[string]string) func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotStatus) WithOpaqueID(s string) func(*SnapshotStatusRequest) { + return func(r *SnapshotStatusRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.verify_repository.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.verify_repository.go new file mode 100644 index 000000000..bd71f3f09 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.snapshot.verify_repository.go @@ -0,0 +1,237 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strings" + "time" +) + +func newSnapshotVerifyRepositoryFunc(t Transport) SnapshotVerifyRepository { + return func(repository string, o ...func(*SnapshotVerifyRepositoryRequest)) (*Response, error) { + var r = SnapshotVerifyRepositoryRequest{Repository: repository} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// SnapshotVerifyRepository verifies a repository. +// +// +type SnapshotVerifyRepository func(repository string, o ...func(*SnapshotVerifyRepositoryRequest)) (*Response, error) + +// SnapshotVerifyRepositoryRequest configures the Snapshot Verify Repository API request. +// +type SnapshotVerifyRepositoryRequest struct { + Repository string + + MasterTimeout time.Duration + Timeout time.Duration + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r SnapshotVerifyRepositoryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_snapshot") + 1 + len(r.Repository) + 1 + len("_verify")) + path.WriteString("/") + path.WriteString("_snapshot") + path.WriteString("/") + path.WriteString(r.Repository) + path.WriteString("/") + path.WriteString("_verify") + + params = make(map[string]string) + + if r.MasterTimeout != 0 { + params["master_timeout"] = formatDuration(r.MasterTimeout) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f SnapshotVerifyRepository) WithContext(v context.Context) func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + r.ctx = v + } +} + +// WithMasterTimeout - explicit operation timeout for connection to master node. +// +func (f SnapshotVerifyRepository) WithMasterTimeout(v time.Duration) func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + r.MasterTimeout = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f SnapshotVerifyRepository) WithTimeout(v time.Duration) func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + r.Timeout = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f SnapshotVerifyRepository) WithPretty() func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f SnapshotVerifyRepository) WithHuman() func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f SnapshotVerifyRepository) WithErrorTrace() func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f SnapshotVerifyRepository) WithFilterPath(v ...string) func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f SnapshotVerifyRepository) WithHeader(h map[string]string) func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f SnapshotVerifyRepository) WithOpaqueID(s string) func(*SnapshotVerifyRepositoryRequest) { + return func(r *SnapshotVerifyRepositoryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.cancel.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.cancel.go new file mode 100644 index 000000000..5996a4b76 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.cancel.go @@ -0,0 +1,275 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newTasksCancelFunc(t Transport) TasksCancel { + return func(o ...func(*TasksCancelRequest)) (*Response, error) { + var r = TasksCancelRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// TasksCancel cancels a task, if it can be cancelled through an API. +// +// This API is experimental. +// +// +type TasksCancel func(o ...func(*TasksCancelRequest)) (*Response, error) + +// TasksCancelRequest configures the Tasks Cancel API request. +// +type TasksCancelRequest struct { + TaskID string + + Actions []string + Nodes []string + ParentTaskID string + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r TasksCancelRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_tasks") + 1 + len(r.TaskID) + 1 + len("_cancel")) + path.WriteString("/") + path.WriteString("_tasks") + if r.TaskID != "" { + path.WriteString("/") + path.WriteString(r.TaskID) + } + path.WriteString("/") + path.WriteString("_cancel") + + params = make(map[string]string) + + if len(r.Actions) > 0 { + params["actions"] = strings.Join(r.Actions, ",") + } + + if len(r.Nodes) > 0 { + params["nodes"] = strings.Join(r.Nodes, ",") + } + + if r.ParentTaskID != "" { + params["parent_task_id"] = r.ParentTaskID + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f TasksCancel) WithContext(v context.Context) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.ctx = v + } +} + +// WithTaskID - cancel the task with specified task ID (node_id:task_number). +// +func (f TasksCancel) WithTaskID(v string) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.TaskID = v + } +} + +// WithActions - a list of actions that should be cancelled. leave empty to cancel all.. +// +func (f TasksCancel) WithActions(v ...string) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.Actions = v + } +} + +// WithNodes - a list of node ids or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes. +// +func (f TasksCancel) WithNodes(v ...string) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.Nodes = v + } +} + +// WithParentTaskID - cancel tasks with specified parent task ID (node_id:task_number). set to -1 to cancel all.. +// +func (f TasksCancel) WithParentTaskID(v string) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.ParentTaskID = v + } +} + +// WithWaitForCompletion - should the request block until the cancellation of the task and its descendant tasks is completed. defaults to false. +// +func (f TasksCancel) WithWaitForCompletion(v bool) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f TasksCancel) WithPretty() func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f TasksCancel) WithHuman() func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f TasksCancel) WithErrorTrace() func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f TasksCancel) WithFilterPath(v ...string) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f TasksCancel) WithHeader(h map[string]string) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f TasksCancel) WithOpaqueID(s string) func(*TasksCancelRequest) { + return func(r *TasksCancelRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.get.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.get.go new file mode 100644 index 000000000..42d00b4b3 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.get.go @@ -0,0 +1,238 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newTasksGetFunc(t Transport) TasksGet { + return func(task_id string, o ...func(*TasksGetRequest)) (*Response, error) { + var r = TasksGetRequest{TaskID: task_id} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// TasksGet returns information about a task. +// +// This API is experimental. +// +// +type TasksGet func(task_id string, o ...func(*TasksGetRequest)) (*Response, error) + +// TasksGetRequest configures the Tasks Get API request. +// +type TasksGetRequest struct { + TaskID string + + Timeout time.Duration + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r TasksGetRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(1 + len("_tasks") + 1 + len(r.TaskID)) + path.WriteString("/") + path.WriteString("_tasks") + path.WriteString("/") + path.WriteString(r.TaskID) + + params = make(map[string]string) + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f TasksGet) WithContext(v context.Context) func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + r.ctx = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f TasksGet) WithTimeout(v time.Duration) func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + r.Timeout = v + } +} + +// WithWaitForCompletion - wait for the matching tasks to complete (default: false). +// +func (f TasksGet) WithWaitForCompletion(v bool) func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f TasksGet) WithPretty() func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f TasksGet) WithHuman() func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f TasksGet) WithErrorTrace() func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f TasksGet) WithFilterPath(v ...string) func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f TasksGet) WithHeader(h map[string]string) func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f TasksGet) WithOpaqueID(s string) func(*TasksGetRequest) { + return func(r *TasksGetRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.list.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.list.go new file mode 100644 index 000000000..a0ffaadea --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.tasks.list.go @@ -0,0 +1,298 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" + "time" +) + +func newTasksListFunc(t Transport) TasksList { + return func(o ...func(*TasksListRequest)) (*Response, error) { + var r = TasksListRequest{} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// TasksList returns a list of tasks. +// +// This API is experimental. +// +// +type TasksList func(o ...func(*TasksListRequest)) (*Response, error) + +// TasksListRequest configures the Tasks List API request. +// +type TasksListRequest struct { + Actions []string + Detailed *bool + GroupBy string + Nodes []string + ParentTaskID string + Timeout time.Duration + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r TasksListRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "GET" + + path.Grow(len("/_tasks")) + path.WriteString("/_tasks") + + params = make(map[string]string) + + if len(r.Actions) > 0 { + params["actions"] = strings.Join(r.Actions, ",") + } + + if r.Detailed != nil { + params["detailed"] = strconv.FormatBool(*r.Detailed) + } + + if r.GroupBy != "" { + params["group_by"] = r.GroupBy + } + + if len(r.Nodes) > 0 { + params["nodes"] = strings.Join(r.Nodes, ",") + } + + if r.ParentTaskID != "" { + params["parent_task_id"] = r.ParentTaskID + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f TasksList) WithContext(v context.Context) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.ctx = v + } +} + +// WithActions - a list of actions that should be returned. leave empty to return all.. +// +func (f TasksList) WithActions(v ...string) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.Actions = v + } +} + +// WithDetailed - return detailed task information (default: false). +// +func (f TasksList) WithDetailed(v bool) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.Detailed = &v + } +} + +// WithGroupBy - group tasks by nodes or parent/child relationships. +// +func (f TasksList) WithGroupBy(v string) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.GroupBy = v + } +} + +// WithNodes - a list of node ids or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes. +// +func (f TasksList) WithNodes(v ...string) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.Nodes = v + } +} + +// WithParentTaskID - return tasks with specified parent task ID (node_id:task_number). set to -1 to return all.. +// +func (f TasksList) WithParentTaskID(v string) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.ParentTaskID = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f TasksList) WithTimeout(v time.Duration) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.Timeout = v + } +} + +// WithWaitForCompletion - wait for the matching tasks to complete (default: false). +// +func (f TasksList) WithWaitForCompletion(v bool) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f TasksList) WithPretty() func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f TasksList) WithHuman() func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f TasksList) WithErrorTrace() func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f TasksList) WithFilterPath(v ...string) func(*TasksListRequest) { + return func(r *TasksListRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f TasksList) WithHeader(h map[string]string) func(*TasksListRequest) { + return func(r *TasksListRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f TasksList) WithOpaqueID(s string) func(*TasksListRequest) { + return func(r *TasksListRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.terms_enum.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.terms_enum.go new file mode 100644 index 000000000..f671d3d89 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.terms_enum.go @@ -0,0 +1,224 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strings" +) + +func newTermsEnumFunc(t Transport) TermsEnum { + return func(index []string, o ...func(*TermsEnumRequest)) (*Response, error) { + var r = TermsEnumRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// TermsEnum the terms enum API can be used to discover terms in the index that begin with the provided string. It is designed for low-latency look-ups used in auto-complete scenarios. +// +// This API is beta. +// +// +type TermsEnum func(index []string, o ...func(*TermsEnumRequest)) (*Response, error) + +// TermsEnumRequest configures the Terms Enum API request. +// +type TermsEnumRequest struct { + Index []string + + Body io.Reader + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r TermsEnumRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len("_terms_enum")) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + path.WriteString("/") + path.WriteString("_terms_enum") + + params = make(map[string]string) + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f TermsEnum) WithContext(v context.Context) func(*TermsEnumRequest) { + return func(r *TermsEnumRequest) { + r.ctx = v + } +} + +// WithBody - field name, string which is the prefix expected in matching terms, timeout and size for max number of results. +// +func (f TermsEnum) WithBody(v io.Reader) func(*TermsEnumRequest) { + return func(r *TermsEnumRequest) { + r.Body = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f TermsEnum) WithPretty() func(*TermsEnumRequest) { + return func(r *TermsEnumRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f TermsEnum) WithHuman() func(*TermsEnumRequest) { + return func(r *TermsEnumRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f TermsEnum) WithErrorTrace() func(*TermsEnumRequest) { + return func(r *TermsEnumRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f TermsEnum) WithFilterPath(v ...string) func(*TermsEnumRequest) { + return func(r *TermsEnumRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f TermsEnum) WithHeader(h map[string]string) func(*TermsEnumRequest) { + return func(r *TermsEnumRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f TermsEnum) WithOpaqueID(s string) func(*TermsEnumRequest) { + return func(r *TermsEnumRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.termvectors.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.termvectors.go new file mode 100644 index 000000000..2caabc8e8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.termvectors.go @@ -0,0 +1,397 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" +) + +func newTermvectorsFunc(t Transport) Termvectors { + return func(index string, o ...func(*TermvectorsRequest)) (*Response, error) { + var r = TermvectorsRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Termvectors returns information and statistics about terms in the fields of a particular document. +// +// +type Termvectors func(index string, o ...func(*TermvectorsRequest)) (*Response, error) + +// TermvectorsRequest configures the Termvectors API request. +// +type TermvectorsRequest struct { + Index string + DocumentType string + DocumentID string + + Body io.Reader + + Fields []string + FieldStatistics *bool + Offsets *bool + Payloads *bool + Positions *bool + Preference string + Realtime *bool + Routing string + TermStatistics *bool + Version *int + VersionType string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r TermvectorsRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID) + 1 + len("_termvectors")) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + if r.DocumentID != "" { + path.WriteString("/") + path.WriteString(r.DocumentID) + } + path.WriteString("/") + path.WriteString("_termvectors") + + params = make(map[string]string) + + if len(r.Fields) > 0 { + params["fields"] = strings.Join(r.Fields, ",") + } + + if r.FieldStatistics != nil { + params["field_statistics"] = strconv.FormatBool(*r.FieldStatistics) + } + + if r.Offsets != nil { + params["offsets"] = strconv.FormatBool(*r.Offsets) + } + + if r.Payloads != nil { + params["payloads"] = strconv.FormatBool(*r.Payloads) + } + + if r.Positions != nil { + params["positions"] = strconv.FormatBool(*r.Positions) + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Realtime != nil { + params["realtime"] = strconv.FormatBool(*r.Realtime) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if r.TermStatistics != nil { + params["term_statistics"] = strconv.FormatBool(*r.TermStatistics) + } + + if r.Version != nil { + params["version"] = strconv.FormatInt(int64(*r.Version), 10) + } + + if r.VersionType != "" { + params["version_type"] = r.VersionType + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Termvectors) WithContext(v context.Context) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.ctx = v + } +} + +// WithBody - Define parameters and or supply a document to get termvectors for. See documentation.. +// +func (f Termvectors) WithBody(v io.Reader) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Body = v + } +} + +// WithDocumentID - the ID of the document, when not specified a doc param should be supplied.. +// +func (f Termvectors) WithDocumentID(v string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.DocumentID = v + } +} + +// WithDocumentType - the type of the document.. +// +func (f Termvectors) WithDocumentType(v string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.DocumentType = v + } +} + +// WithFields - a list of fields to return.. +// +func (f Termvectors) WithFields(v ...string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Fields = v + } +} + +// WithFieldStatistics - specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.. +// +func (f Termvectors) WithFieldStatistics(v bool) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.FieldStatistics = &v + } +} + +// WithOffsets - specifies if term offsets should be returned.. +// +func (f Termvectors) WithOffsets(v bool) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Offsets = &v + } +} + +// WithPayloads - specifies if term payloads should be returned.. +// +func (f Termvectors) WithPayloads(v bool) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Payloads = &v + } +} + +// WithPositions - specifies if term positions should be returned.. +// +func (f Termvectors) WithPositions(v bool) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Positions = &v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random).. +// +func (f Termvectors) WithPreference(v string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Preference = v + } +} + +// WithRealtime - specifies if request is real-time as opposed to near-real-time (default: true).. +// +func (f Termvectors) WithRealtime(v bool) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Realtime = &v + } +} + +// WithRouting - specific routing value.. +// +func (f Termvectors) WithRouting(v string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Routing = v + } +} + +// WithTermStatistics - specifies if total term frequency and document frequency should be returned.. +// +func (f Termvectors) WithTermStatistics(v bool) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.TermStatistics = &v + } +} + +// WithVersion - explicit version number for concurrency control. +// +func (f Termvectors) WithVersion(v int) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Version = &v + } +} + +// WithVersionType - specific version type. +// +func (f Termvectors) WithVersionType(v string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.VersionType = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Termvectors) WithPretty() func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Termvectors) WithHuman() func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Termvectors) WithErrorTrace() func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Termvectors) WithFilterPath(v ...string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Termvectors) WithHeader(h map[string]string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Termvectors) WithOpaqueID(s string) func(*TermvectorsRequest) { + return func(r *TermvectorsRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update.go new file mode 100644 index 000000000..20acbebb1 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update.go @@ -0,0 +1,393 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newUpdateFunc(t Transport) Update { + return func(index string, id string, body io.Reader, o ...func(*UpdateRequest)) (*Response, error) { + var r = UpdateRequest{Index: index, DocumentID: id, Body: body} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// Update updates a document with a script or partial document. +// +// +type Update func(index string, id string, body io.Reader, o ...func(*UpdateRequest)) (*Response, error) + +// UpdateRequest configures the Update API request. +// +type UpdateRequest struct { + Index string + DocumentType string + DocumentID string + + Body io.Reader + + IfPrimaryTerm *int + IfSeqNo *int + Lang string + Refresh string + RequireAlias *bool + RetryOnConflict *int + Routing string + Source []string + SourceExcludes []string + SourceIncludes []string + Timeout time.Duration + WaitForActiveShards string + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r UpdateRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + if r.DocumentType == "" { + r.DocumentType = "_doc" + } + + path.Grow(1 + len(r.Index) + 1 + len(r.DocumentType) + 1 + len(r.DocumentID) + 1 + len("_update")) + path.WriteString("/") + path.WriteString(r.Index) + if r.DocumentType != "" { + path.WriteString("/") + path.WriteString(r.DocumentType) + } + path.WriteString("/") + path.WriteString(r.DocumentID) + path.WriteString("/") + path.WriteString("_update") + + params = make(map[string]string) + + if r.IfPrimaryTerm != nil { + params["if_primary_term"] = strconv.FormatInt(int64(*r.IfPrimaryTerm), 10) + } + + if r.IfSeqNo != nil { + params["if_seq_no"] = strconv.FormatInt(int64(*r.IfSeqNo), 10) + } + + if r.Lang != "" { + params["lang"] = r.Lang + } + + if r.Refresh != "" { + params["refresh"] = r.Refresh + } + + if r.RequireAlias != nil { + params["require_alias"] = strconv.FormatBool(*r.RequireAlias) + } + + if r.RetryOnConflict != nil { + params["retry_on_conflict"] = strconv.FormatInt(int64(*r.RetryOnConflict), 10) + } + + if r.Routing != "" { + params["routing"] = r.Routing + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f Update) WithContext(v context.Context) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.ctx = v + } +} + +// WithDocumentType - the type of the document. +// +func (f Update) WithDocumentType(v string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.DocumentType = v + } +} + +// WithIfPrimaryTerm - only perform the update operation if the last operation that has changed the document has the specified primary term. +// +func (f Update) WithIfPrimaryTerm(v int) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.IfPrimaryTerm = &v + } +} + +// WithIfSeqNo - only perform the update operation if the last operation that has changed the document has the specified sequence number. +// +func (f Update) WithIfSeqNo(v int) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.IfSeqNo = &v + } +} + +// WithLang - the script language (default: painless). +// +func (f Update) WithLang(v string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.Lang = v + } +} + +// WithRefresh - if `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.. +// +func (f Update) WithRefresh(v string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.Refresh = v + } +} + +// WithRequireAlias - when true, requires destination is an alias. default is false. +// +func (f Update) WithRequireAlias(v bool) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.RequireAlias = &v + } +} + +// WithRetryOnConflict - specify how many times should the operation be retried when a conflict occurs (default: 0). +// +func (f Update) WithRetryOnConflict(v int) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.RetryOnConflict = &v + } +} + +// WithRouting - specific routing value. +// +func (f Update) WithRouting(v string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.Routing = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f Update) WithSource(v ...string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f Update) WithSourceExcludes(v ...string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f Update) WithSourceIncludes(v ...string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.SourceIncludes = v + } +} + +// WithTimeout - explicit operation timeout. +// +func (f Update) WithTimeout(v time.Duration) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.Timeout = v + } +} + +// WithWaitForActiveShards - sets the number of shard copies that must be active before proceeding with the update operation. defaults to 1, meaning the primary shard only. set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1). +// +func (f Update) WithWaitForActiveShards(v string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.WaitForActiveShards = v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f Update) WithPretty() func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f Update) WithHuman() func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f Update) WithErrorTrace() func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f Update) WithFilterPath(v ...string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f Update) WithHeader(h map[string]string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f Update) WithOpaqueID(s string) func(*UpdateRequest) { + return func(r *UpdateRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update_by_query.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update_by_query.go new file mode 100644 index 000000000..f1af32071 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update_by_query.go @@ -0,0 +1,695 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "fmt" + "io" + "net/http" + "strconv" + "strings" + "time" +) + +func newUpdateByQueryFunc(t Transport) UpdateByQuery { + return func(index []string, o ...func(*UpdateByQueryRequest)) (*Response, error) { + var r = UpdateByQueryRequest{Index: index} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// UpdateByQuery performs an update on every document in the index without changing the source, +// for example to pick up a mapping change. +// +// +type UpdateByQuery func(index []string, o ...func(*UpdateByQueryRequest)) (*Response, error) + +// UpdateByQueryRequest configures the Update By Query API request. +// +type UpdateByQueryRequest struct { + Index []string + DocumentType []string + + Body io.Reader + + AllowNoIndices *bool + Analyzer string + AnalyzeWildcard *bool + Conflicts string + DefaultOperator string + Df string + ExpandWildcards string + From *int + IgnoreUnavailable *bool + Lenient *bool + MaxDocs *int + Pipeline string + Preference string + Query string + Refresh *bool + RequestCache *bool + RequestsPerSecond *int + Routing []string + Scroll time.Duration + ScrollSize *int + SearchTimeout time.Duration + SearchType string + Size *int + Slices interface{} + Sort []string + Source []string + SourceExcludes []string + SourceIncludes []string + Stats []string + TerminateAfter *int + Timeout time.Duration + Version *bool + VersionType *bool + WaitForActiveShards string + WaitForCompletion *bool + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r UpdateByQueryRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len(strings.Join(r.Index, ",")) + 1 + len(strings.Join(r.DocumentType, ",")) + 1 + len("_update_by_query")) + path.WriteString("/") + path.WriteString(strings.Join(r.Index, ",")) + if len(r.DocumentType) > 0 { + path.WriteString("/") + path.WriteString(strings.Join(r.DocumentType, ",")) + } + path.WriteString("/") + path.WriteString("_update_by_query") + + params = make(map[string]string) + + if r.AllowNoIndices != nil { + params["allow_no_indices"] = strconv.FormatBool(*r.AllowNoIndices) + } + + if r.Analyzer != "" { + params["analyzer"] = r.Analyzer + } + + if r.AnalyzeWildcard != nil { + params["analyze_wildcard"] = strconv.FormatBool(*r.AnalyzeWildcard) + } + + if r.Conflicts != "" { + params["conflicts"] = r.Conflicts + } + + if r.DefaultOperator != "" { + params["default_operator"] = r.DefaultOperator + } + + if r.Df != "" { + params["df"] = r.Df + } + + if r.ExpandWildcards != "" { + params["expand_wildcards"] = r.ExpandWildcards + } + + if r.From != nil { + params["from"] = strconv.FormatInt(int64(*r.From), 10) + } + + if r.IgnoreUnavailable != nil { + params["ignore_unavailable"] = strconv.FormatBool(*r.IgnoreUnavailable) + } + + if r.Lenient != nil { + params["lenient"] = strconv.FormatBool(*r.Lenient) + } + + if r.MaxDocs != nil { + params["max_docs"] = strconv.FormatInt(int64(*r.MaxDocs), 10) + } + + if r.Pipeline != "" { + params["pipeline"] = r.Pipeline + } + + if r.Preference != "" { + params["preference"] = r.Preference + } + + if r.Query != "" { + params["q"] = r.Query + } + + if r.Refresh != nil { + params["refresh"] = strconv.FormatBool(*r.Refresh) + } + + if r.RequestCache != nil { + params["request_cache"] = strconv.FormatBool(*r.RequestCache) + } + + if r.RequestsPerSecond != nil { + params["requests_per_second"] = strconv.FormatInt(int64(*r.RequestsPerSecond), 10) + } + + if len(r.Routing) > 0 { + params["routing"] = strings.Join(r.Routing, ",") + } + + if r.Scroll != 0 { + params["scroll"] = formatDuration(r.Scroll) + } + + if r.ScrollSize != nil { + params["scroll_size"] = strconv.FormatInt(int64(*r.ScrollSize), 10) + } + + if r.SearchTimeout != 0 { + params["search_timeout"] = formatDuration(r.SearchTimeout) + } + + if r.SearchType != "" { + params["search_type"] = r.SearchType + } + + if r.Size != nil { + params["size"] = strconv.FormatInt(int64(*r.Size), 10) + } + + if r.Slices != nil { + params["slices"] = fmt.Sprintf("%v", r.Slices) + } + + if len(r.Sort) > 0 { + params["sort"] = strings.Join(r.Sort, ",") + } + + if len(r.Source) > 0 { + params["_source"] = strings.Join(r.Source, ",") + } + + if len(r.SourceExcludes) > 0 { + params["_source_excludes"] = strings.Join(r.SourceExcludes, ",") + } + + if len(r.SourceIncludes) > 0 { + params["_source_includes"] = strings.Join(r.SourceIncludes, ",") + } + + if len(r.Stats) > 0 { + params["stats"] = strings.Join(r.Stats, ",") + } + + if r.TerminateAfter != nil { + params["terminate_after"] = strconv.FormatInt(int64(*r.TerminateAfter), 10) + } + + if r.Timeout != 0 { + params["timeout"] = formatDuration(r.Timeout) + } + + if r.Version != nil { + params["version"] = strconv.FormatBool(*r.Version) + } + + if r.VersionType != nil { + params["version_type"] = strconv.FormatBool(*r.VersionType) + } + + if r.WaitForActiveShards != "" { + params["wait_for_active_shards"] = r.WaitForActiveShards + } + + if r.WaitForCompletion != nil { + params["wait_for_completion"] = strconv.FormatBool(*r.WaitForCompletion) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), r.Body) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if r.Body != nil { + req.Header[headerContentType] = headerContentTypeJSON + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f UpdateByQuery) WithContext(v context.Context) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.ctx = v + } +} + +// WithBody - The search definition using the Query DSL. +// +func (f UpdateByQuery) WithBody(v io.Reader) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Body = v + } +} + +// WithDocumentType - a list of document types to search; leave empty to perform the operation on all types. +// +func (f UpdateByQuery) WithDocumentType(v ...string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.DocumentType = v + } +} + +// WithAllowNoIndices - whether to ignore if a wildcard indices expression resolves into no concrete indices. (this includes `_all` string or when no indices have been specified). +// +func (f UpdateByQuery) WithAllowNoIndices(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.AllowNoIndices = &v + } +} + +// WithAnalyzer - the analyzer to use for the query string. +// +func (f UpdateByQuery) WithAnalyzer(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Analyzer = v + } +} + +// WithAnalyzeWildcard - specify whether wildcard and prefix queries should be analyzed (default: false). +// +func (f UpdateByQuery) WithAnalyzeWildcard(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.AnalyzeWildcard = &v + } +} + +// WithConflicts - what to do when the update by query hits version conflicts?. +// +func (f UpdateByQuery) WithConflicts(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Conflicts = v + } +} + +// WithDefaultOperator - the default operator for query string query (and or or). +// +func (f UpdateByQuery) WithDefaultOperator(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.DefaultOperator = v + } +} + +// WithDf - the field to use as default where no field prefix is given in the query string. +// +func (f UpdateByQuery) WithDf(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Df = v + } +} + +// WithExpandWildcards - whether to expand wildcard expression to concrete indices that are open, closed or both.. +// +func (f UpdateByQuery) WithExpandWildcards(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.ExpandWildcards = v + } +} + +// WithFrom - starting offset (default: 0). +// +func (f UpdateByQuery) WithFrom(v int) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.From = &v + } +} + +// WithIgnoreUnavailable - whether specified concrete indices should be ignored when unavailable (missing or closed). +// +func (f UpdateByQuery) WithIgnoreUnavailable(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.IgnoreUnavailable = &v + } +} + +// WithLenient - specify whether format-based query failures (such as providing text to a numeric field) should be ignored. +// +func (f UpdateByQuery) WithLenient(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Lenient = &v + } +} + +// WithMaxDocs - maximum number of documents to process (default: all documents). +// +func (f UpdateByQuery) WithMaxDocs(v int) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.MaxDocs = &v + } +} + +// WithPipeline - ingest pipeline to set on index requests made by this action. (default: none). +// +func (f UpdateByQuery) WithPipeline(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Pipeline = v + } +} + +// WithPreference - specify the node or shard the operation should be performed on (default: random). +// +func (f UpdateByQuery) WithPreference(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Preference = v + } +} + +// WithQuery - query in the lucene query string syntax. +// +func (f UpdateByQuery) WithQuery(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Query = v + } +} + +// WithRefresh - should the affected indexes be refreshed?. +// +func (f UpdateByQuery) WithRefresh(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Refresh = &v + } +} + +// WithRequestCache - specify if request cache should be used for this request or not, defaults to index level setting. +// +func (f UpdateByQuery) WithRequestCache(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.RequestCache = &v + } +} + +// WithRequestsPerSecond - the throttle to set on this request in sub-requests per second. -1 means no throttle.. +// +func (f UpdateByQuery) WithRequestsPerSecond(v int) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.RequestsPerSecond = &v + } +} + +// WithRouting - a list of specific routing values. +// +func (f UpdateByQuery) WithRouting(v ...string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Routing = v + } +} + +// WithScroll - specify how long a consistent view of the index should be maintained for scrolled search. +// +func (f UpdateByQuery) WithScroll(v time.Duration) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Scroll = v + } +} + +// WithScrollSize - size on the scroll request powering the update by query. +// +func (f UpdateByQuery) WithScrollSize(v int) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.ScrollSize = &v + } +} + +// WithSearchTimeout - explicit timeout for each search request. defaults to no timeout.. +// +func (f UpdateByQuery) WithSearchTimeout(v time.Duration) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.SearchTimeout = v + } +} + +// WithSearchType - search operation type. +// +func (f UpdateByQuery) WithSearchType(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.SearchType = v + } +} + +// WithSize - deprecated, please use `max_docs` instead. +// +func (f UpdateByQuery) WithSize(v int) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Size = &v + } +} + +// WithSlices - the number of slices this task should be divided into. defaults to 1, meaning the task isn't sliced into subtasks. can be set to `auto`.. +// +func (f UpdateByQuery) WithSlices(v interface{}) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Slices = v + } +} + +// WithSort - a list of : pairs. +// +func (f UpdateByQuery) WithSort(v ...string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Sort = v + } +} + +// WithSource - true or false to return the _source field or not, or a list of fields to return. +// +func (f UpdateByQuery) WithSource(v ...string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Source = v + } +} + +// WithSourceExcludes - a list of fields to exclude from the returned _source field. +// +func (f UpdateByQuery) WithSourceExcludes(v ...string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.SourceExcludes = v + } +} + +// WithSourceIncludes - a list of fields to extract and return from the _source field. +// +func (f UpdateByQuery) WithSourceIncludes(v ...string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.SourceIncludes = v + } +} + +// WithStats - specific 'tag' of the request for logging and statistical purposes. +// +func (f UpdateByQuery) WithStats(v ...string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Stats = v + } +} + +// WithTerminateAfter - the maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.. +// +func (f UpdateByQuery) WithTerminateAfter(v int) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.TerminateAfter = &v + } +} + +// WithTimeout - time each individual bulk request should wait for shards that are unavailable.. +// +func (f UpdateByQuery) WithTimeout(v time.Duration) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Timeout = v + } +} + +// WithVersion - specify whether to return document version as part of a hit. +// +func (f UpdateByQuery) WithVersion(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Version = &v + } +} + +// WithVersionType - should the document increment the version number (internal) on hit or not (reindex). +// +func (f UpdateByQuery) WithVersionType(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.VersionType = &v + } +} + +// WithWaitForActiveShards - sets the number of shard copies that must be active before proceeding with the update by query operation. defaults to 1, meaning the primary shard only. set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1). +// +func (f UpdateByQuery) WithWaitForActiveShards(v string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.WaitForActiveShards = v + } +} + +// WithWaitForCompletion - should the request should block until the update by query operation is complete.. +// +func (f UpdateByQuery) WithWaitForCompletion(v bool) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.WaitForCompletion = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f UpdateByQuery) WithPretty() func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f UpdateByQuery) WithHuman() func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f UpdateByQuery) WithErrorTrace() func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f UpdateByQuery) WithFilterPath(v ...string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f UpdateByQuery) WithHeader(h map[string]string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f UpdateByQuery) WithOpaqueID(s string) func(*UpdateByQueryRequest) { + return func(r *UpdateByQueryRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update_by_query_rethrottle.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update_by_query_rethrottle.go new file mode 100644 index 000000000..2bf5d506c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/api.update_by_query_rethrottle.go @@ -0,0 +1,224 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "net/http" + "strconv" + "strings" +) + +func newUpdateByQueryRethrottleFunc(t Transport) UpdateByQueryRethrottle { + return func(task_id string, requests_per_second *int, o ...func(*UpdateByQueryRethrottleRequest)) (*Response, error) { + var r = UpdateByQueryRethrottleRequest{TaskID: task_id, RequestsPerSecond: requests_per_second} + for _, f := range o { + f(&r) + } + return r.Do(r.ctx, t) + } +} + +// ----- API Definition ------------------------------------------------------- + +// UpdateByQueryRethrottle changes the number of requests per second for a particular Update By Query operation. +// +// +type UpdateByQueryRethrottle func(task_id string, requests_per_second *int, o ...func(*UpdateByQueryRethrottleRequest)) (*Response, error) + +// UpdateByQueryRethrottleRequest configures the Update By Query Rethrottle API request. +// +type UpdateByQueryRethrottleRequest struct { + TaskID string + + RequestsPerSecond *int + + Pretty bool + Human bool + ErrorTrace bool + FilterPath []string + + Header http.Header + + ctx context.Context +} + +// Do executes the request and returns response or error. +// +func (r UpdateByQueryRethrottleRequest) Do(ctx context.Context, transport Transport) (*Response, error) { + var ( + method string + path strings.Builder + params map[string]string + ) + + method = "POST" + + path.Grow(1 + len("_update_by_query") + 1 + len(r.TaskID) + 1 + len("_rethrottle")) + path.WriteString("/") + path.WriteString("_update_by_query") + path.WriteString("/") + path.WriteString(r.TaskID) + path.WriteString("/") + path.WriteString("_rethrottle") + + params = make(map[string]string) + + if r.RequestsPerSecond != nil { + params["requests_per_second"] = strconv.FormatInt(int64(*r.RequestsPerSecond), 10) + } + + if r.Pretty { + params["pretty"] = "true" + } + + if r.Human { + params["human"] = "true" + } + + if r.ErrorTrace { + params["error_trace"] = "true" + } + + if len(r.FilterPath) > 0 { + params["filter_path"] = strings.Join(r.FilterPath, ",") + } + + req, err := newRequest(method, path.String(), nil) + if err != nil { + return nil, err + } + + if len(params) > 0 { + q := req.URL.Query() + for k, v := range params { + q.Set(k, v) + } + req.URL.RawQuery = q.Encode() + } + + if len(r.Header) > 0 { + if len(req.Header) == 0 { + req.Header = r.Header + } else { + for k, vv := range r.Header { + for _, v := range vv { + req.Header.Add(k, v) + } + } + } + } + + if ctx != nil { + req = req.WithContext(ctx) + } + + res, err := transport.Perform(req) + if err != nil { + return nil, err + } + + response := Response{ + StatusCode: res.StatusCode, + Body: res.Body, + Header: res.Header, + } + + return &response, nil +} + +// WithContext sets the request context. +// +func (f UpdateByQueryRethrottle) WithContext(v context.Context) func(*UpdateByQueryRethrottleRequest) { + return func(r *UpdateByQueryRethrottleRequest) { + r.ctx = v + } +} + +// WithRequestsPerSecond - the throttle to set on this request in floating sub-requests per second. -1 means set no throttle.. +// +func (f UpdateByQueryRethrottle) WithRequestsPerSecond(v int) func(*UpdateByQueryRethrottleRequest) { + return func(r *UpdateByQueryRethrottleRequest) { + r.RequestsPerSecond = &v + } +} + +// WithPretty makes the response body pretty-printed. +// +func (f UpdateByQueryRethrottle) WithPretty() func(*UpdateByQueryRethrottleRequest) { + return func(r *UpdateByQueryRethrottleRequest) { + r.Pretty = true + } +} + +// WithHuman makes statistical values human-readable. +// +func (f UpdateByQueryRethrottle) WithHuman() func(*UpdateByQueryRethrottleRequest) { + return func(r *UpdateByQueryRethrottleRequest) { + r.Human = true + } +} + +// WithErrorTrace includes the stack trace for errors in the response body. +// +func (f UpdateByQueryRethrottle) WithErrorTrace() func(*UpdateByQueryRethrottleRequest) { + return func(r *UpdateByQueryRethrottleRequest) { + r.ErrorTrace = true + } +} + +// WithFilterPath filters the properties of the response body. +// +func (f UpdateByQueryRethrottle) WithFilterPath(v ...string) func(*UpdateByQueryRethrottleRequest) { + return func(r *UpdateByQueryRethrottleRequest) { + r.FilterPath = v + } +} + +// WithHeader adds the headers to the HTTP request. +// +func (f UpdateByQueryRethrottle) WithHeader(h map[string]string) func(*UpdateByQueryRethrottleRequest) { + return func(r *UpdateByQueryRethrottleRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + for k, v := range h { + r.Header.Add(k, v) + } + } +} + +// WithOpaqueID adds the X-Opaque-Id header to the HTTP request. +// +func (f UpdateByQueryRethrottle) WithOpaqueID(s string) func(*UpdateByQueryRethrottleRequest) { + return func(r *UpdateByQueryRethrottleRequest) { + if r.Header == nil { + r.Header = make(http.Header) + } + r.Header.Set("X-Opaque-Id", s) + } +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/doc.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/doc.go new file mode 100644 index 000000000..04e8b0a05 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/doc.go @@ -0,0 +1,106 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +/* +Package opensearchapi provides the Go API for OpenSearch. + +It is automatically included in the client provided by the +github.com/opensearch-project/opensearch-go package: + + client, _ := opensearch.NewDefaultClient() + res, _ := client.Info() + log.Println(res) + +For each OpenSearch API, such as "Index", the package exports two corresponding types: +a function and a struct. + +The function type allows you to call the OpenSearch API as a method on the client, +passing the parameters as arguments: + + res, err := client.Index( + "test", // Index name + strings.NewReader(`{"title" : "Test"}`), // Document body + client.Index.WithDocumentID("1"), // Document ID + client.Index.WithRefresh("true"), // Refresh + ) + if err != nil { + log.Fatalf("ERROR: %s", err) + } + defer res.Body.Close() + + log.Println(res) + + // => [201 Created] {"_index":"test","_type":"_doc","_id":"1" ... + +The struct type allows for a more hands-on approach, where you create a new struct, with the +request configuration as fields, and call the Do() method +with a context and the client as arguments: + + req := opensearchapi.IndexRequest{ + Index: "test", // Index name + Body: strings.NewReader(`{"title" : "Test"}`), // Document body + DocumentID: "1", // Document ID + Refresh: "true", // Refresh + } + + res, err := req.Do(context.Background(), client) + if err != nil { + log.Fatalf("Error getting response: %s", err) + } + defer res.Body.Close() + + log.Println(res) + + // => [200 OK] {"_index":"test","_type":"_doc","_id":"1","_version":2 ... + +The function type is a wrapper around the struct, and allows +to configure and perform the request in a more expressive way. +It has a minor overhead compared to using a struct directly; +refer to the opensearchapi_benchmark_test.go suite for concrete numbers. + +See the documentation for each API function or struct at +https://godoc.org/github.com/opensearch-project/opensearch-go, +or locally by: + + go doc github.com/opensearch-project/opensearch-go/opensearchapi Index + go doc github.com/opensearch-project/opensearch-go/opensearchapi IndexRequest + +Response + +The opensearchapi.Response type is a lightweight wrapper around http.Response. + +The res.Body field is an io.ReadCloser, leaving the JSON parsing to the +calling code, in the interest of performance and flexibility +(eg. to allow using a custom JSON parser). + +It is imperative to close the response body for a non-nil response. + +The Response type implements a couple of convenience methods for accessing +the status, checking an error status code or printing +the response body for debugging purposes. + +*/ +package opensearchapi diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.go new file mode 100644 index 000000000..35804c307 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.go @@ -0,0 +1,71 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "net/http" + "strconv" + "time" + + "github.com/opensearch-project/opensearch-go/internal/version" +) + +// Version returns the package version as a string. +// +const Version = version.Client + +// Transport defines the interface for an API client. +// +type Transport interface { + Perform(*http.Request) (*http.Response, error) +} + +// BoolPtr returns a pointer to v. +// +// It is used as a convenience function for converting a bool value +// into a pointer when passing the value to a function or struct field +// which expects a pointer. +// +func BoolPtr(v bool) *bool { return &v } + +// IntPtr returns a pointer to v. +// +// It is used as a convenience function for converting an int value +// into a pointer when passing the value to a function or struct field +// which expects a pointer. +// +func IntPtr(v int) *int { return &v } + +// formatDuration converts duration to a string in the format +// accepted by Elasticsearch. +// +func formatDuration(d time.Duration) string { + if d < time.Millisecond { + return strconv.FormatInt(int64(d), 10) + "nanos" + } + return strconv.FormatInt(int64(d)/int64(time.Millisecond), 10) + "ms" +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.request.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.request.go new file mode 100644 index 000000000..4c83fb3c9 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.request.go @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "context" + "io" + "net/http" +) + +const ( + headerContentType = "Content-Type" +) + +var ( + headerContentTypeJSON = []string{"application/json"} +) + +// Request defines the API request. +// +type Request interface { + Do(ctx context.Context, transport Transport) (*Response, error) +} + +// newRequest creates an HTTP request. +// +func newRequest(method, path string, body io.Reader) (*http.Request, error) { + return http.NewRequest(method, path, body) +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.response.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.response.go new file mode 100644 index 000000000..a0cb074d8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchapi/opensearchapi.response.go @@ -0,0 +1,114 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchapi + +import ( + "bytes" + "fmt" + "io" + "io/ioutil" + "net/http" + "strconv" + "strings" +) + +// Response represents the API response. +// +type Response struct { + StatusCode int + Header http.Header + Body io.ReadCloser +} + +// String returns the response as a string. +// +// The intended usage is for testing or debugging only. +// +func (r *Response) String() string { + var ( + out = new(bytes.Buffer) + b1 = bytes.NewBuffer([]byte{}) + b2 = bytes.NewBuffer([]byte{}) + tr io.Reader + ) + + if r != nil && r.Body != nil { + tr = io.TeeReader(r.Body, b1) + defer r.Body.Close() + + if _, err := io.Copy(b2, tr); err != nil { + out.WriteString(fmt.Sprintf("", err)) + return out.String() + } + defer func() { r.Body = ioutil.NopCloser(b1) }() + } + + if r != nil { + out.WriteString(fmt.Sprintf("[%d %s]", r.StatusCode, http.StatusText(r.StatusCode))) + if r.StatusCode > 0 { + out.WriteRune(' ') + } + } else { + out.WriteString("[0 ]") + } + + if r != nil && r.Body != nil { + out.ReadFrom(b2) // errcheck exclude (*bytes.Buffer).ReadFrom + } + + return out.String() +} + +// Status returns the response status as a string. +// +func (r *Response) Status() string { + var b strings.Builder + if r != nil { + b.WriteString(strconv.Itoa(r.StatusCode)) + b.WriteString(" ") + b.WriteString(http.StatusText(r.StatusCode)) + } + return b.String() +} + +// IsError returns true when the response status indicates failure. +// +func (r *Response) IsError() bool { + return r.StatusCode > 299 +} + +// Warnings returns the deprecation warnings from response headers. +// +func (r *Response) Warnings() []string { + return r.Header["Warning"] +} + +// HasWarnings returns true when the response headers contain deprecation warnings. +// +func (r *Response) HasWarnings() bool { + return len(r.Warnings()) > 0 +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/connection.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/connection.go new file mode 100644 index 000000000..d4214f6bc --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/connection.go @@ -0,0 +1,338 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchtransport + +import ( + "errors" + "fmt" + "math" + "net/url" + "sort" + "sync" + "time" +) + +var ( + defaultResurrectTimeoutInitial = 60 * time.Second + defaultResurrectTimeoutFactorCutoff = 5 +) + +// Selector defines the interface for selecting connections from the pool. +// +type Selector interface { + Select([]*Connection) (*Connection, error) +} + +// ConnectionPool defines the interface for the connection pool. +// +type ConnectionPool interface { + Next() (*Connection, error) // Next returns the next available connection. + OnSuccess(*Connection) error // OnSuccess reports that the connection was successful. + OnFailure(*Connection) error // OnFailure reports that the connection failed. + URLs() []*url.URL // URLs returns the list of URLs of available connections. +} + +// Connection represents a connection to a node. +// +type Connection struct { + sync.Mutex + + URL *url.URL + IsDead bool + DeadSince time.Time + Failures int + + ID string + Name string + Roles []string + Attributes map[string]interface{} +} + +type singleConnectionPool struct { + connection *Connection + + metrics *metrics +} + +type statusConnectionPool struct { + sync.Mutex + + live []*Connection // List of live connections + dead []*Connection // List of dead connections + selector Selector + + metrics *metrics +} + +type roundRobinSelector struct { + sync.Mutex + + curr int // Index of the current connection +} + +// NewConnectionPool creates and returns a default connection pool. +// +func NewConnectionPool(conns []*Connection, selector Selector) (ConnectionPool, error) { + if len(conns) == 1 { + return &singleConnectionPool{connection: conns[0]}, nil + } + if selector == nil { + selector = &roundRobinSelector{curr: -1} + } + return &statusConnectionPool{live: conns, selector: selector}, nil +} + +// Next returns the connection from pool. +// +func (cp *singleConnectionPool) Next() (*Connection, error) { + return cp.connection, nil +} + +// OnSuccess is a no-op for single connection pool. +func (cp *singleConnectionPool) OnSuccess(c *Connection) error { return nil } + +// OnFailure is a no-op for single connection pool. +func (cp *singleConnectionPool) OnFailure(c *Connection) error { return nil } + +// URLs returns the list of URLs of available connections. +func (cp *singleConnectionPool) URLs() []*url.URL { return []*url.URL{cp.connection.URL} } + +func (cp *singleConnectionPool) connections() []*Connection { return []*Connection{cp.connection} } + +// Next returns a connection from pool, or an error. +// +func (cp *statusConnectionPool) Next() (*Connection, error) { + cp.Lock() + defer cp.Unlock() + + // Return next live connection + if len(cp.live) > 0 { + return cp.selector.Select(cp.live) + } else if len(cp.dead) > 0 { + // No live connection is available, resurrect one of the dead ones. + c := cp.dead[len(cp.dead)-1] + cp.dead = cp.dead[:len(cp.dead)-1] + c.Lock() + defer c.Unlock() + cp.resurrect(c, false) + return c, nil + } + return nil, errors.New("no connection available") +} + +// OnSuccess marks the connection as successful. +// +func (cp *statusConnectionPool) OnSuccess(c *Connection) error { + c.Lock() + defer c.Unlock() + + // Short-circuit for live connection + if !c.IsDead { + return nil + } + + c.markAsHealthy() + + cp.Lock() + defer cp.Unlock() + return cp.resurrect(c, true) +} + +// OnFailure marks the connection as failed. +// +func (cp *statusConnectionPool) OnFailure(c *Connection) error { + cp.Lock() + defer cp.Unlock() + + c.Lock() + + if c.IsDead { + if debugLogger != nil { + debugLogger.Logf("Already removed %s\n", c.URL) + } + c.Unlock() + return nil + } + + if debugLogger != nil { + debugLogger.Logf("Removing %s...\n", c.URL) + } + c.markAsDead() + cp.scheduleResurrect(c) + c.Unlock() + + // Push item to dead list and sort slice by number of failures + cp.dead = append(cp.dead, c) + sort.Slice(cp.dead, func(i, j int) bool { + c1 := cp.dead[i] + c2 := cp.dead[j] + c1.Lock() + c2.Lock() + defer c1.Unlock() + defer c2.Unlock() + + res := c1.Failures > c2.Failures + return res + }) + + // Check if connection exists in the list, return error if not. + index := -1 + for i, conn := range cp.live { + if conn == c { + index = i + } + } + if index < 0 { + return errors.New("connection not in live list") + } + + // Remove item; https://github.com/golang/go/wiki/SliceTricks + copy(cp.live[index:], cp.live[index+1:]) + cp.live = cp.live[:len(cp.live)-1] + + return nil +} + +// URLs returns the list of URLs of available connections. +// +func (cp *statusConnectionPool) URLs() []*url.URL { + var urls []*url.URL + + cp.Lock() + defer cp.Unlock() + + for _, c := range cp.live { + urls = append(urls, c.URL) + } + + return urls +} + +func (cp *statusConnectionPool) connections() []*Connection { + var conns []*Connection + conns = append(conns, cp.live...) + conns = append(conns, cp.dead...) + return conns +} + +// resurrect adds the connection to the list of available connections. +// When removeDead is true, it also removes it from the dead list. +// The calling code is responsible for locking. +// +func (cp *statusConnectionPool) resurrect(c *Connection, removeDead bool) error { + if debugLogger != nil { + debugLogger.Logf("Resurrecting %s\n", c.URL) + } + + c.markAsLive() + cp.live = append(cp.live, c) + + if removeDead { + index := -1 + for i, conn := range cp.dead { + if conn == c { + index = i + } + } + if index >= 0 { + // Remove item; https://github.com/golang/go/wiki/SliceTricks + copy(cp.dead[index:], cp.dead[index+1:]) + cp.dead = cp.dead[:len(cp.dead)-1] + } + } + + return nil +} + +// scheduleResurrect schedules the connection to be resurrected. +// +func (cp *statusConnectionPool) scheduleResurrect(c *Connection) { + factor := math.Min(float64(c.Failures-1), float64(defaultResurrectTimeoutFactorCutoff)) + timeout := time.Duration(defaultResurrectTimeoutInitial.Seconds() * math.Exp2(factor) * float64(time.Second)) + if debugLogger != nil { + debugLogger.Logf("Resurrect %s (failures=%d, factor=%1.1f, timeout=%s) in %s\n", c.URL, c.Failures, factor, timeout, c.DeadSince.Add(timeout).Sub(time.Now().UTC()).Truncate(time.Second)) + } + + time.AfterFunc(timeout, func() { + cp.Lock() + defer cp.Unlock() + + c.Lock() + defer c.Unlock() + + if !c.IsDead { + if debugLogger != nil { + debugLogger.Logf("Already resurrected %s\n", c.URL) + } + return + } + + cp.resurrect(c, true) + }) +} + +// Select returns the connection in a round-robin fashion. +// +func (s *roundRobinSelector) Select(conns []*Connection) (*Connection, error) { + s.Lock() + defer s.Unlock() + + s.curr = (s.curr + 1) % len(conns) + return conns[s.curr], nil +} + +// markAsDead marks the connection as dead. +// +func (c *Connection) markAsDead() { + c.IsDead = true + if c.DeadSince.IsZero() { + c.DeadSince = time.Now().UTC() + } + c.Failures++ +} + +// markAsLive marks the connection as alive. +// +func (c *Connection) markAsLive() { + c.IsDead = false +} + +// markAsHealthy marks the connection as healthy. +// +func (c *Connection) markAsHealthy() { + c.IsDead = false + c.DeadSince = time.Time{} + c.Failures = 0 +} + +// String returns a readable connection representation. +// +func (c *Connection) String() string { + c.Lock() + defer c.Unlock() + return fmt.Sprintf("<%s> dead=%v failures=%d", c.URL, c.IsDead, c.Failures) +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/discovery.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/discovery.go new file mode 100644 index 000000000..1e3a3489c --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/discovery.go @@ -0,0 +1,221 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchtransport + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "net/http" + "net/url" + "sort" + "strings" + "sync" + "time" +) + +// Discoverable defines the interface for transports supporting node discovery. +// +type Discoverable interface { + DiscoverNodes() error +} + +// nodeInfo represents the information about node in a cluster. +// +type nodeInfo struct { + ID string + Name string + URL *url.URL + Roles []string `json:"roles"` + Attributes map[string]interface{} + HTTP struct { + PublishAddress string `json:"publish_address"` + } +} + +// DiscoverNodes reloads the client connections by fetching information from the cluster. +// +func (c *Client) DiscoverNodes() error { + var conns []*Connection + + nodes, err := c.getNodesInfo() + if err != nil { + if debugLogger != nil { + debugLogger.Logf("Error getting nodes info: %s\n", err) + } + return fmt.Errorf("discovery: get nodes: %s", err) + } + + for _, node := range nodes { + var ( + isMasterOnlyNode bool + ) + + roles := append(node.Roles[:0:0], node.Roles...) + sort.Strings(roles) + + if len(roles) == 1 && roles[0] == "master" { + isMasterOnlyNode = true + } + + if debugLogger != nil { + var skip string + if isMasterOnlyNode { + skip = "; [SKIP]" + } + debugLogger.Logf("Discovered node [%s]; %s; roles=%s%s\n", node.Name, node.URL, node.Roles, skip) + } + + // Skip master only nodes + // TODO: Move logic to Selector? + if isMasterOnlyNode { + continue + } + + conns = append(conns, &Connection{ + URL: node.URL, + ID: node.ID, + Name: node.Name, + Roles: node.Roles, + Attributes: node.Attributes, + }) + } + + c.Lock() + defer c.Unlock() + + if lockable, ok := c.pool.(sync.Locker); ok { + lockable.Lock() + defer lockable.Unlock() + } + + if c.poolFunc != nil { + c.pool = c.poolFunc(conns, c.selector) + } else { + // TODO: Replace only live connections, leave dead scheduled for resurrect? + c.pool, err = NewConnectionPool(conns, c.selector) + if err != nil { + return err + } + } + + return nil +} + +func (c *Client) getNodesInfo() ([]nodeInfo, error) { + var ( + out []nodeInfo + scheme = c.urls[0].Scheme + ) + + req, err := http.NewRequest("GET", "/_nodes/http", nil) + if err != nil { + return out, err + } + + c.Lock() + conn, err := c.pool.Next() + c.Unlock() + // TODO: If no connection is returned, fallback to original URLs + if err != nil { + return out, err + } + + c.setReqURL(conn.URL, req) + c.setReqAuth(conn.URL, req) + c.setReqUserAgent(req) + + res, err := c.transport.RoundTrip(req) + if err != nil { + return out, err + } + defer res.Body.Close() + + if res.StatusCode > 200 { + body, _ := ioutil.ReadAll(res.Body) + return out, fmt.Errorf("server error: %s: %s", res.Status, body) + } + + var env map[string]json.RawMessage + if err := json.NewDecoder(res.Body).Decode(&env); err != nil { + return out, err + } + + var nodes map[string]nodeInfo + if err := json.Unmarshal(env["nodes"], &nodes); err != nil { + return out, err + } + + for id, node := range nodes { + node.ID = id + u, err := c.getNodeURL(node, scheme) + if err != nil { + return out, err + } + node.URL = u + out = append(out, node) + } + + return out, nil +} + +func (c *Client) getNodeURL(node nodeInfo, scheme string) (*url.URL, error) { + var ( + host string + port string + + addrs = strings.Split(node.HTTP.PublishAddress, "/") + ports = strings.Split(node.HTTP.PublishAddress, ":") + ) + + if len(addrs) > 1 { + host = addrs[0] + } else { + host = strings.Split(addrs[0], ":")[0] + } + port = ports[len(ports)-1] + + u := &url.URL{ + Scheme: scheme, + Host: host + ":" + port, + } + + return u, nil +} + +func (c *Client) scheduleDiscoverNodes(d time.Duration) { + go c.DiscoverNodes() + + c.Lock() + defer c.Unlock() + if c.discoverNodesTimer != nil { + c.discoverNodesTimer.Stop() + } + c.discoverNodesTimer = time.AfterFunc(c.discoverNodesInterval, func() { + c.scheduleDiscoverNodes(c.discoverNodesInterval) + }) +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/doc.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/doc.go new file mode 100644 index 000000000..abefe8614 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/doc.go @@ -0,0 +1,59 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +/* +Package opensearchtransport provides the transport layer for the OpenSearch client. + +It is automatically included in the client provided by the github.com/opensearch-project/opensearch-go package +and is not intended for direct use: to configure the client, use the opensearch.Config struct. + +The default HTTP transport of the client is http.Transport; use the Transport option to customize it; + +The package will automatically retry requests on network-related errors, and on specific +response status codes (by default 502, 503, 504). Use the RetryOnStatus option to customize the list. +The transport will not retry a timeout network error, unless enabled by setting EnableRetryOnTimeout to true. + +Use the MaxRetries option to configure the number of retries, and set DisableRetry to true +to disable the retry behaviour altogether. + +By default, the retry will be performed without any delay; to configure a backoff interval, +implement the RetryBackoff option function; see an example in the package unit tests for information. + +When multiple addresses are passed in configuration, the package will use them in a round-robin fashion, +and will keep track of live and dead nodes. The status of dead nodes is checked periodically. + +To customize the node selection behaviour, provide a Selector implementation in the configuration. +To replace the connection pool entirely, provide a custom ConnectionPool implementation via +the ConnectionPoolFunc option. + +The package defines the Logger interface for logging information about request and response. +It comes with several bundled loggers for logging in text and JSON. + +Use the EnableDebugLogger option to enable the debugging logger for connection management. + +Use the EnableMetrics option to enable metric collection and export. +*/ +package opensearchtransport diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/logger.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/logger.go new file mode 100644 index 000000000..223b0165d --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/logger.go @@ -0,0 +1,461 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchtransport + +import ( + "bufio" + "bytes" + "encoding/json" + "fmt" + "io" + "io/ioutil" + "net/http" + "net/url" + "strconv" + "strings" + "time" +) + +var debugLogger DebuggingLogger + +// Logger defines an interface for logging request and response. +// +type Logger interface { + // LogRoundTrip should not modify the request or response, except for consuming and closing the body. + // Implementations have to check for nil values in request and response. + LogRoundTrip(*http.Request, *http.Response, error, time.Time, time.Duration) error + // RequestBodyEnabled makes the client pass a copy of request body to the logger. + RequestBodyEnabled() bool + // ResponseBodyEnabled makes the client pass a copy of response body to the logger. + ResponseBodyEnabled() bool +} + +// DebuggingLogger defines the interface for a debugging logger. +// +type DebuggingLogger interface { + Log(a ...interface{}) error + Logf(format string, a ...interface{}) error +} + +// TextLogger prints the log message in plain text. +// +type TextLogger struct { + Output io.Writer + EnableRequestBody bool + EnableResponseBody bool +} + +// ColorLogger prints the log message in a terminal-optimized plain text. +// +type ColorLogger struct { + Output io.Writer + EnableRequestBody bool + EnableResponseBody bool +} + +// CurlLogger prints the log message as a runnable curl command. +// +type CurlLogger struct { + Output io.Writer + EnableRequestBody bool + EnableResponseBody bool +} + +// JSONLogger prints the log message as JSON. +// +type JSONLogger struct { + Output io.Writer + EnableRequestBody bool + EnableResponseBody bool +} + +// debuggingLogger prints debug messages as plain text. +// +type debuggingLogger struct { + Output io.Writer +} + +// LogRoundTrip prints the information about request and response. +// +func (l *TextLogger) LogRoundTrip(req *http.Request, res *http.Response, err error, start time.Time, dur time.Duration) error { + fmt.Fprintf(l.Output, "%s %s %s [status:%d request:%s]\n", + start.Format(time.RFC3339), + req.Method, + req.URL.String(), + resStatusCode(res), + dur.Truncate(time.Millisecond), + ) + if l.RequestBodyEnabled() && req != nil && req.Body != nil && req.Body != http.NoBody { + var buf bytes.Buffer + if req.GetBody != nil { + b, _ := req.GetBody() + buf.ReadFrom(b) + } else { + buf.ReadFrom(req.Body) + } + logBodyAsText(l.Output, &buf, ">") + } + if l.ResponseBodyEnabled() && res != nil && res.Body != nil && res.Body != http.NoBody { + defer res.Body.Close() + var buf bytes.Buffer + buf.ReadFrom(res.Body) + logBodyAsText(l.Output, &buf, "<") + } + if err != nil { + fmt.Fprintf(l.Output, "! ERROR: %v\n", err) + } + return nil +} + +// RequestBodyEnabled returns true when the request body should be logged. +func (l *TextLogger) RequestBodyEnabled() bool { return l.EnableRequestBody } + +// ResponseBodyEnabled returns true when the response body should be logged. +func (l *TextLogger) ResponseBodyEnabled() bool { return l.EnableResponseBody } + +// LogRoundTrip prints the information about request and response. +// +func (l *ColorLogger) LogRoundTrip(req *http.Request, res *http.Response, err error, start time.Time, dur time.Duration) error { + query, _ := url.QueryUnescape(req.URL.RawQuery) + if query != "" { + query = "?" + query + } + + var ( + status string + color string + ) + + status = res.Status + switch { + case res.StatusCode > 0 && res.StatusCode < 300: + color = "\x1b[32m" + case res.StatusCode > 299 && res.StatusCode < 500: + color = "\x1b[33m" + case res.StatusCode > 499: + color = "\x1b[31m" + default: + status = "ERROR" + color = "\x1b[31;4m" + } + + fmt.Fprintf(l.Output, "%6s \x1b[1;4m%s://%s%s\x1b[0m%s %s%s\x1b[0m \x1b[2m%s\x1b[0m\n", + req.Method, + req.URL.Scheme, + req.URL.Host, + req.URL.Path, + query, + color, + status, + dur.Truncate(time.Millisecond), + ) + + if l.RequestBodyEnabled() && req != nil && req.Body != nil && req.Body != http.NoBody { + var buf bytes.Buffer + if req.GetBody != nil { + b, _ := req.GetBody() + buf.ReadFrom(b) + } else { + buf.ReadFrom(req.Body) + } + fmt.Fprint(l.Output, "\x1b[2m") + logBodyAsText(l.Output, &buf, " »") + fmt.Fprint(l.Output, "\x1b[0m") + } + + if l.ResponseBodyEnabled() && res != nil && res.Body != nil && res.Body != http.NoBody { + defer res.Body.Close() + var buf bytes.Buffer + buf.ReadFrom(res.Body) + fmt.Fprint(l.Output, "\x1b[2m") + logBodyAsText(l.Output, &buf, " «") + fmt.Fprint(l.Output, "\x1b[0m") + } + + if err != nil { + fmt.Fprintf(l.Output, "\x1b[31;1m» ERROR \x1b[31m%v\x1b[0m\n", err) + } + + if l.RequestBodyEnabled() || l.ResponseBodyEnabled() { + fmt.Fprintf(l.Output, "\x1b[2m%s\x1b[0m\n", strings.Repeat("─", 80)) + } + return nil +} + +// RequestBodyEnabled returns true when the request body should be logged. +func (l *ColorLogger) RequestBodyEnabled() bool { return l.EnableRequestBody } + +// ResponseBodyEnabled returns true when the response body should be logged. +func (l *ColorLogger) ResponseBodyEnabled() bool { return l.EnableResponseBody } + +// LogRoundTrip prints the information about request and response. +// +func (l *CurlLogger) LogRoundTrip(req *http.Request, res *http.Response, err error, start time.Time, dur time.Duration) error { + var b bytes.Buffer + + var query string + qvalues := url.Values{} + for k, v := range req.URL.Query() { + if k == "pretty" { + continue + } + for _, qv := range v { + qvalues.Add(k, qv) + } + } + if len(qvalues) > 0 { + query = qvalues.Encode() + } + + b.WriteString(`curl`) + if req.Method == "HEAD" { + b.WriteString(" --head") + } else { + fmt.Fprintf(&b, " -X %s", req.Method) + } + + if len(req.Header) > 0 { + for k, vv := range req.Header { + if k == "Authorization" || k == "User-Agent" { + continue + } + v := strings.Join(vv, ",") + b.WriteString(fmt.Sprintf(" -H '%s: %s'", k, v)) + } + } + + b.WriteString(" 'http://localhost:9200") + b.WriteString(req.URL.Path) + b.WriteString("?pretty") + if query != "" { + fmt.Fprintf(&b, "&%s", query) + } + b.WriteString("'") + + if req != nil && req.Body != nil && req.Body != http.NoBody { + var buf bytes.Buffer + if req.GetBody != nil { + b, _ := req.GetBody() + buf.ReadFrom(b) + } else { + buf.ReadFrom(req.Body) + } + + b.Grow(buf.Len()) + b.WriteString(" -d \\\n'") + json.Indent(&b, buf.Bytes(), "", " ") + b.WriteString("'") + } + + b.WriteRune('\n') + + var status string + status = res.Status + + fmt.Fprintf(&b, "# => %s [%s] %s\n", start.UTC().Format(time.RFC3339), status, dur.Truncate(time.Millisecond)) + if l.ResponseBodyEnabled() && res != nil && res.Body != nil && res.Body != http.NoBody { + var buf bytes.Buffer + buf.ReadFrom(res.Body) + + b.Grow(buf.Len()) + b.WriteString("# ") + json.Indent(&b, buf.Bytes(), "# ", " ") + } + + b.WriteString("\n") + if l.ResponseBodyEnabled() && res != nil && res.Body != nil && res.Body != http.NoBody { + b.WriteString("\n") + } + + b.WriteTo(l.Output) + + return nil +} + +// RequestBodyEnabled returns true when the request body should be logged. +func (l *CurlLogger) RequestBodyEnabled() bool { return l.EnableRequestBody } + +// ResponseBodyEnabled returns true when the response body should be logged. +func (l *CurlLogger) ResponseBodyEnabled() bool { return l.EnableResponseBody } + +// LogRoundTrip prints the information about request and response. +// +func (l *JSONLogger) LogRoundTrip(req *http.Request, res *http.Response, err error, start time.Time, dur time.Duration) error { + // TODO: Research performance optimization of using sync.Pool + + bsize := 200 + var b = bytes.NewBuffer(make([]byte, 0, bsize)) + var v = make([]byte, 0, bsize) + + appendTime := func(t time.Time) { + v = v[:0] + v = t.AppendFormat(v, time.RFC3339) + b.Write(v) + } + + appendQuote := func(s string) { + v = v[:0] + v = strconv.AppendQuote(v, s) + b.Write(v) + } + + appendInt := func(i int64) { + v = v[:0] + v = strconv.AppendInt(v, i, 10) + b.Write(v) + } + + port := req.URL.Port() + + b.WriteRune('{') + // -- Timestamp + b.WriteString(`"@timestamp":"`) + appendTime(start.UTC()) + b.WriteRune('"') + // -- Event + b.WriteString(`,"event":{`) + b.WriteString(`"duration":`) + appendInt(dur.Nanoseconds()) + b.WriteRune('}') + // -- URL + b.WriteString(`,"url":{`) + b.WriteString(`"scheme":`) + appendQuote(req.URL.Scheme) + b.WriteString(`,"domain":`) + appendQuote(req.URL.Hostname()) + if port != "" { + b.WriteString(`,"port":`) + b.WriteString(port) + } + b.WriteString(`,"path":`) + appendQuote(req.URL.Path) + b.WriteString(`,"query":`) + appendQuote(req.URL.RawQuery) + b.WriteRune('}') // Close "url" + // -- HTTP + b.WriteString(`,"http":`) + // ---- Request + b.WriteString(`{"request":{`) + b.WriteString(`"method":`) + appendQuote(req.Method) + if l.RequestBodyEnabled() && req != nil && req.Body != nil && req.Body != http.NoBody { + var buf bytes.Buffer + if req.GetBody != nil { + b, _ := req.GetBody() + buf.ReadFrom(b) + } else { + buf.ReadFrom(req.Body) + } + + b.Grow(buf.Len() + 8) + b.WriteString(`,"body":`) + appendQuote(buf.String()) + } + b.WriteRune('}') // Close "http.request" + // ---- Response + b.WriteString(`,"response":{`) + b.WriteString(`"status_code":`) + appendInt(int64(resStatusCode(res))) + if l.ResponseBodyEnabled() && res != nil && res.Body != nil && res.Body != http.NoBody { + defer res.Body.Close() + var buf bytes.Buffer + buf.ReadFrom(res.Body) + + b.Grow(buf.Len() + 8) + b.WriteString(`,"body":`) + appendQuote(buf.String()) + } + b.WriteRune('}') // Close "http.response" + b.WriteRune('}') // Close "http" + // -- Error + if err != nil { + b.WriteString(`,"error":{"message":`) + appendQuote(err.Error()) + b.WriteRune('}') // Close "error" + } + b.WriteRune('}') + b.WriteRune('\n') + b.WriteTo(l.Output) + + return nil +} + +// RequestBodyEnabled returns true when the request body should be logged. +func (l *JSONLogger) RequestBodyEnabled() bool { return l.EnableRequestBody } + +// ResponseBodyEnabled returns true when the response body should be logged. +func (l *JSONLogger) ResponseBodyEnabled() bool { return l.EnableResponseBody } + +// Log prints the arguments to output in default format. +// +func (l *debuggingLogger) Log(a ...interface{}) error { + _, err := fmt.Fprint(l.Output, a...) + return err +} + +// Logf prints formats the arguments and prints them to output. +// +func (l *debuggingLogger) Logf(format string, a ...interface{}) error { + _, err := fmt.Fprintf(l.Output, format, a...) + return err +} + +func logBodyAsText(dst io.Writer, body io.Reader, prefix string) { + scanner := bufio.NewScanner(body) + for scanner.Scan() { + s := scanner.Text() + if s != "" { + fmt.Fprintf(dst, "%s %s\n", prefix, s) + } + } +} + +func duplicateBody(body io.ReadCloser) (io.ReadCloser, io.ReadCloser, error) { + var ( + b1 bytes.Buffer + b2 bytes.Buffer + tr = io.TeeReader(body, &b2) + ) + _, err := b1.ReadFrom(tr) + if err != nil { + return ioutil.NopCloser(io.MultiReader(&b1, errorReader{err: err})), ioutil.NopCloser(io.MultiReader(&b2, errorReader{err: err})), err + } + defer func() { body.Close() }() + + return ioutil.NopCloser(&b1), ioutil.NopCloser(&b2), nil +} + +func resStatusCode(res *http.Response) int { + if res == nil { + return -1 + } + return res.StatusCode +} + +type errorReader struct{ err error } + +func (r errorReader) Read(p []byte) (int, error) { return 0, r.err } diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/metrics.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/metrics.go new file mode 100644 index 000000000..caef13e18 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/metrics.go @@ -0,0 +1,203 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchtransport + +import ( + "errors" + "fmt" + "strconv" + "strings" + "sync" + "time" +) + +// Measurable defines the interface for transports supporting metrics. +// +type Measurable interface { + Metrics() (Metrics, error) +} + +// connectionable defines the interface for transports returning a list of connections. +// +type connectionable interface { + connections() []*Connection +} + +// Metrics represents the transport metrics. +// +type Metrics struct { + Requests int `json:"requests"` + Failures int `json:"failures"` + Responses map[int]int `json:"responses"` + + Connections []fmt.Stringer `json:"connections"` +} + +// ConnectionMetric represents metric information for a connection. +// +type ConnectionMetric struct { + URL string `json:"url"` + Failures int `json:"failures,omitempty"` + IsDead bool `json:"dead,omitempty"` + DeadSince *time.Time `json:"dead_since,omitempty"` + + Meta struct { + ID string `json:"id"` + Name string `json:"name"` + Roles []string `json:"roles"` + } `json:"meta"` +} + +// metrics represents the inner state of metrics. +// +type metrics struct { + sync.RWMutex + + requests int + failures int + responses map[int]int + + connections []*Connection +} + +// Metrics returns the transport metrics. +// +func (c *Client) Metrics() (Metrics, error) { + if c.metrics == nil { + return Metrics{}, errors.New("transport metrics not enabled") + } + c.metrics.RLock() + defer c.metrics.RUnlock() + + if lockable, ok := c.pool.(sync.Locker); ok { + lockable.Lock() + defer lockable.Unlock() + } + + m := Metrics{ + Requests: c.metrics.requests, + Failures: c.metrics.failures, + Responses: c.metrics.responses, + } + + if pool, ok := c.pool.(connectionable); ok { + for _, c := range pool.connections() { + c.Lock() + + cm := ConnectionMetric{ + URL: c.URL.String(), + IsDead: c.IsDead, + Failures: c.Failures, + } + + if !c.DeadSince.IsZero() { + cm.DeadSince = &c.DeadSince + } + + if c.ID != "" { + cm.Meta.ID = c.ID + } + + if c.Name != "" { + cm.Meta.Name = c.Name + } + + if len(c.Roles) > 0 { + cm.Meta.Roles = c.Roles + } + + m.Connections = append(m.Connections, cm) + c.Unlock() + } + } + + return m, nil +} + +// String returns the metrics as a string. +// +func (m Metrics) String() string { + var ( + i int + b strings.Builder + ) + b.WriteString("{") + + b.WriteString("Requests:") + b.WriteString(strconv.Itoa(m.Requests)) + + b.WriteString(" Failures:") + b.WriteString(strconv.Itoa(m.Failures)) + + if len(m.Responses) > 0 { + b.WriteString(" Responses: ") + b.WriteString("[") + + for code, num := range m.Responses { + b.WriteString(strconv.Itoa(code)) + b.WriteString(":") + b.WriteString(strconv.Itoa(num)) + if i+1 < len(m.Responses) { + b.WriteString(", ") + } + i++ + } + b.WriteString("]") + } + + b.WriteString(" Connections: [") + for i, c := range m.Connections { + b.WriteString(c.String()) + if i+1 < len(m.Connections) { + b.WriteString(", ") + } + i++ + } + b.WriteString("]") + + b.WriteString("}") + return b.String() +} + +// String returns the connection information as a string. +// +func (cm ConnectionMetric) String() string { + var b strings.Builder + b.WriteString("{") + b.WriteString(cm.URL) + if cm.IsDead { + fmt.Fprintf(&b, " dead=%v", cm.IsDead) + } + if cm.Failures > 0 { + fmt.Fprintf(&b, " failures=%d", cm.Failures) + } + if cm.DeadSince != nil { + fmt.Fprintf(&b, " dead_since=%s", cm.DeadSince.Local().Format(time.Stamp)) + } + b.WriteString("}") + return b.String() +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/opensearchtransport.go b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/opensearchtransport.go new file mode 100644 index 000000000..725fddc95 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/opensearchtransport/opensearchtransport.go @@ -0,0 +1,521 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package opensearchtransport + +import ( + "bytes" + "compress/gzip" + "crypto/x509" + "errors" + "fmt" + "io" + "io/ioutil" + "net" + "net/http" + "net/url" + "os" + "regexp" + "runtime" + "strconv" + "strings" + "sync" + "time" + + "github.com/opensearch-project/opensearch-go/signer" + + "github.com/opensearch-project/opensearch-go/internal/version" +) + +const ( + // Version returns the package version as a string. + Version = version.Client + + // esCompatHeader defines the env var for Compatibility header. + esCompatHeader = "ELASTIC_CLIENT_APIVERSIONING" +) + +var ( + userAgent string + compatibilityHeader bool + reGoVersion = regexp.MustCompile(`go(\d+\.\d+\..+)`) + + defaultMaxRetries = 3 + defaultRetryOnStatus = [...]int{502, 503, 504} +) + +func init() { + userAgent = initUserAgent() + + compatHeaderEnv := os.Getenv(esCompatHeader) + compatibilityHeader, _ = strconv.ParseBool(compatHeaderEnv) +} + +// Interface defines the interface for HTTP client. +// +type Interface interface { + Perform(*http.Request) (*http.Response, error) +} + +// Config represents the configuration of HTTP client. +// +type Config struct { + URLs []*url.URL + Username string + Password string + + Header http.Header + CACert []byte + + Signer signer.Signer + + RetryOnStatus []int + DisableRetry bool + EnableRetryOnTimeout bool + MaxRetries int + RetryBackoff func(attempt int) time.Duration + + CompressRequestBody bool + + EnableMetrics bool + EnableDebugLogger bool + + DiscoverNodesInterval time.Duration + + Transport http.RoundTripper + Logger Logger + Selector Selector + + ConnectionPoolFunc func([]*Connection, Selector) ConnectionPool +} + +// Client represents the HTTP client. +// +type Client struct { + sync.Mutex + + urls []*url.URL + username string + password string + header http.Header + + signer signer.Signer + + retryOnStatus []int + disableRetry bool + enableRetryOnTimeout bool + maxRetries int + retryBackoff func(attempt int) time.Duration + discoverNodesInterval time.Duration + discoverNodesTimer *time.Timer + + compressRequestBody bool + + metrics *metrics + + transport http.RoundTripper + logger Logger + selector Selector + pool ConnectionPool + poolFunc func([]*Connection, Selector) ConnectionPool +} + +// New creates new transport client. +// +// http.DefaultTransport will be used if no transport is passed in the configuration. +// +func New(cfg Config) (*Client, error) { + if cfg.Transport == nil { + cfg.Transport = http.DefaultTransport + } + + if cfg.CACert != nil { + httpTransport, ok := cfg.Transport.(*http.Transport) + if !ok { + return nil, fmt.Errorf("unable to set CA certificate for transport of type %T", cfg.Transport) + } + + httpTransport = httpTransport.Clone() + httpTransport.TLSClientConfig.RootCAs = x509.NewCertPool() + + if ok := httpTransport.TLSClientConfig.RootCAs.AppendCertsFromPEM(cfg.CACert); !ok { + return nil, errors.New("unable to add CA certificate") + } + + cfg.Transport = httpTransport + } + + if len(cfg.RetryOnStatus) == 0 { + cfg.RetryOnStatus = defaultRetryOnStatus[:] + } + + if cfg.MaxRetries == 0 { + cfg.MaxRetries = defaultMaxRetries + } + + var conns []*Connection + for _, u := range cfg.URLs { + conns = append(conns, &Connection{URL: u}) + } + + client := Client{ + urls: cfg.URLs, + username: cfg.Username, + password: cfg.Password, + header: cfg.Header, + + signer: cfg.Signer, + + retryOnStatus: cfg.RetryOnStatus, + disableRetry: cfg.DisableRetry, + enableRetryOnTimeout: cfg.EnableRetryOnTimeout, + maxRetries: cfg.MaxRetries, + retryBackoff: cfg.RetryBackoff, + discoverNodesInterval: cfg.DiscoverNodesInterval, + + compressRequestBody: cfg.CompressRequestBody, + + transport: cfg.Transport, + logger: cfg.Logger, + selector: cfg.Selector, + poolFunc: cfg.ConnectionPoolFunc, + } + + if client.poolFunc != nil { + client.pool = client.poolFunc(conns, client.selector) + } else { + client.pool, _ = NewConnectionPool(conns, client.selector) + } + + if cfg.EnableDebugLogger { + debugLogger = &debuggingLogger{Output: os.Stdout} + } + + if cfg.EnableMetrics { + client.metrics = &metrics{responses: make(map[int]int)} + // TODO(karmi): Type assertion to interface + if pool, ok := client.pool.(*singleConnectionPool); ok { + pool.metrics = client.metrics + } + if pool, ok := client.pool.(*statusConnectionPool); ok { + pool.metrics = client.metrics + } + } + + if client.discoverNodesInterval > 0 { + time.AfterFunc(client.discoverNodesInterval, func() { + client.scheduleDiscoverNodes(client.discoverNodesInterval) + }) + } + + return &client, nil +} + +// Perform executes the request and returns a response or error. +// +func (c *Client) Perform(req *http.Request) (*http.Response, error) { + var ( + res *http.Response + err error + ) + + // Compatibility Header + if compatibilityHeader { + if req.Body != nil { + req.Header.Set("Content-Type", "application/vnd.elasticsearch+json;compatible-with=7") + } + req.Header.Set("Accept", "application/vnd.elasticsearch+json;compatible-with=7") + } + + // Record metrics, when enabled + if c.metrics != nil { + c.metrics.Lock() + c.metrics.requests++ + c.metrics.Unlock() + } + + // Update request + c.setReqUserAgent(req) + c.setReqGlobalHeader(req) + + if req.Body != nil && req.Body != http.NoBody { + if c.compressRequestBody { + var buf bytes.Buffer + zw := gzip.NewWriter(&buf) + if _, err := io.Copy(zw, req.Body); err != nil { + return nil, fmt.Errorf("failed to compress request body: %s", err) + } + if err := zw.Close(); err != nil { + return nil, fmt.Errorf("failed to compress request body (during close): %s", err) + } + + req.GetBody = func() (io.ReadCloser, error) { + r := buf + return ioutil.NopCloser(&r), nil + } + req.Body, _ = req.GetBody() + + req.Header.Set("Content-Encoding", "gzip") + req.ContentLength = int64(buf.Len()) + + } else if req.GetBody == nil { + if !c.disableRetry || (c.logger != nil && c.logger.RequestBodyEnabled()) { + var buf bytes.Buffer + buf.ReadFrom(req.Body) + + req.GetBody = func() (io.ReadCloser, error) { + r := buf + return ioutil.NopCloser(&r), nil + } + req.Body, _ = req.GetBody() + } + } + } + + for i := 0; i <= c.maxRetries; i++ { + var ( + conn *Connection + shouldRetry bool + shouldCloseBody bool + ) + + // Get connection from the pool + c.Lock() + conn, err = c.pool.Next() + c.Unlock() + if err != nil { + if c.logger != nil { + c.logRoundTrip(req, nil, err, time.Time{}, time.Duration(0)) + } + return nil, fmt.Errorf("cannot get connection: %s", err) + } + + // Update request + c.setReqURL(conn.URL, req) + c.setReqAuth(conn.URL, req) + + if err = c.signRequest(req); err != nil { + return nil, fmt.Errorf("failed to sign request: %s", err) + } + + if !c.disableRetry && i > 0 && req.Body != nil && req.Body != http.NoBody { + body, err := req.GetBody() + if err != nil { + return nil, fmt.Errorf("cannot get request body: %s", err) + } + req.Body = body + } + + // Set up time measures and execute the request + start := time.Now().UTC() + res, err = c.transport.RoundTrip(req) + dur := time.Since(start) + + // Log request and response + if c.logger != nil { + if c.logger.RequestBodyEnabled() && req.Body != nil && req.Body != http.NoBody { + req.Body, _ = req.GetBody() + } + c.logRoundTrip(req, res, err, start, dur) + } + + if err != nil { + // Record metrics, when enabled + if c.metrics != nil { + c.metrics.Lock() + c.metrics.failures++ + c.metrics.Unlock() + } + + // Report the connection as unsuccessful + c.Lock() + c.pool.OnFailure(conn) + c.Unlock() + + // Retry on EOF errors + if err == io.EOF { + shouldRetry = true + } + + // Retry on network errors, but not on timeout errors, unless configured + if err, ok := err.(net.Error); ok { + if (!err.Timeout() || c.enableRetryOnTimeout) && !c.disableRetry { + shouldRetry = true + } + } + } else { + // Report the connection as succesfull + c.Lock() + c.pool.OnSuccess(conn) + c.Unlock() + } + + if res != nil && c.metrics != nil { + c.metrics.Lock() + c.metrics.responses[res.StatusCode]++ + c.metrics.Unlock() + } + + // Retry on configured response statuses + if res != nil && !c.disableRetry { + for _, code := range c.retryOnStatus { + if res.StatusCode == code { + shouldRetry = true + shouldCloseBody = true + } + } + } + + // Break if retry should not be performed + if !shouldRetry { + break + } + + // Drain and close body when retrying after response + if shouldCloseBody && i < c.maxRetries { + if res.Body != nil { + io.Copy(ioutil.Discard, res.Body) + res.Body.Close() + } + } + + // Delay the retry if a backoff function is configured + if c.retryBackoff != nil { + time.Sleep(c.retryBackoff(i + 1)) + } + } + + // TODO(karmi): Wrap error + return res, err +} + +// URLs returns a list of transport URLs. +// +// +func (c *Client) URLs() []*url.URL { + return c.pool.URLs() +} + +func (c *Client) setReqURL(u *url.URL, req *http.Request) *http.Request { + req.URL.Scheme = u.Scheme + req.URL.Host = u.Host + + if u.Path != "" { + var b strings.Builder + b.Grow(len(u.Path) + len(req.URL.Path)) + b.WriteString(u.Path) + b.WriteString(req.URL.Path) + req.URL.Path = b.String() + } + + return req +} + +func (c *Client) setReqAuth(u *url.URL, req *http.Request) *http.Request { + if _, ok := req.Header["Authorization"]; !ok { + if u.User != nil { + password, _ := u.User.Password() + req.SetBasicAuth(u.User.Username(), password) + return req + } + + if c.username != "" && c.password != "" { + req.SetBasicAuth(c.username, c.password) + return req + } + } + + return req +} + +func (c *Client) signRequest(req *http.Request) error { + if c.signer != nil { + return c.signer.SignRequest(req) + } + return nil +} + +func (c *Client) setReqUserAgent(req *http.Request) *http.Request { + req.Header.Set("User-Agent", userAgent) + return req +} + +func (c *Client) setReqGlobalHeader(req *http.Request) *http.Request { + if len(c.header) > 0 { + for k, v := range c.header { + if req.Header.Get(k) != k { + for _, vv := range v { + req.Header.Add(k, vv) + } + } + } + } + return req +} + +func (c *Client) logRoundTrip( + req *http.Request, + res *http.Response, + err error, + start time.Time, + dur time.Duration, +) { + var dupRes http.Response + if res != nil { + dupRes = *res + } + if c.logger.ResponseBodyEnabled() { + if res != nil && res.Body != nil && res.Body != http.NoBody { + b1, b2, _ := duplicateBody(res.Body) + dupRes.Body = b1 + res.Body = b2 + } + } + c.logger.LogRoundTrip(req, &dupRes, err, start, dur) // errcheck exclude +} + +func initUserAgent() string { + var b strings.Builder + + b.WriteString("opensearch-go") + b.WriteRune('/') + b.WriteString(Version) + b.WriteRune(' ') + b.WriteRune('(') + b.WriteString(runtime.GOOS) + b.WriteRune(' ') + b.WriteString(runtime.GOARCH) + b.WriteString("; ") + b.WriteString("Go ") + if v := reGoVersion.ReplaceAllString(runtime.Version(), "$1"); v != "" { + b.WriteString(v) + } else { + b.WriteString(runtime.Version()) + } + b.WriteRune(')') + + return b.String() +} diff --git a/vendor/github.com/opensearch-project/opensearch-go/signer/signer.go b/vendor/github.com/opensearch-project/opensearch-go/signer/signer.go new file mode 100644 index 000000000..f0a88e7c8 --- /dev/null +++ b/vendor/github.com/opensearch-project/opensearch-go/signer/signer.go @@ -0,0 +1,17 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// The OpenSearch Contributors require contributions made to +// this file be licensed under the Apache-2.0 license or a +// compatible open source license. +// +// Modifications Copyright OpenSearch Contributors. See +// GitHub history for details. + +package signer + +import "net/http" + +//Signer an interface that will sign http.Request +type Signer interface { + SignRequest(request *http.Request) error +} diff --git a/vendor/modules.txt b/vendor/modules.txt index b7e12d8fc..2c01be630 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -365,7 +365,7 @@ github.com/go-openapi/runtime/middleware/denco github.com/go-openapi/runtime/middleware/header github.com/go-openapi/runtime/middleware/untyped github.com/go-openapi/runtime/security -# github.com/go-openapi/spec v0.19.7 => github.com/go-openapi/spec v0.19.7 +# github.com/go-openapi/spec v0.19.8 => github.com/go-openapi/spec v0.19.7 ## explicit; go 1.13 github.com/go-openapi/spec # github.com/go-openapi/strfmt v0.19.5 => github.com/go-openapi/strfmt v0.19.5 @@ -754,6 +754,13 @@ github.com/opencontainers/image-spec/specs-go/v1 # github.com/opencontainers/runc v0.1.1 => github.com/opencontainers/runc v0.1.1 ## explicit github.com/opencontainers/runc/libcontainer/system +# github.com/opensearch-project/opensearch-go v1.1.0 +## explicit; go 1.11 +github.com/opensearch-project/opensearch-go +github.com/opensearch-project/opensearch-go/internal/version +github.com/opensearch-project/opensearch-go/opensearchapi +github.com/opensearch-project/opensearch-go/opensearchtransport +github.com/opensearch-project/opensearch-go/signer # github.com/opensearch-project/opensearch-go/v2 v2.0.0 => github.com/opensearch-project/opensearch-go/v2 v2.0.0 ## explicit; go 1.11 github.com/opensearch-project/opensearch-go/v2 @@ -873,7 +880,7 @@ github.com/prometheus/client_golang/prometheus/testutil/promlint # github.com/prometheus/client_model v0.2.0 => github.com/prometheus/client_model v0.2.0 ## explicit; go 1.9 github.com/prometheus/client_model/go -# github.com/prometheus/common v0.26.0 => github.com/prometheus/common v0.10.0 +# github.com/prometheus/common v0.37.0 => github.com/prometheus/common v0.10.0 ## explicit; go 1.11 github.com/prometheus/common/expfmt github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg @@ -2132,6 +2139,7 @@ k8s.io/utils/strings k8s.io/utils/trace # kubesphere.io/api v0.0.0 => ./staging/src/kubesphere.io/api ## explicit; go 1.18 +kubesphere.io/api/alerting/v2beta1 kubesphere.io/api/application/crdinstall kubesphere.io/api/application/v1alpha1 kubesphere.io/api/auditing/v1alpha1